drivers/staging/rtl8723bs/os_dep/ioctl_linux.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  ******************************************************************************/
  15 #define _IOCTL_LINUX_C_
  16
  17 #include <drv_types.h>
  18 #include <rtw_debug.h>
  19 #include <rtw_mp.h>
  20 #include <linux/jiffies.h>
  21
  22 #define RTL_IOCTL_WPA_SUPPLICANT        (SIOCIWFIRSTPRIV+30)
  23
  24 #define SCAN_ITEM_SIZE 768
  25 #define MAX_CUSTOM_LEN 64
  26 #define RATE_COUNT 4
  27
  28 /*  combo scan */
  29 #define WEXT_CSCAN_AMOUNT 9
  30 #define WEXT_CSCAN_BUF_LEN              360
  31 #define WEXT_CSCAN_HEADER               "CSCAN S\x01\x00\x00S\x00"
  32 #define WEXT_CSCAN_HEADER_SIZE          12
  33 #define WEXT_CSCAN_SSID_SECTION         'S'
  34 #define WEXT_CSCAN_CHANNEL_SECTION      'C'
  35 #define WEXT_CSCAN_NPROBE_SECTION       'N'
  36 #define WEXT_CSCAN_ACTV_DWELL_SECTION   'A'
  37 #define WEXT_CSCAN_PASV_DWELL_SECTION   'P'
  38 #define WEXT_CSCAN_HOME_DWELL_SECTION   'H'
  39 #define WEXT_CSCAN_TYPE_SECTION         'T'
  40
  41
  42 extern u8 key_2char2num(u8 hch, u8 lch);
  43
  44 static u32 rtw_rates[] = {1000000, 2000000, 5500000, 11000000,
  45         6000000, 9000000, 12000000, 18000000, 24000000, 36000000, 48000000, 54000000};
  46
  47 static const char * const iw_operation_mode[] = {
  48         "Auto", "Ad-Hoc", "Managed",  "Master", "Repeater", "Secondary", "Monitor"
  49 };
  50
  51 static int hex2num_i(char c)
  52 {
  53         if (c >= '0' && c <= '9')
  54                 return c - '0';
  55         if (c >= 'a' && c <= 'f')
  56                 return c - 'a' + 10;
  57         if (c >= 'A' && c <= 'F')
  58                 return c - 'A' + 10;
  59         return -1;
  60 }
  61
  62 /**
  63  * hwaddr_aton - Convert ASCII string to MAC address
  64  * @txt: MAC address as a string (e.g., "00:11:22:33:44:55")
  65  * @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
  66  * Returns: 0 on success, -1 on failure (e.g., string not a MAC address)
  67  */
  68 static int hwaddr_aton_i(const char *txt, u8 *addr)
  69 {
  70         int i;
  71
  72         for (i = 0; i < 6; i++) {
  73                 int a, b;
  74
  75                 a = hex2num_i(*txt++);
  76                 if (a < 0)
  77                         return -1;
  78                 b = hex2num_i(*txt++);
  79                 if (b < 0)
  80                         return -1;
  81                 *addr++ = (a << 4) | b;
  82                 if (i < 5 && *txt++ != ':')
  83                         return -1;
  84         }
  85
  86         return 0;
  87 }
  88
  89 void indicate_wx_scan_complete_event(struct adapter *padapter)
  90 {
  91         union iwreq_data wrqu;
  92
  93         memset(&wrqu, 0, sizeof(union iwreq_data));
  94
  95         /* DBG_871X("+rtw_indicate_wx_scan_complete_event\n"); */
  96 }
  97
  98
  99 void rtw_indicate_wx_assoc_event(struct adapter *padapter)
 100 {
 101         union iwreq_data wrqu;
 102         struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
 103         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 104         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
 105         struct wlan_bssid_ex            *pnetwork = (struct wlan_bssid_ex*)(&(pmlmeinfo->network));
 106
 107         memset(&wrqu, 0, sizeof(union iwreq_data));
 108
 109         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
 110
 111         if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) ==true)
 112                 memcpy(wrqu.ap_addr.sa_data, pnetwork->MacAddress, ETH_ALEN);
 113         else
 114                 memcpy(wrqu.ap_addr.sa_data, pmlmepriv->cur_network.network.MacAddress, ETH_ALEN);
 115
 116         DBG_871X_LEVEL(_drv_always_, "assoc success\n");
 117 }
 118
 119 void rtw_indicate_wx_disassoc_event(struct adapter *padapter)
 120 {
 121         union iwreq_data wrqu;
 122
 123         memset(&wrqu, 0, sizeof(union iwreq_data));
 124
 125         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
 126         memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
 127 }
 128
 129 /*
 130 uint    rtw_is_cckrates_included(u8 *rate)
 131 {
 132                 u32 i = 0;
 133
 134                 while (rate[i]!= 0)
 135                 {
 136                         if  ((((rate[i]) & 0x7f) == 2)  || (((rate[i]) & 0x7f) == 4) ||
 137                         (((rate[i]) & 0x7f) == 11)  || (((rate[i]) & 0x7f) == 22))
 138                         return true;
 139                         i++;
 140                 }
 141
 142                 return false;
 143 }
 144
 145 uint    rtw_is_cckratesonly_included(u8 *rate)
 146 {
 147         u32 i = 0;
 148
 149         while (rate[i]!= 0)
 150         {
 151                         if  ((((rate[i]) & 0x7f) != 2) && (((rate[i]) & 0x7f) != 4) &&
 152                                 (((rate[i]) & 0x7f) != 11)  && (((rate[i]) & 0x7f) != 22))
 153                         return false;
 154                         i++;
 155         }
 156
 157         return true;
 158 }
 159 */
 160
 161 static char *translate_scan(struct adapter *padapter,
 162                                 struct iw_request_info* info, struct wlan_network *pnetwork,
 163                                 char *start, char *stop)
 164 {
 165         struct iw_event iwe;
 166         u16 cap;
 167         u32 ht_ielen = 0;
 168         char *custom = NULL;
 169         char *p;
 170         u16 max_rate = 0, rate, ht_cap =false, vht_cap = false;
 171         u32 i = 0;
 172         u8 bw_40MHz = 0, short_GI = 0;
 173         u16 mcs_rate = 0, vht_data_rate = 0;
 174         u8 ie_offset = (pnetwork->network.Reserved[0] == 2? 0:12);
 175         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 176         u8 ss, sq;
 177
 178         /*  AP MAC address  */
 179         iwe.cmd = SIOCGIWAP;
 180         iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
 181
 182         memcpy(iwe.u.ap_addr.sa_data, pnetwork->network.MacAddress, ETH_ALEN);
 183         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_ADDR_LEN);
 184
 185         /* Add the ESSID */
 186         iwe.cmd = SIOCGIWESSID;
 187         iwe.u.data.flags = 1;
 188         iwe.u.data.length = min((u16)pnetwork->network.Ssid.SsidLength, (u16)32);
 189         start = iwe_stream_add_point(info, start, stop, &iwe, pnetwork->network.Ssid.Ssid);
 190
 191         /* parsing HT_CAP_IE */
 192         if (pnetwork->network.Reserved[0] == 2) { /*  Probe Request */
 193                 p = rtw_get_ie(&pnetwork->network.IEs[0], _HT_CAPABILITY_IE_, &ht_ielen, pnetwork->network.IELength);
 194         } else {
 195                 p = rtw_get_ie(&pnetwork->network.IEs[12], _HT_CAPABILITY_IE_, &ht_ielen, pnetwork->network.IELength-12);
 196         }
 197         if (p && ht_ielen>0) {
 198                 struct rtw_ieee80211_ht_cap *pht_capie;
 199                 ht_cap = true;
 200                 pht_capie = (struct rtw_ieee80211_ht_cap *)(p+2);
 201                 memcpy(&mcs_rate , pht_capie->supp_mcs_set, 2);
 202                 bw_40MHz = (le16_to_cpu(pht_capie->cap_info) & IEEE80211_HT_CAP_SUP_WIDTH) ? 1 : 0;
 203                 short_GI = (le16_to_cpu(pht_capie->cap_info) & (IEEE80211_HT_CAP_SGI_20 | IEEE80211_HT_CAP_SGI_40)) ? 1 : 0;
 204         }
 205
 206         /* Add the protocol name */
 207         iwe.cmd = SIOCGIWNAME;
 208         if ((rtw_is_cckratesonly_included((u8 *)&pnetwork->network.SupportedRates)) == true) {
 209                 if (ht_cap == true)
 210                         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bn");
 211                 else
 212                 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11b");
 213         } else if ((rtw_is_cckrates_included((u8 *)&pnetwork->network.SupportedRates)) == true) {
 214                 if (ht_cap == true)
 215                         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bgn");
 216                 else
 217                         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bg");
 218         } else {
 219                 if (pnetwork->network.Configuration.DSConfig > 14) {
 220                         if (vht_cap == true)
 221                                 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11AC");
 222                         else if (ht_cap == true)
 223                                 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11an");
 224                         else
 225                                 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11a");
 226                 } else {
 227                         if (ht_cap == true)
 228                                 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11gn");
 229                         else
 230                                 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11g");
 231                 }
 232         }
 233
 234         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_CHAR_LEN);
 235
 236           /* Add mode */
 237         if (pnetwork->network.Reserved[0] == 2) { /*  Probe Request */
 238                 cap = 0;
 239         } else {
 240                 __le16 le_tmp;
 241
 242                 iwe.cmd = SIOCGIWMODE;
 243                 memcpy((u8 *)&le_tmp, rtw_get_capability_from_ie(pnetwork->network.IEs), 2);
 244                 cap = le16_to_cpu(le_tmp);
 245         }
 246
 247         if (cap & (WLAN_CAPABILITY_IBSS |WLAN_CAPABILITY_BSS)) {
 248                 if (cap & WLAN_CAPABILITY_BSS)
 249                         iwe.u.mode = IW_MODE_MASTER;
 250                 else
 251                         iwe.u.mode = IW_MODE_ADHOC;
 252
 253                 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_UINT_LEN);
 254         }
 255
 256         if (pnetwork->network.Configuration.DSConfig<1 /*|| pnetwork->network.Configuration.DSConfig>14*/)
 257                 pnetwork->network.Configuration.DSConfig = 1;
 258
 259          /* Add frequency/channel */
 260         iwe.cmd = SIOCGIWFREQ;
 261         iwe.u.freq.m = rtw_ch2freq(pnetwork->network.Configuration.DSConfig) * 100000;
 262         iwe.u.freq.e = 1;
 263         iwe.u.freq.i = pnetwork->network.Configuration.DSConfig;
 264         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_FREQ_LEN);
 265
 266         /* Add encryption capability */
 267         iwe.cmd = SIOCGIWENCODE;
 268         if (cap & WLAN_CAPABILITY_PRIVACY)
 269                 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
 270         else
 271                 iwe.u.data.flags = IW_ENCODE_DISABLED;
 272         iwe.u.data.length = 0;
 273         start = iwe_stream_add_point(info, start, stop, &iwe, pnetwork->network.Ssid.Ssid);
 274
 275         /*Add basic and extended rates */
 276         max_rate = 0;
 277         custom = kzalloc(MAX_CUSTOM_LEN, GFP_ATOMIC);
 278         if (!custom)
 279                 return start;
 280         p = custom;
 281         p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), " Rates (Mb/s): ");
 282         while (pnetwork->network.SupportedRates[i]!= 0) {
 283                 rate = pnetwork->network.SupportedRates[i]&0x7F;
 284                 if (rate > max_rate)
 285                         max_rate = rate;
 286                 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
 287                               "%d%s ", rate >> 1, (rate & 1) ? ".5" : "");
 288                 i++;
 289         }
 290
 291         if (vht_cap == true) {
 292                 max_rate = vht_data_rate;
 293         } else if (ht_cap == true) {
 294                 if (mcs_rate&0x8000) { /* MCS15 */
 295                         max_rate = (bw_40MHz) ? ((short_GI)?300:270):((short_GI)?144:130);
 296                 } else if (mcs_rate&0x0080) { /* MCS7 */
 297                         max_rate = (bw_40MHz) ? ((short_GI)?150:135):((short_GI)?72:65);
 298                 } else { /* default MCS7 */
 299                         /* DBG_871X("wx_get_scan, mcs_rate_bitmap = 0x%x\n", mcs_rate); */
 300                         max_rate = (bw_40MHz) ? ((short_GI)?150:135):((short_GI)?72:65);
 301                 }
 302
 303                 max_rate = max_rate*2;/* Mbps/2; */
 304         }
 305
 306         iwe.cmd = SIOCGIWRATE;
 307         iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
 308         iwe.u.bitrate.value = max_rate * 500000;
 309         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_PARAM_LEN);
 310
 311         /* parsing WPA/WPA2 IE */
 312         if (pnetwork->network.Reserved[0] != 2) { /*  Probe Request */
 313                 u8 *buf;
 314                 u8 wpa_ie[255], rsn_ie[255];
 315                 u16 wpa_len = 0, rsn_len = 0;
 316                 u8 *p;
 317                 sint out_len = 0;
 318                 out_len =rtw_get_sec_ie(pnetwork->network.IEs , pnetwork->network.IELength, rsn_ie,&rsn_len, wpa_ie,&wpa_len);
 319                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_scan: ssid =%s\n", pnetwork->network.Ssid.Ssid));
 320                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_scan: wpa_len =%d rsn_len =%d\n", wpa_len, rsn_len));
 321
 322                 buf = kzalloc(MAX_WPA_IE_LEN*2, GFP_KERNEL);
 323                 if (!buf)
 324                         return start;
 325                 if (wpa_len > 0) {
 326                         p =buf;
 327                         p += sprintf(p, "wpa_ie =");
 328                         for (i = 0; i < wpa_len; i++)
 329                                 p += sprintf(p, "%02x", wpa_ie[i]);
 330
 331                         if (wpa_len > 100) {
 332                                 printk("-----------------Len %d----------------\n", wpa_len);
 333                                 for (i = 0; i < wpa_len; i++)
 334                                         printk("%02x ", wpa_ie[i]);
 335                                 printk("\n");
 336                                 printk("-----------------Len %d----------------\n", wpa_len);
 337                         }
 338
 339                         memset(&iwe, 0, sizeof(iwe));
 340                         iwe.cmd = IWEVCUSTOM;
 341                         iwe.u.data.length = strlen(buf);
 342                         start = iwe_stream_add_point(info, start, stop, &iwe, buf);
 343
 344                         memset(&iwe, 0, sizeof(iwe));
 345                         iwe.cmd =IWEVGENIE;
 346                         iwe.u.data.length = wpa_len;
 347                         start = iwe_stream_add_point(info, start, stop, &iwe, wpa_ie);
 348                 }
 349                 if (rsn_len > 0) {
 350                         p = buf;
 351                         memset(buf, 0, MAX_WPA_IE_LEN*2);
 352                         p += sprintf(p, "rsn_ie =");
 353                         for (i = 0; i < rsn_len; i++)
 354                                 p += sprintf(p, "%02x", rsn_ie[i]);
 355                         memset(&iwe, 0, sizeof(iwe));
 356                         iwe.cmd = IWEVCUSTOM;
 357                         iwe.u.data.length = strlen(buf);
 358                         start = iwe_stream_add_point(info, start, stop, &iwe, buf);
 359
 360                         memset(&iwe, 0, sizeof(iwe));
 361                         iwe.cmd =IWEVGENIE;
 362                         iwe.u.data.length = rsn_len;
 363                         start = iwe_stream_add_point(info, start, stop, &iwe, rsn_ie);
 364                 }
 365                 kfree(buf);
 366         }
 367
 368         { /* parsing WPS IE */
 369                 uint cnt = 0, total_ielen;
 370                 u8 *wpsie_ptr = NULL;
 371                 uint wps_ielen = 0;
 372
 373                 u8 *ie_ptr = pnetwork->network.IEs + ie_offset;
 374                 total_ielen = pnetwork->network.IELength - ie_offset;
 375
 376                 if (pnetwork->network.Reserved[0] == 2) { /*  Probe Request */
 377                         ie_ptr = pnetwork->network.IEs;
 378                         total_ielen = pnetwork->network.IELength;
 379                 } else {    /*  Beacon or Probe Respones */
 380                         ie_ptr = pnetwork->network.IEs + _FIXED_IE_LENGTH_;
 381                         total_ielen = pnetwork->network.IELength - _FIXED_IE_LENGTH_;
 382                 }
 383
 384                 while (cnt < total_ielen) {
 385                         if (rtw_is_wps_ie(&ie_ptr[cnt], &wps_ielen) && (wps_ielen>2)) {
 386                                 wpsie_ptr = &ie_ptr[cnt];
 387                                 iwe.cmd =IWEVGENIE;
 388                                 iwe.u.data.length = (u16)wps_ielen;
 389                                 start = iwe_stream_add_point(info, start, stop, &iwe, wpsie_ptr);
 390                         }
 391                         cnt+=ie_ptr[cnt+1]+2; /* goto next */
 392                 }
 393         }
 394
 395         /* Add quality statistics */
 396         iwe.cmd = IWEVQUAL;
 397         iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED
 398         #if defined(CONFIG_SIGNAL_DISPLAY_DBM) && defined(CONFIG_BACKGROUND_NOISE_MONITOR)
 399                 | IW_QUAL_NOISE_UPDATED
 400         #else
 401                 | IW_QUAL_NOISE_INVALID
 402         #endif
 403         #ifdef CONFIG_SIGNAL_DISPLAY_DBM
 404                 | IW_QUAL_DBM
 405         #endif
 406         ;
 407
 408         if (check_fwstate(pmlmepriv, _FW_LINKED) == true &&
 409                 is_same_network(&pmlmepriv->cur_network.network, &pnetwork->network, 0)) {
 410                 ss = padapter->recvpriv.signal_strength;
 411                 sq = padapter->recvpriv.signal_qual;
 412         } else {
 413                 ss = pnetwork->network.PhyInfo.SignalStrength;
 414                 sq = pnetwork->network.PhyInfo.SignalQuality;
 415         }
 416
 417
 418         #ifdef CONFIG_SIGNAL_DISPLAY_DBM
 419         iwe.u.qual.level = (u8) translate_percentage_to_dbm(ss);/* dbm */
 420         #else
 421         #ifdef CONFIG_SKIP_SIGNAL_SCALE_MAPPING
 422         {
 423                 /* Do signal scale mapping when using percentage as the unit of signal strength, since the scale mapping is skipped in odm */
 424
 425                 struct hal_com_data *pHal = GET_HAL_DATA(padapter);
 426
 427                 iwe.u.qual.level = (u8)odm_SignalScaleMapping(&pHal->odmpriv, ss);
 428         }
 429         #else
 430         iwe.u.qual.level = (u8)ss;/*  */
 431         #endif
 432         #endif
 433
 434         iwe.u.qual.qual = (u8)sq;   /*  signal quality */
 435
 436         #if defined(CONFIG_SIGNAL_DISPLAY_DBM) && defined(CONFIG_BACKGROUND_NOISE_MONITOR)
 437         {
 438                 s16 tmp_noise = 0;
 439                 rtw_hal_get_odm_var(padapter, HAL_ODM_NOISE_MONITOR,&(pnetwork->network.Configuration.DSConfig), &(tmp_noise));
 440                 iwe.u.qual.noise = tmp_noise ;
 441         }
 442         #else
 443         iwe.u.qual.noise = 0; /*  noise level */
 444         #endif
 445
 446         /* DBG_871X("iqual =%d, ilevel =%d, inoise =%d, iupdated =%d\n", iwe.u.qual.qual, iwe.u.qual.level , iwe.u.qual.noise, iwe.u.qual.updated); */
 447
 448         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_QUAL_LEN);
 449
 450         {
 451                 u8 *buf;
 452                 u8 *p, *pos;
 453
 454                 buf = kzalloc(MAX_WPA_IE_LEN, GFP_KERNEL);
 455                 if (!buf)
 456                         goto exit;
 457                 p = buf;
 458                 pos = pnetwork->network.Reserved;
 459                 p += sprintf(p, "fm =%02X%02X", pos[1], pos[0]);
 460                 memset(&iwe, 0, sizeof(iwe));
 461                 iwe.cmd = IWEVCUSTOM;
 462                 iwe.u.data.length = strlen(buf);
 463                 start = iwe_stream_add_point(info, start, stop, &iwe, buf);
 464                 kfree(buf);
 465         }
 466 exit:
 467         kfree(custom);
 468
 469         return start;
 470 }
 471
 472 static int wpa_set_auth_algs(struct net_device *dev, u32 value)
 473 {
 474         struct adapter *padapter = (struct adapter *) rtw_netdev_priv(dev);
 475         int ret = 0;
 476
 477         if ((value & AUTH_ALG_SHARED_KEY) && (value & AUTH_ALG_OPEN_SYSTEM)) {
 478                 DBG_871X("wpa_set_auth_algs, AUTH_ALG_SHARED_KEY and  AUTH_ALG_OPEN_SYSTEM [value:0x%x]\n", value);
 479                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 480                 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeAutoSwitch;
 481                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
 482         } else if (value & AUTH_ALG_SHARED_KEY) {
 483                 DBG_871X("wpa_set_auth_algs, AUTH_ALG_SHARED_KEY  [value:0x%x]\n", value);
 484                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 485
 486                 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeShared;
 487                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Shared;
 488         } else if (value & AUTH_ALG_OPEN_SYSTEM) {
 489                 DBG_871X("wpa_set_auth_algs, AUTH_ALG_OPEN_SYSTEM\n");
 490                 /* padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled; */
 491                 if (padapter->securitypriv.ndisauthtype < Ndis802_11AuthModeWPAPSK) {
 492                         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen;
 493                         padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
 494                 }
 495         } else if (value & AUTH_ALG_LEAP) {
 496                 DBG_871X("wpa_set_auth_algs, AUTH_ALG_LEAP\n");
 497         } else {
 498                 DBG_871X("wpa_set_auth_algs, error!\n");
 499                 ret = -EINVAL;
 500         }
 501
 502         return ret;
 503
 504 }
 505
 506 static int wpa_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len)
 507 {
 508         int ret = 0;
 509         u32 wep_key_idx, wep_key_len, wep_total_len;
 510         struct ndis_802_11_wep   *pwep = NULL;
 511         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 512         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 513         struct security_priv *psecuritypriv = &padapter->securitypriv;
 514
 515         param->u.crypt.err = 0;
 516         param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
 517
 518         if (param_len < (u32) ((u8 *) param->u.crypt.key - (u8 *) param) + param->u.crypt.key_len) {
 519                 ret =  -EINVAL;
 520                 goto exit;
 521         }
 522
 523         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
 524             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
 525             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
 526                 if (param->u.crypt.idx >= WEP_KEYS ||
 527                     param->u.crypt.idx >= BIP_MAX_KEYID) {
 528                         ret = -EINVAL;
 529                         goto exit;
 530                 }
 531         } else {
 532                 {
 533                         ret = -EINVAL;
 534                         goto exit;
 535                 }
 536         }
 537
 538         if (strcmp(param->u.crypt.alg, "WEP") == 0) {
 539                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("wpa_set_encryption, crypt.alg = WEP\n"));
 540                 DBG_871X("wpa_set_encryption, crypt.alg = WEP\n");
 541
 542                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 543                 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
 544                 padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_;
 545
 546                 wep_key_idx = param->u.crypt.idx;
 547                 wep_key_len = param->u.crypt.key_len;
 548
 549                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("(1)wep_key_idx =%d\n", wep_key_idx));
 550                 DBG_871X("(1)wep_key_idx =%d\n", wep_key_idx);
 551
 552                 if (wep_key_idx > WEP_KEYS)
 553                         return -EINVAL;
 554
 555                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("(2)wep_key_idx =%d\n", wep_key_idx));
 556
 557                 if (wep_key_len > 0) {
 558                         wep_key_len = wep_key_len <= 5 ? 5 : 13;
 559                         wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, KeyMaterial);
 560                         pwep =(struct ndis_802_11_wep    *) rtw_malloc(wep_total_len);
 561                         if (pwep == NULL) {
 562                                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, (" wpa_set_encryption: pwep allocate fail !!!\n"));
 563                                 goto exit;
 564                         }
 565
 566                         memset(pwep, 0, wep_total_len);
 567
 568                         pwep->KeyLength = wep_key_len;
 569                         pwep->Length = wep_total_len;
 570
 571                         if (wep_key_len == 13) {
 572                                 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
 573                                 padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_;
 574                         }
 575                 } else {
 576                         ret = -EINVAL;
 577                         goto exit;
 578                 }
 579
 580                 pwep->KeyIndex = wep_key_idx;
 581                 pwep->KeyIndex |= 0x80000000;
 582
 583                 memcpy(pwep->KeyMaterial,  param->u.crypt.key, pwep->KeyLength);
 584
 585                 if (param->u.crypt.set_tx) {
 586                         DBG_871X("wep, set_tx = 1\n");
 587
 588                         if (rtw_set_802_11_add_wep(padapter, pwep) == (u8)_FAIL)
 589                                 ret = -EOPNOTSUPP ;
 590                 } else {
 591                         DBG_871X("wep, set_tx = 0\n");
 592
 593                         /* don't update "psecuritypriv->dot11PrivacyAlgrthm" and */
 594                         /* psecuritypriv->dot11PrivacyKeyIndex =keyid", but can rtw_set_key to fw/cam */
 595
 596                         if (wep_key_idx >= WEP_KEYS) {
 597                                 ret = -EOPNOTSUPP ;
 598                                 goto exit;
 599                         }
 600
 601                         memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength);
 602                         psecuritypriv->dot11DefKeylen[wep_key_idx]=pwep->KeyLength;
 603                         rtw_set_key(padapter, psecuritypriv, wep_key_idx, 0, true);
 604                 }
 605
 606                 goto exit;
 607         }
 608
 609         if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) { /*  802_1x */
 610                 struct sta_info * psta,*pbcmc_sta;
 611                 struct sta_priv * pstapriv = &padapter->stapriv;
 612
 613                 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | WIFI_MP_STATE) == true) { /* sta mode */
 614                         psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
 615                         if (psta == NULL) {
 616                                 /* DEBUG_ERR(("Set wpa_set_encryption: Obtain Sta_info fail\n")); */
 617                         } else {
 618                                 /* Jeff: don't disable ieee8021x_blocked while clearing key */
 619                                 if (strcmp(param->u.crypt.alg, "none") != 0)
 620                                         psta->ieee8021x_blocked = false;
 621
 622                                 if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled)||
 623                                                 (padapter->securitypriv.ndisencryptstatus ==  Ndis802_11Encryption3Enabled)) {
 624                                         psta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
 625                                 }
 626
 627                                 if (param->u.crypt.set_tx == 1) { /* pairwise key */
 628                                         memcpy(psta->dot118021x_UncstKey.skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
 629
 630                                         if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */
 631                                                 /* DEBUG_ERR(("\nset key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len)); */
 632                                                 memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8);
 633                                                 memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8);
 634
 635                                                 padapter->securitypriv.busetkipkey =false;
 636                                                 /* _set_timer(&padapter->securitypriv.tkip_timer, 50); */
 637                                         }
 638
 639                                         /* DEBUG_ERR((" param->u.crypt.key_len =%d\n", param->u.crypt.key_len)); */
 640                                         DBG_871X(" ~~~~set sta key:unicastkey\n");
 641
 642                                         rtw_setstakey_cmd(padapter, psta, true, true);
 643                                 } else { /* group key */
 644                                         if (strcmp(param->u.crypt.alg, "TKIP") == 0 || strcmp(param->u.crypt.alg, "CCMP") == 0) {
 645                                                 memcpy(padapter->securitypriv.dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
 646                                                 /* only TKIP group key need to install this */
 647                                                 if (param->u.crypt.key_len > 16) {
 648                                                         memcpy(padapter->securitypriv.dot118021XGrptxmickey[param->u.crypt.idx].skey,&(param->u.crypt.key[16]), 8);
 649                                                         memcpy(padapter->securitypriv.dot118021XGrprxmickey[param->u.crypt.idx].skey,&(param->u.crypt.key[24]), 8);
 650                                                 }
 651                                                 padapter->securitypriv.binstallGrpkey = true;
 652                                                 /* DEBUG_ERR((" param->u.crypt.key_len =%d\n", param->u.crypt.key_len)); */
 653                                                 DBG_871X(" ~~~~set sta key:groupkey\n");
 654
 655                                                 padapter->securitypriv.dot118021XGrpKeyid = param->u.crypt.idx;
 656
 657                                                 rtw_set_key(padapter,&padapter->securitypriv, param->u.crypt.idx, 1, true);
 658                                         } else if (strcmp(param->u.crypt.alg, "BIP") == 0) {
 659                                                 /* printk("BIP key_len =%d , index =%d @@@@@@@@@@@@@@@@@@\n", param->u.crypt.key_len, param->u.crypt.idx); */
 660                                                 /* save the IGTK key, length 16 bytes */
 661                                                 memcpy(padapter->securitypriv.dot11wBIPKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
 662                                                 /*printk("IGTK key below:\n");
 663                                                 for (no = 0;no<16;no++)
 664                                                         printk(" %02x ", padapter->securitypriv.dot11wBIPKey[param->u.crypt.idx].skey[no]);
 665                                                 printk("\n");*/
 666                                                 padapter->securitypriv.dot11wBIPKeyid = param->u.crypt.idx;
 667                                                 padapter->securitypriv.binstallBIPkey = true;
 668                                                 DBG_871X(" ~~~~set sta key:IGKT\n");
 669                                         }
 670                                 }
 671                         }
 672
 673                         pbcmc_sta =rtw_get_bcmc_stainfo(padapter);
 674                         if (pbcmc_sta == NULL) {
 675                                 /* DEBUG_ERR(("Set OID_802_11_ADD_KEY: bcmc stainfo is null\n")); */
 676                         } else {
 677                                 /* Jeff: don't disable ieee8021x_blocked while clearing key */
 678                                 if (strcmp(param->u.crypt.alg, "none") != 0)
 679                                         pbcmc_sta->ieee8021x_blocked = false;
 680
 681                                 if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled)||
 682                                                 (padapter->securitypriv.ndisencryptstatus ==  Ndis802_11Encryption3Enabled)) {
 683                                         pbcmc_sta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
 684                                 }
 685                         }
 686                 } else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
 687                         /* adhoc mode */
 688                 }
 689         }
 690
 691 exit:
 692
 693         kfree(pwep);
 694         return ret;
 695 }
 696
 697 static int rtw_set_wpa_ie(struct adapter *padapter, char *pie, unsigned short ielen)
 698 {
 699         u8 *buf = NULL, *pos = NULL;
 700         int group_cipher = 0, pairwise_cipher = 0;
 701         int ret = 0;
 702         u8 null_addr[]= {0, 0, 0, 0, 0, 0};
 703
 704         if ((ielen > MAX_WPA_IE_LEN) || (pie == NULL)) {
 705                 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
 706                 if (pie == NULL)
 707                         return ret;
 708                 else
 709                         return -EINVAL;
 710         }
 711
 712         if (ielen) {
 713                 buf = rtw_zmalloc(ielen);
 714                 if (buf == NULL) {
 715                         ret =  -ENOMEM;
 716                         goto exit;
 717                 }
 718
 719                 memcpy(buf, pie , ielen);
 720
 721                 /* dump */
 722                 {
 723                         int i;
 724                         DBG_871X("\n wpa_ie(length:%d):\n", ielen);
 725                         for (i = 0;i<ielen;i =i+8)
 726                                 DBG_871X("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]);
 727                 }
 728
 729                 pos = buf;
 730                 if (ielen < RSN_HEADER_LEN) {
 731                         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("Ie len too short %d\n", ielen));
 732                         ret  = -1;
 733                         goto exit;
 734                 }
 735
 736                 if (rtw_parse_wpa_ie(buf, ielen, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) {
 737                         padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
 738                         padapter->securitypriv.ndisauthtype =Ndis802_11AuthModeWPAPSK;
 739                         memcpy(padapter->securitypriv.supplicant_ie, &buf[0], ielen);
 740                 }
 741
 742                 if (rtw_parse_wpa2_ie(buf, ielen, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) {
 743                         padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
 744                         padapter->securitypriv.ndisauthtype =Ndis802_11AuthModeWPA2PSK;
 745                         memcpy(padapter->securitypriv.supplicant_ie, &buf[0], ielen);
 746                 }
 747
 748                 if (group_cipher == 0)
 749                         group_cipher = WPA_CIPHER_NONE;
 750                 if (pairwise_cipher == 0)
 751                         pairwise_cipher = WPA_CIPHER_NONE;
 752
 753                 switch (group_cipher) {
 754                         case WPA_CIPHER_NONE:
 755                                 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
 756                                 padapter->securitypriv.ndisencryptstatus =Ndis802_11EncryptionDisabled;
 757                                 break;
 758                         case WPA_CIPHER_WEP40:
 759                                 padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_;
 760                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 761                                 break;
 762                         case WPA_CIPHER_TKIP:
 763                                 padapter->securitypriv.dot118021XGrpPrivacy = _TKIP_;
 764                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
 765                                 break;
 766                         case WPA_CIPHER_CCMP:
 767                                 padapter->securitypriv.dot118021XGrpPrivacy = _AES_;
 768                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
 769                                 break;
 770                         case WPA_CIPHER_WEP104:
 771                                 padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_;
 772                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 773                                 break;
 774                 }
 775
 776                 switch (pairwise_cipher) {
 777                         case WPA_CIPHER_NONE:
 778                                 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
 779                                 padapter->securitypriv.ndisencryptstatus =Ndis802_11EncryptionDisabled;
 780                                 break;
 781                         case WPA_CIPHER_WEP40:
 782                                 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
 783                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 784                                 break;
 785                         case WPA_CIPHER_TKIP:
 786                                 padapter->securitypriv.dot11PrivacyAlgrthm = _TKIP_;
 787                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
 788                                 break;
 789                         case WPA_CIPHER_CCMP:
 790                                 padapter->securitypriv.dot11PrivacyAlgrthm = _AES_;
 791                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
 792                                 break;
 793                         case WPA_CIPHER_WEP104:
 794                                 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
 795                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 796                                 break;
 797                 }
 798
 799                 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
 800                 {/* set wps_ie */
 801                         u16 cnt = 0;
 802                         u8 eid, wps_oui[4]={0x0, 0x50, 0xf2, 0x04};
 803
 804                         while (cnt < ielen) {
 805                                 eid = buf[cnt];
 806
 807                                 if ((eid == _VENDOR_SPECIFIC_IE_) && (!memcmp(&buf[cnt+2], wps_oui, 4))) {
 808                                         DBG_871X("SET WPS_IE\n");
 809
 810                                         padapter->securitypriv.wps_ie_len = ((buf[cnt+1]+2) < MAX_WPS_IE_LEN) ? (buf[cnt+1]+2):MAX_WPS_IE_LEN;
 811
 812                                         memcpy(padapter->securitypriv.wps_ie, &buf[cnt], padapter->securitypriv.wps_ie_len);
 813
 814                                         set_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS);
 815
 816                                         cnt += buf[cnt+1]+2;
 817
 818                                         break;
 819                                 } else {
 820                                         cnt += buf[cnt+1]+2; /* goto next */
 821                                 }
 822                         }
 823                 }
 824         }
 825
 826         /* TKIP and AES disallow multicast packets until installing group key */
 827         if (padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_
 828                 || padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_WTMIC_
 829                 || padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)
 830                 /* WPS open need to enable multicast */
 831                 /*  check_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS) == true) */
 832                 rtw_hal_set_hwreg(padapter, HW_VAR_OFF_RCR_AM, null_addr);
 833
 834         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
 835                  ("rtw_set_wpa_ie: pairwise_cipher = 0x%08x padapter->securitypriv.ndisencryptstatus =%d padapter->securitypriv.ndisauthtype =%d\n",
 836                   pairwise_cipher, padapter->securitypriv.ndisencryptstatus, padapter->securitypriv.ndisauthtype));
 837
 838 exit:
 839
 840         kfree(buf);
 841
 842         return ret;
 843 }
 844
 845 static int rtw_wx_get_name(struct net_device *dev,
 846                              struct iw_request_info *info,
 847                              union iwreq_data *wrqu, char *extra)
 848 {
 849         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 850         u32 ht_ielen = 0;
 851         char *p;
 852         u8 ht_cap =false, vht_cap =false;
 853         struct  mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 854         struct wlan_bssid_ex  *pcur_bss = &pmlmepriv->cur_network.network;
 855         NDIS_802_11_RATES_EX* prates = NULL;
 856
 857         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("cmd_code =%x\n", info->cmd));
 858
 859         if (check_fwstate(pmlmepriv, _FW_LINKED|WIFI_ADHOC_MASTER_STATE) == true) {
 860                 /* parsing HT_CAP_IE */
 861                 p = rtw_get_ie(&pcur_bss->IEs[12], _HT_CAPABILITY_IE_, &ht_ielen, pcur_bss->IELength-12);
 862                 if (p && ht_ielen>0)
 863                         ht_cap = true;
 864
 865                 prates = &pcur_bss->SupportedRates;
 866
 867                 if (rtw_is_cckratesonly_included((u8 *)prates) == true) {
 868                         if (ht_cap == true)
 869                                 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11bn");
 870                         else
 871                                 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11b");
 872                 } else if ((rtw_is_cckrates_included((u8 *)prates)) == true) {
 873                         if (ht_cap == true)
 874                                 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11bgn");
 875                         else
 876                                 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11bg");
 877                 } else {
 878                         if (pcur_bss->Configuration.DSConfig > 14) {
 879                                 if (vht_cap == true)
 880                                         snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11AC");
 881                                 else if (ht_cap == true)
 882                                         snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11an");
 883                                 else
 884                                         snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11a");
 885                         } else {
 886                                 if (ht_cap == true)
 887                                         snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11gn");
 888                                 else
 889                                         snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11g");
 890                         }
 891                 }
 892         } else {
 893                 /* prates = &padapter->registrypriv.dev_network.SupportedRates; */
 894                 /* snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11g"); */
 895                 snprintf(wrqu->name, IFNAMSIZ, "unassociated");
 896         }
 897         return 0;
 898 }
 899
 900 static int rtw_wx_set_freq(struct net_device *dev,
 901                              struct iw_request_info *info,
 902                              union iwreq_data *wrqu, char *extra)
 903 {
 904         RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_, ("+rtw_wx_set_freq\n"));
 905
 906         return 0;
 907 }
 908
 909 static int rtw_wx_get_freq(struct net_device *dev,
 910                              struct iw_request_info *info,
 911                              union iwreq_data *wrqu, char *extra)
 912 {
 913         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 914         struct  mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 915         struct wlan_bssid_ex  *pcur_bss = &pmlmepriv->cur_network.network;
 916
 917         if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
 918                 /* wrqu->freq.m = ieee80211_wlan_frequencies[pcur_bss->Configuration.DSConfig-1] * 100000; */
 919                 wrqu->freq.m = rtw_ch2freq(pcur_bss->Configuration.DSConfig) * 100000;
 920                 wrqu->freq.e = 1;
 921                 wrqu->freq.i = pcur_bss->Configuration.DSConfig;
 922
 923         } else {
 924                 wrqu->freq.m = rtw_ch2freq(padapter->mlmeextpriv.cur_channel) * 100000;
 925                 wrqu->freq.e = 1;
 926                 wrqu->freq.i = padapter->mlmeextpriv.cur_channel;
 927         }
 928
 929         return 0;
 930 }
 931
 932 static int rtw_wx_set_mode(struct net_device *dev, struct iw_request_info *a,
 933                              union iwreq_data *wrqu, char *b)
 934 {
 935         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
 936         enum NDIS_802_11_NETWORK_INFRASTRUCTURE networkType ;
 937         int ret = 0;
 938
 939         if (_FAIL == rtw_pwr_wakeup(padapter)) {
 940                 ret = -EPERM;
 941                 goto exit;
 942         }
 943
 944         if (padapter->hw_init_completed ==false) {
 945                 ret = -EPERM;
 946                 goto exit;
 947         }
 948
 949         switch (wrqu->mode) {
 950                 case IW_MODE_AUTO:
 951                         networkType = Ndis802_11AutoUnknown;
 952                         DBG_871X("set_mode = IW_MODE_AUTO\n");
 953                         break;
 954                 case IW_MODE_ADHOC:
 955                         networkType = Ndis802_11IBSS;
 956                         DBG_871X("set_mode = IW_MODE_ADHOC\n");
 957                         break;
 958                 case IW_MODE_MASTER:
 959                         networkType = Ndis802_11APMode;
 960                         DBG_871X("set_mode = IW_MODE_MASTER\n");
 961                         /* rtw_setopmode_cmd(padapter, networkType, true); */
 962                         break;
 963                 case IW_MODE_INFRA:
 964                         networkType = Ndis802_11Infrastructure;
 965                         DBG_871X("set_mode = IW_MODE_INFRA\n");
 966                         break;
 967
 968                 default :
 969                         ret = -EINVAL;;
 970                         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("\n Mode: %s is not supported \n", iw_operation_mode[wrqu->mode]));
 971                         goto exit;
 972         }
 973
 974 /*
 975         if (Ndis802_11APMode == networkType)
 976         {
 977                 rtw_setopmode_cmd(padapter, networkType, true);
 978         }
 979         else
 980         {
 981                 rtw_setopmode_cmd(padapter, Ndis802_11AutoUnknown, true);
 982         }
 983 */
 984
 985         if (rtw_set_802_11_infrastructure_mode(padapter, networkType) ==false) {
 986
 987                 ret = -EPERM;
 988                 goto exit;
 989
 990         }
 991
 992         rtw_setopmode_cmd(padapter, networkType, true);
 993
 994 exit:
 995         return ret;
 996 }
 997
 998 static int rtw_wx_get_mode(struct net_device *dev, struct iw_request_info *a,
 999                              union iwreq_data *wrqu, char *b)
