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_mode(struct net_device *dev,
 126                                struct iw_request_info *a,
 127                                union iwreq_data *wrqu, char *b)
 128 {
 129         struct r8192_priv *priv = rtllib_priv(dev);
 130
 131         enum rt_rf_power_state rt_state;
 132         int ret;
 133
 134         if (priv->hw_radio_off)
 135                 return 0;
 136         rt_state = priv->rtllib->rf_power_state;
 137         mutex_lock(&priv->wx_mutex);
 138         if (wrqu->mode == IW_MODE_MONITOR) {
 139                 if (rt_state == rf_off) {
 140                         if (priv->rtllib->rf_off_reason >
 141                             RF_CHANGE_BY_IPS) {
 142                                 netdev_warn(dev, "%s(): RF is OFF.\n",
 143                                             __func__);
 144                                 mutex_unlock(&priv->wx_mutex);
 145                                 return -1;
 146                         }
 147                         netdev_info(dev,
 148                                     "=========>%s(): rtl92e_ips_leave\n",
 149                                     __func__);
 150                         mutex_lock(&priv->rtllib->ips_mutex);
 151                         rtl92e_ips_leave(dev);
 152                         mutex_unlock(&priv->rtllib->ips_mutex);
 153                 }
 154         }
 155         ret = rtllib_wx_set_mode(priv->rtllib, a, wrqu, b);
 156
 157         mutex_unlock(&priv->wx_mutex);
 158         return ret;
 159 }
 160
 161 static int _rtl92e_wx_get_range(struct net_device *dev,
 162                                 struct iw_request_info *info,
 163                                 union iwreq_data *wrqu, char *extra)
 164 {
 165         struct iw_range *range = (struct iw_range *)extra;
 166         struct r8192_priv *priv = rtllib_priv(dev);
 167         u16 val;
 168         int i;
 169
 170         wrqu->data.length = sizeof(*range);
 171         memset(range, 0, sizeof(*range));
 172
 173         /* ~130 Mb/s real (802.11n) */
 174         range->throughput = 130 * 1000 * 1000;
 175
 176         range->max_qual.qual = 100;
 177         range->max_qual.level = 0;
 178         range->max_qual.noise = 0;
 179         range->max_qual.updated = 7; /* Updated all three */
 180
 181         range->avg_qual.qual = 70; /* > 8% missed beacons is 'bad' */
 182         range->avg_qual.level = 0;
 183         range->avg_qual.noise = 0;
 184         range->avg_qual.updated = 7; /* Updated all three */
 185
 186         range->num_bitrates = min(RATE_COUNT, IW_MAX_BITRATES);
 187
 188         for (i = 0; i < range->num_bitrates; i++)
 189                 range->bitrate[i] = rtl8192_rates[i];
 190
 191         range->max_rts = DEFAULT_RTS_THRESHOLD;
 192         range->min_frag = MIN_FRAG_THRESHOLD;
 193         range->max_frag = MAX_FRAG_THRESHOLD;
 194
 195         range->min_pmp = 0;
 196         range->max_pmp = 5000000;
 197         range->min_pmt = 0;
 198         range->max_pmt = 65535 * 1000;
 199         range->pmp_flags = IW_POWER_PERIOD;
 200         range->pmt_flags = IW_POWER_TIMEOUT;
 201         range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
 202         range->we_version_compiled = WIRELESS_EXT;
 203         range->we_version_source = 18;
 204
 205         for (i = 0, val = 0; i < 14; i++) {
 206                 if ((priv->rtllib->active_channel_map)[i + 1]) {
 207                         s32 freq_khz;
 208
 209                         range->freq[val].i = i + 1;
 210                         freq_khz = ieee80211_channel_to_freq_khz(i + 1, NL80211_BAND_2GHZ);
 211                         range->freq[val].m = freq_khz * 100;
 212                         range->freq[val].e = 1;
 213                         val++;
 214                 }
 215
 216                 if (val == IW_MAX_FREQUENCIES)
 217                         break;
 218         }
 219         range->num_frequency = val;
 220         range->num_channels = val;
 221         range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
 222                           IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
 223         range->scan_capa = IW_SCAN_CAPA_ESSID | IW_SCAN_CAPA_TYPE;
 224
 225         /* Event capability (kernel + driver) */
 226
 227         return 0;
 228 }
 229
 230 static int _rtl92e_wx_set_scan(struct net_device *dev,
 231                                struct iw_request_info *a,
 232                                union iwreq_data *wrqu, char *b)
 233 {
 234         struct r8192_priv *priv = rtllib_priv(dev);
 235         struct rtllib_device *ieee = priv->rtllib;
 236         enum rt_rf_power_state rt_state;
 237         int ret;
 238
 239         if (!(ieee->softmac_features & IEEE_SOFTMAC_SCAN)) {
 240                 if ((ieee->link_state >= RTLLIB_ASSOCIATING) &&
 241                     (ieee->link_state <= RTLLIB_ASSOCIATING_AUTHENTICATED))
 242                         return 0;
 243                 if ((priv->rtllib->link_state == MAC80211_LINKED) &&
 244                     (priv->rtllib->CntAfterLink < 2))
 245                         return 0;
 246         }
 247
 248         if (priv->hw_radio_off) {
 249                 netdev_info(dev, "================>%s(): hwradio off\n",
 250                             __func__);
 251                 return 0;
 252         }
 253         rt_state = priv->rtllib->rf_power_state;
 254         if (!priv->up)
 255                 return -ENETDOWN;
 256         if (priv->rtllib->link_detect_info.bBusyTraffic)
 257                 return -EAGAIN;
 258
 259         if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
 260                 struct iw_scan_req *req = (struct iw_scan_req *)b;
 261
 262                 if (req->essid_len) {
 263                         int len = min_t(int, req->essid_len, IW_ESSID_MAX_SIZE);
 264
 265                         ieee->current_network.ssid_len = len;
 266                         memcpy(ieee->current_network.ssid, req->essid, len);
 267                 }
 268         }
 269
 270         mutex_lock(&priv->wx_mutex);
 271
 272         priv->rtllib->FirstIe_InScan = true;
 273
 274         if (priv->rtllib->link_state != MAC80211_LINKED) {
 275                 if (rt_state == rf_off) {
 276                         if (priv->rtllib->rf_off_reason >
 277                             RF_CHANGE_BY_IPS) {
 278                                 netdev_warn(dev, "%s(): RF is OFF.\n",
 279                                             __func__);
 280                                 mutex_unlock(&priv->wx_mutex);
 281                                 return -1;
 282                         }
 283                         mutex_lock(&priv->rtllib->ips_mutex);
 284                         rtl92e_ips_leave(dev);
 285                         mutex_unlock(&priv->rtllib->ips_mutex);
 286                 }
 287                 rtllib_stop_scan(priv->rtllib);
 288                 if (priv->rtllib->rf_power_state != rf_off) {
 289                         priv->rtllib->actscanning = true;
 290
 291                         ieee->ScanOperationBackupHandler(ieee->dev, SCAN_OPT_BACKUP);
 292
 293                         rtllib_start_scan_syncro(priv->rtllib);
 294
 295                         ieee->ScanOperationBackupHandler(ieee->dev, SCAN_OPT_RESTORE);
 296                 }
 297                 ret = 0;
 298         } else {
 299                 priv->rtllib->actscanning = true;
 300                 ret = rtllib_wx_set_scan(priv->rtllib, a, wrqu, b);
 301         }
 302
 303         mutex_unlock(&priv->wx_mutex);
 304         return ret;
 305 }
 306
 307 static int _rtl92e_wx_get_scan(struct net_device *dev,
 308                                struct iw_request_info *a,
 309                                union iwreq_data *wrqu, char *b)
 310 {
 311         int ret;
 312         struct r8192_priv *priv = rtllib_priv(dev);
 313
 314         if (!priv->up)
 315                 return -ENETDOWN;
 316
 317         if (priv->hw_radio_off)
 318                 return 0;
 319
 320         mutex_lock(&priv->wx_mutex);
 321
 322         ret = rtllib_wx_get_scan(priv->rtllib, a, wrqu, b);
 323
 324         mutex_unlock(&priv->wx_mutex);
 325
 326         return ret;
 327 }
 328
 329 static int _rtl92e_wx_set_essid(struct net_device *dev,
 330                                 struct iw_request_info *a,
 331                                 union iwreq_data *wrqu, char *b)
 332 {
 333         struct r8192_priv *priv = rtllib_priv(dev);
 334         int ret;
 335
 336         if (priv->hw_radio_off) {
 337                 netdev_info(dev,
 338                             "=========>%s():hw radio off,or Rf state is rf_off, return\n",
 339                             __func__);
 340                 return 0;
 341         }
 342         mutex_lock(&priv->wx_mutex);
 343         ret = rtllib_wx_set_essid(priv->rtllib, a, wrqu, b);
 344
 345         mutex_unlock(&priv->wx_mutex);
 346
 347         return ret;
 348 }
 349
 350 static int _rtl92e_wx_get_essid(struct net_device *dev,
 351                                 struct iw_request_info *a,
 352                                 union iwreq_data *wrqu, char *b)
 353 {
 354         int ret;
 355         struct r8192_priv *priv = rtllib_priv(dev);
 356
 357         mutex_lock(&priv->wx_mutex);
 358
 359         ret = rtllib_wx_get_essid(priv->rtllib, a, wrqu, b);
 360
 361         mutex_unlock(&priv->wx_mutex);
 362
 363         return ret;
 364 }
 365
 366 static int _rtl92e_wx_set_nick(struct net_device *dev,
 367                                struct iw_request_info *info,
 368                                union iwreq_data *wrqu, char *extra)
 369 {
 370         struct r8192_priv *priv = rtllib_priv(dev);
 371
 372         if (wrqu->data.length > IW_ESSID_MAX_SIZE)
 373                 return -E2BIG;
 374         mutex_lock(&priv->wx_mutex);
 375         wrqu->data.length = min_t(size_t, wrqu->data.length,
 376                                   sizeof(priv->nick));
 377         memset(priv->nick, 0, sizeof(priv->nick));
 378         memcpy(priv->nick, extra, wrqu->data.length);
 379         mutex_unlock(&priv->wx_mutex);
 380         return 0;
 381 }
 382
 383 static int _rtl92e_wx_get_nick(struct net_device *dev,
 384                                struct iw_request_info *info,
 385                                union iwreq_data *wrqu, char *extra)
 386 {
 387         struct r8192_priv *priv = rtllib_priv(dev);
 388
 389         mutex_lock(&priv->wx_mutex);
 390         wrqu->data.length = strlen(priv->nick);
 391         memcpy(extra, priv->nick, wrqu->data.length);
 392         wrqu->data.flags = 1;   /* active */
 393         mutex_unlock(&priv->wx_mutex);
 394         return 0;
 395 }
 396
 397 static int _rtl92e_wx_set_freq(struct net_device *dev,
 398                                struct iw_request_info *a,
 399                                union iwreq_data *wrqu, char *b)
 400 {
 401         int ret;
 402         struct r8192_priv *priv = rtllib_priv(dev);
 403
 404         if (priv->hw_radio_off)
 405                 return 0;
 406
 407         mutex_lock(&priv->wx_mutex);
 408
 409         ret = rtllib_wx_set_freq(priv->rtllib, a, wrqu, b);
 410
 411         mutex_unlock(&priv->wx_mutex);
 412         return ret;
 413 }
 414
 415 static int _rtl92e_wx_get_name(struct net_device *dev,
 416                                struct iw_request_info *info,
 417                                union iwreq_data *wrqu, char *extra)
 418 {
 419         struct r8192_priv *priv = rtllib_priv(dev);
 420
 421         return rtllib_wx_get_name(priv->rtllib, info, wrqu, extra);
 422 }
 423
 424 static int _rtl92e_wx_set_frag(struct net_device *dev,
 425                                struct iw_request_info *info,
 426                                union iwreq_data *wrqu, char *extra)
 427 {
 428         struct r8192_priv *priv = rtllib_priv(dev);
 429
 430         if (priv->hw_radio_off)
 431                 return 0;
 432
 433         if (wrqu->frag.disabled) {
 434                 priv->rtllib->fts = DEFAULT_FRAG_THRESHOLD;
 435         } else {
 436                 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
 437                     wrqu->frag.value > MAX_FRAG_THRESHOLD)
 438                         return -EINVAL;
 439
 440                 priv->rtllib->fts = wrqu->frag.value & ~0x1;
 441         }
 442
 443         return 0;
 444 }
 445
 446 static int _rtl92e_wx_get_frag(struct net_device *dev,
 447                                struct iw_request_info *info,
 448                                union iwreq_data *wrqu, char *extra)
 449 {
 450         struct r8192_priv *priv = rtllib_priv(dev);
 451
 452         wrqu->frag.value = priv->rtllib->fts;
 453         wrqu->frag.fixed = 0;   /* no auto select */
 454         wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FRAG_THRESHOLD);
 455
 456         return 0;
 457 }
 458
 459 static int _rtl92e_wx_set_wap(struct net_device *dev,
 460                               struct iw_request_info *info,
 461                               union iwreq_data *awrq, char *extra)
 462 {
 463         int ret;
 464         struct r8192_priv *priv = rtllib_priv(dev);
 465
 466         if (priv->hw_radio_off)
 467                 return 0;
 468
 469         mutex_lock(&priv->wx_mutex);
 470
 471         ret = rtllib_wx_set_wap(priv->rtllib, info, awrq, extra);
 472
 473         mutex_unlock(&priv->wx_mutex);
 474
 475         return ret;
 476 }
 477
 478 static int _rtl92e_wx_get_wap(struct net_device *dev,
 479                               struct iw_request_info *info,
 480                               union iwreq_data *wrqu, char *extra)
 481 {
 482         struct r8192_priv *priv = rtllib_priv(dev);
 483
 484         return rtllib_wx_get_wap(priv->rtllib, info, wrqu, extra);
 485 }
 486
 487 static int _rtl92e_wx_get_enc(struct net_device *dev,
 488                               struct iw_request_info *info,
 489                               union iwreq_data *wrqu, char *key)
 490 {
 491         struct r8192_priv *priv = rtllib_priv(dev);
 492
 493         return rtllib_wx_get_encode(priv->rtllib, info, wrqu, key);
 494 }
 495
 496 static int _rtl92e_wx_set_enc(struct net_device *dev,
 497                               struct iw_request_info *info,
 498                               union iwreq_data *wrqu, char *key)
 499 {
 500         struct r8192_priv *priv = rtllib_priv(dev);
 501         int ret;
 502
 503         struct rtllib_device *ieee = priv->rtllib;
 504         u32 hwkey[4] = {0, 0, 0, 0};
 505         u8 mask = 0xff;
 506         u32 key_idx = 0;
 507         u8 zero_addr[4][6] = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 508                              {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
 509                              {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
 510                              {0x00, 0x00, 0x00, 0x00, 0x00, 0x03} };
 511         int i;
 512
 513         if (priv->hw_radio_off)
 514                 return 0;
 515
 516         if (!priv->up)
 517                 return -ENETDOWN;
 518
 519         priv->rtllib->wx_set_enc = 1;
 520         mutex_lock(&priv->rtllib->ips_mutex);
 521         rtl92e_ips_leave(dev);
 522         mutex_unlock(&priv->rtllib->ips_mutex);
 523         mutex_lock(&priv->wx_mutex);
 524
 525         ret = rtllib_wx_set_encode(priv->rtllib, info, wrqu, key);
 526         mutex_unlock(&priv->wx_mutex);
 527
 528         if (wrqu->encoding.flags & IW_ENCODE_DISABLED) {
 529                 ieee->pairwise_key_type = ieee->group_key_type = KEY_TYPE_NA;
 530                 rtl92e_cam_reset(dev);
 531                 memset(priv->rtllib->swcamtable, 0,
 532                        sizeof(struct sw_cam_table) * 32);
 533                 goto end_hw_sec;
 534         }
 535         if (wrqu->encoding.length != 0) {
 536                 for (i = 0; i < 4; i++) {
 537                         hwkey[i] |=  key[4 * i + 0] & mask;
 538                         if (i == 1 && (4 * i + 1) == wrqu->encoding.length)
 539                                 mask = 0x00;
 540                         if (i == 3 && (4 * i + 1) == wrqu->encoding.length)
 541                                 mask = 0x00;
 542                         hwkey[i] |= (key[4 * i + 1] & mask) << 8;
 543                         hwkey[i] |= (key[4 * i + 2] & mask) << 16;
 544                         hwkey[i] |= (key[4 * i + 3] & mask) << 24;
 545                 }
 546
 547                 switch (wrqu->encoding.flags & IW_ENCODE_INDEX) {
 548                 case 0:
 549                         key_idx = ieee->crypt_info.tx_keyidx;
 550                         break;
 551                 case 1:
 552                         key_idx = 0;
 553                         break;
 554                 case 2:
 555                         key_idx = 1;
 556                         break;
 557                 case 3:
 558                         key_idx = 2;
 559                         break;
 560                 case 4:
 561                         key_idx = 3;
 562                         break;
 563                 default:
 564                         break;
 565                 }
 566                 if (wrqu->encoding.length == 0x5) {
 567                         ieee->pairwise_key_type = KEY_TYPE_WEP40;
 568                         rtl92e_enable_hw_security_config(dev);
 569                 }
 570
 571                 else if (wrqu->encoding.length == 0xd) {
 572                         ieee->pairwise_key_type = KEY_TYPE_WEP104;
 573                         rtl92e_enable_hw_security_config(dev);
 574                         rtl92e_set_key(dev, key_idx, key_idx, KEY_TYPE_WEP104,
 575                                        zero_addr[key_idx], 0, hwkey);
 576                         rtl92e_set_swcam(dev, key_idx, key_idx, KEY_TYPE_WEP104,
 577                                          zero_addr[key_idx], hwkey);
 578                 } else {
 579                         netdev_info(dev,
 580                                     "wrong type in WEP, not WEP40 and WEP104\n");
 581                 }
 582         }
 583
 584 end_hw_sec:
 585         priv->rtllib->wx_set_enc = 0;
 586         return ret;
 587 }
 588
 589 #define R8192_MAX_RETRY 255
 590 static int _rtl92e_wx_set_retry(struct net_device *dev,
 591                                 struct iw_request_info *info,
 592                                 union iwreq_data *wrqu, char *extra)
 593 {
 594         struct r8192_priv *priv = rtllib_priv(dev);
 595         int err = 0;
 596
 597         if (priv->hw_radio_off)
 598                 return 0;
 599
 600         mutex_lock(&priv->wx_mutex);
 601
 602         if (wrqu->retry.flags & IW_RETRY_LIFETIME ||
 603             wrqu->retry.disabled) {
 604                 err = -EINVAL;
 605                 goto exit;
 606         }
 607         if (!(wrqu->retry.flags & IW_RETRY_LIMIT)) {
 608                 err = -EINVAL;
 609                 goto exit;
 610         }
 611
 612         if (wrqu->retry.value > R8192_MAX_RETRY) {
 613                 err = -EINVAL;
 614                 goto exit;
 615         }
 616         if (wrqu->retry.flags & IW_RETRY_MAX)
 617                 priv->retry_rts = wrqu->retry.value;
 618         else
 619                 priv->retry_data = wrqu->retry.value;
 620
 621         rtl92e_commit(dev);
 622 exit:
 623         mutex_unlock(&priv->wx_mutex);
 624
 625         return err;
 626 }
 627
 628 static int _rtl92e_wx_get_retry(struct net_device *dev,
 629                                 struct iw_request_info *info,
 630                                 union iwreq_data *wrqu, char *extra)
 631 {
 632         struct r8192_priv *priv = rtllib_priv(dev);
 633
 634         wrqu->retry.disabled = 0; /* can't be disabled */
 635
 636         if ((wrqu->retry.flags & IW_RETRY_TYPE) ==
 637             IW_RETRY_LIFETIME)
 638                 return -EINVAL;
 639
 640         if (wrqu->retry.flags & IW_RETRY_MAX) {
 641                 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
 642                 wrqu->retry.value = priv->retry_rts;
 643         } else {
 644                 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN;
 645                 wrqu->retry.value = priv->retry_data;
 646         }
 647         return 0;
 648 }
 649
 650 static int _rtl92e_wx_set_encode_ext(struct net_device *dev,
 651                                      struct iw_request_info *info,
 652                                      union iwreq_data *wrqu, char *extra)
 653 {
 654         int ret = 0;
 655         struct r8192_priv *priv = rtllib_priv(dev);
 656         struct rtllib_device *ieee = priv->rtllib;
 657
 658         if (priv->hw_radio_off)
 659                 return 0;
 660
 661         mutex_lock(&priv->wx_mutex);
 662
 663         priv->rtllib->wx_set_enc = 1;
 664         mutex_lock(&priv->rtllib->ips_mutex);
 665         rtl92e_ips_leave(dev);
 666         mutex_unlock(&priv->rtllib->ips_mutex);
 667
 668         ret = rtllib_wx_set_encode_ext(ieee, info, wrqu, extra);
 669         {
 670                 const u8 broadcast_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 671                 const u8 zero[ETH_ALEN] = {0};
 672                 u32 key[4] = {0};
 673                 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
 674                 struct iw_point *encoding = &wrqu->encoding;
 675                 u8 idx = 0, alg = 0, group = 0;
 676
 677                 if ((encoding->flags & IW_ENCODE_DISABLED) ||
 678                      ext->alg == IW_ENCODE_ALG_NONE) {
 679                         ieee->pairwise_key_type = ieee->group_key_type
 680                                                 = KEY_TYPE_NA;
 681                         rtl92e_cam_reset(dev);
 682                         memset(priv->rtllib->swcamtable, 0,
 683                                sizeof(struct sw_cam_table) * 32);
 684                         goto end_hw_sec;
 685                 }
 686                 alg = (ext->alg == IW_ENCODE_ALG_CCMP) ? KEY_TYPE_CCMP :
 687                       ext->alg;
 688                 idx = encoding->flags & IW_ENCODE_INDEX;
 689                 if (idx)
 690                         idx--;
 691                 group = ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY;
 692
 693                 if ((!group) || (alg ==  KEY_TYPE_WEP40)) {
 694                         if ((ext->key_len == 13) && (alg == KEY_TYPE_WEP40))
 695                                 alg = KEY_TYPE_WEP104;
 696                         ieee->pairwise_key_type = alg;
 697                         rtl92e_enable_hw_security_config(dev);
 698                 }
 699                 memcpy((u8 *)key, ext->key, 16);
 700
 701                 if ((alg & KEY_TYPE_WEP40) && (ieee->auth_mode != 2)) {
 702                         if (ext->key_len == 13)
 703                                 ieee->pairwise_key_type = alg = KEY_TYPE_WEP104;
 704                         rtl92e_set_key(dev, idx, idx, alg, zero, 0, key);
 705                         rtl92e_set_swcam(dev, idx, idx, alg, zero, key);
 706                 } else if (group) {
 707                         ieee->group_key_type = alg;
 708                         rtl92e_set_key(dev, idx, idx, alg, broadcast_addr, 0,
 709                                        key);
 710                         rtl92e_set_swcam(dev, idx, idx, alg, broadcast_addr, key);
 711                 } else {
 712                         if ((ieee->pairwise_key_type == KEY_TYPE_CCMP) &&
 713                              ieee->ht_info->current_ht_support)
 714                                 rtl92e_writeb(dev, 0x173, 1);
 715                         rtl92e_set_key(dev, 4, idx, alg,
 716                                        (u8 *)ieee->ap_mac_addr, 0, key);
 717                         rtl92e_set_swcam(dev, 4, idx, alg, (u8 *)ieee->ap_mac_addr, key);
 718                 }
 719         }
 720
 721 end_hw_sec:
 722         priv->rtllib->wx_set_enc = 0;
 723         mutex_unlock(&priv->wx_mutex);
 724         return ret;
 725 }
 726
 727 static int _rtl92e_wx_set_auth(struct net_device *dev,
 728                                struct iw_request_info *info,
 729                                union iwreq_data *data, char *extra)
 730 {
 731         int ret = 0;
 732
 733         struct r8192_priv *priv = rtllib_priv(dev);
 734
 735         if (priv->hw_radio_off)
 736                 return 0;
 737
 738         mutex_lock(&priv->wx_mutex);
 739         ret = rtllib_wx_set_auth(priv->rtllib, info, &data->param, extra);
 740         mutex_unlock(&priv->wx_mutex);
 741         return ret;
 742 }
 743
 744 static int _rtl92e_wx_set_mlme(struct net_device *dev,
 745                                struct iw_request_info *info,
 746                                union iwreq_data *wrqu, char *extra)
 747 {
 748         int ret = 0;
 749
 750         struct r8192_priv *priv = rtllib_priv(dev);
 751
 752         if (priv->hw_radio_off)
 753                 return 0;
 754
 755         mutex_lock(&priv->wx_mutex);
 756         ret = rtllib_wx_set_mlme(priv->rtllib, info, wrqu, extra);
 757         mutex_unlock(&priv->wx_mutex);
 758         return ret;
 759 }
 760
 761 static int _rtl92e_wx_set_gen_ie(struct net_device *dev,
 762                                  struct iw_request_info *info,
 763                                  union iwreq_data *data, char *extra)
 764 {
 765         int ret = 0;
 766
 767         struct r8192_priv *priv = rtllib_priv(dev);
 768
 769         if (priv->hw_radio_off)
 770                 return 0;
 771
 772         mutex_lock(&priv->wx_mutex);
 773         ret = rtllib_wx_set_gen_ie(priv->rtllib, extra, data->data.length);
 774         mutex_unlock(&priv->wx_mutex);
 775         return ret;
 776 }
 777
 778 static int _rtl92e_wx_get_gen_ie(struct net_device *dev,
 779                                  struct iw_request_info *info,
 780                                  union iwreq_data *data, char *extra)
 781 {
 782         int ret = 0;
 783         struct r8192_priv *priv = rtllib_priv(dev);
 784         struct rtllib_device *ieee = priv->rtllib;
 785
 786         if (ieee->wpa_ie_len == 0 || !ieee->wpa_ie) {
 787                 data->data.length = 0;
 788                 return 0;
 789         }
 790
 791         if (data->data.length < ieee->wpa_ie_len)
 792                 return -E2BIG;
 793
 794         data->data.length = ieee->wpa_ie_len;
 795         memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
 796         return ret;
 797 }
 798
 799 #define IW_IOCTL(x) ((x) - SIOCSIWCOMMIT)
 800 static iw_handler r8192_wx_handlers[] = {
 801         [IW_IOCTL(SIOCGIWNAME)] = _rtl92e_wx_get_name,
 802         [IW_IOCTL(SIOCSIWFREQ)] = _rtl92e_wx_set_freq,
 803         [IW_IOCTL(SIOCGIWFREQ)] = _rtl92e_wx_get_freq,
 804         [IW_IOCTL(SIOCSIWMODE)] = _rtl92e_wx_set_mode,
 805         [IW_IOCTL(SIOCGIWMODE)] = _rtl92e_wx_get_mode,
 806         [IW_IOCTL(SIOCGIWRANGE)] = _rtl92e_wx_get_range,
 807         [IW_IOCTL(SIOCSIWAP)] = _rtl92e_wx_set_wap,
 808         [IW_IOCTL(SIOCGIWAP)] = _rtl92e_wx_get_wap,
 809         [IW_IOCTL(SIOCSIWSCAN)] = _rtl92e_wx_set_scan,
 810         [IW_IOCTL(SIOCGIWSCAN)] = _rtl92e_wx_get_scan,
 811         [IW_IOCTL(SIOCSIWESSID)] = _rtl92e_wx_set_essid,
 812         [IW_IOCTL(SIOCGIWESSID)] = _rtl92e_wx_get_essid,
 813         [IW_IOCTL(SIOCSIWNICKN)] = _rtl92e_wx_set_nick,
 814         [IW_IOCTL(SIOCGIWNICKN)] = _rtl92e_wx_get_nick,
 815         [IW_IOCTL(SIOCSIWRATE)] = _rtl92e_wx_set_rate,
 816         [IW_IOCTL(SIOCGIWRATE)] = _rtl92e_wx_get_rate,
 817         [IW_IOCTL(SIOCSIWRTS)] = _rtl92e_wx_set_rts,
 818         [IW_IOCTL(SIOCGIWRTS)] = _rtl92e_wx_get_rts,
 819         [IW_IOCTL(SIOCSIWFRAG)] = _rtl92e_wx_set_frag,
 820         [IW_IOCTL(SIOCGIWFRAG)] = _rtl92e_wx_get_frag,
 821         [IW_IOCTL(SIOCSIWRETRY)] = _rtl92e_wx_set_retry,
 822         [IW_IOCTL(SIOCGIWRETRY)] = _rtl92e_wx_get_retry,
 823         [IW_IOCTL(SIOCSIWENCODE)] = _rtl92e_wx_set_enc,
 824         [IW_IOCTL(SIOCGIWENCODE)] = _rtl92e_wx_get_enc,
 825         [IW_IOCTL(SIOCSIWPOWER)] = _rtl92e_wx_set_power,
 826         [IW_IOCTL(SIOCGIWPOWER)] = _rtl92e_wx_get_power,
 827         [IW_IOCTL(SIOCSIWGENIE)] = _rtl92e_wx_set_gen_ie,
 828         [IW_IOCTL(SIOCGIWGENIE)] = _rtl92e_wx_get_gen_ie,
 829         [IW_IOCTL(SIOCSIWMLME)] = _rtl92e_wx_set_mlme,
 830         [IW_IOCTL(SIOCSIWAUTH)] = _rtl92e_wx_set_auth,
 831         [IW_IOCTL(SIOCSIWENCODEEXT)] = _rtl92e_wx_set_encode_ext,
 832 };
 833
 834 static struct iw_statistics *_rtl92e_get_wireless_stats(struct net_device *dev)
 835 {
 836         struct r8192_priv *priv = rtllib_priv(dev);
 837         struct rtllib_device *ieee = priv->rtllib;
 838         struct iw_statistics *wstats = &priv->wstats;
 839         int tmp_level = 0;
 840         int tmp_qual = 0;
 841         int tmp_noise = 0;
 842
 843         if (ieee->link_state < MAC80211_LINKED) {
 844                 wstats->qual.qual = 10;
 845                 wstats->qual.level = 0;
 846                 wstats->qual.noise = 0x100 - 100;       /* -100 dBm */
 847                 wstats->qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
 848                 return wstats;
 849         }
 850
 851         tmp_level = (&ieee->current_network)->stats.rssi;
 852         tmp_qual = (&ieee->current_network)->stats.signal;
 853         tmp_noise = (&ieee->current_network)->stats.noise;
 854
 855         wstats->qual.level = tmp_level;
 856         wstats->qual.qual = tmp_qual;
 857         wstats->qual.noise = tmp_noise;
 858         wstats->qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
 859         return wstats;
 860 }
 861
 862 const struct iw_handler_def r8192_wx_handlers_def = {
 863         .standard = r8192_wx_handlers,
 864         .num_standard = ARRAY_SIZE(r8192_wx_handlers),
 865         .get_wireless_stats = _rtl92e_get_wireless_stats,
 866 };