drivers/staging/otus/ioctl.c

   1 /*
   2  * Copyright (c) 2007-2008 Atheros Communications Inc.
   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
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16 /*                                                                      */
  17 /*  Module Name : ioctl.c                                               */
  18 /*                                                                      */
  19 /*  Abstract                                                            */
  20 /*      This module contains Linux wireless extension related functons. */
  21 /*                                                                      */
  22 /*  NOTES                                                               */
  23 /*     Platform dependent.                                              */
  24 /*                                                                      */
  25 /************************************************************************/
  26 #include <linux/module.h>
  27 #include <linux/if_arp.h>
  28 #include <linux/uaccess.h>
  29
  30 #include "usbdrv.h"
  31
  32 #define ZD_IOCTL_WPA                        (SIOCDEVPRIVATE + 1)
  33 #define ZD_IOCTL_PARAM                      (SIOCDEVPRIVATE + 2)
  34 #define ZD_IOCTL_GETWPAIE                   (SIOCDEVPRIVATE + 3)
  35 #ifdef ZM_ENABLE_CENC
  36 #define ZM_IOCTL_CENC               (SIOCDEVPRIVATE + 4)
  37 #endif  /* ZM_ENABLE_CENC */
  38 #define ZD_PARAM_ROAMING                    0x0001
  39 #define ZD_PARAM_PRIVACY                    0x0002
  40 #define ZD_PARAM_WPA                        0x0003
  41 #define ZD_PARAM_COUNTERMEASURES        0x0004
  42 #define ZD_PARAM_DROPUNENCRYPTED        0x0005
  43 #define ZD_PARAM_AUTH_ALGS                  0x0006
  44 #define ZD_PARAM_WPS_FILTER                 0x0007
  45
  46 #ifdef ZM_ENABLE_CENC
  47 #define P80211_PACKET_CENCFLAG          0x0001
  48 #endif  /* ZM_ENABLE_CENC */
  49 #define P80211_PACKET_SETKEY            0x0003
  50
  51 #define ZD_CMD_SET_ENCRYPT_KEY          0x0001
  52 #define ZD_CMD_SET_MLME                     0x0002
  53 #define ZD_CMD_SCAN_REQ                     0x0003
  54 #define ZD_CMD_SET_GENERIC_ELEMENT      0x0004
  55 #define ZD_CMD_GET_TSC                      0x0005
  56
  57 #define ZD_CRYPT_ALG_NAME_LEN           16
  58 #define ZD_MAX_KEY_SIZE                     32
  59 #define ZD_MAX_GENERIC_SIZE                 64
  60
  61 #include <net/iw_handler.h>
  62
  63 extern u16_t zfLnxGetVapId(zdev_t *dev);
  64
  65 static const u32_t channel_frequency_11A[] =
  66 {
  67         /* Even element for Channel Number, Odd for Frequency */
  68         36, 5180,
  69         40, 5200,
  70         44, 5220,
  71         48, 5240,
  72         52, 5260,
  73         56, 5280,
  74         60, 5300,
  75         64, 5320,
  76         100, 5500,
  77         104, 5520,
  78         108, 5540,
  79         112, 5560,
  80         116, 5580,
  81         120, 5600,
  82         124, 5620,
  83         128, 5640,
  84         132, 5660,
  85         136, 5680,
  86         140, 5700,
  87         /**/
  88         184, 4920,
  89         188, 4940,
  90         192, 4960,
  91         196, 4980,
  92         8, 5040,
  93         12, 5060,
  94         16, 5080,
  95         34, 5170,
  96         38, 5190,
  97         42, 5210,
  98         46, 5230,
  99         /**/
 100         149, 5745,
 101         153, 5765,
 102         157, 5785,
 103         161, 5805,
 104         165, 5825
 105         /**/
 106 };
 107
 108 int usbdrv_freq2chan(u32_t freq)
 109 {
 110         /* 2.4G Hz */
 111         if (freq > 2400 && freq < 3000) {
 112                 return ((freq-2412)/5) + 1;
 113         } else {
 114                 u16_t ii;
 115                 u16_t num_chan = sizeof(channel_frequency_11A)/sizeof(u32_t);
 116
 117                 for (ii = 1; ii < num_chan; ii += 2) {
 118                         if (channel_frequency_11A[ii] == freq)
 119                                 return channel_frequency_11A[ii-1];
 120                 }
 121         }
 122
 123         return 0;
 124 }
 125
 126 int usbdrv_chan2freq(int chan)
 127 {
 128         int freq;
 129
 130         /* If channel number is out of range */
 131         if (chan > 165 || chan <= 0)
 132                 return -1;
 133
 134         /* 2.4G band */
 135         if (chan >= 1 && chan <= 13) {
 136                 freq = (2412 + (chan - 1) * 5);
 137                         return freq;
 138         } else if (chan >= 36 && chan <= 165) {
 139                 u16_t ii;
 140                 u16_t num_chan = sizeof(channel_frequency_11A)/sizeof(u32_t);
 141
 142                 for (ii = 0; ii < num_chan; ii += 2) {
 143                         if (channel_frequency_11A[ii] == chan)
 144                                 return channel_frequency_11A[ii+1];
 145                 }
 146
 147         /* Can't find desired frequency */
 148         if (ii == num_chan)
 149                 return -1;
 150         }
 151
 152         /* Can't find deisred frequency */
 153         return -1;
 154 }
 155
 156 int usbdrv_ioctl_setessid(struct net_device *dev, struct iw_point *erq)
 157 {
 158         #ifdef ZM_HOSTAPD_SUPPORT
 159         /* struct usbdrv_private *macp = dev->ml_priv; */
 160         char essidbuf[IW_ESSID_MAX_SIZE+1];
 161         int i;
 162
 163         if (!netif_running(dev))
 164                 return -EINVAL;
 165
 166         memset(essidbuf, 0, sizeof(essidbuf));
 167
 168         printk(KERN_ERR "usbdrv_ioctl_setessid\n");
 169
 170         /* printk("ssidlen=%d\n", erq->length); //for any, it is 1. */
 171         if (erq->flags) {
 172                 if (erq->length > (IW_ESSID_MAX_SIZE+1))
 173                         return -E2BIG;
 174
 175                 if (copy_from_user(essidbuf, erq->pointer, erq->length))
 176                         return -EFAULT;
 177         }
 178
 179         /* zd_DisasocAll(2); */
 180         /* wait_ms(100); */
 181
 182         printk(KERN_ERR "essidbuf: ");
 183
 184         for (i = 0; i < erq->length; i++)
 185                 printk(KERN_ERR "%02x ", essidbuf[i]);
 186
 187         printk(KERN_ERR "\n");
 188
 189         essidbuf[erq->length] = '\0';
 190         /* memcpy(macp->wd.ws.ssid, essidbuf, erq->length); */
 191         /* macp->wd.ws.ssidLen = strlen(essidbuf)+2; */
 192         /* macp->wd.ws.ssid[1] = strlen(essidbuf); Update ssid length */
 193
 194         zfiWlanSetSSID(dev, essidbuf, erq->length);
 195         #if 0
 196                 printk(KERN_ERR "macp->wd.ws.ssid: ");
 197
 198                 for (i = 0; i < macp->wd.ws.ssidLen; i++)
 199                         printk(KERN_ERR "%02x ", macp->wd.ws.ssid[i]);
 200
 201                 printk(KERN_ERR "\n");
 202         #endif
 203
 204         zfiWlanDisable(dev, 0);
 205         zfiWlanEnable(dev);
 206
 207         #endif
 208
 209         return 0;
 210 }
 211
 212 int usbdrv_ioctl_getessid(struct net_device *dev, struct iw_point *erq)
 213 {
 214         /* struct usbdrv_private *macp = dev->ml_priv; */
 215         u8_t essidbuf[IW_ESSID_MAX_SIZE+1];
 216         u8_t len;
 217         u8_t i;
 218
 219
 220         /* len = macp->wd.ws.ssidLen; */
 221         /* memcpy(essidbuf, macp->wd.ws.ssid, macp->wd.ws.ssidLen); */
 222         zfiWlanQuerySSID(dev, essidbuf, &len);
 223
 224         essidbuf[len] = 0;
 225
 226         printk(KERN_ERR "ESSID: ");
 227
 228         for (i = 0; i < len; i++)
 229                 printk(KERN_ERR "%c", essidbuf[i]);
 230
 231         printk(KERN_ERR "\n");
 232
 233         erq->flags = 1;
 234         erq->length = strlen(essidbuf) + 1;
 235
 236         if (erq->pointer) {
 237                 if (copy_to_user(erq->pointer, essidbuf, erq->length))
 238                         return -EFAULT;
 239         }
 240
 241         return 0;
 242 }
 243
 244 int usbdrv_ioctl_setrts(struct net_device *dev, struct iw_param *rrq)
 245 {
 246         return 0;
 247 }
 248
 249 /*
 250  * Encode a WPA or RSN information element as a custom
 251  * element using the hostap format.
 252  */
 253 u32 encode_ie(void *buf, u32 bufsize, const u8 *ie, u32 ielen,
 254                 const u8 *leader, u32 leader_len)
 255 {
 256         u8 *p;
 257         u32 i;
 258
 259         if (bufsize < leader_len)
 260                 return 0;
 261         p = buf;
 262         memcpy(p, leader, leader_len);
 263         bufsize -= leader_len;
 264         p += leader_len;
 265         for (i = 0; i < ielen && bufsize > 2; i++)
 266                 p += sprintf(p, "%02x", ie[i]);
 267         return (i == ielen ? p - (u8 *)buf:0);
 268 }
 269
 270 /*
 271  * Translate scan data returned from the card to a card independent
 272  * format that the Wireless Tools will understand
 273  */
 274 char *usbdrv_translate_scan(struct net_device *dev,
 275         struct iw_request_info *info, char *current_ev,
 276         char *end_buf, struct zsBssInfo *list)
 277 {
 278         struct iw_event iwe;   /* Temporary buffer */
 279         u16_t capabilities;
 280         char *current_val;     /* For rates */
 281         char *last_ev;
 282         int i;
 283         char    buf[64*2 + 30];
 284
 285         last_ev = current_ev;
 286
 287         /* First entry *MUST* be the AP MAC address */
 288         iwe.cmd = SIOCGIWAP;
 289         iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
 290         memcpy(iwe.u.ap_addr.sa_data, list->bssid, ETH_ALEN);
 291         current_ev = iwe_stream_add_event(info, current_ev,
 292                                         end_buf, &iwe, IW_EV_ADDR_LEN);
 293
 294         /* Ran out of buffer */
 295         if (last_ev == current_ev)
 296                 return end_buf;
 297
 298         last_ev = current_ev;
 299
 300         /* Other entries will be displayed in the order we give them */
 301
 302         /* Add the ESSID */
 303         iwe.u.data.length = list->ssid[1];
 304         if (iwe.u.data.length > 32)
 305                 iwe.u.data.length = 32;
 306         iwe.cmd = SIOCGIWESSID;
 307         iwe.u.data.flags = 1;
 308         current_ev = iwe_stream_add_point(info, current_ev,
 309                                         end_buf, &iwe, &list->ssid[2]);
 310
 311         /* Ran out of buffer */
 312         if (last_ev == current_ev)
 313                 return end_buf;
 314
 315         last_ev = current_ev;
 316
 317         /* Add mode */
 318         iwe.cmd = SIOCGIWMODE;
 319         capabilities = (list->capability[1] << 8) + list->capability[0];
 320         if (capabilities & (0x01 | 0x02)) {
 321                 if (capabilities & 0x01)
 322                         iwe.u.mode = IW_MODE_MASTER;
 323                 else
 324                         iwe.u.mode = IW_MODE_ADHOC;
 325                         current_ev = iwe_stream_add_event(info, current_ev,
 326                                                 end_buf, &iwe, IW_EV_UINT_LEN);
 327         }
 328
 329         /* Ran out of buffer */
 330         if (last_ev == current_ev)
 331                 return end_buf;
 332
 333         last_ev = current_ev;
 334
 335         /* Add frequency */
 336         iwe.cmd = SIOCGIWFREQ;
 337         iwe.u.freq.m = list->channel;
 338         /* Channel frequency in KHz */
 339         if (iwe.u.freq.m > 14) {
 340                 if ((184 <= iwe.u.freq.m) && (iwe.u.freq.m <= 196))
 341                         iwe.u.freq.m = 4000 + iwe.u.freq.m * 5;
 342                 else
 343                         iwe.u.freq.m = 5000 + iwe.u.freq.m * 5;
 344         } else {
 345                 if (iwe.u.freq.m == 14)
 346                         iwe.u.freq.m = 2484;
 347                 else
 348                         iwe.u.freq.m = 2412 + (iwe.u.freq.m - 1) * 5;
 349         }
 350         iwe.u.freq.e = 6;
 351         current_ev = iwe_stream_add_event(info, current_ev,
 352                                         end_buf, &iwe, IW_EV_FREQ_LEN);
 353
 354         /* Ran out of buffer */
 355         if (last_ev == current_ev)
 356                 return end_buf;
 357
 358         last_ev = current_ev;
 359
 360         /* Add quality statistics */
 361         iwe.cmd = IWEVQUAL;
 362         iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED
 363                                 | IW_QUAL_NOISE_UPDATED;
 364         iwe.u.qual.level = list->signalStrength;
 365         iwe.u.qual.noise = 0;
 366         iwe.u.qual.qual = list->signalQuality;
 367         current_ev = iwe_stream_add_event(info, current_ev,
 368                                         end_buf, &iwe, IW_EV_QUAL_LEN);
 369
 370         /* Ran out of buffer */
 371         if (last_ev == current_ev)
 372                 return end_buf;
 373
 374         last_ev = current_ev;
 375
 376         /* Add encryption capability */
 377
 378         iwe.cmd = SIOCGIWENCODE;
 379         if (capabilities & 0x10)
 380                 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
 381         else
 382                 iwe.u.data.flags = IW_ENCODE_DISABLED;
 383
 384         iwe.u.data.length = 0;
 385         current_ev = iwe_stream_add_point(info, current_ev,
 386                                         end_buf, &iwe, list->ssid);
 387
 388         /* Ran out of buffer */
 389         if (last_ev == current_ev)
 390                 return end_buf;
 391
 392         last_ev = current_ev;
 393
 394         /* Rate : stuffing multiple values in a single event require a bit
 395         * more of magic
 396         */
 397         current_val = current_ev + IW_EV_LCP_LEN;
 398
 399         iwe.cmd = SIOCGIWRATE;
 400         /* Those two flags are ignored... */
 401         iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
 402
 403         for (i = 0 ; i < list->supportedRates[1] ; i++) {
 404                 /* Bit rate given in 500 kb/s units (+ 0x80) */
 405                 iwe.u.bitrate.value = ((list->supportedRates[i+2] & 0x7f)
 406                                         * 500000);
 407                 /* Add new value to event */
 408                 current_val = iwe_stream_add_value(info, current_ev,
 409                                 current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
 410
 411                 /* Ran out of buffer */
 412                 if (last_ev == current_val)
 413                         return end_buf;
 414
 415                 last_ev = current_val;
 416         }
 417
 418         for (i = 0 ; i < list->extSupportedRates[1] ; i++) {
 419                 /* Bit rate given in 500 kb/s units (+ 0x80) */
 420                 iwe.u.bitrate.value = ((list->extSupportedRates[i+2] & 0x7f)
 421                                         * 500000);
 422                 /* Add new value to event */
 423                 current_val = iwe_stream_add_value(info, current_ev,
 424                                 current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
 425
 426                 /* Ran out of buffer */
 427                 if (last_ev == current_val)
 428                         return end_buf;
 429
 430                 last_ev = current_ev;
 431         }
 432
 433         /* Check if we added any event */
 434         if ((current_val - current_ev) > IW_EV_LCP_LEN)
 435                 current_ev = current_val;
 436                 #define IEEE80211_ELEMID_RSN 0x30
 437         memset(&iwe, 0, sizeof(iwe));
 438         iwe.cmd = IWEVCUSTOM;
 439         snprintf(buf, sizeof(buf), "bcn_int=%d", (list->beaconInterval[1] << 8)
 440                                                 + list->beaconInterval[0]);
 441         iwe.u.data.length = strlen(buf);
 442         current_ev = iwe_stream_add_point(info, current_ev,
 443                                                 end_buf, &iwe, buf);
 444
 445         /* Ran out of buffer */
 446         if (last_ev == current_ev)
 447                 return end_buf;
 448
 449         last_ev = current_ev;
 450
 451         if (list->wpaIe[1] != 0) {
 452                 static const char rsn_leader[] = "rsn_ie=";
 453                 static const char wpa_leader[] = "wpa_ie=";
 454
 455                 memset(&iwe, 0, sizeof(iwe));
 456                 iwe.cmd = IWEVCUSTOM;
 457                 if (list->wpaIe[0] == IEEE80211_ELEMID_RSN)
 458                         iwe.u.data.length = encode_ie(buf, sizeof(buf),
 459                                         list->wpaIe, list->wpaIe[1]+2,
 460                                         rsn_leader, sizeof(rsn_leader)-1);
 461                 else
 462                         iwe.u.data.length = encode_ie(buf, sizeof(buf),
 463                                         list->wpaIe, list->wpaIe[1]+2,
 464                                         wpa_leader, sizeof(wpa_leader)-1);
 465
 466                 if (iwe.u.data.length != 0)
 467                         current_ev = iwe_stream_add_point(info, current_ev,
 468                                                         end_buf, &iwe, buf);
 469
 470                 /* Ran out of buffer */
 471                 if (last_ev == current_ev)
 472                         return end_buf;
 473
 474                 last_ev = current_ev;
 475         }
 476
 477         if (list->rsnIe[1] != 0) {
 478                 static const char rsn_leader[] = "rsn_ie=";
 479                 memset(&iwe, 0, sizeof(iwe));
 480                 iwe.cmd = IWEVCUSTOM;
 481
 482                 if (list->rsnIe[0] == IEEE80211_ELEMID_RSN) {
 483                         iwe.u.data.length = encode_ie(buf, sizeof(buf),
 484                         list->rsnIe, list->rsnIe[1]+2,
 485                         rsn_leader, sizeof(rsn_leader)-1);
 486                         if (iwe.u.data.length != 0)
 487                                 current_ev = iwe_stream_add_point(info,
 488                                         current_ev, end_buf,  &iwe, buf);
 489
 490                         /* Ran out of buffer */
 491                         if (last_ev == current_ev)
 492                                 return end_buf;
 493
 494                         last_ev = current_ev;
 495                 }
 496         }
 497         /* The other data in the scan result are not really
 498         * interesting, so for now drop it
 499         */
 500         return current_ev;
 501 }
 502
 503 int usbdrvwext_giwname(struct net_device *dev,
 504                 struct iw_request_info *info,
 505                 union iwreq_data *wrq, char *extra)
 506 {
 507         /* struct usbdrv_private *macp = dev->ml_priv; */
 508
 509         strcpy(wrq->name, "IEEE 802.11-MIMO");
 510
 511         return 0;
 512 }
 513
 514 int usbdrvwext_siwfreq(struct net_device *dev,
 515                 struct iw_request_info *info,
 516                 struct iw_freq *freq, char *extra)
 517 {
 518         u32_t FreqKHz;
 519         struct usbdrv_private *macp = dev->ml_priv;
 520
 521         if (!netif_running(dev))
 522                 return -EINVAL;
 523
 524         if (freq->e > 1)
 525                 return -EINVAL;
 526
 527         if (freq->e == 1) {
 528                 FreqKHz = (freq->m / 100000);
 529
 530                 if (FreqKHz > 4000000) {
 531                         if (FreqKHz > 5825000)
 532                                 FreqKHz = 5825000;
 533                         else if (FreqKHz < 4920000)
 534                                 FreqKHz = 4920000;
 535                         else if (FreqKHz < 5000000)
 536                                 FreqKHz = (((FreqKHz - 4000000) / 5000) * 5000)
 537                                                 + 4000000;
 538                         else
 539                                 FreqKHz = (((FreqKHz - 5000000) / 5000) * 5000)
 540                                                 + 5000000;
 541                 } else {
 542                         if (FreqKHz > 2484000)
 543                                 FreqKHz = 2484000;
 544                         else if (FreqKHz < 2412000)
 545                                 FreqKHz = 2412000;
 546                         else
 547                                 FreqKHz = (((FreqKHz - 2412000) / 5000) * 5000)
 548                                                 + 2412000;
 549                 }
 550         } else {
 551                 FreqKHz = usbdrv_chan2freq(freq->m);
 552
 553                 if (FreqKHz != -1)
 554                         FreqKHz *= 1000;
 555                 else
 556                         FreqKHz = 2412000;
 557         }
 558
 559         /* printk("freq->m: %d, freq->e: %d\n", freq->m, freq->e); */
 560         /* printk("FreqKHz: %d\n", FreqKHz); */
 561
 562         if (macp->DeviceOpened == 1) {
 563                 zfiWlanSetFrequency(dev, FreqKHz, 0); /* Immediate */
 564                 /* u8_t wpaieLen,wpaie[50]; */
 565                 /* zfiWlanQueryWpaIe(dev, wpaie, &wpaieLen); */
 566                 zfiWlanDisable(dev, 0);
 567                 zfiWlanEnable(dev);
 568                 /* if (wpaieLen > 2) */
 569                 /* zfiWlanSetWpaIe(dev, wpaie, wpaieLen); */
 570         }
 571
 572         return 0;
 573 }
 574
 575 int usbdrvwext_giwfreq(struct net_device *dev,
 576                 struct iw_request_info *info,
 577                 struct iw_freq *freq, char *extra)
 578 {
 579         struct usbdrv_private *macp = dev->ml_priv;
 580
 581         if (macp->DeviceOpened != 1)
 582                 return 0;
 583
 584         freq->m = zfiWlanQueryFrequency(dev);
 585         freq->e = 3;
 586
 587         return 0;
 588 }
 589
 590 int usbdrvwext_siwmode(struct net_device *dev,
 591                 struct iw_request_info *info,
 592                 union iwreq_data *wrq, char *extra)
 593 {
 594         struct usbdrv_private *macp = dev->ml_priv;
 595         u8_t WlanMode;
 596
 597         if (!netif_running(dev))
 598                 return -EINVAL;
 599
 600         if (macp->DeviceOpened != 1)
 601                 return 0;
 602
 603         switch (wrq->mode) {
 604         case IW_MODE_MASTER:
 605                 WlanMode = ZM_MODE_AP;
 606                 break;
 607         case IW_MODE_INFRA:
 608                 WlanMode = ZM_MODE_INFRASTRUCTURE;
 609                 break;
 610         case IW_MODE_ADHOC:
 611                 WlanMode = ZM_MODE_IBSS;
 612                 break;
 613         default:
 614                 WlanMode = ZM_MODE_IBSS;
 615                 break;
 616         }
 617
 618         zfiWlanSetWlanMode(dev, WlanMode);
 619         zfiWlanDisable(dev, 1);
 620         zfiWlanEnable(dev);
 621
 622         return 0;
 623 }
 624
 625 int usbdrvwext_giwmode(struct net_device *dev,
 626         struct iw_request_info *info,
 627         __u32 *mode, char *extra)
 628 {
 629         unsigned long irqFlag;
 630         struct usbdrv_private *macp = dev->ml_priv;
 631
 632         if (!netif_running(dev))
 633                 return -EINVAL;
 634
 635         if (macp->DeviceOpened != 1)
 636                 return 0;
 637
 638         spin_lock_irqsave(&macp->cs_lock, irqFlag);
 639
 640         switch (zfiWlanQueryWlanMode(dev)) {
 641         case ZM_MODE_AP:
 642                 *mode = IW_MODE_MASTER;
 643                 break;
 644         case ZM_MODE_INFRASTRUCTURE:
 645                 *mode = IW_MODE_INFRA;
 646                 break;
 647         case ZM_MODE_IBSS:
 648                 *mode = IW_MODE_ADHOC;
 649                 break;
 650         default:
 651                 *mode = IW_MODE_ADHOC;
 652                 break;
 653         }
 654
 655         spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
 656
 657         return 0;
 658 }
 659
 660 int usbdrvwext_siwsens(struct net_device *dev,
 661                         struct iw_request_info *info,
 662                         struct iw_param *sens, char *extra)
 663 {
 664         return 0;
 665 }
 666
 667 int usbdrvwext_giwsens(struct net_device *dev,
 668                         struct iw_request_info *info,
 669                         struct iw_param *sens, char *extra)
 670 {
 671         sens->value = 0;
 672         sens->fixed = 1;
 673
 674         return 0;
 675 }
 676
 677 int usbdrvwext_giwrange(struct net_device *dev,
 678                 struct iw_request_info *info,
 679                 struct iw_point *data, char *extra)
 680 {
 681         struct iw_range *range = (struct iw_range *) extra;
 682         int i, val;
 683         /* int num_band_a; */
 684         u16_t channels[60];
 685         u16_t channel_num;
 686
 687         if (!netif_running(dev))
 688                 return -EINVAL;
 689
 690         range->txpower_capa = IW_TXPOW_DBM;
 691         /* XXX what about min/max_pmp, min/max_pmt, etc. */
 692
 693         range->we_version_compiled = WIRELESS_EXT;
 694         range->we_version_source = 13;
 695
 696         range->retry_capa = IW_RETRY_LIMIT;
 697         range->retry_flags = IW_RETRY_LIMIT;
 698         range->min_retry = 0;
 699         range->max_retry = 255;
 700
 701         channel_num = zfiWlanQueryAllowChannels(dev, channels);
 702
 703         /* Gurantee reported channel numbers is less
 704         * or equal to IW_MAX_FREQUENCIES
 705         */
 706         if (channel_num > IW_MAX_FREQUENCIES)
 707                 channel_num = IW_MAX_FREQUENCIES;
 708
 709         val = 0;
 710
 711         for (i = 0; i < channel_num; i++) {
 712                 range->freq[val].i = usbdrv_freq2chan(channels[i]);
 713                 range->freq[val].m = channels[i];
 714                 range->freq[val].e = 6;
 715                 val++;
 716         }
 717
 718         range->num_channels = channel_num;
 719         range->num_frequency = channel_num;
 720
 721         #if 0
 722         range->num_channels = 14; /* Only 2.4G */
 723
 724         /* XXX need to filter against the regulatory domain &| active set */
 725         val = 0;
 726         /* B,G Bands */
 727         for (i = 1; i <= 14; i++) {
 728                 range->freq[val].i = i;
 729                 if (i == 14)
 730                         range->freq[val].m = 2484000;
 731                 else
 732                         range->freq[val].m = (2412+(i-1)*5)*1000;
 733                 range->freq[val].e = 3;
 734                 val++;
 735         }
 736
 737         num_band_a = (IW_MAX_FREQUENCIES - val);
 738         /* A Bands */
 739         for (i = 0; i < num_band_a; i++) {
 740                 range->freq[val].i = channel_frequency_11A[2 * i];
 741                 range->freq[val].m = channel_frequency_11A[2 * i + 1] * 1000;
 742                 range->freq[val].e = 3;
 743                 val++;
 744         }
 745         /* MIMO Rate Not Defined Now
 746         * For 802.11a, there are too more frequency.
 747         * We can't return them all.
 748         */
 749         range->num_frequency = val;
 750         #endif
 751
 752         /* Max of /proc/net/wireless */
 753         range->max_qual.qual = 100;  /* ??  92; */
 754         range->max_qual.level = 154; /* ?? */
 755         range->max_qual.noise = 154; /* ?? */
 756         range->sensitivity = 3;      /* ?? */
 757
 758         /* XXX these need to be nsd-specific! */
 759         range->min_rts = 0;
 760         range->max_rts = 2347;
 761         range->min_frag = 256;
 762         range->max_frag = 2346;
 763         range->max_encoding_tokens = 4 /* NUM_WEPKEYS ?? */;
 764         range->num_encoding_sizes = 2; /* ?? */
 765
 766         range->encoding_size[0] = 5; /* ?? WEP Key Encoding Size */
 767         range->encoding_size[1] = 13; /* ?? */
 768
 769         /* XXX what about num_bitrates/throughput? */
 770         range->num_bitrates = 0; /* ?? */
 771
 772         /* estimated max throughput
 773         * XXX need to cap it if we're running at ~2Mbps..
 774         */
 775
 776         range->throughput = 300000000;
 777
 778         return 0;
 779 }
 780
 781 int usbdrvwext_siwap(struct net_device *dev, struct iw_request_info *info,
 782                 struct sockaddr *MacAddr, char *extra)
 783 {
 784         struct usbdrv_private *macp = dev->ml_priv;
 785
 786         if (!netif_running(dev))
 787                 return -EINVAL;
 788
 789         if (zfiWlanQueryWlanMode(dev) == ZM_MODE_AP) {
 790                 /* AP Mode */
 791                 zfiWlanSetMacAddress(dev, (u16_t *)&MacAddr->sa_data[0]);
 792         } else {
 793                 /* STA Mode */
 794                 zfiWlanSetBssid(dev, &MacAddr->sa_data[0]);
 795         }
 796
 797         if (macp->DeviceOpened == 1) {
 798                 /* u8_t wpaieLen,wpaie[80]; */
 799                 /* zfiWlanQueryWpaIe(dev, wpaie, &wpaieLen); */
 800                 zfiWlanDisable(dev, 0);
 801                 zfiWlanEnable(dev);
 802                 /* if (wpaieLen > 2) */
 803                 /* zfiWlanSetWpaIe(dev, wpaie, wpaieLen); */
 804         }
 805
 806         return 0;
 807 }
 808
 809 int usbdrvwext_giwap(struct net_device *dev,
 810                 struct iw_request_info *info,
 811                 struct sockaddr *MacAddr, char *extra)
 812 {
 813         struct usbdrv_private *macp = dev->ml_priv;
 814
 815         if (macp->DeviceOpened != 1)
 816                 return 0;
 817
 818         if (zfiWlanQueryWlanMode(dev) == ZM_MODE_AP) {
 819                 /* AP Mode */
 820                 zfiWlanQueryMacAddress(dev, &MacAddr->sa_data[0]);
 821         } else {
 822                 /* STA Mode */
 823                 if (macp->adapterState == ZM_STATUS_MEDIA_CONNECT) {
 824                         zfiWlanQueryBssid(dev, &MacAddr->sa_data[0]);
 825                 } else {
 826                         u8_t zero_addr[6] = { 0x00, 0x00, 0x00, 0x00,
 827                                                                 0x00, 0x00 };
 828                         memcpy(&MacAddr->sa_data[0], zero_addr,
 829                                                         sizeof(zero_addr));
 830                 }
 831         }
 832
 833         return 0;
 834 }
 835
 836 int usbdrvwext_iwaplist(struct net_device *dev,
 837                         struct iw_request_info *info,
 838                         struct iw_point *data, char *extra)
 839 {
 840         /* Don't know how to do yet--CWYang(+) */
 841         return 0;
 842
 843 }
 844
 845 int usbdrvwext_siwscan(struct net_device *dev, struct iw_request_info *info,
 846         struct iw_point *data, char *extra)
 847 {
 848         struct usbdrv_private *macp = dev->ml_priv;
 849
 850         if (macp->DeviceOpened != 1)
 851                 return 0;
 852
 853         printk(KERN_WARNING "CWY - usbdrvwext_siwscan\n");
 854
 855         zfiWlanScan(dev);
 856
 857         return 0;
 858 }
 859
 860 int usbdrvwext_giwscan(struct net_device *dev,
 861                 struct iw_request_info *info,
 862                 struct iw_point *data, char *extra)
 863 {
 864         struct usbdrv_private *macp = dev->ml_priv;
 865         /* struct zsWlanDev* wd = (struct zsWlanDev*) zmw_wlan_dev(dev); */
 866         char *current_ev = extra;
 867         char *end_buf;
 868         int i;
 869         /* BssList = wd->sta.pBssList; */
 870         /* zmw_get_wlan_dev(dev); */
 871
 872         if (macp->DeviceOpened != 1)
 873                 return 0;
 874
 875         /* struct zsBssList BssList; */
 876         struct zsBssListV1 *pBssList = kmalloc(sizeof(struct zsBssListV1),
 877                                                                 GFP_KERNEL);
 878         if (data->length == 0)
 879                 end_buf = extra + IW_SCAN_MAX_DATA;
 880         else
 881                 end_buf = extra + data->length;
 882
 883         printk(KERN_WARNING "giwscan - Report Scan Results\n");
 884         /* printk("giwscan - BssList Sreucture Len : %d\n", sizeof(BssList));
 885         * printk("giwscan - BssList Count : %d\n",
 886         * wd->sta.pBssList->bssCount);
 887         * printk("giwscan - UpdateBssList Count : %d\n",
 888         * wd->sta.pUpdateBssList->bssCount);
 889         */
 890         zfiWlanQueryBssListV1(dev, pBssList);
 891         /* zfiWlanQueryBssList(dev, &BssList); */
 892
 893         /* Read and parse all entries */
 894         printk(KERN_WARNING "giwscan - pBssList->bssCount : %d\n",
 895                                                 pBssList->bssCount);
 896         /* printk("giwscan - BssList.bssCount : %d\n", BssList.bssCount); */
 897
 898         for (i = 0; i < pBssList->bssCount; i++) {
 899                 /* Translate to WE format this entry
 900                 * current_ev = usbdrv_translate_scan(dev, info, current_ev,
 901                 * extra + IW_SCAN_MAX_DATA, &pBssList->bssInfo[i]);
 902                 */
 903                 current_ev = usbdrv_translate_scan(dev, info, current_ev,
 904                                         end_buf, &pBssList->bssInfo[i]);
 905
 906                 if (current_ev == end_buf) {
 907                         kfree(pBssList);
 908                         data->length = current_ev - extra;
 909                         return -E2BIG;
 910                 }
 911         }
 912
 913         /* Length of data */
 914         data->length = (current_ev - extra);
 915         data->flags = 0;   /* todo */
 916
 917         kfree(pBssList);
 918
 919         return 0;
 920 }
 921
 922 int usbdrvwext_siwessid(struct net_device *dev,
 923                 struct iw_request_info *info,
 924                 struct iw_point *essid, char *extra)
 925 {
 926         char EssidBuf[IW_ESSID_MAX_SIZE + 1];
 927         struct usbdrv_private *macp = dev->ml_priv;
 928
 929         if (!netif_running(dev))
 930                 return -EINVAL;
 931
 932         if (essid->flags == 1) {
 933                 if (essid->length > IW_ESSID_MAX_SIZE)
 934                         return -E2BIG;
 935
 936                 if (copy_from_user(&EssidBuf, essid->pointer, essid->length))
 937                         return -EFAULT;
 938
 939                 EssidBuf[essid->length] = '\0';
 940                 /* printk("siwessid - Set Essid : %s\n",EssidBuf); */
 941                 /* printk("siwessid - Essid Len : %d\n",essid->length); */
 942                 /* printk("siwessid - Essid Flag : %x\n",essid->flags); */
 943                 if (macp->DeviceOpened == 1) {
 944                         zfiWlanSetSSID(dev, EssidBuf, strlen(EssidBuf));
 945                         zfiWlanSetFrequency(dev, zfiWlanQueryFrequency(dev),
 946                                                 FALSE);
 947                         zfiWlanSetEncryMode(dev, zfiWlanQueryEncryMode(dev));
 948                         /* u8_t wpaieLen,wpaie[50]; */
 949                         /* zfiWlanQueryWpaIe(dev, wpaie, &wpaieLen); */
 950                         zfiWlanDisable(dev, 0);
 951                         zfiWlanEnable(dev);
 952                         /* if (wpaieLen > 2) */
 953                         /* zfiWlanSetWpaIe(dev, wpaie, wpaieLen); */
 954                 }
 955         }
 956
 957         return 0;
 958 }
 959
 960 int usbdrvwext_giwessid(struct net_device *dev,
 961                 struct iw_request_info *info,
 962                 struct iw_point *essid, char *extra)
 963 {
 964         struct usbdrv_private *macp = dev->ml_priv;
 965         u8_t EssidLen;
 966         char EssidBuf[IW_ESSID_MAX_SIZE + 1];
 967         int ssid_len;
 968
 969         if (!netif_running(dev))
 970                 return -EINVAL;
 971
 972         if (macp->DeviceOpened != 1)
 973                 return 0;
 974
 975         zfiWlanQuerySSID(dev, &EssidBuf[0], &EssidLen);
 976
 977         /* Convert type from unsigned char to char */
 978         ssid_len = (int)EssidLen;
 979
 980         /* Make sure the essid length is not greater than IW_ESSID_MAX_SIZE */
 981         if (ssid_len > IW_ESSID_MAX_SIZE)
 982                 ssid_len = IW_ESSID_MAX_SIZE;
 983
 984         EssidBuf[ssid_len] = '\0';
 985
 986         essid->flags = 1;
 987         essid->length = strlen(EssidBuf);
 988
 989         memcpy(extra, EssidBuf, essid->length);
 990         /* wireless.c in Kernel would handle copy_to_user -- line 679 */
 991         /* if (essid->pointer) {
 992         * if (copy_to_user(essid->pointer, EssidBuf, essid->length)) {
 993         * printk("giwessid - copy_to_user Fail\n");
 994         * return -EFAULT;
 995         * }
 996         * }
 997         */
 998
 999         return 0;
1000 }
1001
1002 int usbdrvwext_siwnickn(struct net_device *dev,
1003                         struct iw_request_info *info,
1004                         struct iw_point *data, char *nickname)
1005 {
1006         /* Exist but junk--CWYang(+) */
1007         return 0;
1008 }
1009
1010 int usbdrvwext_giwnickn(struct net_device *dev,
1011                         struct iw_request_info *info,
1012                         struct iw_point *data, char *nickname)
1013 {
1014         struct usbdrv_private *macp = dev->ml_priv;
1015         u8_t EssidLen;
1016         char EssidBuf[IW_ESSID_MAX_SIZE + 1];
1017
1018         if (macp->DeviceOpened != 1)
1019                 return 0;
1020
1021         zfiWlanQuerySSID(dev, &EssidBuf[0], &EssidLen);
1022         EssidBuf[EssidLen] = 0;
1023
1024         data->flags = 1;
1025         data->length = strlen(EssidBuf);
1026
1027         memcpy(nickname, EssidBuf, data->length);
1028
1029         return 0;
1030 }
1031
1032 int usbdrvwext_siwrate(struct net_device *dev,
1033                 struct iw_request_info *info,
1034                 struct iw_param *frq, char *extra)
1035 {
1036         struct usbdrv_private *macp = dev->ml_priv;
1037         /* Array to Define Rate Number that Send to Driver */
1038         u16_t zcIndextoRateBG[16] = {1000, 2000, 5500, 11000, 0, 0, 0, 0,
1039                         48000, 24000, 12000, 6000, 54000, 36000, 18000, 9000};
1040         u16_t zcRateToMCS[] = {0xff, 0, 1, 2, 3, 0xb, 0xf, 0xa, 0xe, 0x9, 0xd,
1041                                 0x8, 0xc};
1042         u8_t i, RateIndex = 4;
1043         u16_t RateKbps;
1044
1045         /* printk("frq->disabled : 0x%x\n",frq->disabled); */
1046         /* printk("frq->value : 0x%x\n",frq->value); */
1047
1048         RateKbps = frq->value / 1000;
1049         /* printk("RateKbps : %d\n", RateKbps); */
1050         for (i = 0; i < 16; i++) {
1051                 if (RateKbps == zcIndextoRateBG[i])
1052                         RateIndex = i;
1053         }
1054
1055         if (zcIndextoRateBG[RateIndex] == 0)
1056                 RateIndex = 0xff;
1057         /* printk("RateIndex : %x\n", RateIndex); */
1058         for (i = 0; i < 13; i++)
1059                 if (RateIndex == zcRateToMCS[i])
1060                         break;
1061         /* printk("Index : %x\n", i); */
1062         if (RateKbps == 65000) {
1063                 RateIndex = 20;
1064                 printk(KERN_WARNING "RateIndex : %d\n", RateIndex);
1065         }
1066
1067         if (macp->DeviceOpened == 1) {
1068                 zfiWlanSetTxRate(dev, i);
1069                 /* zfiWlanDisable(dev); */
1070                 /* zfiWlanEnable(dev); */
1071         }
1072
1073         return 0;
1074 }
1075
1076 int usbdrvwext_giwrate(struct net_device *dev,
1077                 struct iw_request_info *info,
1078                 struct iw_param *frq, char *extra)
1079 {
1080         struct usbdrv_private *macp = dev->ml_priv;
1081
1082         if (!netif_running(dev))
1083                 return -EINVAL;
1084
1085         if (macp->DeviceOpened != 1)
1086                 return 0;
1087
1088         frq->fixed = 0;
1089         frq->disabled = 0;
1090         frq->value = zfiWlanQueryRxRate(dev) * 1000;
1091
1092         return 0;
1093 }
1094
1095 int usbdrvwext_siwrts(struct net_device *dev,
1096                 struct iw_request_info *info,
1097                 struct iw_param *rts, char *extra)
1098 {
1099         struct usbdrv_private *macp = dev->ml_priv;
1100         int val = rts->value;
1101
1102         if (macp->DeviceOpened != 1)
1103                 return 0;
1104
1105         if (rts->disabled)
1106                 val = 2347;
1107
1108         if ((val < 0) || (val > 2347))
1109                 return -EINVAL;
1110
1111         zfiWlanSetRtsThreshold(dev, val);
1112
1113         return 0;
1114 }
1115
1116 int usbdrvwext_giwrts(struct net_device *dev,
1117                 struct iw_request_info *info,
1118                 struct iw_param *rts, char *extra)
1119 {
1120         struct usbdrv_private *macp = dev->ml_priv;
1121
1122         if (!netif_running(dev))
1123                 return -EINVAL;
1124
1125         if (macp->DeviceOpened != 1)
1126                 return 0;
1127
1128         rts->value = zfiWlanQueryRtsThreshold(dev);
1129         rts->disabled = (rts->value >= 2347);
1130         rts->fixed = 1;
1131
1132         return 0;
1133 }
1134
1135 int usbdrvwext_siwfrag(struct net_device *dev,
1136                 struct iw_request_info *info,
1137                 struct iw_param *frag, char *extra)
1138 {
1139         struct usbdrv_private *macp = dev->ml_priv;
1140         u16_t fragThreshold;
1141
1142         if (macp->DeviceOpened != 1)
1143                 return 0;
1144
1145         if (frag->disabled)
1146                 fragThreshold = 0;
1147         else
1148                 fragThreshold = frag->value;
1149
1150         zfiWlanSetFragThreshold(dev, fragThreshold);
1151
1152         return 0;
1153 }
1154
1155 int usbdrvwext_giwfrag(struct net_device *dev,
1156                 struct iw_request_info *info,
1157                 struct iw_param *frag, char *extra)
1158 {
1159         struct usbdrv_private *macp = dev->ml_priv;
1160         u16 val;
1161         unsigned long irqFlag;
1162
1163         if (!netif_running(dev))
1164                 return -EINVAL;
1165
1166         if (macp->DeviceOpened != 1)
1167                 return 0;
1168
1169         spin_lock_irqsave(&macp->cs_lock, irqFlag);
1170
1171         val = zfiWlanQueryFragThreshold(dev);
1172
1173         frag->value = val;
1174
1175         frag->disabled = (val >= 2346);
1176         frag->fixed = 1;
1177
1178         spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
1179
1180         return 0;
1181 }
1182
1183 int usbdrvwext_siwtxpow(struct net_device *dev,
1184                         struct iw_request_info *info,
1185                         struct iw_param *rrq, char *extra)
1186 {
1187         /* Not support yet--CWYng(+) */
1188         return 0;
1189 }
1190
1191 int usbdrvwext_giwtxpow(struct net_device *dev,
1192                         struct iw_request_info *info,
1193                         struct iw_param *rrq, char *extra)
1194 {
1195         /* Not support yet--CWYng(+) */
1196         return 0;
1197 }
1198
1199 int usbdrvwext_siwretry(struct net_device *dev,
1200                         struct iw_request_info *info,
1201                         struct iw_param *rrq, char *extra)
1202 {
1203         /* Do nothing--CWYang(+) */
1204         return 0;
1205 }
1206
1207 int usbdrvwext_giwretry(struct net_device *dev,
1208                         struct iw_request_info *info,
1209                         struct iw_param *rrq, char *extra)
1210 {
1211         /* Do nothing--CWYang(+) */
1212         return 0;
1213 }
1214
1215 int usbdrvwext_siwencode(struct net_device *dev,
1216                 struct iw_request_info *info,
1217                 struct iw_point *erq, char *key)
1218 {
1219         struct zsKeyInfo keyInfo;
1220         int i;
1221         int WepState = ZM_ENCRYPTION_WEP_DISABLED;
1222         struct usbdrv_private *macp = dev->ml_priv;
1223
1224         if (!netif_running(dev))
1225                 return -EINVAL;
1226
1227         if ((erq->flags & IW_ENCODE_DISABLED) == 0) {
1228                 keyInfo.key = key;
1229                 keyInfo.keyLength = erq->length;
1230                 keyInfo.keyIndex = (erq->flags & IW_ENCODE_INDEX) - 1;
1231                 if (keyInfo.keyIndex >= 4)
1232                         keyInfo.keyIndex = 0;
1233                 keyInfo.flag = ZM_KEY_FLAG_DEFAULT_KEY;
1234
1235                 zfiWlanSetKey(dev, keyInfo);
1236                 WepState = ZM_ENCRYPTION_WEP_ENABLED;
1237         } else {
1238                 for (i = 1; i < 4; i++)
1239                         zfiWlanRemoveKey(dev, 0, i);
1240                 WepState = ZM_ENCRYPTION_WEP_DISABLED;
1241                 /* zfiWlanSetEncryMode(dev, ZM_NO_WEP); */
1242         }
1243
1244         if (macp->DeviceOpened == 1) {
1245                 zfiWlanSetWepStatus(dev, WepState);
1246                 zfiWlanSetFrequency(dev, zfiWlanQueryFrequency(dev), FALSE);
1247                 /* zfiWlanSetEncryMode(dev, zfiWlanQueryEncryMode(dev)); */
1248                 /* u8_t wpaieLen,wpaie[50]; */
1249                 /* zfiWlanQueryWpaIe(dev, wpaie, &wpaieLen); */
1250                 zfiWlanDisable(dev, 0);
1251                 zfiWlanEnable(dev);
1252                 /* if (wpaieLen > 2) */
1253                 /* zfiWlanSetWpaIe(dev, wpaie, wpaieLen); */
1254         }
1255
1256         return 0;
1257 }
1258
1259 int usbdrvwext_giwencode(struct net_device *dev,
1260                 struct iw_request_info *info,
1261                 struct iw_point *erq, char *key)
1262 {
1263         struct usbdrv_private *macp = dev->ml_priv;
1264         u8_t EncryptionMode;
1265         u8_t keyLen = 0;
1266
1267         if (macp->DeviceOpened != 1)
1268                 return 0;
1269
1270         EncryptionMode = zfiWlanQueryEncryMode(dev);
1271
1272         if (EncryptionMode)
1273                 erq->flags = IW_ENCODE_ENABLED;
1274         else
1275                 erq->flags = IW_ENCODE_DISABLED;
1276
1277         /* We can't return the key, so set the proper flag and return zero */
1278         erq->flags |= IW_ENCODE_NOKEY;
1279         memset(key, 0, 16);
1280
1281         /* Copy the key to the user buffer */
1282         switch (EncryptionMode) {
1283         case ZM_WEP64:
1284                 keyLen = 5;
1285                 break;
1286         case ZM_WEP128:
1287                 keyLen = 13;
1288                 break;
1289         case ZM_WEP256:
1290                 keyLen = 29;
1291                 break;
1292         case ZM_AES:
1293                 keyLen = 16;
1294                 break;
1295         case ZM_TKIP:
1296                 keyLen = 32;
1297                 break;
1298         #ifdef ZM_ENABLE_CENC
1299         case ZM_CENC:
1300                 /* ZM_ENABLE_CENC */
1301                 keyLen = 32;
1302                 break;
1303         #endif
1304         case ZM_NO_WEP:
1305                 keyLen = 0;
1306                 break;
1307         default:
1308                 keyLen = 0;
1309                 printk(KERN_ERR "Unknown EncryMode\n");
1310                 break;
1311         }
1312         erq->length = keyLen;
1313
1314         return 0;
1315 }
1316
1317 int usbdrvwext_siwpower(struct net_device *dev,
1318                 struct iw_request_info *info,
1319                 struct iw_param *frq, char *extra)
1320 {
1321         struct usbdrv_private *macp = dev->ml_priv;
1322         u8_t PSMode;
1323
1324         if (macp->DeviceOpened != 1)
1325                 return 0;
1326
1327         if (frq->disabled)
1328                 PSMode = ZM_STA_PS_NONE;
1329         else
1330                 PSMode = ZM_STA_PS_MAX;
1331
1332         zfiWlanSetPowerSaveMode(dev, PSMode);
1333
1334         return 0;
1335 }
1336
1337 int usbdrvwext_giwpower(struct net_device *dev,
1338                 struct iw_request_info *info,
1339                 struct iw_param *frq, char *extra)
1340 {
1341         unsigned long irqFlag;
1342         struct usbdrv_private *macp = dev->ml_priv;
1343
1344         if (macp->DeviceOpened != 1)
1345                 return 0;
1346
1347         spin_lock_irqsave(&macp->cs_lock, irqFlag);
1348
1349         if (zfiWlanQueryPowerSaveMode(dev) == ZM_STA_PS_NONE)
1350                 frq->disabled = 1;
1351         else
1352                 frq->disabled = 0;
1353
1354         spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
1355
1356         return 0;
1357 }
1358
1359 /*int usbdrvwext_setparam(struct net_device *dev, struct iw_request_info *info,
1360 *                        void *w, char *extra)
1361 *{
1362 *       struct ieee80211vap *vap = dev->ml_priv;
1363 *       struct ieee80211com *ic = vap->iv_ic;
1364 *       struct ieee80211_rsnparms *rsn = &vap->iv_bss->ni_rsn;
1365 *       int *i = (int *) extra;
1366 *       int param = i[0];               // parameter id is 1st
1367 *       int value = i[1];               // NB: most values are TYPE_INT
1368 *       int retv = 0;
1369 *       int j, caps;
1370 *       const struct ieee80211_authenticator *auth;
1371 *       const struct ieee80211_aclator *acl;
1372 *
1373 *       switch (param) {
1374 *       case IEEE80211_PARAM_AUTHMODE:
1375 *               switch (value) {
1376 *               case IEEE80211_AUTH_WPA:        // WPA
1377 *               case IEEE80211_AUTH_8021X:      // 802.1x
1378 *               case IEEE80211_AUTH_OPEN:       // open
1379 *               case IEEE80211_AUTH_SHARED:     // shared-key
1380 *               case IEEE80211_AUTH_AUTO:       // auto
1381 *                       auth = ieee80211_authenticator_get(value);
1382 *                       if (auth == NULL)
1383 *                               return -EINVAL;
1384 *                       break;
1385 *               default:
1386 *                       return -EINVAL;
1387 *               }
1388 *               switch (value) {
1389 *               case IEEE80211_AUTH_WPA:        // WPA w/ 802.1x
1390 *                       vap->iv_flags |= IEEE80211_F_PRIVACY;
1391 *                       value = IEEE80211_AUTH_8021X;
1392 *                       break;
1393 *               case IEEE80211_AUTH_OPEN:       // open
1394 *               vap->iv_flags &= ~(IEEE80211_F_WPA | IEEE80211_F_PRIVACY);
1395 *                       break;
1396 *               case IEEE80211_AUTH_SHARED:     // shared-key
1397 *               case IEEE80211_AUTH_AUTO:       // auto
1398 *               case IEEE80211_AUTH_8021X:      // 802.1x
1399 *                       vap->iv_flags &= ~IEEE80211_F_WPA;
1400 *                       // both require a key so mark the PRIVACY capability
1401 *                       vap->iv_flags |= IEEE80211_F_PRIVACY;
1402 *                       break;
1403 *               }
1404 *               // NB: authenticator attach/detach happens on state change
1405 *               vap->iv_bss->ni_authmode = value;
1406 *               // XXX mixed/mode/usage?
1407 *               vap->iv_auth = auth;
1408 *               retv = ENETRESET;
1409 *               break;
1410 *       case IEEE80211_PARAM_PROTMODE:
1411 *               if (value > IEEE80211_PROT_RTSCTS)
1412 *                       return -EINVAL;
1413 *               ic->ic_protmode = value;
1414 *               // NB: if not operating in 11g this can wait
1415 *               if (ic->ic_bsschan != IEEE80211_CHAN_ANYC &&
1416 *                   IEEE80211_IS_CHAN_ANYG(ic->ic_bsschan))
1417 *                       retv = ENETRESET;
1418 *               break;
1419 *       case IEEE80211_PARAM_MCASTCIPHER:
1420 *               if ((vap->iv_caps & cipher2cap(value)) == 0 &&
1421 *                   !ieee80211_crypto_available(value))
1422 *                       return -EINVAL;
1423 *               rsn->rsn_mcastcipher = value;
1424 *               if (vap->iv_flags & IEEE80211_F_WPA)
1425 *                       retv = ENETRESET;
1426 *               break;
1427 *       case IEEE80211_PARAM_MCASTKEYLEN:
1428 *               if (!(0 < value && value < IEEE80211_KEYBUF_SIZE))
1429 *                       return -EINVAL;
1430 *               // XXX no way to verify driver capability
1431 *               rsn->rsn_mcastkeylen = value;
1432 *               if (vap->iv_flags & IEEE80211_F_WPA)
1433 *                       retv = ENETRESET;
1434 *               break;
1435 *       case IEEE80211_PARAM_UCASTCIPHERS:
1436 *
1437 *                // Convert cipher set to equivalent capabilities.
1438 *                // NB: this logic intentionally ignores unknown and
1439 *                // unsupported ciphers so folks can specify 0xff or
1440 *                // similar and get all available ciphers.
1441 *
1442 *               caps = 0;
1443 *               for (j = 1; j < 32; j++)        // NB: skip WEP
1444 *                       if ((value & (1<<j)) &&
1445 *                           ((vap->iv_caps & cipher2cap(j)) ||
1446 *                            ieee80211_crypto_available(j)))
1447 *                               caps |= 1<<j;
1448 *               if (caps == 0)                  // nothing available
1449 *                       return -EINVAL;
1450 *               // XXX verify ciphers ok for unicast use?
1451 *               // XXX disallow if running as it'll have no effect
1452 *               rsn->rsn_ucastcipherset = caps;
1453 *               if (vap->iv_flags & IEEE80211_F_WPA)
1454 *                       retv = ENETRESET;
1455 *               break;
1456 *       case IEEE80211_PARAM_UCASTCIPHER:
1457 *               if ((rsn->rsn_ucastcipherset & cipher2cap(value)) == 0)
1458 *                       return -EINVAL;
1459 *               rsn->rsn_ucastcipher = value;
1460 *               break;
1461 *       case IEEE80211_PARAM_UCASTKEYLEN:
1462 *               if (!(0 < value && value < IEEE80211_KEYBUF_SIZE))
1463 *                       return -EINVAL;
1464 *               // XXX no way to verify driver capability
1465 *               rsn->rsn_ucastkeylen = value;
1466 *               break;
1467 *       case IEEE80211_PARAM_KEYMGTALGS:
1468 *               // XXX check
1469 *               rsn->rsn_keymgmtset = value;
1470 *               if (vap->iv_flags & IEEE80211_F_WPA)
1471 *                       retv = ENETRESET;
1472 *               break;
1473 *       case IEEE80211_PARAM_RSNCAPS:
1474 *               // XXX check
1475 *               rsn->rsn_caps = value;
1476 *               if (vap->iv_flags & IEEE80211_F_WPA)
1477 *                       retv = ENETRESET;
1478 *               break;
1479 *       case IEEE80211_PARAM_WPA:
1480 *               if (value > 3)
1481 *                       return -EINVAL;
1482 *               // XXX verify ciphers available
1483 *               vap->iv_flags &= ~IEEE80211_F_WPA;
1484 *               switch (value) {
1485 *               case 1:
1486 *                       vap->iv_flags |= IEEE80211_F_WPA1;
1487 *                       break;
1488 *               case 2:
1489 *                       vap->iv_flags |= IEEE80211_F_WPA2;
1490 *                       break;
1491 *               case 3:
1492 *                       vap->iv_flags |= IEEE80211_F_WPA1 | IEEE80211_F_WPA2;
1493 *                       break;
1494 *               }
1495 *               retv = ENETRESET;               // XXX?
1496 *               break;
1497 *       case IEEE80211_PARAM_ROAMING:
1498 *               if (!(IEEE80211_ROAMING_DEVICE <= value &&
1499 *                   value <= IEEE80211_ROAMING_MANUAL))
1500 *                       return -EINVAL;
1501 *               ic->ic_roaming = value;
1502 *               break;
1503 *       case IEEE80211_PARAM_PRIVACY:
1504 *               if (value) {
1505 *                       // XXX check for key state?
1506 *                       vap->iv_flags |= IEEE80211_F_PRIVACY;
1507 *               } else
1508 *                       vap->iv_flags &= ~IEEE80211_F_PRIVACY;
1509 *               break;
1510 *       case IEEE80211_PARAM_DROPUNENCRYPTED:
1511 *               if (value)
1512 *                       vap->iv_flags |= IEEE80211_F_DROPUNENC;
1513 *               else
1514 *                       vap->iv_flags &= ~IEEE80211_F_DROPUNENC;
1515 *               break;
1516 *       case IEEE80211_PARAM_COUNTERMEASURES:
1517 *               if (value) {
1518 *                       if ((vap->iv_flags & IEEE80211_F_WPA) == 0)
1519 *                               return -EINVAL;
1520 *                       vap->iv_flags |= IEEE80211_F_COUNTERM;
1521 *               } else
1522 *                       vap->iv_flags &= ~IEEE80211_F_COUNTERM;
1523 *               break;
1524 *       case IEEE80211_PARAM_DRIVER_CAPS:
1525 *               vap->iv_caps = value;           // NB: for testing
1526 *               break;
1527 *       case IEEE80211_PARAM_MACCMD:
1528 *               acl = vap->iv_acl;
1529 *               switch (value) {
1530 *               case IEEE80211_MACCMD_POLICY_OPEN:
1531 *               case IEEE80211_MACCMD_POLICY_ALLOW:
1532 *               case IEEE80211_MACCMD_POLICY_DENY:
1533 *                       if (acl == NULL) {
1534 *                               acl = ieee80211_aclator_get("mac");
1535 *                               if (acl == NULL || !acl->iac_attach(vap))
1536 *                                       return -EINVAL;
1537 *                               vap->iv_acl = acl;
1538 *                       }
1539 *                       acl->iac_setpolicy(vap, value);
1540 *                       break;
1541 *               case IEEE80211_MACCMD_FLUSH:
1542 *                       if (acl != NULL)
1543 *                               acl->iac_flush(vap);
1544 *                       // NB: silently ignore when not in use
1545 *                       break;
1546 *               case IEEE80211_MACCMD_DETACH:
1547 *                       if (acl != NULL) {
1548 *                               vap->iv_acl = NULL;
1549 *                               acl->iac_detach(vap);
1550 *                       }
1551 *                       break;
1552 *               }
1553 *               break;
1554 *       case IEEE80211_PARAM_WMM:
1555 *               if (ic->ic_caps & IEEE80211_C_WME){
1556 *                       if (value) {
1557 *                               vap->iv_flags |= IEEE80211_F_WME;
1558 *                                *//* XXX needed by ic_reset *//*
1559 *                               vap->iv_ic->ic_flags |= IEEE80211_F_WME;
1560 *                       }
1561 *                       else {
1562 *                               *//* XXX needed by ic_reset *//*
1563 *                               vap->iv_flags &= ~IEEE80211_F_WME;
1564 *                               vap->iv_ic->ic_flags &= ~IEEE80211_F_WME;
1565 *                       }
1566 *                       retv = ENETRESET;       // Renegotiate for capabilities
1567 *               }
1568 *               break;
1569 *       case IEEE80211_PARAM_HIDESSID:
1570 *               if (value)
1571 *                       vap->iv_flags |= IEEE80211_F_HIDESSID;
1572 *               else
1573 *                       vap->iv_flags &= ~IEEE80211_F_HIDESSID;
1574 *               retv = ENETRESET;
1575 *               break;
1576 *       case IEEE80211_PARAM_APBRIDGE:
1577 *               if (value == 0)
1578 *                       vap->iv_flags |= IEEE80211_F_NOBRIDGE;
1579 *               else
1580 *                       vap->iv_flags &= ~IEEE80211_F_NOBRIDGE;
1581 *               break;
1582 *       case IEEE80211_PARAM_INACT:
1583 *               vap->iv_inact_run = value / IEEE80211_INACT_WAIT;
1584 *               break;
1585 *       case IEEE80211_PARAM_INACT_AUTH:
1586 *               vap->iv_inact_auth = value / IEEE80211_INACT_WAIT;
1587 *               break;
1588 *       case IEEE80211_PARAM_INACT_INIT:
1589 *               vap->iv_inact_init = value / IEEE80211_INACT_WAIT;
1590 *               break;
1591 *       case IEEE80211_PARAM_ABOLT:
1592 *               caps = 0;
1593 *
1594 *                // Map abolt settings to capability bits;
1595 *                // this also strips unknown/unwanted bits.
1596 *
1597 *               if (value & IEEE80211_ABOLT_TURBO_PRIME)
1598 *                       caps |= IEEE80211_ATHC_TURBOP;
1599 *               if (value & IEEE80211_ABOLT_COMPRESSION)
1600 *                       caps |= IEEE80211_ATHC_COMP;
1601 *               if (value & IEEE80211_ABOLT_FAST_FRAME)
1602 *                       caps |= IEEE80211_ATHC_FF;
1603 *               if (value & IEEE80211_ABOLT_XR)
1604 *                       caps |= IEEE80211_ATHC_XR;
1605 *               if (value & IEEE80211_ABOLT_AR)
1606 *                       caps |= IEEE80211_ATHC_AR;
1607 *               if (value & IEEE80211_ABOLT_BURST)
1608 *                       caps |= IEEE80211_ATHC_BURST;
1609 *        if (value & IEEE80211_ABOLT_WME_ELE)
1610 *            caps |= IEEE80211_ATHC_WME;
1611 *               // verify requested capabilities are supported
1612 *               if ((caps & ic->ic_ath_cap) != caps)
1613 *                       return -EINVAL;
1614 *               if (vap->iv_ath_cap != caps) {
1615 *                       if ((vap->iv_ath_cap ^ caps) & IEEE80211_ATHC_TURBOP) {
1616 *                               if (ieee80211_set_turbo(dev,
1617 *                                               caps & IEEE80211_ATHC_TURBOP))
1618 *                                       return -EINVAL;
1619 *                               ieee80211_scan_flush(ic);
1620 *                       }
1621 *                       vap->iv_ath_cap = caps;
1622 *                       ic->ic_athcapsetup(vap->iv_ic, vap->iv_ath_cap);
1623 *                       retv = ENETRESET;
1624 *               }
1625 *               break;
1626 *       case IEEE80211_PARAM_DTIM_PERIOD:
1627 *               if (vap->iv_opmode != IEEE80211_M_HOSTAP &&
1628 *                   vap->iv_opmode != IEEE80211_M_IBSS)
1629 *                       return -EINVAL;
1630 *               if (IEEE80211_DTIM_MIN <= value &&
1631 *                   value <= IEEE80211_DTIM_MAX) {
1632 *                       vap->iv_dtim_period = value;
1633 *                       retv = ENETRESET;               // requires restart
1634 *               } else
1635 *                       retv = EINVAL;
1636 *               break;
1637 *       case IEEE80211_PARAM_BEACON_INTERVAL:
1638 *               if (vap->iv_opmode != IEEE80211_M_HOSTAP &&
1639 *                   vap->iv_opmode != IEEE80211_M_IBSS)
1640 *                       return -EINVAL;
1641 *               if (IEEE80211_BINTVAL_MIN <= value &&
1642 *                   value <= IEEE80211_BINTVAL_MAX) {
1643 *                       ic->ic_lintval = value;         // XXX multi-bss
1644 *                       retv = ENETRESET;               // requires restart
1645 *               } else
1646 *                       retv = EINVAL;
1647 *               break;
1648 *       case IEEE80211_PARAM_DOTH:
1649 *               if (value) {
1650 *                       ic->ic_flags |= IEEE80211_F_DOTH;
1651 *               }
1652 *               else
1653 *                       ic->ic_flags &= ~IEEE80211_F_DOTH;
1654 *               retv = ENETRESET;       // XXX: need something this drastic?
1655 *               break;
1656 *       case IEEE80211_PARAM_PWRTARGET:
1657 *               ic->ic_curchanmaxpwr = value;
1658 *               break;
1659 *       case IEEE80211_PARAM_GENREASSOC:
1660 *               IEEE80211_SEND_MGMT(vap->iv_bss,
1661 *                                       IEEE80211_FC0_SUBTYPE_REASSOC_REQ, 0);
1662 *               break;
1663 *       case IEEE80211_PARAM_COMPRESSION:
1664 *               retv = ieee80211_setathcap(vap, IEEE80211_ATHC_COMP, value);
1665 *               break;
1666 *    case IEEE80211_PARAM_WMM_AGGRMODE:
1667 *        retv = ieee80211_setathcap(vap, IEEE80211_ATHC_WME, value);
1668 *        break;
1669 *       case IEEE80211_PARAM_FF:
1670 *               retv = ieee80211_setathcap(vap, IEEE80211_ATHC_FF, value);
1671 *               break;
1672 *       case IEEE80211_PARAM_TURBO:
1673 *               retv = ieee80211_setathcap(vap, IEEE80211_ATHC_TURBOP, value);
1674 *               if (retv == ENETRESET) {
1675 *                       if(ieee80211_set_turbo(dev,value))
1676 *                                       return -EINVAL;
1677 *                       ieee80211_scan_flush(ic);
1678 *               }
1679 *               break;
1680 *       case IEEE80211_PARAM_XR:
1681 *               retv = ieee80211_setathcap(vap, IEEE80211_ATHC_XR, value);
1682 *               break;
1683 *       case IEEE80211_PARAM_BURST:
1684 *               retv = ieee80211_setathcap(vap, IEEE80211_ATHC_BURST, value);
1685 *               break;
1686 *       case IEEE80211_PARAM_AR:
1687 *               retv = ieee80211_setathcap(vap, IEEE80211_ATHC_AR, value);
1688 *               break;
1689 *       case IEEE80211_PARAM_PUREG:
1690 *               if (value)
1691 *                       vap->iv_flags |= IEEE80211_F_PUREG;
1692 *               else
1693 *                       vap->iv_flags &= ~IEEE80211_F_PUREG;
1694 *               // NB: reset only if we're operating on an 11g channel
1695 *               if (ic->ic_bsschan != IEEE80211_CHAN_ANYC &&
1696 *                   IEEE80211_IS_CHAN_ANYG(ic->ic_bsschan))
1697 *                       retv = ENETRESET;
1698 *               break;
1699 *       case IEEE80211_PARAM_WDS:
1700 *               if (value)
1701 *                       vap->iv_flags_ext |= IEEE80211_FEXT_WDS;
1702 *               else
1703 *                       vap->iv_flags_ext &= ~IEEE80211_FEXT_WDS;
1704 *               break;
1705 *       case IEEE80211_PARAM_BGSCAN:
1706 *               if (value) {
1707 *                       if ((vap->iv_caps & IEEE80211_C_BGSCAN) == 0)
1708 *                               return -EINVAL;
1709 *                       vap->iv_flags |= IEEE80211_F_BGSCAN;
1710 *               } else {
1711 *                       // XXX racey?
1712 *                       vap->iv_flags &= ~IEEE80211_F_BGSCAN;
1713 *                       ieee80211_cancel_scan(vap);     // anything current
1714 *               }
1715 *               break;
1716 *       case IEEE80211_PARAM_BGSCAN_IDLE:
1717 *               if (value >= IEEE80211_BGSCAN_IDLE_MIN)
1718 *                       vap->iv_bgscanidle = value*HZ/1000;
1719 *               else
1720 *                       retv = EINVAL;
1721 *               break;
1722 *       case IEEE80211_PARAM_BGSCAN_INTERVAL:
1723 *               if (value >= IEEE80211_BGSCAN_INTVAL_MIN)
1724 *                       vap->iv_bgscanintvl = value*HZ;
1725 *               else
1726 *                       retv = EINVAL;
1727 *               break;
1728 *       case IEEE80211_PARAM_MCAST_RATE:
1729 *               // units are in KILObits per second
1730 *               if (value >= 256 && value <= 54000)
1731 *                       vap->iv_mcast_rate = value;
1732 *               else
1733 *                       retv = EINVAL;
1734 *               break;
1735 *       case IEEE80211_PARAM_COVERAGE_CLASS:
1736 *               if (value >= 0 && value <= IEEE80211_COVERAGE_CLASS_MAX) {
1737 *                       ic->ic_coverageclass = value;
1738 *                       if (IS_UP_AUTO(vap))
1739 *                               ieee80211_new_state(vap, IEEE80211_S_SCAN, 0);
1740 *                       retv = 0;
1741 *               }
1742 *               else
1743 *                       retv = EINVAL;
1744 *               break;
1745 *       case IEEE80211_PARAM_COUNTRY_IE:
1746 *               if (value)
1747 *                       ic->ic_flags_ext |= IEEE80211_FEXT_COUNTRYIE;
1748 *               else
1749 *                       ic->ic_flags_ext &= ~IEEE80211_FEXT_COUNTRYIE;
1750 *               retv = ENETRESET;
1751 *               break;
1752 *       case IEEE80211_PARAM_REGCLASS:
1753 *               if (value)
1754 *                       ic->ic_flags_ext |= IEEE80211_FEXT_REGCLASS;
1755 *               else
1756 *                       ic->ic_flags_ext &= ~IEEE80211_FEXT_REGCLASS;
1757 *               retv = ENETRESET;
1758 *               break;
1759 *       case IEEE80211_PARAM_SCANVALID:
1760 *               vap->iv_scanvalid = value*HZ;
1761 *               break;
1762 *       case IEEE80211_PARAM_ROAM_RSSI_11A:
1763 *               vap->iv_roam.rssi11a = value;
1764 *               break;
1765 *       case IEEE80211_PARAM_ROAM_RSSI_11B:
1766 *               vap->iv_roam.rssi11bOnly = value;
1767 *               break;
1768 *       case IEEE80211_PARAM_ROAM_RSSI_11G:
1769 *               vap->iv_roam.rssi11b = value;
1770 *               break;
1771 *       case IEEE80211_PARAM_ROAM_RATE_11A:
1772 *               vap->iv_roam.rate11a = value;
1773 *               break;
1774 *       case IEEE80211_PARAM_ROAM_RATE_11B:
1775 *               vap->iv_roam.rate11bOnly = value;
1776 *               break;
1777 *       case IEEE80211_PARAM_ROAM_RATE_11G:
1778 *               vap->iv_roam.rate11b = value;
1779 *               break;
1780 *       case IEEE80211_PARAM_UAPSDINFO:
1781 *               if (vap->iv_opmode == IEEE80211_M_HOSTAP) {
1782 *                       if (ic->ic_caps & IEEE80211_C_UAPSD) {
1783 *                               if (value)
1784 *                                       IEEE80211_VAP_UAPSD_ENABLE(vap);
1785 *                               else
1786 *                                       IEEE80211_VAP_UAPSD_DISABLE(vap);
1787 *                               retv = ENETRESET;
1788 *                       }
1789 *               }
1790 *               else if (vap->iv_opmode == IEEE80211_M_STA) {
1791 *                       vap->iv_uapsdinfo = value;
1792 *                       IEEE80211_VAP_UAPSD_ENABLE(vap);
1793 *                       retv = ENETRESET;
1794 *               }
1795 *               break;
1796 *       case IEEE80211_PARAM_SLEEP:
1797 *               // XXX: Forced sleep for testing. Does not actually place the
1798 *               //      HW in sleep mode yet. this only makes sense for STAs.
1799 *
1800 *               if (value) {
1801 *                       // goto sleep
1802 *                       IEEE80211_VAP_GOTOSLEEP(vap);
1803 *               }
1804 *               else {
1805 *                       // wakeup
1806 *                       IEEE80211_VAP_WAKEUP(vap);
1807 *               }
1808 *               ieee80211_send_nulldata(ieee80211_ref_node(vap->iv_bss));
1809 *               break;
1810 *       case IEEE80211_PARAM_QOSNULL:
1811 *               // Force a QoS Null for testing.
1812 *               ieee80211_send_qosnulldata(vap->iv_bss, value);
1813 *               break;
1814 *       case IEEE80211_PARAM_PSPOLL:
1815 *               // Force a PS-POLL for testing.
1816 *               ieee80211_send_pspoll(vap->iv_bss);
1817 *               break;
1818 *       case IEEE80211_PARAM_EOSPDROP:
1819 *               if (vap->iv_opmode == IEEE80211_M_HOSTAP) {
1820 *                       if (value) IEEE80211_VAP_EOSPDROP_ENABLE(vap);
1821 *                       else IEEE80211_VAP_EOSPDROP_DISABLE(vap);
1822 *               }
1823 *               break;
1824 *       case IEEE80211_PARAM_MARKDFS:
1825 *               if (value)
1826 *                       ic->ic_flags_ext |= IEEE80211_FEXT_MARKDFS;
1827 *               else
1828 *                       ic->ic_flags_ext &= ~IEEE80211_FEXT_MARKDFS;
1829 *               break;
1830 *       case IEEE80211_PARAM_CHANBW:
1831 *               switch (value) {
1832 *                       case 0:
1833 *                               ic->ic_chanbwflag = 0;
1834 *                               break;
1835 *                       case 1:
1836 *                               ic->ic_chanbwflag = IEEE80211_CHAN_HALF;
1837 *                               break;
1838 *                       case 2:
1839 *                               ic->ic_chanbwflag = IEEE80211_CHAN_QUARTER;
1840 *                               break;
1841 *                       default:
1842 *                               retv = EINVAL;
1843 *                               break;
1844 *               }
1845 *               break;
1846 *       case IEEE80211_PARAM_SHORTPREAMBLE:
1847 *               if (value) {
1848 *                       ic->ic_caps |= IEEE80211_C_SHPREAMBLE;
1849 *               } else {
1850 *                       ic->ic_caps &= ~IEEE80211_C_SHPREAMBLE;
1851 *               }
1852 *               retv = ENETRESET;
1853 *               break;
1854 *       default:
1855 *               retv = EOPNOTSUPP;
1856 *               break;
1857 *       }
1858 *       // XXX should any of these cause a rescan?
1859 *       if (retv == ENETRESET)
1860 *               retv = IS_UP_AUTO(vap) ? ieee80211_open(vap->iv_dev) : 0;
1861 *       return -retv;
1862 *}
1863 */
1864
1865 int usbdrvwext_setmode(struct net_device *dev, struct iw_request_info *info,
1866                         void *w, char *extra)
1867 {
1868         return 0;
1869 }
1870
1871 int usbdrvwext_getmode(struct net_device *dev, struct iw_request_info *info,
1872                         void *w, char *extra)
1873 {
1874         /* struct usbdrv_private *macp = dev->ml_priv; */
1875         struct iw_point *wri = (struct iw_point *)extra;
1876         char mode[8];
1877
1878         strcpy(mode, "11g");
1879         return copy_to_user(wri->pointer, mode, 6) ? -EFAULT : 0;
1880 }
1881
1882 int zfLnxPrivateIoctl(struct net_device *dev, struct zdap_ioctl* zdreq)
1883 {
1884         /* void* regp = macp->regp; */
1885         u16_t cmd;
1886         /* u32_t temp; */
1887         u32_t *p;
1888         u32_t i;
1889
1890         cmd = zdreq->cmd;
1891         switch (cmd) {
1892         case ZM_IOCTL_REG_READ:
1893                 zfiDbgReadReg(dev, zdreq->addr);
1894                 break;
1895         case ZM_IOCTL_REG_WRITE:
1896                 zfiDbgWriteReg(dev, zdreq->addr, zdreq->value);
1897                 break;
1898         case ZM_IOCTL_MEM_READ:
1899                 p = (u32_t *) bus_to_virt(zdreq->addr);
1900                 printk(KERN_WARNING
1901                                 "usbdrv: read memory addr: 0x%08x value:"
1902                                 " 0x%08x\n", zdreq->addr, *p);
1903                 break;
1904         case ZM_IOCTL_MEM_WRITE:
1905                 p = (u32_t *) bus_to_virt(zdreq->addr);
1906                 *p = zdreq->value;
1907                 printk(KERN_WARNING
1908                         "usbdrv : write value : 0x%08x to memory addr :"
1909                         " 0x%08x\n", zdreq->value, zdreq->addr);
1910                 break;
1911         case ZM_IOCTL_TALLY:
1912                 zfiWlanShowTally(dev);
1913                 if (zdreq->addr)
1914                         zfiWlanResetTally(dev);
1915                 break;
1916         case ZM_IOCTL_TEST:
1917                 printk(KERN_WARNING
1918                                 "ZM_IOCTL_TEST:len=%d\n", zdreq->addr);
1919                 /* zfiWlanReadReg(dev, 0x10f400); */
1920                 /* zfiWlanReadReg(dev, 0x10f404); */
1921                 printk(KERN_WARNING "IOCTL TEST\n");
1922                 #if 1
1923                 /* print packet */
1924                 for (i = 0; i < zdreq->addr; i++) {
1925                         if ((i&0x7) == 0)
1926                                 printk(KERN_WARNING "\n");
1927                         printk(KERN_WARNING "%02X ",
1928                                         (unsigned char)zdreq->data[i]);
1929                 }
1930                 printk(KERN_WARNING "\n");
1931                 #endif
1932
1933                 /* For Test?? 1 to 0 by CWYang(-) */
1934                 #if 0
1935                         struct sk_buff *s;
1936
1937                         /* Allocate a skb */
1938                         s = alloc_skb(2000, GFP_ATOMIC);
1939
1940                         /* Copy data to skb */
1941                         for (i = 0; i < zdreq->addr; i++)
1942                                 s->data[i] = zdreq->data[i];
1943                         s->len = zdreq->addr;
1944
1945                         /* Call zfIdlRecv() */
1946                         zfiRecv80211(dev, s, NULL);
1947                 #endif
1948                 break;
1949         /************************* ZDCONFIG ***************************/
1950         case ZM_IOCTL_FRAG:
1951                 zfiWlanSetFragThreshold(dev, zdreq->addr);
1952                 break;
1953         case ZM_IOCTL_RTS:
1954                 zfiWlanSetRtsThreshold(dev, zdreq->addr);
1955                 break;
1956         case ZM_IOCTL_SCAN:
1957                 zfiWlanScan(dev);
1958                 break;
1959         case ZM_IOCTL_KEY: {
1960                 u8_t key[29];
1961                 struct zsKeyInfo keyInfo;
1962                 u32_t i;
1963
1964                 for (i = 0; i < 29; i++)
1965                         key[i] = 0;
1966
1967                 for (i = 0; i < zdreq->addr; i++)
1968                         key[i] = zdreq->data[i];
1969
1970                 printk(KERN_WARNING
1971                         "key len=%d, key=%02x%02x%02x%02x%02x...\n",
1972                         zdreq->addr, key[0], key[1], key[2], key[3], key[4]);
1973
1974                 keyInfo.keyLength = zdreq->addr;
1975                 keyInfo.keyIndex = 0;
1976                 keyInfo.flag = 0;
1977                 keyInfo.key = key;
1978                 zfiWlanSetKey(dev, keyInfo);
1979         }
1980                 break;
1981         case ZM_IOCTL_RATE:
1982                 zfiWlanSetTxRate(dev, zdreq->addr);
1983                 break;
1984         case ZM_IOCTL_ENCRYPTION_MODE:
1985                 zfiWlanSetEncryMode(dev, zdreq->addr);
1986
1987                 zfiWlanDisable(dev, 0);
1988                 zfiWlanEnable(dev);
1989                 break;
1990                 /* CWYang(+) */
1991         case ZM_IOCTL_SIGNAL_STRENGTH: {
1992                 u8_t buffer[2];
1993                 zfiWlanQuerySignalInfo(dev, &buffer[0]);
1994                 printk(KERN_WARNING
1995                         "Current Signal Strength : %02d\n", buffer[0]);
1996         }
1997                 break;
1998                 /* CWYang(+) */
1999         case ZM_IOCTL_SIGNAL_QUALITY: {
2000                 u8_t buffer[2];
2001                 zfiWlanQuerySignalInfo(dev, &buffer[0]);
2002                 printk(KERN_WARNING
2003                         "Current Signal Quality : %02d\n", buffer[1]);
2004         }
2005                 break;
2006         case ZM_IOCTL_SET_PIBSS_MODE:
2007                 if (zdreq->addr == 1)
2008                         zfiWlanSetWlanMode(dev, ZM_MODE_PSEUDO);
2009                 else
2010                         zfiWlanSetWlanMode(dev, ZM_MODE_INFRASTRUCTURE);
2011
2012                 zfiWlanDisable(dev, 0);
2013                 zfiWlanEnable(dev);
2014                 break;
2015         /********************* ZDCONFIG ***********************/
2016         default:
2017                 printk(KERN_ERR "usbdrv: error command = %x\n", cmd);
2018                 break;
2019         }
2020
2021         return 0;
2022 }
2023
2024 int usbdrv_wpa_ioctl(struct net_device *dev, struct athr_wlan_param *zdparm)
2025 {
2026         int ret = 0;
2027         u8_t bc_addr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
2028         u8_t mac_addr[80];
2029         struct zsKeyInfo keyInfo;
2030         struct usbdrv_private *macp = dev->ml_priv;
2031         u16_t vapId = 0;
2032         int ii;
2033
2034         /* zmw_get_wlan_dev(dev); */
2035
2036         switch (zdparm->cmd) {
2037         case ZD_CMD_SET_ENCRYPT_KEY:
2038                 /* Set up key information */
2039                 keyInfo.keyLength = zdparm->u.crypt.key_len;
2040                 keyInfo.keyIndex = zdparm->u.crypt.idx;
2041                 if (zfiWlanQueryWlanMode(dev) == ZM_MODE_AP) {
2042                         /* AP Mode */
2043                         keyInfo.flag = ZM_KEY_FLAG_AUTHENTICATOR;
2044                 } else
2045                         keyInfo.flag = 0;
2046                 keyInfo.key = zdparm->u.crypt.key;
2047                 keyInfo.initIv = zdparm->u.crypt.seq;
2048                 keyInfo.macAddr = (u16_t *)zdparm->sta_addr;
2049
2050                 /* Identify the MAC address information */
2051                 if (memcmp(zdparm->sta_addr, bc_addr, sizeof(bc_addr)) == 0)
2052                         keyInfo.flag |= ZM_KEY_FLAG_GK;
2053                 else
2054                         keyInfo.flag |= ZM_KEY_FLAG_PK;
2055
2056                 if (!strcmp(zdparm->u.crypt.alg, "NONE")) {
2057                         /* u8_t zero_mac[]={0,0,0,0,0,0}; */
2058
2059                         /* Set key length to zero */
2060                         keyInfo.keyLength = 0;
2061
2062                         /* del group key */
2063                         if (zdparm->sta_addr[0] & 1) {
2064                                 /* if (macp->cardSetting.WPAIeLen==0)
2065                                 * { 802.1x dynamic WEP
2066                                 *    mDynKeyMode = 0;
2067                                 *    mKeyFormat[0] = 0;
2068                                 *    mPrivacyInvoked[0]=FALSE;
2069                                 *    mCap[0] &= ~CAP_PRIVACY;
2070                                 *    macp->cardSetting.EncryOnOff[0]=0;
2071                                 * }
2072                                 * mWpaBcKeyLen = mGkInstalled = 0;
2073                                 */
2074                         } else {
2075                                 /* if (memcmp(zero_mac,zdparm->sta_addr, 6)==0)
2076                                 * {
2077                                 *     mDynKeyMode=0;
2078                                 *    mKeyFormat[0]=0;
2079                                 *    pSetting->DynKeyMode=0;
2080                                 *    pSetting->EncryMode[0]=0;
2081                                 *    mDynKeyMode=0;
2082                                 * }
2083                                 */
2084                         }
2085
2086                         printk(KERN_ERR "Set Encryption Type NONE\n");
2087                         return ret;
2088                 } else if (!strcmp(zdparm->u.crypt.alg, "TKIP")) {
2089                         zfiWlanSetEncryMode(dev, ZM_TKIP);
2090                         /* //Linux Supplicant will inverse Tx/Rx key
2091                         * //So we inverse it back, CWYang(+)
2092                         * zfMemoryCopy(&temp[0], &keyInfo.key[16], 8);
2093                         * zfMemoryCopy(&keyInfo.key[16], keyInfo.key[24], 8);
2094                         * zfMemoryCopy(&keyInfo.key[24], &temp[0], 8);
2095                         * u8_t temp;
2096                         * int k;
2097                         * for (k = 0; k < 8; k++)
2098                         * {
2099                         *     temp = keyInfo.key[16 + k];
2100                         *     keyInfo.key[16 + k] = keyInfo.key[24 + k];
2101                         *     keyInfo.key[24 + k] = temp;
2102                         * }
2103                         * CamEncryType = ZM_TKIP;
2104                         * if (idx == 0)
2105                         * {   // Pairwise key
2106                         *     mKeyFormat[0] = CamEncryType;
2107                         *     mDynKeyMode = pSetting->DynKeyMode = DYN_KEY_TKIP;
2108                         * }
2109                         */
2110                 } else if (!strcmp(zdparm->u.crypt.alg, "CCMP")) {
2111                         zfiWlanSetEncryMode(dev, ZM_AES);
2112                         /* CamEncryType = ZM_AES;
2113                         * if (idx == 0)
2114                         * {  // Pairwise key
2115                         *    mKeyFormat[0] = CamEncryType;
2116                         *    mDynKeyMode = pSetting->DynKeyMode = DYN_KEY_AES;
2117                         * }
2118                         */
2119                 } else if (!strcmp(zdparm->u.crypt.alg, "WEP")) {
2120                         if (keyInfo.keyLength == 5) {
2121                                 /* WEP 64 */
2122                                 zfiWlanSetEncryMode(dev, ZM_WEP64);
2123                                 /* CamEncryType = ZM_WEP64; */
2124                                 /* tmpDynKeyMode=DYN_KEY_WEP64; */
2125                         } else if (keyInfo.keyLength == 13) {
2126                                 /* keylen=13, WEP 128 */
2127                                 zfiWlanSetEncryMode(dev, ZM_WEP128);
2128                                 /* CamEncryType = ZM_WEP128; */
2129                                 /* tmpDynKeyMode=DYN_KEY_WEP128; */
2130                         } else {
2131                                 zfiWlanSetEncryMode(dev, ZM_WEP256);
2132                         }
2133
2134         /* For Dynamic WEP key (Non-WPA Radius), the key ID range: 0-3
2135         * In WPA/RSN mode, the key ID range: 1-3, usually, a broadcast key.
2136         * For WEP key setting: we set mDynKeyMode and mKeyFormat in following
2137         * case:
2138         *   1. For 802.1x dynamically generated WEP key method.
2139         *   2. For WPA/RSN mode, but key id == 0.
2140         *       (But this is an impossible case)
2141         * So, only check case 1.
2142         * if (macp->cardSetting.WPAIeLen==0)
2143         * {
2144         *    mKeyFormat[0] = CamEncryType;
2145         *    mDynKeyMode = pSetting->DynKeyMode = tmpDynKeyMode;
2146         *    mPrivacyInvoked[0]=TRUE;
2147         *    mCap[0] |= CAP_PRIVACY;
2148         *    macp->cardSetting.EncryOnOff[0]=1;
2149         * }
2150         */
2151                 }
2152
2153                 /* DUMP key context */
2154                 /* #ifdef WPA_DEBUG */
2155                 if (keyInfo.keyLength > 0) {
2156                         printk(KERN_WARNING
2157                                                 "Otus: Key Context:\n");
2158                         for (ii = 0; ii < keyInfo.keyLength; ) {
2159                                 printk(KERN_WARNING
2160                                                 "0x%02x ", keyInfo.key[ii]);
2161                                 if ((++ii % 16) == 0)
2162                                         printk(KERN_WARNING "\n");
2163                         }
2164                         printk(KERN_WARNING "\n");
2165                 }
2166                 /* #endif */
2167
2168                 /* Set encrypt mode */
2169                 /* zfiWlanSetEncryMode(dev, CamEncryType); */
2170                 vapId = zfLnxGetVapId(dev);
2171                 if (vapId == 0xffff)
2172                         keyInfo.vapId = 0;
2173                 else
2174                         keyInfo.vapId = vapId + 1;
2175                 keyInfo.vapAddr[0] = keyInfo.macAddr[0];
2176                 keyInfo.vapAddr[1] = keyInfo.macAddr[1];
2177                 keyInfo.vapAddr[2] = keyInfo.macAddr[2];
2178
2179                 zfiWlanSetKey(dev, keyInfo);
2180
2181                 /* zfiWlanDisable(dev); */
2182                 /* zfiWlanEnable(dev); */
2183                 break;
2184         case ZD_CMD_SET_MLME:
2185                 printk(KERN_ERR "usbdrv_wpa_ioctl: ZD_CMD_SET_MLME\n");
2186
2187                 /* Translate STA's address */
2188                 sprintf(mac_addr, "%02x:%02x:%02x:%02x:%02x:%02x",
2189                         zdparm->sta_addr[0], zdparm->sta_addr[1],
2190                         zdparm->sta_addr[2], zdparm->sta_addr[3],
2191                         zdparm->sta_addr[4], zdparm->sta_addr[5]);
2192
2193                 switch (zdparm->u.mlme.cmd) {
2194                 case MLME_STA_DEAUTH:
2195                         printk(KERN_WARNING
2196                                 " -------Call zfiWlanDeauth, reason:%d\n",
2197                                 zdparm->u.mlme.reason_code);
2198                         if (zfiWlanDeauth(dev, (u16_t *) zdparm->sta_addr,
2199                                 zdparm->u.mlme.reason_code) != 0)
2200                                 printk(KERN_ERR "Can't deauthencate STA: %s\n",
2201                                         mac_addr);
2202                         else
2203                                 printk(KERN_ERR "Deauthenticate STA: %s"
2204                                         "with reason code: %d\n",
2205                                         mac_addr, zdparm->u.mlme.reason_code);
2206                         break;
2207                 case MLME_STA_DISASSOC:
2208                         printk(KERN_WARNING
2209                                 " -------Call zfiWlanDeauth, reason:%d\n",
2210                                 zdparm->u.mlme.reason_code);
2211                         if (zfiWlanDeauth(dev, (u16_t *) zdparm->sta_addr,
2212                                 zdparm->u.mlme.reason_code) != 0)
2213                                 printk(KERN_ERR "Can't disassociate STA: %s\n",
2214                                         mac_addr);
2215                         else
2216                                 printk(KERN_ERR "Disassociate STA: %s"
2217                                         "with reason code: %d\n",
2218                                         mac_addr, zdparm->u.mlme.reason_code);
2219                         break;
2220                 default:
2221                         printk(KERN_ERR "MLME command: 0x%04x not support\n",
2222                                 zdparm->u.mlme.cmd);
2223                         break;
2224                 }
2225
2226                 break;
2227         case ZD_CMD_SCAN_REQ:
2228                 printk(KERN_ERR "usbdrv_wpa_ioctl: ZD_CMD_SCAN_REQ\n");
2229                 break;
2230         case ZD_CMD_SET_GENERIC_ELEMENT: {
2231                 u8_t len, *wpaie;
2232                 printk(KERN_ERR "usbdrv_wpa_ioctl:"
2233                                         " ZD_CMD_SET_GENERIC_ELEMENT\n");
2234
2235                 /* Copy the WPA IE
2236                 * zm_msg1_mm(ZM_LV_0, "CWY - wpaie Length : ",
2237                 * zdparm->u.generic_elem.len);
2238                 */
2239                 printk(KERN_ERR "wpaie Length : % d\n",
2240                                                 zdparm->u.generic_elem.len);
2241                 if (zfiWlanQueryWlanMode(dev) == ZM_MODE_AP) {
2242                         /* AP Mode */
2243                         zfiWlanSetWpaIe(dev, zdparm->u.generic_elem.data,
2244                                         zdparm->u.generic_elem.len);
2245                 } else {
2246                         macp->supLen = zdparm->u.generic_elem.len;
2247                         memcpy(macp->supIe, zdparm->u.generic_elem.data,
2248                                 zdparm->u.generic_elem.len);
2249                 }
2250                 zfiWlanSetWpaSupport(dev, 1);
2251                 /* zfiWlanSetWpaIe(dev, zdparm->u.generic_elem.data,
2252                 * zdparm->u.generic_elem.len);
2253                 */
2254                 len = zdparm->u.generic_elem.len;
2255                 wpaie = zdparm->u.generic_elem.data;
2256
2257                 printk(KERN_ERR "wd->ap.wpaLen : % d\n", len);
2258
2259                 /* DUMP WPA IE */
2260                 for(ii = 0; ii < len;) {
2261                         printk(KERN_ERR "0x%02x ", wpaie[ii]);
2262
2263                         if((++ii % 16) == 0)
2264                                 printk(KERN_ERR "\n");
2265                 }
2266                 printk(KERN_ERR "\n");
2267
2268                 /* #ifdef ZM_HOSTAPD_SUPPORT
2269                 * if (wd->wlanMode == ZM_MODE_AP)
2270                 * {// Update Beacon FIFO in the next TBTT.
2271                 *     memcpy(&mWPAIe, pSetting->WPAIe, pSetting->WPAIeLen);
2272                 *     printk(KERN_ERR "Copy WPA IE into mWPAIe\n");
2273                 * }
2274                 * #endif
2275                 */
2276                 break;
2277         }
2278
2279         /* #ifdef ZM_HOSTAPD_SUPPORT */
2280         case ZD_CMD_GET_TSC:
2281                 printk(KERN_ERR "usbdrv_wpa_ioctl : ZD_CMD_GET_TSC\n");
2282                 break;
2283         /* #endif */
2284
2285         default:
2286                 printk(KERN_ERR "usbdrv_wpa_ioctl default : 0x%04x\n",
2287                         zdparm->cmd);
2288                 ret = -EINVAL;
2289                 break;
2290         }
2291
2292         return ret;
2293 }
2294
2295 #ifdef ZM_ENABLE_CENC
2296 int usbdrv_cenc_ioctl(struct net_device *dev, struct zydas_cenc_param *zdparm)
2297 {
2298         /* struct usbdrv_private *macp = dev->ml_priv; */
2299         struct zsKeyInfo keyInfo;
2300         u16_t apId;
2301         u8_t bc_addr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
2302         int ret = 0;
2303         int ii;
2304
2305         /* Get the AP Id */
2306         apId = zfLnxGetVapId(dev);
2307
2308         if (apId == 0xffff) {
2309                 apId = 0;
2310         } else {
2311                 apId = apId + 1;
2312         }
2313
2314         switch (zdparm->cmd) {
2315         case ZM_CMD_CENC_SETCENC:
2316                 printk(KERN_ERR "ZM_CMD_CENC_SETCENC\n");
2317                 printk(KERN_ERR "length : % d\n", zdparm->len);
2318                 printk(KERN_ERR "policy : % d\n", zdparm->u.info.cenc_policy);
2319                 break;
2320         case ZM_CMD_CENC_SETKEY:
2321                 /* ret = wai_ioctl_setkey(vap, ioctl_msg); */
2322                 printk(KERN_ERR "ZM_CMD_CENC_SETKEY\n");
2323
2324                 printk(KERN_ERR "MAC address = ");
2325                 for (ii = 0; ii < 6; ii++) {
2326                         printk(KERN_ERR "0x%02x ",
2327                                 zdparm->u.crypt.sta_addr[ii]);
2328                 }
2329                 printk(KERN_ERR "\n");
2330
2331                 printk(KERN_ERR "Key Index : % d\n", zdparm->u.crypt.keyid);
2332                 printk(KERN_ERR "Encryption key = ");
2333                 for (ii = 0; ii < 16; ii++) {
2334                         printk(KERN_ERR "0x%02x ", zdparm->u.crypt.key[ii]);
2335                 }
2336                 printk(KERN_ERR "\n");
2337
2338                 printk(KERN_ERR "MIC key = ");
2339                 for(ii = 16; ii < ZM_CENC_KEY_SIZE; ii++) {
2340                         printk(KERN_ERR "0x%02x ", zdparm->u.crypt.key[ii]);
2341                 }
2342                 printk(KERN_ERR "\n");
2343
2344                 /* Set up key information */
2345                 keyInfo.keyLength = ZM_CENC_KEY_SIZE;
2346                 keyInfo.keyIndex = zdparm->u.crypt.keyid;
2347                 keyInfo.flag = ZM_KEY_FLAG_AUTHENTICATOR | ZM_KEY_FLAG_CENC;
2348                 keyInfo.key = zdparm->u.crypt.key;
2349                 keyInfo.macAddr = (u16_t *)zdparm->u.crypt.sta_addr;
2350
2351                 /* Identify the MAC address information */
2352                 if (memcmp(zdparm->u.crypt.sta_addr, bc_addr,
2353                                 sizeof(bc_addr)) == 0) {
2354                         keyInfo.flag |= ZM_KEY_FLAG_GK;
2355                         keyInfo.vapId = apId;
2356                         memcpy(keyInfo.vapAddr, dev->dev_addr, ETH_ALEN);
2357                 } else {
2358                         keyInfo.flag |= ZM_KEY_FLAG_PK;
2359                 }
2360
2361                 zfiWlanSetKey(dev, keyInfo);
2362
2363                 break;
2364         case ZM_CMD_CENC_REKEY:
2365                 /* ret = wai_ioctl_rekey(vap, ioctl_msg); */
2366                 printk(KERN_ERR "ZM_CMD_CENC_REKEY\n");
2367                 break;
2368         default:
2369                 ret = -EOPNOTSUPP;
2370                 break;
2371         }
2372
2373         /* if (retv == ENETRESET) */
2374         /* retv = IS_UP_AUTO(vap) ? ieee80211_open(vap->iv_dev) : 0; */
2375
2376         return ret;
2377 }
2378 #endif /* ZM_ENABLE_CENC */
2379
2380 int usbdrv_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
2381 {
2382         /* struct usbdrv_private *macp; */
2383         /* void *regp; */
2384         struct zdap_ioctl zdreq;
2385         struct iwreq *wrq = (struct iwreq *)ifr;
2386         struct athr_wlan_param zdparm;
2387         struct usbdrv_private *macp = dev->ml_priv;
2388
2389         int err = 0, val = 0;
2390         int changed = 0;
2391
2392         /* regp = macp->regp; */
2393
2394         if (!netif_running(dev))
2395                 return -EINVAL;
2396
2397         switch (cmd) {
2398         case SIOCGIWNAME:
2399                 strcpy(wrq->u.name, "IEEE 802.11-DS");
2400                 break;
2401         case SIOCGIWAP:
2402                 err = usbdrvwext_giwap(dev, NULL, &wrq->u.ap_addr, NULL);
2403                 break;
2404         case SIOCSIWAP:
2405                 err = usbdrvwext_siwap(dev, NULL, &wrq->u.ap_addr, NULL);
2406                 break;
2407         case SIOCGIWMODE:
2408                 err = usbdrvwext_giwmode(dev, NULL, &wrq->u.mode, NULL);
2409                 break;
2410         case SIOCSIWESSID:
2411                 printk(KERN_ERR "CWY - usbdrvwext_siwessid\n");
2412                 /* err = usbdrv_ioctl_setessid(dev, &wrq->u.essid); */
2413                 err = usbdrvwext_siwessid(dev, NULL, &wrq->u.essid, NULL);
2414
2415                 if (!err)
2416                         changed = 1;
2417                 break;
2418         case SIOCGIWESSID:
2419                 err = usbdrvwext_giwessid(dev, NULL, &wrq->u.essid, NULL);
2420                 break;
2421         case SIOCSIWRTS:
2422                 err = usbdrv_ioctl_setrts(dev, &wrq->u.rts);
2423                 if (! err)
2424                         changed = 1;
2425                 break;
2426         /* set_auth */
2427         case SIOCIWFIRSTPRIV + 0x2: {
2428                 /* printk("CWY - SIOCIWFIRSTPRIV + 0x2(set_auth)\n"); */
2429                 if (!capable(CAP_NET_ADMIN)) {
2430                         err = -EPERM;
2431                         break;
2432                 }
2433                 val = *((int *) wrq->u.name);
2434                 if ((val < 0) || (val > 2)) {
2435                         err = -EINVAL;
2436                         break;
2437                 } else {
2438                         zfiWlanSetAuthenticationMode(dev, val);
2439
2440                         if (macp->DeviceOpened == 1) {
2441                                 zfiWlanDisable(dev, 0);
2442                                 zfiWlanEnable(dev);
2443                         }
2444
2445                         err = 0;
2446                         changed = 1;
2447                 }
2448         }
2449                 break;
2450         /* get_auth */
2451         case SIOCIWFIRSTPRIV + 0x3: {
2452                 int AuthMode = ZM_AUTH_MODE_OPEN;
2453
2454                 /* printk("CWY - SIOCIWFIRSTPRIV + 0x3(get_auth)\n"); */
2455
2456                 if (wrq->u.data.pointer) {
2457                         wrq->u.data.flags = 1;
2458
2459                         AuthMode = zfiWlanQueryAuthenticationMode(dev, 0);
2460                         if (AuthMode == ZM_AUTH_MODE_OPEN) {
2461                                 wrq->u.data.length = 12;
2462
2463                                 if (copy_to_user(wrq->u.data.pointer,
2464                                         "open system", 12)) {
2465                                                 return -EFAULT;
2466                                 }
2467                         } else if (AuthMode == ZM_AUTH_MODE_SHARED_KEY) {
2468                                 wrq->u.data.length = 11;
2469
2470                                 if (copy_to_user(wrq->u.data.pointer,
2471                                         "shared key", 11)) {
2472                                                         return -EFAULT;
2473                                 }
2474                         } else if (AuthMode == ZM_AUTH_MODE_AUTO) {
2475                                 wrq->u.data.length = 10;
2476
2477                                 if (copy_to_user(wrq->u.data.pointer,
2478                                         "auto mode", 10)) {
2479                                                         return -EFAULT;
2480                                 }
2481                         } else {
2482                                 return -EFAULT;
2483                         }
2484                 }
2485         }
2486                 break;
2487         /* debug command */
2488         case ZDAPIOCTL:
2489                 if (copy_from_user(&zdreq, ifr->ifr_data, sizeof(zdreq))) {
2490                         printk(KERN_ERR "usbdrv : copy_from_user error\n");
2491                         return -EFAULT;
2492                 }
2493
2494                 /* printk(KERN_WARNING
2495                 * "usbdrv : cmd = % 2x, reg = 0x%04lx,
2496                 *value = 0x%08lx\n",
2497                 * zdreq.cmd, zdreq.addr, zdreq.value);
2498                 */
2499                 zfLnxPrivateIoctl(dev, &zdreq);
2500
2501                 err = 0;
2502                 break;
2503         case ZD_IOCTL_WPA:
2504                 if (copy_from_user(&zdparm, ifr->ifr_data,
2505                         sizeof(struct athr_wlan_param))) {
2506                         printk(KERN_ERR "usbdrv : copy_from_user error\n");
2507                         return -EFAULT;
2508                 }
2509
2510                 usbdrv_wpa_ioctl(dev, &zdparm);
2511                 err = 0;
2512                 break;
2513         case ZD_IOCTL_PARAM: {
2514                 int *p;
2515                 int op;
2516                 int arg;
2517
2518                 /* Point to the name field and retrieve the
2519                 * op and arg elements.
2520                 */
2521                 p = (int *)wrq->u.name;
2522                 op = *p++;
2523                 arg = *p;
2524
2525                 if (op == ZD_PARAM_ROAMING) {
2526                         printk(KERN_ERR
2527                         "*************ZD_PARAM_ROAMING : % d\n", arg);
2528                         /* macp->cardSetting.ap_scan=(U8)arg; */
2529                 }
2530                 if (op == ZD_PARAM_PRIVACY) {
2531                         printk(KERN_ERR "ZD_IOCTL_PRIVACY : ");
2532
2533                         /* Turn on the privacy invoke flag */
2534                         if (arg) {
2535                                 /* mCap[0] |= CAP_PRIVACY; */
2536                                 /* macp->cardSetting.EncryOnOff[0] = 1; */
2537                                 printk(KERN_ERR "enable\n");
2538
2539                         } else {
2540                                 /* mCap[0] &= ~CAP_PRIVACY; */
2541                                 /* macp->cardSetting.EncryOnOff[0] = 0; */
2542                                 printk(KERN_ERR "disable\n");
2543                         }
2544                         /* changed=1; */
2545                 }
2546                 if (op == ZD_PARAM_WPA) {
2547
2548                 printk(KERN_ERR "ZD_PARAM_WPA : ");
2549
2550                 if (arg) {
2551                         printk(KERN_ERR "enable\n");
2552
2553                         if (zfiWlanQueryWlanMode(dev) != ZM_MODE_AP) {
2554                                 printk(KERN_ERR "Station Mode\n");
2555                                 /* zfiWlanQueryWpaIe(dev, (u8_t *)
2556                                         &wpaIe, &wpalen); */
2557                                 /* printk("wpaIe : % 2x, % 2x, % 2x\n",
2558                                         wpaIe[21], wpaIe[22], wpaIe[23]); */
2559                                 /* printk("rsnIe : % 2x, % 2x, % 2x\n",
2560                                         wpaIe[17], wpaIe[18], wpaIe[19]); */
2561                                 if ((macp->supIe[21] == 0x50) &&
2562                                         (macp->supIe[22] == 0xf2) &&
2563                                         (macp->supIe[23] == 0x2)) {
2564                                         printk(KERN_ERR
2565                                 "wd->sta.authMode = ZM_AUTH_MODE_WPAPSK\n");
2566                                 /* wd->sta.authMode = ZM_AUTH_MODE_WPAPSK; */
2567                                 /* wd->ws.authMode = ZM_AUTH_MODE_WPAPSK; */
2568                                 zfiWlanSetAuthenticationMode(dev,
2569                                                         ZM_AUTH_MODE_WPAPSK);
2570                                 } else if ((macp->supIe[21] == 0x50) &&
2571                                         (macp->supIe[22] == 0xf2) &&
2572                                         (macp->supIe[23] == 0x1)) {
2573                                         printk(KERN_ERR
2574                                 "wd->sta.authMode = ZM_AUTH_MODE_WPA\n");
2575                                 /* wd->sta.authMode = ZM_AUTH_MODE_WPA; */
2576                                 /* wd->ws.authMode = ZM_AUTH_MODE_WPA; */
2577                                 zfiWlanSetAuthenticationMode(dev,
2578                                                         ZM_AUTH_MODE_WPA);
2579                                         } else if ((macp->supIe[17] == 0xf) &&
2580                                                 (macp->supIe[18] == 0xac) &&
2581                                                 (macp->supIe[19] == 0x2))
2582                                         {
2583                                                 printk(KERN_ERR
2584                                 "wd->sta.authMode = ZM_AUTH_MODE_WPA2PSK\n");
2585                                 /* wd->sta.authMode = ZM_AUTH_MODE_WPA2PSK; */
2586                                 /* wd->ws.authMode = ZM_AUTH_MODE_WPA2PSK; */
2587                                 zfiWlanSetAuthenticationMode(dev,
2588                                 ZM_AUTH_MODE_WPA2PSK);
2589                         } else if ((macp->supIe[17] == 0xf) &&
2590                                 (macp->supIe[18] == 0xac) &&
2591                                 (macp->supIe[19] == 0x1))
2592                                 {
2593                                         printk(KERN_ERR
2594                                 "wd->sta.authMode = ZM_AUTH_MODE_WPA2\n");
2595                                 /* wd->sta.authMode = ZM_AUTH_MODE_WPA2; */
2596                                 /* wd->ws.authMode = ZM_AUTH_MODE_WPA2; */
2597                                 zfiWlanSetAuthenticationMode(dev,
2598                                                         ZM_AUTH_MODE_WPA2);
2599                         }
2600                         /* WPA or WPAPSK */
2601                         if ((macp->supIe[21] == 0x50) ||
2602                                 (macp->supIe[22] == 0xf2)) {
2603                                 if (macp->supIe[11] == 0x2) {
2604                                         printk(KERN_ERR
2605                                 "wd->sta.wepStatus = ZM_ENCRYPTION_TKIP\n");
2606                                 /* wd->sta.wepStatus = ZM_ENCRYPTION_TKIP; */
2607                                 /* wd->ws.wepStatus = ZM_ENCRYPTION_TKIP; */
2608                                 zfiWlanSetWepStatus(dev, ZM_ENCRYPTION_TKIP);
2609                         } else {
2610                                 printk(KERN_ERR
2611                                 "wd->sta.wepStatus = ZM_ENCRYPTION_AES\n");
2612                                 /* wd->sta.wepStatus = ZM_ENCRYPTION_AES; */
2613                                 /* wd->ws.wepStatus = ZM_ENCRYPTION_AES; */
2614                                 zfiWlanSetWepStatus(dev, ZM_ENCRYPTION_AES);
2615                                 }
2616                         }
2617                         //WPA2 or WPA2PSK
2618                         if ((macp->supIe[17] == 0xf) ||
2619                                 (macp->supIe[18] == 0xac)) {
2620                                 if (macp->supIe[13] == 0x2) {
2621                                         printk(KERN_ERR
2622                                 "wd->sta.wepStatus = ZM_ENCRYPTION_TKIP\n");
2623                                 /* wd->sta.wepStatus = ZM_ENCRYPTION_TKIP; */
2624                                 /* wd->ws.wepStatus = ZM_ENCRYPTION_TKIP; */
2625                                 zfiWlanSetWepStatus(dev, ZM_ENCRYPTION_TKIP);
2626                                 } else {
2627                                         printk(KERN_ERR
2628                                 "wd->sta.wepStatus = ZM_ENCRYPTION_AES\n");
2629                                 /* wd->sta.wepStatus = ZM_ENCRYPTION_AES; */
2630                                 /* wd->ws.wepStatus = ZM_ENCRYPTION_AES; */
2631                                 zfiWlanSetWepStatus(dev, ZM_ENCRYPTION_AES);
2632                                         }
2633                                 }
2634                         }
2635                         zfiWlanSetWpaSupport(dev, 1);
2636                 } else {
2637                         /* Reset the WPA related variables */
2638                         printk(KERN_ERR "disable\n");
2639
2640                         zfiWlanSetWpaSupport(dev, 0);
2641                         zfiWlanSetAuthenticationMode(dev, ZM_AUTH_MODE_OPEN);
2642                         zfiWlanSetWepStatus(dev, ZM_ENCRYPTION_WEP_DISABLED);
2643
2644                         /* Now we only set the length in the WPA IE
2645                         * field to zero.
2646                         *macp->cardSetting.WPAIe[1] = 0;
2647                         */
2648                         }
2649                 }
2650
2651                 if (op == ZD_PARAM_COUNTERMEASURES) {
2652                         printk(KERN_ERR
2653                                 "****************ZD_PARAM_COUNTERMEASURES : ");
2654
2655                         if(arg) {
2656                                 /*    mCounterMeasureState=1; */
2657                                 printk(KERN_ERR "enable\n");
2658                         } else {
2659                                 /*    mCounterMeasureState=0; */
2660                                 printk(KERN_ERR "disable\n");
2661                         }
2662                 }
2663                 if (op == ZD_PARAM_DROPUNENCRYPTED) {
2664                         printk(KERN_ERR "ZD_PARAM_DROPUNENCRYPTED : ");
2665
2666                         if(arg) {
2667                                 printk(KERN_ERR "enable\n");
2668                         } else {
2669                                 printk(KERN_ERR "disable\n");
2670                         }
2671                 }
2672                 if (op == ZD_PARAM_AUTH_ALGS) {
2673                         printk(KERN_ERR "ZD_PARAM_AUTH_ALGS : ");
2674
2675                         if (arg == 0) {
2676                                 printk(KERN_ERR "OPEN_SYSTEM\n");
2677                         } else {
2678                                 printk(KERN_ERR "SHARED_KEY\n");
2679                         }
2680                 }
2681                 if (op == ZD_PARAM_WPS_FILTER) {
2682                         printk(KERN_ERR "ZD_PARAM_WPS_FILTER : ");
2683
2684                         if (arg) {
2685                                 /*    mCounterMeasureState=1; */
2686                                 macp->forwardMgmt = 1;
2687                                 printk(KERN_ERR "enable\n");
2688                         } else {
2689                                 /*    mCounterMeasureState=0; */
2690                                 macp->forwardMgmt = 0;
2691                                 printk(KERN_ERR "disable\n");
2692                         }
2693                 }
2694         }
2695                 err = 0;
2696                 break;
2697         case ZD_IOCTL_GETWPAIE: {
2698                 struct ieee80211req_wpaie req_wpaie;
2699                 u16_t apId, i, j;
2700
2701                 /* Get the AP Id */
2702                 apId = zfLnxGetVapId(dev);
2703
2704                 if (apId == 0xffff) {
2705                         apId = 0;
2706                 } else {
2707                         apId = apId + 1;
2708                 }
2709
2710                 if (copy_from_user(&req_wpaie, ifr->ifr_data,
2711                                         sizeof(struct ieee80211req_wpaie))) {
2712                         printk(KERN_ERR "usbdrv : copy_from_user error\n");
2713                         return -EFAULT;
2714                 }
2715
2716                 for (i = 0; i < ZM_OAL_MAX_STA_SUPPORT; i++) {
2717                         for (j = 0; j < IEEE80211_ADDR_LEN; j++) {
2718                                 if (macp->stawpaie[i].wpa_macaddr[j] !=
2719                                                 req_wpaie.wpa_macaddr[j])
2720                                 break;
2721                         }
2722                         if (j == 6)
2723                         break;
2724                 }
2725
2726                 if (i < ZM_OAL_MAX_STA_SUPPORT) {
2727                 /* printk("ZD_IOCTL_GETWPAIE - sta index = % d\n", i); */
2728                 memcpy(req_wpaie.wpa_ie, macp->stawpaie[i].wpa_ie,
2729                                                         IEEE80211_MAX_IE_SIZE);
2730                 }
2731
2732                 if (copy_to_user(wrq->u.data.pointer, &req_wpaie,
2733                                 sizeof(struct ieee80211req_wpaie))) {
2734                         return -EFAULT;
2735                 }
2736         }
2737
2738                 err = 0;
2739                 break;
2740         #ifdef ZM_ENABLE_CENC
2741         case ZM_IOCTL_CENC:
2742                 if (copy_from_user(&macp->zd_wpa_req, ifr->ifr_data,
2743                         sizeof(struct athr_wlan_param))) {
2744                         printk(KERN_ERR "usbdrv : copy_from_user error\n");
2745                         return -EFAULT;
2746                 }
2747
2748                 usbdrv_cenc_ioctl(dev,
2749                                 (struct zydas_cenc_param *)&macp->zd_wpa_req);
2750                 err = 0;
2751                 break;
2752         #endif /* ZM_ENABLE_CENC */
2753         default:
2754                 err = -EOPNOTSUPP;
2755                 break;
2756         }
2757
2758         return err;
2759 }