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