drivers/staging/rtl8712/rtl871x_ioctl_linux.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /******************************************************************************
   3  * rtl871x_ioctl_linux.c
   4  *
   5  * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
   6  * Linux device driver for RTL8192SU
   7  *
   8  * Modifications for inclusion into the Linux staging tree are
   9  * Copyright(c) 2010 Larry Finger. All rights reserved.
  10  *
  11  * Contact information:
  12  * WLAN FAE <wlanfae@realtek.com>
  13  * Larry Finger <Larry.Finger@lwfinger.net>
  14  *
  15  ******************************************************************************/
  16
  17 #define _RTL871X_IOCTL_LINUX_C_
  18 #define _RTL871X_MP_IOCTL_C_
  19
  20 #include "osdep_service.h"
  21 #include "drv_types.h"
  22 #include "wlan_bssdef.h"
  23 #include "rtl871x_debug.h"
  24 #include "wifi.h"
  25 #include "rtl871x_mlme.h"
  26 #include "rtl871x_ioctl.h"
  27 #include "rtl871x_ioctl_set.h"
  28 #include "rtl871x_mp_ioctl.h"
  29 #include "mlme_osdep.h"
  30 #include <linux/wireless.h>
  31 #include <linux/module.h>
  32 #include <linux/kernel.h>
  33 #include <linux/io.h>
  34 #include <linux/semaphore.h>
  35 #include <net/iw_handler.h>
  36 #include <linux/if_arp.h>
  37 #include <linux/etherdevice.h>
  38
  39 #define RTL_IOCTL_WPA_SUPPLICANT        (SIOCIWFIRSTPRIV + 0x1E)
  40
  41 #define SCAN_ITEM_SIZE 768
  42 #define MAX_CUSTOM_LEN 64
  43 #define RATE_COUNT 4
  44
  45 static const u32 rtl8180_rates[] = {1000000, 2000000, 5500000, 11000000,
  46                        6000000, 9000000, 12000000, 18000000,
  47                        24000000, 36000000, 48000000, 54000000};
  48
  49 static const long ieee80211_wlan_frequencies[] = {
  50         2412, 2417, 2422, 2427,
  51         2432, 2437, 2442, 2447,
  52         2452, 2457, 2462, 2467,
  53         2472, 2484
  54 };
  55
  56 void r8712_indicate_wx_assoc_event(struct _adapter *padapter)
  57 {
  58         union iwreq_data wrqu;
  59         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
  60
  61         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
  62         memcpy(wrqu.ap_addr.sa_data, pmlmepriv->cur_network.network.MacAddress, ETH_ALEN);
  63         wireless_send_event(padapter->pnetdev, SIOCGIWAP, &wrqu, NULL);
  64 }
  65
  66 void r8712_indicate_wx_disassoc_event(struct _adapter *padapter)
  67 {
  68         union iwreq_data wrqu;
  69
  70         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
  71         eth_zero_addr(wrqu.ap_addr.sa_data);
  72         wireless_send_event(padapter->pnetdev, SIOCGIWAP, &wrqu, NULL);
  73 }
  74
  75 static inline void handle_pairwise_key(struct sta_info *psta,
  76                                        struct ieee_param *param,
  77                                        struct _adapter *padapter)
  78 {
  79         /* pairwise key */
  80         memcpy(psta->x_UncstKey.skey, param->u.crypt.key,
  81                (param->u.crypt. key_len > 16 ? 16 : param->u.crypt.key_len));
  82         if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */
  83                 memcpy(psta->tkiptxmickey. skey,
  84                        &param->u.crypt.key[16], 8);
  85                 memcpy(psta->tkiprxmickey. skey,
  86                        &param->u.crypt.key[24], 8);
  87                 padapter->securitypriv. busetkipkey = false;
  88                 mod_timer(&padapter->securitypriv.tkip_timer,
  89                           jiffies + msecs_to_jiffies(50));
  90         }
  91         r8712_setstakey_cmd(padapter, (unsigned char *)psta, true);
  92 }
  93
  94 static inline void handle_group_key(struct ieee_param *param,
  95                                     struct _adapter *padapter)
  96 {
  97         union Keytype *gk = padapter->securitypriv.XGrpKey;
  98         union Keytype *gtk = padapter->securitypriv.XGrptxmickey;
  99         union Keytype *grk = padapter->securitypriv.XGrprxmickey;
 100
 101         if (param->u.crypt.idx > 0 &&
 102             param->u.crypt.idx < 3) {
 103                 /* group key idx is 1 or 2 */
 104                 memcpy(gk[param->u.crypt.idx - 1].skey,
 105                        param->u.crypt.key,
 106                        (param->u.crypt.key_len > 16 ? 16 :
 107                         param->u.crypt.key_len));
 108                 memcpy(gtk[param->u.crypt.idx - 1].skey,
 109                        &param->u.crypt.key[16], 8);
 110                 memcpy(grk[param->u.crypt.idx - 1].skey,
 111                        &param->u.crypt.key[24], 8);
 112                 padapter->securitypriv.binstallGrpkey = true;
 113                 r8712_set_key(padapter, &padapter->securitypriv, param->u.crypt.idx);
 114                 if (padapter->registrypriv.power_mgnt > PS_MODE_ACTIVE) {
 115                         if (padapter->registrypriv.power_mgnt != padapter->pwrctrlpriv.pwr_mode)
 116                                 mod_timer(&padapter->mlmepriv.dhcp_timer,
 117                                           jiffies + msecs_to_jiffies(60000));
 118                 }
 119         }
 120 }
 121
 122 static noinline_for_stack char *translate_scan_wpa(struct iw_request_info *info,
 123                                                    struct wlan_network *pnetwork,
 124                                                    struct iw_event *iwe,
 125                                                    char *start, char *stop)
 126 {
 127         /* parsing WPA/WPA2 IE */
 128         u8 buf[MAX_WPA_IE_LEN];
 129         u8 wpa_ie[255], rsn_ie[255];
 130         u16 wpa_len = 0, rsn_len = 0;
 131         int n, i;
 132
 133         r8712_get_sec_ie(pnetwork->network.IEs,
 134                          pnetwork->network.IELength, rsn_ie, &rsn_len,
 135                          wpa_ie, &wpa_len);
 136         if (wpa_len > 0) {
 137                 memset(buf, 0, MAX_WPA_IE_LEN);
 138                 n = sprintf(buf, "wpa_ie=");
 139                 for (i = 0; i < wpa_len; i++) {
 140                         n += scnprintf(buf + n, MAX_WPA_IE_LEN - n,
 141                                                 "%02x", wpa_ie[i]);
 142                         if (n == MAX_WPA_IE_LEN - 1)
 143                                 break;
 144                 }
 145                 memset(iwe, 0, sizeof(*iwe));
 146                 iwe->cmd = IWEVCUSTOM;
 147                 iwe->u.data.length = (u16)strlen(buf);
 148                 start = iwe_stream_add_point(info, start, stop, iwe, buf);
 149                 memset(iwe, 0, sizeof(*iwe));
 150                 iwe->cmd = IWEVGENIE;
 151                 iwe->u.data.length = (u16)wpa_len;
 152                 start = iwe_stream_add_point(info, start, stop, iwe, wpa_ie);
 153         }
 154         if (rsn_len > 0) {
 155                 memset(buf, 0, MAX_WPA_IE_LEN);
 156                 n = sprintf(buf, "rsn_ie=");
 157                 for (i = 0; i < rsn_len; i++) {
 158                         n += scnprintf(buf + n, MAX_WPA_IE_LEN - n,
 159                                                 "%02x", rsn_ie[i]);
 160                         if (n == MAX_WPA_IE_LEN - 1)
 161                                 break;
 162                 }
 163                 memset(iwe, 0, sizeof(*iwe));
 164                 iwe->cmd = IWEVCUSTOM;
 165                 iwe->u.data.length = strlen(buf);
 166                 start = iwe_stream_add_point(info, start, stop, iwe, buf);
 167                 memset(iwe, 0, sizeof(*iwe));
 168                 iwe->cmd = IWEVGENIE;
 169                 iwe->u.data.length = rsn_len;
 170                 start = iwe_stream_add_point(info, start, stop, iwe, rsn_ie);
 171         }
 172
 173         return start;
 174 }
 175
 176 static noinline_for_stack char *translate_scan_wps(struct iw_request_info *info,
 177                                                    struct wlan_network *pnetwork,
 178                                                    struct iw_event *iwe,
 179                                                    char *start, char *stop)
 180 {
 181         /* parsing WPS IE */
 182         u8 wps_ie[512];
 183         uint wps_ielen;
 184
 185         if (r8712_get_wps_ie(pnetwork->network.IEs, pnetwork->network.IELength, wps_ie, &wps_ielen)) {
 186                 if (wps_ielen > 2) {
 187                         iwe->cmd = IWEVGENIE;
 188                         iwe->u.data.length = (u16)wps_ielen;
 189                         start = iwe_stream_add_point(info, start, stop, iwe, wps_ie);
 190                 }
 191         }
 192
 193         return start;
 194 }
 195
 196 static char *translate_scan(struct _adapter *padapter,
 197                             struct iw_request_info *info,
 198                             struct wlan_network *pnetwork,
 199                             char *start, char *stop)
 200 {
 201         struct iw_event iwe;
 202         char *current_val;
 203         s8 *p;
 204         u32 i = 0, ht_ielen = 0;
 205         u16     cap, ht_cap = false;
 206         u8 rssi;
 207
 208         if ((pnetwork->network.Configuration.DSConfig < 1) ||
 209             (pnetwork->network.Configuration.DSConfig > 14)) {
 210                 if (pnetwork->network.Configuration.DSConfig < 1)
 211                         pnetwork->network.Configuration.DSConfig = 1;
 212                 else
 213                         pnetwork->network.Configuration.DSConfig = 14;
 214         }
 215         /* AP MAC address */
 216         iwe.cmd = SIOCGIWAP;
 217         iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
 218         ether_addr_copy(iwe.u.ap_addr.sa_data, pnetwork->network.MacAddress);
 219         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_ADDR_LEN);
 220         /* Add the ESSID */
 221         iwe.cmd = SIOCGIWESSID;
 222         iwe.u.data.flags = 1;
 223         iwe.u.data.length = min_t(u32, pnetwork->network.Ssid.SsidLength, 32);
 224         start = iwe_stream_add_point(info, start, stop, &iwe,
 225                                      pnetwork->network.Ssid.Ssid);
 226         /* parsing HT_CAP_IE */
 227         p = r8712_get_ie(&pnetwork->network.IEs[12], WLAN_EID_HT_CAPABILITY,
 228                          &ht_ielen, pnetwork->network.IELength - 12);
 229         if (p && ht_ielen > 0)
 230                 ht_cap = true;
 231         /* Add the protocol name */
 232         iwe.cmd = SIOCGIWNAME;
 233         if (r8712_is_cckratesonly_included(pnetwork->network.rates)) {
 234                 if (ht_cap)
 235                         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bn");
 236                 else
 237                         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11b");
 238         } else if (r8712_is_cckrates_included(pnetwork->network.rates)) {
 239                 if (ht_cap)
 240                         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bgn");
 241                 else
 242                         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bg");
 243         } else {
 244                 if (ht_cap)
 245                         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11gn");
 246                 else
 247                         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11g");
 248         }
 249         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_CHAR_LEN);
 250         /* Add mode */
 251         iwe.cmd = SIOCGIWMODE;
 252         memcpy((u8 *)&cap, r8712_get_capability_from_ie(pnetwork->network.IEs), 2);
 253         le16_to_cpus(&cap);
 254         if (cap & (WLAN_CAPABILITY_IBSS | WLAN_CAPABILITY_ESS)) {
 255                 if (cap & WLAN_CAPABILITY_ESS)
 256                         iwe.u.mode = (u32)IW_MODE_MASTER;
 257                 else
 258                         iwe.u.mode = (u32)IW_MODE_ADHOC;
 259                 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_UINT_LEN);
 260         }
 261         /* Add frequency/channel */
 262         iwe.cmd = SIOCGIWFREQ;
 263         {
 264                 /*  check legal index */
 265                 u8 dsconfig = pnetwork->network.Configuration.DSConfig;
 266
 267                 if (dsconfig >= 1 && dsconfig <= sizeof(ieee80211_wlan_frequencies) / sizeof(long))
 268                         iwe.u.freq.m = (s32)(ieee80211_wlan_frequencies[dsconfig - 1] * 100000);
 269                 else
 270                         iwe.u.freq.m = 0;
 271         }
 272         iwe.u.freq.e = (s16)1;
 273         iwe.u.freq.i = (u8)pnetwork->network.Configuration.DSConfig;
 274         start = iwe_stream_add_event(info, start, stop, &iwe,
 275                                      IW_EV_FREQ_LEN);
 276         /* Add encryption capability */
 277         iwe.cmd = SIOCGIWENCODE;
 278         if (cap & WLAN_CAPABILITY_PRIVACY)
 279                 iwe.u.data.flags = (u16)(IW_ENCODE_ENABLED | IW_ENCODE_NOKEY);
 280         else
 281                 iwe.u.data.flags = (u16)(IW_ENCODE_DISABLED);
 282         iwe.u.data.length = (u16)0;
 283         start = iwe_stream_add_point(info, start, stop, &iwe, pnetwork->network.Ssid.Ssid);
 284         /*Add basic and extended rates */
 285         current_val = start + iwe_stream_lcp_len(info);
 286         iwe.cmd = SIOCGIWRATE;
 287         iwe.u.bitrate.fixed = 0;
 288         iwe.u.bitrate.disabled = 0;
 289         iwe.u.bitrate.value = 0;
 290         i = 0;
 291         while (pnetwork->network.rates[i] != 0) {
 292                 /* Bit rate given in 500 kb/s units */
 293                 iwe.u.bitrate.value = (pnetwork->network.rates[i++] & 0x7F) * 500000;
 294                 current_val = iwe_stream_add_value(info, start, current_val, stop, &iwe,
 295                                                    IW_EV_PARAM_LEN);
 296         }
 297         /* Check if we added any event */
 298         if ((current_val - start) > iwe_stream_lcp_len(info))
 299                 start = current_val;
 300
 301         start = translate_scan_wpa(info, pnetwork, &iwe, start, stop);
 302
 303         start = translate_scan_wps(info, pnetwork, &iwe, start, stop);
 304
 305         /* Add quality statistics */
 306         iwe.cmd = IWEVQUAL;
 307         rssi = r8712_signal_scale_mapping(pnetwork->network.Rssi);
 308         /* we only update signal_level (signal strength) that is rssi. */
 309         iwe.u.qual.updated = (u8)(IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_INVALID);
 310         iwe.u.qual.level = rssi;  /* signal strength */
 311         iwe.u.qual.qual = 0; /* signal quality */
 312         iwe.u.qual.noise = 0; /* noise level */
 313         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_QUAL_LEN);
 314         /* how to translate rssi to ?% */
 315         return start;
 316 }
 317
 318 static int wpa_set_auth_algs(struct net_device *dev, u32 value)
 319 {
 320         struct _adapter *padapter = netdev_priv(dev);
 321         int ret = 0;
 322
 323         if ((value & AUTH_ALG_SHARED_KEY) && (value & AUTH_ALG_OPEN_SYSTEM)) {
 324                 padapter->securitypriv.ndisencryptstatus =
 325                                                  Ndis802_11Encryption1Enabled;
 326                 padapter->securitypriv.ndisauthtype =
 327                                                  Ndis802_11AuthModeAutoSwitch;
 328                 padapter->securitypriv.AuthAlgrthm = 3;
 329         } else if (value & AUTH_ALG_SHARED_KEY) {
 330                 padapter->securitypriv.ndisencryptstatus =
 331                                                  Ndis802_11Encryption1Enabled;
 332                 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeShared;
 333                 padapter->securitypriv.AuthAlgrthm = 1;
 334         } else if (value & AUTH_ALG_OPEN_SYSTEM) {
 335                 if (padapter->securitypriv.ndisauthtype <
 336                                                  Ndis802_11AuthModeWPAPSK) {
 337                         padapter->securitypriv.ndisauthtype =
 338                                                  Ndis802_11AuthModeOpen;
 339                         padapter->securitypriv.AuthAlgrthm = 0;
 340                 }
 341         } else {
 342                 ret = -EINVAL;
 343         }
 344         return ret;
 345 }
 346
 347 static int wpa_set_encryption(struct net_device *dev, struct ieee_param *param,
 348                               u32 param_len)
 349 {
 350         int ret = 0;
 351         u32 wep_key_idx, wep_key_len = 0;
 352         struct NDIS_802_11_WEP   *pwep = NULL;
 353         struct _adapter *padapter = netdev_priv(dev);
 354         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 355         struct security_priv *psecuritypriv = &padapter->securitypriv;
 356
 357         param->u.crypt.err = 0;
 358         param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
 359         if (param_len != (u32)((u8 *) param->u.crypt.key - (u8 *)param) +
 360                          param->u.crypt.key_len)
 361                 return -EINVAL;
 362         if (!is_broadcast_ether_addr(param->sta_addr))
 363                 return -EINVAL;
 364
 365         if (param->u.crypt.idx >= WEP_KEYS) {
 366                 /* for large key indices, set the default (0) */
 367                 param->u.crypt.idx = 0;
 368         }
 369         if (strcmp(param->u.crypt.alg, "WEP") == 0) {
 370                 netdev_info(dev, "r8712u: %s: crypt.alg = WEP\n", __func__);
 371                 padapter->securitypriv.ndisencryptstatus =
 372                              Ndis802_11Encryption1Enabled;
 373                 padapter->securitypriv.PrivacyAlgrthm = _WEP40_;
 374                 padapter->securitypriv.XGrpPrivacy = _WEP40_;
 375                 wep_key_idx = param->u.crypt.idx;
 376                 wep_key_len = param->u.crypt.key_len;
 377                 if (wep_key_idx >= WEP_KEYS)
 378                         wep_key_idx = 0;
 379                 if (wep_key_len <= 0)
 380                         return -EINVAL;
 381
 382                 wep_key_len = wep_key_len <= 5 ? 5 : 13;
 383                 pwep = kzalloc(sizeof(*pwep), GFP_ATOMIC);
 384                 if (!pwep)
 385                         return -ENOMEM;
 386                 pwep->KeyLength = wep_key_len;
 387                 pwep->Length = wep_key_len +
 388                         offsetof(struct NDIS_802_11_WEP, KeyMaterial);
 389                 if (wep_key_len == 13) {
 390                         padapter->securitypriv.PrivacyAlgrthm = _WEP104_;
 391                         padapter->securitypriv.XGrpPrivacy = _WEP104_;
 392                 }
 393                 pwep->KeyIndex = wep_key_idx;
 394                 pwep->KeyIndex |= 0x80000000;
 395                 memcpy(pwep->KeyMaterial, param->u.crypt.key, pwep->KeyLength);
 396                 if (param->u.crypt.set_tx) {
 397                         if (r8712_set_802_11_add_wep(padapter, pwep))
 398                                 ret = -EOPNOTSUPP;
 399                 } else {
 400                         /* don't update "psecuritypriv->PrivacyAlgrthm" and
 401                          * "psecuritypriv->PrivacyKeyIndex=keyid", but can
 402                          * r8712_set_key to fw/cam
 403                          */
 404                         if (wep_key_idx >= WEP_KEYS) {
 405                                 ret = -EOPNOTSUPP;
 406                                 goto exit;
 407                         }
 408                         memcpy(&psecuritypriv->DefKey[wep_key_idx].skey[0],
 409                                pwep->KeyMaterial,
 410                                pwep->KeyLength);
 411                         psecuritypriv->DefKeylen[wep_key_idx] =
 412                                 pwep->KeyLength;
 413                         r8712_set_key(padapter, psecuritypriv, wep_key_idx);
 414                 }
 415                 goto exit;
 416         }
 417         if (padapter->securitypriv.AuthAlgrthm == 2) { /* 802_1x */
 418                 struct sta_info *psta, *pbcmc_sta;
 419                 struct sta_priv *pstapriv = &padapter->stapriv;
 420                 struct security_priv *spriv = &padapter->securitypriv;
 421
 422                 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE |
 423                     WIFI_MP_STATE)) { /* sta mode */
 424                         psta = r8712_get_stainfo(pstapriv,
 425                                                  get_bssid(pmlmepriv));
 426                         if (psta) {
 427                                 psta->ieee8021x_blocked = false;
 428                                 if (spriv->ndisencryptstatus ==
 429                                     Ndis802_11Encryption2Enabled ||
 430                                     spriv->ndisencryptstatus ==
 431                                     Ndis802_11Encryption3Enabled)
 432                                         psta->XPrivacy = spriv->PrivacyAlgrthm;
 433                                 if (param->u.crypt.set_tx == 1)
 434                                         handle_pairwise_key(psta, param,
 435                                                             padapter);
 436                                 else /* group key */
 437                                         handle_group_key(param, padapter);
 438                         }
 439                         pbcmc_sta = r8712_get_bcmc_stainfo(padapter);
 440                         if (pbcmc_sta) {
 441                                 pbcmc_sta->ieee8021x_blocked = false;
 442                                 if (spriv->ndisencryptstatus ==
 443                                     Ndis802_11Encryption2Enabled ||
 444                                     spriv->ndisencryptstatus ==
 445                                     Ndis802_11Encryption3Enabled)
 446                                         pbcmc_sta->XPrivacy =
 447                                                 spriv->PrivacyAlgrthm;
 448                         }
 449                 }
 450         }
 451 exit:
 452         kfree(pwep);
 453         return ret;
 454 }
 455
 456 static int r871x_set_wpa_ie(struct _adapter *padapter, char *pie,
 457                             unsigned short ielen)
 458 {
 459         u8 *buf = NULL;
 460         int group_cipher = 0, pairwise_cipher = 0;
 461         int ret = 0;
 462
 463         if (ielen > MAX_WPA_IE_LEN || !pie)
 464                 return -EINVAL;
 465         if (ielen) {
 466                 buf = kmemdup(pie, ielen, GFP_ATOMIC);
 467                 if (!buf)
 468                         return -ENOMEM;
 469                 if (ielen < RSN_HEADER_LEN) {
 470                         ret  = -EINVAL;
 471                         goto exit;
 472                 }
 473                 if (r8712_parse_wpa_ie(buf, ielen, &group_cipher,
 474                                        &pairwise_cipher) == 0) {
 475                         padapter->securitypriv.AuthAlgrthm = 2;
 476                         padapter->securitypriv.ndisauthtype =
 477                                   Ndis802_11AuthModeWPAPSK;
 478                 }
 479                 if (r8712_parse_wpa2_ie(buf, ielen, &group_cipher,
 480                                         &pairwise_cipher) == 0) {
 481                         padapter->securitypriv.AuthAlgrthm = 2;
 482                         padapter->securitypriv.ndisauthtype =
 483                                   Ndis802_11AuthModeWPA2PSK;
 484                 }
 485                 switch (group_cipher) {
 486                 case WPA_CIPHER_NONE:
 487                         padapter->securitypriv.XGrpPrivacy = _NO_PRIVACY_;
 488                         padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
 489                         break;
 490                 case WPA_CIPHER_WEP40:
 491                         padapter->securitypriv.XGrpPrivacy = _WEP40_;
 492                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 493                         break;
 494                 case WPA_CIPHER_TKIP:
 495                         padapter->securitypriv.XGrpPrivacy = _TKIP_;
 496                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
 497                         break;
 498                 case WPA_CIPHER_CCMP:
 499                         padapter->securitypriv.XGrpPrivacy = _AES_;
 500                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
 501                         break;
 502                 case WPA_CIPHER_WEP104:
 503                         padapter->securitypriv.XGrpPrivacy = _WEP104_;
 504                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 505                         break;
 506                 }
 507                 switch (pairwise_cipher) {
 508                 case WPA_CIPHER_NONE:
 509                         padapter->securitypriv.PrivacyAlgrthm = _NO_PRIVACY_;
 510                         padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
 511                         break;
 512                 case WPA_CIPHER_WEP40:
 513                         padapter->securitypriv.PrivacyAlgrthm = _WEP40_;
 514                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 515                         break;
 516                 case WPA_CIPHER_TKIP:
 517                         padapter->securitypriv.PrivacyAlgrthm = _TKIP_;
 518                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
 519                         break;
 520                 case WPA_CIPHER_CCMP:
 521                         padapter->securitypriv.PrivacyAlgrthm = _AES_;
 522                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
 523                         break;
 524                 case WPA_CIPHER_WEP104:
 525                         padapter->securitypriv.PrivacyAlgrthm = _WEP104_;
 526                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 527                         break;
 528                 }
 529                 padapter->securitypriv.wps_phase = false;
 530                 {/* set wps_ie */
 531                         u16 cnt = 0;
 532                         u8 eid, wps_oui[4] = {0x0, 0x50, 0xf2, 0x04};
 533
 534                         while (cnt < ielen) {
 535                                 eid = buf[cnt];
 536
 537                                 if ((eid == WLAN_EID_VENDOR_SPECIFIC) &&
 538                                     (!memcmp(&buf[cnt + 2], wps_oui, 4))) {
 539                                         netdev_info(padapter->pnetdev, "r8712u: SET WPS_IE\n");
 540                                         padapter->securitypriv.wps_ie_len =
 541                                             ((buf[cnt + 1] + 2) <
 542                                             (MAX_WPA_IE_LEN << 2)) ?
 543                                             (buf[cnt + 1] + 2) :
 544                                             (MAX_WPA_IE_LEN << 2);
 545                                         memcpy(padapter->securitypriv.wps_ie,
 546                                                &buf[cnt],
 547                                                padapter->securitypriv.wps_ie_len);
 548                                         padapter->securitypriv.wps_phase =
 549                                                                  true;
 550                                         netdev_info(padapter->pnetdev, "r8712u: SET WPS_IE, wps_phase==true\n");
 551                                         cnt += buf[cnt + 1] + 2;
 552                                         break;
 553                                 }
 554
 555                                 cnt += buf[cnt + 1] + 2;
 556                         }
 557                 }
 558         }
 559 exit:
 560         kfree(buf);
 561         return ret;
 562 }
 563
 564 static int r8711_wx_get_name(struct net_device *dev, struct iw_request_info *info,
 565                              union iwreq_data *wrqu, char *extra)
 566 {
 567         struct _adapter *padapter = netdev_priv(dev);
 568         u32 ht_ielen = 0;
 569         char *p;
 570         u8 ht_cap = false;
 571         struct  mlme_priv       *pmlmepriv = &padapter->mlmepriv;
 572         struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network;
 573         u8 *prates;
 574
 575         if (check_fwstate(pmlmepriv, _FW_LINKED | WIFI_ADHOC_MASTER_STATE) == true) {
 576                 /* parsing HT_CAP_IE */
 577                 p = r8712_get_ie(&pcur_bss->IEs[12], WLAN_EID_HT_CAPABILITY,
 578                                  &ht_ielen, pcur_bss->IELength - 12);
 579                 if (p && ht_ielen > 0)
 580                         ht_cap = true;
 581                 prates = pcur_bss->rates;
 582                 if (r8712_is_cckratesonly_included(prates)) {
 583                         if (ht_cap)
 584                                 snprintf(wrqu->name, IFNAMSIZ,
 585                                          "IEEE 802.11bn");
 586                         else
 587                                 snprintf(wrqu->name, IFNAMSIZ,
 588                                          "IEEE 802.11b");
 589                 } else if (r8712_is_cckrates_included(prates)) {
 590                         if (ht_cap)
 591                                 snprintf(wrqu->name, IFNAMSIZ,
 592                                          "IEEE 802.11bgn");
 593                         else
 594                                 snprintf(wrqu->name, IFNAMSIZ,
 595                                          "IEEE 802.11bg");
 596                 } else {
 597                         if (ht_cap)
 598                                 snprintf(wrqu->name, IFNAMSIZ,
 599                                          "IEEE 802.11gn");
 600                         else
 601                                 snprintf(wrqu->name, IFNAMSIZ,
 602                                          "IEEE 802.11g");
 603                 }
 604         } else {
 605                 snprintf(wrqu->name, IFNAMSIZ, "unassociated");
 606         }
 607         return 0;
 608 }
 609
 610 static const long frequency_list[] = {
 611         2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462,
 612         2467, 2472, 2484, 4915, 4920, 4925, 4935, 4940, 4945, 4960, 4980,
 613         5035, 5040, 5045, 5055, 5060, 5080, 5170, 5180, 5190, 5200, 5210,
 614         5220, 5230, 5240, 5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560,
 615         5580, 5600, 5620, 5640, 5660, 5680, 5700, 5745, 5765, 5785, 5805,
 616         5825
 617 };
 618
 619 static int r8711_wx_set_freq(struct net_device *dev,
 620                              struct iw_request_info *info,
 621                              union iwreq_data *wrqu, char *extra)
 622 {
 623         struct _adapter *padapter = netdev_priv(dev);
 624         struct iw_freq *fwrq = &wrqu->freq;
 625         int rc = 0;
 626
 627 /* If setting by frequency, convert to a channel */
 628         if ((fwrq->e == 1) && (fwrq->m >= 241200000) && (fwrq->m <= 248700000)) {
 629                 int f = fwrq->m / 100000;
 630                 int c = 0;
 631
 632                 while ((c < 14) && (f != frequency_list[c]))
 633                         c++;
 634                 fwrq->e = 0;
 635                 fwrq->m = c + 1;
 636         }
 637         /* Setting by channel number */
 638         if ((fwrq->m > 14) || (fwrq->e > 0)) {
 639                 rc = -EOPNOTSUPP;
 640         } else {
 641                 int channel = fwrq->m;
 642
 643                 if ((channel < 1) || (channel > 14)) {
 644                         rc = -EINVAL;
 645                 } else {
 646                         /* Yes ! We can set it !!! */
 647                         padapter->registrypriv.channel = channel;
 648                 }
 649         }
 650         return rc;
 651 }
 652
 653 static int r8711_wx_get_freq(struct net_device *dev, struct iw_request_info *info,
 654                              union iwreq_data *wrqu, char *extra)
 655 {
 656         struct _adapter *padapter = netdev_priv(dev);
 657         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 658         struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network;
 659
 660         if (!check_fwstate(pmlmepriv, _FW_LINKED))
 661                 return -ENOLINK;
 662
 663         wrqu->freq.m = ieee80211_wlan_frequencies[
 664                        pcur_bss->Configuration.DSConfig - 1] * 100000;
 665         wrqu->freq.e = 1;
 666         wrqu->freq.i = pcur_bss->Configuration.DSConfig;
 667
 668         return 0;
 669 }
 670
 671 static int r8711_wx_set_mode(struct net_device *dev,
 672                              struct iw_request_info *a,
 673                              union iwreq_data *wrqu, char *b)
 674 {
 675         struct _adapter *padapter = netdev_priv(dev);
 676         enum NDIS_802_11_NETWORK_INFRASTRUCTURE networkType;
 677
 678         switch (wrqu->mode) {
 679         case IW_MODE_AUTO:
 680                 networkType = Ndis802_11AutoUnknown;
 681                 break;
 682         case IW_MODE_ADHOC:
 683                 networkType = Ndis802_11IBSS;
 684                 break;
 685         case IW_MODE_MASTER:
 686                 networkType = Ndis802_11APMode;
 687                 break;
 688         case IW_MODE_INFRA:
 689                 networkType = Ndis802_11Infrastructure;
 690                 break;
 691         default:
 692                 return -EINVAL;
 693         }
 694         if (Ndis802_11APMode == networkType)
 695                 r8712_setopmode_cmd(padapter, networkType);
 696         else
 697                 r8712_setopmode_cmd(padapter, Ndis802_11AutoUnknown);
 698
 699         r8712_set_802_11_infrastructure_mode(padapter, networkType);
 700         return 0;
 701 }
 702
 703 static int r8711_wx_get_mode(struct net_device *dev, struct iw_request_info *a,
 704                              union iwreq_data *wrqu, char *b)
 705 {
 706         struct _adapter *padapter = netdev_priv(dev);
 707         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 708
 709         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
 710                 wrqu->mode = IW_MODE_INFRA;
 711         else if (check_fwstate(pmlmepriv,
 712                                WIFI_ADHOC_MASTER_STATE | WIFI_ADHOC_STATE))
 713                 wrqu->mode = IW_MODE_ADHOC;
 714         else if (check_fwstate(pmlmepriv, WIFI_AP_STATE))
 715                 wrqu->mode = IW_MODE_MASTER;
 716         else
 717                 wrqu->mode = IW_MODE_AUTO;
 718         return 0;
 719 }
 720
 721 static int r871x_wx_set_pmkid(struct net_device *dev, struct iw_request_info *a,
 722                               union iwreq_data *wrqu, char *extra)
 723 {
 724         struct _adapter *padapter = netdev_priv(dev);
 725         struct security_priv *psecuritypriv = &padapter->securitypriv;
 726         struct iw_pmksa *pPMK = (struct iw_pmksa *) extra;
 727         struct RT_PMKID_LIST *pl = psecuritypriv->PMKIDList;
 728         u8 strZeroMacAddress[ETH_ALEN] = {0x00};
 729         u8 strIssueBssid[ETH_ALEN] = {0x00};
 730         u8 j, blInserted = false;
 731         int intReturn = false;
 732
 733 /*
 734  *      There are the BSSID information in the bssid.sa_data array.
 735  *      If cmd is IW_PMKSA_FLUSH, it means the wpa_supplicant wants to clear
 736  *      all the PMKID information. If cmd is IW_PMKSA_ADD, it means the
 737  *      wpa_supplicant wants to add a PMKID/BSSID to driver.
 738  *      If cmd is IW_PMKSA_REMOVE, it means the wpa_supplicant wants to
 739  *      remove a PMKID/BSSID from driver.
 740  */
 741         if (!pPMK)
 742                 return -EINVAL;
 743         memcpy(strIssueBssid, pPMK->bssid.sa_data, ETH_ALEN);
 744         switch (pPMK->cmd) {
 745         case IW_PMKSA_ADD:
 746                 if (!memcmp(strIssueBssid, strZeroMacAddress, ETH_ALEN))
 747                         return intReturn;
 748                 intReturn = true;
 749                 blInserted = false;
 750                 /* overwrite PMKID */
 751                 for (j = 0; j < NUM_PMKID_CACHE; j++) {
 752                         if (!memcmp(pl[j].Bssid, strIssueBssid, ETH_ALEN)) {
 753                                 /* BSSID is matched, the same AP => rewrite
 754                                  * with new PMKID.
 755                                  */
 756                                 netdev_info(dev, "r8712u: %s: BSSID exists in the PMKList.\n",
 757                                             __func__);
 758                                 memcpy(pl[j].PMKID, pPMK->pmkid, IW_PMKID_LEN);
 759                                 pl[j].bUsed = true;
 760                                 psecuritypriv->PMKIDIndex = j + 1;
 761                                 blInserted = true;
 762                                 break;
 763                         }
 764                 }
 765                 if (!blInserted) {
 766                         /* Find a new entry */
 767                         netdev_info(dev, "r8712u: %s: Use the new entry index = %d for this PMKID.\n",
 768                                     __func__, psecuritypriv->PMKIDIndex);
 769                         memcpy(pl[psecuritypriv->PMKIDIndex].Bssid,
 770                                strIssueBssid, ETH_ALEN);
 771                         memcpy(pl[psecuritypriv->PMKIDIndex].PMKID,
 772                                pPMK->pmkid, IW_PMKID_LEN);
 773                         pl[psecuritypriv->PMKIDIndex].bUsed = true;
 774                         psecuritypriv->PMKIDIndex++;
 775                         if (psecuritypriv->PMKIDIndex == NUM_PMKID_CACHE)
 776                                 psecuritypriv->PMKIDIndex = 0;
 777                 }
 778                 break;
 779         case IW_PMKSA_REMOVE:
 780                 intReturn = true;
 781                 for (j = 0; j < NUM_PMKID_CACHE; j++) {
 782                         if (!memcmp(pl[j].Bssid, strIssueBssid, ETH_ALEN)) {
 783                                 /* BSSID is matched, the same AP => Remove
 784                                  * this PMKID information and reset it.
 785                                  */
 786                                 eth_zero_addr(pl[j].Bssid);
 787                                 pl[j].bUsed = false;
 788                                 break;
 789                         }
 790                 }
 791                 break;
 792         case IW_PMKSA_FLUSH:
 793                 memset(psecuritypriv->PMKIDList, 0,
 794                        sizeof(struct RT_PMKID_LIST) * NUM_PMKID_CACHE);
 795                 psecuritypriv->PMKIDIndex = 0;
 796                 intReturn = true;
 797                 break;
 798         default:
 799                 netdev_info(dev, "r8712u: %s: unknown Command\n", __func__);
 800                 intReturn = false;
 801                 break;
 802         }
 803         return intReturn;
 804 }
 805
 806 static int r8711_wx_get_sens(struct net_device *dev,
 807                              struct iw_request_info *info,
 808                              union iwreq_data *wrqu, char *extra)
 809 {
 810         wrqu->sens.value = 0;
 811         wrqu->sens.fixed = 0;   /* no auto select */
 812         wrqu->sens.disabled = 1;
 813         return 0;
 814 }
 815
 816 static int r8711_wx_get_range(struct net_device *dev, struct iw_request_info *info,
 817                               union iwreq_data *wrqu, char *extra)
 818 {
 819         struct iw_range *range = (struct iw_range *)extra;
 820         u16 val;
 821         int i;
 822
 823         wrqu->data.length = sizeof(*range);
 824         memset(range, 0, sizeof(*range));
 825         /* Let's try to keep this struct in the same order as in
 826          * linux/include/wireless.h
 827          */
 828
 829         /* TODO: See what values we can set, and remove the ones we can't
 830          * set, or fill them with some default data.
 831          */
 832         /* ~5 Mb/s real (802.11b) */
 833         range->throughput = 5 * 1000 * 1000;
 834         /* TODO: 8711 sensitivity ? */
 835         /* signal level threshold range */
 836         /* percent values between 0 and 100. */
 837         range->max_qual.qual = 100;
 838         range->max_qual.level = 100;
 839         range->max_qual.noise = 100;
 840         range->max_qual.updated = 7; /* Updated all three */
 841         range->avg_qual.qual = 92; /* > 8% missed beacons is 'bad' */
 842         /* TODO: Find real 'good' to 'bad' threshold value for RSSI */
 843         range->avg_qual.level = 0x100 - 78;
 844         range->avg_qual.noise = 0;
 845         range->avg_qual.updated = 7; /* Updated all three */
 846         range->num_bitrates = RATE_COUNT;
 847         for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++)
 848                 range->bitrate[i] = rtl8180_rates[i];
 849         range->min_frag = MIN_FRAG_THRESHOLD;
 850         range->max_frag = MAX_FRAG_THRESHOLD;
 851         range->pm_capa = 0;
 852         range->we_version_compiled = WIRELESS_EXT;
 853         range->we_version_source = 16;
 854         range->num_channels = 14;
 855         for (i = 0, val = 0; i < 14; i++) {
 856                 /* Include only legal frequencies for some countries */
 857                 range->freq[val].i = i + 1;
 858                 range->freq[val].m = ieee80211_wlan_frequencies[i] * 100000;
 859                 range->freq[val].e = 1;
 860                 val++;
 861                 if (val == IW_MAX_FREQUENCIES)
 862                         break;
 863         }
 864         range->num_frequency = val;
 865         range->enc_capa = IW_ENC_CAPA_WPA |
 866                           IW_ENC_CAPA_WPA2 |
 867                           IW_ENC_CAPA_CIPHER_TKIP |
 868                           IW_ENC_CAPA_CIPHER_CCMP;
 869         return 0;
 870 }
 871
 872 static int r8711_wx_get_rate(struct net_device *dev,
 873                              struct iw_request_info *info,
 874                              union iwreq_data *wrqu, char *extra);
 875
 876 static int r871x_wx_set_priv(struct net_device *dev,
 877                              struct iw_request_info *info,
 878                              union iwreq_data *awrq,
 879                              char *extra)
 880 {
 881         int ret = 0, len = 0;
 882         char *ext;
 883         struct _adapter *padapter = netdev_priv(dev);
 884         struct iw_point *dwrq = (struct iw_point *)awrq;
 885
 886         len = dwrq->length;
 887         ext = strndup_user(dwrq->pointer, len);
 888         if (IS_ERR(ext))
 889                 return PTR_ERR(ext);
 890
 891         if (!strcasecmp(ext, "RSSI")) {
 892                 /*Return received signal strength indicator in -db for */
 893                 /* current AP */
 894                 /*<ssid> Rssi xx */
 895                 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 896                 struct wlan_network *pcur_network = &pmlmepriv->cur_network;
 897                 /*static u8 xxxx; */
 898                 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 899                         sprintf(ext, "%s rssi %d",
 900                                 pcur_network->network.Ssid.Ssid,
 901                                 /*(xxxx=xxxx+10) */
 902                                 ((padapter->recvpriv.fw_rssi) >> 1) - 95
 903                                 /*pcur_network->network.Rssi */
 904                                 );
 905                 } else {
 906                         sprintf(ext, "OK");
 907                 }
 908         } else if (!strcasecmp(ext, "LINKSPEED")) {
 909                 /*Return link speed in MBPS */
 910                 /*LinkSpeed xx */
 911                 union iwreq_data wrqd;
 912                 int ret_inner;
 913                 int mbps;
 914
 915                 ret_inner = r8711_wx_get_rate(dev, info, &wrqd, extra);
 916                 if (ret_inner != 0)
 917                         mbps = 0;
 918                 else
 919                         mbps = wrqd.bitrate.value / 1000000;
 920                 sprintf(ext, "LINKSPEED %d", mbps);
 921         } else if (!strcasecmp(ext, "MACADDR")) {
 922                 /*Return mac address of the station */
 923                 /* Macaddr = xx:xx:xx:xx:xx:xx */
 924                 sprintf(ext, "MACADDR = %pM", dev->dev_addr);
 925         } else if (!strcasecmp(ext, "SCAN-ACTIVE")) {
 926                 /*Set scan type to active */
 927                 /*OK if successful */
 928                 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 929
 930                 pmlmepriv->passive_mode = 1;
 931                 sprintf(ext, "OK");
 932         } else if (!strcasecmp(ext, "SCAN-PASSIVE")) {
 933                 /*Set scan type to passive */
 934                 /*OK if successful */
 935                 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 936
 937                 pmlmepriv->passive_mode = 0;
 938                 sprintf(ext, "OK");
 939         } else if (!strncmp(ext, "DCE-E", 5)) {
 940                 /*Set scan type to passive */
 941                 /*OK if successful */
 942                 r8712_disconnectCtrlEx_cmd(padapter
 943                         , 1 /*u32 enableDrvCtrl */
 944                         , 5 /*u32 tryPktCnt */
 945                         , 100 /*u32 tryPktInterval */
 946                         , 5000 /*u32 firstStageTO */
 947                 );
 948                 sprintf(ext, "OK");
 949         } else if (!strncmp(ext, "DCE-D", 5)) {
 950                 /*Set scan type to passive */
 951                 /*OK if successfu */
 952                 r8712_disconnectCtrlEx_cmd(padapter
 953                         , 0 /*u32 enableDrvCtrl */
 954                         , 5 /*u32 tryPktCnt */
 955                         , 100 /*u32 tryPktInterval */
 956                         , 5000 /*u32 firstStageTO */
 957                 );
 958                 sprintf(ext, "OK");
 959         } else {
 960                 netdev_info(dev, "r8712u: %s: unknown Command %s.\n", __func__, ext);
 961                 goto FREE_EXT;
 962         }
 963         if (copy_to_user(dwrq->pointer, ext, min(dwrq->length, (__u16)(strlen(ext) + 1))))
 964                 ret = -EFAULT;
 965
 966 FREE_EXT:
 967         kfree(ext);
 968         return ret;
 969 }
 970
 971 /* set bssid flow
 972  * s1. set_802_11_infrastructure_mode()
 973  * s2. set_802_11_authentication_mode()
 974  * s3. set_802_11_encryption_mode()
 975  * s4. set_802_11_bssid()
 976  *
 977  * This function intends to handle the Set AP command, which specifies the
 978  * MAC# of a preferred Access Point.
 979  * Currently, the request comes via Wireless Extensions' SIOCSIWAP ioctl.
 980  *
 981  * For this operation to succeed, there is no need for the interface to be up.
 982  *
 983  */
 984 static int r8711_wx_set_wap(struct net_device *dev, struct iw_request_info *info,
 985                             union iwreq_data *awrq, char *extra)
 986 {
 987         int ret = -EINPROGRESS;
 988         struct _adapter *padapter = netdev_priv(dev);
 989         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 990         struct  __queue *queue = &pmlmepriv->scanned_queue;
 991         struct sockaddr *temp = (struct sockaddr *)awrq;
 992         unsigned long irqL;
 993         struct list_head *phead;
 994         u8 *dst_bssid;
 995         struct wlan_network *pnetwork = NULL;
 996         enum NDIS_802_11_AUTHENTICATION_MODE    authmode;
 997
 998         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
 999                 return -EBUSY;
1000         if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING))
1001                 return ret;
1002         if (temp->sa_family != ARPHRD_ETHER)
1003                 return -EINVAL;
1004         authmode = padapter->securitypriv.ndisauthtype;
1005         spin_lock_irqsave(&queue->lock, irqL);
1006         phead = &queue->queue;
1007         pmlmepriv->pscanned = phead->next;
1008         while (1) {
1009                 if (end_of_queue_search(phead, pmlmepriv->pscanned))
1010                         break;
1011                 pnetwork = container_of(pmlmepriv->pscanned,
1012                                         struct wlan_network, list);
1013                 pmlmepriv->pscanned = pmlmepriv->pscanned->next;
1014                 dst_bssid = pnetwork->network.MacAddress;
1015                 if (!memcmp(dst_bssid, temp->sa_data, ETH_ALEN)) {
1016                         r8712_set_802_11_infrastructure_mode(padapter,
1017                             pnetwork->network.InfrastructureMode);
1018                         break;
1019                 }
1020         }
1021         spin_unlock_irqrestore(&queue->lock, irqL);
1022         if (!ret) {
1023                 if (!r8712_set_802_11_authentication_mode(padapter, authmode)) {
1024                         ret = -ENOMEM;
1025                 } else {
1026                         if (!r8712_set_802_11_bssid(padapter, temp->sa_data))
1027                                 ret = -1;
1028                 }
1029         }
1030         return ret;
1031 }
1032
1033 static int r8711_wx_get_wap(struct net_device *dev, struct iw_request_info *info,
1034                             union iwreq_data *wrqu, char *extra)
1035 {
1036         struct _adapter *padapter = netdev_priv(dev);
1037         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1038         struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network;
1039
1040         wrqu->ap_addr.sa_family = ARPHRD_ETHER;
1041         if (check_fwstate(pmlmepriv, _FW_LINKED | WIFI_ADHOC_MASTER_STATE | WIFI_AP_STATE))
1042                 ether_addr_copy(wrqu->ap_addr.sa_data, pcur_bss->MacAddress);
1043         else
1044                 eth_zero_addr(wrqu->ap_addr.sa_data);
1045         return 0;
1046 }
1047
1048 static int r871x_wx_set_mlme(struct net_device *dev,
1049                              struct iw_request_info *info,
1050                              union iwreq_data *wrqu, char *extra)
1051 {
1052         int ret = 0;
1053         struct _adapter *padapter = netdev_priv(dev);
1054         struct iw_mlme *mlme = (struct iw_mlme *) extra;
1055
1056         if (!mlme)
1057                 return -1;
1058         switch (mlme->cmd) {
1059         case IW_MLME_DEAUTH:
1060                 if (!r8712_set_802_11_disassociate(padapter))
1061                         ret = -1;
1062                 break;
1063         case IW_MLME_DISASSOC:
1064                 if (!r8712_set_802_11_disassociate(padapter))
1065                         ret = -1;
1066                 break;
1067         default:
1068                 return -EOPNOTSUPP;
1069         }
1070         return ret;
1071 }
1072
1073 /*
1074  *
1075  * This function intends to handle the Set Scan command.
1076  * Currently, the request comes via Wireless Extensions' SIOCSIWSCAN ioctl.
1077  *
1078  * For this operation to succeed, the interface is brought Up beforehand.
1079  *
1080  */
1081 static int r8711_wx_set_scan(struct net_device *dev, struct iw_request_info *a,
1082                              union iwreq_data *wrqu, char *extra)
1083 {
1084         struct _adapter *padapter = netdev_priv(dev);
1085         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1086         u8 status = true;
1087
1088         if (padapter->driver_stopped) {
1089                 netdev_info(dev, "In %s: driver_stopped=%d\n",
1090                             __func__, padapter->driver_stopped);
1091                 return -1;
1092         }
1093         if (!padapter->bup)
1094                 return -ENETDOWN;
1095         if (!padapter->hw_init_completed)
1096                 return -1;
1097         if ((check_fwstate(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING)) ||
1098             (pmlmepriv->sitesurveyctrl.traffic_busy))
1099                 return 0;
1100         if (wrqu->data.length == sizeof(struct iw_scan_req)) {
1101                 struct iw_scan_req *req = (struct iw_scan_req *)extra;
1102
1103                 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
1104                         struct ndis_802_11_ssid ssid;
1105                         unsigned long irqL;
1106                         u32 len = min_t(u8, req->essid_len, IW_ESSID_MAX_SIZE);
1107
1108                         memset((unsigned char *)&ssid, 0, sizeof(struct ndis_802_11_ssid));
1109                         memcpy(ssid.Ssid, req->essid, len);
1110                         ssid.SsidLength = len;
1111                         spin_lock_irqsave(&pmlmepriv->lock, irqL);
1112                         if ((check_fwstate(pmlmepriv, _FW_UNDER_SURVEY |
1113                              _FW_UNDER_LINKING)) ||
1114                             (pmlmepriv->sitesurveyctrl.traffic_busy)) {
1115                                 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING))
1116                                         status = false;
1117                         } else {
1118                                 status = r8712_sitesurvey_cmd(padapter, &ssid);
1119                         }
1120                         spin_unlock_irqrestore(&pmlmepriv->lock, irqL);
1121                 }
1122         } else {
1123                 status = r8712_set_802_11_bssid_list_scan(padapter);
1124         }
1125         if (!status)
1126                 return -1;
1127         return 0;
1128 }
1129
1130 static int r8711_wx_get_scan(struct net_device *dev, struct iw_request_info *a,
1131                              union iwreq_data *wrqu, char *extra)
1132 {
1133         struct _adapter *padapter = netdev_priv(dev);
1134         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1135         struct  __queue *queue = &pmlmepriv->scanned_queue;
1136         struct wlan_network *pnetwork = NULL;
1137         unsigned long irqL;
1138         struct list_head *plist, *phead;
1139         char *ev = extra;
1140         char *stop = ev + wrqu->data.length;
1141         u32 ret = 0, cnt = 0;
1142
1143         if (padapter->driver_stopped)
1144                 return -EINVAL;
1145         while (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING)) {
1146                 msleep(30);
1147                 cnt++;
1148                 if (cnt > 100)
1149                         break;
1150         }
1151         spin_lock_irqsave(&queue->lock, irqL);
1152         phead = &queue->queue;
1153         plist = phead->next;
1154         while (1) {
1155                 if (end_of_queue_search(phead, plist))
1156                         break;
1157                 if ((stop - ev) < SCAN_ITEM_SIZE) {
1158                         ret = -E2BIG;
1159                         break;
1160                 }
1161                 pnetwork = container_of(plist, struct wlan_network, list);
1162                 ev = translate_scan(padapter, a, pnetwork, ev, stop);
1163                 plist = plist->next;
1164         }
1165         spin_unlock_irqrestore(&queue->lock, irqL);
1166         wrqu->data.length = ev - extra;
1167         wrqu->data.flags = 0;
1168         return ret;
1169 }
1170
1171 /* set ssid flow
1172  * s1. set_802_11_infrastructure_mode()
1173  * s2. set_802_11_authenticaion_mode()
1174  * s3. set_802_11_encryption_mode()
1175  * s4. set_802_11_ssid()
1176  *
1177  * This function intends to handle the Set ESSID command.
1178  * Currently, the request comes via the Wireless Extensions' SIOCSIWESSID ioctl.
1179  *
1180  * For this operation to succeed, there is no need for the interface to be Up.
1181  *
1182  */
1183 static int r8711_wx_set_essid(struct net_device *dev, struct iw_request_info *a,
1184                               union iwreq_data *wrqu, char *extra)
1185 {
1186         struct _adapter *padapter = netdev_priv(dev);
1187         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1188         struct  __queue *queue = &pmlmepriv->scanned_queue;
1189         struct wlan_network *pnetwork = NULL;
1190         enum NDIS_802_11_AUTHENTICATION_MODE    authmode;
1191         struct ndis_802_11_ssid ndis_ssid;
1192         u8 *dst_ssid, *src_ssid;
1193         struct list_head *phead;
1194         u32 len;
1195
1196         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
1197                 return -EBUSY;
1198         if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING))
1199                 return 0;
1200         if (wrqu->essid.length > IW_ESSID_MAX_SIZE)
1201                 return -E2BIG;
1202         authmode = padapter->securitypriv.ndisauthtype;
1203         if (wrqu->essid.flags && wrqu->essid.length) {
1204                 len = (wrqu->essid.length < IW_ESSID_MAX_SIZE) ?
1205                        wrqu->essid.length : IW_ESSID_MAX_SIZE;
1206                 memset(&ndis_ssid, 0, sizeof(struct ndis_802_11_ssid));
1207                 ndis_ssid.SsidLength = len;
1208                 memcpy(ndis_ssid.Ssid, extra, len);
1209                 src_ssid = ndis_ssid.Ssid;
1210                 phead = &queue->queue;
1211                 pmlmepriv->pscanned = phead->next;
1212                 while (1) {
1213                         if (end_of_queue_search(phead, pmlmepriv->pscanned))
1214                                 break;
1215                         pnetwork = container_of(pmlmepriv->pscanned,
1216                                                 struct wlan_network, list);
1217                         pmlmepriv->pscanned = pmlmepriv->pscanned->next;
1218                         dst_ssid = pnetwork->network.Ssid.Ssid;
1219                         if ((!memcmp(dst_ssid, src_ssid, ndis_ssid.SsidLength))
1220                             && (pnetwork->network.Ssid.SsidLength ==
1221                              ndis_ssid.SsidLength)) {
1222                                 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
1223                                         if (pnetwork->network.
1224                                                 InfrastructureMode
1225                                                 !=
1226                                                 padapter->mlmepriv.
1227                                                 cur_network.network.
1228                                                 InfrastructureMode)
1229                                                 continue;
1230                                 }
1231
1232                                 r8712_set_802_11_infrastructure_mode(
1233                                      padapter,
1234                                      pnetwork->network.InfrastructureMode);
1235                                 break;
1236                         }
1237                 }
1238                 r8712_set_802_11_authentication_mode(padapter, authmode);
1239                 r8712_set_802_11_ssid(padapter, &ndis_ssid);
1240         }
1241         return -EINPROGRESS;
1242 }
1243
1244 static int r8711_wx_get_essid(struct net_device *dev, struct iw_request_info *a,
1245                               union iwreq_data *wrqu, char *extra)
1246 {
1247         struct _adapter *padapter = netdev_priv(dev);
1248         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1249         struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network;
1250         u32 len, ret = 0;
1251
1252         if (check_fwstate(pmlmepriv, _FW_LINKED | WIFI_ADHOC_MASTER_STATE)) {
1253                 len = pcur_bss->Ssid.SsidLength;
1254                 wrqu->essid.length = len;
1255                 memcpy(extra, pcur_bss->Ssid.Ssid, len);
1256                 wrqu->essid.flags = 1;
1257         } else {
1258                 ret = -ENOLINK;
1259         }
1260         return ret;
1261 }
1262
1263 static int r8711_wx_set_rate(struct net_device *dev, struct iw_request_info *a,
1264                              union iwreq_data *wrqu, char *extra)
1265 {
1266         struct _adapter *padapter = netdev_priv(dev);
1267         u32 target_rate = wrqu->bitrate.value;
1268         u32 fixed = wrqu->bitrate.fixed;
1269         u32 ratevalue = 0;
1270         u8 datarates[NumRates];
1271         u8 mpdatarate[NumRates] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0xff};
1272         int i;
1273
1274         if (target_rate == -1) {
1275                 ratevalue = 11;
1276                 goto set_rate;
1277         }
1278         target_rate = target_rate / 100000;
1279         switch (target_rate) {
1280         case 10:
1281                 ratevalue = 0;
1282                 break;
1283         case 20:
1284                 ratevalue = 1;
1285                 break;
1286         case 55:
1287                 ratevalue = 2;
1288                 break;
1289         case 60:
1290                 ratevalue = 3;
1291                 break;
1292         case 90:
1293                 ratevalue = 4;
1294                 break;
1295         case 110:
1296                 ratevalue = 5;
1297                 break;
1298         case 120:
1299                 ratevalue = 6;
1300                 break;
1301         case 180:
1302                 ratevalue = 7;
1303                 break;
1304         case 240:
1305                 ratevalue = 8;
1306                 break;
1307         case 360:
1308                 ratevalue = 9;
1309                 break;
1310         case 480:
1311                 ratevalue = 10;
1312                 break;
1313         case 540:
1314                 ratevalue = 11;
1315                 break;
1316         default:
1317                 ratevalue = 11;
1318                 break;
1319         }
1320 set_rate:
1321         for (i = 0; i < NumRates; i++) {
1322                 if (ratevalue == mpdatarate[i]) {
1323                         datarates[i] = mpdatarate[i];
1324                         if (fixed == 0)
1325                                 break;
1326                 } else {
1327                         datarates[i] = 0xff;
1328                 }
1329         }
1330         return r8712_setdatarate_cmd(padapter, datarates);
1331 }
1332
1333 static int r8711_wx_get_rate(struct net_device *dev, struct iw_request_info *info,
1334                              union iwreq_data *wrqu, char *extra)
1335 {
1336         struct _adapter *padapter = netdev_priv(dev);
1337         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1338         struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network;
1339         struct ieee80211_ht_cap *pht_capie;
1340         unsigned char rf_type = padapter->registrypriv.rf_config;
1341         int i;
1342         u8 *p;
1343         u16 rate, max_rate = 0, ht_cap = false;
1344         u32 ht_ielen = 0;
1345         u8 bw_40MHz = 0, short_GI = 0;
1346         u16 mcs_rate = 0;
1347
1348         i = 0;
1349         if (!check_fwstate(pmlmepriv, _FW_LINKED | WIFI_ADHOC_MASTER_STATE))
1350                 return -ENOLINK;
1351         p = r8712_get_ie(&pcur_bss->IEs[12], WLAN_EID_HT_CAPABILITY, &ht_ielen,
1352                          pcur_bss->IELength - 12);
1353         if (p && ht_ielen > 0) {
1354                 ht_cap = true;
1355                 pht_capie = (struct ieee80211_ht_cap *)(p + 2);
1356                 memcpy(&mcs_rate, &pht_capie->mcs, 2);
1357                 bw_40MHz = (le16_to_cpu(pht_capie->cap_info) &
1358                             IEEE80211_HT_CAP_SUP_WIDTH_20_40) ? 1 : 0;
1359                 short_GI = (le16_to_cpu(pht_capie->cap_info) &
1360                             (IEEE80211_HT_CAP_SGI_20 |
1361                             IEEE80211_HT_CAP_SGI_40)) ? 1 : 0;
1362         }
1363         while ((pcur_bss->rates[i] != 0) &&
1364                (pcur_bss->rates[i] != 0xFF)) {
1365                 rate = pcur_bss->rates[i] & 0x7F;
1366                 if (rate > max_rate)
1367                         max_rate = rate;
1368                 wrqu->bitrate.fixed = 0;        /* no auto select */
1369                 wrqu->bitrate.value = rate * 500000;
1370                 i++;
1371         }
1372         if (ht_cap) {
1373                 if (mcs_rate & 0x8000 /* MCS15 */
1374                     &&
1375                     rf_type == RTL8712_RF_2T2R)
1376                         max_rate = (bw_40MHz) ? ((short_GI) ? 300 : 270) :
1377                         ((short_GI) ? 144 : 130);
1378                 else /* default MCS7 */
1379                         max_rate = (bw_40MHz) ? ((short_GI) ? 150 : 135) :
1380                         ((short_GI) ? 72 : 65);
1381                 max_rate *= 2; /* Mbps/2 */
1382         }
1383         wrqu->bitrate.value = max_rate * 500000;
1384         return 0;
1385 }
1386
1387 static int r8711_wx_get_rts(struct net_device *dev, struct iw_request_info *info,
1388                             union iwreq_data *wrqu, char *extra)
1389 {
1390         struct _adapter *padapter = netdev_priv(dev);
1391
1392         wrqu->rts.value = padapter->registrypriv.rts_thresh;
1393         wrqu->rts.fixed = 0;    /* no auto select */
1394         return 0;
1395 }
1396
1397 static int r8711_wx_set_frag(struct net_device *dev, struct iw_request_info *info,
1398                              union iwreq_data *wrqu, char *extra)
1399 {
1400         struct _adapter *padapter = netdev_priv(dev);
1401
1402         if (wrqu->frag.disabled) {
1403                 padapter->xmitpriv.frag_len = MAX_FRAG_THRESHOLD;
1404         } else {
1405                 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
1406                     wrqu->frag.value > MAX_FRAG_THRESHOLD)
1407                         return -EINVAL;
1408                 padapter->xmitpriv.frag_len = wrqu->frag.value & ~0x1;
1409         }
1410         return 0;
1411 }
1412
1413 static int r8711_wx_get_frag(struct net_device *dev,
1414                                 struct iw_request_info *info,
1415                                 union iwreq_data *wrqu, char *extra)
1416 {
1417         struct _adapter *padapter = netdev_priv(dev);
1418
1419         wrqu->frag.value = padapter->xmitpriv.frag_len;
1420         wrqu->frag.fixed = 0;   /* no auto select */
1421         return 0;
1422 }
1423
1424 static int r8711_wx_get_retry(struct net_device *dev,
1425                                 struct iw_request_info *info,
1426                                 union iwreq_data *wrqu, char *extra)
1427 {
1428         wrqu->retry.value = 7;
1429         wrqu->retry.fixed = 0;  /* no auto select */
1430         wrqu->retry.disabled = 1;
1431         return 0;
1432 }
1433
1434 static int r8711_wx_set_enc(struct net_device *dev,
1435                                 struct iw_request_info *info,
1436                                 union iwreq_data *wrqu, char *keybuf)
1437 {
1438         u32 key;
1439         u32 keyindex_provided;
1440         struct NDIS_802_11_WEP   wep;
1441         enum NDIS_802_11_AUTHENTICATION_MODE authmode;
1442         struct iw_point *erq = &wrqu->encoding;
1443         struct _adapter *padapter = netdev_priv(dev);
1444
1445         key = erq->flags & IW_ENCODE_INDEX;
1446         memset(&wep, 0, sizeof(struct NDIS_802_11_WEP));
1447         if (erq->flags & IW_ENCODE_DISABLED) {
1448                 netdev_info(dev, "r8712u: %s: EncryptionDisabled\n", __func__);
1449                 padapter->securitypriv.ndisencryptstatus =
1450                                  Ndis802_11EncryptionDisabled;
1451                 padapter->securitypriv.PrivacyAlgrthm = _NO_PRIVACY_;
1452                 padapter->securitypriv.XGrpPrivacy = _NO_PRIVACY_;
1453                 padapter->securitypriv.AuthAlgrthm = 0; /* open system */
1454                 authmode = Ndis802_11AuthModeOpen;
1455                 padapter->securitypriv.ndisauthtype = authmode;
1456                 return 0;
1457         }
1458         if (key) {
1459                 if (key > WEP_KEYS)
1460                         return -EINVAL;
1461                 key--;
1462                 keyindex_provided = 1;
1463         } else {
1464                 keyindex_provided = 0;
1465                 key = padapter->securitypriv.PrivacyKeyIndex;
1466         }
1467         /* set authentication mode */
1468         if (erq->flags & IW_ENCODE_OPEN) {
1469                 netdev_info(dev, "r8712u: %s: IW_ENCODE_OPEN\n", __func__);
1470                 padapter->securitypriv.ndisencryptstatus =
1471                                  Ndis802_11Encryption1Enabled;
1472                 padapter->securitypriv.AuthAlgrthm = 0; /* open system */
1473                 padapter->securitypriv.PrivacyAlgrthm = _NO_PRIVACY_;
1474                 padapter->securitypriv.XGrpPrivacy = _NO_PRIVACY_;
1475                 authmode = Ndis802_11AuthModeOpen;
1476                 padapter->securitypriv.ndisauthtype = authmode;
1477         } else if (erq->flags & IW_ENCODE_RESTRICTED) {
1478                 netdev_info(dev,
1479                                 "r8712u: %s: IW_ENCODE_RESTRICTED\n", __func__);
1480                 padapter->securitypriv.ndisencryptstatus =
1481                                  Ndis802_11Encryption1Enabled;
1482                 padapter->securitypriv.AuthAlgrthm = 1; /* shared system */
1483                 padapter->securitypriv.PrivacyAlgrthm = _WEP40_;
1484                 padapter->securitypriv.XGrpPrivacy = _WEP40_;
1485                 authmode = Ndis802_11AuthModeShared;
1486                 padapter->securitypriv.ndisauthtype = authmode;
1487         } else {
1488                 padapter->securitypriv.ndisencryptstatus =
1489                                  Ndis802_11Encryption1Enabled;
1490                 padapter->securitypriv.AuthAlgrthm = 0; /* open system */
1491                 padapter->securitypriv.PrivacyAlgrthm = _NO_PRIVACY_;
1492                 padapter->securitypriv.XGrpPrivacy = _NO_PRIVACY_;
1493                 authmode = Ndis802_11AuthModeOpen;
1494                 padapter->securitypriv.ndisauthtype = authmode;
1495         }
1496         wep.KeyIndex = key;
1497         if (erq->length > 0) {
1498                 wep.KeyLength = erq->length <= 5 ? 5 : 13;
1499                 wep.Length = wep.KeyLength +
1500                              offsetof(struct NDIS_802_11_WEP, KeyMaterial);
1501         } else {
1502                 wep.KeyLength = 0;
1503                 if (keyindex_provided == 1) { /* set key_id only, no given
1504                                                * KeyMaterial(erq->length==0).
1505                                                */
1506                         padapter->securitypriv.PrivacyKeyIndex = key;
1507                         switch (padapter->securitypriv.DefKeylen[key]) {
1508                         case 5:
1509                                 padapter->securitypriv.PrivacyAlgrthm =
1510                                                  _WEP40_;
1511                                 break;
1512                         case 13:
1513                                 padapter->securitypriv.PrivacyAlgrthm =
1514                                                  _WEP104_;
1515                                 break;
1516                         default:
1517                                 padapter->securitypriv.PrivacyAlgrthm =
1518                                                  _NO_PRIVACY_;
1519                                 break;
1520                         }
1521                         return 0;
1522                 }
1523         }
1524         wep.KeyIndex |= 0x80000000;     /* transmit key */
1525         memcpy(wep.KeyMaterial, keybuf, wep.KeyLength);
1526         if (r8712_set_802_11_add_wep(padapter, &wep))
1527                 return -EOPNOTSUPP;
1528         return 0;
1529 }
1530
1531 static int r8711_wx_get_enc(struct net_device *dev,
1532                                 struct iw_request_info *info,
1533                                 union iwreq_data *wrqu, char *keybuf)
1534 {
1535         uint key;
1536         struct _adapter *padapter = netdev_priv(dev);
1537         struct iw_point *erq = &wrqu->encoding;
1538         struct  mlme_priv       *pmlmepriv = &padapter->mlmepriv;
1539         union Keytype *dk = padapter->securitypriv.DefKey;
1540
1541         if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
1542                 if (!check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) {
1543                         erq->length = 0;
1544                         erq->flags |= IW_ENCODE_DISABLED;
1545                         return 0;
1546                 }
1547         }
1548         key = erq->flags & IW_ENCODE_INDEX;
1549         if (key) {
1550                 if (key > WEP_KEYS)
1551                         return -EINVAL;
1552                 key--;
1553         } else {
1554                 key = padapter->securitypriv.PrivacyKeyIndex;
1555         }
1556         erq->flags = key + 1;
1557         switch (padapter->securitypriv.ndisencryptstatus) {
1558         case Ndis802_11EncryptionNotSupported:
1559         case Ndis802_11EncryptionDisabled:
1560                 erq->length = 0;
1561                 erq->flags |= IW_ENCODE_DISABLED;
1562                 break;
1563         case Ndis802_11Encryption1Enabled:
1564                 erq->length = padapter->securitypriv.DefKeylen[key];
1565                 if (erq->length) {
1566                         memcpy(keybuf, dk[key].skey,
1567                                padapter->securitypriv.DefKeylen[key]);
1568                         erq->flags |= IW_ENCODE_ENABLED;
1569                         if (padapter->securitypriv.ndisauthtype ==
1570                             Ndis802_11AuthModeOpen)
1571                                 erq->flags |= IW_ENCODE_OPEN;
1572                         else if (padapter->securitypriv.ndisauthtype ==
1573                                  Ndis802_11AuthModeShared)
1574                                 erq->flags |= IW_ENCODE_RESTRICTED;
1575                 } else {
1576                         erq->length = 0;
1577                         erq->flags |= IW_ENCODE_DISABLED;
1578                 }
1579                 break;
1580         case Ndis802_11Encryption2Enabled:
1581         case Ndis802_11Encryption3Enabled:
1582                 erq->length = 16;
1583                 erq->flags |= (IW_ENCODE_ENABLED | IW_ENCODE_OPEN |
1584                                IW_ENCODE_NOKEY);
1585                 break;
1586         default:
1587                 erq->length = 0;
1588                 erq->flags |= IW_ENCODE_DISABLED;
1589                 break;
1590         }
1591         return 0;
1592 }
1593
1594 static int r8711_wx_get_power(struct net_device *dev,
1595                                 struct iw_request_info *info,
1596                                 union iwreq_data *wrqu, char *extra)
1597 {
1598         wrqu->power.value = 0;
1599         wrqu->power.fixed = 0;  /* no auto select */
1600         wrqu->power.disabled = 1;
1601         return 0;
1602 }
1603
1604 static int r871x_wx_set_gen_ie(struct net_device *dev,
1605                                 struct iw_request_info *info,
1606                                 union iwreq_data *wrqu, char *extra)
1607 {
1608         struct _adapter *padapter = netdev_priv(dev);
1609
1610         return r871x_set_wpa_ie(padapter, extra, wrqu->data.length);
1611 }
1612
1613 static int r871x_wx_set_auth(struct net_device *dev,
1614                                 struct iw_request_info *info,
1615                                 union iwreq_data *wrqu, char *extra)
1616 {
1617         struct _adapter *padapter = netdev_priv(dev);
1618         struct iw_param *param = (struct iw_param *)&wrqu->param;
1619         int paramid;
1620         int paramval;
1621         int ret = 0;
1622
1623         paramid = param->flags & IW_AUTH_INDEX;
1624         paramval = param->value;
1625         switch (paramid) {
1626         case IW_AUTH_WPA_VERSION:
1627                 break;
1628         case IW_AUTH_CIPHER_PAIRWISE:
1629                 break;
1630         case IW_AUTH_CIPHER_GROUP:
1631                 break;
1632         case IW_AUTH_KEY_MGMT:
1633                 /*
1634                  *  ??? does not use these parameters
1635                  */
1636                 break;
1637         case IW_AUTH_TKIP_COUNTERMEASURES:
1638                 if (paramval) {
1639                         /* wpa_supplicant is enabling tkip countermeasure. */
1640                         padapter->securitypriv.btkip_countermeasure = true;
1641                 } else {
1642                         /* wpa_supplicant is disabling tkip countermeasure. */
1643                         padapter->securitypriv.btkip_countermeasure = false;
1644                 }
1645                 break;
1646         case IW_AUTH_DROP_UNENCRYPTED:
1647                 /* HACK:
1648                  *
1649                  * wpa_supplicant calls set_wpa_enabled when the driver
1650                  * is loaded and unloaded, regardless of if WPA is being
1651                  * used.  No other calls are made which can be used to
1652                  * determine if encryption will be used or not prior to
1653                  * association being expected.  If encryption is not being
1654                  * used, drop_unencrypted is set to false, else true -- we
1655                  * can use this to determine if the CAP_PRIVACY_ON bit should
1656                  * be set.
1657                  */
1658                 if (padapter->securitypriv.ndisencryptstatus ==
1659                     Ndis802_11Encryption1Enabled) {
1660                         /* it means init value, or using wep,
1661                          * ndisencryptstatus =
1662                          *      Ndis802_11Encryption1Enabled,
1663                          * then it needn't reset it;
1664                          */
1665                         break;
1666                 }
1667
1668                 if (paramval) {
1669                         padapter->securitypriv.ndisencryptstatus =
1670                                    Ndis802_11EncryptionDisabled;
1671                         padapter->securitypriv.PrivacyAlgrthm =
1672                                   _NO_PRIVACY_;
1673                         padapter->securitypriv.XGrpPrivacy =
1674                                   _NO_PRIVACY_;
1675                         padapter->securitypriv.AuthAlgrthm = 0;
1676                         padapter->securitypriv.ndisauthtype =
1677                                   Ndis802_11AuthModeOpen;
1678                 }
1679                 break;
1680         case IW_AUTH_80211_AUTH_ALG:
1681                 ret = wpa_set_auth_algs(dev, (u32)paramval);
1682                 break;
1683         case IW_AUTH_WPA_ENABLED:
1684                 break;
1685         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
1686                 break;
1687         case IW_AUTH_PRIVACY_INVOKED:
1688                 break;
1689         default:
1690                 return -EOPNOTSUPP;
1691         }
1692
1693         return ret;
1694 }
1695
1696 static int r871x_wx_set_enc_ext(struct net_device *dev,
1697                              struct iw_request_info *info,
1698                              union iwreq_data *wrqu, char *extra)
1699 {
1700         struct iw_point *pencoding = &wrqu->encoding;
1701         struct iw_encode_ext *pext = (struct iw_encode_ext *)extra;
1702         struct ieee_param *param = NULL;
1703         char *alg_name;
1704         u32 param_len;
1705         int ret = 0;
1706
1707         switch (pext->alg) {
1708         case IW_ENCODE_ALG_NONE:
1709                 alg_name = "none";
1710                 break;
1711         case IW_ENCODE_ALG_WEP:
1712                 alg_name = "WEP";
1713                 break;
1714         case IW_ENCODE_ALG_TKIP:
1715                 alg_name = "TKIP";
1716                 break;
1717         case IW_ENCODE_ALG_CCMP:
1718                 alg_name = "CCMP";
1719                 break;
1720         default:
1721                 return -EINVAL;
1722         }
1723
1724         param_len = sizeof(struct ieee_param) + pext->key_len;
1725         param = kzalloc(param_len, GFP_ATOMIC);
1726         if (!param)
1727                 return -ENOMEM;
1728         param->cmd = IEEE_CMD_SET_ENCRYPTION;
1729         eth_broadcast_addr(param->sta_addr);
1730         strscpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN);
1731         if (pext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
1732                 param->u.crypt.set_tx = 0;
1733         if (pext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
1734                 param->u.crypt.set_tx = 1;
1735         param->u.crypt.idx = (pencoding->flags & 0x00FF) - 1;
1736         if (pext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID)
1737                 memcpy(param->u.crypt.seq, pext->rx_seq, 8);
1738         if (pext->key_len) {
1739                 param->u.crypt.key_len = pext->key_len;
1740                 memcpy(param + 1, pext + 1, pext->key_len);
1741         }
1742         ret = wpa_set_encryption(dev, param, param_len);
1743         kfree(param);
1744         return ret;
1745 }
1746
1747 static int r871x_wx_get_nick(struct net_device *dev,
1748                              struct iw_request_info *info,
1749                              union iwreq_data *wrqu, char *extra)
1750 {
1751         if (extra) {
1752                 wrqu->data.length = 8;
1753                 wrqu->data.flags = 1;
1754                 memcpy(extra, "rtl_wifi", 8);
1755         }
1756         return 0;
1757 }
1758
1759 static int r8711_wx_read32(struct net_device *dev,
1760                                 struct iw_request_info *info,
1761                                 union iwreq_data *wrqu, char *keybuf)
1762 {
1763         struct _adapter *padapter = netdev_priv(dev);
1764         u32 addr;
1765         u32 data32;
1766
1767         get_user(addr, (u32 __user *)wrqu->data.pointer);
1768         data32 = r8712_read32(padapter, addr);
1769         put_user(data32, (u32 __user *)wrqu->data.pointer);
1770         wrqu->data.length = (data32 & 0xffff0000) >> 16;
1771         wrqu->data.flags = data32 & 0xffff;
1772         get_user(addr, (u32 __user *)wrqu->data.pointer);
1773         return 0;
1774 }
1775
1776 static int r8711_wx_write32(struct net_device *dev,
1777                                  struct iw_request_info *info,
1778                                  union iwreq_data *wrqu, char *keybuf)
1779 {
1780         struct _adapter *padapter = netdev_priv(dev);
1781         u32 addr;
1782         u32 data32;
1783
1784         get_user(addr, (u32 __user *)wrqu->data.pointer);
1785         data32 = ((u32)wrqu->data.length << 16) | (u32)wrqu->data.flags;
1786         r8712_write32(padapter, addr, data32);
1787         return 0;
1788 }
1789
1790 static int dummy(struct net_device *dev,
1791                 struct iw_request_info *a,
1792                 union iwreq_data *wrqu, char *b)
1793 {
1794         return -EINVAL;
1795 }
1796
1797 static int r8711_drvext_hdl(struct net_device *dev,
1798                                 struct iw_request_info *info,
1799                                 union iwreq_data *wrqu, char *extra)
1800 {
1801         return 0;
1802 }
1803
1804 static int r871x_mp_ioctl_hdl(struct net_device *dev,
1805                                 struct iw_request_info *info,
1806                                 union iwreq_data *wrqu, char *extra)
1807 {
1808         struct _adapter *padapter = netdev_priv(dev);
1809         struct iw_point *p = &wrqu->data;
1810         struct oid_par_priv oid_par;
1811         struct mp_ioctl_handler *phandler;
1812         struct mp_ioctl_param *poidparam;
1813         unsigned long BytesRead, BytesWritten, BytesNeeded;
1814         u8 *pparmbuf, bset;
1815         u16 len;
1816         uint status;
1817         int ret = 0;
1818
1819         if ((!p->length) || (!p->pointer))
1820                 return -EINVAL;
1821
1822         bset = (u8)(p->flags & 0xFFFF);
1823         len = p->length;
1824         pparmbuf = memdup_user(p->pointer, len);
1825         if (IS_ERR(pparmbuf))
1826                 return PTR_ERR(pparmbuf);
1827
1828         poidparam = (struct mp_ioctl_param *)pparmbuf;
1829         if (poidparam->subcode >= MAX_MP_IOCTL_SUBCODE) {
1830                 ret = -EINVAL;
1831                 goto _r871x_mp_ioctl_hdl_exit;
1832         }
1833         phandler = mp_ioctl_hdl + poidparam->subcode;
1834         if ((phandler->paramsize != 0) &&
1835             (poidparam->len < phandler->paramsize)) {
1836                 ret = -EINVAL;
1837                 goto _r871x_mp_ioctl_hdl_exit;
1838         }
1839         if (phandler->oid == 0 && phandler->handler) {
1840                 status = phandler->handler(&oid_par);
1841         } else if (phandler->handler) {
1842                 oid_par.adapter_context = padapter;
1843                 oid_par.oid = phandler->oid;
1844                 oid_par.information_buf = poidparam->data;
1845                 oid_par.information_buf_len = poidparam->len;
1846                 oid_par.dbg = 0;
1847                 BytesWritten = 0;
1848                 BytesNeeded = 0;
1849                 if (bset) {
1850                         oid_par.bytes_rw = &BytesRead;
1851                         oid_par.bytes_needed = &BytesNeeded;
1852                         oid_par.type_of_oid = SET_OID;
1853                 } else {
1854                         oid_par.bytes_rw = &BytesWritten;
1855                         oid_par.bytes_needed = &BytesNeeded;
1856                         oid_par.type_of_oid = QUERY_OID;
1857                 }
1858                 status = phandler->handler(&oid_par);
1859                 /* todo:check status, BytesNeeded, etc. */
1860         } else {
1861                 netdev_info(dev, "r8712u: %s: err!, subcode=%d, oid=%d, handler=%p\n",
1862                             __func__, poidparam->subcode, phandler->oid,
1863                             phandler->handler);
1864                 ret = -EFAULT;
1865                 goto _r871x_mp_ioctl_hdl_exit;
1866         }
1867         if (bset == 0x00) { /* query info */
1868                 if (copy_to_user(p->pointer, pparmbuf, len))
1869                         ret = -EFAULT;
1870         }
1871         if (status) {
1872                 ret = -EFAULT;
1873                 goto _r871x_mp_ioctl_hdl_exit;
1874         }
1875 _r871x_mp_ioctl_hdl_exit:
1876         kfree(pparmbuf);
1877         return ret;
1878 }
1879
1880 static int r871x_get_ap_info(struct net_device *dev,
1881                                 struct iw_request_info *info,
1882                                 union iwreq_data *wrqu, char *extra)
1883 {
1884         struct _adapter *padapter = netdev_priv(dev);
1885         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1886         struct  __queue *queue = &pmlmepriv->scanned_queue;
1887         struct iw_point *pdata = &wrqu->data;
1888         struct wlan_network *pnetwork = NULL;
1889         u32 cnt = 0, wpa_ielen;
1890         unsigned long irqL;
1891         struct list_head *plist, *phead;
1892         unsigned char *pbuf;
1893         u8 bssid[ETH_ALEN];
1894         char data[33];
1895
1896         if (padapter->driver_stopped || !pdata)
1897                 return -EINVAL;
1898         while (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY |
1899                              _FW_UNDER_LINKING)) {
1900                 msleep(30);
1901                 cnt++;
1902                 if (cnt > 100)
1903                         break;
1904         }
1905         pdata->flags = 0;
1906         if (pdata->length < 32)
1907                 return -EINVAL;
1908         if (copy_from_user(data, pdata->pointer, 32))
1909                 return -EINVAL;
1910         data[32] = 0;
1911
1912         spin_lock_irqsave(&pmlmepriv->scanned_queue.lock, irqL);
1913         phead = &queue->queue;
1914         plist = phead->next;
1915         while (1) {
1916                 if (end_of_queue_search(phead, plist))
1917                         break;
1918                 pnetwork = container_of(plist, struct wlan_network, list);
1919                 if (!mac_pton(data, bssid)) {
1920                         netdev_info(dev, "r8712u: Invalid BSSID '%s'.\n",
1921                                     (u8 *)data);
1922                         spin_unlock_irqrestore(&pmlmepriv->scanned_queue.lock,
1923                                                irqL);
1924                         return -EINVAL;
1925                 }
1926                 netdev_info(dev, "r8712u: BSSID:%pM\n", bssid);
1927                 if (ether_addr_equal(bssid, pnetwork->network.MacAddress)) {
1928                         /* BSSID match, then check if supporting wpa/wpa2 */
1929                         pbuf = r8712_get_wpa_ie(&pnetwork->network.IEs[12],
1930                                &wpa_ielen, pnetwork->network.IELength - 12);
1931                         if (pbuf && (wpa_ielen > 0)) {
1932                                 pdata->flags = 1;
1933                                 break;
1934                         }
1935                         pbuf = r8712_get_wpa2_ie(&pnetwork->network.IEs[12],
1936                                &wpa_ielen, pnetwork->network.IELength - 12);
1937                         if (pbuf && (wpa_ielen > 0)) {
1938                                 pdata->flags = 2;
1939                                 break;
1940                         }
1941                 }
1942                 plist = plist->next;
1943         }
1944         spin_unlock_irqrestore(&pmlmepriv->scanned_queue.lock, irqL);
1945         if (pdata->length >= 34) {
1946                 if (copy_to_user((u8 __user *)pdata->pointer + 32,
1947                     (u8 *)&pdata->flags, 1))
1948                         return -EINVAL;
1949         }
1950         return 0;
1951 }
1952
1953 static int r871x_set_pid(struct net_device *dev,
1954                                 struct iw_request_info *info,
1955                                 union iwreq_data *wrqu, char *extra)
1956 {
1957         struct _adapter *padapter = netdev_priv(dev);
1958         struct iw_point *pdata = &wrqu->data;
1959
1960         if (padapter->driver_stopped || !pdata)
1961                 return -EINVAL;
1962         if (copy_from_user(&padapter->pid, pdata->pointer, sizeof(int)))
1963                 return -EINVAL;
1964         return 0;
1965 }
1966
1967 static int r871x_set_chplan(struct net_device *dev,
1968                                 struct iw_request_info *info,
1969                                 union iwreq_data *wrqu, char *extra)
1970 {
1971         int ret = 0;
1972         struct _adapter *padapter = netdev_priv(dev);
1973         struct iw_point *pdata = &wrqu->data;
1974         int ch_plan = -1;
1975
1976         if (padapter->driver_stopped || !pdata) {
1977                 ret = -EINVAL;
1978                 goto exit;
1979         }
1980         ch_plan = (int)*extra;
1981         r8712_set_chplan_cmd(padapter, ch_plan);
1982
1983 exit:
1984
1985         return ret;
1986 }
1987
1988 static int r871x_wps_start(struct net_device *dev,
1989                            struct iw_request_info *info,
1990                            union iwreq_data *wrqu, char *extra)
1991 {
1992         struct _adapter *padapter = netdev_priv(dev);
1993         struct iw_point *pdata = &wrqu->data;
1994         u32   u32wps_start = 0;
1995
1996         if (padapter->driver_stopped || !pdata)
1997                 return -EINVAL;
1998         if (copy_from_user((void *)&u32wps_start, pdata->pointer, 4))
1999                 return -EFAULT;
2000         if (u32wps_start == 0)
2001                 u32wps_start = *extra;
2002         if (u32wps_start == 1) /* WPS Start */
2003                 padapter->ledpriv.LedControlHandler(padapter,
2004                            LED_CTL_START_WPS);
2005         else if (u32wps_start == 2) /* WPS Stop because of wps success */
2006                 padapter->ledpriv.LedControlHandler(padapter,
2007                            LED_CTL_STOP_WPS);
2008         else if (u32wps_start == 3) /* WPS Stop because of wps fail */
2009                 padapter->ledpriv.LedControlHandler(padapter,
2010                            LED_CTL_STOP_WPS_FAIL);
2011         return 0;
2012 }
2013
2014 static int wpa_set_param(struct net_device *dev, u8 name, u32 value)
2015 {
2016         struct _adapter *padapter = netdev_priv(dev);
2017
2018         switch (name) {
2019         case IEEE_PARAM_WPA_ENABLED:
2020                 padapter->securitypriv.AuthAlgrthm = 2; /* 802.1x */
2021                 switch ((value) & 0xff) {
2022                 case 1: /* WPA */
2023                         padapter->securitypriv.ndisauthtype =
2024                                 Ndis802_11AuthModeWPAPSK; /* WPA_PSK */
2025                         padapter->securitypriv.ndisencryptstatus =
2026                                 Ndis802_11Encryption2Enabled;
2027                         break;
2028                 case 2: /* WPA2 */
2029                         padapter->securitypriv.ndisauthtype =
2030                                 Ndis802_11AuthModeWPA2PSK; /* WPA2_PSK */
2031                         padapter->securitypriv.ndisencryptstatus =
2032                                 Ndis802_11Encryption3Enabled;
2033                         break;
2034                 }
2035                 break;
2036         case IEEE_PARAM_TKIP_COUNTERMEASURES:
2037                 break;
2038         case IEEE_PARAM_DROP_UNENCRYPTED:
2039                 /* HACK:
2040                  *
2041                  * wpa_supplicant calls set_wpa_enabled when the driver
2042                  * is loaded and unloaded, regardless of if WPA is being
2043                  * used.  No other calls are made which can be used to
2044                  * determine if encryption will be used or not prior to
2045                  * association being expected.  If encryption is not being
2046                  * used, drop_unencrypted is set to false, else true -- we
2047                  * can use this to determine if the CAP_PRIVACY_ON bit should
2048                  * be set.
2049                  */
2050                 break;
2051         case IEEE_PARAM_PRIVACY_INVOKED:
2052                 break;
2053         case IEEE_PARAM_AUTH_ALGS:
2054                 return wpa_set_auth_algs(dev, value);
2055         case IEEE_PARAM_IEEE_802_1X:
2056                 break;
2057         case IEEE_PARAM_WPAX_SELECT:
2058                 /* added for WPA2 mixed mode */
2059                 break;
2060         default:
2061                 return -EOPNOTSUPP;
2062         }
2063         return 0;
2064 }
2065
2066 static int wpa_mlme(struct net_device *dev, u32 command, u32 reason)
2067 {
2068         struct _adapter *padapter = netdev_priv(dev);
2069
2070         switch (command) {
2071         case IEEE_MLME_STA_DEAUTH:
2072                 if (!r8712_set_802_11_disassociate(padapter))
2073                         return -1;
2074                 break;
2075         case IEEE_MLME_STA_DISASSOC:
2076                 if (!r8712_set_802_11_disassociate(padapter))
2077                         return -1;
2078                 break;
2079         default:
2080                 return -EOPNOTSUPP;
2081         }
2082         return 0;
2083 }
2084
2085 static int wpa_supplicant_ioctl(struct net_device *dev, struct iw_point *p)
2086 {
2087         struct ieee_param *param;
2088         int ret = 0;
2089         struct _adapter *padapter = netdev_priv(dev);
2090
2091         if (p->length < sizeof(struct ieee_param) || !p->pointer)
2092                 return -EINVAL;
2093         param = memdup_user(p->pointer, p->length);
2094         if (IS_ERR(param))
2095                 return PTR_ERR(param);
2096         switch (param->cmd) {
2097         case IEEE_CMD_SET_WPA_PARAM:
2098                 ret = wpa_set_param(dev, param->u.wpa_param.name,
2099                       param->u.wpa_param.value);
2100                 break;
2101         case IEEE_CMD_SET_WPA_IE:
2102                 ret =  r871x_set_wpa_ie(padapter, (char *)param->u.wpa_ie.data,
2103                        (u16)param->u.wpa_ie.len);
2104                 break;
2105         case IEEE_CMD_SET_ENCRYPTION:
2106                 ret = wpa_set_encryption(dev, param, p->length);
2107                 break;
2108         case IEEE_CMD_MLME:
2109                 ret = wpa_mlme(dev, param->u.mlme.command,
2110                       param->u.mlme.reason_code);
2111                 break;
2112         default:
2113                 ret = -EOPNOTSUPP;
2114                 break;
2115         }
2116         if (ret == 0 && copy_to_user(p->pointer, param, p->length))
2117                 ret = -EFAULT;
2118         kfree(param);
2119         return ret;
2120 }
2121
2122 /* based on "driver_ipw" and for hostapd */
2123 int r871x_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2124 {
2125         struct iwreq *wrq = (struct iwreq *)rq;
2126
2127         switch (cmd) {
2128         case RTL_IOCTL_WPA_SUPPLICANT:
2129                 return wpa_supplicant_ioctl(dev, &wrq->u.data);
2130         default:
2131                 return -EOPNOTSUPP;
2132         }
2133         return 0;
2134 }
2135
2136 static iw_handler r8711_handlers[] = {
2137         NULL,                           /* SIOCSIWCOMMIT */
2138         r8711_wx_get_name,              /* SIOCGIWNAME */
2139         dummy,                          /* SIOCSIWNWID */
2140         dummy,                          /* SIOCGIWNWID */
2141         r8711_wx_set_freq,              /* SIOCSIWFREQ */
2142         r8711_wx_get_freq,              /* SIOCGIWFREQ */
2143         r8711_wx_set_mode,              /* SIOCSIWMODE */
2144         r8711_wx_get_mode,              /* SIOCGIWMODE */
2145         dummy,                          /* SIOCSIWSENS */
2146         r8711_wx_get_sens,              /* SIOCGIWSENS */
2147         NULL,                           /* SIOCSIWRANGE */
2148         r8711_wx_get_range,             /* SIOCGIWRANGE */
2149         r871x_wx_set_priv,              /* SIOCSIWPRIV */
2150         NULL,                           /* SIOCGIWPRIV */
2151         NULL,                           /* SIOCSIWSTATS */
2152         NULL,                           /* SIOCGIWSTATS */
2153         dummy,                          /* SIOCSIWSPY */
2154         dummy,                          /* SIOCGIWSPY */
2155         NULL,                           /* SIOCGIWTHRSPY */
2156         NULL,                           /* SIOCWIWTHRSPY */
2157         r8711_wx_set_wap,               /* SIOCSIWAP */
2158         r8711_wx_get_wap,               /* SIOCGIWAP */
2159         r871x_wx_set_mlme,              /* request MLME operation;
2160                                          *  uses struct iw_mlme
2161                                          */
2162         dummy,                          /* SIOCGIWAPLIST -- deprecated */
2163         r8711_wx_set_scan,              /* SIOCSIWSCAN */
2164         r8711_wx_get_scan,              /* SIOCGIWSCAN */
2165         r8711_wx_set_essid,             /* SIOCSIWESSID */
2166         r8711_wx_get_essid,             /* SIOCGIWESSID */
2167         dummy,                          /* SIOCSIWNICKN */
2168         r871x_wx_get_nick,              /* SIOCGIWNICKN */
2169         NULL,                           /* -- hole -- */
2170         NULL,                           /* -- hole -- */
2171         r8711_wx_set_rate,              /* SIOCSIWRATE */
2172         r8711_wx_get_rate,              /* SIOCGIWRATE */
2173         dummy,                          /* SIOCSIWRTS */
2174         r8711_wx_get_rts,               /* SIOCGIWRTS */
2175         r8711_wx_set_frag,              /* SIOCSIWFRAG */
2176         r8711_wx_get_frag,              /* SIOCGIWFRAG */
2177         dummy,                          /* SIOCSIWTXPOW */
2178         dummy,                          /* SIOCGIWTXPOW */
2179         dummy,                          /* SIOCSIWRETRY */
2180         r8711_wx_get_retry,             /* SIOCGIWRETRY */
2181         r8711_wx_set_enc,               /* SIOCSIWENCODE */
2182         r8711_wx_get_enc,               /* SIOCGIWENCODE */
2183         dummy,                          /* SIOCSIWPOWER */
2184         r8711_wx_get_power,             /* SIOCGIWPOWER */
2185         NULL,                           /*---hole---*/
2186         NULL,                           /*---hole---*/
2187         r871x_wx_set_gen_ie,            /* SIOCSIWGENIE */
2188         NULL,                           /* SIOCGIWGENIE */
2189         r871x_wx_set_auth,              /* SIOCSIWAUTH */
2190         NULL,                           /* SIOCGIWAUTH */
2191         r871x_wx_set_enc_ext,           /* SIOCSIWENCODEEXT */
2192         NULL,                           /* SIOCGIWENCODEEXT */
2193         r871x_wx_set_pmkid,             /* SIOCSIWPMKSA */
2194         NULL,                           /*---hole---*/
2195 };
2196
2197 static const struct iw_priv_args r8711_private_args[] = {
2198         {
2199                 SIOCIWFIRSTPRIV + 0x0,
2200                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "read32"
2201         },
2202         {
2203                 SIOCIWFIRSTPRIV + 0x1,
2204                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "write32"
2205         },
2206         {
2207                 SIOCIWFIRSTPRIV + 0x2, 0, 0, "driver_ext"
2208         },
2209         {
2210                 SIOCIWFIRSTPRIV + 0x3, 0, 0, "mp_ioctl"
2211         },
2212         {
2213                 SIOCIWFIRSTPRIV + 0x4,
2214                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "apinfo"
2215         },
2216         {
2217                 SIOCIWFIRSTPRIV + 0x5,
2218                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "setpid"
2219         },
2220         {
2221                 SIOCIWFIRSTPRIV + 0x6,
2222                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_start"
2223         },
2224         {
2225                 SIOCIWFIRSTPRIV + 0x7,
2226                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "chplan"
2227         }
2228 };
2229
2230 static iw_handler r8711_private_handler[] = {
2231         r8711_wx_read32,
2232         r8711_wx_write32,
2233         r8711_drvext_hdl,
2234         r871x_mp_ioctl_hdl,
2235         r871x_get_ap_info, /*for MM DTV platform*/
2236         r871x_set_pid,
2237         r871x_wps_start,
2238         r871x_set_chplan
2239 };
2240
2241 static struct iw_statistics *r871x_get_wireless_stats(struct net_device *dev)
2242 {
2243         struct _adapter *padapter = netdev_priv(dev);
2244         struct iw_statistics *piwstats = &padapter->iwstats;
2245         int tmp_level = 0;
2246         int tmp_qual = 0;
2247         int tmp_noise = 0;
2248
2249         if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) != true) {
2250                 piwstats->qual.qual = 0;
2251                 piwstats->qual.level = 0;
2252                 piwstats->qual.noise = 0;
2253         } else {
2254                 /* show percentage, we need transfer dbm to original value. */
2255                 tmp_level = padapter->recvpriv.fw_rssi;
2256                 tmp_qual = padapter->recvpriv.signal;
2257                 tmp_noise = padapter->recvpriv.noise;
2258                 piwstats->qual.level = tmp_level;
2259                 piwstats->qual.qual = tmp_qual;
2260                 piwstats->qual.noise = tmp_noise;
2261         }
2262         piwstats->qual.updated = IW_QUAL_ALL_UPDATED;
2263         return &padapter->iwstats;
2264 }
2265
2266 struct iw_handler_def r871x_handlers_def = {
2267         .standard = r8711_handlers,
2268         .num_standard = ARRAY_SIZE(r8711_handlers),
2269         .private = r8711_private_handler,
2270         .private_args = (struct iw_priv_args *)r8711_private_args,
2271         .num_private = ARRAY_SIZE(r8711_private_handler),
2272         .num_private_args = sizeof(r8711_private_args) /
2273                             sizeof(struct iw_priv_args),
2274         .get_wireless_stats = r871x_get_wireless_stats
2275 };