drivers/staging/rtl8188eu/os_dep/ioctl_linux.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
   5  *
   6  ******************************************************************************/
   7 #define _IOCTL_LINUX_C_
   8
   9 #include <linux/ieee80211.h>
  10
  11 #include <osdep_service.h>
  12 #include <drv_types.h>
  13 #include <wlan_bssdef.h>
  14 #include <rtw_debug.h>
  15 #include <wifi.h>
  16 #include <rtw_mlme.h>
  17 #include <rtw_mlme_ext.h>
  18 #include <rtw_ioctl.h>
  19 #include <rtw_ioctl_set.h>
  20 #include <rtl8188e_hal.h>
  21
  22 #include <linux/vmalloc.h>
  23 #include <linux/etherdevice.h>
  24
  25 #include "osdep_intf.h"
  26
  27 #define RTL_IOCTL_WPA_SUPPLICANT        (SIOCIWFIRSTPRIV + 30)
  28
  29 #define SCAN_ITEM_SIZE 768
  30 #define MAX_CUSTOM_LEN 64
  31 #define RATE_COUNT 4
  32
  33 /*  combo scan */
  34 #define WEXT_CSCAN_AMOUNT 9
  35 #define WEXT_CSCAN_BUF_LEN              360
  36 #define WEXT_CSCAN_HEADER               "CSCAN S\x01\x00\x00S\x00"
  37 #define WEXT_CSCAN_HEADER_SIZE          12
  38 #define WEXT_CSCAN_SSID_SECTION         'S'
  39 #define WEXT_CSCAN_CHANNEL_SECTION      'C'
  40 #define WEXT_CSCAN_NPROBE_SECTION       'N'
  41 #define WEXT_CSCAN_ACTV_DWELL_SECTION   'A'
  42 #define WEXT_CSCAN_PASV_DWELL_SECTION   'P'
  43 #define WEXT_CSCAN_HOME_DWELL_SECTION   'H'
  44 #define WEXT_CSCAN_TYPE_SECTION         'T'
  45
  46 static u32 rtw_rates[] = {1000000, 2000000, 5500000, 11000000,
  47         6000000, 9000000, 12000000, 18000000, 24000000, 36000000,
  48         48000000, 54000000};
  49
  50 static const char * const iw_operation_mode[] = {
  51         "Auto", "Ad-Hoc", "Managed",  "Master", "Repeater",
  52         "Secondary", "Monitor"
  53 };
  54
  55 void indicate_wx_scan_complete_event(struct adapter *padapter)
  56 {
  57         union iwreq_data wrqu;
  58
  59         memset(&wrqu, 0, sizeof(union iwreq_data));
  60         wireless_send_event(padapter->pnetdev, SIOCGIWSCAN, &wrqu, NULL);
  61 }
  62
  63 void rtw_indicate_wx_assoc_event(struct adapter *padapter)
  64 {
  65         union iwreq_data wrqu;
  66         struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
  67
  68         memset(&wrqu, 0, sizeof(union iwreq_data));
  69
  70         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
  71
  72         memcpy(wrqu.ap_addr.sa_data, pmlmepriv->cur_network.network.MacAddress, ETH_ALEN);
  73
  74         DBG_88E_LEVEL(_drv_always_, "assoc success\n");
  75         wireless_send_event(padapter->pnetdev, SIOCGIWAP, &wrqu, NULL);
  76 }
  77
  78 void rtw_indicate_wx_disassoc_event(struct adapter *padapter)
  79 {
  80         union iwreq_data wrqu;
  81
  82         memset(&wrqu, 0, sizeof(union iwreq_data));
  83
  84         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
  85         eth_zero_addr(wrqu.ap_addr.sa_data);
  86
  87         DBG_88E_LEVEL(_drv_always_, "indicate disassoc\n");
  88         wireless_send_event(padapter->pnetdev, SIOCGIWAP, &wrqu, NULL);
  89 }
  90
  91 static char *translate_scan(struct adapter *padapter,
  92                             struct iw_request_info *info,
  93                             struct wlan_network *pnetwork,
  94                             char *start, char *stop)
  95 {
  96         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
  97         struct iw_event iwe;
  98         u16 cap;
  99         __le16 le_tmp;
 100         u32 ht_ielen = 0;
 101         char custom[MAX_CUSTOM_LEN];
 102         char *p;
 103         u16 max_rate = 0, rate, ht_cap = false;
 104         u32 i = 0;
 105         u8 bw_40MHz = 0, short_GI = 0;
 106         u16 mcs_rate = 0;
 107         u8 ss, sq;
 108
 109         /*  AP MAC address  */
 110         iwe.cmd = SIOCGIWAP;
 111         iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
 112
 113         memcpy(iwe.u.ap_addr.sa_data, pnetwork->network.MacAddress, ETH_ALEN);
 114         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_ADDR_LEN);
 115
 116         /* Add the ESSID */
 117         iwe.cmd = SIOCGIWESSID;
 118         iwe.u.data.flags = 1;
 119         iwe.u.data.length = min_t(u16, pnetwork->network.Ssid.SsidLength, 32);
 120         start = iwe_stream_add_point(info, start, stop, &iwe, pnetwork->network.Ssid.Ssid);
 121
 122         /* parsing HT_CAP_IE */
 123         p = rtw_get_ie(&pnetwork->network.ies[12], _HT_CAPABILITY_IE_, &ht_ielen, pnetwork->network.ie_length-12);
 124
 125         if (p && ht_ielen > 0) {
 126                 struct ieee80211_ht_cap *pht_capie;
 127                 ht_cap = true;
 128
 129                 pht_capie = (struct ieee80211_ht_cap *)(p + 2);
 130                 memcpy(&mcs_rate, pht_capie->mcs.rx_mask, 2);
 131                 bw_40MHz = !!(le16_to_cpu(pht_capie->cap_info) &
 132                               IEEE80211_HT_CAP_SUP_WIDTH);
 133                 short_GI = !!(le16_to_cpu(pht_capie->cap_info) &
 134                               (IEEE80211_HT_CAP_SGI_20 |
 135                                IEEE80211_HT_CAP_SGI_40));
 136         }
 137
 138         /* Add the protocol name */
 139         iwe.cmd = SIOCGIWNAME;
 140         if ((rtw_is_cckratesonly_included((u8 *)&pnetwork->network.SupportedRates))) {
 141                 if (ht_cap)
 142                         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bn");
 143                 else
 144                         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11b");
 145         } else if ((rtw_is_cckrates_included((u8 *)&pnetwork->network.SupportedRates))) {
 146                 if (ht_cap)
 147                         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bgn");
 148                 else
 149                         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bg");
 150         } else {
 151                 if (pnetwork->network.Configuration.DSConfig > 14) {
 152                         if (ht_cap)
 153                                 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11an");
 154                         else
 155                                 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11a");
 156                 } else {
 157                         if (ht_cap)
 158                                 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11gn");
 159                         else
 160                                 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11g");
 161                 }
 162         }
 163
 164         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_CHAR_LEN);
 165
 166           /* Add mode */
 167         iwe.cmd = SIOCGIWMODE;
 168         memcpy(&le_tmp, rtw_get_capability_from_ie(pnetwork->network.ies), 2);
 169
 170         cap = le16_to_cpu(le_tmp);
 171
 172         if (!WLAN_CAPABILITY_IS_STA_BSS(cap)) {
 173                 if (cap & WLAN_CAPABILITY_ESS)
 174                         iwe.u.mode = IW_MODE_MASTER;
 175                 else
 176                         iwe.u.mode = IW_MODE_ADHOC;
 177
 178                 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_UINT_LEN);
 179         }
 180
 181         if (pnetwork->network.Configuration.DSConfig < 1)
 182                 pnetwork->network.Configuration.DSConfig = 1;
 183
 184          /* Add frequency/channel */
 185         iwe.cmd = SIOCGIWFREQ;
 186         iwe.u.freq.m = rtw_ch2freq(pnetwork->network.Configuration.DSConfig) * 100000;
 187         iwe.u.freq.e = 1;
 188         iwe.u.freq.i = pnetwork->network.Configuration.DSConfig;
 189         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_FREQ_LEN);
 190
 191         /* Add encryption capability */
 192         iwe.cmd = SIOCGIWENCODE;
 193         if (cap & WLAN_CAPABILITY_PRIVACY)
 194                 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
 195         else
 196                 iwe.u.data.flags = IW_ENCODE_DISABLED;
 197         iwe.u.data.length = 0;
 198         start = iwe_stream_add_point(info, start, stop, &iwe, pnetwork->network.Ssid.Ssid);
 199
 200         /*Add basic and extended rates */
 201         max_rate = 0;
 202         p = custom;
 203         p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), " Rates (Mb/s): ");
 204         while (pnetwork->network.SupportedRates[i] != 0) {
 205                 rate = pnetwork->network.SupportedRates[i]&0x7F;
 206                 if (rate > max_rate)
 207                         max_rate = rate;
 208                 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
 209                               "%d%s ", rate >> 1, (rate & 1) ? ".5" : "");
 210                 i++;
 211         }
 212
 213         if (ht_cap) {
 214                 if (mcs_rate&0x8000)/* MCS15 */
 215                         max_rate = (bw_40MHz) ? ((short_GI) ? 300 : 270) : ((short_GI) ? 144 : 130);
 216                 else if (mcs_rate&0x0080)/* MCS7 */
 217                         ;
 218                 else/* default MCS7 */
 219                         max_rate = (bw_40MHz) ? ((short_GI) ? 150 : 135) : ((short_GI) ? 72 : 65);
 220
 221                 max_rate = max_rate*2;/* Mbps/2; */
 222         }
 223
 224         iwe.cmd = SIOCGIWRATE;
 225         iwe.u.bitrate.fixed = 0;
 226         iwe.u.bitrate.disabled = 0;
 227         iwe.u.bitrate.value = max_rate * 500000;
 228         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_PARAM_LEN);
 229
 230         /* parsing WPA/WPA2 IE */
 231         {
 232                 u8 *buf;
 233                 u8 wpa_ie[255], rsn_ie[255];
 234                 u16 wpa_len = 0, rsn_len = 0;
 235                 u8 *p;
 236
 237                 buf = kzalloc(MAX_WPA_IE_LEN, GFP_ATOMIC);
 238                 if (!buf)
 239                         return start;
 240
 241                 rtw_get_sec_ie(pnetwork->network.ies, pnetwork->network.ie_length, rsn_ie, &rsn_len, wpa_ie, &wpa_len);
 242                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_scan: ssid =%s\n", pnetwork->network.Ssid.Ssid));
 243                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_scan: wpa_len =%d rsn_len =%d\n", wpa_len, rsn_len));
 244
 245                 if (wpa_len > 0) {
 246                         p = buf;
 247                         p += sprintf(p, "wpa_ie=");
 248                         for (i = 0; i < wpa_len; i++)
 249                                 p += sprintf(p, "%02x", wpa_ie[i]);
 250
 251                         memset(&iwe, 0, sizeof(iwe));
 252                         iwe.cmd = IWEVCUSTOM;
 253                         iwe.u.data.length = strlen(buf);
 254                         start = iwe_stream_add_point(info, start, stop, &iwe, buf);
 255
 256                         memset(&iwe, 0, sizeof(iwe));
 257                         iwe.cmd = IWEVGENIE;
 258                         iwe.u.data.length = wpa_len;
 259                         start = iwe_stream_add_point(info, start, stop, &iwe, wpa_ie);
 260                 }
 261                 if (rsn_len > 0) {
 262                         p = buf;
 263                         p += sprintf(p, "rsn_ie=");
 264                         for (i = 0; i < rsn_len; i++)
 265                                 p += sprintf(p, "%02x", rsn_ie[i]);
 266                         memset(&iwe, 0, sizeof(iwe));
 267                         iwe.cmd = IWEVCUSTOM;
 268                         iwe.u.data.length = strlen(buf);
 269                         start = iwe_stream_add_point(info, start, stop, &iwe, buf);
 270
 271                         memset(&iwe, 0, sizeof(iwe));
 272                         iwe.cmd = IWEVGENIE;
 273                         iwe.u.data.length = rsn_len;
 274                         start = iwe_stream_add_point(info, start, stop, &iwe, rsn_ie);
 275                 }
 276                 kfree(buf);
 277         }
 278
 279         {/* parsing WPS IE */
 280                 uint cnt = 0, total_ielen;
 281                 u8 *wpsie_ptr = NULL;
 282                 uint wps_ielen = 0;
 283                 u8 *ie_ptr = pnetwork->network.ies + _FIXED_IE_LENGTH_;
 284
 285                 total_ielen = pnetwork->network.ie_length - _FIXED_IE_LENGTH_;
 286
 287                 while (cnt < total_ielen) {
 288                         if (rtw_is_wps_ie(&ie_ptr[cnt], &wps_ielen) && (wps_ielen > 2)) {
 289                                 wpsie_ptr = &ie_ptr[cnt];
 290                                 iwe.cmd = IWEVGENIE;
 291                                 iwe.u.data.length = (u16)wps_ielen;
 292                                 start = iwe_stream_add_point(info, start, stop, &iwe, wpsie_ptr);
 293                         }
 294                         cnt += ie_ptr[cnt+1]+2; /* goto next */
 295                 }
 296         }
 297
 298         /* Add quality statistics */
 299         iwe.cmd = IWEVQUAL;
 300         iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_INVALID;
 301
 302         if (check_fwstate(pmlmepriv, _FW_LINKED) == true &&
 303             is_same_network(&pmlmepriv->cur_network.network, &pnetwork->network)) {
 304                 ss = padapter->recvpriv.signal_strength;
 305                 sq = padapter->recvpriv.signal_qual;
 306         } else {
 307                 ss = pnetwork->network.PhyInfo.SignalStrength;
 308                 sq = pnetwork->network.PhyInfo.SignalQuality;
 309         }
 310
 311         iwe.u.qual.level = (u8)ss;
 312         iwe.u.qual.qual = (u8)sq;   /*  signal quality */
 313         iwe.u.qual.noise = 0; /*  noise level */
 314         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_QUAL_LEN);
 315         return start;
 316 }
 317
 318 static int wpa_set_auth_algs(struct net_device *dev, u32 value)
 319 {
 320         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 321         int ret = 0;
 322
 323         if ((value & AUTH_ALG_SHARED_KEY) && (value & AUTH_ALG_OPEN_SYSTEM)) {
 324                 DBG_88E("wpa_set_auth_algs, AUTH_ALG_SHARED_KEY and  AUTH_ALG_OPEN_SYSTEM [value:0x%x]\n", value);
 325                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 326                 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeAutoSwitch;
 327                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
 328         } else if (value & AUTH_ALG_SHARED_KEY) {
 329                 DBG_88E("wpa_set_auth_algs, AUTH_ALG_SHARED_KEY  [value:0x%x]\n", value);
 330                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 331
 332                 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeShared;
 333                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Shared;
 334         } else if (value & AUTH_ALG_OPEN_SYSTEM) {
 335                 DBG_88E("wpa_set_auth_algs, AUTH_ALG_OPEN_SYSTEM\n");
 336                 if (padapter->securitypriv.ndisauthtype < Ndis802_11AuthModeWPAPSK) {
 337                         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen;
 338                         padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
 339                 }
 340         } else if (value & AUTH_ALG_LEAP) {
 341                 DBG_88E("wpa_set_auth_algs, AUTH_ALG_LEAP\n");
 342         } else {
 343                 DBG_88E("wpa_set_auth_algs, error!\n");
 344                 ret = -EINVAL;
 345         }
 346         return ret;
 347 }
 348
 349 static int wpa_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len)
 350 {
 351         int ret = 0;
 352         u32 wep_key_idx, wep_key_len, wep_total_len;
 353         struct ndis_802_11_wep   *pwep = NULL;
 354         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 355         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
 356         struct security_priv *psecuritypriv = &padapter->securitypriv;
 357
 358         param->u.crypt.err = 0;
 359         param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
 360
 361         if (param_len < (u32)((u8 *)param->u.crypt.key - (u8 *)param) + param->u.crypt.key_len) {
 362                 ret =  -EINVAL;
 363                 goto exit;
 364         }
 365
 366         if (is_broadcast_ether_addr(param->sta_addr)) {
 367                 if (param->u.crypt.idx >= WEP_KEYS) {
 368                         ret = -EINVAL;
 369                         goto exit;
 370                 }
 371         } else {
 372                 ret = -EINVAL;
 373                 goto exit;
 374         }
 375
 376         if (strcmp(param->u.crypt.alg, "WEP") == 0) {
 377                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("wpa_set_encryption, crypt.alg = WEP\n"));
 378                 DBG_88E("wpa_set_encryption, crypt.alg = WEP\n");
 379
 380                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 381                 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
 382                 padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_;
 383
 384                 wep_key_idx = param->u.crypt.idx;
 385                 wep_key_len = param->u.crypt.key_len;
 386
 387                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("(1)wep_key_idx =%d\n", wep_key_idx));
 388                 DBG_88E("(1)wep_key_idx =%d\n", wep_key_idx);
 389
 390                 if (wep_key_idx > WEP_KEYS)
 391                         return -EINVAL;
 392
 393                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("(2)wep_key_idx =%d\n", wep_key_idx));
 394
 395                 if (wep_key_len > 0) {
 396                         wep_key_len = wep_key_len <= 5 ? 5 : 13;
 397                         wep_total_len = wep_key_len + offsetof(struct ndis_802_11_wep, KeyMaterial);
 398                         pwep = (struct ndis_802_11_wep *)rtw_malloc(wep_total_len);
 399                         if (!pwep) {
 400                                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, (" wpa_set_encryption: pwep allocate fail !!!\n"));
 401                                 goto exit;
 402                         }
 403                         memset(pwep, 0, wep_total_len);
 404                         pwep->KeyLength = wep_key_len;
 405                         pwep->Length = wep_total_len;
 406                         if (wep_key_len == 13) {
 407                                 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
 408                                 padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_;
 409                         }
 410                 } else {
 411                         ret = -EINVAL;
 412                         goto exit;
 413                 }
 414                 pwep->KeyIndex = wep_key_idx;
 415                 pwep->KeyIndex |= 0x80000000;
 416                 memcpy(pwep->KeyMaterial,  param->u.crypt.key, pwep->KeyLength);
 417                 if (param->u.crypt.set_tx) {
 418                         DBG_88E("wep, set_tx = 1\n");
 419                         if (rtw_set_802_11_add_wep(padapter, pwep) == (u8)_FAIL)
 420                                 ret = -EOPNOTSUPP;
 421                 } else {
 422                         DBG_88E("wep, set_tx = 0\n");
 423                         if (wep_key_idx >= WEP_KEYS) {
 424                                 ret = -EOPNOTSUPP;
 425                                 goto exit;
 426                         }
 427                       memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength);
 428                         psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->KeyLength;
 429                         rtw_set_key(padapter, psecuritypriv, wep_key_idx, 0);
 430                 }
 431                 goto exit;
 432         }
 433
 434         if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) { /*  802_1x */
 435                 struct sta_info *psta, *pbcmc_sta;
 436                 struct sta_priv *pstapriv = &padapter->stapriv;
 437
 438                 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) { /* sta mode */
 439                         psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
 440                         if (!psta) {
 441                                 ;
 442                         } else {
 443                                 if (strcmp(param->u.crypt.alg, "none") != 0)
 444                                         psta->ieee8021x_blocked = false;
 445
 446                                 if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled) ||
 447                                     (padapter->securitypriv.ndisencryptstatus ==  Ndis802_11Encryption3Enabled))
 448                                         psta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
 449
 450                                 if (param->u.crypt.set_tx == 1) { /* pairwise key */
 451                                         memcpy(psta->dot118021x_UncstKey.skey,  param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
 452
 453                                         if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */
 454                                                 memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8);
 455                                                 memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8);
 456                                                 padapter->securitypriv.busetkipkey = false;
 457                                         }
 458
 459                                         DBG_88E(" ~~~~set sta key:unicastkey\n");
 460
 461                                         rtw_setstakey_cmd(padapter, (unsigned char *)psta, true);
 462                                 } else { /* group key */
 463                                         memcpy(padapter->securitypriv.dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16 ));
 464                                         memcpy(padapter->securitypriv.dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8);
 465                                         memcpy(padapter->securitypriv.dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8);
 466                                         padapter->securitypriv.binstallGrpkey = true;
 467                                         DBG_88E(" ~~~~set sta key:groupkey\n");
 468
 469                                         padapter->securitypriv.dot118021XGrpKeyid = param->u.crypt.idx;
 470
 471                                         rtw_set_key(padapter, &padapter->securitypriv, param->u.crypt.idx, 1);
 472                                 }
 473                         }
 474                         pbcmc_sta = rtw_get_bcmc_stainfo(padapter);
 475                         if (!pbcmc_sta) {
 476                                 ;
 477                         } else {
 478                                 /* Jeff: don't disable ieee8021x_blocked while clearing key */
 479                                 if (strcmp(param->u.crypt.alg, "none") != 0)
 480                                         pbcmc_sta->ieee8021x_blocked = false;
 481
 482                                 if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled) ||
 483                                     (padapter->securitypriv.ndisencryptstatus ==  Ndis802_11Encryption3Enabled))
 484                                         pbcmc_sta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
 485                         }
 486                 }
 487         }
 488
 489 exit:
 490
 491         kfree(pwep);
 492         return ret;
 493 }
 494
 495 static int rtw_set_wpa_ie(struct adapter *padapter, char *pie, unsigned short ielen)
 496 {
 497         u8 *buf = NULL;
 498         int group_cipher = 0, pairwise_cipher = 0;
 499         int ret = 0;
 500
 501         if ((ielen > MAX_WPA_IE_LEN) || (!pie)) {
 502                 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
 503                 if (!pie)
 504                         return ret;
 505                 else
 506                         return -EINVAL;
 507         }
 508
 509         if (ielen) {
 510                 buf = kmemdup(pie, ielen, GFP_KERNEL);
 511                 if (!buf) {
 512                         ret =  -ENOMEM;
 513                         goto exit;
 514                 }
 515
 516                 /* dump */
 517                 {
 518                         int i;
 519
 520                         DBG_88E("\n wpa_ie(length:%d):\n", ielen);
 521                         for (i = 0; i < ielen; i += 8)
 522                                 DBG_88E("0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x\n", buf[i], buf[i+1], buf[i+2], buf[i+3], buf[i+4], buf[i+5], buf[i+6], buf[i+7]);
 523                 }
 524
 525                 if (ielen < RSN_HEADER_LEN) {
 526                         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("Ie len too short %d\n", ielen));
 527                         ret  = -1;
 528                         goto exit;
 529                 }
 530
 531                 if (rtw_parse_wpa_ie(buf, ielen, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) {
 532                         padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
 533                         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPAPSK;
 534                         memcpy(padapter->securitypriv.supplicant_ie, &buf[0], ielen);
 535                 }
 536
 537                 if (rtw_parse_wpa2_ie(buf, ielen, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) {
 538                         padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
 539                         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPA2PSK;
 540                         memcpy(padapter->securitypriv.supplicant_ie, &buf[0], ielen);
 541                 }
 542
 543                 switch (group_cipher) {
 544                 case WPA_CIPHER_NONE:
 545                         padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
 546                         padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
 547                         break;
 548                 case WPA_CIPHER_WEP40:
 549                         padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_;
 550                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 551                         break;
 552                 case WPA_CIPHER_TKIP:
 553                         padapter->securitypriv.dot118021XGrpPrivacy = _TKIP_;
 554                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
 555                         break;
 556                 case WPA_CIPHER_CCMP:
 557                         padapter->securitypriv.dot118021XGrpPrivacy = _AES_;
 558                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
 559                         break;
 560                 case WPA_CIPHER_WEP104:
 561                         padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_;
 562                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 563                         break;
 564                 }
 565
 566                 switch (pairwise_cipher) {
 567                 case WPA_CIPHER_NONE:
 568                         padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
 569                         padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
 570                         break;
 571                 case WPA_CIPHER_WEP40:
 572                         padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
 573                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 574                         break;
 575                 case WPA_CIPHER_TKIP:
 576                         padapter->securitypriv.dot11PrivacyAlgrthm = _TKIP_;
 577                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
 578                         break;
 579                 case WPA_CIPHER_CCMP:
 580                         padapter->securitypriv.dot11PrivacyAlgrthm = _AES_;
 581                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
 582                         break;
 583                 case WPA_CIPHER_WEP104:
 584                         padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
 585                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 586                         break;
 587                 }
 588
 589                 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
 590                 {/* set wps_ie */
 591                         u16 cnt = 0;
 592                         u8 eid, wps_oui[4] = {0x0, 0x50, 0xf2, 0x04};
 593
 594                         while (cnt < ielen) {
 595                                 eid = buf[cnt];
 596                                 if ((eid == _VENDOR_SPECIFIC_IE_) && (!memcmp(&buf[cnt+2], wps_oui, 4))) {
 597                                         DBG_88E("SET WPS_IE\n");
 598
 599                                         padapter->securitypriv.wps_ie_len = min(buf[cnt + 1] + 2, MAX_WPA_IE_LEN << 2);
 600
 601                                         memcpy(padapter->securitypriv.wps_ie, &buf[cnt], padapter->securitypriv.wps_ie_len);
 602
 603                                         set_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS);
 604                                         cnt += buf[cnt+1]+2;
 605                                         break;
 606                                 } else {
 607                                         cnt += buf[cnt+1]+2; /* goto next */
 608                                 }
 609                         }
 610                 }
 611         }
 612
 613         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
 614                  ("rtw_set_wpa_ie: pairwise_cipher = 0x%08x padapter->securitypriv.ndisencryptstatus =%d padapter->securitypriv.ndisauthtype =%d\n",
 615                  pairwise_cipher, padapter->securitypriv.ndisencryptstatus, padapter->securitypriv.ndisauthtype));
 616 exit:
 617         kfree(buf);
 618         return ret;
 619 }
 620
 621 typedef unsigned char   NDIS_802_11_RATES_EX[NDIS_802_11_LENGTH_RATES_EX];
 622
 623 static int rtw_wx_get_name(struct net_device *dev,
 624                              struct iw_request_info *info,
 625                              union iwreq_data *wrqu, char *extra)
 626 {
 627         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 628         u32 ht_ielen = 0;
 629         char *p;
 630         u8 ht_cap = false;
 631         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
 632         struct wlan_bssid_ex  *pcur_bss = &pmlmepriv->cur_network.network;
 633         NDIS_802_11_RATES_EX *prates = NULL;
 634
 635         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("cmd_code =%x\n", info->cmd));
 636
 637         if (check_fwstate(pmlmepriv, _FW_LINKED|WIFI_ADHOC_MASTER_STATE) == true) {
 638                 /* parsing HT_CAP_IE */
 639                 p = rtw_get_ie(&pcur_bss->ies[12], _HT_CAPABILITY_IE_, &ht_ielen, pcur_bss->ie_length-12);
 640                 if (p && ht_ielen > 0)
 641                         ht_cap = true;
 642
 643                 prates = &pcur_bss->SupportedRates;
 644
 645                 if (rtw_is_cckratesonly_included((u8 *)prates)) {
 646                         if (ht_cap)
 647                                 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11bn");
 648                         else
 649                                 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11b");
 650                 } else if (rtw_is_cckrates_included((u8 *)prates)) {
 651                         if (ht_cap)
 652                                 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11bgn");
 653                         else
 654                                 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11bg");
 655                 } else {
 656                         if (pcur_bss->Configuration.DSConfig > 14) {
 657                                 if (ht_cap)
 658                                         snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11an");
 659                                 else
 660                                         snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11a");
 661                         } else {
 662                                 if (ht_cap)
 663                                         snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11gn");
 664                                 else
 665                                         snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11g");
 666                         }
 667                 }
 668         } else {
 669                 snprintf(wrqu->name, IFNAMSIZ, "unassociated");
 670         }
 671         return 0;
 672 }
 673
 674 static int rtw_wx_set_freq(struct net_device *dev,
 675                              struct iw_request_info *info,
 676                              union iwreq_data *wrqu, char *extra)
 677 {
 678         RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_, ("+rtw_wx_set_freq\n"));
 679         return 0;
 680 }
 681
 682 static int rtw_wx_get_freq(struct net_device *dev,
 683                              struct iw_request_info *info,
 684                              union iwreq_data *wrqu, char *extra)
 685 {
 686         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 687         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
 688         struct wlan_bssid_ex  *pcur_bss = &pmlmepriv->cur_network.network;
 689
 690         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 691                 /* wrqu->freq.m = ieee80211_wlan_frequencies[pcur_bss->Configuration.DSConfig-1] * 100000; */
 692                 wrqu->freq.m = rtw_ch2freq(pcur_bss->Configuration.DSConfig) * 100000;
 693                 wrqu->freq.e = 1;
 694                 wrqu->freq.i = pcur_bss->Configuration.DSConfig;
 695         } else {
 696                 wrqu->freq.m = rtw_ch2freq(padapter->mlmeextpriv.cur_channel) * 100000;
 697                 wrqu->freq.e = 1;
 698                 wrqu->freq.i = padapter->mlmeextpriv.cur_channel;
 699         }
 700
 701         return 0;
 702 }
 703
 704 static int rtw_wx_set_mode(struct net_device *dev, struct iw_request_info *a,
 705                              union iwreq_data *wrqu, char *b)
 706 {
 707         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 708         enum ndis_802_11_network_infra networkType;
 709         int ret = 0;
 710
 711         if (_FAIL == rtw_pwr_wakeup(padapter)) {
 712                 ret = -EPERM;
 713                 goto exit;
 714         }
 715
 716         if (!padapter->hw_init_completed) {
 717                 ret = -EPERM;
 718                 goto exit;
 719         }
 720
 721         switch (wrqu->mode) {
 722         case IW_MODE_AUTO:
 723                 networkType = Ndis802_11AutoUnknown;
 724                 DBG_88E("set_mode = IW_MODE_AUTO\n");
 725                 break;
 726         case IW_MODE_ADHOC:
 727                 networkType = Ndis802_11IBSS;
 728                 DBG_88E("set_mode = IW_MODE_ADHOC\n");
 729                 break;
 730         case IW_MODE_MASTER:
 731                 networkType = Ndis802_11APMode;
 732                 DBG_88E("set_mode = IW_MODE_MASTER\n");
 733                 break;
 734         case IW_MODE_INFRA:
 735                 networkType = Ndis802_11Infrastructure;
 736                 DBG_88E("set_mode = IW_MODE_INFRA\n");
 737                 break;
 738         default:
 739                 ret = -EINVAL;
 740                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("\n Mode: %s is not supported\n", iw_operation_mode[wrqu->mode]));
 741                 goto exit;
 742         }
 743         if (rtw_set_802_11_infrastructure_mode(padapter, networkType) == false) {
 744                 ret = -EPERM;
 745                 goto exit;
 746         }
 747         rtw_setopmode_cmd(padapter, networkType);
 748 exit:
 749         return ret;
 750 }
 751
 752 static int rtw_wx_get_mode(struct net_device *dev, struct iw_request_info *a,
 753                              union iwreq_data *wrqu, char *b)
 754 {
 755         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 756         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
 757
 758         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, (" rtw_wx_get_mode\n"));
 759
 760         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
 761                 wrqu->mode = IW_MODE_INFRA;
 762         else if  ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) ||
 763                   (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)))
 764                 wrqu->mode = IW_MODE_ADHOC;
 765         else if (check_fwstate(pmlmepriv, WIFI_AP_STATE))
 766                 wrqu->mode = IW_MODE_MASTER;
 767         else
 768                 wrqu->mode = IW_MODE_AUTO;
 769
 770         return 0;
 771 }
 772
 773 static int rtw_wx_set_pmkid(struct net_device *dev,
 774                             struct iw_request_info *a,
 775                             union iwreq_data *wrqu, char *extra)
 776 {
 777         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 778         u8   j, blInserted = false;
 779         int  ret = false;
 780         struct security_priv *psecuritypriv = &padapter->securitypriv;
 781         struct iw_pmksa *pPMK = (struct iw_pmksa *)extra;
 782         u8     strZeroMacAddress[ETH_ALEN] = {0x00};
 783         u8     strIssueBssid[ETH_ALEN] = {0x00};
 784
 785         memcpy(strIssueBssid, pPMK->bssid.sa_data, ETH_ALEN);
 786         if (pPMK->cmd == IW_PMKSA_ADD) {
 787                 DBG_88E("[rtw_wx_set_pmkid] IW_PMKSA_ADD!\n");
 788                 if (!memcmp(strIssueBssid, strZeroMacAddress, ETH_ALEN))
 789                         return ret;
 790                 else
 791                         ret = true;
 792                 blInserted = false;
 793
 794                 /* overwrite PMKID */
 795                 for (j = 0; j < NUM_PMKID_CACHE; j++) {
 796                         if (!memcmp(psecuritypriv->PMKIDList[j].Bssid, strIssueBssid, ETH_ALEN)) {
 797                                 /*  BSSID is matched, the same AP => rewrite with new PMKID. */
 798                                 DBG_88E("[rtw_wx_set_pmkid] BSSID exists in the PMKList.\n");
 799                                 memcpy(psecuritypriv->PMKIDList[j].PMKID, pPMK->pmkid, IW_PMKID_LEN);
 800                                 psecuritypriv->PMKIDList[j].bUsed = true;
 801                                 psecuritypriv->PMKIDIndex = j+1;
 802                                 blInserted = true;
 803                                 break;
 804                         }
 805                 }
 806
 807                 if (!blInserted) {
 808                         /*  Find a new entry */
 809                         DBG_88E("[rtw_wx_set_pmkid] Use the new entry index = %d for this PMKID.\n",
 810                                 psecuritypriv->PMKIDIndex);
 811
 812                         memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].Bssid, strIssueBssid, ETH_ALEN);
 813                         memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].PMKID, pPMK->pmkid, IW_PMKID_LEN);
 814
 815                         psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].bUsed = true;
 816                         psecuritypriv->PMKIDIndex++;
 817                         if (psecuritypriv->PMKIDIndex == 16)
 818                                 psecuritypriv->PMKIDIndex = 0;
 819                 }
 820         } else if (pPMK->cmd == IW_PMKSA_REMOVE) {
 821                 DBG_88E("[rtw_wx_set_pmkid] IW_PMKSA_REMOVE!\n");
 822                 ret = true;
 823                 for (j = 0; j < NUM_PMKID_CACHE; j++) {
 824                         if (!memcmp(psecuritypriv->PMKIDList[j].Bssid, strIssueBssid, ETH_ALEN)) {
 825                                 /*  BSSID is matched, the same AP => Remove this PMKID information and reset it. */
 826                                 eth_zero_addr(psecuritypriv->PMKIDList[j].Bssid);
 827                                 psecuritypriv->PMKIDList[j].bUsed = false;
 828                                 break;
 829                         }
 830                }
 831         } else if (pPMK->cmd == IW_PMKSA_FLUSH) {
 832                 DBG_88E("[rtw_wx_set_pmkid] IW_PMKSA_FLUSH!\n");
 833                 memset(&psecuritypriv->PMKIDList[0], 0x00, sizeof(struct rt_pmkid_list) * NUM_PMKID_CACHE);
 834                 psecuritypriv->PMKIDIndex = 0;
 835                 ret = true;
 836         }
 837         return ret;
 838 }
 839
 840 static int rtw_wx_get_sens(struct net_device *dev,
 841                              struct iw_request_info *info,
 842                              union iwreq_data *wrqu, char *extra)
 843 {
 844         wrqu->sens.value = 0;
 845         wrqu->sens.fixed = 0;   /* no auto select */
 846         wrqu->sens.disabled = 1;
 847         return 0;
 848 }
 849
 850 static int rtw_wx_get_range(struct net_device *dev,
 851                                 struct iw_request_info *info,
 852                                 union iwreq_data *wrqu, char *extra)
 853 {
 854         struct iw_range *range = (struct iw_range *)extra;
 855         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 856         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 857
 858         u16 val;
 859         int i;
 860
 861         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_range. cmd_code =%x\n", info->cmd));
 862
 863         wrqu->data.length = sizeof(*range);
 864         memset(range, 0, sizeof(*range));
 865
 866         /* Let's try to keep this struct in the same order as in
 867          * linux/include/wireless.h
 868          */
 869
 870         /* TODO: See what values we can set, and remove the ones we can't
 871          * set, or fill them with some default data.
 872          */
 873
 874         /* ~5 Mb/s real (802.11b) */
 875         range->throughput = 5 * 1000 * 1000;
 876
 877         /* signal level threshold range */
 878
 879         /* percent values between 0 and 100. */
 880         range->max_qual.qual = 100;
 881         range->max_qual.level = 100;
 882         range->max_qual.noise = 100;
 883         range->max_qual.updated = 7; /* Updated all three */
 884
 885         range->avg_qual.qual = 92; /* > 8% missed beacons is 'bad' */
 886         /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
 887         range->avg_qual.level = 178; /* -78 dBm */
 888         range->avg_qual.noise = 0;
 889         range->avg_qual.updated = 7; /* Updated all three */
 890
 891         range->num_bitrates = RATE_COUNT;
 892
 893         for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++)
 894                 range->bitrate[i] = rtw_rates[i];
 895
 896         range->min_frag = MIN_FRAG_THRESHOLD;
 897         range->max_frag = MAX_FRAG_THRESHOLD;
 898
 899         range->pm_capa = 0;
 900
 901         range->we_version_compiled = WIRELESS_EXT;
 902         range->we_version_source = 16;
 903
 904         for (i = 0, val = 0; i < MAX_CHANNEL_NUM; i++) {
 905                 /*  Include only legal frequencies for some countries */
 906                 if (pmlmeext->channel_set[i].ChannelNum != 0) {
 907                         range->freq[val].i = pmlmeext->channel_set[i].ChannelNum;
 908                         range->freq[val].m = rtw_ch2freq(pmlmeext->channel_set[i].ChannelNum) * 100000;
 909                         range->freq[val].e = 1;
 910                         val++;
 911                 }
 912
 913                 if (val == IW_MAX_FREQUENCIES)
 914                         break;
 915         }
 916
 917         range->num_channels = val;
 918         range->num_frequency = val;
 919
 920 /*  The following code will proivde the security capability to network manager. */
 921 /*  If the driver doesn't provide this capability to network manager, */
 922 /*  the WPA/WPA2 routers can't be chosen in the network manager. */
 923
 924 /*
 925 #define IW_SCAN_CAPA_NONE               0x00
 926 #define IW_SCAN_CAPA_ESSID              0x01
 927 #define IW_SCAN_CAPA_BSSID              0x02
 928 #define IW_SCAN_CAPA_CHANNEL            0x04
 929 #define IW_SCAN_CAPA_MODE               0x08
 930 #define IW_SCAN_CAPA_RATE               0x10
 931 #define IW_SCAN_CAPA_TYPE               0x20
 932 #define IW_SCAN_CAPA_TIME               0x40
 933 */
 934
 935         range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
 936                           IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
 937
 938         range->scan_capa = IW_SCAN_CAPA_ESSID | IW_SCAN_CAPA_TYPE |
 939                            IW_SCAN_CAPA_BSSID | IW_SCAN_CAPA_CHANNEL |
 940                            IW_SCAN_CAPA_MODE | IW_SCAN_CAPA_RATE;
 941         return 0;
 942 }
 943
 944 /* set bssid flow */
 945 /* s1. rtw_set_802_11_infrastructure_mode() */
 946 /* s2. rtw_set_802_11_authentication_mode() */
 947 /* s3. set_802_11_encryption_mode() */
 948 /* s4. rtw_set_802_11_bssid() */
 949 static int rtw_wx_set_wap(struct net_device *dev,
 950                          struct iw_request_info *info,
 951                          union iwreq_data *awrq,
 952                          char *extra)
 953 {
 954         uint ret = 0;
 955         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 956         struct sockaddr *temp = (struct sockaddr *)awrq;
 957         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
 958         struct list_head *phead;
 959         u8 *dst_bssid, *src_bssid;
 960         struct __queue *queue   = &(pmlmepriv->scanned_queue);
 961         struct  wlan_network    *pnetwork = NULL;
 962         enum ndis_802_11_auth_mode      authmode;
 963
 964         if (_FAIL == rtw_pwr_wakeup(padapter)) {
 965                 ret = -1;
 966                 goto exit;
 967         }
 968
 969         if (!padapter->bup) {
 970                 ret = -1;
 971                 goto exit;
 972         }
 973
 974         if (temp->sa_family != ARPHRD_ETHER) {
 975                 ret = -EINVAL;
 976                 goto exit;
 977         }
 978
 979         authmode = padapter->securitypriv.ndisauthtype;
 980         spin_lock_bh(&queue->lock);
 981         phead = get_list_head(queue);
 982         pmlmepriv->pscanned = phead->next;
 983
 984         while (phead != pmlmepriv->pscanned) {
 985                 pnetwork = container_of(pmlmepriv->pscanned, struct wlan_network, list);
 986
 987                 pmlmepriv->pscanned = pmlmepriv->pscanned->next;
 988
 989                 dst_bssid = pnetwork->network.MacAddress;
 990
 991                 src_bssid = temp->sa_data;
 992
 993                 if ((!memcmp(dst_bssid, src_bssid, ETH_ALEN))) {
 994                         if (!rtw_set_802_11_infrastructure_mode(padapter, pnetwork->network.InfrastructureMode)) {
 995                                 ret = -1;
 996                                 spin_unlock_bh(&queue->lock);
 997                                 goto exit;
 998                         }
 999
1000                                 break;
1001                 }
1002         }
1003         spin_unlock_bh(&queue->lock);
1004
1005         rtw_set_802_11_authentication_mode(padapter, authmode);
1006         /* set_802_11_encryption_mode(padapter, padapter->securitypriv.ndisencryptstatus); */
1007         if (rtw_set_802_11_bssid(padapter, temp->sa_data) == false) {
1008                 ret = -1;
1009                 goto exit;
1010         }
1011
1012 exit:
1013
1014         return ret;
1015 }
1016
1017 static int rtw_wx_get_wap(struct net_device *dev,
1018                             struct iw_request_info *info,
1019                             union iwreq_data *wrqu, char *extra)
1020 {
1021         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1022         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
1023         struct wlan_bssid_ex  *pcur_bss = &pmlmepriv->cur_network.network;
1024
1025         wrqu->ap_addr.sa_family = ARPHRD_ETHER;
1026
1027         eth_zero_addr(wrqu->ap_addr.sa_data);
1028
1029         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_wap\n"));
1030
1031         if (((check_fwstate(pmlmepriv, _FW_LINKED)) == true) ||
1032             ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) == true) ||
1033             ((check_fwstate(pmlmepriv, WIFI_AP_STATE)) == true))
1034                 memcpy(wrqu->ap_addr.sa_data, pcur_bss->MacAddress, ETH_ALEN);
1035         else
1036                 eth_zero_addr(wrqu->ap_addr.sa_data);
1037         return 0;
1038 }
1039
1040 static int rtw_wx_set_mlme(struct net_device *dev,
1041                              struct iw_request_info *info,
1042                              union iwreq_data *wrqu, char *extra)
1043 {
1044         int ret = 0;
1045         u16 reason;
1046         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1047         struct iw_mlme *mlme = (struct iw_mlme *)extra;
1048
1049         if (!mlme)
1050                 return -1;
1051
1052         DBG_88E("%s\n", __func__);
1053
1054         reason = mlme->reason_code;
1055
1056         DBG_88E("%s, cmd =%d, reason =%d\n", __func__, mlme->cmd, reason);
1057
1058         switch (mlme->cmd) {
1059         case IW_MLME_DEAUTH:
1060                 if (!rtw_set_802_11_disassociate(padapter))
1061                         ret = -1;
1062                 break;
1063         case IW_MLME_DISASSOC:
1064                 if (!rtw_set_802_11_disassociate(padapter))
1065                         ret = -1;
1066                 break;
1067         default:
1068                 return -EOPNOTSUPP;
1069         }
1070         return ret;
1071 }
1072
1073 static int rtw_wx_set_scan(struct net_device *dev, struct iw_request_info *a,
1074                              union iwreq_data *wrqu, char *extra)
1075 {
1076         u8 _status = false;
1077         int ret = 0;
1078         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1079         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1080         struct ndis_802_11_ssid ssid[RTW_SSID_SCAN_AMOUNT];
1081
1082         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_set_scan\n"));
1083
1084         if (_FAIL == rtw_pwr_wakeup(padapter)) {
1085                 ret = -1;
1086                 goto exit;
1087         }
1088
1089         if (padapter->bDriverStopped) {
1090                 DBG_88E("bDriverStopped =%d\n", padapter->bDriverStopped);
1091                 ret = -1;
1092                 goto exit;
1093         }
1094
1095         if (!padapter->bup) {
1096                 ret = -1;
1097                 goto exit;
1098         }
1099
1100         if (!padapter->hw_init_completed) {
1101                 ret = -1;
1102                 goto exit;
1103         }
1104
1105         /*  When Busy Traffic, driver do not site survey. So driver return success. */
1106         /*  wpa_supplicant will not issue SIOCSIWSCAN cmd again after scan timeout. */
1107         /*  modify by thomas 2011-02-22. */
1108         if (pmlmepriv->LinkDetectInfo.bBusyTraffic) {
1109                 indicate_wx_scan_complete_event(padapter);
1110                 goto exit;
1111         }
1112
1113         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING)) {
1114                 indicate_wx_scan_complete_event(padapter);
1115                 goto exit;
1116         }
1117
1118 /*      For the DMP WiFi Display project, the driver won't to scan because */
1119 /*      the pmlmepriv->scan_interval is always equal to 3. */
1120 /*      So, the wpa_supplicant won't find out the WPS SoftAP. */
1121
1122         memset(ssid, 0, sizeof(struct ndis_802_11_ssid)*RTW_SSID_SCAN_AMOUNT);
1123
1124         if (wrqu->data.length == sizeof(struct iw_scan_req)) {
1125                 struct iw_scan_req *req = (struct iw_scan_req *)extra;
1126
1127                 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
1128                         int len = min_t(int, req->essid_len,
1129                                         IW_ESSID_MAX_SIZE);
1130
1131                         memcpy(ssid[0].Ssid, req->essid, len);
1132                         ssid[0].SsidLength = len;
1133
1134                         DBG_88E("IW_SCAN_THIS_ESSID, ssid =%s, len =%d\n", req->essid, req->essid_len);
1135
1136                         spin_lock_bh(&pmlmepriv->lock);
1137
1138                         _status = rtw_sitesurvey_cmd(padapter, ssid, 1, NULL, 0);
1139
1140                         spin_unlock_bh(&pmlmepriv->lock);
1141                 } else if (req->scan_type == IW_SCAN_TYPE_PASSIVE) {
1142                         DBG_88E("rtw_wx_set_scan, req->scan_type == IW_SCAN_TYPE_PASSIVE\n");
1143                 }
1144         } else {
1145                 if (wrqu->data.length >= WEXT_CSCAN_HEADER_SIZE &&
1146                     !memcmp(extra, WEXT_CSCAN_HEADER, WEXT_CSCAN_HEADER_SIZE)) {
1147                         int len = wrqu->data.length - WEXT_CSCAN_HEADER_SIZE;
1148                         char *pos = extra+WEXT_CSCAN_HEADER_SIZE;
1149                         char section;
1150                         char sec_len;
1151                         int ssid_index = 0;
1152
1153                         while (len >= 1) {
1154                                 section = *(pos++);
1155                                 len -= 1;
1156
1157                                 switch (section) {
1158                                 case WEXT_CSCAN_SSID_SECTION:
1159                                         if (len < 1) {
1160                                                 len = 0;
1161                                                 break;
1162                                         }
1163                                         sec_len = *(pos++); len -= 1;
1164                                         if (sec_len > 0 &&
1165                                             sec_len <= len &&
1166                                             sec_len <= 32) {
1167                                                 ssid[ssid_index].SsidLength = sec_len;
1168                                                 memcpy(ssid[ssid_index].Ssid, pos, sec_len);
1169                                                 ssid_index++;
1170                                         }
1171                                         pos += sec_len;
1172                                         len -= sec_len;
1173                                         break;
1174                                 case WEXT_CSCAN_TYPE_SECTION:
1175                                 case WEXT_CSCAN_CHANNEL_SECTION:
1176                                         pos += 1;
1177                                         len -= 1;
1178                                         break;
1179                                 case WEXT_CSCAN_PASV_DWELL_SECTION:
1180                                 case WEXT_CSCAN_HOME_DWELL_SECTION:
1181                                 case WEXT_CSCAN_ACTV_DWELL_SECTION:
1182                                         pos += 2;
1183                                         len -= 2;
1184                                         break;
1185                                 default:
1186                                         len = 0; /*  stop parsing */
1187                                 }
1188                         }
1189
1190                         /* it has still some scan parameter to parse, we only do this now... */
1191                         _status = rtw_set_802_11_bssid_list_scan(padapter, ssid, RTW_SSID_SCAN_AMOUNT);
1192                 } else {
1193                         _status = rtw_set_802_11_bssid_list_scan(padapter, NULL, 0);
1194                 }
1195         }
1196
1197         if (!_status)
1198                 ret = -1;
1199
1200 exit:
1201
1202         return ret;
1203 }
1204
1205 static int rtw_wx_get_scan(struct net_device *dev, struct iw_request_info *a,
1206                              union iwreq_data *wrqu, char *extra)
1207 {
1208         struct list_head *plist, *phead;
1209         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1210         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
1211         struct __queue *queue   = &(pmlmepriv->scanned_queue);
1212         struct  wlan_network    *pnetwork = NULL;
1213         char *ev = extra;
1214         char *stop = ev + wrqu->data.length;
1215         u32 ret = 0;
1216         u32 cnt = 0;
1217         u32 wait_for_surveydone;
1218         int wait_status;
1219
1220         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_scan\n"));
1221         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, (" Start of Query SIOCGIWSCAN .\n"));
1222
1223         if (padapter->pwrctrlpriv.brfoffbyhw && padapter->bDriverStopped) {
1224                 ret = -EINVAL;
1225                 goto exit;
1226         }
1227
1228         wait_for_surveydone = 100;
1229
1230         wait_status = _FW_UNDER_SURVEY | _FW_UNDER_LINKING;
1231
1232         while (check_fwstate(pmlmepriv, wait_status)) {
1233                 msleep(30);
1234                 cnt++;
1235                 if (cnt > wait_for_surveydone)
1236                         break;
1237         }
1238
1239         spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
1240
1241         phead = get_list_head(queue);
1242         plist = phead->next;
1243
1244         while (phead != plist) {
1245                 if ((stop - ev) < SCAN_ITEM_SIZE) {
1246                         ret = -E2BIG;
1247                         break;
1248                 }
1249
1250                 pnetwork = container_of(plist, struct wlan_network, list);
1251
1252                 /* report network only if the current channel set contains the channel to which this network belongs */
1253                 if (rtw_ch_set_search_ch(padapter->mlmeextpriv.channel_set, pnetwork->network.Configuration.DSConfig) >= 0)
1254                         ev = translate_scan(padapter, a, pnetwork, ev, stop);
1255
1256                 plist = plist->next;
1257         }
1258
1259         spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1260
1261         wrqu->data.length = ev-extra;
1262         wrqu->data.flags = 0;
1263
1264 exit:
1265         return ret;
1266 }
1267
1268 /* set ssid flow */
1269 /* s1. rtw_set_802_11_infrastructure_mode() */
1270 /* s2. set_802_11_authenticaion_mode() */
1271 /* s3. set_802_11_encryption_mode() */
1272 /* s4. rtw_set_802_11_ssid() */
1273 static int rtw_wx_set_essid(struct net_device *dev,
1274                               struct iw_request_info *a,
1275                               union iwreq_data *wrqu, char *extra)
1276 {
1277         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1278         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1279         struct __queue *queue = &pmlmepriv->scanned_queue;
1280         struct list_head *phead;
1281         struct wlan_network *pnetwork = NULL;
1282         enum ndis_802_11_auth_mode authmode;
1283         struct ndis_802_11_ssid ndis_ssid;
1284         u8 *dst_ssid, *src_ssid;
1285
1286         uint ret = 0, len;
1287
1288         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1289                  ("+rtw_wx_set_essid: fw_state = 0x%08x\n", get_fwstate(pmlmepriv)));
1290         if (_FAIL == rtw_pwr_wakeup(padapter)) {
1291                 ret = -1;
1292                 goto exit;
1293         }
1294
1295         if (!padapter->bup) {
1296                 ret = -1;
1297                 goto exit;
1298         }
1299
1300         if (wrqu->essid.length > IW_ESSID_MAX_SIZE) {
1301                 ret = -E2BIG;
1302                 goto exit;
1303         }
1304
1305         if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1306                 ret = -1;
1307                 goto exit;
1308         }
1309
1310         authmode = padapter->securitypriv.ndisauthtype;
1311         DBG_88E("=>%s\n", __func__);
1312         if (wrqu->essid.flags && wrqu->essid.length) {
1313                 len = min_t(uint, wrqu->essid.length, IW_ESSID_MAX_SIZE);
1314
1315                 if (wrqu->essid.length != 33)
1316                         DBG_88E("ssid =%s, len =%d\n", extra, wrqu->essid.length);
1317
1318                 memset(&ndis_ssid, 0, sizeof(struct ndis_802_11_ssid));
1319                 ndis_ssid.SsidLength = len;
1320                 memcpy(ndis_ssid.Ssid, extra, len);
1321                 src_ssid = ndis_ssid.Ssid;
1322
1323                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("rtw_wx_set_essid: ssid =[%s]\n", src_ssid));
1324                 spin_lock_bh(&queue->lock);
1325                phead = get_list_head(queue);
1326               pmlmepriv->pscanned = phead->next;
1327
1328                 while (phead != pmlmepriv->pscanned) {
1329                         pnetwork = container_of(pmlmepriv->pscanned, struct wlan_network, list);
1330
1331                         pmlmepriv->pscanned = pmlmepriv->pscanned->next;
1332
1333                         dst_ssid = pnetwork->network.Ssid.Ssid;
1334
1335                         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1336                                  ("rtw_wx_set_essid: dst_ssid =%s\n",
1337                                   pnetwork->network.Ssid.Ssid));
1338
1339                         if ((!memcmp(dst_ssid, src_ssid, ndis_ssid.SsidLength)) &&
1340                             (pnetwork->network.Ssid.SsidLength == ndis_ssid.SsidLength)) {
1341                                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1342                                          ("rtw_wx_set_essid: find match, set infra mode\n"));
1343
1344                                 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) {
1345                                         if (pnetwork->network.InfrastructureMode != pmlmepriv->cur_network.network.InfrastructureMode)
1346                                                 continue;
1347                                 }
1348
1349                                 if (!rtw_set_802_11_infrastructure_mode(padapter, pnetwork->network.InfrastructureMode)) {
1350                                         ret = -1;
1351                                         spin_unlock_bh(&queue->lock);
1352                                         goto exit;
1353                                 }
1354
1355                                 break;
1356                         }
1357                 }
1358                 spin_unlock_bh(&queue->lock);
1359                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1360                          ("set ssid: set_802_11_auth. mode =%d\n", authmode));
1361                 rtw_set_802_11_authentication_mode(padapter, authmode);
1362                 if (rtw_set_802_11_ssid(padapter, &ndis_ssid) == false) {
1363                         ret = -1;
1364                         goto exit;
1365                 }
1366         }
1367
1368 exit:
1369         DBG_88E("<=%s, ret %d\n", __func__, ret);
1370
1371         return ret;
1372 }
1373
1374 static int rtw_wx_get_essid(struct net_device *dev,
1375                               struct iw_request_info *a,
1376                               union iwreq_data *wrqu, char *extra)
1377 {
1378         u32 len, ret = 0;
1379         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1380         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
1381         struct wlan_bssid_ex  *pcur_bss = &pmlmepriv->cur_network.network;
1382
1383         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_essid\n"));
1384
1385         if ((check_fwstate(pmlmepriv, _FW_LINKED)) ||
1386             (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE))) {
1387                 len = pcur_bss->Ssid.SsidLength;
1388                 memcpy(extra, pcur_bss->Ssid.Ssid, len);
1389         } else {
1390                 len = 0;
1391                 *extra = 0;
1392         }
1393         wrqu->essid.length = len;
1394         wrqu->essid.flags = 1;
1395
1396         return ret;
1397 }
1398
1399 static int rtw_wx_set_rate(struct net_device *dev,
1400                               struct iw_request_info *a,
1401                               union iwreq_data *wrqu, char *extra)
1402 {
1403         int i;
1404         u8 datarates[NumRates];
1405         u32     target_rate = wrqu->bitrate.value;
1406         u32     fixed = wrqu->bitrate.fixed;
1407         u32     ratevalue = 0;
1408          u8 mpdatarate[NumRates] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0xff};
1409
1410         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, (" rtw_wx_set_rate\n"));
1411         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("target_rate = %d, fixed = %d\n", target_rate, fixed));
1412
1413         if (target_rate == -1) {
1414                 ratevalue = 11;
1415                 goto set_rate;
1416         }
1417         target_rate = target_rate/100000;
1418
1419         switch (target_rate) {
1420         case 10:
1421                 ratevalue = 0;
1422                 break;
1423         case 20:
1424                 ratevalue = 1;
1425                 break;
1426         case 55:
1427                 ratevalue = 2;
1428                 break;
1429         case 60:
1430                 ratevalue = 3;
1431                 break;
1432         case 90:
1433                 ratevalue = 4;
1434                 break;
1435         case 110:
1436                 ratevalue = 5;
1437                 break;
1438         case 120:
1439                 ratevalue = 6;
1440                 break;
1441         case 180:
1442                 ratevalue = 7;
1443                 break;
1444         case 240:
1445                 ratevalue = 8;
1446                 break;
1447         case 360:
1448                 ratevalue = 9;
1449                 break;
1450         case 480:
1451                 ratevalue = 10;
1452                 break;
1453         case 540:
1454                 ratevalue = 11;
1455                 break;
1456         default:
1457                 ratevalue = 11;
1458                 break;
1459         }
1460
1461 set_rate:
1462
1463         for (i = 0; i < NumRates; i++) {
1464                 if (ratevalue == mpdatarate[i]) {
1465                         datarates[i] = mpdatarate[i];
1466                         if (fixed == 0)
1467                                 break;
1468                 } else {
1469                         datarates[i] = 0xff;
1470                 }
1471
1472                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("datarate_inx =%d\n", datarates[i]));
1473         }
1474
1475         return 0;
1476 }
1477
1478 static int rtw_wx_get_rate(struct net_device *dev,
1479                              struct iw_request_info *info,
1480                              union iwreq_data *wrqu, char *extra)
1481 {
1482         u16 max_rate = 0;
1483
1484         max_rate = rtw_get_cur_max_rate((struct adapter *)rtw_netdev_priv(dev));
1485
1486         if (max_rate == 0)
1487                 return -EPERM;
1488
1489         wrqu->bitrate.fixed = 0;        /* no auto select */
1490         wrqu->bitrate.value = max_rate * 100000;
1491
1492         return 0;
1493 }
1494
1495 static int rtw_wx_set_rts(struct net_device *dev,
1496                              struct iw_request_info *info,
1497                              union iwreq_data *wrqu, char *extra)
1498 {
1499         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1500
1501         if (wrqu->rts.disabled) {
1502                 padapter->registrypriv.rts_thresh = 2347;
1503         } else {
1504                 if (wrqu->rts.value < 0 ||
1505                     wrqu->rts.value > 2347)
1506                         return -EINVAL;
1507
1508                 padapter->registrypriv.rts_thresh = wrqu->rts.value;
1509         }
1510
1511         DBG_88E("%s, rts_thresh =%d\n", __func__, padapter->registrypriv.rts_thresh);
1512
1513         return 0;
1514 }
1515
1516 static int rtw_wx_get_rts(struct net_device *dev,
1517                              struct iw_request_info *info,
1518                              union iwreq_data *wrqu, char *extra)
1519 {
1520         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1521
1522         DBG_88E("%s, rts_thresh =%d\n", __func__, padapter->registrypriv.rts_thresh);
1523
1524         wrqu->rts.value = padapter->registrypriv.rts_thresh;
1525         wrqu->rts.fixed = 0;    /* no auto select */
1526         /* wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD); */
1527
1528         return 0;
1529 }
1530
1531 static int rtw_wx_set_frag(struct net_device *dev,
1532                              struct iw_request_info *info,
1533                              union iwreq_data *wrqu, char *extra)
1534 {
1535         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1536
1537         if (wrqu->frag.disabled) {
1538                 padapter->xmitpriv.frag_len = MAX_FRAG_THRESHOLD;
1539         } else {
1540                 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
1541                     wrqu->frag.value > MAX_FRAG_THRESHOLD)
1542                         return -EINVAL;
1543
1544                 padapter->xmitpriv.frag_len = wrqu->frag.value & ~0x1;
1545         }
1546
1547         DBG_88E("%s, frag_len =%d\n", __func__, padapter->xmitpriv.frag_len);
1548
1549         return 0;
1550 }
1551
1552 static int rtw_wx_get_frag(struct net_device *dev,
1553                              struct iw_request_info *info,
1554                              union iwreq_data *wrqu, char *extra)
1555 {
1556         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1557
1558         DBG_88E("%s, frag_len =%d\n", __func__, padapter->xmitpriv.frag_len);
1559
1560         wrqu->frag.value = padapter->xmitpriv.frag_len;
1561         wrqu->frag.fixed = 0;   /* no auto select */
1562
1563         return 0;
1564 }
1565
1566 static int rtw_wx_get_retry(struct net_device *dev,
1567                              struct iw_request_info *info,
1568                              union iwreq_data *wrqu, char *extra)
1569 {
1570         wrqu->retry.value = 7;
1571         wrqu->retry.fixed = 0;  /* no auto select */
1572         wrqu->retry.disabled = 1;
1573
1574         return 0;
1575 }
1576
1577 static int rtw_wx_set_enc(struct net_device *dev,
1578                             struct iw_request_info *info,
1579                             union iwreq_data *wrqu, char *keybuf)
1580 {
1581         u32 key, ret = 0;
1582         u32 keyindex_provided;
1583         struct ndis_802_11_wep   wep;
1584         enum ndis_802_11_auth_mode authmode;
1585
1586         struct iw_point *erq = &(wrqu->encoding);
1587         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1588         struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
1589
1590         DBG_88E("+rtw_wx_set_enc, flags = 0x%x\n", erq->flags);
1591
1592         memset(&wep, 0, sizeof(struct ndis_802_11_wep));
1593
1594         key = erq->flags & IW_ENCODE_INDEX;
1595
1596         if (erq->flags & IW_ENCODE_DISABLED) {
1597                 DBG_88E("EncryptionDisabled\n");
1598                 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
1599                 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1600                 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
1601                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
1602                 authmode = Ndis802_11AuthModeOpen;
1603                 padapter->securitypriv.ndisauthtype = authmode;
1604
1605                 goto exit;
1606         }
1607
1608         if (key) {
1609                 if (key > WEP_KEYS)
1610                         return -EINVAL;
1611                 key--;
1612                 keyindex_provided = 1;
1613         } else {
1614                 keyindex_provided = 0;
1615                 key = padapter->securitypriv.dot11PrivacyKeyIndex;
1616                 DBG_88E("rtw_wx_set_enc, key =%d\n", key);
1617         }
1618
1619         /* set authentication mode */
1620         if (erq->flags & IW_ENCODE_OPEN) {
1621                 DBG_88E("rtw_wx_set_enc():IW_ENCODE_OPEN\n");
1622                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;/* Ndis802_11EncryptionDisabled; */
1623                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
1624                 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1625                 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
1626                 authmode = Ndis802_11AuthModeOpen;
1627                 padapter->securitypriv.ndisauthtype = authmode;
1628         } else if (erq->flags & IW_ENCODE_RESTRICTED) {
1629                 DBG_88E("rtw_wx_set_enc():IW_ENCODE_RESTRICTED\n");
1630                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
1631                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Shared;
1632                 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
1633                 padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_;
1634                 authmode = Ndis802_11AuthModeShared;
1635                 padapter->securitypriv.ndisauthtype = authmode;
1636         } else {
1637                 DBG_88E("rtw_wx_set_enc():erq->flags = 0x%x\n", erq->flags);
1638
1639                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;/* Ndis802_11EncryptionDisabled; */
1640                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
1641                 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1642                 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
1643                 authmode = Ndis802_11AuthModeOpen;
1644                 padapter->securitypriv.ndisauthtype = authmode;
1645         }
1646
1647         wep.KeyIndex = key;
1648         if (erq->length > 0) {
1649                 wep.KeyLength = erq->length <= 5 ? 5 : 13;
1650
1651                 wep.Length = wep.KeyLength + offsetof(struct ndis_802_11_wep, KeyMaterial);
1652         } else {
1653                 wep.KeyLength = 0;
1654
1655                 if (keyindex_provided == 1) {
1656                         /*  set key_id only, no given KeyMaterial(erq->length == 0). */
1657                         padapter->securitypriv.dot11PrivacyKeyIndex = key;
1658
1659                         DBG_88E("(keyindex_provided == 1), keyid =%d, key_len =%d\n", key, padapter->securitypriv.dot11DefKeylen[key]);
1660
1661                         switch (padapter->securitypriv.dot11DefKeylen[key]) {
1662                         case 5:
1663                                 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
1664                                 break;
1665                         case 13:
1666                                 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
1667                                 break;
1668                         default:
1669                                 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1670                                 break;
1671                         }
1672
1673                         goto exit;
1674                 }
1675         }
1676
1677         wep.KeyIndex |= 0x80000000;
1678
1679         memcpy(wep.KeyMaterial, keybuf, wep.KeyLength);
1680
1681         if (rtw_set_802_11_add_wep(padapter, &wep) == false) {
1682                 if (rf_on == pwrpriv->rf_pwrstate)
1683                         ret = -EOPNOTSUPP;
1684                 goto exit;
1685         }
1686
1687 exit:
1688         return ret;
1689 }
1690
1691 static int rtw_wx_get_enc(struct net_device *dev,
1692                             struct iw_request_info *info,
1693                             union iwreq_data *wrqu, char *keybuf)
1694 {
1695         uint key, ret = 0;
1696         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1697         struct iw_point *erq = &(wrqu->encoding);
1698         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
1699
1700         if (check_fwstate(pmlmepriv, _FW_LINKED) != true) {
1701                 if (!check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) {
1702                         erq->length = 0;
1703                         erq->flags |= IW_ENCODE_DISABLED;
1704                         return 0;
1705                 }
1706         }
1707
1708         key = erq->flags & IW_ENCODE_INDEX;
1709
1710         if (key) {
1711                 if (key > WEP_KEYS)
1712                         return -EINVAL;
1713                 key--;
1714         } else {
1715                 key = padapter->securitypriv.dot11PrivacyKeyIndex;
1716         }
1717
1718         erq->flags = key + 1;
1719
1720         switch (padapter->securitypriv.ndisencryptstatus) {
1721         case Ndis802_11EncryptionNotSupported:
1722         case Ndis802_11EncryptionDisabled:
1723                 erq->length = 0;
1724                 erq->flags |= IW_ENCODE_DISABLED;
1725                 break;
1726         case Ndis802_11Encryption1Enabled:
1727                 erq->length = padapter->securitypriv.dot11DefKeylen[key];
1728                 if (erq->length) {
1729                         memcpy(keybuf, padapter->securitypriv.dot11DefKey[key].skey, padapter->securitypriv.dot11DefKeylen[key]);
1730
1731                         erq->flags |= IW_ENCODE_ENABLED;
1732
1733                         if (padapter->securitypriv.ndisauthtype == Ndis802_11AuthModeOpen)
1734                                 erq->flags |= IW_ENCODE_OPEN;
1735                         else if (padapter->securitypriv.ndisauthtype == Ndis802_11AuthModeShared)
1736                                 erq->flags |= IW_ENCODE_RESTRICTED;
1737                 } else {
1738                         erq->length = 0;
1739                         erq->flags |= IW_ENCODE_DISABLED;
1740                 }
1741                 break;
1742         case Ndis802_11Encryption2Enabled:
1743         case Ndis802_11Encryption3Enabled:
1744                 erq->length = 16;
1745                 erq->flags |= (IW_ENCODE_ENABLED | IW_ENCODE_OPEN | IW_ENCODE_NOKEY);
1746                 break;
1747         default:
1748                 erq->length = 0;
1749                 erq->flags |= IW_ENCODE_DISABLED;
1750                 break;
1751         }
1752
1753         return ret;
1754 }
1755
1756 static int rtw_wx_get_power(struct net_device *dev,
1757                              struct iw_request_info *info,
1758                              union iwreq_data *wrqu, char *extra)
1759 {
1760         wrqu->power.value = 0;
1761         wrqu->power.fixed = 0;  /* no auto select */
1762         wrqu->power.disabled = 1;
1763
1764         return 0;
1765 }
1766
1767 static int rtw_wx_set_gen_ie(struct net_device *dev,
1768                              struct iw_request_info *info,
1769                              union iwreq_data *wrqu, char *extra)
1770 {
1771         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1772
1773         return rtw_set_wpa_ie(padapter, extra, wrqu->data.length);
1774 }
1775
1776 static int rtw_wx_set_auth(struct net_device *dev,
1777                              struct iw_request_info *info,
1778                              union iwreq_data *wrqu, char *extra)
1779 {
1780         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1781         struct iw_param *param = (struct iw_param *)&(wrqu->param);
1782         int ret = 0;
1783
1784         switch (param->flags & IW_AUTH_INDEX) {
1785         case IW_AUTH_WPA_VERSION:
1786                 break;
1787         case IW_AUTH_CIPHER_PAIRWISE:
1788
1789                 break;
1790         case IW_AUTH_CIPHER_GROUP:
1791
1792                 break;
1793         case IW_AUTH_KEY_MGMT:
1794                 /*
1795                  *  ??? does not use these parameters
1796                  */
1797                 break;
1798         case IW_AUTH_TKIP_COUNTERMEASURES:
1799                 if (param->value) {
1800                         /*  wpa_supplicant is enabling the tkip countermeasure. */
1801                         padapter->securitypriv.btkip_countermeasure = true;
1802                 } else {
1803                         /*  wpa_supplicant is disabling the tkip countermeasure. */
1804                         padapter->securitypriv.btkip_countermeasure = false;
1805                 }
1806                 break;
1807         case IW_AUTH_DROP_UNENCRYPTED:
1808                 /* HACK:
1809                  *
1810                  * wpa_supplicant calls set_wpa_enabled when the driver
1811                  * is loaded and unloaded, regardless of if WPA is being
1812                  * used.  No other calls are made which can be used to
1813                  * determine if encryption will be used or not prior to
1814                  * association being expected.  If encryption is not being
1815                  * used, drop_unencrypted is set to false, else true -- we
1816                  * can use this to determine if the CAP_PRIVACY_ON bit should
1817                  * be set.
1818                  */
1819
1820                 if (padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption1Enabled)
1821                         break;/* it means init value, or using wep, ndisencryptstatus = Ndis802_11Encryption1Enabled, */
1822                                         /*  then it needn't reset it; */
1823
1824                 if (param->value) {
1825                         padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
1826                         padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1827                         padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
1828                         padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
1829                         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen;
1830                 }
1831
1832                 break;
1833         case IW_AUTH_80211_AUTH_ALG:
1834                 /*
1835                  *  It's the starting point of a link layer connection using wpa_supplicant
1836                 */
1837                 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED)) {
1838                         LeaveAllPowerSaveMode(padapter);
1839                         rtw_disassoc_cmd(padapter, 500, false);
1840                         DBG_88E("%s...call rtw_indicate_disconnect\n ", __func__);
1841                         rtw_indicate_disconnect(padapter);
1842                         rtw_free_assoc_resources(padapter);
1843                 }
1844                 ret = wpa_set_auth_algs(dev, (u32)param->value);
1845                 break;
1846         case IW_AUTH_WPA_ENABLED:
1847                 break;
1848         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
1849                 break;
1850         case IW_AUTH_PRIVACY_INVOKED:
1851                 break;
1852         default:
1853                 return -EOPNOTSUPP;
1854         }
1855
1856         return ret;
1857 }
1858
1859 static int rtw_wx_set_enc_ext(struct net_device *dev,
1860                              struct iw_request_info *info,
1861                              union iwreq_data *wrqu, char *extra)
1862 {
1863         char *alg_name;
1864         u32 param_len;
1865         struct ieee_param *param = NULL;
1866         struct iw_point *pencoding = &wrqu->encoding;
1867         struct iw_encode_ext *pext = (struct iw_encode_ext *)extra;
1868         int ret = 0;
1869
1870         param_len = sizeof(struct ieee_param) + pext->key_len;
1871         param = (struct ieee_param *)rtw_malloc(param_len);
1872         if (!param)
1873                 return -1;
1874
1875         memset(param, 0, param_len);
1876
1877         param->cmd = IEEE_CMD_SET_ENCRYPTION;
1878         eth_broadcast_addr(param->sta_addr);
1879
1880         switch (pext->alg) {
1881         case IW_ENCODE_ALG_NONE:
1882                 /* todo: remove key */
1883                 /* remove = 1; */
1884                 alg_name = "none";
1885                 break;
1886         case IW_ENCODE_ALG_WEP:
1887                 alg_name = "WEP";
1888                 break;
1889         case IW_ENCODE_ALG_TKIP:
1890                 alg_name = "TKIP";
1891                 break;
1892         case IW_ENCODE_ALG_CCMP:
1893                 alg_name = "CCMP";
1894                 break;
1895         default:
1896                 ret = -1;
1897                 goto exit;
1898         }
1899
1900         strlcpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN);
1901
1902         if (pext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
1903                 param->u.crypt.set_tx = 1;
1904
1905         /* cliW: WEP does not have group key
1906          * just not checking GROUP key setting
1907          */
1908         if ((pext->alg != IW_ENCODE_ALG_WEP) &&
1909             (pext->ext_flags & IW_ENCODE_EXT_GROUP_KEY))
1910                 param->u.crypt.set_tx = 0;
1911
1912         param->u.crypt.idx = (pencoding->flags&0x00FF) - 1;
1913
1914         if (pext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID)
1915                 memcpy(param->u.crypt.seq, pext->rx_seq, 8);
1916
1917         if (pext->key_len) {
1918                 param->u.crypt.key_len = pext->key_len;
1919                 memcpy(param->u.crypt.key, pext + 1, pext->key_len);
1920         }
1921
1922         ret =  wpa_set_encryption(dev, param, param_len);
1923
1924 exit:
1925         kfree(param);
1926         return ret;
1927 }
1928
1929 static int rtw_wx_get_nick(struct net_device *dev,
1930                            struct iw_request_info *info,
1931                            union iwreq_data *wrqu, char *extra)
1932 {
1933         if (extra) {
1934                 wrqu->data.length = 14;
1935                 wrqu->data.flags = 1;
1936                 memcpy(extra, "<WIFI@REALTEK>", 14);
1937         }
1938
1939         /* dump debug info here */
1940         return 0;
1941 }
1942
1943 static int dummy(struct net_device *dev, struct iw_request_info *a,
1944                  union iwreq_data *wrqu, char *b)
1945 {
1946         return -1;
1947 }
1948
1949 static int wpa_set_param(struct net_device *dev, u8 name, u32 value)
1950 {
1951         uint ret = 0;
1952         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1953
1954         switch (name) {
1955         case IEEE_PARAM_WPA_ENABLED:
1956                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; /* 802.1x */
1957                 switch ((value)&0xff) {
1958                 case 1: /* WPA */
1959                         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPAPSK; /* WPA_PSK */
1960                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
1961                         break;
1962                 case 2: /* WPA2 */
1963                         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPA2PSK; /* WPA2_PSK */
1964                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
1965                         break;
1966                 }
1967                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1968                          ("wpa_set_param:padapter->securitypriv.ndisauthtype =%d\n", padapter->securitypriv.ndisauthtype));
1969                 break;
1970         case IEEE_PARAM_TKIP_COUNTERMEASURES:
1971                 break;
1972         case IEEE_PARAM_DROP_UNENCRYPTED: {
1973                 /* HACK:
1974                  *
1975                  * wpa_supplicant calls set_wpa_enabled when the driver
1976                  * is loaded and unloaded, regardless of if WPA is being
1977                  * used.  No other calls are made which can be used to
1978                  * determine if encryption will be used or not prior to
1979                  * association being expected.  If encryption is not being
1980                  * used, drop_unencrypted is set to false, else true -- we
1981                  * can use this to determine if the CAP_PRIVACY_ON bit should
1982                  * be set.
1983                  */
1984
1985                 break;
1986         }
1987         case IEEE_PARAM_PRIVACY_INVOKED:
1988                 break;
1989
1990         case IEEE_PARAM_AUTH_ALGS:
1991                 ret = wpa_set_auth_algs(dev, value);
1992                 break;
1993         case IEEE_PARAM_IEEE_802_1X:
1994                 break;
1995         case IEEE_PARAM_WPAX_SELECT:
1996                 break;
1997         default:
1998                 ret = -EOPNOTSUPP;
1999                 break;
2000         }
2001         return ret;
2002 }
2003
2004 static int wpa_mlme(struct net_device *dev, u32 command, u32 reason)
2005 {
2006         int ret = 0;
2007         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2008
2009         switch (command) {
2010         case IEEE_MLME_STA_DEAUTH:
2011                 if (!rtw_set_802_11_disassociate(padapter))
2012                         ret = -1;
2013                 break;
2014         case IEEE_MLME_STA_DISASSOC:
2015                 if (!rtw_set_802_11_disassociate(padapter))
2016                         ret = -1;
2017                 break;
2018         default:
2019                 ret = -EOPNOTSUPP;
2020                 break;
2021         }
2022
2023         return ret;
2024 }
2025
2026 static int wpa_supplicant_ioctl(struct net_device *dev, struct iw_point *p)
2027 {
2028         struct ieee_param *param;
2029         uint ret = 0;
2030
2031         if (!p->pointer || p->length != sizeof(struct ieee_param)) {
2032                 ret = -EINVAL;
2033                 goto out;
2034         }
2035
2036         param = (struct ieee_param *)rtw_malloc(p->length);
2037         if (!param) {
2038                 ret = -ENOMEM;
2039                 goto out;
2040         }
2041
2042         if (copy_from_user(param, p->pointer, p->length)) {
2043                 kfree(param);
2044                 ret = -EFAULT;
2045                 goto out;
2046         }
2047
2048         switch (param->cmd) {
2049         case IEEE_CMD_SET_WPA_PARAM:
2050                 ret = wpa_set_param(dev, param->u.wpa_param.name, param->u.wpa_param.value);
2051                 break;
2052
2053         case IEEE_CMD_SET_WPA_IE:
2054                 ret =  rtw_set_wpa_ie((struct adapter *)rtw_netdev_priv(dev),
2055                                       (char *)param->u.wpa_ie.data, (u16)param->u.wpa_ie.len);
2056                 break;
2057
2058         case IEEE_CMD_SET_ENCRYPTION:
2059                 ret = wpa_set_encryption(dev, param, p->length);
2060                 break;
2061
2062         case IEEE_CMD_MLME:
2063                 ret = wpa_mlme(dev, param->u.mlme.command, param->u.mlme.reason_code);
2064                 break;
2065
2066         default:
2067                 DBG_88E("Unknown WPA supplicant request: %d\n", param->cmd);
2068                 ret = -EOPNOTSUPP;
2069                 break;
2070         }
2071
2072         if (ret == 0 && copy_to_user(p->pointer, param, p->length))
2073                 ret = -EFAULT;
2074
2075         kfree(param);
2076
2077 out:
2078
2079         return ret;
2080 }
2081
2082 #ifdef CONFIG_88EU_AP_MODE
2083 static u8 set_pairwise_key(struct adapter *padapter, struct sta_info *psta)
2084 {
2085         struct cmd_obj *ph2c;
2086         struct set_stakey_parm  *psetstakey_para;
2087         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
2088         u8 res = _SUCCESS;
2089
2090         ph2c = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
2091         if (!ph2c) {
2092                 res = _FAIL;
2093                 goto exit;
2094         }
2095
2096         psetstakey_para = kzalloc(sizeof(struct set_stakey_parm), GFP_KERNEL);
2097         if (!psetstakey_para) {
2098                 kfree(ph2c);
2099                 res = _FAIL;
2100                 goto exit;
2101         }
2102
2103         init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
2104
2105         psetstakey_para->algorithm = (u8)psta->dot118021XPrivacy;
2106
2107         memcpy(psetstakey_para->addr, psta->hwaddr, ETH_ALEN);
2108
2109         memcpy(psetstakey_para->key, &psta->dot118021x_UncstKey, 16);
2110
2111         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
2112
2113 exit:
2114
2115         return res;
2116 }
2117
2118 static int set_group_key(struct adapter *padapter, u8 *key, u8 alg, int keyid)
2119 {
2120         u8 keylen;
2121         struct cmd_obj *pcmd;
2122         struct setkey_parm *psetkeyparm;
2123         struct cmd_priv *pcmdpriv = &(padapter->cmdpriv);
2124         int res = _SUCCESS;
2125
2126         DBG_88E("%s\n", __func__);
2127
2128         pcmd = kzalloc(sizeof(struct    cmd_obj), GFP_KERNEL);
2129         if (!pcmd) {
2130                 res = _FAIL;
2131                 goto exit;
2132         }
2133         psetkeyparm = kzalloc(sizeof(struct setkey_parm), GFP_KERNEL);
2134         if (!psetkeyparm) {
2135                 kfree(pcmd);
2136                 res = _FAIL;
2137                 goto exit;
2138         }
2139
2140         psetkeyparm->keyid = (u8)keyid;
2141
2142         psetkeyparm->algorithm = alg;
2143
2144         psetkeyparm->set_tx = 1;
2145
2146         switch (alg) {
2147         case _WEP40_:
2148                 keylen = 5;
2149                 break;
2150         case _WEP104_:
2151                 keylen = 13;
2152                 break;
2153         case _TKIP_:
2154         case _TKIP_WTMIC_:
2155         case _AES_:
2156         default:
2157                 keylen = 16;
2158         }
2159
2160         memcpy(&(psetkeyparm->key[0]), key, keylen);
2161
2162         pcmd->cmdcode = _SetKey_CMD_;
2163         pcmd->parmbuf = (u8 *)psetkeyparm;
2164         pcmd->cmdsz =  (sizeof(struct setkey_parm));
2165         pcmd->rsp = NULL;
2166         pcmd->rspsz = 0;
2167
2168         INIT_LIST_HEAD(&pcmd->list);
2169
2170         res = rtw_enqueue_cmd(pcmdpriv, pcmd);
2171
2172 exit:
2173
2174         return res;
2175 }
2176
2177 static int set_wep_key(struct adapter *padapter, u8 *key, u8 keylen, int keyid)
2178 {
2179         u8 alg;
2180
2181         switch (keylen) {
2182         case 5:
2183                 alg = _WEP40_;
2184                 break;
2185         case 13:
2186                 alg = _WEP104_;
2187                 break;
2188         default:
2189                 alg = _NO_PRIVACY_;
2190         }
2191
2192         return set_group_key(padapter, key, alg, keyid);
2193 }
2194
2195 static int rtw_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len)
2196 {
2197         int ret = 0;
2198         u32 wep_key_idx, wep_key_len, wep_total_len;
2199         struct ndis_802_11_wep   *pwep = NULL;
2200         struct sta_info *psta = NULL, *pbcmc_sta = NULL;
2201         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2202         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
2203         struct security_priv *psecuritypriv = &(padapter->securitypriv);
2204         struct sta_priv *pstapriv = &padapter->stapriv;
2205
2206         DBG_88E("%s\n", __func__);
2207         param->u.crypt.err = 0;
2208         param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
2209         if (param_len !=  sizeof(struct ieee_param) + param->u.crypt.key_len) {
2210                 ret =  -EINVAL;
2211                 goto exit;
2212         }
2213         if (is_broadcast_ether_addr(param->sta_addr)) {
2214                 if (param->u.crypt.idx >= WEP_KEYS) {
2215                         ret = -EINVAL;
2216                         goto exit;
2217                 }
2218         } else {
2219                 psta = rtw_get_stainfo(pstapriv, param->sta_addr);
2220                 if (!psta) {
2221                         DBG_88E("rtw_set_encryption(), sta has already been removed or never been added\n");
2222                         goto exit;
2223                 }
2224         }
2225
2226         if (strcmp(param->u.crypt.alg, "none") == 0 && (!psta)) {
2227                 /* todo:clear default encryption keys */
2228
2229                 DBG_88E("clear default encryption keys, keyid =%d\n", param->u.crypt.idx);
2230                 goto exit;
2231         }
2232         if (strcmp(param->u.crypt.alg, "WEP") == 0 && (!psta)) {
2233                 DBG_88E("r871x_set_encryption, crypt.alg = WEP\n");
2234                 wep_key_idx = param->u.crypt.idx;
2235                 wep_key_len = param->u.crypt.key_len;
2236                 DBG_88E("r871x_set_encryption, wep_key_idx=%d, len=%d\n", wep_key_idx, wep_key_len);
2237                 if ((wep_key_idx >= WEP_KEYS) || (wep_key_len <= 0)) {
2238                         ret = -EINVAL;
2239                         goto exit;
2240                 }
2241
2242                 if (wep_key_len > 0) {
2243                         wep_key_len = wep_key_len <= 5 ? 5 : 13;
2244                         wep_total_len = wep_key_len + offsetof(struct ndis_802_11_wep, KeyMaterial);
2245                         pwep = (struct ndis_802_11_wep *)rtw_malloc(wep_total_len);
2246                         if (!pwep) {
2247                                 DBG_88E(" r871x_set_encryption: pwep allocate fail !!!\n");
2248                                 goto exit;
2249                         }
2250
2251                         memset(pwep, 0, wep_total_len);
2252
2253                         pwep->KeyLength = wep_key_len;
2254                         pwep->Length = wep_total_len;
2255                 }
2256
2257                 pwep->KeyIndex = wep_key_idx;
2258
2259                 memcpy(pwep->KeyMaterial,  param->u.crypt.key, pwep->KeyLength);
2260
2261                 if (param->u.crypt.set_tx) {
2262                         DBG_88E("wep, set_tx = 1\n");
2263
2264                         psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled;
2265                         psecuritypriv->dot11PrivacyAlgrthm = _WEP40_;
2266                         psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
2267
2268                         if (pwep->KeyLength == 13) {
2269                                 psecuritypriv->dot11PrivacyAlgrthm = _WEP104_;
2270                                 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
2271                         }
2272
2273                         psecuritypriv->dot11PrivacyKeyIndex = wep_key_idx;
2274
2275                         memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength);
2276
2277                         psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->KeyLength;
2278
2279                         set_wep_key(padapter, pwep->KeyMaterial, pwep->KeyLength, wep_key_idx);
2280                 } else {
2281                         DBG_88E("wep, set_tx = 0\n");
2282
2283                         /* don't update "psecuritypriv->dot11PrivacyAlgrthm" and */
2284                         /* psecuritypriv->dot11PrivacyKeyIndex = keyid", but can rtw_set_key to cam */
2285
2286                       memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength);
2287
2288                         psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->KeyLength;
2289
2290                         set_wep_key(padapter, pwep->KeyMaterial, pwep->KeyLength, wep_key_idx);
2291                 }
2292
2293                 goto exit;
2294         }
2295
2296         if (!psta && check_fwstate(pmlmepriv, WIFI_AP_STATE)) { /*  group key */
2297                 if (param->u.crypt.set_tx == 1) {
2298                         if (strcmp(param->u.crypt.alg, "WEP") == 0) {
2299                                 DBG_88E("%s, set group_key, WEP\n", __func__);
2300
2301                                 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
2302                                             param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
2303
2304                                 psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
2305                                 if (param->u.crypt.key_len == 13)
2306                                         psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
2307                         } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
2308                                 DBG_88E("%s, set group_key, TKIP\n", __func__);
2309                                 psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
2310                                 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
2311                                             param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
2312                                 /* set mic key */
2313                                 memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8);
2314                                 memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8);
2315
2316                                 psecuritypriv->busetkipkey = true;
2317                         } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
2318                                 DBG_88E("%s, set group_key, CCMP\n", __func__);
2319                                 psecuritypriv->dot118021XGrpPrivacy = _AES_;
2320                                 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
2321                                             param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
2322                         } else {
2323                                 DBG_88E("%s, set group_key, none\n", __func__);
2324                                 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
2325                         }
2326                         psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
2327                         psecuritypriv->binstallGrpkey = true;
2328                         psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/*  */
2329                         set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx);
2330                         pbcmc_sta = rtw_get_bcmc_stainfo(padapter);
2331                         if (pbcmc_sta) {
2332                                 pbcmc_sta->ieee8021x_blocked = false;
2333                                 pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */
2334                         }
2335                 }
2336                 goto exit;
2337         }
2338
2339         if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X && psta) { /*  psk/802_1x */
2340                 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
2341                         if (param->u.crypt.set_tx == 1) {
2342                                 memcpy(psta->dot118021x_UncstKey.skey,  param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
2343
2344                                 if (strcmp(param->u.crypt.alg, "WEP") == 0) {
2345                                         DBG_88E("%s, set pairwise key, WEP\n", __func__);
2346
2347                                         psta->dot118021XPrivacy = _WEP40_;
2348                                         if (param->u.crypt.key_len == 13)
2349                                                 psta->dot118021XPrivacy = _WEP104_;
2350                                 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
2351                                         DBG_88E("%s, set pairwise key, TKIP\n", __func__);
2352
2353                                         psta->dot118021XPrivacy = _TKIP_;
2354
2355                                         /* set mic key */
2356                                         memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8);
2357                                         memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8);
2358
2359                                         psecuritypriv->busetkipkey = true;
2360                                 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
2361                                         DBG_88E("%s, set pairwise key, CCMP\n", __func__);
2362
2363                                         psta->dot118021XPrivacy = _AES_;
2364                                 } else {
2365                                         DBG_88E("%s, set pairwise key, none\n", __func__);
2366
2367                                         psta->dot118021XPrivacy = _NO_PRIVACY_;
2368                                 }
2369
2370                                 set_pairwise_key(padapter, psta);
2371
2372                                 psta->ieee8021x_blocked = false;
2373                         } else { /* group key??? */
2374                                 if (strcmp(param->u.crypt.alg, "WEP") == 0) {
2375                                         memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
2376                                                     param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
2377                                         psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
2378                                         if (param->u.crypt.key_len == 13)
2379                                                 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
2380                                 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
2381                                         psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
2382
2383                                         memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
2384                                                     param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
2385
2386                                         /* set mic key */
2387                                         memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8);
2388                                         memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8);
2389
2390                                         psecuritypriv->busetkipkey = true;
2391                                 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
2392                                         psecuritypriv->dot118021XGrpPrivacy = _AES_;
2393
2394                                         memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
2395                                                     param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
2396                                 } else {
2397                                         psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
2398                                 }
2399
2400                                 psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
2401
2402                                 psecuritypriv->binstallGrpkey = true;
2403
2404                                 psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/*  */
2405
2406                                 set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx);
2407
2408                                 pbcmc_sta = rtw_get_bcmc_stainfo(padapter);
2409                                 if (pbcmc_sta) {
2410                                         pbcmc_sta->ieee8021x_blocked = false;
2411                                         pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */
2412                                 }
2413                         }
2414                 }
2415         }
2416
2417 exit:
2418
2419         kfree(pwep);
2420
2421         return ret;
2422 }
2423
2424 static int rtw_set_beacon(struct net_device *dev, struct ieee_param *param, int len)
2425 {
2426         int ret = 0;
2427         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2428         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2429         struct sta_priv *pstapriv = &padapter->stapriv;
2430         unsigned char *pbuf = param->u.bcn_ie.buf;
2431
2432         DBG_88E("%s, len =%d\n", __func__, len);
2433
2434         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
2435                 return -EINVAL;
2436
2437         memcpy(&pstapriv->max_num_sta, param->u.bcn_ie.reserved, 2);
2438
2439         if ((pstapriv->max_num_sta > NUM_STA) || (pstapriv->max_num_sta <= 0))
2440                 pstapriv->max_num_sta = NUM_STA;
2441
2442         if (rtw_check_beacon_data(padapter, pbuf,  (len-12-2)) == _SUCCESS)/*  12 = param header, 2:no packed */
2443                 ret = 0;
2444         else
2445                 ret = -EINVAL;
2446
2447         return ret;
2448 }
2449
2450 static int rtw_hostapd_sta_flush(struct net_device *dev)
2451 {
2452         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2453
2454         DBG_88E("%s\n", __func__);
2455
2456         flush_all_cam_entry(padapter);  /* clear CAM */
2457
2458         return rtw_sta_flush(padapter);
2459 }
2460
2461 static int rtw_add_sta(struct net_device *dev, struct ieee_param *param)
2462 {
2463         int ret = 0;
2464         struct sta_info *psta = NULL;
2465         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2466         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2467         struct sta_priv *pstapriv = &padapter->stapriv;
2468
2469         DBG_88E("rtw_add_sta(aid =%d) =%pM\n", param->u.add_sta.aid, (param->sta_addr));
2470
2471         if (!check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)))
2472                 return -EINVAL;
2473
2474         if (is_broadcast_ether_addr(param->sta_addr))
2475                 return -EINVAL;
2476
2477         psta = rtw_get_stainfo(pstapriv, param->sta_addr);
2478         if (psta) {
2479                 int flags = param->u.add_sta.flags;
2480
2481                 psta->aid = param->u.add_sta.aid;/* aid = 1~2007 */
2482
2483                 memcpy(psta->bssrateset, param->u.add_sta.tx_supp_rates, 16);
2484
2485                 /* check wmm cap. */
2486                 if (WLAN_STA_WME&flags)
2487                         psta->qos_option = 1;
2488                 else
2489                         psta->qos_option = 0;
2490
2491                 if (pmlmepriv->qospriv.qos_option == 0)
2492                         psta->qos_option = 0;
2493
2494                 /* chec 802.11n ht cap. */
2495                 if (WLAN_STA_HT&flags) {
2496                         psta->htpriv.ht_option = true;
2497                         psta->qos_option = 1;
2498                         memcpy(&psta->htpriv.ht_cap, &param->u.add_sta.ht_cap,
2499                                sizeof(struct ieee80211_ht_cap));
2500                 } else {
2501                         psta->htpriv.ht_option = false;
2502                 }
2503
2504                 if (pmlmepriv->htpriv.ht_option == false)
2505                         psta->htpriv.ht_option = false;
2506
2507                 update_sta_info_apmode(padapter, psta);
2508         } else {
2509                 ret = -ENOMEM;
2510         }
2511
2512         return ret;
2513 }
2514
2515 static int rtw_del_sta(struct net_device *dev, struct ieee_param *param)
2516 {
2517         int ret = 0;
2518         struct sta_info *psta = NULL;
2519         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2520         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2521         struct sta_priv *pstapriv = &padapter->stapriv;
2522         int updated = 0;
2523
2524         DBG_88E("rtw_del_sta =%pM\n", (param->sta_addr));
2525
2526         if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true)
2527                 return -EINVAL;
2528
2529         if (is_broadcast_ether_addr(param->sta_addr))
2530                 return -EINVAL;
2531
2532         psta = rtw_get_stainfo(pstapriv, param->sta_addr);
2533         if (psta) {
2534                 spin_lock_bh(&pstapriv->asoc_list_lock);
2535                 if (!list_empty(&psta->asoc_list)) {
2536                         list_del_init(&psta->asoc_list);
2537                         pstapriv->asoc_list_cnt--;
2538                         updated = ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING);
2539                 }
2540                 spin_unlock_bh(&pstapriv->asoc_list_lock);
2541                 associated_clients_update(padapter, updated);
2542                 psta = NULL;
2543         } else {
2544                 DBG_88E("rtw_del_sta(), sta has already been removed or never been added\n");
2545         }
2546
2547         return ret;
2548 }
2549
2550 static int rtw_ioctl_get_sta_data(struct net_device *dev, struct ieee_param *param, int len)
2551 {
2552         int ret = 0;
2553         struct sta_info *psta = NULL;
2554         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2555         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2556         struct sta_priv *pstapriv = &padapter->stapriv;
2557         struct ieee_param_ex *param_ex = (struct ieee_param_ex *)param;
2558         struct sta_data *psta_data = (struct sta_data *)param_ex->data;
2559
2560         DBG_88E("rtw_ioctl_get_sta_info, sta_addr: %pM\n", (param_ex->sta_addr));
2561
2562         if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true)
2563                 return -EINVAL;
2564
2565         if (is_broadcast_ether_addr(param_ex->sta_addr))
2566                 return -EINVAL;
2567
2568         psta = rtw_get_stainfo(pstapriv, param_ex->sta_addr);
2569         if (psta) {
2570                 psta_data->aid = (u16)psta->aid;
2571                 psta_data->capability = psta->capability;
2572                 psta_data->flags = psta->flags;
2573
2574 /*
2575                 nonerp_set : BIT(0)
2576                 no_short_slot_time_set : BIT(1)
2577                 no_short_preamble_set : BIT(2)
2578                 no_ht_gf_set : BIT(3)
2579                 no_ht_set : BIT(4)
2580                 ht_20mhz_set : BIT(5)
2581 */
2582
2583                 psta_data->sta_set = ((psta->nonerp_set) |
2584                                       (psta->no_short_slot_time_set << 1) |
2585                                       (psta->no_short_preamble_set << 2) |
2586                                       (psta->no_ht_gf_set << 3) |
2587                                       (psta->no_ht_set << 4) |
2588                                       (psta->ht_20mhz_set << 5));
2589                 psta_data->tx_supp_rates_len =  psta->bssratelen;
2590                 memcpy(psta_data->tx_supp_rates, psta->bssrateset, psta->bssratelen);
2591                 memcpy(&psta_data->ht_cap,
2592                        &psta->htpriv.ht_cap, sizeof(struct ieee80211_ht_cap));
2593                 psta_data->rx_pkts = psta->sta_stats.rx_data_pkts;
2594                 psta_data->rx_bytes = psta->sta_stats.rx_bytes;
2595                 psta_data->rx_drops = psta->sta_stats.rx_drops;
2596                 psta_data->tx_pkts = psta->sta_stats.tx_pkts;
2597                 psta_data->tx_bytes = psta->sta_stats.tx_bytes;
2598                 psta_data->tx_drops = psta->sta_stats.tx_drops;
2599         } else {
2600                 ret = -1;
2601         }
2602
2603         return ret;
2604 }
2605
2606 static int rtw_get_sta_wpaie(struct net_device *dev, struct ieee_param *param)
2607 {
2608         int ret = 0;
2609         struct sta_info *psta = NULL;
2610         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2611         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2612         struct sta_priv *pstapriv = &padapter->stapriv;
2613
2614         DBG_88E("rtw_get_sta_wpaie, sta_addr: %pM\n", (param->sta_addr));
2615
2616         if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true)
2617                 return -EINVAL;
2618
2619         if (is_broadcast_ether_addr(param->sta_addr))
2620                 return -EINVAL;
2621
2622         psta = rtw_get_stainfo(pstapriv, param->sta_addr);
2623         if (psta) {
2624                 if (psta->wpa_ie[0] == WLAN_EID_RSN ||
2625                     psta->wpa_ie[0] == WLAN_EID_VENDOR_SPECIFIC) {
2626                         int wpa_ie_len;
2627                         int copy_len;
2628
2629                         wpa_ie_len = psta->wpa_ie[1];
2630                         copy_len = min_t(int, wpa_ie_len + 2, sizeof(psta->wpa_ie));
2631                         param->u.wpa_ie.len = copy_len;
2632                         memcpy(param->u.wpa_ie.reserved, psta->wpa_ie, copy_len);
2633                 } else {
2634                         DBG_88E("sta's wpa_ie is NONE\n");
2635                 }
2636         } else {
2637                 ret = -1;
2638         }
2639
2640         return ret;
2641 }
2642
2643 static int rtw_set_wps_beacon(struct net_device *dev, struct ieee_param *param, int len)
2644 {
2645         int ret = 0;
2646         unsigned char wps_oui[4] = {0x0, 0x50, 0xf2, 0x04};
2647         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2648         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2649         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
2650         int ie_len;
2651
2652         DBG_88E("%s, len =%d\n", __func__, len);
2653
2654         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
2655                 return -EINVAL;
2656
2657         ie_len = len-12-2;/*  12 = param header, 2:no packed */
2658
2659         kfree(pmlmepriv->wps_beacon_ie);
2660         pmlmepriv->wps_beacon_ie = NULL;
2661
2662         if (ie_len > 0) {
2663                 pmlmepriv->wps_beacon_ie = rtw_malloc(ie_len);
2664                 pmlmepriv->wps_beacon_ie_len = ie_len;
2665                 if (!pmlmepriv->wps_beacon_ie) {
2666                         DBG_88E("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
2667                         return -EINVAL;
2668                 }
2669
2670                 memcpy(pmlmepriv->wps_beacon_ie, param->u.bcn_ie.buf, ie_len);
2671
2672                 update_beacon(padapter, _VENDOR_SPECIFIC_IE_, wps_oui, true);
2673
2674                 pmlmeext->bstart_bss = true;
2675         }
2676
2677         return ret;
2678 }
2679
2680 static int rtw_set_wps_probe_resp(struct net_device *dev, struct ieee_param *param, int len)
2681 {
2682         int ret = 0;
2683         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2684         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2685         int ie_len;
2686
2687         DBG_88E("%s, len =%d\n", __func__, len);
2688
2689         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
2690                 return -EINVAL;
2691
2692         ie_len = len-12-2;/*  12 = param header, 2:no packed */
2693
2694         kfree(pmlmepriv->wps_probe_resp_ie);
2695         pmlmepriv->wps_probe_resp_ie = NULL;
2696
2697         if (ie_len > 0) {
2698                 pmlmepriv->wps_probe_resp_ie = rtw_malloc(ie_len);
2699                 pmlmepriv->wps_probe_resp_ie_len = ie_len;
2700                 if (!pmlmepriv->wps_probe_resp_ie) {
2701                         DBG_88E("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
2702                         return -EINVAL;
2703                 }
2704                 memcpy(pmlmepriv->wps_probe_resp_ie, param->u.bcn_ie.buf, ie_len);
2705         }
2706
2707         return ret;
2708 }
2709
2710 static int rtw_set_wps_assoc_resp(struct net_device *dev, struct ieee_param *param, int len)
2711 {
2712         int ret = 0;
2713         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2714         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2715         int ie_len;
2716
2717         DBG_88E("%s, len =%d\n", __func__, len);
2718
2719         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
2720                 return -EINVAL;
2721
2722         ie_len = len-12-2;/*  12 = param header, 2:no packed */
2723
2724         kfree(pmlmepriv->wps_assoc_resp_ie);
2725         pmlmepriv->wps_assoc_resp_ie = NULL;
2726
2727         if (ie_len > 0) {
2728                 pmlmepriv->wps_assoc_resp_ie = rtw_malloc(ie_len);
2729                 pmlmepriv->wps_assoc_resp_ie_len = ie_len;
2730                 if (!pmlmepriv->wps_assoc_resp_ie) {
2731                         DBG_88E("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
2732                         return -EINVAL;
2733                 }
2734
2735                 memcpy(pmlmepriv->wps_assoc_resp_ie, param->u.bcn_ie.buf, ie_len);
2736         }
2737
2738         return ret;
2739 }
2740
2741 static int rtw_set_hidden_ssid(struct net_device *dev, struct ieee_param *param, int len)
2742 {
2743         int ret = 0;
2744         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2745         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2746         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
2747         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2748
2749         u8 value;
2750
2751         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
2752                 return -EINVAL;
2753
2754         if (param->u.wpa_param.name != 0) /* dummy test... */
2755                 DBG_88E("%s name(%u) != 0\n", __func__, param->u.wpa_param.name);
2756         value = param->u.wpa_param.value;
2757
2758         /* use the same definition of hostapd's ignore_broadcast_ssid */
2759         if (value != 1 && value != 2)
2760                 value = 0;
2761         DBG_88E("%s value(%u)\n", __func__, value);
2762         pmlmeinfo->hidden_ssid_mode = value;
2763         return ret;
2764 }
2765
2766 static int rtw_ioctl_acl_remove_sta(struct net_device *dev, struct ieee_param *param, int len)
2767 {
2768         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2769         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2770
2771         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
2772                 return -EINVAL;
2773
2774         if (is_broadcast_ether_addr(param->sta_addr))
2775                 return -EINVAL;
2776
2777         return rtw_acl_remove_sta(padapter, param->sta_addr);
2778 }
2779
2780 static int rtw_ioctl_acl_add_sta(struct net_device *dev, struct ieee_param *param, int len)
2781 {
2782         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2783         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2784
2785         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
2786                 return -EINVAL;
2787
2788         if (is_broadcast_ether_addr(param->sta_addr))
2789                 return -EINVAL;
2790
2791         return rtw_acl_add_sta(padapter, param->sta_addr);
2792 }
2793
2794 static int rtw_ioctl_set_macaddr_acl(struct net_device *dev, struct ieee_param *param, int len)
2795 {
2796         int ret = 0;
2797         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2798         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2799
2800         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
2801                 return -EINVAL;
2802
2803         rtw_set_macaddr_acl(padapter, param->u.mlme.command);
2804
2805         return ret;
2806 }
2807
2808 static int rtw_hostapd_ioctl(struct net_device *dev, struct iw_point *p)
2809 {
2810         struct ieee_param *param;
2811         int ret = 0;
2812         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2813
2814         /*
2815         * this function is expect to call in master mode, which allows no power saving
2816         * so, we just check hw_init_completed
2817         */
2818
2819         if (!padapter->hw_init_completed) {
2820                 ret = -EPERM;
2821                 goto out;
2822         }
2823
2824         if (!p->pointer || p->length != sizeof(struct ieee_param)) {
2825                 ret = -EINVAL;
2826                 goto out;
2827         }
2828
2829         param = (struct ieee_param *)rtw_malloc(p->length);
2830         if (!param) {
2831                 ret = -ENOMEM;
2832                 goto out;
2833         }
2834
2835         if (copy_from_user(param, p->pointer, p->length)) {
2836                 kfree(param);
2837                 ret = -EFAULT;
2838                 goto out;
2839         }
2840
2841         switch (param->cmd) {
2842         case RTL871X_HOSTAPD_FLUSH:
2843                 ret = rtw_hostapd_sta_flush(dev);
2844                 break;
2845         case RTL871X_HOSTAPD_ADD_STA:
2846                 ret = rtw_add_sta(dev, param);
2847                 break;
2848         case RTL871X_HOSTAPD_REMOVE_STA:
2849                 ret = rtw_del_sta(dev, param);
2850                 break;
2851         case RTL871X_HOSTAPD_SET_BEACON:
2852                 ret = rtw_set_beacon(dev, param, p->length);
2853                 break;
2854         case RTL871X_SET_ENCRYPTION:
2855                 ret = rtw_set_encryption(dev, param, p->length);
2856                 break;
2857         case RTL871X_HOSTAPD_GET_WPAIE_STA:
2858                 ret = rtw_get_sta_wpaie(dev, param);
2859                 break;
2860         case RTL871X_HOSTAPD_SET_WPS_BEACON:
2861                 ret = rtw_set_wps_beacon(dev, param, p->length);
2862                 break;
2863         case RTL871X_HOSTAPD_SET_WPS_PROBE_RESP:
2864                 ret = rtw_set_wps_probe_resp(dev, param, p->length);
2865                 break;
2866         case RTL871X_HOSTAPD_SET_WPS_ASSOC_RESP:
2867                 ret = rtw_set_wps_assoc_resp(dev, param, p->length);
2868                 break;
2869         case RTL871X_HOSTAPD_SET_HIDDEN_SSID:
2870                 ret = rtw_set_hidden_ssid(dev, param, p->length);
2871                 break;
2872         case RTL871X_HOSTAPD_GET_INFO_STA:
2873                 ret = rtw_ioctl_get_sta_data(dev, param, p->length);
2874                 break;
2875         case RTL871X_HOSTAPD_SET_MACADDR_ACL:
2876                 ret = rtw_ioctl_set_macaddr_acl(dev, param, p->length);
2877                 break;
2878         case RTL871X_HOSTAPD_ACL_ADD_STA:
2879                 ret = rtw_ioctl_acl_add_sta(dev, param, p->length);
2880                 break;
2881         case RTL871X_HOSTAPD_ACL_REMOVE_STA:
2882                 ret = rtw_ioctl_acl_remove_sta(dev, param, p->length);
2883                 break;
2884         default:
2885                 DBG_88E("Unknown hostapd request: %d\n", param->cmd);
2886                 ret = -EOPNOTSUPP;
2887                 break;
2888         }
2889
2890         if (ret == 0 && copy_to_user(p->pointer, param, p->length))
2891                 ret = -EFAULT;
2892         kfree(param);
2893 out:
2894         return ret;
2895 }
2896 #endif
2897
2898 #include <rtw_android.h>
2899 static int rtw_wx_set_priv(struct net_device *dev,
2900                                 struct iw_request_info *info,
2901                                 union iwreq_data *awrq,
2902                                 char *extra)
2903 {
2904         int ret = 0;
2905         int len = 0;
2906         char *ext;
2907         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2908         struct iw_point *dwrq = (struct iw_point *)awrq;
2909
2910         if (dwrq->length == 0)
2911                 return -EFAULT;
2912
2913         len = dwrq->length;
2914         ext = vmalloc(len);
2915         if (!ext)
2916                 return -ENOMEM;
2917
2918         if (copy_from_user(ext, dwrq->pointer, len)) {
2919                 vfree(ext);
2920                 return -EFAULT;
2921         }
2922
2923         /* added for wps2.0 @20110524 */
2924         if (dwrq->flags == 0x8766 && len > 8) {
2925                 u32 cp_sz;
2926                 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2927                 u8 *probereq_wpsie = ext;
2928                 int probereq_wpsie_len = len;
2929                 u8 wps_oui[4] = {0x0, 0x50, 0xf2, 0x04};
2930
2931                 if ((_VENDOR_SPECIFIC_IE_ == probereq_wpsie[0]) &&
2932                     (!memcmp(&probereq_wpsie[2], wps_oui, 4))) {
2933                         cp_sz = min(probereq_wpsie_len, MAX_WPS_IE_LEN);
2934
2935                         pmlmepriv->wps_probe_req_ie_len = 0;
2936                         kfree(pmlmepriv->wps_probe_req_ie);
2937                         pmlmepriv->wps_probe_req_ie = NULL;
2938
2939                         pmlmepriv->wps_probe_req_ie = rtw_malloc(cp_sz);
2940                         if (!pmlmepriv->wps_probe_req_ie) {
2941                                 pr_info("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
2942                                 ret =  -EINVAL;
2943                                 goto FREE_EXT;
2944                         }
2945                         memcpy(pmlmepriv->wps_probe_req_ie, probereq_wpsie, cp_sz);
2946                         pmlmepriv->wps_probe_req_ie_len = cp_sz;
2947                 }
2948                 goto FREE_EXT;
2949         }
2950
2951         if (len >= WEXT_CSCAN_HEADER_SIZE &&
2952             !memcmp(ext, WEXT_CSCAN_HEADER, WEXT_CSCAN_HEADER_SIZE)) {
2953                 ret = rtw_wx_set_scan(dev, info, awrq, ext);
2954                 goto FREE_EXT;
2955         }
2956
2957 FREE_EXT:
2958
2959         vfree(ext);
2960
2961         return ret;
2962 }
2963
2964 static iw_handler rtw_handlers[] = {
2965         NULL,                                   /* SIOCSIWCOMMIT */
2966         rtw_wx_get_name,                /* SIOCGIWNAME */
2967         dummy,                                  /* SIOCSIWNWID */
2968         dummy,                                  /* SIOCGIWNWID */
2969         rtw_wx_set_freq,                /* SIOCSIWFREQ */
2970         rtw_wx_get_freq,                /* SIOCGIWFREQ */
2971         rtw_wx_set_mode,                /* SIOCSIWMODE */
2972         rtw_wx_get_mode,                /* SIOCGIWMODE */
2973         dummy,                                  /* SIOCSIWSENS */
2974         rtw_wx_get_sens,                /* SIOCGIWSENS */
2975         NULL,                                   /* SIOCSIWRANGE */
2976         rtw_wx_get_range,               /* SIOCGIWRANGE */
2977         rtw_wx_set_priv,                /* SIOCSIWPRIV */
2978         NULL,                                   /* SIOCGIWPRIV */
2979         NULL,                                   /* SIOCSIWSTATS */
2980         NULL,                                   /* SIOCGIWSTATS */
2981         dummy,                                  /* SIOCSIWSPY */
2982         dummy,                                  /* SIOCGIWSPY */
2983         NULL,                                   /* SIOCGIWTHRSPY */
2984         NULL,                                   /* SIOCWIWTHRSPY */
2985         rtw_wx_set_wap,         /* SIOCSIWAP */
2986         rtw_wx_get_wap,         /* SIOCGIWAP */
2987         rtw_wx_set_mlme,                /* request MLME operation; uses struct iw_mlme */
2988         dummy,                                  /* SIOCGIWAPLIST -- depricated */
2989         rtw_wx_set_scan,                /* SIOCSIWSCAN */
2990         rtw_wx_get_scan,                /* SIOCGIWSCAN */
2991         rtw_wx_set_essid,               /* SIOCSIWESSID */
2992         rtw_wx_get_essid,               /* SIOCGIWESSID */
2993         dummy,                                  /* SIOCSIWNICKN */
2994         rtw_wx_get_nick,                /* SIOCGIWNICKN */
2995         NULL,                                   /* -- hole -- */
2996         NULL,                                   /* -- hole -- */
2997         rtw_wx_set_rate,                /* SIOCSIWRATE */
2998         rtw_wx_get_rate,                /* SIOCGIWRATE */
2999         rtw_wx_set_rts,                 /* SIOCSIWRTS */
3000         rtw_wx_get_rts,                 /* SIOCGIWRTS */
3001         rtw_wx_set_frag,                /* SIOCSIWFRAG */
3002         rtw_wx_get_frag,                /* SIOCGIWFRAG */
3003         dummy,                                  /* SIOCSIWTXPOW */
3004         dummy,                                  /* SIOCGIWTXPOW */
3005         dummy,                                  /* SIOCSIWRETRY */
3006         rtw_wx_get_retry,               /* SIOCGIWRETRY */
3007         rtw_wx_set_enc,                 /* SIOCSIWENCODE */
3008         rtw_wx_get_enc,                 /* SIOCGIWENCODE */
3009         dummy,                                  /* SIOCSIWPOWER */
3010         rtw_wx_get_power,               /* SIOCGIWPOWER */
3011         NULL,                                   /*---hole---*/
3012         NULL,                                   /*---hole---*/
3013         rtw_wx_set_gen_ie,              /* SIOCSIWGENIE */
3014         NULL,                                   /* SIOCGWGENIE */
3015         rtw_wx_set_auth,                /* SIOCSIWAUTH */
3016         NULL,                                   /* SIOCGIWAUTH */
3017         rtw_wx_set_enc_ext,             /* SIOCSIWENCODEEXT */
3018         NULL,                                   /* SIOCGIWENCODEEXT */
3019         rtw_wx_set_pmkid,               /* SIOCSIWPMKSA */
3020         NULL,                                   /*---hole---*/
3021 };
3022
3023 static struct iw_statistics *rtw_get_wireless_stats(struct net_device *dev)
3024 {
3025         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
3026         struct iw_statistics *piwstats = &padapter->iwstats;
3027         int tmp_level = 0;
3028         int tmp_qual = 0;
3029         int tmp_noise = 0;
3030
3031         if (!check_fwstate(&padapter->mlmepriv, _FW_LINKED)) {
3032                 piwstats->qual.qual = 0;
3033                 piwstats->qual.level = 0;
3034                 piwstats->qual.noise = 0;
3035         } else {
3036                 tmp_level = padapter->recvpriv.signal_strength;
3037                 tmp_qual = padapter->recvpriv.signal_qual;
3038                 tmp_noise = padapter->recvpriv.noise;
3039
3040                 piwstats->qual.level = tmp_level;
3041                 piwstats->qual.qual = tmp_qual;
3042                 piwstats->qual.noise = tmp_noise;
3043         }
3044         piwstats->qual.updated = IW_QUAL_ALL_UPDATED;/* IW_QUAL_DBM; */
3045         return &padapter->iwstats;
3046 }
3047
3048 struct iw_handler_def rtw_handlers_def = {
3049         .standard = rtw_handlers,
3050         .num_standard = ARRAY_SIZE(rtw_handlers),
3051         .get_wireless_stats = rtw_get_wireless_stats,
3052 };
3053
3054 int rtw_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
3055 {
3056         struct iwreq *wrq = (struct iwreq *)rq;
3057         int ret = 0;
3058
3059         switch (cmd) {
3060         case RTL_IOCTL_WPA_SUPPLICANT:
3061                 ret = wpa_supplicant_ioctl(dev, &wrq->u.data);
3062                 break;
3063 #ifdef CONFIG_88EU_AP_MODE
3064         case RTL_IOCTL_HOSTAPD:
3065                 ret = rtw_hostapd_ioctl(dev, &wrq->u.data);
3066                 break;
3067 #endif /*  CONFIG_88EU_AP_MODE */
3068         case (SIOCDEVPRIVATE+1):
3069                 ret = rtw_android_priv_cmd(dev, rq, cmd);
3070                 break;
3071         default:
3072                 ret = -EOPNOTSUPP;
3073                 break;
3074         }
3075         return ret;
3076 }