1000 {
1001         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1002         struct  mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1003
1004         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, (" rtw_wx_get_mode\n"));
1005
1006         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
1007                 wrqu->mode = IW_MODE_INFRA;
1008         } else if  ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) ||
1009                        (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true)) {
1010                 wrqu->mode = IW_MODE_ADHOC;
1011         } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) {
1012                 wrqu->mode = IW_MODE_MASTER;
1013         } else {
1014                 wrqu->mode = IW_MODE_AUTO;
1015         }
1016         return 0;
1017 }
1018
1019
1020 static int rtw_wx_set_pmkid(struct net_device *dev,
1021                              struct iw_request_info *a,
1022                              union iwreq_data *wrqu, char *extra)
1023 {
1024         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1025         u8          j, blInserted = false;
1026         int         intReturn = false;
1027         struct security_priv *psecuritypriv = &padapter->securitypriv;
1028         struct iw_pmksa*  pPMK = (struct iw_pmksa*) extra;
1029         u8     strZeroMacAddress[ ETH_ALEN ] = { 0x00 };
1030         u8     strIssueBssid[ ETH_ALEN ] = { 0x00 };
1031
1032         /*
1033         There are the BSSID information in the bssid.sa_data array.
1034         If cmd is IW_PMKSA_FLUSH, it means the wpa_suppplicant wants to clear all the PMKID information.
1035         If cmd is IW_PMKSA_ADD, it means the wpa_supplicant wants to add a PMKID/BSSID to driver.
1036         If cmd is IW_PMKSA_REMOVE, it means the wpa_supplicant wants to remove a PMKID/BSSID from driver.
1037         */
1038
1039         memcpy(strIssueBssid, pPMK->bssid.sa_data, ETH_ALEN);
1040         if (pPMK->cmd == IW_PMKSA_ADD) {
1041                 DBG_871X("[rtw_wx_set_pmkid] IW_PMKSA_ADD!\n");
1042                 if (!memcmp(strIssueBssid, strZeroMacAddress, ETH_ALEN))
1043                     return(intReturn);
1044                 else
1045                     intReturn = true;
1046
1047                 blInserted = false;
1048
1049                 /* overwrite PMKID */
1050                 for (j = 0 ; j<NUM_PMKID_CACHE; j++) {
1051                         if (!memcmp(psecuritypriv->PMKIDList[j].Bssid, strIssueBssid, ETH_ALEN)) {
1052                                 /*  BSSID is matched, the same AP => rewrite with new PMKID. */
1053                                 DBG_871X("[rtw_wx_set_pmkid] BSSID exists in the PMKList.\n");
1054
1055                                 memcpy(psecuritypriv->PMKIDList[j].PMKID, pPMK->pmkid, IW_PMKID_LEN);
1056                                 psecuritypriv->PMKIDList[ j ].bUsed = true;
1057                                 psecuritypriv->PMKIDIndex = j+1;
1058                                 blInserted = true;
1059                                 break;
1060                         }
1061                 }
1062
1063                 if (!blInserted) {
1064                     /*  Find a new entry */
1065                     DBG_871X("[rtw_wx_set_pmkid] Use the new entry index = %d for this PMKID.\n",
1066                             psecuritypriv->PMKIDIndex);
1067
1068                     memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].Bssid, strIssueBssid, ETH_ALEN);
1069                     memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].PMKID, pPMK->pmkid, IW_PMKID_LEN);
1070
1071                     psecuritypriv->PMKIDList[ psecuritypriv->PMKIDIndex ].bUsed = true;
1072                     psecuritypriv->PMKIDIndex++ ;
1073                     if (psecuritypriv->PMKIDIndex == 16)
1074                         psecuritypriv->PMKIDIndex = 0;
1075                 }
1076         } else if (pPMK->cmd == IW_PMKSA_REMOVE) {
1077                 DBG_871X("[rtw_wx_set_pmkid] IW_PMKSA_REMOVE!\n");
1078                 intReturn = true;
1079                 for (j = 0 ; j<NUM_PMKID_CACHE; j++) {
1080                         if (!memcmp(psecuritypriv->PMKIDList[j].Bssid, strIssueBssid, ETH_ALEN)) {
1081                                 /*  BSSID is matched, the same AP => Remove this PMKID information and reset it. */
1082                                 memset(psecuritypriv->PMKIDList[ j ].Bssid, 0x00, ETH_ALEN);
1083                                 psecuritypriv->PMKIDList[ j ].bUsed = false;
1084                                 break;
1085                         }
1086                 }
1087         } else if (pPMK->cmd == IW_PMKSA_FLUSH) {
1088             DBG_871X("[rtw_wx_set_pmkid] IW_PMKSA_FLUSH!\n");
1089             memset(&psecuritypriv->PMKIDList[ 0 ], 0x00, sizeof(RT_PMKID_LIST) * NUM_PMKID_CACHE);
1090             psecuritypriv->PMKIDIndex = 0;
1091             intReturn = true;
1092         }
1093         return intReturn;
1094 }
1095
1096 static int rtw_wx_get_sens(struct net_device *dev,
1097                              struct iw_request_info *info,
1098                              union iwreq_data *wrqu, char *extra)
1099 {
1100         {
1101                 wrqu->sens.value = 0;
1102                 wrqu->sens.fixed = 0;   /* no auto select */
1103                 wrqu->sens.disabled = 1;
1104         }
1105         return 0;
1106 }
1107
1108 static int rtw_wx_get_range(struct net_device *dev,
1109                                 struct iw_request_info *info,
1110                                 union iwreq_data *wrqu, char *extra)
1111 {
1112         struct iw_range *range = (struct iw_range *)extra;
1113         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1114         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1115
1116         u16 val;
1117         int i;
1118
1119         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_range. cmd_code =%x\n", info->cmd));
1120
1121         wrqu->data.length = sizeof(*range);
1122         memset(range, 0, sizeof(*range));
1123
1124         /* Let's try to keep this struct in the same order as in
1125          * linux/include/wireless.h
1126          */
1127
1128         /* TODO: See what values we can set, and remove the ones we can't
1129          * set, or fill them with some default data.
1130          */
1131
1132         /* ~5 Mb/s real (802.11b) */
1133         range->throughput = 5 * 1000 * 1000;
1134
1135         /* signal level threshold range */
1136
1137         /* percent values between 0 and 100. */
1138         range->max_qual.qual = 100;
1139         range->max_qual.level = 100;
1140         range->max_qual.noise = 100;
1141         range->max_qual.updated = 7; /* Updated all three */
1142
1143
1144         range->avg_qual.qual = 92; /* > 8% missed beacons is 'bad' */
1145         /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
1146         range->avg_qual.level = 256 - 78;
1147         range->avg_qual.noise = 0;
1148         range->avg_qual.updated = 7; /* Updated all three */
1149
1150         range->num_bitrates = RATE_COUNT;
1151
1152         for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++)
1153                 range->bitrate[i] = rtw_rates[i];
1154
1155         range->min_frag = MIN_FRAG_THRESHOLD;
1156         range->max_frag = MAX_FRAG_THRESHOLD;
1157
1158         range->pm_capa = 0;
1159
1160         range->we_version_compiled = WIRELESS_EXT;
1161         range->we_version_source = 16;
1162
1163         for (i = 0, val = 0; i < MAX_CHANNEL_NUM; i++) {
1164
1165                 /*  Include only legal frequencies for some countries */
1166                 if (pmlmeext->channel_set[i].ChannelNum != 0) {
1167                         range->freq[val].i = pmlmeext->channel_set[i].ChannelNum;
1168                         range->freq[val].m = rtw_ch2freq(pmlmeext->channel_set[i].ChannelNum) * 100000;
1169                         range->freq[val].e = 1;
1170                         val++;
1171                 }
1172
1173                 if (val == IW_MAX_FREQUENCIES)
1174                         break;
1175         }
1176
1177         range->num_channels = val;
1178         range->num_frequency = val;
1179
1180 /*  Commented by Albert 2009/10/13 */
1181 /*  The following code will proivde the security capability to network manager. */
1182 /*  If the driver doesn't provide this capability to network manager, */
1183 /*  the WPA/WPA2 routers can't be choosen in the network manager. */
1184
1185 /*
1186 #define IW_SCAN_CAPA_NONE               0x00
1187 #define IW_SCAN_CAPA_ESSID              0x01
1188 #define IW_SCAN_CAPA_BSSID              0x02
1189 #define IW_SCAN_CAPA_CHANNEL    0x04
1190 #define IW_SCAN_CAPA_MODE               0x08
1191 #define IW_SCAN_CAPA_RATE               0x10
1192 #define IW_SCAN_CAPA_TYPE               0x20
1193 #define IW_SCAN_CAPA_TIME               0x40
1194 */
1195
1196         range->enc_capa = IW_ENC_CAPA_WPA|IW_ENC_CAPA_WPA2|
1197                           IW_ENC_CAPA_CIPHER_TKIP|IW_ENC_CAPA_CIPHER_CCMP;
1198
1199         range->scan_capa = IW_SCAN_CAPA_ESSID | IW_SCAN_CAPA_TYPE |IW_SCAN_CAPA_BSSID|
1200                                         IW_SCAN_CAPA_CHANNEL|IW_SCAN_CAPA_MODE|IW_SCAN_CAPA_RATE;
1201
1202         return 0;
1203 }
1204
1205 /* set bssid flow */
1206 /* s1. rtw_set_802_11_infrastructure_mode() */
1207 /* s2. rtw_set_802_11_authentication_mode() */
1208 /* s3. set_802_11_encryption_mode() */
1209 /* s4. rtw_set_802_11_bssid() */
1210 static int rtw_wx_set_wap(struct net_device *dev,
1211                          struct iw_request_info *info,
1212                          union iwreq_data *awrq,
1213                          char *extra)
1214 {
1215         uint ret = 0;
1216         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1217         struct sockaddr *temp = (struct sockaddr *)awrq;
1218         struct  mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1219         struct list_head        *phead;
1220         u8 *dst_bssid, *src_bssid;
1221         struct __queue  *queue  = &(pmlmepriv->scanned_queue);
1222         struct  wlan_network    *pnetwork = NULL;
1223         enum NDIS_802_11_AUTHENTICATION_MODE    authmode;
1224
1225         rtw_ps_deny(padapter, PS_DENY_JOIN);
1226         if (_FAIL == rtw_pwr_wakeup(padapter)) {
1227                 ret = -1;
1228                 goto exit;
1229         }
1230
1231         if (!padapter->bup) {
1232                 ret = -1;
1233                 goto exit;
1234         }
1235
1236
1237         if (temp->sa_family != ARPHRD_ETHER) {
1238                 ret = -EINVAL;
1239                 goto exit;
1240         }
1241
1242         authmode = padapter->securitypriv.ndisauthtype;
1243         spin_lock_bh(&queue->lock);
1244         phead = get_list_head(queue);
1245         pmlmepriv->pscanned = get_next(phead);
1246
1247         while (1) {
1248                 if (phead == pmlmepriv->pscanned)
1249                         break;
1250
1251                 pnetwork = LIST_CONTAINOR(pmlmepriv->pscanned, struct wlan_network, list);
1252
1253                 pmlmepriv->pscanned = get_next(pmlmepriv->pscanned);
1254
1255                 dst_bssid = pnetwork->network.MacAddress;
1256
1257                 src_bssid = temp->sa_data;
1258
1259                 if ((!memcmp(dst_bssid, src_bssid, ETH_ALEN))) {
1260                         if (!rtw_set_802_11_infrastructure_mode(padapter, pnetwork->network.InfrastructureMode)) {
1261                                 ret = -1;
1262                                 spin_unlock_bh(&queue->lock);
1263                                 goto exit;
1264                         }
1265                                 break;
1266                 }
1267
1268         }
1269         spin_unlock_bh(&queue->lock);
1270
1271         rtw_set_802_11_authentication_mode(padapter, authmode);
1272         /* set_802_11_encryption_mode(padapter, padapter->securitypriv.ndisencryptstatus); */
1273         if (rtw_set_802_11_bssid(padapter, temp->sa_data) == false) {
1274                 ret = -1;
1275                 goto exit;
1276         }
1277
1278 exit:
1279
1280         rtw_ps_deny_cancel(padapter, PS_DENY_JOIN);
1281
1282         return ret;
1283 }
1284
1285 static int rtw_wx_get_wap(struct net_device *dev,
1286                             struct iw_request_info *info,
1287                             union iwreq_data *wrqu, char *extra)
1288 {
1289
1290         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1291         struct  mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1292         struct wlan_bssid_ex  *pcur_bss = &pmlmepriv->cur_network.network;
1293
1294         wrqu->ap_addr.sa_family = ARPHRD_ETHER;
1295
1296         memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
1297
1298         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_wap\n"));
1299
1300         if  (((check_fwstate(pmlmepriv, _FW_LINKED)) == true) ||
1301                         ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) == true) ||
1302                         ((check_fwstate(pmlmepriv, WIFI_AP_STATE)) == true)) {
1303                 memcpy(wrqu->ap_addr.sa_data, pcur_bss->MacAddress, ETH_ALEN);
1304         } else {
1305                 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
1306         }
1307
1308         return 0;
1309 }
1310
1311 static int rtw_wx_set_mlme(struct net_device *dev,
1312                              struct iw_request_info *info,
1313                              union iwreq_data *wrqu, char *extra)
1314 {
1315         int ret = 0;
1316         u16 reason;
1317         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1318         struct iw_mlme *mlme = (struct iw_mlme *) extra;
1319
1320
1321         if (mlme == NULL)
1322                 return -1;
1323
1324         DBG_871X("%s\n", __func__);
1325
1326         reason = mlme->reason_code;
1327
1328         DBG_871X("%s, cmd =%d, reason =%d\n", __func__, mlme->cmd, reason);
1329
1330         switch (mlme->cmd) {
1331         case IW_MLME_DEAUTH:
1332                 if (!rtw_set_802_11_disassociate(padapter))
1333                         ret = -1;
1334                 break;
1335         case IW_MLME_DISASSOC:
1336                 if (!rtw_set_802_11_disassociate(padapter))
1337                         ret = -1;
1338                 break;
1339         default:
1340                 return -EOPNOTSUPP;
1341         }
1342
1343         return ret;
1344 }
1345
1346 static int rtw_wx_set_scan(struct net_device *dev, struct iw_request_info *a,
1347                              union iwreq_data *wrqu, char *extra)
1348 {
1349         u8 _status = false;
1350         int ret = 0;
1351         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1352         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1353         struct ndis_802_11_ssid ssid[RTW_SSID_SCAN_AMOUNT];
1354         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_set_scan\n"));
1355
1356         #ifdef DBG_IOCTL
1357         DBG_871X("DBG_IOCTL %s:%d\n", __func__, __LINE__);
1358         #endif
1359
1360         rtw_ps_deny(padapter, PS_DENY_SCAN);
1361         if (_FAIL == rtw_pwr_wakeup(padapter)) {
1362                 ret = -1;
1363                 goto exit;
1364         }
1365
1366         if (padapter->bDriverStopped) {
1367                 DBG_871X("bDriverStopped =%d\n", padapter->bDriverStopped);
1368                 ret = -1;
1369                 goto exit;
1370         }
1371
1372         if (!padapter->bup) {
1373                 ret = -1;
1374                 goto exit;
1375         }
1376
1377         if (padapter->hw_init_completed ==false) {
1378                 ret = -1;
1379                 goto exit;
1380         }
1381
1382         /*  When Busy Traffic, driver do not site survey. So driver return success. */
1383         /*  wpa_supplicant will not issue SIOCSIWSCAN cmd again after scan timeout. */
1384         /*  modify by thomas 2011-02-22. */
1385         if (pmlmepriv->LinkDetectInfo.bBusyTraffic == true) {
1386                 indicate_wx_scan_complete_event(padapter);
1387                 goto exit;
1388         }
1389
1390         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING) == true) {
1391                 indicate_wx_scan_complete_event(padapter);
1392                 goto exit;
1393         }
1394
1395         memset(ssid, 0, sizeof(struct ndis_802_11_ssid)*RTW_SSID_SCAN_AMOUNT);
1396
1397         if (wrqu->data.length == sizeof(struct iw_scan_req)) {
1398                 struct iw_scan_req *req = (struct iw_scan_req *)extra;
1399
1400                 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
1401                         int len = min((int)req->essid_len, IW_ESSID_MAX_SIZE);
1402
1403                         memcpy(ssid[0].Ssid, req->essid, len);
1404                         ssid[0].SsidLength = len;
1405
1406                         DBG_871X("IW_SCAN_THIS_ESSID, ssid =%s, len =%d\n", req->essid, req->essid_len);
1407
1408                         spin_lock_bh(&pmlmepriv->lock);
1409
1410                         _status = rtw_sitesurvey_cmd(padapter, ssid, 1, NULL, 0);
1411
1412                         spin_unlock_bh(&pmlmepriv->lock);
1413
1414                 } else if (req->scan_type == IW_SCAN_TYPE_PASSIVE) {
1415                         DBG_871X("rtw_wx_set_scan, req->scan_type == IW_SCAN_TYPE_PASSIVE\n");
1416                 }
1417
1418         } else if (wrqu->data.length >= WEXT_CSCAN_HEADER_SIZE
1419                 && !memcmp(extra, WEXT_CSCAN_HEADER, WEXT_CSCAN_HEADER_SIZE)) {
1420                 int len = wrqu->data.length -WEXT_CSCAN_HEADER_SIZE;
1421                 char *pos = extra+WEXT_CSCAN_HEADER_SIZE;
1422                 char section;
1423                 char sec_len;
1424                 int ssid_index = 0;
1425
1426                 /* DBG_871X("%s COMBO_SCAN header is recognized\n", __func__); */
1427
1428                 while (len >= 1) {
1429                         section = *(pos++); len-= 1;
1430
1431                         switch (section) {
1432                                 case WEXT_CSCAN_SSID_SECTION:
1433                                         /* DBG_871X("WEXT_CSCAN_SSID_SECTION\n"); */
1434                                         if (len < 1) {
1435                                                 len = 0;
1436                                                 break;
1437                                         }
1438
1439                                         sec_len = *(pos++); len-= 1;
1440
1441                                         if (sec_len>0 && sec_len<=len) {
1442                                                 ssid[ssid_index].SsidLength = sec_len;
1443                                                 memcpy(ssid[ssid_index].Ssid, pos, ssid[ssid_index].SsidLength);
1444                                                 /* DBG_871X("%s COMBO_SCAN with specific ssid:%s, %d\n", __func__ */
1445                                                 /*      , ssid[ssid_index].Ssid, ssid[ssid_index].SsidLength); */
1446                                                 ssid_index++;
1447                                         }
1448
1449                                         pos+=sec_len; len-=sec_len;
1450                                         break;
1451
1452
1453                                 case WEXT_CSCAN_CHANNEL_SECTION:
1454                                         /* DBG_871X("WEXT_CSCAN_CHANNEL_SECTION\n"); */
1455                                         pos+= 1; len-= 1;
1456                                         break;
1457                                 case WEXT_CSCAN_ACTV_DWELL_SECTION:
1458                                         /* DBG_871X("WEXT_CSCAN_ACTV_DWELL_SECTION\n"); */
1459                                         pos+=2; len-=2;
1460                                         break;
1461                                 case WEXT_CSCAN_PASV_DWELL_SECTION:
1462                                         /* DBG_871X("WEXT_CSCAN_PASV_DWELL_SECTION\n"); */
1463                                         pos+=2; len-=2;
1464                                         break;
1465                                 case WEXT_CSCAN_HOME_DWELL_SECTION:
1466                                         /* DBG_871X("WEXT_CSCAN_HOME_DWELL_SECTION\n"); */
1467                                         pos+=2; len-=2;
1468                                         break;
1469                                 case WEXT_CSCAN_TYPE_SECTION:
1470                                         /* DBG_871X("WEXT_CSCAN_TYPE_SECTION\n"); */
1471                                         pos+= 1; len-= 1;
1472                                         break;
1473                                 default:
1474                                         /* DBG_871X("Unknown CSCAN section %c\n", section); */
1475                                         len = 0; /*  stop parsing */
1476                         }
1477                         /* DBG_871X("len:%d\n", len); */
1478
1479                 }
1480
1481                 /* jeff: it has still some scan paramater to parse, we only do this now... */
1482                 _status = rtw_set_802_11_bssid_list_scan(padapter, ssid, RTW_SSID_SCAN_AMOUNT);
1483
1484         } else {
1485                 _status = rtw_set_802_11_bssid_list_scan(padapter, NULL, 0);
1486         }
1487
1488         if (_status == false)
1489                 ret = -1;
1490
1491 exit:
1492
1493         rtw_ps_deny_cancel(padapter, PS_DENY_SCAN);
1494
1495         #ifdef DBG_IOCTL
1496         DBG_871X("DBG_IOCTL %s:%d return %d\n", __func__, __LINE__, ret);
1497         #endif
1498
1499         return ret;
1500 }
1501
1502 static int rtw_wx_get_scan(struct net_device *dev, struct iw_request_info *a,
1503                              union iwreq_data *wrqu, char *extra)
1504 {
1505         struct list_head                                        *plist, *phead;
1506         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1507         struct  mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1508         struct __queue                          *queue  = &(pmlmepriv->scanned_queue);
1509         struct  wlan_network    *pnetwork = NULL;
1510         char *ev = extra;
1511         char *stop = ev + wrqu->data.length;
1512         u32 ret = 0;
1513         sint wait_status;
1514
1515         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_scan\n"));
1516         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, (" Start of Query SIOCGIWSCAN .\n"));
1517
1518         #ifdef DBG_IOCTL
1519         DBG_871X("DBG_IOCTL %s:%d\n", __func__, __LINE__);
1520         #endif
1521
1522         if (adapter_to_pwrctl(padapter)->brfoffbyhw && padapter->bDriverStopped) {
1523                 ret = -EINVAL;
1524                 goto exit;
1525         }
1526
1527         wait_status = _FW_UNDER_SURVEY | _FW_UNDER_LINKING;
1528
1529         if (check_fwstate(pmlmepriv, wait_status))
1530                 return -EAGAIN;
1531
1532         spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
1533
1534         phead = get_list_head(queue);
1535         plist = get_next(phead);
1536
1537         while (1) {
1538                 if (phead == plist)
1539                         break;
1540
1541                 if ((stop - ev) < SCAN_ITEM_SIZE) {
1542                         ret = -E2BIG;
1543                         break;
1544                 }
1545
1546                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
1547
1548                 /* report network only if the current channel set contains the channel to which this network belongs */
1549                 if (rtw_ch_set_search_ch(padapter->mlmeextpriv.channel_set, pnetwork->network.Configuration.DSConfig) >= 0
1550                         && rtw_mlme_band_check(padapter, pnetwork->network.Configuration.DSConfig) == true
1551                         && true == rtw_validate_ssid(&(pnetwork->network.Ssid))) {
1552
1553                         ev =translate_scan(padapter, a, pnetwork, ev, stop);
1554                 }
1555
1556                 plist = get_next(plist);
1557
1558         }
1559
1560         spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
1561
1562         wrqu->data.length = ev-extra;
1563         wrqu->data.flags = 0;
1564
1565 exit:
1566
1567         #ifdef DBG_IOCTL
1568         DBG_871X("DBG_IOCTL %s:%d return %d\n", __func__, __LINE__, ret);
1569         #endif
1570
1571         return ret ;
1572
1573 }
1574
1575 /* set ssid flow */
1576 /* s1. rtw_set_802_11_infrastructure_mode() */
1577 /* s2. set_802_11_authenticaion_mode() */
1578 /* s3. set_802_11_encryption_mode() */
1579 /* s4. rtw_set_802_11_ssid() */
1580 static int rtw_wx_set_essid(struct net_device *dev,
1581                               struct iw_request_info *a,
1582                               union iwreq_data *wrqu, char *extra)
1583 {
1584         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1585         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1586         struct __queue *queue = &pmlmepriv->scanned_queue;
1587         struct list_head *phead;
1588         struct wlan_network *pnetwork = NULL;
1589         enum NDIS_802_11_AUTHENTICATION_MODE authmode;
1590         struct ndis_802_11_ssid ndis_ssid;
1591         u8 *dst_ssid, *src_ssid;
1592
1593         uint ret = 0, len;
1594
1595         #ifdef DBG_IOCTL
1596         DBG_871X("DBG_IOCTL %s:%d\n", __func__, __LINE__);
1597         #endif
1598
1599         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1600                  ("+rtw_wx_set_essid: fw_state = 0x%08x\n", get_fwstate(pmlmepriv)));
1601
1602         rtw_ps_deny(padapter, PS_DENY_JOIN);
1603         if (_FAIL == rtw_pwr_wakeup(padapter)) {
1604                 ret = -1;
1605                 goto exit;
1606         }
1607
1608         if (!padapter->bup) {
1609                 ret = -1;
1610                 goto exit;
1611         }
1612
1613         if (wrqu->essid.length > IW_ESSID_MAX_SIZE) {
1614                 ret = -E2BIG;
1615                 goto exit;
1616         }
1617
1618         if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1619                 ret = -1;
1620                 goto exit;
1621         }
1622
1623         authmode = padapter->securitypriv.ndisauthtype;
1624         DBG_871X("=>%s\n", __func__);
1625         if (wrqu->essid.flags && wrqu->essid.length) {
1626                 len = (wrqu->essid.length < IW_ESSID_MAX_SIZE) ? wrqu->essid.length : IW_ESSID_MAX_SIZE;
1627
1628                 if (wrqu->essid.length != 33)
1629                         DBG_871X("ssid =%s, len =%d\n", extra, wrqu->essid.length);
1630
1631                 memset(&ndis_ssid, 0, sizeof(struct ndis_802_11_ssid));
1632                 ndis_ssid.SsidLength = len;
1633                 memcpy(ndis_ssid.Ssid, extra, len);
1634                 src_ssid = ndis_ssid.Ssid;
1635
1636                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("rtw_wx_set_essid: ssid =[%s]\n", src_ssid));
1637                 spin_lock_bh(&queue->lock);
1638                 phead = get_list_head(queue);
1639                 pmlmepriv->pscanned = get_next(phead);
1640
1641                 while (1) {
1642                         if (phead == pmlmepriv->pscanned) {
1643                                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_warning_,
1644                                          ("rtw_wx_set_essid: scan_q is empty, set ssid to check if scanning again!\n"));
1645
1646                                 break;
1647                         }
1648
1649                         pnetwork = LIST_CONTAINOR(pmlmepriv->pscanned, struct wlan_network, list);
1650
1651                         pmlmepriv->pscanned = get_next(pmlmepriv->pscanned);
1652
1653                         dst_ssid = pnetwork->network.Ssid.Ssid;
1654
1655                         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1656                                  ("rtw_wx_set_essid: dst_ssid =%s\n",
1657                                   pnetwork->network.Ssid.Ssid));
1658
1659                         if ((!memcmp(dst_ssid, src_ssid, ndis_ssid.SsidLength)) &&
1660                                 (pnetwork->network.Ssid.SsidLength ==ndis_ssid.SsidLength)) {
1661                                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1662                                          ("rtw_wx_set_essid: find match, set infra mode\n"));
1663
1664                                 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) {
1665                                         if (pnetwork->network.InfrastructureMode != pmlmepriv->cur_network.network.InfrastructureMode)
1666                                                 continue;
1667                                 }
1668
1669                                 if (rtw_set_802_11_infrastructure_mode(padapter, pnetwork->network.InfrastructureMode) == false) {
1670                                         ret = -1;
1671                                         spin_unlock_bh(&queue->lock);
1672                                         goto exit;
1673                                 }
1674
1675                                 break;
1676                         }
1677                 }
1678                 spin_unlock_bh(&queue->lock);
1679                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1680                          ("set ssid: set_802_11_auth. mode =%d\n", authmode));
1681                 rtw_set_802_11_authentication_mode(padapter, authmode);
1682                 /* set_802_11_encryption_mode(padapter, padapter->securitypriv.ndisencryptstatus); */
1683                 if (rtw_set_802_11_ssid(padapter, &ndis_ssid) == false) {
1684                         ret = -1;
1685                         goto exit;
1686                 }
1687         }
1688
1689 exit:
1690
1691         rtw_ps_deny_cancel(padapter, PS_DENY_JOIN);
1692
1693         DBG_871X("<=%s, ret %d\n", __func__, ret);
1694
1695         #ifdef DBG_IOCTL
1696         DBG_871X("DBG_IOCTL %s:%d return %d\n", __func__, __LINE__, ret);
1697         #endif
1698
1699         return ret;
1700 }
1701
1702 static int rtw_wx_get_essid(struct net_device *dev,
1703                               struct iw_request_info *a,
1704                               union iwreq_data *wrqu, char *extra)
1705 {
1706         u32 len, ret = 0;
1707         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1708         struct  mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1709         struct wlan_bssid_ex  *pcur_bss = &pmlmepriv->cur_network.network;
1710
1711         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_essid\n"));
1712
1713         if ((check_fwstate(pmlmepriv, _FW_LINKED) == true) ||
1714               (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true)) {
1715                 len = pcur_bss->Ssid.SsidLength;
1716
1717                 wrqu->essid.length = len;
1718
1719                 memcpy(extra, pcur_bss->Ssid.Ssid, len);
1720
1721                 wrqu->essid.flags = 1;
1722         } else {
1723                 ret = -1;
1724                 goto exit;
1725         }
1726
1727 exit:
1728         return ret;
1729 }
1730
1731 static int rtw_wx_set_rate(struct net_device *dev,
1732                               struct iw_request_info *a,
1733                               union iwreq_data *wrqu, char *extra)
1734 {
1735         int     i, ret = 0;
1736         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1737         u8 datarates[NumRates];
1738         u32 target_rate = wrqu->bitrate.value;
1739         u32 fixed = wrqu->bitrate.fixed;
1740         u32 ratevalue = 0;
1741         u8 mpdatarate[NumRates]={11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0xff};
1742
1743         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, (" rtw_wx_set_rate\n"));
1744         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("target_rate = %d, fixed = %d\n", target_rate, fixed));
1745
1746         if (target_rate == -1) {
1747                 ratevalue = 11;
1748                 goto set_rate;
1749         }
1750         target_rate = target_rate/100000;
1751
1752         switch (target_rate) {
1753                 case 10:
1754                         ratevalue = 0;
1755                         break;
1756                 case 20:
1757                         ratevalue = 1;
1758                         break;
1759                 case 55:
1760                         ratevalue = 2;
1761                         break;
1762                 case 60:
1763                         ratevalue = 3;
1764                         break;
1765                 case 90:
1766                         ratevalue = 4;
1767                         break;
1768                 case 110:
1769                         ratevalue = 5;
1770                         break;
1771                 case 120:
1772                         ratevalue = 6;
1773                         break;
1774                 case 180:
1775                         ratevalue = 7;
1776                         break;
1777                 case 240:
1778                         ratevalue = 8;
1779                         break;
1780                 case 360:
1781                         ratevalue = 9;
1782                         break;
1783                 case 480:
1784                         ratevalue = 10;
1785                         break;
1786                 case 540:
1787                         ratevalue = 11;
1788                         break;
1789                 default:
1790                         ratevalue = 11;
1791                         break;
1792         }
1793
1794 set_rate:
1795
1796         for (i = 0; i<NumRates; i++) {
1797                 if (ratevalue ==mpdatarate[i]) {
1798                         datarates[i] = mpdatarate[i];
1799                         if (fixed == 0)
1800                                 break;
1801                 } else {
1802                         datarates[i] = 0xff;
1803                 }
1804
1805                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("datarate_inx =%d\n", datarates[i]));
1806         }
1807
1808         if (rtw_setdatarate_cmd(padapter, datarates) != _SUCCESS) {
1809                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("rtw_wx_set_rate Fail!!!\n"));
1810                 ret = -1;
1811         }
1812         return ret;
1813 }
1814
1815 static int rtw_wx_get_rate(struct net_device *dev,
1816                              struct iw_request_info *info,
1817                              union iwreq_data *wrqu, char *extra)
1818 {
1819         u16 max_rate = 0;
1820
1821         max_rate = rtw_get_cur_max_rate((struct adapter *)rtw_netdev_priv(dev));
1822
1823         if (max_rate == 0)
1824                 return -EPERM;
1825
1826         wrqu->bitrate.fixed = 0;        /* no auto select */
1827         wrqu->bitrate.value = max_rate * 100000;
1828
1829         return 0;
1830 }
1831
1832 static int rtw_wx_set_rts(struct net_device *dev,
1833                              struct iw_request_info *info,
1834                              union iwreq_data *wrqu, char *extra)
1835 {
1836         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1837
1838         if (wrqu->rts.disabled)
1839                 padapter->registrypriv.rts_thresh = 2347;
1840         else {
1841                 if (wrqu->rts.value < 0 ||
1842                     wrqu->rts.value > 2347)
1843                         return -EINVAL;
1844
1845                 padapter->registrypriv.rts_thresh = wrqu->rts.value;
1846         }
1847
1848         DBG_871X("%s, rts_thresh =%d\n", __func__, padapter->registrypriv.rts_thresh);
1849
1850         return 0;
1851 }
1852
1853 static int rtw_wx_get_rts(struct net_device *dev,
1854                              struct iw_request_info *info,
1855                              union iwreq_data *wrqu, char *extra)
1856 {
1857         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1858
1859         DBG_871X("%s, rts_thresh =%d\n", __func__, padapter->registrypriv.rts_thresh);
1860
1861         wrqu->rts.value = padapter->registrypriv.rts_thresh;
1862         wrqu->rts.fixed = 0;    /* no auto select */
1863         /* wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD); */
1864
1865         return 0;
1866 }
1867
1868 static int rtw_wx_set_frag(struct net_device *dev,
1869                              struct iw_request_info *info,
1870                              union iwreq_data *wrqu, char *extra)
1871 {
1872         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1873
1874         if (wrqu->frag.disabled)
1875                 padapter->xmitpriv.frag_len = MAX_FRAG_THRESHOLD;
1876         else {
1877                 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
1878                     wrqu->frag.value > MAX_FRAG_THRESHOLD)
1879                         return -EINVAL;
1880
1881                 padapter->xmitpriv.frag_len = wrqu->frag.value & ~0x1;
1882         }
1883
1884         DBG_871X("%s, frag_len =%d\n", __func__, padapter->xmitpriv.frag_len);
1885
1886         return 0;
1887
1888 }
1889
1890 static int rtw_wx_get_frag(struct net_device *dev,
1891                              struct iw_request_info *info,
1892                              union iwreq_data *wrqu, char *extra)
1893 {
1894         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1895
1896         DBG_871X("%s, frag_len =%d\n", __func__, padapter->xmitpriv.frag_len);
1897
1898         wrqu->frag.value = padapter->xmitpriv.frag_len;
1899         wrqu->frag.fixed = 0;   /* no auto select */
1900         /* wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FRAG_THRESHOLD); */
1901
1902         return 0;
1903 }
1904
1905 static int rtw_wx_get_retry(struct net_device *dev,
1906                              struct iw_request_info *info,
1907                              union iwreq_data *wrqu, char *extra)
1908 {
1909         /* struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); */
1910
1911
1912         wrqu->retry.value = 7;
1913         wrqu->retry.fixed = 0;  /* no auto select */
1914         wrqu->retry.disabled = 1;
1915
1916         return 0;
1917
1918 }
1919
1920 static int rtw_wx_set_enc(struct net_device *dev,
1921                             struct iw_request_info *info,
1922                             union iwreq_data *wrqu, char *keybuf)
1923 {
1924         u32 key, ret = 0;
1925         u32 keyindex_provided;
1926         struct ndis_802_11_wep   wep;
1927         enum NDIS_802_11_AUTHENTICATION_MODE authmode;
1928
1929         struct iw_point *erq = &(wrqu->encoding);
1930         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1931         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1932         DBG_871X("+rtw_wx_set_enc, flags = 0x%x\n", erq->flags);
1933
1934         memset(&wep, 0, sizeof(struct ndis_802_11_wep));
1935
1936         key = erq->flags & IW_ENCODE_INDEX;
1937
1938         if (erq->flags & IW_ENCODE_DISABLED) {
1939                 DBG_871X("EncryptionDisabled\n");
1940                 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
1941                 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1942                 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
1943                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
1944                 authmode = Ndis802_11AuthModeOpen;
1945                 padapter->securitypriv.ndisauthtype =authmode;
1946
1947                 goto exit;
1948         }
1949
1950         if (key) {
1951                 if (key > WEP_KEYS)
1952                         return -EINVAL;
1953                 key--;
1954                 keyindex_provided = 1;
1955         } else {
1956                 keyindex_provided = 0;
1957                 key = padapter->securitypriv.dot11PrivacyKeyIndex;
1958                 DBG_871X("rtw_wx_set_enc, key =%d\n", key);
1959         }
1960
1961         /* set authentication mode */
1962         if (erq->flags & IW_ENCODE_OPEN) {
1963                 DBG_871X("rtw_wx_set_enc():IW_ENCODE_OPEN\n");
1964                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;/* Ndis802_11EncryptionDisabled; */
1965
1966                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
1967
1968                 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1969                 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
1970                 authmode = Ndis802_11AuthModeOpen;
1971                 padapter->securitypriv.ndisauthtype =authmode;
1972         } else if (erq->flags & IW_ENCODE_RESTRICTED) {
1973                 DBG_871X("rtw_wx_set_enc():IW_ENCODE_RESTRICTED\n");
1974                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
1975
1976                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Shared;
1977
1978                 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
1979                 padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_;
1980                 authmode = Ndis802_11AuthModeShared;
1981                 padapter->securitypriv.ndisauthtype =authmode;
1982         } else {
1983                 DBG_871X("rtw_wx_set_enc():erq->flags = 0x%x\n", erq->flags);
1984
1985                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;/* Ndis802_11EncryptionDisabled; */
1986                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
1987                 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1988                 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
1989                 authmode = Ndis802_11AuthModeOpen;
1990                 padapter->securitypriv.ndisauthtype =authmode;
1991         }
1992
1993         wep.KeyIndex = key;
1994         if (erq->length > 0) {
1995                 wep.KeyLength = erq->length <= 5 ? 5 : 13;
1996
1997                 wep.Length = wep.KeyLength + FIELD_OFFSET(struct ndis_802_11_wep, KeyMaterial);
1998         } else {
1999                 wep.KeyLength = 0 ;
2000
2001                 if (keyindex_provided == 1) { /*  set key_id only, no given KeyMaterial(erq->length == 0). */
2002                         padapter->securitypriv.dot11PrivacyKeyIndex = key;
2003
2004                         DBG_871X("(keyindex_provided == 1), keyid =%d, key_len =%d\n", key, padapter->securitypriv.dot11DefKeylen[key]);
2005
2006                         switch (padapter->securitypriv.dot11DefKeylen[key]) {
2007                                 case 5:
2008                                         padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
2009                                         break;
2010                                 case 13:
2011                                         padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
2012                                         break;
2013                                 default:
2014                                         padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
2015                                         break;
2016                         }
2017
2018                         goto exit;
2019
2020                 }
2021
2022         }
2023
2024         wep.KeyIndex |= 0x80000000;
2025
2026         memcpy(wep.KeyMaterial, keybuf, wep.KeyLength);
2027
2028         if (rtw_set_802_11_add_wep(padapter, &wep) == false) {
2029                 if (rf_on == pwrpriv->rf_pwrstate)
2030                         ret = -EOPNOTSUPP;
2031                 goto exit;
2032         }
2033
2034 exit:
2035         return ret;
2036 }
2037
2038 static int rtw_wx_get_enc(struct net_device *dev,
2039                             struct iw_request_info *info,
2040                             union iwreq_data *wrqu, char *keybuf)
2041 {
2042         uint key, ret = 0;
2043         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2044         struct iw_point *erq = &(wrqu->encoding);
2045         struct  mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2046
2047         if (check_fwstate(pmlmepriv, _FW_LINKED) != true) {
2048                  if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) != true) {
2049                          erq->length = 0;
2050                          erq->flags |= IW_ENCODE_DISABLED;
2051                          return 0;
2052                  }
2053         }
2054
2055
2056         key = erq->flags & IW_ENCODE_INDEX;
2057
2058         if (key) {
2059                 if (key > WEP_KEYS)
2060                         return -EINVAL;
2061                 key--;
2062         } else {
2063                 key = padapter->securitypriv.dot11PrivacyKeyIndex;
2064         }
2065
2066         erq->flags = key + 1;
2067
2068         /* if (padapter->securitypriv.ndisauthtype == Ndis802_11AuthModeOpen) */
2069         /*  */
2070         /*       erq->flags |= IW_ENCODE_OPEN; */
2071         /*  */
2072
2073         switch (padapter->securitypriv.ndisencryptstatus) {
2074         case Ndis802_11EncryptionNotSupported:
2075         case Ndis802_11EncryptionDisabled:
2076                 erq->length = 0;
2077                 erq->flags |= IW_ENCODE_DISABLED;
2078                 break;
2079         case Ndis802_11Encryption1Enabled:
2080                 erq->length = padapter->securitypriv.dot11DefKeylen[key];
2081
2082                 if (erq->length) {
2083                         memcpy(keybuf, padapter->securitypriv.dot11DefKey[key].skey, padapter->securitypriv.dot11DefKeylen[key]);
2084
2085                         erq->flags |= IW_ENCODE_ENABLED;
2086
2087                         if (padapter->securitypriv.ndisauthtype == Ndis802_11AuthModeOpen)
2088                                 erq->flags |= IW_ENCODE_OPEN;
2089                         else if (padapter->securitypriv.ndisauthtype == Ndis802_11AuthModeShared)
2090                                 erq->flags |= IW_ENCODE_RESTRICTED;
2091                 } else {
2092                         erq->length = 0;
2093                         erq->flags |= IW_ENCODE_DISABLED;
2094                 }
2095                 break;
2096         case Ndis802_11Encryption2Enabled:
2097         case Ndis802_11Encryption3Enabled:
2098                 erq->length = 16;
2099                 erq->flags |= (IW_ENCODE_ENABLED | IW_ENCODE_OPEN | IW_ENCODE_NOKEY);
2100                 break;
2101         default:
2102                 erq->length = 0;
2103                 erq->flags |= IW_ENCODE_DISABLED;
2104                 break;
2105         }
2106         return ret;
2107 }
2108
2109 static int rtw_wx_get_power(struct net_device *dev,
2110                              struct iw_request_info *info,
2111                              union iwreq_data *wrqu, char *extra)
2112 {
2113         /* struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); */
2114
2115         wrqu->power.value = 0;
2116         wrqu->power.fixed = 0;  /* no auto select */
2117         wrqu->power.disabled = 1;
2118
2119         return 0;
2120 }
2121
2122 static int rtw_wx_set_gen_ie(struct net_device *dev,
2123                              struct iw_request_info *info,
2124                              union iwreq_data *wrqu, char *extra)
2125 {
2126         int ret;
2127         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2128
2129         ret = rtw_set_wpa_ie(padapter, extra, wrqu->data.length);
2130
2131         return ret;
2132 }
2133
2134 static int rtw_wx_set_auth(struct net_device *dev,
2135                              struct iw_request_info *info,
2136                              union iwreq_data *wrqu, char *extra)
2137 {
2138         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2139         struct iw_param *param = (struct iw_param*)&(wrqu->param);
2140         int ret = 0;
2141
2142         switch (param->flags & IW_AUTH_INDEX) {
2143
2144         case IW_AUTH_WPA_VERSION:
2145                 break;
2146         case IW_AUTH_CIPHER_PAIRWISE:
2147
2148                 break;
2149         case IW_AUTH_CIPHER_GROUP:
2150
2151                 break;
2152         case IW_AUTH_KEY_MGMT:
2153                 /*
2154                  *  ??? does not use these parameters
2155                  */
2156                 break;
2157
2158         case IW_AUTH_TKIP_COUNTERMEASURES:
2159         {
2160                 if (param->value) {
2161                         /*  wpa_supplicant is enabling the tkip countermeasure. */
2162                         padapter->securitypriv.btkip_countermeasure = true;
2163                 } else {
2164                         /*  wpa_supplicant is disabling the tkip countermeasure. */
2165                         padapter->securitypriv.btkip_countermeasure = false;
2166                 }
2167                 break;
2168         }
2169         case IW_AUTH_DROP_UNENCRYPTED:
2170                 {
2171                         /* HACK:
2172                          *
2173                          * wpa_supplicant calls set_wpa_enabled when the driver
2174                          * is loaded and unloaded, regardless of if WPA is being
2175                          * used.  No other calls are made which can be used to
2176                          * determine if encryption will be used or not prior to
2177                          * association being expected.  If encryption is not being
2178                          * used, drop_unencrypted is set to false, else true -- we
2179                          * can use this to determine if the CAP_PRIVACY_ON bit should
2180                          * be set.
2181                          */
2182
2183                         if (padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption1Enabled) {
2184                                 break;/* it means init value, or using wep, ndisencryptstatus = Ndis802_11Encryption1Enabled, */
2185                                                 /*  then it needn't reset it; */
2186                         }
2187
2188                         if (param->value) {
2189                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
2190                                 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
2191                                 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
2192                                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
2193                                 padapter->securitypriv.ndisauthtype =Ndis802_11AuthModeOpen;
2194                         }
2195
2196                         break;
2197                 }
2198
2199         case IW_AUTH_80211_AUTH_ALG:
2200
2201                 /*
2202                  *  It's the starting point of a link layer connection using wpa_supplicant
2203                 */
2204                 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED)) {
2205                         LeaveAllPowerSaveMode(padapter);
2206                         rtw_disassoc_cmd(padapter, 500, false);
2207                         DBG_871X("%s...call rtw_indicate_disconnect\n ", __func__);
2208                         rtw_indicate_disconnect(padapter);
2209                         rtw_free_assoc_resources(padapter, 1);
2210                 }
2211
2212
2213                 ret = wpa_set_auth_algs(dev, (u32)param->value);
2214
2215                 break;
2216
2217         case IW_AUTH_WPA_ENABLED:
2218                 break;
2219         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
2220                 break;
2221         case IW_AUTH_PRIVACY_INVOKED:
2222                 break;
2223         default:
2224                 return -EOPNOTSUPP;
2225         }
2226         return ret;
2227 }
2228
2229 static int rtw_wx_set_enc_ext(struct net_device *dev,
2230                              struct iw_request_info *info,
2231                              union iwreq_data *wrqu, char *extra)
2232 {
2233         char *alg_name;
2234         u32 param_len;
2235         struct ieee_param *param = NULL;
2236         struct iw_point *pencoding = &wrqu->encoding;
2237         struct iw_encode_ext *pext = (struct iw_encode_ext *)extra;
2238         int ret = 0;
2239
2240         param_len = sizeof(struct ieee_param) + pext->key_len;
2241         param = (struct ieee_param *)rtw_malloc(param_len);
2242         if (param == NULL)
2243                 return -1;
2244
2245         memset(param, 0, param_len);
2246
2247         param->cmd = IEEE_CMD_SET_ENCRYPTION;
2248         memset(param->sta_addr, 0xff, ETH_ALEN);
2249
2250
2251         switch (pext->alg) {
2252         case IW_ENCODE_ALG_NONE:
2253                 /* todo: remove key */
2254                 /* remove = 1; */
2255                 alg_name = "none";
2256                 break;
2257         case IW_ENCODE_ALG_WEP:
2258                 alg_name = "WEP";
2259                 break;
2260         case IW_ENCODE_ALG_TKIP:
2261                 alg_name = "TKIP";
2262                 break;
2263         case IW_ENCODE_ALG_CCMP:
2264                 alg_name = "CCMP";
2265                 break;
2266         case IW_ENCODE_ALG_AES_CMAC:
2267                 alg_name = "BIP";
2268                 break;
2269         default:
2270                 ret = -1;
2271                 goto exit;
2272         }
2273
2274         strncpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN);
2275
2276         if (pext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
2277                 param->u.crypt.set_tx = 1;
2278
2279         /* cliW: WEP does not have group key
2280          * just not checking GROUP key setting
2281          */
2282         if ((pext->alg != IW_ENCODE_ALG_WEP) &&
2283                 ((pext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
2284                 || (pext->ext_flags & IW_ENCODE_ALG_AES_CMAC))) {
2285                 param->u.crypt.set_tx = 0;
2286         }
2287
2288         param->u.crypt.idx = (pencoding->flags&0x00FF) -1 ;
2289
2290         if (pext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID)
2291                 memcpy(param->u.crypt.seq, pext->rx_seq, 8);
2292
2293         if (pext->key_len) {
2294                 param->u.crypt.key_len = pext->key_len;
2295                 /* memcpy(param + 1, pext + 1, pext->key_len); */
2296                 memcpy(param->u.crypt.key, pext + 1, pext->key_len);
2297         }
2298
2299         if (pencoding->flags & IW_ENCODE_DISABLED) {
2300                 /* todo: remove key */
2301                 /* remove = 1; */
2302         }
2303
2304         ret =  wpa_set_encryption(dev, param, param_len);
2305
2306 exit:
2307         kfree(param);
2308
2309         return ret;
2310 }
2311
2312
2313 static int rtw_wx_get_nick(struct net_device *dev,
2314                              struct iw_request_info *info,
2315                              union iwreq_data *wrqu, char *extra)
2316 {
2317         /* struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); */
2318          /* struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); */
2319          /* struct security_priv *psecuritypriv = &padapter->securitypriv; */
2320
2321         if (extra) {
2322                 wrqu->data.length = 14;
2323                 wrqu->data.flags = 1;
2324                 memcpy(extra, "<WIFI@REALTEK>", 14);
2325         }
2326         return 0;
2327 }
2328
2329 static int rtw_wx_read32(struct net_device *dev,
2330                             struct iw_request_info *info,
2331                             union iwreq_data *wrqu, char *extra)
2332 {
2333         struct adapter *padapter;
2334         struct iw_point *p;
2335         u16 len;
2336         u32 addr;
2337         u32 data32;
2338         u32 bytes;
2339         u8 *ptmp;
2340         int ret;
2341
2342
2343         ret = 0;
2344         padapter = (struct adapter *)rtw_netdev_priv(dev);
2345         p = &wrqu->data;
2346         len = p->length;
2347         if (0 == len)
2348                 return -EINVAL;
2349
2350         ptmp = (u8 *)rtw_malloc(len);
2351         if (NULL == ptmp)
2352                 return -ENOMEM;
2353
2354         if (copy_from_user(ptmp, p->pointer, len)) {
2355                 ret = -EFAULT;
2356                 goto exit;
2357         }
2358
2359         bytes = 0;
2360         addr = 0;
2361         sscanf(ptmp, "%d,%x", &bytes, &addr);
2362
2363         switch (bytes) {
2364                 case 1:
2365                         data32 = rtw_read8(padapter, addr);
2366                         sprintf(extra, "0x%02X", data32);
2367                         break;
2368                 case 2:
2369                         data32 = rtw_read16(padapter, addr);
2370                         sprintf(extra, "0x%04X", data32);
2371                         break;
2372                 case 4:
2373                         data32 = rtw_read32(padapter, addr);
2374                         sprintf(extra, "0x%08X", data32);
2375                         break;
2376                 default:
2377                         DBG_871X(KERN_INFO "%s: usage> read [bytes],[address(hex)]\n", __func__);
2378                         ret = -EINVAL;
2379                         goto exit;
2380         }
2381         DBG_871X(KERN_INFO "%s: addr = 0x%08X data =%s\n", __func__, addr, extra);
2382
2383 exit:
2384         kfree(ptmp);
2385
2386         return ret;
2387 }
2388
2389 static int rtw_wx_write32(struct net_device *dev,
2390                             struct iw_request_info *info,
2391                             union iwreq_data *wrqu, char *extra)
2392 {
2393         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2394
2395         u32 addr;
2396         u32 data32;
2397         u32 bytes;
2398
2399
2400         bytes = 0;
2401         addr = 0;
2402         data32 = 0;
2403         sscanf(extra, "%d,%x,%x", &bytes, &addr, &data32);
2404
2405         switch (bytes) {
2406                 case 1:
2407                         rtw_write8(padapter, addr, (u8)data32);
2408                         DBG_871X(KERN_INFO "%s: addr = 0x%08X data = 0x%02X\n", __func__, addr, (u8)data32);
2409                         break;
2410                 case 2:
2411                         rtw_write16(padapter, addr, (u16)data32);
2412                         DBG_871X(KERN_INFO "%s: addr = 0x%08X data = 0x%04X\n", __func__, addr, (u16)data32);
2413                         break;
2414                 case 4:
2415                         rtw_write32(padapter, addr, data32);
2416                         DBG_871X(KERN_INFO "%s: addr = 0x%08X data = 0x%08X\n", __func__, addr, data32);
2417                         break;
2418                 default:
2419                         DBG_871X(KERN_INFO "%s: usage> write [bytes],[address(hex)],[data(hex)]\n", __func__);
2420                         return -EINVAL;
2421         }
2422
2423         return 0;
2424 }
2425
2426 static int rtw_wx_read_rf(struct net_device *dev,
2427                             struct iw_request_info *info,
2428                             union iwreq_data *wrqu, char *extra)
2429 {
2430         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2431         u32 path, addr, data32;
2432
2433
2434         path = *(u32*)extra;
2435         addr = *((u32*)extra + 1);
2436         data32 = rtw_hal_read_rfreg(padapter, path, addr, 0xFFFFF);
2437         /*
2438          * IMPORTANT!!
2439          * Only when wireless private ioctl is at odd order,
2440          * "extra" would be copied to user space.
2441          */
2442         sprintf(extra, "0x%05x", data32);
2443
2444         return 0;
2445 }
2446
2447 static int rtw_wx_write_rf(struct net_device *dev,
2448                             struct iw_request_info *info,
2449                             union iwreq_data *wrqu, char *extra)
2450 {
2451         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2452         u32 path, addr, data32;
2453
2454
2455         path = *(u32*)extra;
2456         addr = *((u32*)extra + 1);
2457         data32 = *((u32*)extra + 2);
2458 /*      DBG_871X("%s: path =%d addr = 0x%02x data = 0x%05x\n", __func__, path, addr, data32); */
2459         rtw_hal_write_rfreg(padapter, path, addr, 0xFFFFF, data32);
2460
2461         return 0;
2462 }
2463
2464 static int rtw_wx_priv_null(struct net_device *dev, struct iw_request_info *a,
2465                  union iwreq_data *wrqu, char *b)
2466 {
2467         return -1;
2468 }
2469
2470 static int dummy(struct net_device *dev, struct iw_request_info *a,
2471                  union iwreq_data *wrqu, char *b)
2472 {
2473         /* struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); */
2474         /* struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); */
2475
2476         /* DBG_871X("cmd_code =%x, fwstate = 0x%x\n", a->cmd, get_fwstate(pmlmepriv)); */
2477
2478         return -1;
2479
2480 }
2481
2482 static int rtw_wx_set_channel_plan(struct net_device *dev,
2483                                struct iw_request_info *info,
2484                                union iwreq_data *wrqu, char *extra)
2485 {
2486         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2487         u8 channel_plan_req = (u8) (*((int *)wrqu));
2488
2489         if (_SUCCESS == rtw_set_chplan_cmd(padapter, channel_plan_req, 1, 1))
2490                 DBG_871X("%s set channel_plan = 0x%02X\n", __func__, channel_plan_req);
2491          else
2492                 return -EPERM;
2493
2494         return 0;
2495 }
2496
2497 static int rtw_wx_set_mtk_wps_probe_ie(struct net_device *dev,
2498                 struct iw_request_info *a,
2499                 union iwreq_data *wrqu, char *b)
2500 {
2501         return 0;
2502 }
2503
2504 static int rtw_wx_get_sensitivity(struct net_device *dev,
2505                                 struct iw_request_info *info,
2506                                 union iwreq_data *wrqu, char *buf)
2507 {
2508         return 0;
2509 }
2510
2511 static int rtw_wx_set_mtk_wps_ie(struct net_device *dev,
2512                                 struct iw_request_info *info,
2513                                 union iwreq_data *wrqu, char *extra)
2514 {
2515         return 0;
2516 }
2517
2518 /*
2519 typedef int (*iw_handler)(struct net_device *dev, struct iw_request_info *info,
2520                           union iwreq_data *wrqu, char *extra);
2521 */
2522 /*
2523  *For all data larger than 16 octets, we need to use a
2524  *pointer to memory allocated in user space.
2525  */
2526 static  int rtw_drvext_hdl(struct net_device *dev, struct iw_request_info *info,
2527                                                 union iwreq_data *wrqu, char *extra)
2528 {
2529         return 0;
2530 }
2531
2532 static int rtw_mp_ioctl_hdl(struct net_device *dev, struct iw_request_info *info,
2533                                                 union iwreq_data *wrqu, char *extra)
2534 {
2535         int ret = 0;
2536         return ret;
2537 }
2538
2539 static int rtw_get_ap_info(struct net_device *dev,
2540                                struct iw_request_info *info,
2541                                union iwreq_data *wrqu, char *extra)
2542 {
2543         int ret = 0;
2544         u32 cnt = 0, wpa_ielen;
2545         struct list_head        *plist, *phead;
2546         unsigned char *pbuf;
2547         u8 bssid[ETH_ALEN];
2548         char data[32];
2549         struct wlan_network *pnetwork = NULL;
2550         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2551         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2552         struct __queue *queue = &(pmlmepriv->scanned_queue);
2553         struct iw_point *pdata = &wrqu->data;
2554
2555         DBG_871X("+rtw_get_aplist_info\n");
2556
2557         if ((padapter->bDriverStopped) || (pdata == NULL)) {
2558                 ret = -EINVAL;
2559                 goto exit;
2560         }
2561
2562         while ((check_fwstate(pmlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING))) == true) {
2563                 msleep(30);
2564                 cnt++;
2565                 if (cnt > 100)
2566                         break;
2567         }
2568
2569
2570         /* pdata->length = 0;? */
2571         pdata->flags = 0;
2572         if (pdata->length>=32) {
2573                 if (copy_from_user(data, pdata->pointer, 32)) {
2574                         ret = -EINVAL;
2575                         goto exit;
2576                 }
2577         } else {
2578                 ret = -EINVAL;
2579                 goto exit;
2580         }
2581
2582         spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
2583
2584         phead = get_list_head(queue);
2585         plist = get_next(phead);
2586
2587         while (1) {
2588                 if (phead == plist)
2589                         break;
2590
2591
2592                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
2593
2594                 /* if (hwaddr_aton_i(pdata->pointer, bssid)) */
2595                 if (hwaddr_aton_i(data, bssid)) {
2596                         DBG_871X("Invalid BSSID '%s'.\n", (u8 *)data);
2597                         spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
2598                         return -EINVAL;
2599                 }
2600
2601
2602                 if (!memcmp(bssid, pnetwork->network.MacAddress, ETH_ALEN)) { /* BSSID match, then check if supporting wpa/wpa2 */
2603                         DBG_871X("BSSID:" MAC_FMT "\n", MAC_ARG(bssid));
2604
2605                         pbuf = rtw_get_wpa_ie(&pnetwork->network.IEs[12], &wpa_ielen, pnetwork->network.IELength-12);
2606                         if (pbuf && (wpa_ielen>0)) {
2607                                 pdata->flags = 1;
2608                                 break;
2609                         }
2610
2611                         pbuf = rtw_get_wpa2_ie(&pnetwork->network.IEs[12], &wpa_ielen, pnetwork->network.IELength-12);
2612                         if (pbuf && (wpa_ielen>0)) {
2613                                 pdata->flags = 2;
2614                                 break;
2615                         }
2616                 }
2617
2618                 plist = get_next(plist);
2619
2620         }
2621
2622         spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
2623
2624         if (pdata->length>=34) {
2625                 if (copy_to_user((u8 __force __user *)pdata->pointer+32, (u8 *)&pdata->flags, 1)) {
2626                         ret = -EINVAL;
2627                         goto exit;
2628                 }
2629         }
2630
2631 exit:
2632
2633         return ret;
2634
2635 }
2636
2637 static int rtw_set_pid(struct net_device *dev,
2638                                struct iw_request_info *info,
2639                                union iwreq_data *wrqu, char *extra)
2640 {
2641
2642         int ret = 0;
2643         struct adapter *padapter = rtw_netdev_priv(dev);
2644         int *pdata = (int *)wrqu;
2645         int selector;
2646
2647         if ((padapter->bDriverStopped) || (pdata == NULL)) {
2648                 ret = -EINVAL;
2649                 goto exit;
2650         }
2651
2652         selector = *pdata;
2653         if (selector < 3 && selector >= 0) {
2654                 padapter->pid[selector] = *(pdata+1);
2655                 DBG_871X("%s set pid[%d]=%d\n", __func__, selector , padapter->pid[selector]);
2656         }
2657         else
2658                 DBG_871X("%s selector %d error\n", __func__, selector);
2659
2660 exit:
2661
2662         return ret;
2663
2664 }
2665
2666 static int rtw_wps_start(struct net_device *dev,
2667                                struct iw_request_info *info,
2668                                union iwreq_data *wrqu, char *extra)
2669 {
2670
2671         int ret = 0;
2672         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2673         struct iw_point *pdata = &wrqu->data;
2674         u32   u32wps_start = 0;
2675         unsigned int uintRet = 0;
2676
2677         if ((true == padapter->bDriverStopped) ||(true ==padapter->bSurpriseRemoved) || (NULL == pdata)) {
2678                 ret = -EINVAL;
2679                 goto exit;
2680         }
2681
2682         uintRet = copy_from_user((void*) &u32wps_start, pdata->pointer, 4);
2683         if (u32wps_start == 0)
2684                 u32wps_start = *extra;
2685
2686         DBG_871X("[%s] wps_start = %d\n", __func__, u32wps_start);
2687
2688 #ifdef CONFIG_INTEL_WIDI
2689         process_intel_widi_wps_status(padapter, u32wps_start);
2690 #endif /* CONFIG_INTEL_WIDI */
2691
2692 exit:
2693
2694         return ret;
2695
2696 }
2697
2698 static int rtw_p2p_set(struct net_device *dev,
2699                                struct iw_request_info *info,
2700                                union iwreq_data *wrqu, char *extra)
2701 {
2702
2703         int ret = 0;
2704
2705         return ret;
2706
2707 }
2708
2709 static int rtw_p2p_get(struct net_device *dev,
2710                                struct iw_request_info *info,
2711                                union iwreq_data *wrqu, char *extra)
2712 {
2713
2714         int ret = 0;
2715
2716         return ret;
2717
2718 }
2719
2720 static int rtw_p2p_get2(struct net_device *dev,
2721                                                 struct iw_request_info *info,
2722                                                 union iwreq_data *wrqu, char *extra)
2723 {
2724
2725         int ret = 0;
2726
2727         return ret;
2728
2729 }
2730
2731 static int rtw_rereg_nd_name(struct net_device *dev,
2732                                struct iw_request_info *info,
2733                                union iwreq_data *wrqu, char *extra)
2734 {
2735         int ret = 0;
2736         struct adapter *padapter = rtw_netdev_priv(dev);
2737         struct rereg_nd_name_data *rereg_priv = &padapter->rereg_nd_name_priv;
2738         char new_ifname[IFNAMSIZ];
2739
2740         if (rereg_priv->old_ifname[0] == 0) {
2741                 char *reg_ifname;
2742                 reg_ifname = padapter->registrypriv.ifname;
2743
2744                 strncpy(rereg_priv->old_ifname, reg_ifname, IFNAMSIZ);
2745                 rereg_priv->old_ifname[IFNAMSIZ-1] = 0;
2746         }
2747
2748         /* DBG_871X("%s wrqu->data.length:%d\n", __func__, wrqu->data.length); */
2749         if (wrqu->data.length > IFNAMSIZ)
2750                 return -EFAULT;
2751
2752         if (copy_from_user(new_ifname, wrqu->data.pointer, IFNAMSIZ))
2753                 return -EFAULT;
2754
2755         if (0 == strcmp(rereg_priv->old_ifname, new_ifname))
2756                 return ret;
2757
2758         DBG_871X("%s new_ifname:%s\n", __func__, new_ifname);
2759         if (0 != (ret = rtw_change_ifname(padapter, new_ifname)))
2760                 goto exit;
2761
2762         strncpy(rereg_priv->old_ifname, new_ifname, IFNAMSIZ);
2763         rereg_priv->old_ifname[IFNAMSIZ-1] = 0;
2764
2765         if (!memcmp(new_ifname, "disable%d", 9)) {
2766
2767                 DBG_871X("%s disable\n", __func__);
2768                 /*  free network queue for Android's timming issue */
2769                 rtw_free_network_queue(padapter, true);
2770
2771                 /*  the interface is being "disabled", we can do deeper IPS */
2772                 /* rereg_priv->old_ips_mode = rtw_get_ips_mode_req(&padapter->pwrctrlpriv); */
2773                 /* rtw_ips_mode_req(&padapter->pwrctrlpriv, IPS_NORMAL); */
2774         }
2775 exit:
2776         return ret;
2777
2778 }
2779
2780 static int rtw_dbg_port(struct net_device *dev,
2781                                struct iw_request_info *info,
2782                                union iwreq_data *wrqu, char *extra)
2783 {
2784         int ret = 0;
2785         u8 major_cmd, minor_cmd;
2786         u16 arg;
2787         u32 extra_arg, *pdata, val32;
2788         struct sta_info *psta;
2789         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2790         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2791         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2792         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2793         struct wlan_network *cur_network = &(pmlmepriv->cur_network);
2794         struct sta_priv *pstapriv = &padapter->stapriv;
2795
2796
2797         pdata = (u32*)&wrqu->data;
2798
2799         val32 = *pdata;
2800         arg = (u16)(val32&0x0000ffff);
2801         major_cmd = (u8)(val32>>24);
2802         minor_cmd = (u8)((val32>>16)&0x00ff);
2803
2804         extra_arg = *(pdata+1);
2805
2806         switch (major_cmd) {
2807                 case 0x70:/* read_reg */
2808                         switch (minor_cmd) {
2809                                 case 1:
2810                                         DBG_871X("rtw_read8(0x%x) = 0x%02x\n", arg, rtw_read8(padapter, arg));
2811                                         break;
2812                                 case 2:
2813                                         DBG_871X("rtw_read16(0x%x) = 0x%04x\n", arg, rtw_read16(padapter, arg));
2814                                         break;
2815                                 case 4:
2816                                         DBG_871X("rtw_read32(0x%x) = 0x%08x\n", arg, rtw_read32(padapter, arg));
2817                                         break;
2818                         }
2819                         break;
2820                 case 0x71:/* write_reg */
2821                         switch (minor_cmd) {
2822                                 case 1:
2823                                         rtw_write8(padapter, arg, extra_arg);
2824                                         DBG_871X("rtw_write8(0x%x) = 0x%02x\n", arg, rtw_read8(padapter, arg));
2825                                         break;
2826                                 case 2:
2827                                         rtw_write16(padapter, arg, extra_arg);
2828                                         DBG_871X("rtw_write16(0x%x) = 0x%04x\n", arg, rtw_read16(padapter, arg));
2829                                         break;
2830                                 case 4:
2831                                         rtw_write32(padapter, arg, extra_arg);
2832                                         DBG_871X("rtw_write32(0x%x) = 0x%08x\n", arg, rtw_read32(padapter, arg));
2833                                         break;
2834                         }
2835                         break;
2836                 case 0x72:/* read_bb */
2837                         DBG_871X("read_bbreg(0x%x) = 0x%x\n", arg, rtw_hal_read_bbreg(padapter, arg, 0xffffffff));
2838                         break;
2839                 case 0x73:/* write_bb */
2840                         rtw_hal_write_bbreg(padapter, arg, 0xffffffff, extra_arg);
2841                         DBG_871X("write_bbreg(0x%x) = 0x%x\n", arg, rtw_hal_read_bbreg(padapter, arg, 0xffffffff));
2842                         break;
2843                 case 0x74:/* read_rf */
2844                         DBG_871X("read RF_reg path(0x%02x), offset(0x%x), value(0x%08x)\n", minor_cmd, arg, rtw_hal_read_rfreg(padapter, minor_cmd, arg, 0xffffffff));
2845                         break;
2846                 case 0x75:/* write_rf */
2847                         rtw_hal_write_rfreg(padapter, minor_cmd, arg, 0xffffffff, extra_arg);
2848                         DBG_871X("write RF_reg path(0x%02x), offset(0x%x), value(0x%08x)\n", minor_cmd, arg, rtw_hal_read_rfreg(padapter, minor_cmd, arg, 0xffffffff));
2849                         break;
2850
2851                 case 0x76:
2852                         switch (minor_cmd) {
2853                                 case 0x00: /* normal mode, */
2854                                         padapter->recvpriv.is_signal_dbg = 0;
2855                                         break;
2856                                 case 0x01: /* dbg mode */
2857                                         padapter->recvpriv.is_signal_dbg = 1;
2858                                         extra_arg = extra_arg>100?100:extra_arg;
2859                                         padapter->recvpriv.signal_strength_dbg =extra_arg;
2860                                         break;
2861                         }
2862                         break;
2863                 case 0x78: /* IOL test */
2864                         break;
2865                 case 0x79:
2866                         {
2867                                 /*
2868                                 * dbg 0x79000000 [value], set RESP_TXAGC to + value, value:0~15
2869                                 * dbg 0x79010000 [value], set RESP_TXAGC to - value, value:0~15
2870                                 */
2871                                 u8 value =  extra_arg & 0x0f;
2872                                 u8 sign = minor_cmd;
2873                                 u16 write_value = 0;
2874
2875                                 DBG_871X("%s set RESP_TXAGC to %s %u\n", __func__, sign?"minus":"plus", value);
2876
2877                                 if (sign)
2878                                         value = value | 0x10;
2879
2880                                 write_value = value | (value << 5);
2881                                 rtw_write16(padapter, 0x6d9, write_value);
2882                         }
2883                         break;
2884                 case 0x7a:
2885                         receive_disconnect(padapter, pmlmeinfo->network.MacAddress
2886                                 , WLAN_REASON_EXPIRATION_CHK);
2887                         break;
2888                 case 0x7F:
2889                         switch (minor_cmd) {
2890                                 case 0x0:
2891                                         DBG_871X("fwstate = 0x%x\n", get_fwstate(pmlmepriv));
2892                                         break;
2893                                 case 0x01:
2894                                         DBG_871X("minor_cmd 0x%x\n", minor_cmd);
2895                                         break;
2896                                 case 0x02:
2897                                         DBG_871X("pmlmeinfo->state = 0x%x\n", pmlmeinfo->state);
2898                                         DBG_871X("DrvBcnEarly =%d\n", pmlmeext->DrvBcnEarly);
2899                                         DBG_871X("DrvBcnTimeOut =%d\n", pmlmeext->DrvBcnTimeOut);
2900                                         break;
2901                                 case 0x03:
2902                                         DBG_871X("qos_option =%d\n", pmlmepriv->qospriv.qos_option);
2903                                         DBG_871X("ht_option =%d\n", pmlmepriv->htpriv.ht_option);
2904                                         break;
2905                                 case 0x04:
2906                                         DBG_871X("cur_ch =%d\n", pmlmeext->cur_channel);
2907                                         DBG_871X("cur_bw =%d\n", pmlmeext->cur_bwmode);
2908                                         DBG_871X("cur_ch_off =%d\n", pmlmeext->cur_ch_offset);
2909
2910                                         DBG_871X("oper_ch =%d\n", rtw_get_oper_ch(padapter));
2911                                         DBG_871X("oper_bw =%d\n", rtw_get_oper_bw(padapter));
2912                                         DBG_871X("oper_ch_offet =%d\n", rtw_get_oper_choffset(padapter));
2913
2914                                         break;
2915                                 case 0x05:
2916                                         psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
2917                                         if (psta) {
2918                                                 int i;
2919                                                 struct recv_reorder_ctrl *preorder_ctrl;
2920
2921                                                 DBG_871X("SSID =%s\n", cur_network->network.Ssid.Ssid);
2922                                                 DBG_871X("sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr));
2923                                                 DBG_871X("cur_channel =%d, cur_bwmode =%d, cur_ch_offset =%d\n", pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
2924                                                 DBG_871X("rtsen =%d, cts2slef =%d\n", psta->rtsen, psta->cts2self);
2925                                                 DBG_871X("state = 0x%x, aid =%d, macid =%d, raid =%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
2926                                                 DBG_871X("qos_en =%d, ht_en =%d, init_rate =%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
2927                                                 DBG_871X("bwmode =%d, ch_offset =%d, sgi_20m =%d, sgi_40m =%d\n", psta->bw_mode, psta->htpriv.ch_offset, psta->htpriv.sgi_20m, psta->htpriv.sgi_40m);
2928                                                 DBG_871X("ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
2929                                                 DBG_871X("agg_enable_bitmap =%x, candidate_tid_bitmap =%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
2930
2931                                                 for (i = 0;i<16;i++) {
2932                                                         preorder_ctrl = &psta->recvreorder_ctrl[i];
2933                                                         if (preorder_ctrl->enable)
2934                                                                 DBG_871X("tid =%d, indicate_seq =%d\n", i, preorder_ctrl->indicate_seq);
2935                                                 }
2936
2937                                         } else {
2938                                                 DBG_871X("can't get sta's macaddr, cur_network's macaddr:" MAC_FMT "\n", MAC_ARG(cur_network->network.MacAddress));
2939                                         }
2940                                         break;
2941                                 case 0x06:
2942                                         {
2943                                                 u32 ODMFlag;
2944                                                 rtw_hal_get_hwreg(padapter, HW_VAR_DM_FLAG, (u8 *)(&ODMFlag));
2945                                                 DBG_871X("(B)DMFlag = 0x%x, arg = 0x%x\n", ODMFlag, arg);
2946                                                 ODMFlag = (u32)(0x0f&arg);
2947                                                 DBG_871X("(A)DMFlag = 0x%x\n", ODMFlag);
2948                                                 rtw_hal_set_hwreg(padapter, HW_VAR_DM_FLAG, (u8 *)(&ODMFlag));
2949                                         }
2950                                         break;
2951                                 case 0x07:
2952                                         DBG_871X("bSurpriseRemoved =%d, bDriverStopped =%d\n",
2953                                                 padapter->bSurpriseRemoved, padapter->bDriverStopped);
2954                                         break;
2955                                 case 0x08:
2956                                         {
2957                                                 DBG_871X("minor_cmd 0x%x\n", minor_cmd);
2958                                         }
2959                                         break;
2960                                 case 0x09:
2961                                         {
2962                                                 int i, j;
2963                                                 struct list_head        *plist, *phead;
2964                                                 struct recv_reorder_ctrl *preorder_ctrl;
2965
2966                                                 DBG_871X("sta_dz_bitmap = 0x%x, tim_bitmap = 0x%x\n", pstapriv->sta_dz_bitmap, pstapriv->tim_bitmap);
2967
2968                                                 spin_lock_bh(&pstapriv->sta_hash_lock);
2969
2970                                                 for (i = 0; i< NUM_STA; i++) {
2971                                                         phead = &(pstapriv->sta_hash[i]);
2972                                                         plist = get_next(phead);
2973
2974                                                         while (phead != plist) {
2975                                                                 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
2976
2977                                                                 plist = get_next(plist);
2978
2979                                                                 if (extra_arg == psta->aid) {
2980                                                                         DBG_871X("sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr));
2981                                                                         DBG_871X("rtsen =%d, cts2slef =%d\n", psta->rtsen, psta->cts2self);
2982                                                                         DBG_871X("state = 0x%x, aid =%d, macid =%d, raid =%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
2983                                                                         DBG_871X("qos_en =%d, ht_en =%d, init_rate =%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
2984                                                                         DBG_871X("bwmode =%d, ch_offset =%d, sgi_20m =%d, sgi_40m =%d\n", psta->bw_mode, psta->htpriv.ch_offset, psta->htpriv.sgi_20m, psta->htpriv.sgi_40m);
2985                                                                         DBG_871X("ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
2986                                                                         DBG_871X("agg_enable_bitmap =%x, candidate_tid_bitmap =%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
2987                                                                         DBG_871X("capability = 0x%x\n", psta->capability);
2988                                                                         DBG_871X("flags = 0x%x\n", psta->flags);
2989                                                                         DBG_871X("wpa_psk = 0x%x\n", psta->wpa_psk);
2990                                                                         DBG_871X("wpa2_group_cipher = 0x%x\n", psta->wpa2_group_cipher);
2991                                                                         DBG_871X("wpa2_pairwise_cipher = 0x%x\n", psta->wpa2_pairwise_cipher);
2992                                                                         DBG_871X("qos_info = 0x%x\n", psta->qos_info);
2993                                                                         DBG_871X("dot118021XPrivacy = 0x%x\n", psta->dot118021XPrivacy);
2994
2995
2996
2997                                                                         for (j = 0;j<16;j++) {
2998                                                                                 preorder_ctrl = &psta->recvreorder_ctrl[j];
2999                                                                                 if (preorder_ctrl->enable)
3000                                                                                         DBG_871X("tid =%d, indicate_seq =%d\n", j, preorder_ctrl->indicate_seq);
3001                                                                         }
3002                                                                 }
3003                                                         }
3004                                                 }
3005
3006                                                 spin_unlock_bh(&pstapriv->sta_hash_lock);
3007
3008                                         }
3009                                         break;
3010                                 case 0x0a:
3011                                         {
3012                                                 int max_mac_id = 0;
3013                                                 max_mac_id = rtw_search_max_mac_id(padapter);
3014                                                 printk("%s ==> max_mac_id = %d\n", __func__, max_mac_id);
3015                                         }
3016                                         break;
3017                                 case 0x0b: /* Enable = 1, Disable = 0 driver control vrtl_carrier_sense. */
3018                                         if (arg == 0) {
3019                                                 DBG_871X("disable driver ctrl vcs\n");
3020                                                 padapter->driver_vcs_en = 0;
3021                                         } else if (arg == 1) {
3022                                                 DBG_871X("enable driver ctrl vcs = %d\n", extra_arg);
3023                                                 padapter->driver_vcs_en = 1;
3024
3025                                                 if (extra_arg>2)
3026                                                         padapter->driver_vcs_type = 1;
3027                                                 else
3028                                                         padapter->driver_vcs_type = extra_arg;
3029                                         }
3030                                         break;
3031                                 case 0x0c:/* dump rx/tx packet */
3032                                         {
3033                                                 if (arg == 0) {
3034                                                         DBG_871X("dump rx packet (%d)\n", extra_arg);
3035                                                         /* pHalData->bDumpRxPkt =extra_arg; */
3036                                                         rtw_hal_set_def_var(padapter, HAL_DEF_DBG_DUMP_RXPKT, &(extra_arg));
3037                                                 } else if (arg == 1) {
3038                                                         DBG_871X("dump tx packet (%d)\n", extra_arg);
3039                                                         rtw_hal_set_def_var(padapter, HAL_DEF_DBG_DUMP_TXPKT, &(extra_arg));
3040                                                 }
3041                                         }
3042                                         break;
3043                                 case 0x0e:
3044                                         {
3045                                                 if (arg == 0) {
3046                                                         DBG_871X("disable driver ctrl rx_ampdu_factor\n");
3047                                                         padapter->driver_rx_ampdu_factor = 0xFF;
3048                                                 } else if (arg == 1) {
3049
3050                                                         DBG_871X("enable driver ctrl rx_ampdu_factor = %d\n", extra_arg);
3051
3052                                                         if ((extra_arg & 0x03) > 0x03)
3053                                                                 padapter->driver_rx_ampdu_factor = 0xFF;
3054                                                         else
3055                                                                 padapter->driver_rx_ampdu_factor = extra_arg;
3056                                                 }
3057                                         }
3058                                         break;
3059
3060                                 case 0x10:/*  driver version display */
3061                                         dump_drv_version(RTW_DBGDUMP);
3062                                         break;
3063                                 case 0x11:/* dump linked status */
3064                                         {
3065                                                  linked_info_dump(padapter, extra_arg);
3066                                         }
3067                                         break;
3068                                 case 0x12: /* set rx_stbc */
3069                                 {
3070                                         struct registry_priv *pregpriv = &padapter->registrypriv;
3071                                         /*  0: disable, bit(0):enable 2.4g, bit(1):enable 5g, 0x3: enable both 2.4g and 5g */
3072                                         /* default is set to enable 2.4GHZ for IOT issue with bufflao's AP at 5GHZ */
3073                                         if (pregpriv && (extra_arg == 0 || extra_arg == 1|| extra_arg == 2 || extra_arg == 3)) {
3074                                                 pregpriv->rx_stbc = extra_arg;
3075                                                 DBG_871X("set rx_stbc =%d\n", pregpriv->rx_stbc);
3076                                         } else
3077                                                 DBG_871X("get rx_stbc =%d\n", pregpriv->rx_stbc);
3078
3079                                 }
3080                                 break;
3081                                 case 0x13: /* set ampdu_enable */
3082                                 {
3083                                         struct registry_priv *pregpriv = &padapter->registrypriv;
3084                                         /*  0: disable, 0x1:enable (but wifi_spec should be 0), 0x2: force enable (don't care wifi_spec) */
3085                                         if (pregpriv && extra_arg < 3) {
3086                                                 pregpriv->ampdu_enable = extra_arg;
3087                                                 DBG_871X("set ampdu_enable =%d\n", pregpriv->ampdu_enable);
3088                                         } else
3089                                                 DBG_871X("get ampdu_enable =%d\n", pregpriv->ampdu_enable);
3090
3091                                 }
3092                                 break;
3093                                 case 0x14:
3094                                 {
3095                                         DBG_871X("minor_cmd 0x%x\n", minor_cmd);
3096                                 }
3097                                 break;
3098                                 case 0x16:
3099                                 {
3100                                         if (arg == 0xff) {
3101                                                 rtw_odm_dbg_comp_msg(RTW_DBGDUMP, padapter);
3102                                         } else {
3103                                                 u64 dbg_comp = (u64)extra_arg;
3104                                                 rtw_odm_dbg_comp_set(padapter, dbg_comp);
3105                                         }
3106                                 }
3107                                         break;
3108 #ifdef DBG_FIXED_CHAN
3109                                 case 0x17:
3110                                         {
3111                                                 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
3112                                                 printk("===>  Fixed channel to %d\n", extra_arg);
3113                                                 pmlmeext->fixed_chan = extra_arg;
3114
3115                                         }
3116                                         break;
3117 #endif
3118                                 case 0x18:
3119                                         {
3120                                                 printk("===>  Switch USB Mode %d\n", extra_arg);
3121                                                 rtw_hal_set_hwreg(padapter, HW_VAR_USB_MODE, (u8 *)&extra_arg);
3122                                         }
3123                                         break;
3124                                 case 0x19:
3125                                         {
3126                                                 struct registry_priv *pregistrypriv = &padapter->registrypriv;
3127                                                 /*  extra_arg : */
3128                                                 /*  BIT0: Enable VHT LDPC Rx, BIT1: Enable VHT LDPC Tx, */
3129                                                 /*  BIT4: Enable HT LDPC Rx, BIT5: Enable HT LDPC Tx */
3130                                                 if (arg == 0) {
3131                                                         DBG_871X("driver disable LDPC\n");
3132                                                         pregistrypriv->ldpc_cap = 0x00;
3133                                                 } else if (arg == 1) {
3134                                                         DBG_871X("driver set LDPC cap = 0x%x\n", extra_arg);
3135                                                         pregistrypriv->ldpc_cap = (u8)(extra_arg&0x33);
3136                                                 }
3137                                         }
3138                                         break;
3139                                 case 0x1a:
3140                                         {
3141                                                 struct registry_priv *pregistrypriv = &padapter->registrypriv;
3142                                                 /*  extra_arg : */
3143                                                 /*  BIT0: Enable VHT STBC Rx, BIT1: Enable VHT STBC Tx, */
3144                                                 /*  BIT4: Enable HT STBC Rx, BIT5: Enable HT STBC Tx */
3145                                                 if (arg == 0) {
3146                                                         DBG_871X("driver disable STBC\n");
3147                                                         pregistrypriv->stbc_cap = 0x00;
3148                                                 } else if (arg == 1) {
3149                                                         DBG_871X("driver set STBC cap = 0x%x\n", extra_arg);
3150                                                         pregistrypriv->stbc_cap = (u8)(extra_arg&0x33);
3151                                                 }
3152                                         }
3153                                         break;
3154                                 case 0x1b:
3155                                         {
3156                                                 struct registry_priv *pregistrypriv = &padapter->registrypriv;
3157
3158                                                 if (arg == 0) {
3159                                                         DBG_871X("disable driver ctrl max_rx_rate, reset to default_rate_set\n");
3160                                                         init_mlme_default_rate_set(padapter);
3161                                                         pregistrypriv->ht_enable = (u8)rtw_ht_enable;
3162                                                 } else if (arg == 1) {
3163
3164                                                         int i;
3165                                                         u8 max_rx_rate;
3166
3167                                                         DBG_871X("enable driver ctrl max_rx_rate = 0x%x\n", extra_arg);
3168
3169                                                         max_rx_rate = (u8)extra_arg;
3170
3171                                                         if (max_rx_rate < 0xc) { /*  max_rx_rate < MSC0 -> B or G -> disable HT */
3172                                                                 pregistrypriv->ht_enable = 0;
3173                                                                 for (i = 0; i<NumRates; i++) {
3174                                                                         if (pmlmeext->datarate[i] > max_rx_rate)
3175                                                                                 pmlmeext->datarate[i] = 0xff;
3176                                                                 }
3177
3178                                                         }
3179                                                         else if (max_rx_rate < 0x1c) { /*  mcs0~mcs15 */
3180                                                                 u32 mcs_bitmap = 0x0;
3181
3182                                                                 for (i = 0; i<((max_rx_rate+1)-0xc); i++)
3183                                                                         mcs_bitmap |= BIT(i);
3184
3185                                                                 set_mcs_rate_by_mask(pmlmeext->default_supported_mcs_set, mcs_bitmap);
3186                                                         }
3187                                                 }
3188                                         }
3189                                         break;
3190                                 case 0x1c: /* enable/disable driver control AMPDU Density for peer sta's rx */
3191                                         {
3192                                                 if (arg == 0) {
3193                                                         DBG_871X("disable driver ctrl ampdu density\n");
3194                                                         padapter->driver_ampdu_spacing = 0xFF;
3195                                                 } else if (arg == 1) {
3196
3197                                                         DBG_871X("enable driver ctrl ampdu density = %d\n", extra_arg);
3198
3199                                                         if ((extra_arg & 0x07) > 0x07)
3200                                                                 padapter->driver_ampdu_spacing = 0xFF;
3201                                                         else
3202                                                                 padapter->driver_ampdu_spacing = extra_arg;
3203                                                 }
3204                                         }
3205                                         break;
3206 #ifdef CONFIG_BACKGROUND_NOISE_MONITOR
3207                                 case 0x1e:
3208                                         {
3209                                                 struct hal_com_data     *pHalData = GET_HAL_DATA(padapter);
3210                                                 PDM_ODM_T pDM_Odm = &pHalData->odmpriv;
3211                                                 u8 chan = rtw_get_oper_ch(padapter);
3212                                                 DBG_871X("===========================================\n");
3213                                                 ODM_InbandNoise_Monitor(pDM_Odm, true, 0x1e, 100);
3214                                                 DBG_871X("channel(%d), noise_a = %d, noise_b = %d , noise_all:%d\n",
3215                                                         chan, pDM_Odm->noise_level.noise[ODM_RF_PATH_A],
3216                                                         pDM_Odm->noise_level.noise[ODM_RF_PATH_B],
3217                                                         pDM_Odm->noise_level.noise_all);
3218                                                 DBG_871X("===========================================\n");
3219
3220                                         }
3221                                         break;
3222 #endif
3223                                 case 0x23:
3224                                         {
3225                                                 DBG_871X("turn %s the bNotifyChannelChange Variable\n", (extra_arg == 1)?"on":"off");
3226                                                 padapter->bNotifyChannelChange = extra_arg;
3227                                                 break;
3228                                         }
3229                                 case 0x24:
3230                                         {
3231                                                 break;
3232                                         }
3233 #ifdef CONFIG_GPIO_API
3234                             case 0x25: /* Get GPIO register */
3235                                     {
3236                                             /*
3237                                             * dbg 0x7f250000 [gpio_num], Get gpio value, gpio_num:0~7
3238                                             */
3239
3240                                             int value;
3241                                             DBG_871X("Read GPIO Value  extra_arg = %d\n", extra_arg);
3242                                             value = rtw_get_gpio(dev, extra_arg);
3243                                             DBG_871X("Read GPIO Value = %d\n", value);
3244                                             break;
3245                                     }
3246                             case 0x26: /* Set GPIO direction */
3247                                     {
3248
3249                                             /* dbg 0x7f26000x [y], Set gpio direction,
3250                                             * x: gpio_num, 4~7  y: indicate direction, 0~1
3251                                             */
3252
3253                                             int value;
3254                                             DBG_871X("Set GPIO Direction! arg = %d , extra_arg =%d\n", arg , extra_arg);
3255                                             value = rtw_config_gpio(dev, arg, extra_arg);
3256                                             DBG_871X("Set GPIO Direction %s\n", (value ==-1)?"Fail!!!":"Success");
3257                                             break;
3258                                         }
3259                                 case 0x27: /* Set GPIO output direction value */
3260                                         {
3261                                                 /*
3262                                                 * dbg 0x7f27000x [y], Set gpio output direction value,
3263                                                 * x: gpio_num, 4~7  y: indicate direction, 0~1
3264                                                 */
3265
3266                                                 int value;
3267                                                 DBG_871X("Set GPIO Value! arg = %d , extra_arg =%d\n", arg , extra_arg);
3268                                                 value = rtw_set_gpio_output_value(dev, arg, extra_arg);
3269                                                 DBG_871X("Set GPIO Value %s\n", (value ==-1)?"Fail!!!":"Success");
3270                                                 break;
3271                                         }
3272 #endif
3273                                 case 0xaa:
3274                                         {
3275                                                 if ((extra_arg & 0x7F)> 0x3F) extra_arg = 0xFF;
3276                                                 DBG_871X("chang data rate to :0x%02x\n", extra_arg);
3277                                                 padapter->fix_rate = extra_arg;
3278                                         }
3279                                         break;
3280                                 case 0xdd:/* registers dump , 0 for mac reg, 1 for bb reg, 2 for rf reg */
3281                                         {
3282                                                 if (extra_arg == 0)
3283                                                         mac_reg_dump(RTW_DBGDUMP, padapter);
3284                                                 else if (extra_arg == 1)
3285                                                         bb_reg_dump(RTW_DBGDUMP, padapter);
3286                                                 else if (extra_arg ==2)
3287                                                         rf_reg_dump(RTW_DBGDUMP, padapter);
3288                                         }
3289                                         break;
3290
3291                                 case 0xee:/* turn on/off dynamic funcs */
3292                                         {
3293                                                 u32 odm_flag;
3294
3295                                                 if (0xf ==extra_arg) {
3296                                                         rtw_hal_get_def_var(padapter, HAL_DEF_DBG_DM_FUNC,&odm_flag);
3297                                                         DBG_871X(" === DMFlag(0x%08x) ===\n", odm_flag);
3298                                                         DBG_871X("extra_arg = 0  - disable all dynamic func\n");
3299                                                         DBG_871X("extra_arg = 1  - disable DIG- BIT(0)\n");
3300                                                         DBG_871X("extra_arg = 2  - disable High power - BIT(1)\n");
3301                                                         DBG_871X("extra_arg = 3  - disable tx power tracking - BIT(2)\n");
3302                                                         DBG_871X("extra_arg = 4  - disable BT coexistence - BIT(3)\n");
3303                                                         DBG_871X("extra_arg = 5  - disable antenna diversity - BIT(4)\n");
3304                                                         DBG_871X("extra_arg = 6  - enable all dynamic func\n");
3305                                                 } else {
3306                                                         /*extra_arg = 0  - disable all dynamic func
3307                                                                 extra_arg = 1  - disable DIG
3308                                                                 extra_arg = 2  - disable tx power tracking
3309                                                                 extra_arg = 3  - turn on all dynamic func
3310                                                         */
3311                                                         rtw_hal_set_def_var(padapter, HAL_DEF_DBG_DM_FUNC, &(extra_arg));
3312                                                         rtw_hal_get_def_var(padapter, HAL_DEF_DBG_DM_FUNC,&odm_flag);
3313                                                         DBG_871X(" === DMFlag(0x%08x) ===\n", odm_flag);
3314                                                 }
3315                                         }
3316                                         break;
3317
3318                                 case 0xfd:
3319                                         rtw_write8(padapter, 0xc50, arg);
3320                                         DBG_871X("wr(0xc50) = 0x%x\n", rtw_read8(padapter, 0xc50));
3321                                         rtw_write8(padapter, 0xc58, arg);
3322                                         DBG_871X("wr(0xc58) = 0x%x\n", rtw_read8(padapter, 0xc58));
3323                                         break;
3324                                 case 0xfe:
3325                                         DBG_871X("rd(0xc50) = 0x%x\n", rtw_read8(padapter, 0xc50));
3326                                         DBG_871X("rd(0xc58) = 0x%x\n", rtw_read8(padapter, 0xc58));
3327                                         break;
3328                                 case 0xff:
3329                                         {
3330                                                 DBG_871X("dbg(0x210) = 0x%x\n", rtw_read32(padapter, 0x210));
3331                                                 DBG_871X("dbg(0x608) = 0x%x\n", rtw_read32(padapter, 0x608));
3332                                                 DBG_871X("dbg(0x280) = 0x%x\n", rtw_read32(padapter, 0x280));
3333                                                 DBG_871X("dbg(0x284) = 0x%x\n", rtw_read32(padapter, 0x284));
3334                                                 DBG_871X("dbg(0x288) = 0x%x\n", rtw_read32(padapter, 0x288));
3335
3336                                                 DBG_871X("dbg(0x664) = 0x%x\n", rtw_read32(padapter, 0x664));
3337
3338
3339                                                 DBG_871X("\n");
3340
3341                                                 DBG_871X("dbg(0x430) = 0x%x\n", rtw_read32(padapter, 0x430));
3342                                                 DBG_871X("dbg(0x438) = 0x%x\n", rtw_read32(padapter, 0x438));
3343
3344                                                 DBG_871X("dbg(0x440) = 0x%x\n", rtw_read32(padapter, 0x440));
3345
3346                                                 DBG_871X("dbg(0x458) = 0x%x\n", rtw_read32(padapter, 0x458));
3347
3348                                                 DBG_871X("dbg(0x484) = 0x%x\n", rtw_read32(padapter, 0x484));
3349                                                 DBG_871X("dbg(0x488) = 0x%x\n", rtw_read32(padapter, 0x488));
3350
3351                                                 DBG_871X("dbg(0x444) = 0x%x\n", rtw_read32(padapter, 0x444));
3352                                                 DBG_871X("dbg(0x448) = 0x%x\n", rtw_read32(padapter, 0x448));
3353                                                 DBG_871X("dbg(0x44c) = 0x%x\n", rtw_read32(padapter, 0x44c));
3354                                                 DBG_871X("dbg(0x450) = 0x%x\n", rtw_read32(padapter, 0x450));
3355                                         }
3356                                         break;
3357                         }
3358                         break;
3359                 default:
3360                         DBG_871X("error dbg cmd!\n");
3361                         break;
3362         }
3363
3364
3365         return ret;
3366
3367 }
3368
3369 static int wpa_set_param(struct net_device *dev, u8 name, u32 value)
3370 {
3371         uint ret = 0;
3372         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
3373
3374         switch (name) {
3375         case IEEE_PARAM_WPA_ENABLED:
3376
3377                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; /* 802.1x */
3378
3379                 /* ret = ieee80211_wpa_enable(ieee, value); */
3380
3381                 switch ((value)&0xff) {
3382                 case 1 : /* WPA */
3383                         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPAPSK; /* WPA_PSK */
3384                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
3385                         break;
3386                 case 2: /* WPA2 */
3387                         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPA2PSK; /* WPA2_PSK */
3388                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
3389                         break;
3390                 }
3391
3392                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("wpa_set_param:padapter->securitypriv.ndisauthtype =%d\n", padapter->securitypriv.ndisauthtype));
3393
3394                 break;
3395
3396         case IEEE_PARAM_TKIP_COUNTERMEASURES:
3397                 /* ieee->tkip_countermeasures =value; */
3398                 break;
3399
3400         case IEEE_PARAM_DROP_UNENCRYPTED:
3401         {
3402                 /* HACK:
3403                  *
3404                  * wpa_supplicant calls set_wpa_enabled when the driver
3405                  * is loaded and unloaded, regardless of if WPA is being
3406                  * used.  No other calls are made which can be used to
3407                  * determine if encryption will be used or not prior to
3408                  * association being expected.  If encryption is not being
3409                  * used, drop_unencrypted is set to false, else true -- we
3410                  * can use this to determine if the CAP_PRIVACY_ON bit should
3411                  * be set.
3412                  */
3413                 break;
3414
3415         }
3416         case IEEE_PARAM_PRIVACY_INVOKED:
3417
3418                 /* ieee->privacy_invoked =value; */
3419
3420                 break;
3421
3422         case IEEE_PARAM_AUTH_ALGS:
3423
3424                 ret = wpa_set_auth_algs(dev, value);
3425
3426                 break;
3427
3428         case IEEE_PARAM_IEEE_802_1X:
3429
3430                 /* ieee->ieee802_1x =value; */
3431
3432                 break;
3433
3434         case IEEE_PARAM_WPAX_SELECT:
3435
3436                 /*  added for WPA2 mixed mode */
3437                 /* DBG_871X(KERN_WARNING "------------------------>wpax value = %x\n", value); */
3438                 /*
3439                 spin_lock_irqsave(&ieee->wpax_suitlist_lock, flags);
3440                 ieee->wpax_type_set = 1;
3441                 ieee->wpax_type_notify = value;
3442                 spin_unlock_irqrestore(&ieee->wpax_suitlist_lock, flags);
3443                 */
3444
3445                 break;
3446
3447         default:
3448
3449
3450
3451                 ret = -EOPNOTSUPP;
3452
3453
3454                 break;
3455
3456         }
3457
3458         return ret;
3459
3460 }
3461
3462 static int wpa_mlme(struct net_device *dev, u32 command, u32 reason)
3463 {
3464         int ret = 0;
3465         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
3466
3467         switch (command) {
3468                 case IEEE_MLME_STA_DEAUTH:
3469
3470                         if (!rtw_set_802_11_disassociate(padapter))
3471                                 ret = -1;
3472
3473                         break;
3474
3475                 case IEEE_MLME_STA_DISASSOC:
3476
3477                         if (!rtw_set_802_11_disassociate(padapter))
3478                                 ret = -1;
3479
3480                         break;
3481
3482                 default:
3483                         ret = -EOPNOTSUPP;
3484                         break;
3485         }
3486
3487         return ret;
3488
3489 }
3490
3491 static int wpa_supplicant_ioctl(struct net_device *dev, struct iw_point *p)
3492 {
3493         struct ieee_param *param;
3494         uint ret = 0;
3495
3496         /* down(&ieee->wx_sem); */
3497
3498         if (!p->pointer || p->length != sizeof(struct ieee_param)) {
3499                 ret = -EINVAL;
3500                 goto out;
3501         }
3502
3503         param = (struct ieee_param *)rtw_malloc(p->length);
3504         if (param == NULL) {
3505                 ret = -ENOMEM;
3506                 goto out;
3507         }
3508
3509         if (copy_from_user(param, p->pointer, p->length)) {
3510                 kfree(param);
3511                 ret = -EFAULT;
3512                 goto out;
3513         }
3514
3515         switch (param->cmd) {
3516
3517         case IEEE_CMD_SET_WPA_PARAM:
3518                 ret = wpa_set_param(dev, param->u.wpa_param.name, param->u.wpa_param.value);
3519                 break;
3520
3521         case IEEE_CMD_SET_WPA_IE:
3522                 /* ret = wpa_set_wpa_ie(dev, param, p->length); */
3523                 ret =  rtw_set_wpa_ie((struct adapter *)rtw_netdev_priv(dev), (char*)param->u.wpa_ie.data, (u16)param->u.wpa_ie.len);
3524                 break;
3525
3526         case IEEE_CMD_SET_ENCRYPTION:
3527                 ret = wpa_set_encryption(dev, param, p->length);
3528                 break;
3529
3530         case IEEE_CMD_MLME:
3531                 ret = wpa_mlme(dev, param->u.mlme.command, param->u.mlme.reason_code);
3532                 break;
3533
3534         default:
3535                 DBG_871X("Unknown WPA supplicant request: %d\n", param->cmd);
3536                 ret = -EOPNOTSUPP;
3537                 break;
3538
3539         }
3540
3541         if (ret == 0 && copy_to_user(p->pointer, param, p->length))
3542                 ret = -EFAULT;
3543
3544         kfree(param);
3545
3546 out:
3547
3548         /* up(&ieee->wx_sem); */
3549
3550         return ret;
3551
3552 }
3553
3554 static int rtw_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len)
3555 {
3556         int ret = 0;
3557         u32 wep_key_idx, wep_key_len, wep_total_len;
3558         struct ndis_802_11_wep   *pwep = NULL;
3559         struct sta_info *psta = NULL, *pbcmc_sta = NULL;
3560         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
3561         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3562         struct security_priv* psecuritypriv =&(padapter->securitypriv);
3563         struct sta_priv *pstapriv = &padapter->stapriv;
3564
3565         DBG_871X("%s\n", __func__);
3566
3567         param->u.crypt.err = 0;
3568         param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
3569
3570         /* sizeof(struct ieee_param) = 64 bytes; */
3571         /* if (param_len !=  (u32) ((u8 *) param->u.crypt.key - (u8 *) param) + param->u.crypt.key_len) */
3572         if (param_len !=  sizeof(struct ieee_param) + param->u.crypt.key_len) {
3573                 ret =  -EINVAL;
3574                 goto exit;
3575         }
3576
3577         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
3578             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
3579             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
3580                 if (param->u.crypt.idx >= WEP_KEYS) {
3581                         ret = -EINVAL;
3582                         goto exit;
3583                 }
3584         } else {
3585                 psta = rtw_get_stainfo(pstapriv, param->sta_addr);
3586                 if (!psta) {
3587                         /* ret = -EINVAL; */
3588                         DBG_871X("rtw_set_encryption(), sta has already been removed or never been added\n");
3589                         goto exit;
3590                 }
3591         }
3592
3593         if (strcmp(param->u.crypt.alg, "none") == 0 && (psta == NULL)) {
3594                 /* todo:clear default encryption keys */
3595
3596                 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
3597                 psecuritypriv->ndisencryptstatus = Ndis802_11EncryptionDisabled;
3598                 psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
3599                 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
3600
3601                 DBG_871X("clear default encryption keys, keyid =%d\n", param->u.crypt.idx);
3602
3603                 goto exit;
3604         }
3605
3606
3607         if (strcmp(param->u.crypt.alg, "WEP") == 0 && (psta == NULL)) {
3608                 DBG_871X("r871x_set_encryption, crypt.alg = WEP\n");
3609
3610                 wep_key_idx = param->u.crypt.idx;
3611                 wep_key_len = param->u.crypt.key_len;
3612
3613                 DBG_871X("r871x_set_encryption, wep_key_idx =%d, len =%d\n", wep_key_idx, wep_key_len);
3614
3615                 if ((wep_key_idx >= WEP_KEYS) || (wep_key_len<= 0)) {
3616                         ret = -EINVAL;
3617                         goto exit;
3618                 }
3619
3620
3621                 if (wep_key_len > 0) {
3622                         wep_key_len = wep_key_len <= 5 ? 5 : 13;
3623                         wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, KeyMaterial);
3624                         pwep =(struct ndis_802_11_wep *)rtw_malloc(wep_total_len);
3625                         if (pwep == NULL) {
3626                                 DBG_871X(" r871x_set_encryption: pwep allocate fail !!!\n");
3627                                 goto exit;
3628                         }
3629
3630                         memset(pwep, 0, wep_total_len);
3631
3632                         pwep->KeyLength = wep_key_len;
3633                         pwep->Length = wep_total_len;
3634
3635                 }
3636
3637                 pwep->KeyIndex = wep_key_idx;
3638
3639                 memcpy(pwep->KeyMaterial,  param->u.crypt.key, pwep->KeyLength);
3640
3641                 if (param->u.crypt.set_tx) {
3642                         DBG_871X("wep, set_tx = 1\n");
3643
3644                         psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
3645                         psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled;
3646                         psecuritypriv->dot11PrivacyAlgrthm = _WEP40_;
3647                         psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
3648
3649                         if (pwep->KeyLength == 13) {
3650                                 psecuritypriv->dot11PrivacyAlgrthm = _WEP104_;
3651                                 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
3652                         }
3653
3654
3655                         psecuritypriv->dot11PrivacyKeyIndex = wep_key_idx;
3656
3657                         memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength);
3658
3659                         psecuritypriv->dot11DefKeylen[wep_key_idx]=pwep->KeyLength;
3660
3661                         rtw_ap_set_wep_key(padapter, pwep->KeyMaterial, pwep->KeyLength, wep_key_idx, 1);
3662                 } else {
3663                         DBG_871X("wep, set_tx = 0\n");
3664
3665                         /* don't update "psecuritypriv->dot11PrivacyAlgrthm" and */
3666                         /* psecuritypriv->dot11PrivacyKeyIndex =keyid", but can rtw_set_key to cam */
3667
3668                         memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength);
3669
3670                         psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->KeyLength;
3671
3672                         rtw_ap_set_wep_key(padapter, pwep->KeyMaterial, pwep->KeyLength, wep_key_idx, 0);
3673                 }
3674
3675                 goto exit;
3676
3677         }
3678
3679
3680         if (!psta && check_fwstate(pmlmepriv, WIFI_AP_STATE)) { /*  group key */
3681                 if (param->u.crypt.set_tx == 1) {
3682                         if (strcmp(param->u.crypt.alg, "WEP") == 0) {
3683                                 DBG_871X("%s, set group_key, WEP\n", __func__);
3684
3685                                 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
3686
3687                                 psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
3688                                 if (param->u.crypt.key_len == 13)
3689                                                 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
3690
3691                         } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
3692                                 DBG_871X("%s, set group_key, TKIP\n", __func__);
3693
3694                                 psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
3695
3696                                 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
3697
3698                                 /* DEBUG_ERR("set key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len); */
3699                                 /* set mic key */
3700                                 memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8);
3701                                 memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8);
3702
3703                                 psecuritypriv->busetkipkey = true;
3704
3705                         }
3706                         else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
3707                                 DBG_871X("%s, set group_key, CCMP\n", __func__);
3708
3709                                 psecuritypriv->dot118021XGrpPrivacy = _AES_;
3710
3711                                 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
3712                         } else {
3713                                 DBG_871X("%s, set group_key, none\n", __func__);
3714
3715                                 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
3716                         }
3717
3718                         psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
3719
3720                         psecuritypriv->binstallGrpkey = true;
3721
3722                         psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/*  */
3723
3724                         rtw_ap_set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx);
3725
3726                         pbcmc_sta =rtw_get_bcmc_stainfo(padapter);
3727                         if (pbcmc_sta) {
3728                                 pbcmc_sta->ieee8021x_blocked = false;
3729                                 pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */
3730                         }
3731                 }
3732
3733                 goto exit;
3734
3735         }
3736
3737         if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X && psta) { /*  psk/802_1x */
3738                 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
3739                         if (param->u.crypt.set_tx == 1) {
3740                                 memcpy(psta->dot118021x_UncstKey.skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
3741
3742                                 if (strcmp(param->u.crypt.alg, "WEP") == 0) {
3743                                         DBG_871X("%s, set pairwise key, WEP\n", __func__);
3744
3745                                         psta->dot118021XPrivacy = _WEP40_;
3746                                         if (param->u.crypt.key_len == 13)
3747                                                 psta->dot118021XPrivacy = _WEP104_;
3748                                 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
3749                                         DBG_871X("%s, set pairwise key, TKIP\n", __func__);
3750
3751                                         psta->dot118021XPrivacy = _TKIP_;
3752
3753                                         /* DEBUG_ERR("set key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len); */
3754                                         /* set mic key */
3755                                         memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8);
3756                                         memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8);
3757
3758                                         psecuritypriv->busetkipkey = true;
3759
3760                                 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
3761
3762                                         DBG_871X("%s, set pairwise key, CCMP\n", __func__);
3763
3764                                         psta->dot118021XPrivacy = _AES_;
3765                                 } else {
3766                                         DBG_871X("%s, set pairwise key, none\n", __func__);
3767
3768                                         psta->dot118021XPrivacy = _NO_PRIVACY_;
3769                                 }
3770
3771                                 rtw_ap_set_pairwise_key(padapter, psta);
3772
3773                                 psta->ieee8021x_blocked = false;
3774
3775                         } else { /* group key??? */
3776                                 if (strcmp(param->u.crypt.alg, "WEP") == 0) {
3777                                         memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
3778
3779                                         psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
3780                                         if (param->u.crypt.key_len == 13)
3781                                                 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
3782                                 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
3783                                         psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
3784
3785                                         memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
3786
3787                                         /* DEBUG_ERR("set key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len); */
3788                                         /* set mic key */
3789                                         memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8);
3790                                         memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8);
3791
3792                                         psecuritypriv->busetkipkey = true;
3793
3794                                 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
3795                                         psecuritypriv->dot118021XGrpPrivacy = _AES_;
3796
3797                                         memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
3798                                 } else {
3799                                         psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
3800                                 }
3801
3802                                 psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
3803
3804                                 psecuritypriv->binstallGrpkey = true;
3805
3806                                 psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/*  */
3807
3808                                 rtw_ap_set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx);
3809
3810                                 pbcmc_sta =rtw_get_bcmc_stainfo(padapter);
3811                                 if (pbcmc_sta) {
3812                                         pbcmc_sta->ieee8021x_blocked = false;
3813                                         pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */
3814                                 }
3815                         }
3816                 }
3817         }
3818
3819 exit:
3820         kfree(pwep);
3821
3822         return ret;
3823
3824 }
3825
3826 static int rtw_set_beacon(struct net_device *dev, struct ieee_param *param, int len)
3827 {
3828         int ret = 0;
3829         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
3830         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3831         struct sta_priv *pstapriv = &padapter->stapriv;
3832         unsigned char *pbuf = param->u.bcn_ie.buf;
3833
3834
3835         DBG_871X("%s, len =%d\n", __func__, len);
3836
3837         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
3838                 return -EINVAL;
3839
3840         memcpy(&pstapriv->max_num_sta, param->u.bcn_ie.reserved, 2);
3841
3842         if ((pstapriv->max_num_sta>NUM_STA) || (pstapriv->max_num_sta<= 0))
3843                 pstapriv->max_num_sta = NUM_STA;
3844
3845
3846         if (rtw_check_beacon_data(padapter, pbuf,  (len-12-2)) == _SUCCESS)/*  12 = param header, 2:no packed */
3847                 ret = 0;
3848         else
3849                 ret = -EINVAL;
3850
3851
3852         return ret;
3853
3854 }
3855
3856 static int rtw_hostapd_sta_flush(struct net_device *dev)
3857 {
3858         /* _irqL irqL; */
3859         /* struct list_head     *phead, *plist; */
3860         int ret = 0;
3861         /* struct sta_info *psta = NULL; */
3862         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
3863         /* struct sta_priv *pstapriv = &padapter->stapriv; */
3864
3865         DBG_871X("%s\n", __func__);
3866
3867         flush_all_cam_entry(padapter);  /* clear CAM */
3868
3869         ret = rtw_sta_flush(padapter);
3870
3871         return ret;
3872
3873 }
3874
3875 static int rtw_add_sta(struct net_device *dev, struct ieee_param *param)
3876 {
3877         int ret = 0;
3878         struct sta_info *psta = NULL;
3879         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
3880         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3881         struct sta_priv *pstapriv = &padapter->stapriv;
3882
3883         DBG_871X("rtw_add_sta(aid =%d) =" MAC_FMT "\n", param->u.add_sta.aid, MAC_ARG(param->sta_addr));
3884
3885         if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true)
3886                 return -EINVAL;
3887
3888         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
3889             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
3890             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
3891                 return -EINVAL;
3892         }
3893
3894 /*
3895         psta = rtw_get_stainfo(pstapriv, param->sta_addr);
3896         if (psta)
3897         {
3898                 DBG_871X("rtw_add_sta(), free has been added psta =%p\n", psta);
3899                 spin_lock_bh(&(pstapriv->sta_hash_lock));
3900                 rtw_free_stainfo(padapter,  psta);
3901                 spin_unlock_bh(&(pstapriv->sta_hash_lock));
3902
3903                 psta = NULL;
3904         }
3905 */
3906         /* psta = rtw_alloc_stainfo(pstapriv, param->sta_addr); */
3907         psta = rtw_get_stainfo(pstapriv, param->sta_addr);
3908         if (psta) {
3909                 int flags = param->u.add_sta.flags;
3910
3911                 /* DBG_871X("rtw_add_sta(), init sta's variables, psta =%p\n", psta); */
3912
3913                 psta->aid = param->u.add_sta.aid;/* aid = 1~2007 */
3914
3915                 memcpy(psta->bssrateset, param->u.add_sta.tx_supp_rates, 16);
3916
3917
3918                 /* check wmm cap. */
3919                 if (WLAN_STA_WME&flags)
3920                         psta->qos_option = 1;
3921                 else
3922                         psta->qos_option = 0;
3923
3924                 if (pmlmepriv->qospriv.qos_option == 0)
3925                         psta->qos_option = 0;
3926
3927                 /* chec 802.11n ht cap. */
3928                 if (WLAN_STA_HT&flags) {
3929                         psta->htpriv.ht_option = true;
3930                         psta->qos_option = 1;
3931                         memcpy((void*)&psta->htpriv.ht_cap, (void*)&param->u.add_sta.ht_cap, sizeof(struct rtw_ieee80211_ht_cap));
3932                 } else {
3933                         psta->htpriv.ht_option = false;
3934                 }
3935
3936                 if (pmlmepriv->htpriv.ht_option == false)
3937                         psta->htpriv.ht_option = false;
3938
3939                 update_sta_info_apmode(padapter, psta);
3940
3941
3942         } else {
3943                 ret = -ENOMEM;
3944         }
3945
3946         return ret;
3947
3948 }
3949
3950 static int rtw_del_sta(struct net_device *dev, struct ieee_param *param)
3951 {
3952         int ret = 0;
3953         struct sta_info *psta = NULL;
3954         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
3955         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3956         struct sta_priv *pstapriv = &padapter->stapriv;
3957
3958         DBG_871X("rtw_del_sta =" MAC_FMT "\n", MAC_ARG(param->sta_addr));
3959
3960         if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true)
3961                 return -EINVAL;
3962
3963         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
3964             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
3965             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
3966                 return -EINVAL;
3967         }
3968
3969         psta = rtw_get_stainfo(pstapriv, param->sta_addr);
3970         if (psta) {
3971                 u8 updated =false;
3972
3973                 /* DBG_871X("free psta =%p, aid =%d\n", psta, psta->aid); */
3974
3975                 spin_lock_bh(&pstapriv->asoc_list_lock);
3976                 if (list_empty(&psta->asoc_list) ==false) {
3977                         list_del_init(&psta->asoc_list);
3978                         pstapriv->asoc_list_cnt--;
3979                         updated = ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING);
3980
3981                 }
3982                 spin_unlock_bh(&pstapriv->asoc_list_lock);
3983
3984                 associated_clients_update(padapter, updated);
3985
3986                 psta = NULL;
3987
3988         } else {
3989                 DBG_871X("rtw_del_sta(), sta has already been removed or never been added\n");
3990
3991                 /* ret = -1; */
3992         }
3993
3994
3995         return ret;
3996
3997 }
3998
3999 static int rtw_ioctl_get_sta_data(struct net_device *dev, struct ieee_param *param, int len)
4000 {
4001         int ret = 0;
4002         struct sta_info *psta = NULL;
4003         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4004         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4005         struct sta_priv *pstapriv = &padapter->stapriv;
4006         struct ieee_param_ex *param_ex = (struct ieee_param_ex *)param;
4007         struct sta_data *psta_data = (struct sta_data *)param_ex->data;
4008
4009         DBG_871X("rtw_ioctl_get_sta_info, sta_addr: " MAC_FMT "\n", MAC_ARG(param_ex->sta_addr));
4010
4011         if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true)
4012                 return -EINVAL;
4013
4014         if (param_ex->sta_addr[0] == 0xff && param_ex->sta_addr[1] == 0xff &&
4015             param_ex->sta_addr[2] == 0xff && param_ex->sta_addr[3] == 0xff &&
4016             param_ex->sta_addr[4] == 0xff && param_ex->sta_addr[5] == 0xff) {
4017                 return -EINVAL;
4018         }
4019
4020         psta = rtw_get_stainfo(pstapriv, param_ex->sta_addr);
4021         if (psta) {
4022                 psta_data->aid = (u16)psta->aid;
4023                 psta_data->capability = psta->capability;
4024                 psta_data->flags = psta->flags;
4025
4026 /*
4027                 nonerp_set : BIT(0)
4028                 no_short_slot_time_set : BIT(1)
4029                 no_short_preamble_set : BIT(2)
4030                 no_ht_gf_set : BIT(3)
4031                 no_ht_set : BIT(4)
4032                 ht_20mhz_set : BIT(5)
4033 */
4034
4035                 psta_data->sta_set =((psta->nonerp_set) |
4036                                                         (psta->no_short_slot_time_set <<1) |
4037                                                         (psta->no_short_preamble_set <<2) |
4038                                                         (psta->no_ht_gf_set <<3) |
4039                                                         (psta->no_ht_set <<4) |
4040                                                         (psta->ht_20mhz_set <<5));
4041
4042                 psta_data->tx_supp_rates_len =  psta->bssratelen;
4043                 memcpy(psta_data->tx_supp_rates, psta->bssrateset, psta->bssratelen);
4044                 memcpy(&psta_data->ht_cap, &psta->htpriv.ht_cap, sizeof(struct rtw_ieee80211_ht_cap));
4045                 psta_data->rx_pkts = psta->sta_stats.rx_data_pkts;
4046                 psta_data->rx_bytes = psta->sta_stats.rx_bytes;
4047                 psta_data->rx_drops = psta->sta_stats.rx_drops;
4048
4049                 psta_data->tx_pkts = psta->sta_stats.tx_pkts;
4050                 psta_data->tx_bytes = psta->sta_stats.tx_bytes;
4051                 psta_data->tx_drops = psta->sta_stats.tx_drops;
4052
4053
4054         } else {
4055                 ret = -1;
4056         }
4057
4058         return ret;
4059
4060 }
4061
4062 static int rtw_get_sta_wpaie(struct net_device *dev, struct ieee_param *param)
4063 {
4064         int ret = 0;
4065         struct sta_info *psta = NULL;
4066         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4067         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4068         struct sta_priv *pstapriv = &padapter->stapriv;
4069
4070         DBG_871X("rtw_get_sta_wpaie, sta_addr: " MAC_FMT "\n", MAC_ARG(param->sta_addr));
4071
4072         if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true)
4073                 return -EINVAL;
4074
4075         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
4076             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
4077             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
4078                 return -EINVAL;
4079         }
4080
4081         psta = rtw_get_stainfo(pstapriv, param->sta_addr);
4082         if (psta) {
4083                 if ((psta->wpa_ie[0] == WLAN_EID_RSN) || (psta->wpa_ie[0] == WLAN_EID_GENERIC)) {
4084                         int wpa_ie_len;
4085                         int copy_len;
4086
4087                         wpa_ie_len = psta->wpa_ie[1];
4088
4089                         copy_len = ((wpa_ie_len+2) > sizeof(psta->wpa_ie)) ? (sizeof(psta->wpa_ie)):(wpa_ie_len+2);
4090
4091                         param->u.wpa_ie.len = copy_len;
4092
4093                         memcpy(param->u.wpa_ie.reserved, psta->wpa_ie, copy_len);
4094                 } else {
4095                         /* ret = -1; */
4096                         DBG_871X("sta's wpa_ie is NONE\n");
4097                 }
4098         } else {
4099                 ret = -1;
4100         }
4101
4102         return ret;
4103
4104 }
4105
4106 static int rtw_set_wps_beacon(struct net_device *dev, struct ieee_param *param, int len)
4107 {
4108         int ret = 0;
4109         unsigned char wps_oui[4]={0x0, 0x50, 0xf2, 0x04};
4110         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4111         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4112         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
4113         int ie_len;
4114
4115         DBG_871X("%s, len =%d\n", __func__, len);
4116
4117         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
4118                 return -EINVAL;
4119
4120         ie_len = len-12-2;/*  12 = param header, 2:no packed */
4121
4122
4123         kfree(pmlmepriv->wps_beacon_ie);
4124         pmlmepriv->wps_beacon_ie = NULL;
4125
4126         if (ie_len>0) {
4127                 pmlmepriv->wps_beacon_ie = rtw_malloc(ie_len);
4128                 pmlmepriv->wps_beacon_ie_len = ie_len;
4129                 if (pmlmepriv->wps_beacon_ie == NULL) {
4130                         DBG_871X("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
4131                         return -EINVAL;
4132                 }
4133
4134                 memcpy(pmlmepriv->wps_beacon_ie, param->u.bcn_ie.buf, ie_len);
4135
4136                 update_beacon(padapter, _VENDOR_SPECIFIC_IE_, wps_oui, true);
4137
4138                 pmlmeext->bstart_bss = true;
4139         }
4140
4141
4142         return ret;
4143
4144 }
4145
4146 static int rtw_set_wps_probe_resp(struct net_device *dev, struct ieee_param *param, int len)
4147 {
4148         int ret = 0;
4149         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4150         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4151         int ie_len;
4152
4153         DBG_871X("%s, len =%d\n", __func__, len);
4154
4155         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
4156                 return -EINVAL;
4157
4158         ie_len = len-12-2;/*  12 = param header, 2:no packed */
4159
4160
4161         kfree(pmlmepriv->wps_probe_resp_ie);
4162         pmlmepriv->wps_probe_resp_ie = NULL;
4163
4164         if (ie_len>0) {
4165                 pmlmepriv->wps_probe_resp_ie = rtw_malloc(ie_len);
4166                 pmlmepriv->wps_probe_resp_ie_len = ie_len;
4167                 if (pmlmepriv->wps_probe_resp_ie == NULL) {
4168                         DBG_871X("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
4169                         return -EINVAL;
4170                 }
4171                 memcpy(pmlmepriv->wps_probe_resp_ie, param->u.bcn_ie.buf, ie_len);
4172         }
4173
4174
4175         return ret;
4176
4177 }
4178
4179 static int rtw_set_wps_assoc_resp(struct net_device *dev, struct ieee_param *param, int len)
4180 {
4181         int ret = 0;
4182         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4183         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4184         int ie_len;
4185
4186         DBG_871X("%s, len =%d\n", __func__, len);
4187
4188         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
4189                 return -EINVAL;
4190
4191         ie_len = len-12-2;/*  12 = param header, 2:no packed */
4192
4193
4194         kfree(pmlmepriv->wps_assoc_resp_ie);
4195         pmlmepriv->wps_assoc_resp_ie = NULL;
4196
4197         if (ie_len>0) {
4198                 pmlmepriv->wps_assoc_resp_ie = rtw_malloc(ie_len);
4199                 pmlmepriv->wps_assoc_resp_ie_len = ie_len;
4200                 if (pmlmepriv->wps_assoc_resp_ie == NULL) {
4201                         DBG_871X("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
4202                         return -EINVAL;
4203                 }
4204
4205                 memcpy(pmlmepriv->wps_assoc_resp_ie, param->u.bcn_ie.buf, ie_len);
4206         }
4207
4208
4209         return ret;
4210
4211 }
4212
4213 static int rtw_set_hidden_ssid(struct net_device *dev, struct ieee_param *param, int len)
4214 {
4215         int ret = 0;
4216         struct adapter *adapter = (struct adapter *)rtw_netdev_priv(dev);
4217         struct mlme_priv *mlmepriv = &(adapter->mlmepriv);
4218         struct mlme_ext_priv *mlmeext = &(adapter->mlmeextpriv);
4219         struct mlme_ext_info *mlmeinfo = &(mlmeext->mlmext_info);
4220         int ie_len;
4221         u8 *ssid_ie;
4222         char ssid[NDIS_802_11_LENGTH_SSID + 1];
4223         sint ssid_len;
4224         u8 ignore_broadcast_ssid;
4225
4226         if (check_fwstate(mlmepriv, WIFI_AP_STATE) != true)
4227                 return -EPERM;
4228
4229         if (param->u.bcn_ie.reserved[0] != 0xea)
4230                 return -EINVAL;
4231
4232         mlmeinfo->hidden_ssid_mode = ignore_broadcast_ssid = param->u.bcn_ie.reserved[1];
4233
4234         ie_len = len-12-2;/*  12 = param header, 2:no packed */
4235         ssid_ie = rtw_get_ie(param->u.bcn_ie.buf,  WLAN_EID_SSID, &ssid_len, ie_len);
4236
4237         if (ssid_ie && ssid_len > 0 && ssid_len <= NDIS_802_11_LENGTH_SSID) {
4238                 struct wlan_bssid_ex *pbss_network = &mlmepriv->cur_network.network;
4239                 struct wlan_bssid_ex *pbss_network_ext = &mlmeinfo->network;
4240
4241                 memcpy(ssid, ssid_ie+2, ssid_len);
4242                 ssid[ssid_len] = 0x0;
4243
4244                 if (0)
4245                         DBG_871X(FUNC_ADPT_FMT" ssid:(%s,%d), from ie:(%s,%d), (%s,%d)\n", FUNC_ADPT_ARG(adapter),
4246                                  ssid, ssid_len,
4247                                  pbss_network->Ssid.Ssid, pbss_network->Ssid.SsidLength,
4248                                  pbss_network_ext->Ssid.Ssid, pbss_network_ext->Ssid.SsidLength);
4249
4250                 memcpy(pbss_network->Ssid.Ssid, (void *)ssid, ssid_len);
4251                 pbss_network->Ssid.SsidLength = ssid_len;
4252                 memcpy(pbss_network_ext->Ssid.Ssid, (void *)ssid, ssid_len);
4253                 pbss_network_ext->Ssid.SsidLength = ssid_len;
4254
4255                 if (0)
4256                         DBG_871X(FUNC_ADPT_FMT" after ssid:(%s,%d), (%s,%d)\n", FUNC_ADPT_ARG(adapter),
4257                                  pbss_network->Ssid.Ssid, pbss_network->Ssid.SsidLength,
4258                                  pbss_network_ext->Ssid.Ssid, pbss_network_ext->Ssid.SsidLength);
4259         }
4260
4261         DBG_871X(FUNC_ADPT_FMT" ignore_broadcast_ssid:%d, %s,%d\n", FUNC_ADPT_ARG(adapter),
4262                 ignore_broadcast_ssid, ssid, ssid_len);
4263
4264         return ret;
4265 }
4266
4267 static int rtw_ioctl_acl_remove_sta(struct net_device *dev, struct ieee_param *param, int len)
4268 {
4269         int ret = 0;
4270         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4271         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4272
4273         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
4274                 return -EINVAL;
4275
4276         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
4277             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
4278             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
4279                 return -EINVAL;
4280         }
4281
4282         ret = rtw_acl_remove_sta(padapter, param->sta_addr);
4283
4284         return ret;
4285
4286 }
4287
4288 static int rtw_ioctl_acl_add_sta(struct net_device *dev, struct ieee_param *param, int len)
4289 {
4290         int ret = 0;
4291         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4292         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4293
4294         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
4295                 return -EINVAL;
4296
4297         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
4298             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
4299             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
4300                 return -EINVAL;
4301         }
4302
4303         ret = rtw_acl_add_sta(padapter, param->sta_addr);
4304
4305         return ret;
4306
4307 }
4308
4309 static int rtw_ioctl_set_macaddr_acl(struct net_device *dev, struct ieee_param *param, int len)
4310 {
4311         int ret = 0;
4312         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4313         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4314
4315         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
4316                 return -EINVAL;
4317
4318         rtw_set_macaddr_acl(padapter, param->u.mlme.command);
4319
4320         return ret;
4321 }
4322
4323 static int rtw_hostapd_ioctl(struct net_device *dev, struct iw_point *p)
4324 {
4325         struct ieee_param *param;
4326         int ret = 0;
4327         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4328
4329         /* DBG_871X("%s\n", __func__); */
4330
4331         /*
4332         * this function is expect to call in master mode, which allows no power saving
4333         * so, we just check hw_init_completed
4334         */
4335
4336         if (padapter->hw_init_completed ==false) {
4337                 ret = -EPERM;
4338                 goto out;
4339         }
4340
4341
4342         /* if (p->length < sizeof(struct ieee_param) || !p->pointer) { */
4343         if (!p->pointer || p->length != sizeof(*param)) {
4344                 ret = -EINVAL;
4345                 goto out;
4346         }
4347
4348         param = (struct ieee_param *)rtw_malloc(p->length);
4349         if (param == NULL) {
4350                 ret = -ENOMEM;
4351                 goto out;
4352         }
4353
4354         if (copy_from_user(param, p->pointer, p->length)) {
4355                 kfree(param);
4356                 ret = -EFAULT;
4357                 goto out;
4358         }
4359
4360         /* DBG_871X("%s, cmd =%d\n", __func__, param->cmd); */
4361
4362         switch (param->cmd) {
4363                 case RTL871X_HOSTAPD_FLUSH:
4364
4365                         ret = rtw_hostapd_sta_flush(dev);
4366
4367                         break;
4368
4369                 case RTL871X_HOSTAPD_ADD_STA:
4370
4371                         ret = rtw_add_sta(dev, param);
4372
4373                         break;
4374
4375                 case RTL871X_HOSTAPD_REMOVE_STA:
4376
4377                         ret = rtw_del_sta(dev, param);
4378
4379                         break;
4380
4381                 case RTL871X_HOSTAPD_SET_BEACON:
4382
4383                         ret = rtw_set_beacon(dev, param, p->length);
4384
4385                         break;
4386
4387                 case RTL871X_SET_ENCRYPTION:
4388
4389                         ret = rtw_set_encryption(dev, param, p->length);
4390
4391                         break;
4392
4393                 case RTL871X_HOSTAPD_GET_WPAIE_STA:
4394
4395                         ret = rtw_get_sta_wpaie(dev, param);
4396
4397                         break;
4398
4399                 case RTL871X_HOSTAPD_SET_WPS_BEACON:
4400
4401                         ret = rtw_set_wps_beacon(dev, param, p->length);
4402
4403                         break;
4404
4405                 case RTL871X_HOSTAPD_SET_WPS_PROBE_RESP:
4406
4407                         ret = rtw_set_wps_probe_resp(dev, param, p->length);
4408
4409                         break;
4410
4411                 case RTL871X_HOSTAPD_SET_WPS_ASSOC_RESP:
4412
4413                         ret = rtw_set_wps_assoc_resp(dev, param, p->length);
4414
4415                         break;
4416
4417                 case RTL871X_HOSTAPD_SET_HIDDEN_SSID:
4418
4419                         ret = rtw_set_hidden_ssid(dev, param, p->length);
4420
4421                         break;
4422
4423                 case RTL871X_HOSTAPD_GET_INFO_STA:
4424
4425                         ret = rtw_ioctl_get_sta_data(dev, param, p->length);
4426
4427                         break;
4428
4429                 case RTL871X_HOSTAPD_SET_MACADDR_ACL:
4430
4431                         ret = rtw_ioctl_set_macaddr_acl(dev, param, p->length);
4432
4433                         break;
4434
4435                 case RTL871X_HOSTAPD_ACL_ADD_STA:
4436
4437                         ret = rtw_ioctl_acl_add_sta(dev, param, p->length);
4438
4439                         break;
4440
4441                 case RTL871X_HOSTAPD_ACL_REMOVE_STA:
4442
4443                         ret = rtw_ioctl_acl_remove_sta(dev, param, p->length);
4444
4445                         break;
4446
4447                 default:
4448                         DBG_871X("Unknown hostapd request: %d\n", param->cmd);
4449                         ret = -EOPNOTSUPP;
4450                         break;
4451
4452         }
4453
4454         if (ret == 0 && copy_to_user(p->pointer, param, p->length))
4455                 ret = -EFAULT;
4456
4457
4458         kfree(param);
4459
4460 out:
4461
4462         return ret;
4463
4464 }
4465
4466 static int rtw_wx_set_priv(struct net_device *dev,
4467                                 struct iw_request_info *info,
4468                                 union iwreq_data *awrq,
4469                                 char *extra)
4470 {
4471
4472 #ifdef DEBUG_RTW_WX_SET_PRIV
4473         char *ext_dbg;
4474 #endif
4475
4476         int ret = 0;
4477         int len = 0;
4478         char *ext;
4479
4480         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4481         struct iw_point *dwrq = (struct iw_point*)awrq;
4482
4483         /* RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_notice_, ("+rtw_wx_set_priv\n")); */
4484         if (dwrq->length == 0)
4485                 return -EFAULT;
4486
4487         len = dwrq->length;
4488         if (!(ext = vmalloc(len)))
4489                 return -ENOMEM;
4490
4491         if (copy_from_user(ext, dwrq->pointer, len)) {
4492                 vfree(ext);
4493                 return -EFAULT;
4494         }
4495
4496
4497         /* RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_notice_, */
4498         /*       ("rtw_wx_set_priv: %s req =%s\n", */
4499         /*        dev->name, ext)); */
4500
4501         #ifdef DEBUG_RTW_WX_SET_PRIV
4502         if (!(ext_dbg = vmalloc(len))) {
4503                 vfree(ext, len);
4504                 return -ENOMEM;
4505         }
4506
4507         memcpy(ext_dbg, ext, len);
4508         #endif
4509
4510         /* added for wps2.0 @20110524 */
4511         if (dwrq->flags == 0x8766 && len > 8) {
4512                 u32 cp_sz;
4513                 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4514                 u8 *probereq_wpsie = ext;
4515                 int probereq_wpsie_len = len;
4516                 u8 wps_oui[4]={0x0, 0x50, 0xf2, 0x04};
4517
4518                 if ((_VENDOR_SPECIFIC_IE_ == probereq_wpsie[0]) &&
4519                         (!memcmp(&probereq_wpsie[2], wps_oui, 4))) {
4520                         cp_sz = probereq_wpsie_len>MAX_WPS_IE_LEN ? MAX_WPS_IE_LEN:probereq_wpsie_len;
4521
4522                         if (pmlmepriv->wps_probe_req_ie) {
4523                                 pmlmepriv->wps_probe_req_ie_len = 0;
4524                                 kfree(pmlmepriv->wps_probe_req_ie);
4525                                 pmlmepriv->wps_probe_req_ie = NULL;
4526                         }
4527
4528                         pmlmepriv->wps_probe_req_ie = rtw_malloc(cp_sz);
4529                         if (pmlmepriv->wps_probe_req_ie == NULL) {
4530                                 printk("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
4531                                 ret =  -EINVAL;
4532                                 goto FREE_EXT;
4533
4534                         }
4535
4536                         memcpy(pmlmepriv->wps_probe_req_ie, probereq_wpsie, cp_sz);
4537                         pmlmepriv->wps_probe_req_ie_len = cp_sz;
4538
4539                 }
4540
4541                 goto FREE_EXT;
4542
4543         }
4544
4545         if (len >= WEXT_CSCAN_HEADER_SIZE
4546                 && !memcmp(ext, WEXT_CSCAN_HEADER, WEXT_CSCAN_HEADER_SIZE)) {
4547                 ret = rtw_wx_set_scan(dev, info, awrq, ext);
4548                 goto FREE_EXT;
4549         }
4550
4551 FREE_EXT:
4552
4553         vfree(ext);
4554         #ifdef DEBUG_RTW_WX_SET_PRIV
4555         vfree(ext_dbg);
4556         #endif
4557
4558         /* DBG_871X("rtw_wx_set_priv: (SIOCSIWPRIV) %s ret =%d\n", */
4559         /*              dev->name, ret); */
4560
4561         return ret;
4562
4563 }
4564
4565 static int rtw_pm_set(struct net_device *dev,
4566                                struct iw_request_info *info,
4567                                union iwreq_data *wrqu, char *extra)
4568 {
4569         int ret = 0;
4570         unsigned        mode = 0;
4571         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4572
4573         DBG_871X("[%s] extra = %s\n", __func__, extra);
4574
4575         if (!memcmp(extra, "lps =", 4)) {
4576                 sscanf(extra+4, "%u", &mode);
4577                 ret = rtw_pm_set_lps(padapter, mode);
4578         } else if (!memcmp(extra, "ips =", 4)) {
4579                 sscanf(extra+4, "%u", &mode);
4580                 ret = rtw_pm_set_ips(padapter, mode);
4581         } else {
4582                 ret = -EINVAL;
4583         }
4584
4585         return ret;
4586 }
4587
4588 static int rtw_mp_efuse_get(struct net_device *dev,
4589                         struct iw_request_info *info,
4590                         union iwreq_data *wdata, char *extra)
4591 {
4592         int err = 0;
4593         return err;
4594 }
4595
4596 static int rtw_mp_efuse_set(struct net_device *dev,
4597                         struct iw_request_info *info,
4598                         union iwreq_data *wdata, char *extra)
4599 {
4600         int err = 0;
4601         return err;
4602 }
4603
4604 static int rtw_tdls(struct net_device *dev,
4605                                 struct iw_request_info *info,
4606                                 union iwreq_data *wrqu, char *extra)
4607 {
4608         int ret = 0;
4609         return ret;
4610 }
4611
4612
4613 static int rtw_tdls_get(struct net_device *dev,
4614                                 struct iw_request_info *info,
4615                                 union iwreq_data *wrqu, char *extra)
4616 {
4617         int ret = 0;
4618         return ret;
4619 }
4620
4621
4622
4623
4624
4625 #ifdef CONFIG_INTEL_WIDI
4626 static int rtw_widi_set(struct net_device *dev,
4627                                struct iw_request_info *info,
4628                                union iwreq_data *wrqu, char *extra)
4629 {
4630         int ret = 0;
4631         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4632
4633         process_intel_widi_cmd(padapter, extra);
4634
4635         return ret;
4636 }
4637
4638 static int rtw_widi_set_probe_request(struct net_device *dev,
4639                                struct iw_request_info *info,
4640                                union iwreq_data *wrqu, char *extra)
4641 {
4642         int     ret = 0;
4643         u8 *pbuf = NULL;
4644         struct adapter  *padapter = (struct adapter *)rtw_netdev_priv(dev);
4645
4646         pbuf = rtw_malloc(sizeof(l2_msg_t));
4647         if (pbuf) {
4648                 if (copy_from_user(pbuf, wrqu->data.pointer, wrqu->data.length))
4649                         ret = -EFAULT;
4650                 /* memcpy(pbuf, wrqu->data.pointer, wrqu->data.length); */
4651
4652                 if (wrqu->data.flags == 0)
4653                         intel_widi_wk_cmd(padapter, INTEL_WIDI_ISSUE_PROB_WK, pbuf, sizeof(l2_msg_t));
4654                 else if (wrqu->data.flags == 1)
4655                         rtw_set_wfd_rds_sink_info(padapter, (l2_msg_t *)pbuf);
4656         }
4657         return ret;
4658 }
4659 #endif /*  CONFIG_INTEL_WIDI */
4660
4661 static int rtw_test(
4662         struct net_device *dev,
4663         struct iw_request_info *info,
4664         union iwreq_data *wrqu, char *extra)
4665 {
4666         u32 len;
4667         u8 *pbuf, *pch;
4668         char *ptmp;
4669         u8 *delim = ",";
4670         struct adapter *padapter = rtw_netdev_priv(dev);
4671
4672
4673         DBG_871X("+%s\n", __func__);
4674         len = wrqu->data.length;
4675
4676         pbuf = (u8 *)rtw_zmalloc(len);
4677         if (pbuf == NULL) {
4678                 DBG_871X("%s: no memory!\n", __func__);
4679                 return -ENOMEM;
4680         }
4681
4682         if (copy_from_user(pbuf, wrqu->data.pointer, len)) {
4683                 kfree(pbuf);
4684                 DBG_871X("%s: copy from user fail!\n", __func__);
4685                 return -EFAULT;
4686         }
4687         DBG_871X("%s: string =\"%s\"\n", __func__, pbuf);
4688
4689         ptmp = (char*)pbuf;
4690         pch = strsep(&ptmp, delim);
4691         if ((pch == NULL) || (strlen(pch) == 0)) {
4692                 kfree(pbuf);
4693                 DBG_871X("%s: parameter error(level 1)!\n", __func__);
4694                 return -EFAULT;
4695         }
4696
4697         if (strcmp(pch, "bton") == 0)
4698                 rtw_btcoex_SetManualControl(padapter, false);
4699
4700         if (strcmp(pch, "btoff") == 0)
4701                 rtw_btcoex_SetManualControl(padapter, true);
4702
4703         if (strcmp(pch, "h2c") == 0) {
4704                 u8 param[8];
4705                 u8 count = 0;
4706                 u32 tmp;
4707                 u8 i;
4708                 u32 pos;
4709                 s32 ret;
4710
4711
4712                 do {
4713                         pch = strsep(&ptmp, delim);
4714                         if ((pch == NULL) || (strlen(pch) == 0))
4715                                 break;
4716
4717                         sscanf(pch, "%x", &tmp);
4718                         param[count++] = (u8)tmp;
4719                 } while (count < 8);
4720
4721                 if (count == 0) {
4722                         kfree(pbuf);
4723                         DBG_871X("%s: parameter error(level 2)!\n", __func__);
4724                         return -EFAULT;
4725                 }
4726
4727                 ret = rtw_hal_fill_h2c_cmd(padapter, param[0], count-1, &param[1]);
4728
4729                 pos = sprintf(extra, "H2C ID = 0x%02x content =", param[0]);
4730                 for (i = 1; i<count; i++)
4731                         pos += sprintf(extra+pos, "%02x,", param[i]);
4732                 extra[pos] = 0;
4733                 pos--;
4734                 pos += sprintf(extra+pos, " %s", ret == _FAIL?"FAIL":"OK");
4735
4736                 wrqu->data.length = strlen(extra) + 1;
4737         }
4738
4739         kfree(pbuf);
4740         return 0;
4741 }
4742
4743 static iw_handler rtw_handlers[] = {
4744         NULL,                                   /* SIOCSIWCOMMIT */
4745         rtw_wx_get_name,                /* SIOCGIWNAME */
4746         dummy,                                  /* SIOCSIWNWID */
4747         dummy,                                  /* SIOCGIWNWID */
4748         rtw_wx_set_freq,                /* SIOCSIWFREQ */
4749         rtw_wx_get_freq,                /* SIOCGIWFREQ */
4750         rtw_wx_set_mode,                /* SIOCSIWMODE */
4751         rtw_wx_get_mode,                /* SIOCGIWMODE */
4752         dummy,                                  /* SIOCSIWSENS */
4753         rtw_wx_get_sens,                /* SIOCGIWSENS */
4754         NULL,                                   /* SIOCSIWRANGE */
4755         rtw_wx_get_range,               /* SIOCGIWRANGE */
4756         rtw_wx_set_priv,                /* SIOCSIWPRIV */
4757         NULL,                                   /* SIOCGIWPRIV */
4758         NULL,                                   /* SIOCSIWSTATS */
4759         NULL,                                   /* SIOCGIWSTATS */
4760         dummy,                                  /* SIOCSIWSPY */
4761         dummy,                                  /* SIOCGIWSPY */
4762         NULL,                                   /* SIOCGIWTHRSPY */
4763         NULL,                                   /* SIOCWIWTHRSPY */
4764         rtw_wx_set_wap,         /* SIOCSIWAP */
4765         rtw_wx_get_wap,         /* SIOCGIWAP */
4766         rtw_wx_set_mlme,                /* request MLME operation; uses struct iw_mlme */
4767         dummy,                                  /* SIOCGIWAPLIST -- depricated */
4768         rtw_wx_set_scan,                /* SIOCSIWSCAN */
4769         rtw_wx_get_scan,                /* SIOCGIWSCAN */
4770         rtw_wx_set_essid,               /* SIOCSIWESSID */
4771         rtw_wx_get_essid,               /* SIOCGIWESSID */
4772         dummy,                                  /* SIOCSIWNICKN */
4773         rtw_wx_get_nick,                /* SIOCGIWNICKN */
4774         NULL,                                   /* -- hole -- */
4775         NULL,                                   /* -- hole -- */
4776         rtw_wx_set_rate,                /* SIOCSIWRATE */
4777         rtw_wx_get_rate,                /* SIOCGIWRATE */
4778         rtw_wx_set_rts,                 /* SIOCSIWRTS */
4779         rtw_wx_get_rts,                 /* SIOCGIWRTS */
4780         rtw_wx_set_frag,                /* SIOCSIWFRAG */
4781         rtw_wx_get_frag,                /* SIOCGIWFRAG */
4782         dummy,                                  /* SIOCSIWTXPOW */
4783         dummy,                                  /* SIOCGIWTXPOW */
4784         dummy,                                  /* SIOCSIWRETRY */
4785         rtw_wx_get_retry,               /* SIOCGIWRETRY */
4786         rtw_wx_set_enc,                 /* SIOCSIWENCODE */
4787         rtw_wx_get_enc,                 /* SIOCGIWENCODE */
4788         dummy,                                  /* SIOCSIWPOWER */
4789         rtw_wx_get_power,               /* SIOCGIWPOWER */
4790         NULL,                                   /*---hole---*/
4791         NULL,                                   /*---hole---*/
4792         rtw_wx_set_gen_ie,              /* SIOCSIWGENIE */
4793         NULL,                                   /* SIOCGWGENIE */
4794         rtw_wx_set_auth,                /* SIOCSIWAUTH */
4795         NULL,                                   /* SIOCGIWAUTH */
4796         rtw_wx_set_enc_ext,             /* SIOCSIWENCODEEXT */
4797         NULL,                                   /* SIOCGIWENCODEEXT */
4798         rtw_wx_set_pmkid,               /* SIOCSIWPMKSA */
4799         NULL,                                   /*---hole---*/
4800 };
4801
4802 static const struct iw_priv_args rtw_private_args[] = {
4803         {
4804                 SIOCIWFIRSTPRIV + 0x0,
4805                 IW_PRIV_TYPE_CHAR | 0x7FF, 0, "write"
4806         },
4807         {
4808                 SIOCIWFIRSTPRIV + 0x1,
4809                 IW_PRIV_TYPE_CHAR | 0x7FF,
4810                 IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "read"
4811         },
4812         {
4813                 SIOCIWFIRSTPRIV + 0x2, 0, 0, "driver_ext"
4814         },
4815         {
4816                 SIOCIWFIRSTPRIV + 0x3, 0, 0, "mp_ioctl"
4817         },
4818         {
4819                 SIOCIWFIRSTPRIV + 0x4,
4820                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "apinfo"
4821         },
4822         {
4823                 SIOCIWFIRSTPRIV + 0x5,
4824                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "setpid"
4825         },
4826         {
4827                 SIOCIWFIRSTPRIV + 0x6,
4828                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_start"
4829         },
4830 /* for PLATFORM_MT53XX */
4831         {
4832                 SIOCIWFIRSTPRIV + 0x7,
4833                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "get_sensitivity"
4834         },
4835         {
4836                 SIOCIWFIRSTPRIV + 0x8,
4837                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_prob_req_ie"
4838         },
4839         {
4840                 SIOCIWFIRSTPRIV + 0x9,
4841                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_assoc_req_ie"
4842         },
4843
4844 /* for RTK_DMP_PLATFORM */
4845         {
4846                 SIOCIWFIRSTPRIV + 0xA,
4847                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "channel_plan"
4848         },
4849
4850         {
4851                 SIOCIWFIRSTPRIV + 0xB,
4852                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "dbg"
4853         },
4854         {
4855                 SIOCIWFIRSTPRIV + 0xC,
4856                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 3, 0, "rfw"
4857         },
4858         {
4859                 SIOCIWFIRSTPRIV + 0xD,
4860                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "rfr"
4861         },
4862         {
4863                 SIOCIWFIRSTPRIV + 0x10,
4864                 IW_PRIV_TYPE_CHAR | 1024, 0, "p2p_set"
4865         },
4866         {
4867                 SIOCIWFIRSTPRIV + 0x11,
4868                 IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK , "p2p_get"
4869         },
4870         {
4871                 SIOCIWFIRSTPRIV + 0x12, 0, 0, "NULL"
4872         },
4873         {
4874                 SIOCIWFIRSTPRIV + 0x13,
4875                 IW_PRIV_TYPE_CHAR | 64, IW_PRIV_TYPE_CHAR | 64 , "p2p_get2"
4876         },
4877         {
4878                 SIOCIWFIRSTPRIV + 0x14,
4879                 IW_PRIV_TYPE_CHAR  | 64, 0, "tdls"
4880         },
4881         {
4882                 SIOCIWFIRSTPRIV + 0x15,
4883                 IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | 1024 , "tdls_get"
4884         },
4885         {
4886                 SIOCIWFIRSTPRIV + 0x16,
4887                 IW_PRIV_TYPE_CHAR | 64, 0, "pm_set"
4888         },
4889
4890         {SIOCIWFIRSTPRIV + 0x18, IW_PRIV_TYPE_CHAR | IFNAMSIZ , 0 , "rereg_nd_name"},
4891         {SIOCIWFIRSTPRIV + 0x1A, IW_PRIV_TYPE_CHAR | 1024, 0, "efuse_set"},
4892         {SIOCIWFIRSTPRIV + 0x1B, IW_PRIV_TYPE_CHAR | 128, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "efuse_get"},
4893         {
4894                 SIOCIWFIRSTPRIV + 0x1D,
4895                 IW_PRIV_TYPE_CHAR | 40, IW_PRIV_TYPE_CHAR | 0x7FF, "test"
4896         },
4897
4898 #ifdef CONFIG_INTEL_WIDI
4899         {
4900                 SIOCIWFIRSTPRIV + 0x1E,
4901                 IW_PRIV_TYPE_CHAR | 1024, 0, "widi_set"
4902         },
4903         {
4904                 SIOCIWFIRSTPRIV + 0x1F,
4905                 IW_PRIV_TYPE_CHAR | 128, 0, "widi_prob_req"
4906         },
4907 #endif /*  CONFIG_INTEL_WIDI */
4908
4909 #ifdef CONFIG_WOWLAN
4910                 { MP_WOW_ENABLE , IW_PRIV_TYPE_CHAR | 1024, 0, "wow_mode" }, /* set */
4911 #endif
4912 #ifdef CONFIG_AP_WOWLAN
4913                 { MP_AP_WOW_ENABLE , IW_PRIV_TYPE_CHAR | 1024, 0, "ap_wow_mode" }, /* set */
4914 #endif
4915 };
4916
4917 static iw_handler rtw_private_handler[] = {
4918         rtw_wx_write32,                                 /* 0x00 */
4919         rtw_wx_read32,                                  /* 0x01 */
4920         rtw_drvext_hdl,                                 /* 0x02 */
4921         rtw_mp_ioctl_hdl,                               /* 0x03 */
4922
4923 /*  for MM DTV platform */
4924         rtw_get_ap_info,                                        /* 0x04 */
4925
4926         rtw_set_pid,                                            /* 0x05 */
4927         rtw_wps_start,                                  /* 0x06 */
4928
4929 /*  for PLATFORM_MT53XX */
4930         rtw_wx_get_sensitivity,                 /* 0x07 */
4931         rtw_wx_set_mtk_wps_probe_ie,    /* 0x08 */
4932         rtw_wx_set_mtk_wps_ie,                  /* 0x09 */
4933
4934 /*  for RTK_DMP_PLATFORM */
4935 /*  Set Channel depend on the country code */
4936         rtw_wx_set_channel_plan,                /* 0x0A */
4937
4938         rtw_dbg_port,                                   /* 0x0B */
4939         rtw_wx_write_rf,                                        /* 0x0C */
4940         rtw_wx_read_rf,                                 /* 0x0D */
4941         rtw_wx_priv_null,                               /* 0x0E */
4942         rtw_wx_priv_null,                               /* 0x0F */
4943         rtw_p2p_set,                                    /* 0x10 */
4944         rtw_p2p_get,                                    /* 0x11 */
4945         NULL,                                                   /* 0x12 */
4946         rtw_p2p_get2,                                   /* 0x13 */
4947
4948         rtw_tdls,                                               /* 0x14 */
4949         rtw_tdls_get,                                   /* 0x15 */
4950
4951         rtw_pm_set,                                             /* 0x16 */
4952         rtw_wx_priv_null,                               /* 0x17 */
4953         rtw_rereg_nd_name,                              /* 0x18 */
4954         rtw_wx_priv_null,                               /* 0x19 */
4955         rtw_mp_efuse_set,                               /* 0x1A */
4956         rtw_mp_efuse_get,                               /* 0x1B */
4957         NULL,                                                   /*  0x1C is reserved for hostapd */
4958         rtw_test,                                               /*  0x1D */
4959 #ifdef CONFIG_INTEL_WIDI
4960         rtw_widi_set,                                   /* 0x1E */
4961         rtw_widi_set_probe_request,             /* 0x1F */
4962 #endif /*  CONFIG_INTEL_WIDI */
4963 };
4964
4965 static struct iw_statistics *rtw_get_wireless_stats(struct net_device *dev)
4966 {
4967         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4968         struct iw_statistics *piwstats =&padapter->iwstats;
4969         int tmp_level = 0;
4970         int tmp_qual = 0;
4971         int tmp_noise = 0;
4972
4973         if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) != true) {
4974                 piwstats->qual.qual = 0;
4975                 piwstats->qual.level = 0;
4976                 piwstats->qual.noise = 0;
4977                 /* DBG_871X("No link  level:%d, qual:%d, noise:%d\n", tmp_level, tmp_qual, tmp_noise); */
4978         } else {
4979                 #ifdef CONFIG_SIGNAL_DISPLAY_DBM
4980                 tmp_level = translate_percentage_to_dbm(padapter->recvpriv.signal_strength);
4981                 #else
4982                 #ifdef CONFIG_SKIP_SIGNAL_SCALE_MAPPING
4983                 {
4984                         /* Do signal scale mapping when using percentage as the unit of signal strength, since the scale mapping is skipped in odm */
4985
4986                         struct hal_com_data *pHal = GET_HAL_DATA(padapter);
4987
4988                         tmp_level = (u8)odm_SignalScaleMapping(&pHal->odmpriv, padapter->recvpriv.signal_strength);
4989                 }
4990                 #else
4991                 tmp_level = padapter->recvpriv.signal_strength;
4992                 #endif
4993                 #endif
4994
4995                 tmp_qual = padapter->recvpriv.signal_qual;
4996 #if defined(CONFIG_SIGNAL_DISPLAY_DBM) && defined(CONFIG_BACKGROUND_NOISE_MONITOR)
4997                 if (rtw_linked_check(padapter)) {
4998                         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4999                         struct noise_info info;
5000                         info.bPauseDIG = true;
5001                         info.IGIValue = 0x1e;
5002                         info.max_time = 100;/* ms */
5003                         info.chan = pmlmeext->cur_channel ;/* rtw_get_oper_ch(padapter); */
5004                         rtw_ps_deny(padapter, PS_DENY_IOCTL);
5005                         LeaveAllPowerSaveModeDirect(padapter);
5006
5007                         rtw_hal_set_odm_var(padapter, HAL_ODM_NOISE_MONITOR,&info, false);
5008                         /* ODM_InbandNoise_Monitor(podmpriv, true, 0x20, 100); */
5009                         rtw_ps_deny_cancel(padapter, PS_DENY_IOCTL);
5010                         rtw_hal_get_odm_var(padapter, HAL_ODM_NOISE_MONITOR,&(info.chan), &(padapter->recvpriv.noise));
5011                         DBG_871X("chan:%d, noise_level:%d\n", info.chan, padapter->recvpriv.noise);
5012                 }
5013 #endif
5014                 tmp_noise = padapter->recvpriv.noise;
5015                 DBG_871X("level:%d, qual:%d, noise:%d, rssi (%d)\n", tmp_level, tmp_qual, tmp_noise, padapter->recvpriv.rssi);
5016
5017                 piwstats->qual.level = tmp_level;
5018                 piwstats->qual.qual = tmp_qual;
5019                 piwstats->qual.noise = tmp_noise;
5020         }
5021         piwstats->qual.updated = IW_QUAL_ALL_UPDATED ;/* IW_QUAL_DBM; */
5022
5023         #ifdef CONFIG_SIGNAL_DISPLAY_DBM
5024         piwstats->qual.updated = piwstats->qual.updated | IW_QUAL_DBM;
5025         #endif
5026
5027         return &padapter->iwstats;
5028 }
5029
5030 struct iw_handler_def rtw_handlers_def = {
5031         .standard = rtw_handlers,
5032         .num_standard = sizeof(rtw_handlers) / sizeof(iw_handler),
5033 #if defined(CONFIG_WEXT_PRIV)
5034         .private = rtw_private_handler,
5035         .private_args = (struct iw_priv_args *)rtw_private_args,
5036         .num_private = sizeof(rtw_private_handler) / sizeof(iw_handler),
5037         .num_private_args = sizeof(rtw_private_args) / sizeof(struct iw_priv_args),
5038 #endif
5039         .get_wireless_stats = rtw_get_wireless_stats,
5040 };
5041
5042 /*  copy from net/wireless/wext.c start */
5043 /* ---------------------------------------------------------------- */
5044 /*
5045  * Calculate size of private arguments
5046  */
5047 static const char iw_priv_type_size[] = {
5048         0,                              /* IW_PRIV_TYPE_NONE */
5049         1,                              /* IW_PRIV_TYPE_BYTE */
5050         1,                              /* IW_PRIV_TYPE_CHAR */
5051         0,                              /* Not defined */
5052         sizeof(__u32),                  /* IW_PRIV_TYPE_INT */
5053         sizeof(struct iw_freq),         /* IW_PRIV_TYPE_FLOAT */
5054         sizeof(struct sockaddr),        /* IW_PRIV_TYPE_ADDR */
5055         0,                              /* Not defined */
5056 };
5057
5058 static int get_priv_size(__u16 args)
5059 {
5060         int num = args & IW_PRIV_SIZE_MASK;
5061         int type = (args & IW_PRIV_TYPE_MASK) >> 12;
5062
5063         return num * iw_priv_type_size[type];
5064 }
5065 /*  copy from net/wireless/wext.c end */
5066
5067 static int rtw_ioctl_wext_private(struct net_device *dev, union iwreq_data *wrq_data)
5068 {
5069         int err = 0;
5070         u8 *input = NULL;
5071         u32 input_len = 0;
5072         const char delim[] = " ";
5073         u8 *output = NULL;
5074         u32 output_len = 0;
5075         u32 count = 0;
5076         u8 *buffer = NULL;
5077         u32 buffer_len = 0;
5078         char *ptr = NULL;
5079         u8 cmdname[17] = {0}; /*  IFNAMSIZ+1 */
5080         u32 cmdlen;
5081         s32 len;
5082         u8 *extra = NULL;
5083         u32 extra_size = 0;
5084
5085         s32 k;
5086         const iw_handler *priv;         /* Private ioctl */
5087         const struct iw_priv_args *priv_args;   /* Private ioctl description */
5088         u32 num_priv;                           /* Number of ioctl */
5089         u32 num_priv_args;                      /* Number of descriptions */
5090         iw_handler handler;
5091         int temp;
5092         int subcmd = 0;                         /* sub-ioctl index */
5093         int offset = 0;                         /* Space for sub-ioctl index */
5094
5095         union iwreq_data wdata;
5096
5097
5098         memcpy(&wdata, wrq_data, sizeof(wdata));
5099
5100         input_len = 2048;
5101         input = rtw_zmalloc(input_len);
5102         if (NULL == input)
5103                 return -ENOMEM;
5104         if (copy_from_user(input, wdata.data.pointer, input_len)) {
5105                 err = -EFAULT;
5106                 goto exit;
5107         }
5108         ptr = input;
5109         len = strlen(input);
5110
5111         sscanf(ptr, "%16s", cmdname);
5112         cmdlen = strlen(cmdname);
5113         DBG_8192C("%s: cmd =%s\n", __func__, cmdname);
5114
5115         /*  skip command string */
5116         if (cmdlen > 0)
5117                 cmdlen += 1; /*  skip one space */
5118         ptr += cmdlen;
5119         len -= cmdlen;
5120         DBG_8192C("%s: parameters =%s\n", __func__, ptr);
5121
5122         priv = rtw_private_handler;
5123         priv_args = rtw_private_args;
5124         num_priv = sizeof(rtw_private_handler) / sizeof(iw_handler);
5125         num_priv_args = sizeof(rtw_private_args) / sizeof(struct iw_priv_args);
5126
5127         if (num_priv_args == 0) {
5128                 err = -EOPNOTSUPP;
5129                 goto exit;
5130         }
5131
5132         /* Search the correct ioctl */
5133         k = -1;
5134         while ((++k < num_priv_args) && strcmp(priv_args[k].name, cmdname));
5135
5136         /* If not found... */
5137         if (k == num_priv_args) {
5138                 err = -EOPNOTSUPP;
5139                 goto exit;
5140         }
5141
5142         /* Watch out for sub-ioctls ! */
5143         if (priv_args[k].cmd < SIOCDEVPRIVATE) {
5144                 int j = -1;
5145
5146                 /* Find the matching *real* ioctl */
5147                 while ((++j < num_priv_args) && ((priv_args[j].name[0] != '\0') ||
5148                         (priv_args[j].set_args != priv_args[k].set_args) ||
5149                         (priv_args[j].get_args != priv_args[k].get_args)));
5150
5151                 /* If not found... */
5152                 if (j == num_priv_args) {
5153                         err = -EINVAL;
5154                         goto exit;
5155                 }
5156
5157                 /* Save sub-ioctl number */
5158                 subcmd = priv_args[k].cmd;
5159                 /* Reserve one int (simplify alignment issues) */
5160                 offset = sizeof(__u32);
5161                 /* Use real ioctl definition from now on */
5162                 k = j;
5163         }
5164
5165         buffer = rtw_zmalloc(4096);
5166         if (NULL == buffer) {
5167                 err = -ENOMEM;
5168                 goto exit;
5169         }
5170
5171         /* If we have to set some data */
5172         if ((priv_args[k].set_args & IW_PRIV_TYPE_MASK) &&
5173                 (priv_args[k].set_args & IW_PRIV_SIZE_MASK)) {
5174                 u8 *str;
5175
5176                 switch (priv_args[k].set_args & IW_PRIV_TYPE_MASK) {
5177                         case IW_PRIV_TYPE_BYTE:
5178                                 /* Fetch args */
5179                                 count = 0;
5180                                 do {
5181                                         str = strsep(&ptr, delim);
5182                                         if (NULL == str) break;
5183                                         sscanf(str, "%i", &temp);
5184                                         buffer[count++] = (u8)temp;
5185                                 } while (1);
5186                                 buffer_len = count;
5187
5188                                 /* Number of args to fetch */
5189                                 wdata.data.length = count;
5190                                 if (wdata.data.length > (priv_args[k].set_args & IW_PRIV_SIZE_MASK))
5191                                         wdata.data.length = priv_args[k].set_args & IW_PRIV_SIZE_MASK;
5192
5193                                 break;
5194
5195                         case IW_PRIV_TYPE_INT:
5196                                 /* Fetch args */
5197                                 count = 0;
5198                                 do {
5199                                         str = strsep(&ptr, delim);
5200                                         if (NULL == str) break;
5201                                         sscanf(str, "%i", &temp);
5202                                         ((s32*)buffer)[count++] = (s32)temp;
5203                                 } while (1);
5204                                 buffer_len = count * sizeof(s32);
5205
5206                                 /* Number of args to fetch */
5207                                 wdata.data.length = count;
5208                                 if (wdata.data.length > (priv_args[k].set_args & IW_PRIV_SIZE_MASK))
5209                                         wdata.data.length = priv_args[k].set_args & IW_PRIV_SIZE_MASK;
5210
5211                                 break;
5212
5213                         case IW_PRIV_TYPE_CHAR:
5214                                 if (len > 0) {
5215                                         /* Size of the string to fetch */
5216                                         wdata.data.length = len;
5217                                         if (wdata.data.length > (priv_args[k].set_args & IW_PRIV_SIZE_MASK))
5218                                                 wdata.data.length = priv_args[k].set_args & IW_PRIV_SIZE_MASK;
5219
5220                                         /* Fetch string */
5221                                         memcpy(buffer, ptr, wdata.data.length);
5222                                 } else {
5223                                         wdata.data.length = 1;
5224                                         buffer[0] = '\0';
5225                                 }
5226                                 buffer_len = wdata.data.length;
5227                                 break;
5228
5229                         default:
5230                                 DBG_8192C("%s: Not yet implemented...\n", __func__);
5231                                 err = -1;
5232                                 goto exit;
5233                 }
5234
5235                 if ((priv_args[k].set_args & IW_PRIV_SIZE_FIXED) &&
5236                         (wdata.data.length != (priv_args[k].set_args & IW_PRIV_SIZE_MASK))) {
5237                         DBG_8192C("%s: The command %s needs exactly %d argument(s)...\n",
5238                                         __func__, cmdname, priv_args[k].set_args & IW_PRIV_SIZE_MASK);
5239                         err = -EINVAL;
5240                         goto exit;
5241                 }
5242         } else { /* if args to set */
5243                 wdata.data.length = 0L;
5244         }
5245
5246         /* Those two tests are important. They define how the driver
5247         * will have to handle the data */
5248         if ((priv_args[k].set_args & IW_PRIV_SIZE_FIXED) &&
5249                 ((get_priv_size(priv_args[k].set_args) + offset) <= IFNAMSIZ)) {
5250                 /* First case : all SET args fit within wrq */
5251                 if (offset)
5252                         wdata.mode = subcmd;
5253                 memcpy(wdata.name + offset, buffer, IFNAMSIZ - offset);
5254         } else {
5255                 if ((priv_args[k].set_args == 0) &&
5256                         (priv_args[k].get_args & IW_PRIV_SIZE_FIXED) &&
5257                         (get_priv_size(priv_args[k].get_args) <= IFNAMSIZ)) {
5258                         /* Second case : no SET args, GET args fit within wrq */
5259                         if (offset)
5260                                 wdata.mode = subcmd;
5261                 } else {
5262                         /* Third case : args won't fit in wrq, or variable number of args */
5263                         if (copy_to_user(wdata.data.pointer, buffer, buffer_len)) {
5264                                 err = -EFAULT;
5265                                 goto exit;
5266                         }
5267                         wdata.data.flags = subcmd;
5268                 }
5269         }
5270
5271         kfree(input);
5272         input = NULL;
5273
5274         extra_size = 0;
5275         if (IW_IS_SET(priv_args[k].cmd)) {
5276                 /* Size of set arguments */
5277                 extra_size = get_priv_size(priv_args[k].set_args);
5278
5279                 /* Does it fits in iwr ? */
5280                 if ((priv_args[k].set_args & IW_PRIV_SIZE_FIXED) &&
5281                         ((extra_size + offset) <= IFNAMSIZ))
5282                         extra_size = 0;
5283         } else {
5284                 /* Size of get arguments */
5285                 extra_size = get_priv_size(priv_args[k].get_args);
5286
5287                 /* Does it fits in iwr ? */
5288                 if ((priv_args[k].get_args & IW_PRIV_SIZE_FIXED) &&
5289                         (extra_size <= IFNAMSIZ))
5290                         extra_size = 0;
5291         }
5292
5293         if (extra_size == 0) {
5294                 extra = (u8 *)&wdata;
5295                 kfree(buffer);
5296                 buffer = NULL;
5297         } else
5298                 extra = buffer;
5299
5300         handler = priv[priv_args[k].cmd - SIOCIWFIRSTPRIV];
5301         err = handler(dev, NULL, &wdata, extra);
5302
5303         /* If we have to get some data */
5304         if ((priv_args[k].get_args & IW_PRIV_TYPE_MASK) &&
5305                 (priv_args[k].get_args & IW_PRIV_SIZE_MASK)) {
5306                 int j;
5307                 int n = 0;      /* number of args */
5308                 u8 str[20] = {0};
5309
5310                 /* Check where is the returned data */
5311                 if ((priv_args[k].get_args & IW_PRIV_SIZE_FIXED) &&
5312                         (get_priv_size(priv_args[k].get_args) <= IFNAMSIZ))
5313                         n = priv_args[k].get_args & IW_PRIV_SIZE_MASK;
5314                 else
5315                         n = wdata.data.length;
5316
5317                 output = rtw_zmalloc(4096);
5318                 if (NULL == output) {
5319                         err =  -ENOMEM;
5320                         goto exit;
5321                 }
5322
5323                 switch (priv_args[k].get_args & IW_PRIV_TYPE_MASK) {
5324                         case IW_PRIV_TYPE_BYTE:
5325                                 /* Display args */
5326                                 for (j = 0; j < n; j++) {
5327                                         sprintf(str, "%d  ", extra[j]);
5328                                         len = strlen(str);
5329                                         output_len = strlen(output);
5330                                         if ((output_len + len + 1) > 4096) {
5331                                                 err = -E2BIG;
5332                                                 goto exit;
5333                                         }
5334                                         memcpy(output+output_len, str, len);
5335                                 }
5336                                 break;
5337
5338                         case IW_PRIV_TYPE_INT:
5339                                 /* Display args */
5340                                 for (j = 0; j < n; j++) {
5341                                         sprintf(str, "%d  ", ((__s32*)extra)[j]);
5342                                         len = strlen(str);
5343                                         output_len = strlen(output);
5344                                         if ((output_len + len + 1) > 4096) {
5345                                                 err = -E2BIG;
5346                                                 goto exit;
5347                                         }
5348                                         memcpy(output+output_len, str, len);
5349                                 }
5350                                 break;
5351
5352                         case IW_PRIV_TYPE_CHAR:
5353                                 /* Display args */
5354                                 memcpy(output, extra, n);
5355                                 break;
5356
5357                         default:
5358                                 DBG_8192C("%s: Not yet implemented...\n", __func__);
5359                                 err = -1;
5360                                 goto exit;
5361                 }
5362
5363                 output_len = strlen(output) + 1;
5364                 wrq_data->data.length = output_len;
5365                 if (copy_to_user(wrq_data->data.pointer, output, output_len)) {
5366                         err = -EFAULT;
5367                         goto exit;
5368                 }
5369         } else { /* if args to set */
5370                 wrq_data->data.length = 0;
5371         }
5372
5373 exit:
5374         kfree(input);
5375         kfree(buffer);
5376         kfree(output);
5377
5378         return err;
5379 }
5380
5381 int rtw_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
5382 {
5383         struct iwreq *wrq = (struct iwreq *)rq;
5384         int ret = 0;
5385
5386         switch (cmd) {
5387                 case RTL_IOCTL_WPA_SUPPLICANT:
5388                         ret = wpa_supplicant_ioctl(dev, &wrq->u.data);
5389                         break;
5390                 case RTL_IOCTL_HOSTAPD:
5391                         ret = rtw_hostapd_ioctl(dev, &wrq->u.data);
5392                         break;
5393                 case SIOCDEVPRIVATE:
5394                         ret = rtw_ioctl_wext_private(dev, &wrq->u);
5395                         break;
5396                 default:
5397                         ret = -EOPNOTSUPP;
5398                         break;
5399         }
5400
5401         return ret;
5402 }