drivers/staging/rtl8192e/rtl_wx.c

   1 /******************************************************************************
   2  * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
   3  *
   4  * This program is distributed in the hope that it will be useful, but WITHOUT
   5  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   6  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
   7  * more details.
   8  *
   9  * You should have received a copy of the GNU General Public License along with
  10  * this program; if not, write to the Free Software Foundation, Inc.,
  11  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  12  *
  13  * The full GNU General Public License is included in this distribution in the
  14  * file called LICENSE.
  15  *
  16  * Contact Information:
  17  * wlanfae <wlanfae@realtek.com>
  18 ******************************************************************************/
  19
  20 #include <linux/string.h>
  21 #include "rtl_core.h"
  22 #include "dot11d.h"
  23
  24 #define RATE_COUNT 12
  25 u32 rtl8192_rates[] = {
  26         1000000, 2000000, 5500000, 11000000, 6000000, 9000000, 12000000,
  27         18000000, 24000000, 36000000, 48000000, 54000000
  28 };
  29
  30 #ifndef ENETDOWN
  31 #define ENETDOWN 1
  32 #endif
  33
  34 static int r8192_wx_get_freq(struct net_device *dev,
  35                              struct iw_request_info *a,
  36                              union iwreq_data *wrqu, char *b)
  37 {
  38         struct r8192_priv *priv = rtllib_priv(dev);
  39
  40         return rtllib_wx_get_freq(priv->rtllib, a, wrqu, b);
  41 }
  42
  43
  44 static int r8192_wx_get_mode(struct net_device *dev, struct iw_request_info *a,
  45                              union iwreq_data *wrqu, char *b)
  46 {
  47         struct r8192_priv *priv = rtllib_priv(dev);
  48
  49         return rtllib_wx_get_mode(priv->rtllib, a, wrqu, b);
  50 }
  51
  52 static int r8192_wx_get_rate(struct net_device *dev,
  53                              struct iw_request_info *info,
  54                              union iwreq_data *wrqu, char *extra)
  55 {
  56         struct r8192_priv *priv = rtllib_priv(dev);
  57         return rtllib_wx_get_rate(priv->rtllib, info, wrqu, extra);
  58 }
  59
  60
  61
  62 static int r8192_wx_set_rate(struct net_device *dev,
  63                              struct iw_request_info *info,
  64                              union iwreq_data *wrqu, char *extra)
  65 {
  66         int ret;
  67         struct r8192_priv *priv = rtllib_priv(dev);
  68
  69         if (priv->bHwRadioOff == true)
  70                 return 0;
  71
  72         down(&priv->wx_sem);
  73
  74         ret = rtllib_wx_set_rate(priv->rtllib, info, wrqu, extra);
  75
  76         up(&priv->wx_sem);
  77
  78         return ret;
  79 }
  80
  81
  82 static int r8192_wx_set_rts(struct net_device *dev,
  83                              struct iw_request_info *info,
  84                              union iwreq_data *wrqu, char *extra)
  85 {
  86         int ret;
  87         struct r8192_priv *priv = rtllib_priv(dev);
  88
  89         if (priv->bHwRadioOff == true)
  90                 return 0;
  91
  92         down(&priv->wx_sem);
  93
  94         ret = rtllib_wx_set_rts(priv->rtllib, info, wrqu, extra);
  95
  96         up(&priv->wx_sem);
  97
  98         return ret;
  99 }
 100
 101 static int r8192_wx_get_rts(struct net_device *dev,
 102                              struct iw_request_info *info,
 103                              union iwreq_data *wrqu, char *extra)
 104 {
 105         struct r8192_priv *priv = rtllib_priv(dev);
 106         return rtllib_wx_get_rts(priv->rtllib, info, wrqu, extra);
 107 }
 108
 109 static int r8192_wx_set_power(struct net_device *dev,
 110                              struct iw_request_info *info,
 111                              union iwreq_data *wrqu, char *extra)
 112 {
 113         int ret;
 114         struct r8192_priv *priv = rtllib_priv(dev);
 115
 116         if (priv->bHwRadioOff == true) {
 117                 RT_TRACE(COMP_ERR, "%s():Hw is Radio Off, we can't set "
 118                          "Power,return\n", __func__);
 119                 return 0;
 120         }
 121         down(&priv->wx_sem);
 122
 123         ret = rtllib_wx_set_power(priv->rtllib, info, wrqu, extra);
 124
 125         up(&priv->wx_sem);
 126
 127         return ret;
 128 }
 129
 130 static int r8192_wx_get_power(struct net_device *dev,
 131                              struct iw_request_info *info,
 132                              union iwreq_data *wrqu, char *extra)
 133 {
 134         struct r8192_priv *priv = rtllib_priv(dev);
 135         return rtllib_wx_get_power(priv->rtllib, info, wrqu, extra);
 136 }
 137
 138 static int r8192_wx_set_rawtx(struct net_device *dev,
 139                               struct iw_request_info *info,
 140                               union iwreq_data *wrqu, char *extra)
 141 {
 142         struct r8192_priv *priv = rtllib_priv(dev);
 143         int ret;
 144
 145         if (priv->bHwRadioOff == true)
 146                 return 0;
 147
 148         down(&priv->wx_sem);
 149
 150         ret = rtllib_wx_set_rawtx(priv->rtllib, info, wrqu, extra);
 151
 152         up(&priv->wx_sem);
 153
 154         return ret;
 155
 156 }
 157
 158 static int r8192_wx_force_reset(struct net_device *dev,
 159                 struct iw_request_info *info,
 160                 union iwreq_data *wrqu, char *extra)
 161 {
 162         struct r8192_priv *priv = rtllib_priv(dev);
 163
 164         down(&priv->wx_sem);
 165
 166         RT_TRACE(COMP_DBG, "%s(): force reset ! extra is %d\n",
 167                  __func__, *extra);
 168         priv->force_reset = *extra;
 169         up(&priv->wx_sem);
 170         return 0;
 171
 172 }
 173
 174 static int r8192_wx_force_mic_error(struct net_device *dev,
 175                 struct iw_request_info *info,
 176                 union iwreq_data *wrqu, char *extra)
 177 {
 178         struct r8192_priv *priv = rtllib_priv(dev);
 179         struct rtllib_device *ieee = priv->rtllib;
 180
 181         down(&priv->wx_sem);
 182
 183         RT_TRACE(COMP_DBG, "%s(): force mic error !\n", __func__);
 184         ieee->force_mic_error = true;
 185         up(&priv->wx_sem);
 186         return 0;
 187
 188 }
 189
 190 #define MAX_ADHOC_PEER_NUM 64
 191 struct adhoc_peer_entry {
 192         unsigned char MacAddr[ETH_ALEN];
 193         unsigned char WirelessMode;
 194         unsigned char bCurTxBW40MHz;
 195 };
 196 struct adhoc_peers_info {
 197         struct adhoc_peer_entry Entry[MAX_ADHOC_PEER_NUM];
 198         unsigned char num;
 199 };
 200
 201 int r8192_wx_get_adhoc_peers(struct net_device *dev,
 202                              struct iw_request_info *info,
 203                              union iwreq_data *wrqu, char *extra)
 204 {
 205         return 0;
 206 }
 207
 208
 209 static int r8191se_wx_get_firm_version(struct net_device *dev,
 210                 struct iw_request_info *info,
 211                 struct iw_param *wrqu, char *extra)
 212 {
 213         return 0;
 214 }
 215
 216 static int r8192_wx_adapter_power_status(struct net_device *dev,
 217                 struct iw_request_info *info,
 218                 union iwreq_data *wrqu, char *extra)
 219 {
 220         struct r8192_priv *priv = rtllib_priv(dev);
 221         struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
 222                                         (&(priv->rtllib->PowerSaveControl));
 223         struct rtllib_device *ieee = priv->rtllib;
 224
 225         down(&priv->wx_sem);
 226
 227         RT_TRACE(COMP_POWER, "%s(): %s\n", __func__, (*extra == 6) ?
 228                  "DC power" : "AC power");
 229         if (*extra || priv->force_lps) {
 230                 priv->ps_force = false;
 231                 pPSC->bLeisurePs = true;
 232         } else {
 233                 if (priv->rtllib->state == RTLLIB_LINKED)
 234                         LeisurePSLeave(dev);
 235
 236                 priv->ps_force = true;
 237                 pPSC->bLeisurePs = false;
 238                 ieee->ps = *extra;
 239         }
 240
 241         up(&priv->wx_sem);
 242
 243         return 0;
 244 }
 245
 246 static int r8192se_wx_set_radio(struct net_device *dev,
 247         struct iw_request_info *info,
 248         union iwreq_data *wrqu, char *extra)
 249 {
 250         struct r8192_priv *priv = rtllib_priv(dev);
 251
 252         down(&priv->wx_sem);
 253
 254         printk(KERN_INFO "%s(): set radio ! extra is %d\n", __func__, *extra);
 255         if ((*extra != 0) && (*extra != 1)) {
 256                 RT_TRACE(COMP_ERR, "%s(): set radio an err value,must 0(radio "
 257                          "off) or 1(radio on)\n", __func__);
 258                 return -1;
 259         }
 260         priv->sw_radio_on = *extra;
 261         up(&priv->wx_sem);
 262         return 0;
 263
 264 }
 265
 266 static int r8192se_wx_set_lps_awake_interval(struct net_device *dev,
 267         struct iw_request_info *info,
 268         union iwreq_data *wrqu, char *extra)
 269 {
 270         struct r8192_priv *priv = rtllib_priv(dev);
 271         struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
 272                                         (&(priv->rtllib->PowerSaveControl));
 273
 274         down(&priv->wx_sem);
 275
 276         printk(KERN_INFO "%s(): set lps awake interval ! extra is %d\n",
 277                __func__, *extra);
 278
 279         pPSC->RegMaxLPSAwakeIntvl = *extra;
 280         up(&priv->wx_sem);
 281         return 0;
 282 }
 283
 284 static int r8192se_wx_set_force_lps(struct net_device *dev,
 285                 struct iw_request_info *info,
 286                 union iwreq_data *wrqu, char *extra)
 287 {
 288         struct r8192_priv *priv = rtllib_priv(dev);
 289
 290         down(&priv->wx_sem);
 291
 292         printk(KERN_INFO "%s(): force LPS ! extra is %d (1 is open 0 is "
 293                "close)\n", __func__, *extra);
 294         priv->force_lps = *extra;
 295         up(&priv->wx_sem);
 296         return 0;
 297
 298 }
 299
 300 static int r8192_wx_set_debugflag(struct net_device *dev,
 301                                   struct iw_request_info *info,
 302                                   union iwreq_data *wrqu, char *extra)
 303 {
 304         struct r8192_priv *priv = rtllib_priv(dev);
 305         u8 c = *extra;
 306
 307         if (priv->bHwRadioOff == true)
 308                 return 0;
 309
 310         printk(KERN_INFO "=====>%s(), *extra:%x, debugflag:%x\n", __func__,
 311                *extra, rt_global_debug_component);
 312         if (c > 0)
 313                 rt_global_debug_component |= (1<<c);
 314         else
 315                 rt_global_debug_component &= BIT31;
 316         return 0;
 317 }
 318
 319 static int r8192_wx_set_mode(struct net_device *dev, struct iw_request_info *a,
 320                              union iwreq_data *wrqu, char *b)
 321 {
 322         struct r8192_priv *priv = rtllib_priv(dev);
 323         struct rtllib_device *ieee = netdev_priv_rsl(dev);
 324
 325         enum rt_rf_power_state rtState;
 326         int ret;
 327
 328         if (priv->bHwRadioOff == true)
 329                 return 0;
 330         rtState = priv->rtllib->eRFPowerState;
 331         down(&priv->wx_sem);
 332         if (wrqu->mode == IW_MODE_ADHOC || wrqu->mode == IW_MODE_MONITOR ||
 333             ieee->bNetPromiscuousMode) {
 334                 if (priv->rtllib->PowerSaveControl.bInactivePs) {
 335                         if (rtState == eRfOff) {
 336                                 if (priv->rtllib->RfOffReason >
 337                                     RF_CHANGE_BY_IPS) {
 338                                         RT_TRACE(COMP_ERR, "%s(): RF is OFF.\n",
 339                                                  __func__);
 340                                         up(&priv->wx_sem);
 341                                         return -1;
 342                                 } else {
 343                                         printk(KERN_INFO "=========>%s(): "
 344                                                "IPSLeave\n", __func__);
 345                                         down(&priv->rtllib->ips_sem);
 346                                         IPSLeave(dev);
 347                                         up(&priv->rtllib->ips_sem);
 348                                 }
 349                         }
 350                 }
 351         }
 352         ret = rtllib_wx_set_mode(priv->rtllib, a, wrqu, b);
 353
 354         up(&priv->wx_sem);
 355         return ret;
 356 }
 357
 358 struct  iw_range_with_scan_capa {
 359         /* Informative stuff (to choose between different interface) */
 360         __u32      throughput;     /* To give an idea... */
 361         /* In theory this value should be the maximum benchmarked
 362          * TCP/IP throughput, because with most of these devices the
 363          * bit rate is meaningless (overhead an co) to estimate how
 364          * fast the connection will go and pick the fastest one.
 365          * I suggest people to play with Netperf or any benchmark...
 366          */
 367
 368         /* NWID (or domain id) */
 369         __u32      min_nwid;    /* Minimal NWID we are able to set */
 370         __u32      max_nwid;    /* Maximal NWID we are able to set */
 371
 372         /* Old Frequency (backward compat - moved lower ) */
 373         __u16      old_num_channels;
 374         __u8        old_num_frequency;
 375
 376         /* Scan capabilities */
 377         __u8        scan_capa;
 378 };
 379
 380 static int rtl8192_wx_get_range(struct net_device *dev,
 381                                 struct iw_request_info *info,
 382                                 union iwreq_data *wrqu, char *extra)
 383 {
 384         struct iw_range *range = (struct iw_range *)extra;
 385         struct r8192_priv *priv = rtllib_priv(dev);
 386         u16 val;
 387         int i;
 388
 389         wrqu->data.length = sizeof(*range);
 390         memset(range, 0, sizeof(*range));
 391
 392         /* ~130 Mb/s real (802.11n) */
 393         range->throughput = 130 * 1000 * 1000;
 394
 395         if (priv->rf_set_sens != NULL) {
 396                 /* signal level threshold range */
 397                 range->sensitivity = priv->max_sens;
 398         }
 399
 400         range->max_qual.qual = 100;
 401         range->max_qual.level = 0;
 402         range->max_qual.noise = 0;
 403         range->max_qual.updated = 7; /* Updated all three */
 404
 405         range->avg_qual.qual = 70; /* > 8% missed beacons is 'bad' */
 406         range->avg_qual.level = 0;
 407         range->avg_qual.noise = 0;
 408         range->avg_qual.updated = 7; /* Updated all three */
 409
 410         range->num_bitrates = min(RATE_COUNT, IW_MAX_BITRATES);
 411
 412         for (i = 0; i < range->num_bitrates; i++)
 413                 range->bitrate[i] = rtl8192_rates[i];
 414
 415         range->max_rts = DEFAULT_RTS_THRESHOLD;
 416         range->min_frag = MIN_FRAG_THRESHOLD;
 417         range->max_frag = MAX_FRAG_THRESHOLD;
 418
 419         range->min_pmp = 0;
 420         range->max_pmp = 5000000;
 421         range->min_pmt = 0;
 422         range->max_pmt = 65535*1000;
 423         range->pmp_flags = IW_POWER_PERIOD;
 424         range->pmt_flags = IW_POWER_TIMEOUT;
 425         range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
 426         range->we_version_compiled = WIRELESS_EXT;
 427         range->we_version_source = 18;
 428
 429         for (i = 0, val = 0; i < 14; i++) {
 430                 if ((priv->rtllib->active_channel_map)[i+1]) {
 431                         range->freq[val].i = i + 1;
 432                         range->freq[val].m = rtllib_wlan_frequencies[i] *
 433                                              100000;
 434                         range->freq[val].e = 1;
 435                         val++;
 436                 }
 437
 438                 if (val == IW_MAX_FREQUENCIES)
 439                         break;
 440         }
 441         range->num_frequency = val;
 442         range->num_channels = val;
 443         range->enc_capa = IW_ENC_CAPA_WPA|IW_ENC_CAPA_WPA2|
 444                           IW_ENC_CAPA_CIPHER_TKIP|IW_ENC_CAPA_CIPHER_CCMP;
 445         range->scan_capa = IW_SCAN_CAPA_ESSID | IW_SCAN_CAPA_TYPE;
 446
 447         /* Event capability (kernel + driver) */
 448
 449         return 0;
 450 }
 451
 452 static int r8192_wx_set_scan(struct net_device *dev, struct iw_request_info *a,
 453                              union iwreq_data *wrqu, char *b)
 454 {
 455         struct r8192_priv *priv = rtllib_priv(dev);
 456         struct rtllib_device *ieee = priv->rtllib;
 457         enum rt_rf_power_state rtState;
 458         int ret;
 459
 460         if (!(ieee->softmac_features & IEEE_SOFTMAC_SCAN)) {
 461                 if ((ieee->state >= RTLLIB_ASSOCIATING) &&
 462                     (ieee->state <= RTLLIB_ASSOCIATING_AUTHENTICATED))
 463                         return 0;
 464                 if ((priv->rtllib->state == RTLLIB_LINKED) &&
 465                     (priv->rtllib->CntAfterLink < 2))
 466                         return 0;
 467         }
 468
 469         if (priv->bHwRadioOff == true) {
 470                 printk(KERN_INFO "================>%s(): hwradio off\n",
 471                        __func__);
 472                 return 0;
 473         }
 474         rtState = priv->rtllib->eRFPowerState;
 475         if (!priv->up)
 476                 return -ENETDOWN;
 477         if (priv->rtllib->LinkDetectInfo.bBusyTraffic == true)
 478                 return -EAGAIN;
 479
 480         if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
 481                 struct iw_scan_req *req = (struct iw_scan_req *)b;
 482                 if (req->essid_len) {
 483                         ieee->current_network.ssid_len = req->essid_len;
 484                         memcpy(ieee->current_network.ssid, req->essid,
 485                                req->essid_len);
 486                 }
 487         }
 488
 489         down(&priv->wx_sem);
 490
 491         priv->rtllib->FirstIe_InScan = true;
 492
 493         if (priv->rtllib->state != RTLLIB_LINKED) {
 494                 if (priv->rtllib->PowerSaveControl.bInactivePs) {
 495                         if (rtState == eRfOff) {
 496                                 if (priv->rtllib->RfOffReason >
 497                                     RF_CHANGE_BY_IPS) {
 498                                         RT_TRACE(COMP_ERR, "%s(): RF is "
 499                                                  "OFF.\n", __func__);
 500                                         up(&priv->wx_sem);
 501                                         return -1;
 502                                 } else {
 503                                         RT_TRACE(COMP_PS, "=========>%s(): "
 504                                                  "IPSLeave\n", __func__);
 505                                         down(&priv->rtllib->ips_sem);
 506                                         IPSLeave(dev);
 507                                         up(&priv->rtllib->ips_sem);
 508                                 }
 509                         }
 510                 }
 511                 rtllib_stop_scan(priv->rtllib);
 512                 if (priv->rtllib->LedControlHandler)
 513                         priv->rtllib->LedControlHandler(dev,
 514                                                          LED_CTL_SITE_SURVEY);
 515
 516                 if (priv->rtllib->eRFPowerState != eRfOff) {
 517                         priv->rtllib->actscanning = true;
 518
 519                         if (ieee->ScanOperationBackupHandler)
 520                                 ieee->ScanOperationBackupHandler(ieee->dev,
 521                                                          SCAN_OPT_BACKUP);
 522
 523                         rtllib_start_scan_syncro(priv->rtllib, 0);
 524
 525                         if (ieee->ScanOperationBackupHandler)
 526                                 ieee->ScanOperationBackupHandler(ieee->dev,
 527                                                          SCAN_OPT_RESTORE);
 528                 }
 529                 ret = 0;
 530         } else {
 531                 priv->rtllib->actscanning = true;
 532                 ret = rtllib_wx_set_scan(priv->rtllib, a, wrqu, b);
 533         }
 534
 535         up(&priv->wx_sem);
 536         return ret;
 537 }
 538
 539
 540 static int r8192_wx_get_scan(struct net_device *dev, struct iw_request_info *a,
 541                              union iwreq_data *wrqu, char *b)
 542 {
 543
 544         int ret;
 545         struct r8192_priv *priv = rtllib_priv(dev);
 546
 547         if (!priv->up)
 548                 return -ENETDOWN;
 549
 550         if (priv->bHwRadioOff == true)
 551                 return 0;
 552
 553
 554         down(&priv->wx_sem);
 555
 556         ret = rtllib_wx_get_scan(priv->rtllib, a, wrqu, b);
 557
 558         up(&priv->wx_sem);
 559
 560         return ret;
 561 }
 562
 563 static int r8192_wx_set_essid(struct net_device *dev,
 564                               struct iw_request_info *a,
 565                               union iwreq_data *wrqu, char *b)
 566 {
 567         struct r8192_priv *priv = rtllib_priv(dev);
 568         int ret;
 569
 570         if ((rtllib_act_scanning(priv->rtllib, false)) &&
 571             !(priv->rtllib->softmac_features & IEEE_SOFTMAC_SCAN)) {
 572                 ;       /* TODO - get rid of if */
 573         }
 574         if (priv->bHwRadioOff == true) {
 575                 printk(KERN_INFO "=========>%s():hw radio off,or Rf state is "
 576                        "eRfOff, return\n", __func__);
 577                 return 0;
 578         }
 579         down(&priv->wx_sem);
 580         ret = rtllib_wx_set_essid(priv->rtllib, a, wrqu, b);
 581
 582         up(&priv->wx_sem);
 583
 584         return ret;
 585 }
 586
 587 static int r8192_wx_get_essid(struct net_device *dev,
 588                               struct iw_request_info *a,
 589                               union iwreq_data *wrqu, char *b)
 590 {
 591         int ret;
 592         struct r8192_priv *priv = rtllib_priv(dev);
 593
 594         down(&priv->wx_sem);
 595
 596         ret = rtllib_wx_get_essid(priv->rtllib, a, wrqu, b);
 597
 598         up(&priv->wx_sem);
 599
 600         return ret;
 601 }
 602
 603 static int r8192_wx_set_nick(struct net_device *dev,
 604                            struct iw_request_info *info,
 605                            union iwreq_data *wrqu, char *extra)
 606 {
 607         struct r8192_priv *priv = rtllib_priv(dev);
 608
 609         if (wrqu->data.length > IW_ESSID_MAX_SIZE)
 610                 return -E2BIG;
 611         down(&priv->wx_sem);
 612         wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
 613         memset(priv->nick, 0, sizeof(priv->nick));
 614         memcpy(priv->nick, extra, wrqu->data.length);
 615         up(&priv->wx_sem);
 616         return 0;
 617
 618 }
 619
 620 static int r8192_wx_get_nick(struct net_device *dev,
 621                              struct iw_request_info *info,
 622                              union iwreq_data *wrqu, char *extra)
 623 {
 624         struct r8192_priv *priv = rtllib_priv(dev);
 625
 626         down(&priv->wx_sem);
 627         wrqu->data.length = strlen(priv->nick);
 628         memcpy(extra, priv->nick, wrqu->data.length);
 629         wrqu->data.flags = 1;   /* active */
 630         up(&priv->wx_sem);
 631         return 0;
 632 }
 633
 634 static int r8192_wx_set_freq(struct net_device *dev, struct iw_request_info *a,
 635                              union iwreq_data *wrqu, char *b)
 636 {
 637         int ret;
 638         struct r8192_priv *priv = rtllib_priv(dev);
 639
 640         if (priv->bHwRadioOff == true)
 641                 return 0;
 642
 643         down(&priv->wx_sem);
 644
 645         ret = rtllib_wx_set_freq(priv->rtllib, a, wrqu, b);
 646
 647         up(&priv->wx_sem);
 648         return ret;
 649 }
 650
 651 static int r8192_wx_get_name(struct net_device *dev,
 652                              struct iw_request_info *info,
 653                              union iwreq_data *wrqu, char *extra)
 654 {
 655         struct r8192_priv *priv = rtllib_priv(dev);
 656         return rtllib_wx_get_name(priv->rtllib, info, wrqu, extra);
 657 }
 658
 659
 660 static int r8192_wx_set_frag(struct net_device *dev,
 661                              struct iw_request_info *info,
 662                              union iwreq_data *wrqu, char *extra)
 663 {
 664         struct r8192_priv *priv = rtllib_priv(dev);
 665
 666         if (priv->bHwRadioOff == true)
 667                 return 0;
 668
 669         if (wrqu->frag.disabled)
 670                 priv->rtllib->fts = DEFAULT_FRAG_THRESHOLD;
 671         else {
 672                 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
 673                     wrqu->frag.value > MAX_FRAG_THRESHOLD)
 674                         return -EINVAL;
 675
 676                 priv->rtllib->fts = wrqu->frag.value & ~0x1;
 677         }
 678
 679         return 0;
 680 }
 681
 682
 683 static int r8192_wx_get_frag(struct net_device *dev,
 684                              struct iw_request_info *info,
 685                              union iwreq_data *wrqu, char *extra)
 686 {
 687         struct r8192_priv *priv = rtllib_priv(dev);
 688
 689         wrqu->frag.value = priv->rtllib->fts;
 690         wrqu->frag.fixed = 0;   /* no auto select */
 691         wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FRAG_THRESHOLD);
 692
 693         return 0;
 694 }
 695
 696
 697 static int r8192_wx_set_wap(struct net_device *dev,
 698                          struct iw_request_info *info,
 699                          union iwreq_data *awrq,
 700                          char *extra)
 701 {
 702         int ret;
 703         struct r8192_priv *priv = rtllib_priv(dev);
 704
 705         if ((rtllib_act_scanning(priv->rtllib, false)) &&
 706             !(priv->rtllib->softmac_features & IEEE_SOFTMAC_SCAN)) {
 707                 ;       /* TODO - get rid of if */
 708         }
 709
 710         if (priv->bHwRadioOff == true)
 711                 return 0;
 712
 713         down(&priv->wx_sem);
 714
 715         ret = rtllib_wx_set_wap(priv->rtllib, info, awrq, extra);
 716
 717         up(&priv->wx_sem);
 718
 719         return ret;
 720
 721 }
 722
 723
 724 static int r8192_wx_get_wap(struct net_device *dev,
 725                             struct iw_request_info *info,
 726                             union iwreq_data *wrqu, char *extra)
 727 {
 728         struct r8192_priv *priv = rtllib_priv(dev);
 729
 730         return rtllib_wx_get_wap(priv->rtllib, info, wrqu, extra);
 731 }
 732
 733
 734 static int r8192_wx_get_enc(struct net_device *dev,
 735                             struct iw_request_info *info,
 736                             union iwreq_data *wrqu, char *key)
 737 {
 738         struct r8192_priv *priv = rtllib_priv(dev);
 739
 740         return rtllib_wx_get_encode(priv->rtllib, info, wrqu, key);
 741 }
 742
 743 static int r8192_wx_set_enc(struct net_device *dev,
 744                             struct iw_request_info *info,
 745                             union iwreq_data *wrqu, char *key)
 746 {
 747         struct r8192_priv *priv = rtllib_priv(dev);
 748         int ret;
 749
 750         struct rtllib_device *ieee = priv->rtllib;
 751         u32 hwkey[4] = {0, 0, 0, 0};
 752         u8 mask = 0xff;
 753         u32 key_idx = 0;
 754         u8 zero_addr[4][6] = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 755                              {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
 756                              {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
 757                              {0x00, 0x00, 0x00, 0x00, 0x00, 0x03} };
 758         int i;
 759
 760         if ((rtllib_act_scanning(priv->rtllib, false)) &&
 761            !(priv->rtllib->softmac_features & IEEE_SOFTMAC_SCAN))
 762                 ;       /* TODO - get rid of if */
 763         if (priv->bHwRadioOff == true)
 764                 return 0;
 765
 766         if (!priv->up)
 767                 return -ENETDOWN;
 768
 769         priv->rtllib->wx_set_enc = 1;
 770         down(&priv->rtllib->ips_sem);
 771         IPSLeave(dev);
 772         up(&priv->rtllib->ips_sem);
 773         down(&priv->wx_sem);
 774
 775         RT_TRACE(COMP_SEC, "Setting SW wep key");
 776         ret = rtllib_wx_set_encode(priv->rtllib, info, wrqu, key);
 777         up(&priv->wx_sem);
 778
 779
 780         if (wrqu->encoding.flags & IW_ENCODE_DISABLED) {
 781                 ieee->pairwise_key_type = ieee->group_key_type = KEY_TYPE_NA;
 782                 CamResetAllEntry(dev);
 783                 memset(priv->rtllib->swcamtable, 0,
 784                        sizeof(struct sw_cam_table) * 32);
 785                 goto end_hw_sec;
 786         }
 787         if (wrqu->encoding.length != 0) {
 788
 789                 for (i = 0; i < 4; i++) {
 790                         hwkey[i] |=  key[4*i+0]&mask;
 791                         if (i == 1 && (4 * i + 1) == wrqu->encoding.length)
 792                                 mask = 0x00;
 793                         if (i == 3 && (4 * i + 1) == wrqu->encoding.length)
 794                                 mask = 0x00;
 795                         hwkey[i] |= (key[4 * i + 1] & mask) << 8;
 796                         hwkey[i] |= (key[4 * i + 2] & mask) << 16;
 797                         hwkey[i] |= (key[4 * i + 3] & mask) << 24;
 798                 }
 799
 800                 #define CONF_WEP40  0x4
 801                 #define CONF_WEP104 0x14
 802
 803                 switch (wrqu->encoding.flags & IW_ENCODE_INDEX) {
 804                 case 0:
 805                         key_idx = ieee->tx_keyidx;
 806                         break;
 807                 case 1:
 808                         key_idx = 0;
 809                         break;
 810                 case 2:
 811                         key_idx = 1;
 812                         break;
 813                 case 3:
 814                         key_idx = 2;
 815                         break;
 816                 case 4:
 817                         key_idx = 3;
 818                         break;
 819                 default:
 820                         break;
 821                 }
 822                 if (wrqu->encoding.length == 0x5) {
 823                         ieee->pairwise_key_type = KEY_TYPE_WEP40;
 824                         EnableHWSecurityConfig8192(dev);
 825                 }
 826
 827                 else if (wrqu->encoding.length == 0xd) {
 828                         ieee->pairwise_key_type = KEY_TYPE_WEP104;
 829                                 EnableHWSecurityConfig8192(dev);
 830                         setKey(dev, key_idx, key_idx, KEY_TYPE_WEP104,
 831                                zero_addr[key_idx], 0, hwkey);
 832                         set_swcam(dev, key_idx, key_idx, KEY_TYPE_WEP104,
 833                                   zero_addr[key_idx], 0, hwkey, 0);
 834                 } else {
 835                          printk(KERN_INFO "wrong type in WEP, not WEP40 and WEP104\n");
 836                 }
 837         }
 838
 839 end_hw_sec:
 840         priv->rtllib->wx_set_enc = 0;
 841         return ret;
 842 }
 843
 844 static int r8192_wx_set_scan_type(struct net_device *dev,
 845                                   struct iw_request_info *aa,
 846                                   union iwreq_data *wrqu, char *p)
 847 {
 848         struct r8192_priv *priv = rtllib_priv(dev);
 849         int *parms = (int *)p;
 850         int mode = parms[0];
 851
 852         if (priv->bHwRadioOff == true)
 853                 return 0;
 854
 855         priv->rtllib->active_scan = mode;
 856
 857         return 1;
 858 }
 859
 860
 861
 862 #define R8192_MAX_RETRY 255
 863 static int r8192_wx_set_retry(struct net_device *dev,
 864                                 struct iw_request_info *info,
 865                                 union iwreq_data *wrqu, char *extra)
 866 {
 867         struct r8192_priv *priv = rtllib_priv(dev);
 868         int err = 0;
 869
 870         if (priv->bHwRadioOff == true)
 871                 return 0;
 872
 873         down(&priv->wx_sem);
 874
 875         if (wrqu->retry.flags & IW_RETRY_LIFETIME ||
 876             wrqu->retry.disabled) {
 877                 err = -EINVAL;
 878                 goto exit;
 879         }
 880         if (!(wrqu->retry.flags & IW_RETRY_LIMIT)) {
 881                 err = -EINVAL;
 882                 goto exit;
 883         }
 884
 885         if (wrqu->retry.value > R8192_MAX_RETRY) {
 886                 err = -EINVAL;
 887                 goto exit;
 888         }
 889         if (wrqu->retry.flags & IW_RETRY_MAX) {
 890                 priv->retry_rts = wrqu->retry.value;
 891                 DMESG("Setting retry for RTS/CTS data to %d",
 892                       wrqu->retry.value);
 893
 894         } else {
 895                 priv->retry_data = wrqu->retry.value;
 896                 DMESG("Setting retry for non RTS/CTS data to %d",
 897                       wrqu->retry.value);
 898         }
 899
 900
 901         rtl8192_commit(dev);
 902 exit:
 903         up(&priv->wx_sem);
 904
 905         return err;
 906 }
 907
 908 static int r8192_wx_get_retry(struct net_device *dev,
 909                                 struct iw_request_info *info,
 910                                 union iwreq_data *wrqu, char *extra)
 911 {
 912         struct r8192_priv *priv = rtllib_priv(dev);
 913
 914
 915         wrqu->retry.disabled = 0; /* can't be disabled */
 916
 917         if ((wrqu->retry.flags & IW_RETRY_TYPE) ==
 918             IW_RETRY_LIFETIME)
 919                 return -EINVAL;
 920
 921         if (wrqu->retry.flags & IW_RETRY_MAX) {
 922                 wrqu->retry.flags = IW_RETRY_LIMIT & IW_RETRY_MAX;
 923                 wrqu->retry.value = priv->retry_rts;
 924         } else {
 925                 wrqu->retry.flags = IW_RETRY_LIMIT & IW_RETRY_MIN;
 926                 wrqu->retry.value = priv->retry_data;
 927         }
 928         return 0;
 929 }
 930
 931 static int r8192_wx_get_sens(struct net_device *dev,
 932                              struct iw_request_info *info,
 933                              union iwreq_data *wrqu, char *extra)
 934 {
 935         struct r8192_priv *priv = rtllib_priv(dev);
 936         if (priv->rf_set_sens == NULL)
 937                 return -1; /* we have not this support for this radio */
 938         wrqu->sens.value = priv->sens;
 939         return 0;
 940 }
 941
 942
 943 static int r8192_wx_set_sens(struct net_device *dev,
 944                                 struct iw_request_info *info,
 945                                 union iwreq_data *wrqu, char *extra)
 946 {
 947
 948         struct r8192_priv *priv = rtllib_priv(dev);
 949
 950         short err = 0;
 951
 952         if (priv->bHwRadioOff == true)
 953                 return 0;
 954
 955         down(&priv->wx_sem);
 956         if (priv->rf_set_sens == NULL) {
 957                 err = -1; /* we have not this support for this radio */
 958                 goto exit;
 959         }
 960         if (priv->rf_set_sens(dev, wrqu->sens.value) == 0)
 961                 priv->sens = wrqu->sens.value;
 962         else
 963                 err = -EINVAL;
 964
 965 exit:
 966         up(&priv->wx_sem);
 967
 968         return err;
 969 }
 970
 971 static int r8192_wx_set_enc_ext(struct net_device *dev,
 972                                 struct iw_request_info *info,
 973                                 union iwreq_data *wrqu, char *extra)
 974 {
 975         int ret = 0;
 976         struct r8192_priv *priv = rtllib_priv(dev);
 977         struct rtllib_device *ieee = priv->rtllib;
 978
 979         if (priv->bHwRadioOff == true)
 980                 return 0;
 981
 982         down(&priv->wx_sem);
 983
 984         priv->rtllib->wx_set_enc = 1;
 985         down(&priv->rtllib->ips_sem);
 986         IPSLeave(dev);
 987         up(&priv->rtllib->ips_sem);
 988
 989         ret = rtllib_wx_set_encode_ext(ieee, info, wrqu, extra);
 990         {
 991                 u8 broadcast_addr[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 992                 u8 zero[6] = {0};
 993                 u32 key[4] = {0};
 994                 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
 995                 struct iw_point *encoding = &wrqu->encoding;
 996                 u8 idx = 0, alg = 0, group = 0;
 997                 if ((encoding->flags & IW_ENCODE_DISABLED) ||
 998                      ext->alg == IW_ENCODE_ALG_NONE) {
 999                         ieee->pairwise_key_type = ieee->group_key_type
1000                                                 = KEY_TYPE_NA;
1001                         CamResetAllEntry(dev);
1002                         memset(priv->rtllib->swcamtable, 0,
1003                                sizeof(struct sw_cam_table) * 32);
1004                         goto end_hw_sec;
1005                 }
1006                 alg = (ext->alg == IW_ENCODE_ALG_CCMP) ? KEY_TYPE_CCMP :
1007                       ext->alg;
1008                 idx = encoding->flags & IW_ENCODE_INDEX;
1009                 if (idx)
1010                         idx--;
1011                 group = ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY;
1012
1013                 if ((!group) || (IW_MODE_ADHOC == ieee->iw_mode) ||
1014                     (alg ==  KEY_TYPE_WEP40)) {
1015                         if ((ext->key_len == 13) && (alg == KEY_TYPE_WEP40))
1016                                 alg = KEY_TYPE_WEP104;
1017                         ieee->pairwise_key_type = alg;
1018                         EnableHWSecurityConfig8192(dev);
1019                 }
1020                 memcpy((u8 *)key, ext->key, 16);
1021
1022                 if ((alg & KEY_TYPE_WEP40) && (ieee->auth_mode != 2)) {
1023                         if (ext->key_len == 13)
1024                                 ieee->pairwise_key_type = alg = KEY_TYPE_WEP104;
1025                         setKey(dev, idx, idx, alg, zero, 0, key);
1026                         set_swcam(dev, idx, idx, alg, zero, 0, key, 0);
1027                 } else if (group) {
1028                         ieee->group_key_type = alg;
1029                         setKey(dev, idx, idx, alg, broadcast_addr, 0, key);
1030                         set_swcam(dev, idx, idx, alg, broadcast_addr, 0,
1031                                   key, 0);
1032                 } else {
1033                         if ((ieee->pairwise_key_type == KEY_TYPE_CCMP) &&
1034                              ieee->pHTInfo->bCurrentHTSupport)
1035                                 write_nic_byte(dev, 0x173, 1);
1036                         setKey(dev, 4, idx, alg, (u8 *)ieee->ap_mac_addr,
1037                                0, key);
1038                         set_swcam(dev, 4, idx, alg, (u8 *)ieee->ap_mac_addr,
1039                                   0, key, 0);
1040                 }
1041
1042
1043         }
1044
1045 end_hw_sec:
1046         priv->rtllib->wx_set_enc = 0;
1047         up(&priv->wx_sem);
1048         return ret;
1049
1050 }
1051 static int r8192_wx_set_auth(struct net_device *dev,
1052                              struct iw_request_info *info,
1053                              union iwreq_data *data, char *extra)
1054 {
1055         int ret = 0;
1056
1057         struct r8192_priv *priv = rtllib_priv(dev);
1058
1059         if (priv->bHwRadioOff == true)
1060                 return 0;
1061
1062         down(&priv->wx_sem);
1063         ret = rtllib_wx_set_auth(priv->rtllib, info, &(data->param), extra);
1064         up(&priv->wx_sem);
1065         return ret;
1066 }
1067
1068 static int r8192_wx_set_mlme(struct net_device *dev,
1069                              struct iw_request_info *info,
1070                              union iwreq_data *wrqu, char *extra)
1071 {
1072
1073         int ret = 0;
1074
1075         struct r8192_priv *priv = rtllib_priv(dev);
1076
1077         if (priv->bHwRadioOff == true)
1078                 return 0;
1079
1080         down(&priv->wx_sem);
1081         ret = rtllib_wx_set_mlme(priv->rtllib, info, wrqu, extra);
1082         up(&priv->wx_sem);
1083         return ret;
1084 }
1085
1086 static int r8192_wx_set_gen_ie(struct net_device *dev,
1087                                struct iw_request_info *info,
1088                                union iwreq_data *data, char *extra)
1089 {
1090         int ret = 0;
1091
1092         struct r8192_priv *priv = rtllib_priv(dev);
1093
1094         if (priv->bHwRadioOff == true)
1095                 return 0;
1096
1097         down(&priv->wx_sem);
1098         ret = rtllib_wx_set_gen_ie(priv->rtllib, extra, data->data.length);
1099         up(&priv->wx_sem);
1100         return ret;
1101 }
1102
1103 static int r8192_wx_get_gen_ie(struct net_device *dev,
1104                                struct iw_request_info *info,
1105                                union iwreq_data *data, char *extra)
1106 {
1107         int ret = 0;
1108         struct r8192_priv *priv = rtllib_priv(dev);
1109         struct rtllib_device *ieee = priv->rtllib;
1110
1111         if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
1112                 data->data.length = 0;
1113                 return 0;
1114         }
1115
1116         if (data->data.length < ieee->wpa_ie_len)
1117                 return -E2BIG;
1118
1119         data->data.length = ieee->wpa_ie_len;
1120         memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
1121         return ret;
1122 }
1123
1124 #define OID_RT_INTEL_PROMISCUOUS_MODE   0xFF0101F6
1125
1126 static int r8192_wx_set_PromiscuousMode(struct net_device *dev,
1127                 struct iw_request_info *info,
1128                 union iwreq_data *wrqu, char *extra)
1129 {
1130         struct r8192_priv *priv = rtllib_priv(dev);
1131         struct rtllib_device *ieee = priv->rtllib;
1132
1133         u32 *info_buf = (u32 *)(wrqu->data.pointer);
1134
1135         u32 oid = info_buf[0];
1136         u32 bPromiscuousOn = info_buf[1];
1137         u32 bFilterSourceStationFrame = info_buf[2];
1138
1139         if (OID_RT_INTEL_PROMISCUOUS_MODE == oid) {
1140                 ieee->IntelPromiscuousModeInfo.bPromiscuousOn =
1141                                         (bPromiscuousOn) ? (true) : (false);
1142                 ieee->IntelPromiscuousModeInfo.bFilterSourceStationFrame =
1143                         (bFilterSourceStationFrame) ? (true) : (false);
1144                         (bPromiscuousOn) ?
1145                         (rtllib_EnableIntelPromiscuousMode(dev, false)) :
1146                         (rtllib_DisableIntelPromiscuousMode(dev, false));
1147
1148                 printk(KERN_INFO "=======>%s(), on = %d, filter src sta = %d\n",
1149                        __func__, bPromiscuousOn, bFilterSourceStationFrame);
1150         } else {
1151                 return -1;
1152         }
1153
1154         return 0;
1155 }
1156
1157
1158 static int r8192_wx_get_PromiscuousMode(struct net_device *dev,
1159                                struct iw_request_info *info,
1160                                union iwreq_data *wrqu, char *extra)
1161 {
1162         struct r8192_priv *priv = rtllib_priv(dev);
1163         struct rtllib_device *ieee = priv->rtllib;
1164
1165         down(&priv->wx_sem);
1166
1167         snprintf(extra, 45, "PromiscuousMode:%d, FilterSrcSTAFrame:%d",
1168                  ieee->IntelPromiscuousModeInfo.bPromiscuousOn,
1169                  ieee->IntelPromiscuousModeInfo.bFilterSourceStationFrame);
1170         wrqu->data.length = strlen(extra) + 1;
1171
1172         up(&priv->wx_sem);
1173
1174         return 0;
1175 }
1176
1177
1178 #define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
1179 static iw_handler r8192_wx_handlers[] = {
1180         IW_IOCTL(SIOCGIWNAME) = r8192_wx_get_name,
1181         IW_IOCTL(SIOCSIWFREQ) = r8192_wx_set_freq,
1182         IW_IOCTL(SIOCGIWFREQ) = r8192_wx_get_freq,
1183         IW_IOCTL(SIOCSIWMODE) = r8192_wx_set_mode,
1184         IW_IOCTL(SIOCGIWMODE) = r8192_wx_get_mode,
1185         IW_IOCTL(SIOCSIWSENS) = r8192_wx_set_sens,
1186         IW_IOCTL(SIOCGIWSENS) = r8192_wx_get_sens,
1187         IW_IOCTL(SIOCGIWRANGE) = rtl8192_wx_get_range,
1188         IW_IOCTL(SIOCSIWAP) = r8192_wx_set_wap,
1189         IW_IOCTL(SIOCGIWAP) = r8192_wx_get_wap,
1190         IW_IOCTL(SIOCSIWSCAN) = r8192_wx_set_scan,
1191         IW_IOCTL(SIOCGIWSCAN) = r8192_wx_get_scan,
1192         IW_IOCTL(SIOCSIWESSID) = r8192_wx_set_essid,
1193         IW_IOCTL(SIOCGIWESSID) = r8192_wx_get_essid,
1194         IW_IOCTL(SIOCSIWNICKN) = r8192_wx_set_nick,
1195                 IW_IOCTL(SIOCGIWNICKN) = r8192_wx_get_nick,
1196         IW_IOCTL(SIOCSIWRATE) = r8192_wx_set_rate,
1197         IW_IOCTL(SIOCGIWRATE) = r8192_wx_get_rate,
1198         IW_IOCTL(SIOCSIWRTS) = r8192_wx_set_rts,
1199         IW_IOCTL(SIOCGIWRTS) = r8192_wx_get_rts,
1200         IW_IOCTL(SIOCSIWFRAG) = r8192_wx_set_frag,
1201         IW_IOCTL(SIOCGIWFRAG) = r8192_wx_get_frag,
1202         IW_IOCTL(SIOCSIWRETRY) = r8192_wx_set_retry,
1203         IW_IOCTL(SIOCGIWRETRY) = r8192_wx_get_retry,
1204         IW_IOCTL(SIOCSIWENCODE) = r8192_wx_set_enc,
1205         IW_IOCTL(SIOCGIWENCODE) = r8192_wx_get_enc,
1206         IW_IOCTL(SIOCSIWPOWER) = r8192_wx_set_power,
1207         IW_IOCTL(SIOCGIWPOWER) = r8192_wx_get_power,
1208         IW_IOCTL(SIOCSIWGENIE) = r8192_wx_set_gen_ie,
1209         IW_IOCTL(SIOCGIWGENIE) = r8192_wx_get_gen_ie,
1210         IW_IOCTL(SIOCSIWMLME) = r8192_wx_set_mlme,
1211         IW_IOCTL(SIOCSIWAUTH) = r8192_wx_set_auth,
1212         IW_IOCTL(SIOCSIWENCODEEXT) = r8192_wx_set_enc_ext,
1213 };
1214
1215 /*
1216  * the following rule need to be follwing,
1217  * Odd : get (world access),
1218  * even : set (root access)
1219  * */
1220 static const struct iw_priv_args r8192_private_args[] = {
1221         {
1222                 SIOCIWFIRSTPRIV + 0x0,
1223                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_debugflag"
1224         }, {
1225                 SIOCIWFIRSTPRIV + 0x1,
1226                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "activescan"
1227         }, {
1228                 SIOCIWFIRSTPRIV + 0x2,
1229                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "rawtx"
1230         }, {
1231                 SIOCIWFIRSTPRIV + 0x3,
1232                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "forcereset"
1233         }, {
1234                 SIOCIWFIRSTPRIV + 0x4,
1235                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "force_mic_error"
1236         }, {
1237                 SIOCIWFIRSTPRIV + 0x5,
1238                 IW_PRIV_TYPE_NONE, IW_PRIV_TYPE_INT|IW_PRIV_SIZE_FIXED|1,
1239                 "firm_ver"
1240         }, {
1241                 SIOCIWFIRSTPRIV + 0x6,
1242                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED|1, IW_PRIV_TYPE_NONE,
1243                 "set_power"
1244         }, {
1245                 SIOCIWFIRSTPRIV + 0x9,
1246                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED|1, IW_PRIV_TYPE_NONE,
1247                 "radio"
1248         }, {
1249                 SIOCIWFIRSTPRIV + 0xa,
1250                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED|1, IW_PRIV_TYPE_NONE,
1251                 "lps_interv"
1252         }, {
1253                 SIOCIWFIRSTPRIV + 0xb,
1254                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED|1, IW_PRIV_TYPE_NONE,
1255                 "lps_force"
1256         }, {
1257                 SIOCIWFIRSTPRIV + 0xc,
1258                 0, IW_PRIV_TYPE_CHAR|2047, "adhoc_peer_list"
1259         }, {
1260                 SIOCIWFIRSTPRIV + 0x16,
1261                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 3, 0, "setpromisc"
1262         }, {
1263                 SIOCIWFIRSTPRIV + 0x17,
1264                 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | 45, "getpromisc"
1265         }
1266
1267 };
1268
1269 static iw_handler r8192_private_handler[] = {
1270         (iw_handler)r8192_wx_set_debugflag,   /*SIOCIWSECONDPRIV*/
1271         (iw_handler)r8192_wx_set_scan_type,
1272         (iw_handler)r8192_wx_set_rawtx,
1273         (iw_handler)r8192_wx_force_reset,
1274         (iw_handler)r8192_wx_force_mic_error,
1275         (iw_handler)r8191se_wx_get_firm_version,
1276         (iw_handler)r8192_wx_adapter_power_status,
1277         (iw_handler)NULL,
1278         (iw_handler)NULL,
1279         (iw_handler)r8192se_wx_set_radio,
1280         (iw_handler)r8192se_wx_set_lps_awake_interval,
1281         (iw_handler)r8192se_wx_set_force_lps,
1282         (iw_handler)r8192_wx_get_adhoc_peers,
1283         (iw_handler)NULL,
1284         (iw_handler)NULL,
1285         (iw_handler)NULL,
1286         (iw_handler)NULL,
1287         (iw_handler)NULL,
1288         (iw_handler)NULL,
1289         (iw_handler)NULL,
1290         (iw_handler)NULL,
1291         (iw_handler)NULL,
1292         (iw_handler)r8192_wx_set_PromiscuousMode,
1293         (iw_handler)r8192_wx_get_PromiscuousMode,
1294 };
1295
1296 struct iw_statistics *r8192_get_wireless_stats(struct net_device *dev)
1297 {
1298         struct r8192_priv *priv = rtllib_priv(dev);
1299         struct rtllib_device *ieee = priv->rtllib;
1300         struct iw_statistics *wstats = &priv->wstats;
1301         int tmp_level = 0;
1302         int tmp_qual = 0;
1303         int tmp_noise = 0;
1304         if (ieee->state < RTLLIB_LINKED) {
1305                 wstats->qual.qual = 10;
1306                 wstats->qual.level = 0;
1307                 wstats->qual.noise = -100;
1308                 wstats->qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
1309                 return wstats;
1310         }
1311
1312         tmp_level = (&ieee->current_network)->stats.rssi;
1313         tmp_qual = (&ieee->current_network)->stats.signal;
1314         tmp_noise = (&ieee->current_network)->stats.noise;
1315
1316         wstats->qual.level = tmp_level;
1317         wstats->qual.qual = tmp_qual;
1318         wstats->qual.noise = tmp_noise;
1319         wstats->qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
1320         return wstats;
1321 }
1322
1323 struct iw_handler_def  r8192_wx_handlers_def = {
1324         .standard = r8192_wx_handlers,
1325         .num_standard = sizeof(r8192_wx_handlers) / sizeof(iw_handler),
1326         .private = r8192_private_handler,
1327         .num_private = sizeof(r8192_private_handler) / sizeof(iw_handler),
1328         .num_private_args = sizeof(r8192_private_args) /
1329                             sizeof(struct iw_priv_args),
1330         .get_wireless_stats = r8192_get_wireless_stats,
1331         .private_args = (struct iw_priv_args *)r8192_private_args,
1332 };