drivers/staging/rtl8192e/rtl8192e/rtl_wx.c

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