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 &&
1442                                             sec_len <= len &&
1443                                             sec_len <= 32) {
1444                                                 ssid[ssid_index].SsidLength = sec_len;
1445                                                 memcpy(ssid[ssid_index].Ssid, pos, sec_len);
1446                                                 /* DBG_871X("%s COMBO_SCAN with specific ssid:%s, %d\n", __func__ */
1447                                                 /*      , ssid[ssid_index].Ssid, ssid[ssid_index].SsidLength); */
1448                                                 ssid_index++;
1449                                         }
1450
1451                                         pos+=sec_len; len-=sec_len;
1452                                         break;
1453
1454
1455                                 case WEXT_CSCAN_CHANNEL_SECTION:
1456                                         /* DBG_871X("WEXT_CSCAN_CHANNEL_SECTION\n"); */
1457                                         pos+= 1; len-= 1;
1458                                         break;
1459                                 case WEXT_CSCAN_ACTV_DWELL_SECTION:
1460                                         /* DBG_871X("WEXT_CSCAN_ACTV_DWELL_SECTION\n"); */
1461                                         pos+=2; len-=2;
1462                                         break;
1463                                 case WEXT_CSCAN_PASV_DWELL_SECTION:
1464                                         /* DBG_871X("WEXT_CSCAN_PASV_DWELL_SECTION\n"); */
1465                                         pos+=2; len-=2;
1466                                         break;
1467                                 case WEXT_CSCAN_HOME_DWELL_SECTION:
1468                                         /* DBG_871X("WEXT_CSCAN_HOME_DWELL_SECTION\n"); */
1469                                         pos+=2; len-=2;
1470                                         break;
1471                                 case WEXT_CSCAN_TYPE_SECTION:
1472                                         /* DBG_871X("WEXT_CSCAN_TYPE_SECTION\n"); */
1473                                         pos+= 1; len-= 1;
1474                                         break;
1475                                 default:
1476                                         /* DBG_871X("Unknown CSCAN section %c\n", section); */
1477                                         len = 0; /*  stop parsing */
1478                         }
1479                         /* DBG_871X("len:%d\n", len); */
1480
1481                 }
1482
1483                 /* jeff: it has still some scan paramater to parse, we only do this now... */
1484                 _status = rtw_set_802_11_bssid_list_scan(padapter, ssid, RTW_SSID_SCAN_AMOUNT);
1485
1486         } else {
1487                 _status = rtw_set_802_11_bssid_list_scan(padapter, NULL, 0);
1488         }
1489
1490         if (_status == false)
1491                 ret = -1;
1492
1493 exit:
1494
1495         rtw_ps_deny_cancel(padapter, PS_DENY_SCAN);
1496
1497         #ifdef DBG_IOCTL
1498         DBG_871X("DBG_IOCTL %s:%d return %d\n", __func__, __LINE__, ret);
1499         #endif
1500
1501         return ret;
1502 }
1503
1504 static int rtw_wx_get_scan(struct net_device *dev, struct iw_request_info *a,
1505                              union iwreq_data *wrqu, char *extra)
1506 {
1507         struct list_head                                        *plist, *phead;
1508         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1509         struct  mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1510         struct __queue                          *queue  = &(pmlmepriv->scanned_queue);
1511         struct  wlan_network    *pnetwork = NULL;
1512         char *ev = extra;
1513         char *stop = ev + wrqu->data.length;
1514         u32 ret = 0;
1515         sint wait_status;
1516
1517         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_scan\n"));
1518         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, (" Start of Query SIOCGIWSCAN .\n"));
1519
1520         #ifdef DBG_IOCTL
1521         DBG_871X("DBG_IOCTL %s:%d\n", __func__, __LINE__);
1522         #endif
1523
1524         if (adapter_to_pwrctl(padapter)->brfoffbyhw && padapter->bDriverStopped) {
1525                 ret = -EINVAL;
1526                 goto exit;
1527         }
1528
1529         wait_status = _FW_UNDER_SURVEY | _FW_UNDER_LINKING;
1530
1531         if (check_fwstate(pmlmepriv, wait_status))
1532                 return -EAGAIN;
1533
1534         spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
1535
1536         phead = get_list_head(queue);
1537         plist = get_next(phead);
1538
1539         while (1) {
1540                 if (phead == plist)
1541                         break;
1542
1543                 if ((stop - ev) < SCAN_ITEM_SIZE) {
1544                         ret = -E2BIG;
1545                         break;
1546                 }
1547
1548                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
1549
1550                 /* report network only if the current channel set contains the channel to which this network belongs */
1551                 if (rtw_ch_set_search_ch(padapter->mlmeextpriv.channel_set, pnetwork->network.Configuration.DSConfig) >= 0
1552                         && rtw_mlme_band_check(padapter, pnetwork->network.Configuration.DSConfig) == true
1553                         && true == rtw_validate_ssid(&(pnetwork->network.Ssid))) {
1554
1555                         ev =translate_scan(padapter, a, pnetwork, ev, stop);
1556                 }
1557
1558                 plist = get_next(plist);
1559
1560         }
1561
1562         spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
1563
1564         wrqu->data.length = ev-extra;
1565         wrqu->data.flags = 0;
1566
1567 exit:
1568
1569         #ifdef DBG_IOCTL
1570         DBG_871X("DBG_IOCTL %s:%d return %d\n", __func__, __LINE__, ret);
1571         #endif
1572
1573         return ret ;
1574
1575 }
1576
1577 /* set ssid flow */
1578 /* s1. rtw_set_802_11_infrastructure_mode() */
1579 /* s2. set_802_11_authenticaion_mode() */
1580 /* s3. set_802_11_encryption_mode() */
1581 /* s4. rtw_set_802_11_ssid() */
1582 static int rtw_wx_set_essid(struct net_device *dev,
1583                               struct iw_request_info *a,
1584                               union iwreq_data *wrqu, char *extra)
1585 {
1586         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1587         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1588         struct __queue *queue = &pmlmepriv->scanned_queue;
1589         struct list_head *phead;
1590         struct wlan_network *pnetwork = NULL;
1591         enum NDIS_802_11_AUTHENTICATION_MODE authmode;
1592         struct ndis_802_11_ssid ndis_ssid;
1593         u8 *dst_ssid, *src_ssid;
1594
1595         uint ret = 0, len;
1596
1597         #ifdef DBG_IOCTL
1598         DBG_871X("DBG_IOCTL %s:%d\n", __func__, __LINE__);
1599         #endif
1600
1601         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1602                  ("+rtw_wx_set_essid: fw_state = 0x%08x\n", get_fwstate(pmlmepriv)));
1603
1604         rtw_ps_deny(padapter, PS_DENY_JOIN);
1605         if (_FAIL == rtw_pwr_wakeup(padapter)) {
1606                 ret = -1;
1607                 goto exit;
1608         }
1609
1610         if (!padapter->bup) {
1611                 ret = -1;
1612                 goto exit;
1613         }
1614
1615         if (wrqu->essid.length > IW_ESSID_MAX_SIZE) {
1616                 ret = -E2BIG;
1617                 goto exit;
1618         }
1619
1620         if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1621                 ret = -1;
1622                 goto exit;
1623         }
1624
1625         authmode = padapter->securitypriv.ndisauthtype;
1626         DBG_871X("=>%s\n", __func__);
1627         if (wrqu->essid.flags && wrqu->essid.length) {
1628                 len = (wrqu->essid.length < IW_ESSID_MAX_SIZE) ? wrqu->essid.length : IW_ESSID_MAX_SIZE;
1629
1630                 if (wrqu->essid.length != 33)
1631                         DBG_871X("ssid =%s, len =%d\n", extra, wrqu->essid.length);
1632
1633                 memset(&ndis_ssid, 0, sizeof(struct ndis_802_11_ssid));
1634                 ndis_ssid.SsidLength = len;
1635                 memcpy(ndis_ssid.Ssid, extra, len);
1636                 src_ssid = ndis_ssid.Ssid;
1637
1638                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("rtw_wx_set_essid: ssid =[%s]\n", src_ssid));
1639                 spin_lock_bh(&queue->lock);
1640                 phead = get_list_head(queue);
1641                 pmlmepriv->pscanned = get_next(phead);
1642
1643                 while (1) {
1644                         if (phead == pmlmepriv->pscanned) {
1645                                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_warning_,
1646                                          ("rtw_wx_set_essid: scan_q is empty, set ssid to check if scanning again!\n"));
1647
1648                                 break;
1649                         }
1650
1651                         pnetwork = LIST_CONTAINOR(pmlmepriv->pscanned, struct wlan_network, list);
1652
1653                         pmlmepriv->pscanned = get_next(pmlmepriv->pscanned);
1654
1655                         dst_ssid = pnetwork->network.Ssid.Ssid;
1656
1657                         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1658                                  ("rtw_wx_set_essid: dst_ssid =%s\n",
1659                                   pnetwork->network.Ssid.Ssid));
1660
1661                         if ((!memcmp(dst_ssid, src_ssid, ndis_ssid.SsidLength)) &&
1662                                 (pnetwork->network.Ssid.SsidLength ==ndis_ssid.SsidLength)) {
1663                                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1664                                          ("rtw_wx_set_essid: find match, set infra mode\n"));
1665
1666                                 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) {
1667                                         if (pnetwork->network.InfrastructureMode != pmlmepriv->cur_network.network.InfrastructureMode)
1668                                                 continue;
1669                                 }
1670
1671                                 if (rtw_set_802_11_infrastructure_mode(padapter, pnetwork->network.InfrastructureMode) == false) {
1672                                         ret = -1;
1673                                         spin_unlock_bh(&queue->lock);
1674                                         goto exit;
1675                                 }
1676
1677                                 break;
1678                         }
1679                 }
1680                 spin_unlock_bh(&queue->lock);
1681                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1682                          ("set ssid: set_802_11_auth. mode =%d\n", authmode));
1683                 rtw_set_802_11_authentication_mode(padapter, authmode);
1684                 /* set_802_11_encryption_mode(padapter, padapter->securitypriv.ndisencryptstatus); */
1685                 if (rtw_set_802_11_ssid(padapter, &ndis_ssid) == false) {
1686                         ret = -1;
1687                         goto exit;
1688                 }
1689         }
1690
1691 exit:
1692
1693         rtw_ps_deny_cancel(padapter, PS_DENY_JOIN);
1694
1695         DBG_871X("<=%s, ret %d\n", __func__, ret);
1696
1697         #ifdef DBG_IOCTL
1698         DBG_871X("DBG_IOCTL %s:%d return %d\n", __func__, __LINE__, ret);
1699         #endif
1700
1701         return ret;
1702 }
1703
1704 static int rtw_wx_get_essid(struct net_device *dev,
1705                               struct iw_request_info *a,
1706                               union iwreq_data *wrqu, char *extra)
1707 {
1708         u32 len, ret = 0;
1709         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1710         struct  mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1711         struct wlan_bssid_ex  *pcur_bss = &pmlmepriv->cur_network.network;
1712
1713         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_essid\n"));
1714
1715         if ((check_fwstate(pmlmepriv, _FW_LINKED) == true) ||
1716               (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true)) {
1717                 len = pcur_bss->Ssid.SsidLength;
1718
1719                 wrqu->essid.length = len;
1720
1721                 memcpy(extra, pcur_bss->Ssid.Ssid, len);
1722
1723                 wrqu->essid.flags = 1;
1724         } else {
1725                 ret = -1;
1726                 goto exit;
1727         }
1728
1729 exit:
1730         return ret;
1731 }
1732
1733 static int rtw_wx_set_rate(struct net_device *dev,
1734                               struct iw_request_info *a,
1735                               union iwreq_data *wrqu, char *extra)
1736 {
1737         int     i, ret = 0;
1738         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1739         u8 datarates[NumRates];
1740         u32 target_rate = wrqu->bitrate.value;
1741         u32 fixed = wrqu->bitrate.fixed;
1742         u32 ratevalue = 0;
1743         u8 mpdatarate[NumRates]={11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0xff};
1744
1745         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, (" rtw_wx_set_rate\n"));
1746         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("target_rate = %d, fixed = %d\n", target_rate, fixed));
1747
1748         if (target_rate == -1) {
1749                 ratevalue = 11;
1750                 goto set_rate;
1751         }
1752         target_rate = target_rate/100000;
1753
1754         switch (target_rate) {
1755                 case 10:
1756                         ratevalue = 0;
1757                         break;
1758                 case 20:
1759                         ratevalue = 1;
1760                         break;
1761                 case 55:
1762                         ratevalue = 2;
1763                         break;
1764                 case 60:
1765                         ratevalue = 3;
1766                         break;
1767                 case 90:
1768                         ratevalue = 4;
1769                         break;
1770                 case 110:
1771                         ratevalue = 5;
1772                         break;
1773                 case 120:
1774                         ratevalue = 6;
1775                         break;
1776                 case 180:
1777                         ratevalue = 7;
1778                         break;
1779                 case 240:
1780                         ratevalue = 8;
1781                         break;
1782                 case 360:
1783                         ratevalue = 9;
1784                         break;
1785                 case 480:
1786                         ratevalue = 10;
1787                         break;
1788                 case 540:
1789                         ratevalue = 11;
1790                         break;
1791                 default:
1792                         ratevalue = 11;
1793                         break;
1794         }
1795
1796 set_rate:
1797
1798         for (i = 0; i<NumRates; i++) {
1799                 if (ratevalue ==mpdatarate[i]) {
1800                         datarates[i] = mpdatarate[i];
1801                         if (fixed == 0)
1802                                 break;
1803                 } else {
1804                         datarates[i] = 0xff;
1805                 }
1806
1807                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("datarate_inx =%d\n", datarates[i]));
1808         }
1809
1810         if (rtw_setdatarate_cmd(padapter, datarates) != _SUCCESS) {
1811                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("rtw_wx_set_rate Fail!!!\n"));
1812                 ret = -1;
1813         }
1814         return ret;
1815 }
1816
1817 static int rtw_wx_get_rate(struct net_device *dev,
1818                              struct iw_request_info *info,
1819                              union iwreq_data *wrqu, char *extra)
1820 {
1821         u16 max_rate = 0;
1822
1823         max_rate = rtw_get_cur_max_rate((struct adapter *)rtw_netdev_priv(dev));
1824
1825         if (max_rate == 0)
1826                 return -EPERM;
1827
1828         wrqu->bitrate.fixed = 0;        /* no auto select */
1829         wrqu->bitrate.value = max_rate * 100000;
1830
1831         return 0;
1832 }
1833
1834 static int rtw_wx_set_rts(struct net_device *dev,
1835                              struct iw_request_info *info,
1836                              union iwreq_data *wrqu, char *extra)
1837 {
1838         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1839
1840         if (wrqu->rts.disabled)
1841                 padapter->registrypriv.rts_thresh = 2347;
1842         else {
1843                 if (wrqu->rts.value < 0 ||
1844                     wrqu->rts.value > 2347)
1845                         return -EINVAL;
1846
1847                 padapter->registrypriv.rts_thresh = wrqu->rts.value;
1848         }
1849
1850         DBG_871X("%s, rts_thresh =%d\n", __func__, padapter->registrypriv.rts_thresh);
1851
1852         return 0;
1853 }
1854
1855 static int rtw_wx_get_rts(struct net_device *dev,
1856                              struct iw_request_info *info,
1857                              union iwreq_data *wrqu, char *extra)
1858 {
1859         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1860
1861         DBG_871X("%s, rts_thresh =%d\n", __func__, padapter->registrypriv.rts_thresh);
1862
1863         wrqu->rts.value = padapter->registrypriv.rts_thresh;
1864         wrqu->rts.fixed = 0;    /* no auto select */
1865         /* wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD); */
1866
1867         return 0;
1868 }
1869
1870 static int rtw_wx_set_frag(struct net_device *dev,
1871                              struct iw_request_info *info,
1872                              union iwreq_data *wrqu, char *extra)
1873 {
1874         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1875
1876         if (wrqu->frag.disabled)
1877                 padapter->xmitpriv.frag_len = MAX_FRAG_THRESHOLD;
1878         else {
1879                 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
1880                     wrqu->frag.value > MAX_FRAG_THRESHOLD)
1881                         return -EINVAL;
1882
1883                 padapter->xmitpriv.frag_len = wrqu->frag.value & ~0x1;
1884         }
1885
1886         DBG_871X("%s, frag_len =%d\n", __func__, padapter->xmitpriv.frag_len);
1887
1888         return 0;
1889
1890 }
1891
1892 static int rtw_wx_get_frag(struct net_device *dev,
1893                              struct iw_request_info *info,
1894                              union iwreq_data *wrqu, char *extra)
1895 {
1896         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1897
1898         DBG_871X("%s, frag_len =%d\n", __func__, padapter->xmitpriv.frag_len);
1899
1900         wrqu->frag.value = padapter->xmitpriv.frag_len;
1901         wrqu->frag.fixed = 0;   /* no auto select */
1902         /* wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FRAG_THRESHOLD); */
1903
1904         return 0;
1905 }
1906
1907 static int rtw_wx_get_retry(struct net_device *dev,
1908                              struct iw_request_info *info,
1909                              union iwreq_data *wrqu, char *extra)
1910 {
1911         /* struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); */
1912
1913
1914         wrqu->retry.value = 7;
1915         wrqu->retry.fixed = 0;  /* no auto select */
1916         wrqu->retry.disabled = 1;
1917
1918         return 0;
1919
1920 }
1921
1922 static int rtw_wx_set_enc(struct net_device *dev,
1923                             struct iw_request_info *info,
1924                             union iwreq_data *wrqu, char *keybuf)
1925 {
1926         u32 key, ret = 0;
1927         u32 keyindex_provided;
1928         struct ndis_802_11_wep   wep;
1929         enum NDIS_802_11_AUTHENTICATION_MODE authmode;
1930
1931         struct iw_point *erq = &(wrqu->encoding);
1932         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1933         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1934         DBG_871X("+rtw_wx_set_enc, flags = 0x%x\n", erq->flags);
1935
1936         memset(&wep, 0, sizeof(struct ndis_802_11_wep));
1937
1938         key = erq->flags & IW_ENCODE_INDEX;
1939
1940         if (erq->flags & IW_ENCODE_DISABLED) {
1941                 DBG_871X("EncryptionDisabled\n");
1942                 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
1943                 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1944                 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
1945                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
1946                 authmode = Ndis802_11AuthModeOpen;
1947                 padapter->securitypriv.ndisauthtype =authmode;
1948
1949                 goto exit;
1950         }
1951
1952         if (key) {
1953                 if (key > WEP_KEYS)
1954                         return -EINVAL;
1955                 key--;
1956                 keyindex_provided = 1;
1957         } else {
1958                 keyindex_provided = 0;
1959                 key = padapter->securitypriv.dot11PrivacyKeyIndex;
1960                 DBG_871X("rtw_wx_set_enc, key =%d\n", key);
1961         }
1962
1963         /* set authentication mode */
1964         if (erq->flags & IW_ENCODE_OPEN) {
1965                 DBG_871X("rtw_wx_set_enc():IW_ENCODE_OPEN\n");
1966                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;/* Ndis802_11EncryptionDisabled; */
1967
1968                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
1969
1970                 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1971                 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
1972                 authmode = Ndis802_11AuthModeOpen;
1973                 padapter->securitypriv.ndisauthtype =authmode;
1974         } else if (erq->flags & IW_ENCODE_RESTRICTED) {
1975                 DBG_871X("rtw_wx_set_enc():IW_ENCODE_RESTRICTED\n");
1976                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
1977
1978                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Shared;
1979
1980                 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
1981                 padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_;
1982                 authmode = Ndis802_11AuthModeShared;
1983                 padapter->securitypriv.ndisauthtype =authmode;
1984         } else {
1985                 DBG_871X("rtw_wx_set_enc():erq->flags = 0x%x\n", erq->flags);
1986
1987                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;/* Ndis802_11EncryptionDisabled; */
1988                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
1989                 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1990                 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
1991                 authmode = Ndis802_11AuthModeOpen;
1992                 padapter->securitypriv.ndisauthtype =authmode;
1993         }
1994
1995         wep.KeyIndex = key;
1996         if (erq->length > 0) {
1997                 wep.KeyLength = erq->length <= 5 ? 5 : 13;
1998
1999                 wep.Length = wep.KeyLength + FIELD_OFFSET(struct ndis_802_11_wep, KeyMaterial);
2000         } else {
2001                 wep.KeyLength = 0 ;
2002
2003                 if (keyindex_provided == 1) { /*  set key_id only, no given KeyMaterial(erq->length == 0). */
2004                         padapter->securitypriv.dot11PrivacyKeyIndex = key;
2005
2006                         DBG_871X("(keyindex_provided == 1), keyid =%d, key_len =%d\n", key, padapter->securitypriv.dot11DefKeylen[key]);
2007
2008                         switch (padapter->securitypriv.dot11DefKeylen[key]) {
2009                                 case 5:
2010                                         padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
2011                                         break;
2012                                 case 13:
2013                                         padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
2014                                         break;
2015                                 default:
2016                                         padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
2017                                         break;
2018                         }
2019
2020                         goto exit;
2021
2022                 }
2023
2024         }
2025
2026         wep.KeyIndex |= 0x80000000;
2027
2028         memcpy(wep.KeyMaterial, keybuf, wep.KeyLength);
2029
2030         if (rtw_set_802_11_add_wep(padapter, &wep) == false) {
2031                 if (rf_on == pwrpriv->rf_pwrstate)
2032                         ret = -EOPNOTSUPP;
2033                 goto exit;
2034         }
2035
2036 exit:
2037         return ret;
2038 }
2039
2040 static int rtw_wx_get_enc(struct net_device *dev,
2041                             struct iw_request_info *info,
2042                             union iwreq_data *wrqu, char *keybuf)
2043 {
2044         uint key, ret = 0;
2045         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2046         struct iw_point *erq = &(wrqu->encoding);
2047         struct  mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2048
2049         if (check_fwstate(pmlmepriv, _FW_LINKED) != true) {
2050                  if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) != true) {
2051                          erq->length = 0;
2052                          erq->flags |= IW_ENCODE_DISABLED;
2053                          return 0;
2054                  }
2055         }
2056
2057
2058         key = erq->flags & IW_ENCODE_INDEX;
2059
2060         if (key) {
2061                 if (key > WEP_KEYS)
2062                         return -EINVAL;
2063                 key--;
2064         } else {
2065                 key = padapter->securitypriv.dot11PrivacyKeyIndex;
2066         }
2067
2068         erq->flags = key + 1;
2069
2070         /* if (padapter->securitypriv.ndisauthtype == Ndis802_11AuthModeOpen) */
2071         /*  */
2072         /*       erq->flags |= IW_ENCODE_OPEN; */
2073         /*  */
2074
2075         switch (padapter->securitypriv.ndisencryptstatus) {
2076         case Ndis802_11EncryptionNotSupported:
2077         case Ndis802_11EncryptionDisabled:
2078                 erq->length = 0;
2079                 erq->flags |= IW_ENCODE_DISABLED;
2080                 break;
2081         case Ndis802_11Encryption1Enabled:
2082                 erq->length = padapter->securitypriv.dot11DefKeylen[key];
2083
2084                 if (erq->length) {
2085                         memcpy(keybuf, padapter->securitypriv.dot11DefKey[key].skey, padapter->securitypriv.dot11DefKeylen[key]);
2086
2087                         erq->flags |= IW_ENCODE_ENABLED;
2088
2089                         if (padapter->securitypriv.ndisauthtype == Ndis802_11AuthModeOpen)
2090                                 erq->flags |= IW_ENCODE_OPEN;
2091                         else if (padapter->securitypriv.ndisauthtype == Ndis802_11AuthModeShared)
2092                                 erq->flags |= IW_ENCODE_RESTRICTED;
2093                 } else {
2094                         erq->length = 0;
2095                         erq->flags |= IW_ENCODE_DISABLED;
2096                 }
2097                 break;
2098         case Ndis802_11Encryption2Enabled:
2099         case Ndis802_11Encryption3Enabled:
2100                 erq->length = 16;
2101                 erq->flags |= (IW_ENCODE_ENABLED | IW_ENCODE_OPEN | IW_ENCODE_NOKEY);
2102                 break;
2103         default:
2104                 erq->length = 0;
2105                 erq->flags |= IW_ENCODE_DISABLED;
2106                 break;
2107         }
2108         return ret;
2109 }
2110
2111 static int rtw_wx_get_power(struct net_device *dev,
2112                              struct iw_request_info *info,
2113                              union iwreq_data *wrqu, char *extra)
2114 {
2115         /* struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); */
2116
2117         wrqu->power.value = 0;
2118         wrqu->power.fixed = 0;  /* no auto select */
2119         wrqu->power.disabled = 1;
2120
2121         return 0;
2122 }
2123
2124 static int rtw_wx_set_gen_ie(struct net_device *dev,
2125                              struct iw_request_info *info,
2126                              union iwreq_data *wrqu, char *extra)
2127 {
2128         int ret;
2129         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2130
2131         ret = rtw_set_wpa_ie(padapter, extra, wrqu->data.length);
2132
2133         return ret;
2134 }
2135
2136 static int rtw_wx_set_auth(struct net_device *dev,
2137                              struct iw_request_info *info,
2138                              union iwreq_data *wrqu, char *extra)
2139 {
2140         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2141         struct iw_param *param = (struct iw_param*)&(wrqu->param);
2142         int ret = 0;
2143
2144         switch (param->flags & IW_AUTH_INDEX) {
2145
2146         case IW_AUTH_WPA_VERSION:
2147                 break;
2148         case IW_AUTH_CIPHER_PAIRWISE:
2149
2150                 break;
2151         case IW_AUTH_CIPHER_GROUP:
2152
2153                 break;
2154         case IW_AUTH_KEY_MGMT:
2155                 /*
2156                  *  ??? does not use these parameters
2157                  */
2158                 break;
2159
2160         case IW_AUTH_TKIP_COUNTERMEASURES:
2161         {
2162                 if (param->value) {
2163                         /*  wpa_supplicant is enabling the tkip countermeasure. */
2164                         padapter->securitypriv.btkip_countermeasure = true;
2165                 } else {
2166                         /*  wpa_supplicant is disabling the tkip countermeasure. */
2167                         padapter->securitypriv.btkip_countermeasure = false;
2168                 }
2169                 break;
2170         }
2171         case IW_AUTH_DROP_UNENCRYPTED:
2172                 {
2173                         /* HACK:
2174                          *
2175                          * wpa_supplicant calls set_wpa_enabled when the driver
2176                          * is loaded and unloaded, regardless of if WPA is being
2177                          * used.  No other calls are made which can be used to
2178                          * determine if encryption will be used or not prior to
2179                          * association being expected.  If encryption is not being
2180                          * used, drop_unencrypted is set to false, else true -- we
2181                          * can use this to determine if the CAP_PRIVACY_ON bit should
2182                          * be set.
2183                          */
2184
2185                         if (padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption1Enabled) {
2186                                 break;/* it means init value, or using wep, ndisencryptstatus = Ndis802_11Encryption1Enabled, */
2187                                                 /*  then it needn't reset it; */
2188                         }
2189
2190                         if (param->value) {
2191                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
2192                                 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
2193                                 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
2194                                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
2195                                 padapter->securitypriv.ndisauthtype =Ndis802_11AuthModeOpen;
2196                         }
2197
2198                         break;
2199                 }
2200
2201         case IW_AUTH_80211_AUTH_ALG:
2202
2203                 /*
2204                  *  It's the starting point of a link layer connection using wpa_supplicant
2205                 */
2206                 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED)) {
2207                         LeaveAllPowerSaveMode(padapter);
2208                         rtw_disassoc_cmd(padapter, 500, false);
2209                         DBG_871X("%s...call rtw_indicate_disconnect\n ", __func__);
2210                         rtw_indicate_disconnect(padapter);
2211                         rtw_free_assoc_resources(padapter, 1);
2212                 }
2213
2214
2215                 ret = wpa_set_auth_algs(dev, (u32)param->value);
2216
2217                 break;
2218
2219         case IW_AUTH_WPA_ENABLED:
2220                 break;
2221         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
2222                 break;
2223         case IW_AUTH_PRIVACY_INVOKED:
2224                 break;
2225         default:
2226                 return -EOPNOTSUPP;
2227         }
2228         return ret;
2229 }
2230
2231 static int rtw_wx_set_enc_ext(struct net_device *dev,
2232                              struct iw_request_info *info,
2233                              union iwreq_data *wrqu, char *extra)
2234 {
2235         char *alg_name;
2236         u32 param_len;
2237         struct ieee_param *param = NULL;
2238         struct iw_point *pencoding = &wrqu->encoding;
2239         struct iw_encode_ext *pext = (struct iw_encode_ext *)extra;
2240         int ret = 0;
2241
2242         param_len = sizeof(struct ieee_param) + pext->key_len;
2243         param = (struct ieee_param *)rtw_malloc(param_len);
2244         if (param == NULL)
2245                 return -1;
2246
2247         memset(param, 0, param_len);
2248
2249         param->cmd = IEEE_CMD_SET_ENCRYPTION;
2250         memset(param->sta_addr, 0xff, ETH_ALEN);
2251
2252
2253         switch (pext->alg) {
2254         case IW_ENCODE_ALG_NONE:
2255                 /* todo: remove key */
2256                 /* remove = 1; */
2257                 alg_name = "none";
2258                 break;
2259         case IW_ENCODE_ALG_WEP:
2260                 alg_name = "WEP";
2261                 break;
2262         case IW_ENCODE_ALG_TKIP:
2263                 alg_name = "TKIP";
2264                 break;
2265         case IW_ENCODE_ALG_CCMP:
2266                 alg_name = "CCMP";
2267                 break;
2268         case IW_ENCODE_ALG_AES_CMAC:
2269                 alg_name = "BIP";
2270                 break;
2271         default:
2272                 ret = -1;
2273                 goto exit;
2274         }
2275
2276         strncpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN);
2277
2278         if (pext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
2279                 param->u.crypt.set_tx = 1;
2280
2281         /* cliW: WEP does not have group key
2282          * just not checking GROUP key setting
2283          */
2284         if ((pext->alg != IW_ENCODE_ALG_WEP) &&
2285                 ((pext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
2286                 || (pext->ext_flags & IW_ENCODE_ALG_AES_CMAC))) {
2287                 param->u.crypt.set_tx = 0;
2288         }
2289
2290         param->u.crypt.idx = (pencoding->flags&0x00FF) -1 ;
2291
2292         if (pext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID)
2293                 memcpy(param->u.crypt.seq, pext->rx_seq, 8);
2294
2295         if (pext->key_len) {
2296                 param->u.crypt.key_len = pext->key_len;
2297                 /* memcpy(param + 1, pext + 1, pext->key_len); */
2298                 memcpy(param->u.crypt.key, pext + 1, pext->key_len);
2299         }
2300
2301         if (pencoding->flags & IW_ENCODE_DISABLED) {
2302                 /* todo: remove key */
2303                 /* remove = 1; */
2304         }
2305
2306         ret =  wpa_set_encryption(dev, param, param_len);
2307
2308 exit:
2309         kfree(param);
2310
2311         return ret;
2312 }
2313
2314
2315 static int rtw_wx_get_nick(struct net_device *dev,
2316                              struct iw_request_info *info,
2317                              union iwreq_data *wrqu, char *extra)
2318 {
2319         /* struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); */
2320          /* struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); */
2321          /* struct security_priv *psecuritypriv = &padapter->securitypriv; */
2322
2323         if (extra) {
2324                 wrqu->data.length = 14;
2325                 wrqu->data.flags = 1;
2326                 memcpy(extra, "<WIFI@REALTEK>", 14);
2327         }
2328         return 0;
2329 }
2330
2331 static int rtw_wx_read32(struct net_device *dev,
2332                             struct iw_request_info *info,
2333                             union iwreq_data *wrqu, char *extra)
2334 {
2335         struct adapter *padapter;
2336         struct iw_point *p;
2337         u16 len;
2338         u32 addr;
2339         u32 data32;
2340         u32 bytes;
2341         u8 *ptmp;
2342         int ret;
2343
2344
2345         ret = 0;
2346         padapter = (struct adapter *)rtw_netdev_priv(dev);
2347         p = &wrqu->data;
2348         len = p->length;
2349         if (0 == len)
2350                 return -EINVAL;
2351
2352         ptmp = (u8 *)rtw_malloc(len);
2353         if (NULL == ptmp)
2354                 return -ENOMEM;
2355
2356         if (copy_from_user(ptmp, p->pointer, len)) {
2357                 ret = -EFAULT;
2358                 goto exit;
2359         }
2360
2361         bytes = 0;
2362         addr = 0;
2363         sscanf(ptmp, "%d,%x", &bytes, &addr);
2364
2365         switch (bytes) {
2366                 case 1:
2367                         data32 = rtw_read8(padapter, addr);
2368                         sprintf(extra, "0x%02X", data32);
2369                         break;
2370                 case 2:
2371                         data32 = rtw_read16(padapter, addr);
2372                         sprintf(extra, "0x%04X", data32);
2373                         break;
2374                 case 4:
2375                         data32 = rtw_read32(padapter, addr);
2376                         sprintf(extra, "0x%08X", data32);
2377                         break;
2378                 default:
2379                         DBG_871X(KERN_INFO "%s: usage> read [bytes],[address(hex)]\n", __func__);
2380                         ret = -EINVAL;
2381                         goto exit;
2382         }
2383         DBG_871X(KERN_INFO "%s: addr = 0x%08X data =%s\n", __func__, addr, extra);
2384
2385 exit:
2386         kfree(ptmp);
2387
2388         return ret;
2389 }
2390
2391 static int rtw_wx_write32(struct net_device *dev,
2392                             struct iw_request_info *info,
2393                             union iwreq_data *wrqu, char *extra)
2394 {
2395         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2396
2397         u32 addr;
2398         u32 data32;
2399         u32 bytes;
2400
2401
2402         bytes = 0;
2403         addr = 0;
2404         data32 = 0;
2405         sscanf(extra, "%d,%x,%x", &bytes, &addr, &data32);
2406
2407         switch (bytes) {
2408                 case 1:
2409                         rtw_write8(padapter, addr, (u8)data32);
2410                         DBG_871X(KERN_INFO "%s: addr = 0x%08X data = 0x%02X\n", __func__, addr, (u8)data32);
2411                         break;
2412                 case 2:
2413                         rtw_write16(padapter, addr, (u16)data32);
2414                         DBG_871X(KERN_INFO "%s: addr = 0x%08X data = 0x%04X\n", __func__, addr, (u16)data32);
2415                         break;
2416                 case 4:
2417                         rtw_write32(padapter, addr, data32);
2418                         DBG_871X(KERN_INFO "%s: addr = 0x%08X data = 0x%08X\n", __func__, addr, data32);
2419                         break;
2420                 default:
2421                         DBG_871X(KERN_INFO "%s: usage> write [bytes],[address(hex)],[data(hex)]\n", __func__);
2422                         return -EINVAL;
2423         }
2424
2425         return 0;
2426 }
2427
2428 static int rtw_wx_read_rf(struct net_device *dev,
2429                             struct iw_request_info *info,
2430                             union iwreq_data *wrqu, char *extra)
2431 {
2432         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2433         u32 path, addr, data32;
2434
2435
2436         path = *(u32*)extra;
2437         addr = *((u32*)extra + 1);
2438         data32 = rtw_hal_read_rfreg(padapter, path, addr, 0xFFFFF);
2439         /*
2440          * IMPORTANT!!
2441          * Only when wireless private ioctl is at odd order,
2442          * "extra" would be copied to user space.
2443          */
2444         sprintf(extra, "0x%05x", data32);
2445
2446         return 0;
2447 }
2448
2449 static int rtw_wx_write_rf(struct net_device *dev,
2450                             struct iw_request_info *info,
2451                             union iwreq_data *wrqu, char *extra)
2452 {
2453         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2454         u32 path, addr, data32;
2455
2456
2457         path = *(u32*)extra;
2458         addr = *((u32*)extra + 1);
2459         data32 = *((u32*)extra + 2);
2460 /*      DBG_871X("%s: path =%d addr = 0x%02x data = 0x%05x\n", __func__, path, addr, data32); */
2461         rtw_hal_write_rfreg(padapter, path, addr, 0xFFFFF, data32);
2462
2463         return 0;
2464 }
2465
2466 static int rtw_wx_priv_null(struct net_device *dev, struct iw_request_info *a,
2467                  union iwreq_data *wrqu, char *b)
2468 {
2469         return -1;
2470 }
2471
2472 static int dummy(struct net_device *dev, struct iw_request_info *a,
2473                  union iwreq_data *wrqu, char *b)
2474 {
2475         /* struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev); */
2476         /* struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); */
2477
2478         /* DBG_871X("cmd_code =%x, fwstate = 0x%x\n", a->cmd, get_fwstate(pmlmepriv)); */
2479
2480         return -1;
2481
2482 }
2483
2484 static int rtw_wx_set_channel_plan(struct net_device *dev,
2485                                struct iw_request_info *info,
2486                                union iwreq_data *wrqu, char *extra)
2487 {
2488         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2489         u8 channel_plan_req = (u8) (*((int *)wrqu));
2490
2491         if (_SUCCESS == rtw_set_chplan_cmd(padapter, channel_plan_req, 1, 1))
2492                 DBG_871X("%s set channel_plan = 0x%02X\n", __func__, channel_plan_req);
2493          else
2494                 return -EPERM;
2495
2496         return 0;
2497 }
2498
2499 static int rtw_wx_set_mtk_wps_probe_ie(struct net_device *dev,
2500                 struct iw_request_info *a,
2501                 union iwreq_data *wrqu, char *b)
2502 {
2503         return 0;
2504 }
2505
2506 static int rtw_wx_get_sensitivity(struct net_device *dev,
2507                                 struct iw_request_info *info,
2508                                 union iwreq_data *wrqu, char *buf)
2509 {
2510         return 0;
2511 }
2512
2513 static int rtw_wx_set_mtk_wps_ie(struct net_device *dev,
2514                                 struct iw_request_info *info,
2515                                 union iwreq_data *wrqu, char *extra)
2516 {
2517         return 0;
2518 }
2519
2520 /*
2521 typedef int (*iw_handler)(struct net_device *dev, struct iw_request_info *info,
2522                           union iwreq_data *wrqu, char *extra);
2523 */
2524 /*
2525  *For all data larger than 16 octets, we need to use a
2526  *pointer to memory allocated in user space.
2527  */
2528 static  int rtw_drvext_hdl(struct net_device *dev, struct iw_request_info *info,
2529                                                 union iwreq_data *wrqu, char *extra)
2530 {
2531         return 0;
2532 }
2533
2534 static int rtw_mp_ioctl_hdl(struct net_device *dev, struct iw_request_info *info,
2535                                                 union iwreq_data *wrqu, char *extra)
2536 {
2537         int ret = 0;
2538         return ret;
2539 }
2540
2541 static int rtw_get_ap_info(struct net_device *dev,
2542                                struct iw_request_info *info,
2543                                union iwreq_data *wrqu, char *extra)
2544 {
2545         int ret = 0;
2546         u32 cnt = 0, wpa_ielen;
2547         struct list_head        *plist, *phead;
2548         unsigned char *pbuf;
2549         u8 bssid[ETH_ALEN];
2550         char data[32];
2551         struct wlan_network *pnetwork = NULL;
2552         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2553         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2554         struct __queue *queue = &(pmlmepriv->scanned_queue);
2555         struct iw_point *pdata = &wrqu->data;
2556
2557         DBG_871X("+rtw_get_aplist_info\n");
2558
2559         if ((padapter->bDriverStopped) || (pdata == NULL)) {
2560                 ret = -EINVAL;
2561                 goto exit;
2562         }
2563
2564         while ((check_fwstate(pmlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING))) == true) {
2565                 msleep(30);
2566                 cnt++;
2567                 if (cnt > 100)
2568                         break;
2569         }
2570
2571
2572         /* pdata->length = 0;? */
2573         pdata->flags = 0;
2574         if (pdata->length>=32) {
2575                 if (copy_from_user(data, pdata->pointer, 32)) {
2576                         ret = -EINVAL;
2577                         goto exit;
2578                 }
2579         } else {
2580                 ret = -EINVAL;
2581                 goto exit;
2582         }
2583
2584         spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
2585
2586         phead = get_list_head(queue);
2587         plist = get_next(phead);
2588
2589         while (1) {
2590                 if (phead == plist)
2591                         break;
2592
2593
2594                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
2595
2596                 /* if (hwaddr_aton_i(pdata->pointer, bssid)) */
2597                 if (hwaddr_aton_i(data, bssid)) {
2598                         DBG_871X("Invalid BSSID '%s'.\n", (u8 *)data);
2599                         spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
2600                         return -EINVAL;
2601                 }
2602
2603
2604                 if (!memcmp(bssid, pnetwork->network.MacAddress, ETH_ALEN)) { /* BSSID match, then check if supporting wpa/wpa2 */
2605                         DBG_871X("BSSID:" MAC_FMT "\n", MAC_ARG(bssid));
2606
2607                         pbuf = rtw_get_wpa_ie(&pnetwork->network.IEs[12], &wpa_ielen, pnetwork->network.IELength-12);
2608                         if (pbuf && (wpa_ielen>0)) {
2609                                 pdata->flags = 1;
2610                                 break;
2611                         }
2612
2613                         pbuf = rtw_get_wpa2_ie(&pnetwork->network.IEs[12], &wpa_ielen, pnetwork->network.IELength-12);
2614                         if (pbuf && (wpa_ielen>0)) {
2615                                 pdata->flags = 2;
2616                                 break;
2617                         }
2618                 }
2619
2620                 plist = get_next(plist);
2621
2622         }
2623
2624         spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
2625
2626         if (pdata->length>=34) {
2627                 if (copy_to_user((u8 __force __user *)pdata->pointer+32, (u8 *)&pdata->flags, 1)) {
2628                         ret = -EINVAL;
2629                         goto exit;
2630                 }
2631         }
2632
2633 exit:
2634
2635         return ret;
2636
2637 }
2638
2639 static int rtw_set_pid(struct net_device *dev,
2640                                struct iw_request_info *info,
2641                                union iwreq_data *wrqu, char *extra)
2642 {
2643
2644         int ret = 0;
2645         struct adapter *padapter = rtw_netdev_priv(dev);
2646         int *pdata = (int *)wrqu;
2647         int selector;
2648
2649         if ((padapter->bDriverStopped) || (pdata == NULL)) {
2650                 ret = -EINVAL;
2651                 goto exit;
2652         }
2653
2654         selector = *pdata;
2655         if (selector < 3 && selector >= 0) {
2656                 padapter->pid[selector] = *(pdata+1);
2657                 DBG_871X("%s set pid[%d]=%d\n", __func__, selector , padapter->pid[selector]);
2658         }
2659         else
2660                 DBG_871X("%s selector %d error\n", __func__, selector);
2661
2662 exit:
2663
2664         return ret;
2665
2666 }
2667
2668 static int rtw_wps_start(struct net_device *dev,
2669                                struct iw_request_info *info,
2670                                union iwreq_data *wrqu, char *extra)
2671 {
2672
2673         int ret = 0;
2674         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2675         struct iw_point *pdata = &wrqu->data;
2676         u32   u32wps_start = 0;
2677         unsigned int uintRet = 0;
2678
2679         if ((true == padapter->bDriverStopped) ||(true ==padapter->bSurpriseRemoved) || (NULL == pdata)) {
2680                 ret = -EINVAL;
2681                 goto exit;
2682         }
2683
2684         uintRet = copy_from_user((void*) &u32wps_start, pdata->pointer, 4);
2685         if (u32wps_start == 0)
2686                 u32wps_start = *extra;
2687
2688         DBG_871X("[%s] wps_start = %d\n", __func__, u32wps_start);
2689
2690 #ifdef CONFIG_INTEL_WIDI
2691         process_intel_widi_wps_status(padapter, u32wps_start);
2692 #endif /* CONFIG_INTEL_WIDI */
2693
2694 exit:
2695
2696         return ret;
2697
2698 }
2699
2700 static int rtw_p2p_set(struct net_device *dev,
2701                                struct iw_request_info *info,
2702                                union iwreq_data *wrqu, char *extra)
2703 {
2704
2705         int ret = 0;
2706
2707         return ret;
2708
2709 }
2710
2711 static int rtw_p2p_get(struct net_device *dev,
2712                                struct iw_request_info *info,
2713                                union iwreq_data *wrqu, char *extra)
2714 {
2715
2716         int ret = 0;
2717
2718         return ret;
2719
2720 }
2721
2722 static int rtw_p2p_get2(struct net_device *dev,
2723                                                 struct iw_request_info *info,
2724                                                 union iwreq_data *wrqu, char *extra)
2725 {
2726
2727         int ret = 0;
2728
2729         return ret;
2730
2731 }
2732
2733 static int rtw_rereg_nd_name(struct net_device *dev,
2734                                struct iw_request_info *info,
2735                                union iwreq_data *wrqu, char *extra)
2736 {
2737         int ret = 0;
2738         struct adapter *padapter = rtw_netdev_priv(dev);
2739         struct rereg_nd_name_data *rereg_priv = &padapter->rereg_nd_name_priv;
2740         char new_ifname[IFNAMSIZ];
2741
2742         if (rereg_priv->old_ifname[0] == 0) {
2743                 char *reg_ifname;
2744                 reg_ifname = padapter->registrypriv.ifname;
2745
2746                 strncpy(rereg_priv->old_ifname, reg_ifname, IFNAMSIZ);
2747                 rereg_priv->old_ifname[IFNAMSIZ-1] = 0;
2748         }
2749
2750         /* DBG_871X("%s wrqu->data.length:%d\n", __func__, wrqu->data.length); */
2751         if (wrqu->data.length > IFNAMSIZ)
2752                 return -EFAULT;
2753
2754         if (copy_from_user(new_ifname, wrqu->data.pointer, IFNAMSIZ))
2755                 return -EFAULT;
2756
2757         if (0 == strcmp(rereg_priv->old_ifname, new_ifname))
2758                 return ret;
2759
2760         DBG_871X("%s new_ifname:%s\n", __func__, new_ifname);
2761         if (0 != (ret = rtw_change_ifname(padapter, new_ifname)))
2762                 goto exit;
2763
2764         strncpy(rereg_priv->old_ifname, new_ifname, IFNAMSIZ);
2765         rereg_priv->old_ifname[IFNAMSIZ-1] = 0;
2766
2767         if (!memcmp(new_ifname, "disable%d", 9)) {
2768
2769                 DBG_871X("%s disable\n", __func__);
2770                 /*  free network queue for Android's timming issue */
2771                 rtw_free_network_queue(padapter, true);
2772
2773                 /*  the interface is being "disabled", we can do deeper IPS */
2774                 /* rereg_priv->old_ips_mode = rtw_get_ips_mode_req(&padapter->pwrctrlpriv); */
2775                 /* rtw_ips_mode_req(&padapter->pwrctrlpriv, IPS_NORMAL); */
2776         }
2777 exit:
2778         return ret;
2779
2780 }
2781
2782 static int rtw_dbg_port(struct net_device *dev,
2783                                struct iw_request_info *info,
2784                                union iwreq_data *wrqu, char *extra)
2785 {
2786         int ret = 0;
2787         u8 major_cmd, minor_cmd;
2788         u16 arg;
2789         u32 extra_arg, *pdata, val32;
2790         struct sta_info *psta;
2791         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2792         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2793         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2794         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2795         struct wlan_network *cur_network = &(pmlmepriv->cur_network);
2796         struct sta_priv *pstapriv = &padapter->stapriv;
2797
2798
2799         pdata = (u32*)&wrqu->data;
2800
2801         val32 = *pdata;
2802         arg = (u16)(val32&0x0000ffff);
2803         major_cmd = (u8)(val32>>24);
2804         minor_cmd = (u8)((val32>>16)&0x00ff);
2805
2806         extra_arg = *(pdata+1);
2807
2808         switch (major_cmd) {
2809                 case 0x70:/* read_reg */
2810                         switch (minor_cmd) {
2811                                 case 1:
2812                                         DBG_871X("rtw_read8(0x%x) = 0x%02x\n", arg, rtw_read8(padapter, arg));
2813                                         break;
2814                                 case 2:
2815                                         DBG_871X("rtw_read16(0x%x) = 0x%04x\n", arg, rtw_read16(padapter, arg));
2816                                         break;
2817                                 case 4:
2818                                         DBG_871X("rtw_read32(0x%x) = 0x%08x\n", arg, rtw_read32(padapter, arg));
2819                                         break;
2820                         }
2821                         break;
2822                 case 0x71:/* write_reg */
2823                         switch (minor_cmd) {
2824                                 case 1:
2825                                         rtw_write8(padapter, arg, extra_arg);
2826                                         DBG_871X("rtw_write8(0x%x) = 0x%02x\n", arg, rtw_read8(padapter, arg));
2827                                         break;
2828                                 case 2:
2829                                         rtw_write16(padapter, arg, extra_arg);
2830                                         DBG_871X("rtw_write16(0x%x) = 0x%04x\n", arg, rtw_read16(padapter, arg));
2831                                         break;
2832                                 case 4:
2833                                         rtw_write32(padapter, arg, extra_arg);
2834                                         DBG_871X("rtw_write32(0x%x) = 0x%08x\n", arg, rtw_read32(padapter, arg));
2835                                         break;
2836                         }
2837                         break;
2838                 case 0x72:/* read_bb */
2839                         DBG_871X("read_bbreg(0x%x) = 0x%x\n", arg, rtw_hal_read_bbreg(padapter, arg, 0xffffffff));
2840                         break;
2841                 case 0x73:/* write_bb */
2842                         rtw_hal_write_bbreg(padapter, arg, 0xffffffff, extra_arg);
2843                         DBG_871X("write_bbreg(0x%x) = 0x%x\n", arg, rtw_hal_read_bbreg(padapter, arg, 0xffffffff));
2844                         break;
2845                 case 0x74:/* read_rf */
2846                         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));
2847                         break;
2848                 case 0x75:/* write_rf */
2849                         rtw_hal_write_rfreg(padapter, minor_cmd, arg, 0xffffffff, extra_arg);
2850                         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));
2851                         break;
2852
2853                 case 0x76:
2854                         switch (minor_cmd) {
2855                                 case 0x00: /* normal mode, */
2856                                         padapter->recvpriv.is_signal_dbg = 0;
2857                                         break;
2858                                 case 0x01: /* dbg mode */
2859                                         padapter->recvpriv.is_signal_dbg = 1;
2860                                         extra_arg = extra_arg>100?100:extra_arg;
2861                                         padapter->recvpriv.signal_strength_dbg =extra_arg;
2862                                         break;
2863                         }
2864                         break;
2865                 case 0x78: /* IOL test */
2866                         break;
2867                 case 0x79:
2868                         {
2869                                 /*
2870                                 * dbg 0x79000000 [value], set RESP_TXAGC to + value, value:0~15
2871                                 * dbg 0x79010000 [value], set RESP_TXAGC to - value, value:0~15
2872                                 */
2873                                 u8 value =  extra_arg & 0x0f;
2874                                 u8 sign = minor_cmd;
2875                                 u16 write_value = 0;
2876
2877                                 DBG_871X("%s set RESP_TXAGC to %s %u\n", __func__, sign?"minus":"plus", value);
2878
2879                                 if (sign)
2880                                         value = value | 0x10;
2881
2882                                 write_value = value | (value << 5);
2883                                 rtw_write16(padapter, 0x6d9, write_value);
2884                         }
2885                         break;
2886                 case 0x7a:
2887                         receive_disconnect(padapter, pmlmeinfo->network.MacAddress
2888                                 , WLAN_REASON_EXPIRATION_CHK);
2889                         break;
2890                 case 0x7F:
2891                         switch (minor_cmd) {
2892                                 case 0x0:
2893                                         DBG_871X("fwstate = 0x%x\n", get_fwstate(pmlmepriv));
2894                                         break;
2895                                 case 0x01:
2896                                         DBG_871X("minor_cmd 0x%x\n", minor_cmd);
2897                                         break;
2898                                 case 0x02:
2899                                         DBG_871X("pmlmeinfo->state = 0x%x\n", pmlmeinfo->state);
2900                                         DBG_871X("DrvBcnEarly =%d\n", pmlmeext->DrvBcnEarly);
2901                                         DBG_871X("DrvBcnTimeOut =%d\n", pmlmeext->DrvBcnTimeOut);
2902                                         break;
2903                                 case 0x03:
2904                                         DBG_871X("qos_option =%d\n", pmlmepriv->qospriv.qos_option);
2905                                         DBG_871X("ht_option =%d\n", pmlmepriv->htpriv.ht_option);
2906                                         break;
2907                                 case 0x04:
2908                                         DBG_871X("cur_ch =%d\n", pmlmeext->cur_channel);
2909                                         DBG_871X("cur_bw =%d\n", pmlmeext->cur_bwmode);
2910                                         DBG_871X("cur_ch_off =%d\n", pmlmeext->cur_ch_offset);
2911
2912                                         DBG_871X("oper_ch =%d\n", rtw_get_oper_ch(padapter));
2913                                         DBG_871X("oper_bw =%d\n", rtw_get_oper_bw(padapter));
2914                                         DBG_871X("oper_ch_offet =%d\n", rtw_get_oper_choffset(padapter));
2915
2916                                         break;
2917                                 case 0x05:
2918                                         psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
2919                                         if (psta) {
2920                                                 int i;
2921                                                 struct recv_reorder_ctrl *preorder_ctrl;
2922
2923                                                 DBG_871X("SSID =%s\n", cur_network->network.Ssid.Ssid);
2924                                                 DBG_871X("sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr));
2925                                                 DBG_871X("cur_channel =%d, cur_bwmode =%d, cur_ch_offset =%d\n", pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
2926                                                 DBG_871X("rtsen =%d, cts2slef =%d\n", psta->rtsen, psta->cts2self);
2927                                                 DBG_871X("state = 0x%x, aid =%d, macid =%d, raid =%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
2928                                                 DBG_871X("qos_en =%d, ht_en =%d, init_rate =%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
2929                                                 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);
2930                                                 DBG_871X("ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
2931                                                 DBG_871X("agg_enable_bitmap =%x, candidate_tid_bitmap =%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
2932
2933                                                 for (i = 0;i<16;i++) {
2934                                                         preorder_ctrl = &psta->recvreorder_ctrl[i];
2935                                                         if (preorder_ctrl->enable)
2936                                                                 DBG_871X("tid =%d, indicate_seq =%d\n", i, preorder_ctrl->indicate_seq);
2937                                                 }
2938
2939                                         } else {
2940                                                 DBG_871X("can't get sta's macaddr, cur_network's macaddr:" MAC_FMT "\n", MAC_ARG(cur_network->network.MacAddress));
2941                                         }
2942                                         break;
2943                                 case 0x06:
2944                                         {
2945                                                 u32 ODMFlag;
2946                                                 rtw_hal_get_hwreg(padapter, HW_VAR_DM_FLAG, (u8 *)(&ODMFlag));
2947                                                 DBG_871X("(B)DMFlag = 0x%x, arg = 0x%x\n", ODMFlag, arg);
2948                                                 ODMFlag = (u32)(0x0f&arg);
2949                                                 DBG_871X("(A)DMFlag = 0x%x\n", ODMFlag);
2950                                                 rtw_hal_set_hwreg(padapter, HW_VAR_DM_FLAG, (u8 *)(&ODMFlag));
2951                                         }
2952                                         break;
2953                                 case 0x07:
2954                                         DBG_871X("bSurpriseRemoved =%d, bDriverStopped =%d\n",
2955                                                 padapter->bSurpriseRemoved, padapter->bDriverStopped);
2956                                         break;
2957                                 case 0x08:
2958                                         {
2959                                                 DBG_871X("minor_cmd 0x%x\n", minor_cmd);
2960                                         }
2961                                         break;
2962                                 case 0x09:
2963                                         {
2964                                                 int i, j;
2965                                                 struct list_head        *plist, *phead;
2966                                                 struct recv_reorder_ctrl *preorder_ctrl;
2967
2968                                                 DBG_871X("sta_dz_bitmap = 0x%x, tim_bitmap = 0x%x\n", pstapriv->sta_dz_bitmap, pstapriv->tim_bitmap);
2969
2970                                                 spin_lock_bh(&pstapriv->sta_hash_lock);
2971
2972                                                 for (i = 0; i< NUM_STA; i++) {
2973                                                         phead = &(pstapriv->sta_hash[i]);
2974                                                         plist = get_next(phead);
2975
2976                                                         while (phead != plist) {
2977                                                                 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
2978
2979                                                                 plist = get_next(plist);
2980
2981                                                                 if (extra_arg == psta->aid) {
2982                                                                         DBG_871X("sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr));
2983                                                                         DBG_871X("rtsen =%d, cts2slef =%d\n", psta->rtsen, psta->cts2self);
2984                                                                         DBG_871X("state = 0x%x, aid =%d, macid =%d, raid =%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
2985                                                                         DBG_871X("qos_en =%d, ht_en =%d, init_rate =%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
2986                                                                         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);
2987                                                                         DBG_871X("ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
2988                                                                         DBG_871X("agg_enable_bitmap =%x, candidate_tid_bitmap =%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
2989                                                                         DBG_871X("capability = 0x%x\n", psta->capability);
2990                                                                         DBG_871X("flags = 0x%x\n", psta->flags);
2991                                                                         DBG_871X("wpa_psk = 0x%x\n", psta->wpa_psk);
2992                                                                         DBG_871X("wpa2_group_cipher = 0x%x\n", psta->wpa2_group_cipher);
2993                                                                         DBG_871X("wpa2_pairwise_cipher = 0x%x\n", psta->wpa2_pairwise_cipher);
2994                                                                         DBG_871X("qos_info = 0x%x\n", psta->qos_info);
2995                                                                         DBG_871X("dot118021XPrivacy = 0x%x\n", psta->dot118021XPrivacy);
2996
2997
2998
2999                                                                         for (j = 0;j<16;j++) {
3000                                                                                 preorder_ctrl = &psta->recvreorder_ctrl[j];
3001                                                                                 if (preorder_ctrl->enable)
3002                                                                                         DBG_871X("tid =%d, indicate_seq =%d\n", j, preorder_ctrl->indicate_seq);
3003                                                                         }
3004                                                                 }
3005                                                         }
3006                                                 }
3007
3008                                                 spin_unlock_bh(&pstapriv->sta_hash_lock);
3009
3010                                         }
3011                                         break;
3012                                 case 0x0a:
3013                                         {
3014                                                 int max_mac_id = 0;
3015                                                 max_mac_id = rtw_search_max_mac_id(padapter);
3016                                                 printk("%s ==> max_mac_id = %d\n", __func__, max_mac_id);
3017                                         }
3018                                         break;
3019                                 case 0x0b: /* Enable = 1, Disable = 0 driver control vrtl_carrier_sense. */
3020                                         if (arg == 0) {
3021                                                 DBG_871X("disable driver ctrl vcs\n");
3022                                                 padapter->driver_vcs_en = 0;
3023                                         } else if (arg == 1) {
3024                                                 DBG_871X("enable driver ctrl vcs = %d\n", extra_arg);
3025                                                 padapter->driver_vcs_en = 1;
3026
3027                                                 if (extra_arg>2)
3028                                                         padapter->driver_vcs_type = 1;
3029                                                 else
3030                                                         padapter->driver_vcs_type = extra_arg;
3031                                         }
3032                                         break;
3033                                 case 0x0c:/* dump rx/tx packet */
3034                                         {
3035                                                 if (arg == 0) {
3036                                                         DBG_871X("dump rx packet (%d)\n", extra_arg);
3037                                                         /* pHalData->bDumpRxPkt =extra_arg; */
3038                                                         rtw_hal_set_def_var(padapter, HAL_DEF_DBG_DUMP_RXPKT, &(extra_arg));
3039                                                 } else if (arg == 1) {
3040                                                         DBG_871X("dump tx packet (%d)\n", extra_arg);
3041                                                         rtw_hal_set_def_var(padapter, HAL_DEF_DBG_DUMP_TXPKT, &(extra_arg));
3042                                                 }
3043                                         }
3044                                         break;
3045                                 case 0x0e:
3046                                         {
3047                                                 if (arg == 0) {
3048                                                         DBG_871X("disable driver ctrl rx_ampdu_factor\n");
3049                                                         padapter->driver_rx_ampdu_factor = 0xFF;
3050                                                 } else if (arg == 1) {
3051
3052                                                         DBG_871X("enable driver ctrl rx_ampdu_factor = %d\n", extra_arg);
3053
3054                                                         if ((extra_arg & 0x03) > 0x03)
3055                                                                 padapter->driver_rx_ampdu_factor = 0xFF;
3056                                                         else
3057                                                                 padapter->driver_rx_ampdu_factor = extra_arg;
3058                                                 }
3059                                         }
3060                                         break;
3061
3062                                 case 0x10:/*  driver version display */
3063                                         dump_drv_version(RTW_DBGDUMP);
3064                                         break;
3065                                 case 0x11:/* dump linked status */
3066                                         {
3067                                                  linked_info_dump(padapter, extra_arg);
3068                                         }
3069                                         break;
3070                                 case 0x12: /* set rx_stbc */
3071                                 {
3072                                         struct registry_priv *pregpriv = &padapter->registrypriv;
3073                                         /*  0: disable, bit(0):enable 2.4g, bit(1):enable 5g, 0x3: enable both 2.4g and 5g */
3074                                         /* default is set to enable 2.4GHZ for IOT issue with bufflao's AP at 5GHZ */
3075                                         if (pregpriv && (extra_arg == 0 || extra_arg == 1|| extra_arg == 2 || extra_arg == 3)) {
3076                                                 pregpriv->rx_stbc = extra_arg;
3077                                                 DBG_871X("set rx_stbc =%d\n", pregpriv->rx_stbc);
3078                                         } else
3079                                                 DBG_871X("get rx_stbc =%d\n", pregpriv->rx_stbc);
3080
3081                                 }
3082                                 break;
3083                                 case 0x13: /* set ampdu_enable */
3084                                 {
3085                                         struct registry_priv *pregpriv = &padapter->registrypriv;
3086                                         /*  0: disable, 0x1:enable (but wifi_spec should be 0), 0x2: force enable (don't care wifi_spec) */
3087                                         if (pregpriv && extra_arg < 3) {
3088                                                 pregpriv->ampdu_enable = extra_arg;
3089                                                 DBG_871X("set ampdu_enable =%d\n", pregpriv->ampdu_enable);
3090                                         } else
3091                                                 DBG_871X("get ampdu_enable =%d\n", pregpriv->ampdu_enable);
3092
3093                                 }
3094                                 break;
3095                                 case 0x14:
3096                                 {
3097                                         DBG_871X("minor_cmd 0x%x\n", minor_cmd);
3098                                 }
3099                                 break;
3100                                 case 0x16:
3101                                 {
3102                                         if (arg == 0xff) {
3103                                                 rtw_odm_dbg_comp_msg(RTW_DBGDUMP, padapter);
3104                                         } else {
3105                                                 u64 dbg_comp = (u64)extra_arg;
3106                                                 rtw_odm_dbg_comp_set(padapter, dbg_comp);
3107                                         }
3108                                 }
3109                                         break;
3110 #ifdef DBG_FIXED_CHAN
3111                                 case 0x17:
3112                                         {
3113                                                 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
3114                                                 printk("===>  Fixed channel to %d\n", extra_arg);
3115                                                 pmlmeext->fixed_chan = extra_arg;
3116
3117                                         }
3118                                         break;
3119 #endif
3120                                 case 0x18:
3121                                         {
3122                                                 printk("===>  Switch USB Mode %d\n", extra_arg);
3123                                                 rtw_hal_set_hwreg(padapter, HW_VAR_USB_MODE, (u8 *)&extra_arg);
3124                                         }
3125                                         break;
3126                                 case 0x19:
3127                                         {
3128                                                 struct registry_priv *pregistrypriv = &padapter->registrypriv;
3129                                                 /*  extra_arg : */
3130                                                 /*  BIT0: Enable VHT LDPC Rx, BIT1: Enable VHT LDPC Tx, */
3131                                                 /*  BIT4: Enable HT LDPC Rx, BIT5: Enable HT LDPC Tx */
3132                                                 if (arg == 0) {
3133                                                         DBG_871X("driver disable LDPC\n");
3134                                                         pregistrypriv->ldpc_cap = 0x00;
3135                                                 } else if (arg == 1) {
3136                                                         DBG_871X("driver set LDPC cap = 0x%x\n", extra_arg);
3137                                                         pregistrypriv->ldpc_cap = (u8)(extra_arg&0x33);
3138                                                 }
3139                                         }
3140                                         break;
3141                                 case 0x1a:
3142                                         {
3143                                                 struct registry_priv *pregistrypriv = &padapter->registrypriv;
3144                                                 /*  extra_arg : */
3145                                                 /*  BIT0: Enable VHT STBC Rx, BIT1: Enable VHT STBC Tx, */
3146                                                 /*  BIT4: Enable HT STBC Rx, BIT5: Enable HT STBC Tx */
3147                                                 if (arg == 0) {
3148                                                         DBG_871X("driver disable STBC\n");
3149                                                         pregistrypriv->stbc_cap = 0x00;
3150                                                 } else if (arg == 1) {
3151                                                         DBG_871X("driver set STBC cap = 0x%x\n", extra_arg);
3152                                                         pregistrypriv->stbc_cap = (u8)(extra_arg&0x33);
3153                                                 }
3154                                         }
3155                                         break;
3156                                 case 0x1b:
3157                                         {
3158                                                 struct registry_priv *pregistrypriv = &padapter->registrypriv;
3159
3160                                                 if (arg == 0) {
3161                                                         DBG_871X("disable driver ctrl max_rx_rate, reset to default_rate_set\n");
3162                                                         init_mlme_default_rate_set(padapter);
3163                                                         pregistrypriv->ht_enable = (u8)rtw_ht_enable;
3164                                                 } else if (arg == 1) {
3165
3166                                                         int i;
3167                                                         u8 max_rx_rate;
3168
3169                                                         DBG_871X("enable driver ctrl max_rx_rate = 0x%x\n", extra_arg);
3170
3171                                                         max_rx_rate = (u8)extra_arg;
3172
3173                                                         if (max_rx_rate < 0xc) { /*  max_rx_rate < MSC0 -> B or G -> disable HT */
3174                                                                 pregistrypriv->ht_enable = 0;
3175                                                                 for (i = 0; i<NumRates; i++) {
3176                                                                         if (pmlmeext->datarate[i] > max_rx_rate)
3177                                                                                 pmlmeext->datarate[i] = 0xff;
3178                                                                 }
3179
3180                                                         }
3181                                                         else if (max_rx_rate < 0x1c) { /*  mcs0~mcs15 */
3182                                                                 u32 mcs_bitmap = 0x0;
3183
3184                                                                 for (i = 0; i<((max_rx_rate+1)-0xc); i++)
3185                                                                         mcs_bitmap |= BIT(i);
3186
3187                                                                 set_mcs_rate_by_mask(pmlmeext->default_supported_mcs_set, mcs_bitmap);
3188                                                         }
3189                                                 }
3190                                         }
3191                                         break;
3192                                 case 0x1c: /* enable/disable driver control AMPDU Density for peer sta's rx */
3193                                         {
3194                                                 if (arg == 0) {
3195                                                         DBG_871X("disable driver ctrl ampdu density\n");
3196                                                         padapter->driver_ampdu_spacing = 0xFF;
3197                                                 } else if (arg == 1) {
3198
3199                                                         DBG_871X("enable driver ctrl ampdu density = %d\n", extra_arg);
3200
3201                                                         if ((extra_arg & 0x07) > 0x07)
3202                                                                 padapter->driver_ampdu_spacing = 0xFF;
3203                                                         else
3204                                                                 padapter->driver_ampdu_spacing = extra_arg;
3205                                                 }
3206                                         }
3207                                         break;
3208 #ifdef CONFIG_BACKGROUND_NOISE_MONITOR
3209                                 case 0x1e:
3210                                         {
3211                                                 struct hal_com_data     *pHalData = GET_HAL_DATA(padapter);
3212                                                 PDM_ODM_T pDM_Odm = &pHalData->odmpriv;
3213                                                 u8 chan = rtw_get_oper_ch(padapter);
3214                                                 DBG_871X("===========================================\n");
3215                                                 ODM_InbandNoise_Monitor(pDM_Odm, true, 0x1e, 100);
3216                                                 DBG_871X("channel(%d), noise_a = %d, noise_b = %d , noise_all:%d\n",
3217                                                         chan, pDM_Odm->noise_level.noise[ODM_RF_PATH_A],
3218                                                         pDM_Odm->noise_level.noise[ODM_RF_PATH_B],
3219                                                         pDM_Odm->noise_level.noise_all);
3220                                                 DBG_871X("===========================================\n");
3221
3222                                         }
3223                                         break;
3224 #endif
3225                                 case 0x23:
3226                                         {
3227                                                 DBG_871X("turn %s the bNotifyChannelChange Variable\n", (extra_arg == 1)?"on":"off");
3228                                                 padapter->bNotifyChannelChange = extra_arg;
3229                                                 break;
3230                                         }
3231                                 case 0x24:
3232                                         {
3233                                                 break;
3234                                         }
3235 #ifdef CONFIG_GPIO_API
3236                             case 0x25: /* Get GPIO register */
3237                                     {
3238                                             /*
3239                                             * dbg 0x7f250000 [gpio_num], Get gpio value, gpio_num:0~7
3240                                             */
3241
3242                                             int value;
3243                                             DBG_871X("Read GPIO Value  extra_arg = %d\n", extra_arg);
3244                                             value = rtw_get_gpio(dev, extra_arg);
3245                                             DBG_871X("Read GPIO Value = %d\n", value);
3246                                             break;
3247                                     }
3248                             case 0x26: /* Set GPIO direction */
3249                                     {
3250
3251                                             /* dbg 0x7f26000x [y], Set gpio direction,
3252                                             * x: gpio_num, 4~7  y: indicate direction, 0~1
3253                                             */
3254
3255                                             int value;
3256                                             DBG_871X("Set GPIO Direction! arg = %d , extra_arg =%d\n", arg , extra_arg);
3257                                             value = rtw_config_gpio(dev, arg, extra_arg);
3258                                             DBG_871X("Set GPIO Direction %s\n", (value ==-1)?"Fail!!!":"Success");
3259                                             break;
3260                                         }
3261                                 case 0x27: /* Set GPIO output direction value */
3262                                         {
3263                                                 /*
3264                                                 * dbg 0x7f27000x [y], Set gpio output direction value,
3265                                                 * x: gpio_num, 4~7  y: indicate direction, 0~1
3266                                                 */
3267
3268                                                 int value;
3269                                                 DBG_871X("Set GPIO Value! arg = %d , extra_arg =%d\n", arg , extra_arg);
3270                                                 value = rtw_set_gpio_output_value(dev, arg, extra_arg);
3271                                                 DBG_871X("Set GPIO Value %s\n", (value ==-1)?"Fail!!!":"Success");
3272                                                 break;
3273                                         }
3274 #endif
3275                                 case 0xaa:
3276                                         {
3277                                                 if ((extra_arg & 0x7F)> 0x3F) extra_arg = 0xFF;
3278                                                 DBG_871X("chang data rate to :0x%02x\n", extra_arg);
3279                                                 padapter->fix_rate = extra_arg;
3280                                         }
3281                                         break;
3282                                 case 0xdd:/* registers dump , 0 for mac reg, 1 for bb reg, 2 for rf reg */
3283                                         {
3284                                                 if (extra_arg == 0)
3285                                                         mac_reg_dump(RTW_DBGDUMP, padapter);
3286                                                 else if (extra_arg == 1)
3287                                                         bb_reg_dump(RTW_DBGDUMP, padapter);
3288                                                 else if (extra_arg ==2)
3289                                                         rf_reg_dump(RTW_DBGDUMP, padapter);
3290                                         }
3291                                         break;
3292
3293                                 case 0xee:/* turn on/off dynamic funcs */
3294                                         {
3295                                                 u32 odm_flag;
3296
3297                                                 if (0xf ==extra_arg) {
3298                                                         rtw_hal_get_def_var(padapter, HAL_DEF_DBG_DM_FUNC,&odm_flag);
3299                                                         DBG_871X(" === DMFlag(0x%08x) ===\n", odm_flag);
3300                                                         DBG_871X("extra_arg = 0  - disable all dynamic func\n");
3301                                                         DBG_871X("extra_arg = 1  - disable DIG- BIT(0)\n");
3302                                                         DBG_871X("extra_arg = 2  - disable High power - BIT(1)\n");
3303                                                         DBG_871X("extra_arg = 3  - disable tx power tracking - BIT(2)\n");
3304                                                         DBG_871X("extra_arg = 4  - disable BT coexistence - BIT(3)\n");
3305                                                         DBG_871X("extra_arg = 5  - disable antenna diversity - BIT(4)\n");
3306                                                         DBG_871X("extra_arg = 6  - enable all dynamic func\n");
3307                                                 } else {
3308                                                         /*extra_arg = 0  - disable all dynamic func
3309                                                                 extra_arg = 1  - disable DIG
3310                                                                 extra_arg = 2  - disable tx power tracking
3311                                                                 extra_arg = 3  - turn on all dynamic func
3312                                                         */
3313                                                         rtw_hal_set_def_var(padapter, HAL_DEF_DBG_DM_FUNC, &(extra_arg));
3314                                                         rtw_hal_get_def_var(padapter, HAL_DEF_DBG_DM_FUNC,&odm_flag);
3315                                                         DBG_871X(" === DMFlag(0x%08x) ===\n", odm_flag);
3316                                                 }
3317                                         }
3318                                         break;
3319
3320                                 case 0xfd:
3321                                         rtw_write8(padapter, 0xc50, arg);
3322                                         DBG_871X("wr(0xc50) = 0x%x\n", rtw_read8(padapter, 0xc50));
3323                                         rtw_write8(padapter, 0xc58, arg);
3324                                         DBG_871X("wr(0xc58) = 0x%x\n", rtw_read8(padapter, 0xc58));
3325                                         break;
3326                                 case 0xfe:
3327                                         DBG_871X("rd(0xc50) = 0x%x\n", rtw_read8(padapter, 0xc50));
3328                                         DBG_871X("rd(0xc58) = 0x%x\n", rtw_read8(padapter, 0xc58));
3329                                         break;
3330                                 case 0xff:
3331                                         {
3332                                                 DBG_871X("dbg(0x210) = 0x%x\n", rtw_read32(padapter, 0x210));
3333                                                 DBG_871X("dbg(0x608) = 0x%x\n", rtw_read32(padapter, 0x608));
3334                                                 DBG_871X("dbg(0x280) = 0x%x\n", rtw_read32(padapter, 0x280));
3335                                                 DBG_871X("dbg(0x284) = 0x%x\n", rtw_read32(padapter, 0x284));
3336                                                 DBG_871X("dbg(0x288) = 0x%x\n", rtw_read32(padapter, 0x288));
3337
3338                                                 DBG_871X("dbg(0x664) = 0x%x\n", rtw_read32(padapter, 0x664));
3339
3340
3341                                                 DBG_871X("\n");
3342
3343                                                 DBG_871X("dbg(0x430) = 0x%x\n", rtw_read32(padapter, 0x430));
3344                                                 DBG_871X("dbg(0x438) = 0x%x\n", rtw_read32(padapter, 0x438));
3345
3346                                                 DBG_871X("dbg(0x440) = 0x%x\n", rtw_read32(padapter, 0x440));
3347
3348                                                 DBG_871X("dbg(0x458) = 0x%x\n", rtw_read32(padapter, 0x458));
3349
3350                                                 DBG_871X("dbg(0x484) = 0x%x\n", rtw_read32(padapter, 0x484));
3351                                                 DBG_871X("dbg(0x488) = 0x%x\n", rtw_read32(padapter, 0x488));
3352
3353                                                 DBG_871X("dbg(0x444) = 0x%x\n", rtw_read32(padapter, 0x444));
3354                                                 DBG_871X("dbg(0x448) = 0x%x\n", rtw_read32(padapter, 0x448));
3355                                                 DBG_871X("dbg(0x44c) = 0x%x\n", rtw_read32(padapter, 0x44c));
3356                                                 DBG_871X("dbg(0x450) = 0x%x\n", rtw_read32(padapter, 0x450));
3357                                         }
3358                                         break;
3359                         }
3360                         break;
3361                 default:
3362                         DBG_871X("error dbg cmd!\n");
3363                         break;
3364         }
3365
3366
3367         return ret;
3368
3369 }
3370
3371 static int wpa_set_param(struct net_device *dev, u8 name, u32 value)
3372 {
3373         uint ret = 0;
3374         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
3375
3376         switch (name) {
3377         case IEEE_PARAM_WPA_ENABLED:
3378
3379                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; /* 802.1x */
3380
3381                 /* ret = ieee80211_wpa_enable(ieee, value); */
3382
3383                 switch ((value)&0xff) {
3384                 case 1 : /* WPA */
3385                         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPAPSK; /* WPA_PSK */
3386                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
3387                         break;
3388                 case 2: /* WPA2 */
3389                         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPA2PSK; /* WPA2_PSK */
3390                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
3391                         break;
3392                 }
3393
3394                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("wpa_set_param:padapter->securitypriv.ndisauthtype =%d\n", padapter->securitypriv.ndisauthtype));
3395
3396                 break;
3397
3398         case IEEE_PARAM_TKIP_COUNTERMEASURES:
3399                 /* ieee->tkip_countermeasures =value; */
3400                 break;
3401
3402         case IEEE_PARAM_DROP_UNENCRYPTED:
3403         {
3404                 /* HACK:
3405                  *
3406                  * wpa_supplicant calls set_wpa_enabled when the driver
3407                  * is loaded and unloaded, regardless of if WPA is being
3408                  * used.  No other calls are made which can be used to
3409                  * determine if encryption will be used or not prior to
3410                  * association being expected.  If encryption is not being
3411                  * used, drop_unencrypted is set to false, else true -- we
3412                  * can use this to determine if the CAP_PRIVACY_ON bit should
3413                  * be set.
3414                  */
3415                 break;
3416
3417         }
3418         case IEEE_PARAM_PRIVACY_INVOKED:
3419
3420                 /* ieee->privacy_invoked =value; */
3421
3422                 break;
3423
3424         case IEEE_PARAM_AUTH_ALGS:
3425
3426                 ret = wpa_set_auth_algs(dev, value);
3427
3428                 break;
3429
3430         case IEEE_PARAM_IEEE_802_1X:
3431
3432                 /* ieee->ieee802_1x =value; */
3433
3434                 break;
3435
3436         case IEEE_PARAM_WPAX_SELECT:
3437
3438                 /*  added for WPA2 mixed mode */
3439                 /* DBG_871X(KERN_WARNING "------------------------>wpax value = %x\n", value); */
3440                 /*
3441                 spin_lock_irqsave(&ieee->wpax_suitlist_lock, flags);
3442                 ieee->wpax_type_set = 1;
3443                 ieee->wpax_type_notify = value;
3444                 spin_unlock_irqrestore(&ieee->wpax_suitlist_lock, flags);
3445                 */
3446
3447                 break;
3448
3449         default:
3450
3451
3452
3453                 ret = -EOPNOTSUPP;
3454
3455
3456                 break;
3457
3458         }
3459
3460         return ret;
3461
3462 }
3463
3464 static int wpa_mlme(struct net_device *dev, u32 command, u32 reason)
3465 {
3466         int ret = 0;
3467         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
3468
3469         switch (command) {
3470                 case IEEE_MLME_STA_DEAUTH:
3471
3472                         if (!rtw_set_802_11_disassociate(padapter))
3473                                 ret = -1;
3474
3475                         break;
3476
3477                 case IEEE_MLME_STA_DISASSOC:
3478
3479                         if (!rtw_set_802_11_disassociate(padapter))
3480                                 ret = -1;
3481
3482                         break;
3483
3484                 default:
3485                         ret = -EOPNOTSUPP;
3486                         break;
3487         }
3488
3489         return ret;
3490
3491 }
3492
3493 static int wpa_supplicant_ioctl(struct net_device *dev, struct iw_point *p)
3494 {
3495         struct ieee_param *param;
3496         uint ret = 0;
3497
3498         /* down(&ieee->wx_sem); */
3499
3500         if (!p->pointer || p->length != sizeof(struct ieee_param)) {
3501                 ret = -EINVAL;
3502                 goto out;
3503         }
3504
3505         param = (struct ieee_param *)rtw_malloc(p->length);
3506         if (param == NULL) {
3507                 ret = -ENOMEM;
3508                 goto out;
3509         }
3510
3511         if (copy_from_user(param, p->pointer, p->length)) {
3512                 kfree(param);
3513                 ret = -EFAULT;
3514                 goto out;
3515         }
3516
3517         switch (param->cmd) {
3518
3519         case IEEE_CMD_SET_WPA_PARAM:
3520                 ret = wpa_set_param(dev, param->u.wpa_param.name, param->u.wpa_param.value);
3521                 break;
3522
3523         case IEEE_CMD_SET_WPA_IE:
3524                 /* ret = wpa_set_wpa_ie(dev, param, p->length); */
3525                 ret =  rtw_set_wpa_ie((struct adapter *)rtw_netdev_priv(dev), (char*)param->u.wpa_ie.data, (u16)param->u.wpa_ie.len);
3526                 break;
3527
3528         case IEEE_CMD_SET_ENCRYPTION:
3529                 ret = wpa_set_encryption(dev, param, p->length);
3530                 break;
3531
3532         case IEEE_CMD_MLME:
3533                 ret = wpa_mlme(dev, param->u.mlme.command, param->u.mlme.reason_code);
3534                 break;
3535
3536         default:
3537                 DBG_871X("Unknown WPA supplicant request: %d\n", param->cmd);
3538                 ret = -EOPNOTSUPP;
3539                 break;
3540
3541         }
3542
3543         if (ret == 0 && copy_to_user(p->pointer, param, p->length))
3544                 ret = -EFAULT;
3545
3546         kfree(param);
3547
3548 out:
3549
3550         /* up(&ieee->wx_sem); */
3551
3552         return ret;
3553
3554 }
3555
3556 static int rtw_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len)
3557 {
3558         int ret = 0;
3559         u32 wep_key_idx, wep_key_len, wep_total_len;
3560         struct ndis_802_11_wep   *pwep = NULL;
3561         struct sta_info *psta = NULL, *pbcmc_sta = NULL;
3562         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
3563         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3564         struct security_priv* psecuritypriv =&(padapter->securitypriv);
3565         struct sta_priv *pstapriv = &padapter->stapriv;
3566
3567         DBG_871X("%s\n", __func__);
3568
3569         param->u.crypt.err = 0;
3570         param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
3571
3572         /* sizeof(struct ieee_param) = 64 bytes; */
3573         /* if (param_len !=  (u32) ((u8 *) param->u.crypt.key - (u8 *) param) + param->u.crypt.key_len) */
3574         if (param_len !=  sizeof(struct ieee_param) + param->u.crypt.key_len) {
3575                 ret =  -EINVAL;
3576                 goto exit;
3577         }
3578
3579         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
3580             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
3581             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
3582                 if (param->u.crypt.idx >= WEP_KEYS) {
3583                         ret = -EINVAL;
3584                         goto exit;
3585                 }
3586         } else {
3587                 psta = rtw_get_stainfo(pstapriv, param->sta_addr);
3588                 if (!psta) {
3589                         /* ret = -EINVAL; */
3590                         DBG_871X("rtw_set_encryption(), sta has already been removed or never been added\n");
3591                         goto exit;
3592                 }
3593         }
3594
3595         if (strcmp(param->u.crypt.alg, "none") == 0 && (psta == NULL)) {
3596                 /* todo:clear default encryption keys */
3597
3598                 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
3599                 psecuritypriv->ndisencryptstatus = Ndis802_11EncryptionDisabled;
3600                 psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
3601                 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
3602
3603                 DBG_871X("clear default encryption keys, keyid =%d\n", param->u.crypt.idx);
3604
3605                 goto exit;
3606         }
3607
3608
3609         if (strcmp(param->u.crypt.alg, "WEP") == 0 && (psta == NULL)) {
3610                 DBG_871X("r871x_set_encryption, crypt.alg = WEP\n");
3611
3612                 wep_key_idx = param->u.crypt.idx;
3613                 wep_key_len = param->u.crypt.key_len;
3614
3615                 DBG_871X("r871x_set_encryption, wep_key_idx =%d, len =%d\n", wep_key_idx, wep_key_len);
3616
3617                 if ((wep_key_idx >= WEP_KEYS) || (wep_key_len<= 0)) {
3618                         ret = -EINVAL;
3619                         goto exit;
3620                 }
3621
3622
3623                 if (wep_key_len > 0) {
3624                         wep_key_len = wep_key_len <= 5 ? 5 : 13;
3625                         wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, KeyMaterial);
3626                         pwep =(struct ndis_802_11_wep *)rtw_malloc(wep_total_len);
3627                         if (pwep == NULL) {
3628                                 DBG_871X(" r871x_set_encryption: pwep allocate fail !!!\n");
3629                                 goto exit;
3630                         }
3631
3632                         memset(pwep, 0, wep_total_len);
3633
3634                         pwep->KeyLength = wep_key_len;
3635                         pwep->Length = wep_total_len;
3636
3637                 }
3638
3639                 pwep->KeyIndex = wep_key_idx;
3640
3641                 memcpy(pwep->KeyMaterial,  param->u.crypt.key, pwep->KeyLength);
3642
3643                 if (param->u.crypt.set_tx) {
3644                         DBG_871X("wep, set_tx = 1\n");
3645
3646                         psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
3647                         psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled;
3648                         psecuritypriv->dot11PrivacyAlgrthm = _WEP40_;
3649                         psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
3650
3651                         if (pwep->KeyLength == 13) {
3652                                 psecuritypriv->dot11PrivacyAlgrthm = _WEP104_;
3653                                 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
3654                         }
3655
3656
3657                         psecuritypriv->dot11PrivacyKeyIndex = wep_key_idx;
3658
3659                         memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength);
3660
3661                         psecuritypriv->dot11DefKeylen[wep_key_idx]=pwep->KeyLength;
3662
3663                         rtw_ap_set_wep_key(padapter, pwep->KeyMaterial, pwep->KeyLength, wep_key_idx, 1);
3664                 } else {
3665                         DBG_871X("wep, set_tx = 0\n");
3666
3667                         /* don't update "psecuritypriv->dot11PrivacyAlgrthm" and */
3668                         /* psecuritypriv->dot11PrivacyKeyIndex =keyid", but can rtw_set_key to cam */
3669
3670                         memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength);
3671
3672                         psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->KeyLength;
3673
3674                         rtw_ap_set_wep_key(padapter, pwep->KeyMaterial, pwep->KeyLength, wep_key_idx, 0);
3675                 }
3676
3677                 goto exit;
3678
3679         }
3680
3681
3682         if (!psta && check_fwstate(pmlmepriv, WIFI_AP_STATE)) { /*  group key */
3683                 if (param->u.crypt.set_tx == 1) {
3684                         if (strcmp(param->u.crypt.alg, "WEP") == 0) {
3685                                 DBG_871X("%s, set group_key, WEP\n", __func__);
3686
3687                                 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
3688
3689                                 psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
3690                                 if (param->u.crypt.key_len == 13)
3691                                                 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
3692
3693                         } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
3694                                 DBG_871X("%s, set group_key, TKIP\n", __func__);
3695
3696                                 psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
3697
3698                                 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
3699
3700                                 /* DEBUG_ERR("set key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len); */
3701                                 /* set mic key */
3702                                 memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8);
3703                                 memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8);
3704
3705                                 psecuritypriv->busetkipkey = true;
3706
3707                         }
3708                         else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
3709                                 DBG_871X("%s, set group_key, CCMP\n", __func__);
3710
3711                                 psecuritypriv->dot118021XGrpPrivacy = _AES_;
3712
3713                                 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
3714                         } else {
3715                                 DBG_871X("%s, set group_key, none\n", __func__);
3716
3717                                 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
3718                         }
3719
3720                         psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
3721
3722                         psecuritypriv->binstallGrpkey = true;
3723
3724                         psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/*  */
3725
3726                         rtw_ap_set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx);
3727
3728                         pbcmc_sta =rtw_get_bcmc_stainfo(padapter);
3729                         if (pbcmc_sta) {
3730                                 pbcmc_sta->ieee8021x_blocked = false;
3731                                 pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */
3732                         }
3733                 }
3734
3735                 goto exit;
3736
3737         }
3738
3739         if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X && psta) { /*  psk/802_1x */
3740                 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
3741                         if (param->u.crypt.set_tx == 1) {
3742                                 memcpy(psta->dot118021x_UncstKey.skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
3743
3744                                 if (strcmp(param->u.crypt.alg, "WEP") == 0) {
3745                                         DBG_871X("%s, set pairwise key, WEP\n", __func__);
3746
3747                                         psta->dot118021XPrivacy = _WEP40_;
3748                                         if (param->u.crypt.key_len == 13)
3749                                                 psta->dot118021XPrivacy = _WEP104_;
3750                                 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
3751                                         DBG_871X("%s, set pairwise key, TKIP\n", __func__);
3752
3753                                         psta->dot118021XPrivacy = _TKIP_;
3754
3755                                         /* DEBUG_ERR("set key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len); */
3756                                         /* set mic key */
3757                                         memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8);
3758                                         memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8);
3759
3760                                         psecuritypriv->busetkipkey = true;
3761
3762                                 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
3763
3764                                         DBG_871X("%s, set pairwise key, CCMP\n", __func__);
3765
3766                                         psta->dot118021XPrivacy = _AES_;
3767                                 } else {
3768                                         DBG_871X("%s, set pairwise key, none\n", __func__);
3769
3770                                         psta->dot118021XPrivacy = _NO_PRIVACY_;
3771                                 }
3772
3773                                 rtw_ap_set_pairwise_key(padapter, psta);
3774
3775                                 psta->ieee8021x_blocked = false;
3776
3777                         } else { /* group key??? */
3778                                 if (strcmp(param->u.crypt.alg, "WEP") == 0) {
3779                                         memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
3780
3781                                         psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
3782                                         if (param->u.crypt.key_len == 13)
3783                                                 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
3784                                 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
3785                                         psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
3786
3787                                         memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
3788
3789                                         /* DEBUG_ERR("set key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len); */
3790                                         /* set mic key */
3791                                         memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8);
3792                                         memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8);
3793
3794                                         psecuritypriv->busetkipkey = true;
3795
3796                                 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
3797                                         psecuritypriv->dot118021XGrpPrivacy = _AES_;
3798
3799                                         memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
3800                                 } else {
3801                                         psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
3802                                 }
3803
3804                                 psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
3805
3806                                 psecuritypriv->binstallGrpkey = true;
3807
3808                                 psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/*  */
3809
3810                                 rtw_ap_set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx);
3811
3812                                 pbcmc_sta =rtw_get_bcmc_stainfo(padapter);
3813                                 if (pbcmc_sta) {
3814                                         pbcmc_sta->ieee8021x_blocked = false;
3815                                         pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */
3816                                 }
3817                         }
3818                 }
3819         }
3820
3821 exit:
3822         kfree(pwep);
3823
3824         return ret;
3825
3826 }
3827
3828 static int rtw_set_beacon(struct net_device *dev, struct ieee_param *param, int len)
3829 {
3830         int ret = 0;
3831         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
3832         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3833         struct sta_priv *pstapriv = &padapter->stapriv;
3834         unsigned char *pbuf = param->u.bcn_ie.buf;
3835
3836
3837         DBG_871X("%s, len =%d\n", __func__, len);
3838
3839         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
3840                 return -EINVAL;
3841
3842         memcpy(&pstapriv->max_num_sta, param->u.bcn_ie.reserved, 2);
3843
3844         if ((pstapriv->max_num_sta>NUM_STA) || (pstapriv->max_num_sta<= 0))
3845                 pstapriv->max_num_sta = NUM_STA;
3846
3847
3848         if (rtw_check_beacon_data(padapter, pbuf,  (len-12-2)) == _SUCCESS)/*  12 = param header, 2:no packed */
3849                 ret = 0;
3850         else
3851                 ret = -EINVAL;
3852
3853
3854         return ret;
3855
3856 }
3857
3858 static int rtw_hostapd_sta_flush(struct net_device *dev)
3859 {
3860         /* _irqL irqL; */
3861         /* struct list_head     *phead, *plist; */
3862         int ret = 0;
3863         /* struct sta_info *psta = NULL; */
3864         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
3865         /* struct sta_priv *pstapriv = &padapter->stapriv; */
3866
3867         DBG_871X("%s\n", __func__);
3868
3869         flush_all_cam_entry(padapter);  /* clear CAM */
3870
3871         ret = rtw_sta_flush(padapter);
3872
3873         return ret;
3874
3875 }
3876
3877 static int rtw_add_sta(struct net_device *dev, struct ieee_param *param)
3878 {
3879         int ret = 0;
3880         struct sta_info *psta = NULL;
3881         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
3882         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3883         struct sta_priv *pstapriv = &padapter->stapriv;
3884
3885         DBG_871X("rtw_add_sta(aid =%d) =" MAC_FMT "\n", param->u.add_sta.aid, MAC_ARG(param->sta_addr));
3886
3887         if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true)
3888                 return -EINVAL;
3889
3890         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
3891             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
3892             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
3893                 return -EINVAL;
3894         }
3895
3896 /*
3897         psta = rtw_get_stainfo(pstapriv, param->sta_addr);
3898         if (psta)
3899         {
3900                 DBG_871X("rtw_add_sta(), free has been added psta =%p\n", psta);
3901                 spin_lock_bh(&(pstapriv->sta_hash_lock));
3902                 rtw_free_stainfo(padapter,  psta);
3903                 spin_unlock_bh(&(pstapriv->sta_hash_lock));
3904
3905                 psta = NULL;
3906         }
3907 */
3908         /* psta = rtw_alloc_stainfo(pstapriv, param->sta_addr); */
3909         psta = rtw_get_stainfo(pstapriv, param->sta_addr);
3910         if (psta) {
3911                 int flags = param->u.add_sta.flags;
3912
3913                 /* DBG_871X("rtw_add_sta(), init sta's variables, psta =%p\n", psta); */
3914
3915                 psta->aid = param->u.add_sta.aid;/* aid = 1~2007 */
3916
3917                 memcpy(psta->bssrateset, param->u.add_sta.tx_supp_rates, 16);
3918
3919
3920                 /* check wmm cap. */
3921                 if (WLAN_STA_WME&flags)
3922                         psta->qos_option = 1;
3923                 else
3924                         psta->qos_option = 0;
3925
3926                 if (pmlmepriv->qospriv.qos_option == 0)
3927                         psta->qos_option = 0;
3928
3929                 /* chec 802.11n ht cap. */
3930                 if (WLAN_STA_HT&flags) {
3931                         psta->htpriv.ht_option = true;
3932                         psta->qos_option = 1;
3933                         memcpy((void*)&psta->htpriv.ht_cap, (void*)&param->u.add_sta.ht_cap, sizeof(struct rtw_ieee80211_ht_cap));
3934                 } else {
3935                         psta->htpriv.ht_option = false;
3936                 }
3937
3938                 if (pmlmepriv->htpriv.ht_option == false)
3939                         psta->htpriv.ht_option = false;
3940
3941                 update_sta_info_apmode(padapter, psta);
3942
3943
3944         } else {
3945                 ret = -ENOMEM;
3946         }
3947
3948         return ret;
3949
3950 }
3951
3952 static int rtw_del_sta(struct net_device *dev, struct ieee_param *param)
3953 {
3954         int ret = 0;
3955         struct sta_info *psta = NULL;
3956         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
3957         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3958         struct sta_priv *pstapriv = &padapter->stapriv;
3959
3960         DBG_871X("rtw_del_sta =" MAC_FMT "\n", MAC_ARG(param->sta_addr));
3961
3962         if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true)
3963                 return -EINVAL;
3964
3965         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
3966             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
3967             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
3968                 return -EINVAL;
3969         }
3970
3971         psta = rtw_get_stainfo(pstapriv, param->sta_addr);
3972         if (psta) {
3973                 u8 updated =false;
3974
3975                 /* DBG_871X("free psta =%p, aid =%d\n", psta, psta->aid); */
3976
3977                 spin_lock_bh(&pstapriv->asoc_list_lock);
3978                 if (list_empty(&psta->asoc_list) ==false) {
3979                         list_del_init(&psta->asoc_list);
3980                         pstapriv->asoc_list_cnt--;
3981                         updated = ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING);
3982
3983                 }
3984                 spin_unlock_bh(&pstapriv->asoc_list_lock);
3985
3986                 associated_clients_update(padapter, updated);
3987
3988                 psta = NULL;
3989
3990         } else {
3991                 DBG_871X("rtw_del_sta(), sta has already been removed or never been added\n");
3992
3993                 /* ret = -1; */
3994         }
3995
3996
3997         return ret;
3998
3999 }
4000
4001 static int rtw_ioctl_get_sta_data(struct net_device *dev, struct ieee_param *param, int len)
4002 {
4003         int ret = 0;
4004         struct sta_info *psta = NULL;
4005         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4006         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4007         struct sta_priv *pstapriv = &padapter->stapriv;
4008         struct ieee_param_ex *param_ex = (struct ieee_param_ex *)param;
4009         struct sta_data *psta_data = (struct sta_data *)param_ex->data;
4010
4011         DBG_871X("rtw_ioctl_get_sta_info, sta_addr: " MAC_FMT "\n", MAC_ARG(param_ex->sta_addr));
4012
4013         if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true)
4014                 return -EINVAL;
4015
4016         if (param_ex->sta_addr[0] == 0xff && param_ex->sta_addr[1] == 0xff &&
4017             param_ex->sta_addr[2] == 0xff && param_ex->sta_addr[3] == 0xff &&
4018             param_ex->sta_addr[4] == 0xff && param_ex->sta_addr[5] == 0xff) {
4019                 return -EINVAL;
4020         }
4021
4022         psta = rtw_get_stainfo(pstapriv, param_ex->sta_addr);
4023         if (psta) {
4024                 psta_data->aid = (u16)psta->aid;
4025                 psta_data->capability = psta->capability;
4026                 psta_data->flags = psta->flags;
4027
4028 /*
4029                 nonerp_set : BIT(0)
4030                 no_short_slot_time_set : BIT(1)
4031                 no_short_preamble_set : BIT(2)
4032                 no_ht_gf_set : BIT(3)
4033                 no_ht_set : BIT(4)
4034                 ht_20mhz_set : BIT(5)
4035 */
4036
4037                 psta_data->sta_set =((psta->nonerp_set) |
4038                                                         (psta->no_short_slot_time_set <<1) |
4039                                                         (psta->no_short_preamble_set <<2) |
4040                                                         (psta->no_ht_gf_set <<3) |
4041                                                         (psta->no_ht_set <<4) |
4042                                                         (psta->ht_20mhz_set <<5));
4043
4044                 psta_data->tx_supp_rates_len =  psta->bssratelen;
4045                 memcpy(psta_data->tx_supp_rates, psta->bssrateset, psta->bssratelen);
4046                 memcpy(&psta_data->ht_cap, &psta->htpriv.ht_cap, sizeof(struct rtw_ieee80211_ht_cap));
4047                 psta_data->rx_pkts = psta->sta_stats.rx_data_pkts;
4048                 psta_data->rx_bytes = psta->sta_stats.rx_bytes;
4049                 psta_data->rx_drops = psta->sta_stats.rx_drops;
4050
4051                 psta_data->tx_pkts = psta->sta_stats.tx_pkts;
4052                 psta_data->tx_bytes = psta->sta_stats.tx_bytes;
4053                 psta_data->tx_drops = psta->sta_stats.tx_drops;
4054
4055
4056         } else {
4057                 ret = -1;
4058         }
4059
4060         return ret;
4061
4062 }
4063
4064 static int rtw_get_sta_wpaie(struct net_device *dev, struct ieee_param *param)
4065 {
4066         int ret = 0;
4067         struct sta_info *psta = NULL;
4068         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4069         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4070         struct sta_priv *pstapriv = &padapter->stapriv;
4071
4072         DBG_871X("rtw_get_sta_wpaie, sta_addr: " MAC_FMT "\n", MAC_ARG(param->sta_addr));
4073
4074         if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true)
4075                 return -EINVAL;
4076
4077         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
4078             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
4079             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
4080                 return -EINVAL;
4081         }
4082
4083         psta = rtw_get_stainfo(pstapriv, param->sta_addr);
4084         if (psta) {
4085                 if ((psta->wpa_ie[0] == WLAN_EID_RSN) || (psta->wpa_ie[0] == WLAN_EID_GENERIC)) {
4086                         int wpa_ie_len;
4087                         int copy_len;
4088
4089                         wpa_ie_len = psta->wpa_ie[1];
4090
4091                         copy_len = ((wpa_ie_len+2) > sizeof(psta->wpa_ie)) ? (sizeof(psta->wpa_ie)):(wpa_ie_len+2);
4092
4093                         param->u.wpa_ie.len = copy_len;
4094
4095                         memcpy(param->u.wpa_ie.reserved, psta->wpa_ie, copy_len);
4096                 } else {
4097                         /* ret = -1; */
4098                         DBG_871X("sta's wpa_ie is NONE\n");
4099                 }
4100         } else {
4101                 ret = -1;
4102         }
4103
4104         return ret;
4105
4106 }
4107
4108 static int rtw_set_wps_beacon(struct net_device *dev, struct ieee_param *param, int len)
4109 {
4110         int ret = 0;
4111         unsigned char wps_oui[4]={0x0, 0x50, 0xf2, 0x04};
4112         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4113         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4114         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
4115         int ie_len;
4116
4117         DBG_871X("%s, len =%d\n", __func__, len);
4118
4119         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
4120                 return -EINVAL;
4121
4122         ie_len = len-12-2;/*  12 = param header, 2:no packed */
4123
4124
4125         kfree(pmlmepriv->wps_beacon_ie);
4126         pmlmepriv->wps_beacon_ie = NULL;
4127
4128         if (ie_len>0) {
4129                 pmlmepriv->wps_beacon_ie = rtw_malloc(ie_len);
4130                 pmlmepriv->wps_beacon_ie_len = ie_len;
4131                 if (pmlmepriv->wps_beacon_ie == NULL) {
4132                         DBG_871X("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
4133                         return -EINVAL;
4134                 }
4135
4136                 memcpy(pmlmepriv->wps_beacon_ie, param->u.bcn_ie.buf, ie_len);
4137
4138                 update_beacon(padapter, _VENDOR_SPECIFIC_IE_, wps_oui, true);
4139
4140                 pmlmeext->bstart_bss = true;
4141         }
4142
4143
4144         return ret;
4145
4146 }
4147
4148 static int rtw_set_wps_probe_resp(struct net_device *dev, struct ieee_param *param, int len)
4149 {
4150         int ret = 0;
4151         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4152         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4153         int ie_len;
4154
4155         DBG_871X("%s, len =%d\n", __func__, len);
4156
4157         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
4158                 return -EINVAL;
4159
4160         ie_len = len-12-2;/*  12 = param header, 2:no packed */
4161
4162
4163         kfree(pmlmepriv->wps_probe_resp_ie);
4164         pmlmepriv->wps_probe_resp_ie = NULL;
4165
4166         if (ie_len>0) {
4167                 pmlmepriv->wps_probe_resp_ie = rtw_malloc(ie_len);
4168                 pmlmepriv->wps_probe_resp_ie_len = ie_len;
4169                 if (pmlmepriv->wps_probe_resp_ie == NULL) {
4170                         DBG_871X("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
4171                         return -EINVAL;
4172                 }
4173                 memcpy(pmlmepriv->wps_probe_resp_ie, param->u.bcn_ie.buf, ie_len);
4174         }
4175
4176
4177         return ret;
4178
4179 }
4180
4181 static int rtw_set_wps_assoc_resp(struct net_device *dev, struct ieee_param *param, int len)
4182 {
4183         int ret = 0;
4184         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4185         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4186         int ie_len;
4187
4188         DBG_871X("%s, len =%d\n", __func__, len);
4189
4190         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
4191                 return -EINVAL;
4192
4193         ie_len = len-12-2;/*  12 = param header, 2:no packed */
4194
4195
4196         kfree(pmlmepriv->wps_assoc_resp_ie);
4197         pmlmepriv->wps_assoc_resp_ie = NULL;
4198
4199         if (ie_len>0) {
4200                 pmlmepriv->wps_assoc_resp_ie = rtw_malloc(ie_len);
4201                 pmlmepriv->wps_assoc_resp_ie_len = ie_len;
4202                 if (pmlmepriv->wps_assoc_resp_ie == NULL) {
4203                         DBG_871X("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
4204                         return -EINVAL;
4205                 }
4206
4207                 memcpy(pmlmepriv->wps_assoc_resp_ie, param->u.bcn_ie.buf, ie_len);
4208         }
4209
4210
4211         return ret;
4212
4213 }
4214
4215 static int rtw_set_hidden_ssid(struct net_device *dev, struct ieee_param *param, int len)
4216 {
4217         int ret = 0;
4218         struct adapter *adapter = (struct adapter *)rtw_netdev_priv(dev);
4219         struct mlme_priv *mlmepriv = &(adapter->mlmepriv);
4220         struct mlme_ext_priv *mlmeext = &(adapter->mlmeextpriv);
4221         struct mlme_ext_info *mlmeinfo = &(mlmeext->mlmext_info);
4222         int ie_len;
4223         u8 *ssid_ie;
4224         char ssid[NDIS_802_11_LENGTH_SSID + 1];
4225         sint ssid_len;
4226         u8 ignore_broadcast_ssid;
4227
4228         if (check_fwstate(mlmepriv, WIFI_AP_STATE) != true)
4229                 return -EPERM;
4230
4231         if (param->u.bcn_ie.reserved[0] != 0xea)
4232                 return -EINVAL;
4233
4234         mlmeinfo->hidden_ssid_mode = ignore_broadcast_ssid = param->u.bcn_ie.reserved[1];
4235
4236         ie_len = len-12-2;/*  12 = param header, 2:no packed */
4237         ssid_ie = rtw_get_ie(param->u.bcn_ie.buf,  WLAN_EID_SSID, &ssid_len, ie_len);
4238
4239         if (ssid_ie && ssid_len > 0 && ssid_len <= NDIS_802_11_LENGTH_SSID) {
4240                 struct wlan_bssid_ex *pbss_network = &mlmepriv->cur_network.network;
4241                 struct wlan_bssid_ex *pbss_network_ext = &mlmeinfo->network;
4242
4243                 memcpy(ssid, ssid_ie+2, ssid_len);
4244                 ssid[ssid_len] = 0x0;
4245
4246                 if (0)
4247                         DBG_871X(FUNC_ADPT_FMT" ssid:(%s,%d), from ie:(%s,%d), (%s,%d)\n", FUNC_ADPT_ARG(adapter),
4248                                  ssid, ssid_len,
4249                                  pbss_network->Ssid.Ssid, pbss_network->Ssid.SsidLength,
4250                                  pbss_network_ext->Ssid.Ssid, pbss_network_ext->Ssid.SsidLength);
4251
4252                 memcpy(pbss_network->Ssid.Ssid, (void *)ssid, ssid_len);
4253                 pbss_network->Ssid.SsidLength = ssid_len;
4254                 memcpy(pbss_network_ext->Ssid.Ssid, (void *)ssid, ssid_len);
4255                 pbss_network_ext->Ssid.SsidLength = ssid_len;
4256
4257                 if (0)
4258                         DBG_871X(FUNC_ADPT_FMT" after ssid:(%s,%d), (%s,%d)\n", FUNC_ADPT_ARG(adapter),
4259                                  pbss_network->Ssid.Ssid, pbss_network->Ssid.SsidLength,
4260                                  pbss_network_ext->Ssid.Ssid, pbss_network_ext->Ssid.SsidLength);
4261         }
4262
4263         DBG_871X(FUNC_ADPT_FMT" ignore_broadcast_ssid:%d, %s,%d\n", FUNC_ADPT_ARG(adapter),
4264                 ignore_broadcast_ssid, ssid, ssid_len);
4265
4266         return ret;
4267 }
4268
4269 static int rtw_ioctl_acl_remove_sta(struct net_device *dev, struct ieee_param *param, int len)
4270 {
4271         int ret = 0;
4272         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4273         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4274
4275         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
4276                 return -EINVAL;
4277
4278         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
4279             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
4280             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
4281                 return -EINVAL;
4282         }
4283
4284         ret = rtw_acl_remove_sta(padapter, param->sta_addr);
4285
4286         return ret;
4287
4288 }
4289
4290 static int rtw_ioctl_acl_add_sta(struct net_device *dev, struct ieee_param *param, int len)
4291 {
4292         int ret = 0;
4293         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4294         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4295
4296         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
4297                 return -EINVAL;
4298
4299         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
4300             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
4301             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
4302                 return -EINVAL;
4303         }
4304
4305         ret = rtw_acl_add_sta(padapter, param->sta_addr);
4306
4307         return ret;
4308
4309 }
4310
4311 static int rtw_ioctl_set_macaddr_acl(struct net_device *dev, struct ieee_param *param, int len)
4312 {
4313         int ret = 0;
4314         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4315         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4316
4317         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
4318                 return -EINVAL;
4319
4320         rtw_set_macaddr_acl(padapter, param->u.mlme.command);
4321
4322         return ret;
4323 }
4324
4325 static int rtw_hostapd_ioctl(struct net_device *dev, struct iw_point *p)
4326 {
4327         struct ieee_param *param;
4328         int ret = 0;
4329         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4330
4331         /* DBG_871X("%s\n", __func__); */
4332
4333         /*
4334         * this function is expect to call in master mode, which allows no power saving
4335         * so, we just check hw_init_completed
4336         */
4337
4338         if (padapter->hw_init_completed ==false) {
4339                 ret = -EPERM;
4340                 goto out;
4341         }
4342
4343
4344         /* if (p->length < sizeof(struct ieee_param) || !p->pointer) { */
4345         if (!p->pointer || p->length != sizeof(*param)) {
4346                 ret = -EINVAL;
4347                 goto out;
4348         }
4349
4350         param = (struct ieee_param *)rtw_malloc(p->length);
4351         if (param == NULL) {
4352                 ret = -ENOMEM;
4353                 goto out;
4354         }
4355
4356         if (copy_from_user(param, p->pointer, p->length)) {
4357                 kfree(param);
4358                 ret = -EFAULT;
4359                 goto out;
4360         }
4361
4362         /* DBG_871X("%s, cmd =%d\n", __func__, param->cmd); */
4363
4364         switch (param->cmd) {
4365                 case RTL871X_HOSTAPD_FLUSH:
4366
4367                         ret = rtw_hostapd_sta_flush(dev);
4368
4369                         break;
4370
4371                 case RTL871X_HOSTAPD_ADD_STA:
4372
4373                         ret = rtw_add_sta(dev, param);
4374
4375                         break;
4376
4377                 case RTL871X_HOSTAPD_REMOVE_STA:
4378
4379                         ret = rtw_del_sta(dev, param);
4380
4381                         break;
4382
4383                 case RTL871X_HOSTAPD_SET_BEACON:
4384
4385                         ret = rtw_set_beacon(dev, param, p->length);
4386
4387                         break;
4388
4389                 case RTL871X_SET_ENCRYPTION:
4390
4391                         ret = rtw_set_encryption(dev, param, p->length);
4392
4393                         break;
4394
4395                 case RTL871X_HOSTAPD_GET_WPAIE_STA:
4396
4397                         ret = rtw_get_sta_wpaie(dev, param);
4398
4399                         break;
4400
4401                 case RTL871X_HOSTAPD_SET_WPS_BEACON:
4402
4403                         ret = rtw_set_wps_beacon(dev, param, p->length);
4404
4405                         break;
4406
4407                 case RTL871X_HOSTAPD_SET_WPS_PROBE_RESP:
4408
4409                         ret = rtw_set_wps_probe_resp(dev, param, p->length);
4410
4411                         break;
4412
4413                 case RTL871X_HOSTAPD_SET_WPS_ASSOC_RESP:
4414
4415                         ret = rtw_set_wps_assoc_resp(dev, param, p->length);
4416
4417                         break;
4418
4419                 case RTL871X_HOSTAPD_SET_HIDDEN_SSID:
4420
4421                         ret = rtw_set_hidden_ssid(dev, param, p->length);
4422
4423                         break;
4424
4425                 case RTL871X_HOSTAPD_GET_INFO_STA:
4426
4427                         ret = rtw_ioctl_get_sta_data(dev, param, p->length);
4428
4429                         break;
4430
4431                 case RTL871X_HOSTAPD_SET_MACADDR_ACL:
4432
4433                         ret = rtw_ioctl_set_macaddr_acl(dev, param, p->length);
4434
4435                         break;
4436
4437                 case RTL871X_HOSTAPD_ACL_ADD_STA:
4438
4439                         ret = rtw_ioctl_acl_add_sta(dev, param, p->length);
4440
4441                         break;
4442
4443                 case RTL871X_HOSTAPD_ACL_REMOVE_STA:
4444
4445                         ret = rtw_ioctl_acl_remove_sta(dev, param, p->length);
4446
4447                         break;
4448
4449                 default:
4450                         DBG_871X("Unknown hostapd request: %d\n", param->cmd);
4451                         ret = -EOPNOTSUPP;
4452                         break;
4453
4454         }
4455
4456         if (ret == 0 && copy_to_user(p->pointer, param, p->length))
4457                 ret = -EFAULT;
4458
4459
4460         kfree(param);
4461
4462 out:
4463
4464         return ret;
4465
4466 }
4467
4468 static int rtw_wx_set_priv(struct net_device *dev,
4469                                 struct iw_request_info *info,
4470                                 union iwreq_data *awrq,
4471                                 char *extra)
4472 {
4473
4474 #ifdef DEBUG_RTW_WX_SET_PRIV
4475         char *ext_dbg;
4476 #endif
4477
4478         int ret = 0;
4479         int len = 0;
4480         char *ext;
4481
4482         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4483         struct iw_point *dwrq = (struct iw_point*)awrq;
4484
4485         /* RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_notice_, ("+rtw_wx_set_priv\n")); */
4486         if (dwrq->length == 0)
4487                 return -EFAULT;
4488
4489         len = dwrq->length;
4490         if (!(ext = vmalloc(len)))
4491                 return -ENOMEM;
4492
4493         if (copy_from_user(ext, dwrq->pointer, len)) {
4494                 vfree(ext);
4495                 return -EFAULT;
4496         }
4497
4498
4499         /* RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_notice_, */
4500         /*       ("rtw_wx_set_priv: %s req =%s\n", */
4501         /*        dev->name, ext)); */
4502
4503         #ifdef DEBUG_RTW_WX_SET_PRIV
4504         if (!(ext_dbg = vmalloc(len))) {
4505                 vfree(ext, len);
4506                 return -ENOMEM;
4507         }
4508
4509         memcpy(ext_dbg, ext, len);
4510         #endif
4511
4512         /* added for wps2.0 @20110524 */
4513         if (dwrq->flags == 0x8766 && len > 8) {
4514                 u32 cp_sz;
4515                 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4516                 u8 *probereq_wpsie = ext;
4517                 int probereq_wpsie_len = len;
4518                 u8 wps_oui[4]={0x0, 0x50, 0xf2, 0x04};
4519
4520                 if ((_VENDOR_SPECIFIC_IE_ == probereq_wpsie[0]) &&
4521                         (!memcmp(&probereq_wpsie[2], wps_oui, 4))) {
4522                         cp_sz = probereq_wpsie_len>MAX_WPS_IE_LEN ? MAX_WPS_IE_LEN:probereq_wpsie_len;
4523
4524                         if (pmlmepriv->wps_probe_req_ie) {
4525                                 pmlmepriv->wps_probe_req_ie_len = 0;
4526                                 kfree(pmlmepriv->wps_probe_req_ie);
4527                                 pmlmepriv->wps_probe_req_ie = NULL;
4528                         }
4529
4530                         pmlmepriv->wps_probe_req_ie = rtw_malloc(cp_sz);
4531                         if (pmlmepriv->wps_probe_req_ie == NULL) {
4532                                 printk("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
4533                                 ret =  -EINVAL;
4534                                 goto FREE_EXT;
4535
4536                         }
4537
4538                         memcpy(pmlmepriv->wps_probe_req_ie, probereq_wpsie, cp_sz);
4539                         pmlmepriv->wps_probe_req_ie_len = cp_sz;
4540
4541                 }
4542
4543                 goto FREE_EXT;
4544
4545         }
4546
4547         if (len >= WEXT_CSCAN_HEADER_SIZE
4548                 && !memcmp(ext, WEXT_CSCAN_HEADER, WEXT_CSCAN_HEADER_SIZE)) {
4549                 ret = rtw_wx_set_scan(dev, info, awrq, ext);
4550                 goto FREE_EXT;
4551         }
4552
4553 FREE_EXT:
4554
4555         vfree(ext);
4556         #ifdef DEBUG_RTW_WX_SET_PRIV
4557         vfree(ext_dbg);
4558         #endif
4559
4560         /* DBG_871X("rtw_wx_set_priv: (SIOCSIWPRIV) %s ret =%d\n", */
4561         /*              dev->name, ret); */
4562
4563         return ret;
4564
4565 }
4566
4567 static int rtw_pm_set(struct net_device *dev,
4568                                struct iw_request_info *info,
4569                                union iwreq_data *wrqu, char *extra)
4570 {
4571         int ret = 0;
4572         unsigned        mode = 0;
4573         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4574
4575         DBG_871X("[%s] extra = %s\n", __func__, extra);
4576
4577         if (!memcmp(extra, "lps =", 4)) {
4578                 sscanf(extra+4, "%u", &mode);
4579                 ret = rtw_pm_set_lps(padapter, mode);
4580         } else if (!memcmp(extra, "ips =", 4)) {
4581                 sscanf(extra+4, "%u", &mode);
4582                 ret = rtw_pm_set_ips(padapter, mode);
4583         } else {
4584                 ret = -EINVAL;
4585         }
4586
4587         return ret;
4588 }
4589
4590 static int rtw_mp_efuse_get(struct net_device *dev,
4591                         struct iw_request_info *info,
4592                         union iwreq_data *wdata, char *extra)
4593 {
4594         int err = 0;
4595         return err;
4596 }
4597
4598 static int rtw_mp_efuse_set(struct net_device *dev,
4599                         struct iw_request_info *info,
4600                         union iwreq_data *wdata, char *extra)
4601 {
4602         int err = 0;
4603         return err;
4604 }
4605
4606 static int rtw_tdls(struct net_device *dev,
4607                                 struct iw_request_info *info,
4608                                 union iwreq_data *wrqu, char *extra)
4609 {
4610         int ret = 0;
4611         return ret;
4612 }
4613
4614
4615 static int rtw_tdls_get(struct net_device *dev,
4616                                 struct iw_request_info *info,
4617                                 union iwreq_data *wrqu, char *extra)
4618 {
4619         int ret = 0;
4620         return ret;
4621 }
4622
4623
4624
4625
4626
4627 #ifdef CONFIG_INTEL_WIDI
4628 static int rtw_widi_set(struct net_device *dev,
4629                                struct iw_request_info *info,
4630                                union iwreq_data *wrqu, char *extra)
4631 {
4632         int ret = 0;
4633         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4634
4635         process_intel_widi_cmd(padapter, extra);
4636
4637         return ret;
4638 }
4639
4640 static int rtw_widi_set_probe_request(struct net_device *dev,
4641                                struct iw_request_info *info,
4642                                union iwreq_data *wrqu, char *extra)
4643 {
4644         int     ret = 0;
4645         u8 *pbuf = NULL;
4646         struct adapter  *padapter = (struct adapter *)rtw_netdev_priv(dev);
4647
4648         pbuf = rtw_malloc(sizeof(l2_msg_t));
4649         if (pbuf) {
4650                 if (copy_from_user(pbuf, wrqu->data.pointer, wrqu->data.length))
4651                         ret = -EFAULT;
4652                 /* memcpy(pbuf, wrqu->data.pointer, wrqu->data.length); */
4653
4654                 if (wrqu->data.flags == 0)
4655                         intel_widi_wk_cmd(padapter, INTEL_WIDI_ISSUE_PROB_WK, pbuf, sizeof(l2_msg_t));
4656                 else if (wrqu->data.flags == 1)
4657                         rtw_set_wfd_rds_sink_info(padapter, (l2_msg_t *)pbuf);
4658         }
4659         return ret;
4660 }
4661 #endif /*  CONFIG_INTEL_WIDI */
4662
4663 static int rtw_test(
4664         struct net_device *dev,
4665         struct iw_request_info *info,
4666         union iwreq_data *wrqu, char *extra)
4667 {
4668         u32 len;
4669         u8 *pbuf, *pch;
4670         char *ptmp;
4671         u8 *delim = ",";
4672         struct adapter *padapter = rtw_netdev_priv(dev);
4673
4674
4675         DBG_871X("+%s\n", __func__);
4676         len = wrqu->data.length;
4677
4678         pbuf = (u8 *)rtw_zmalloc(len);
4679         if (pbuf == NULL) {
4680                 DBG_871X("%s: no memory!\n", __func__);
4681                 return -ENOMEM;
4682         }
4683
4684         if (copy_from_user(pbuf, wrqu->data.pointer, len)) {
4685                 kfree(pbuf);
4686                 DBG_871X("%s: copy from user fail!\n", __func__);
4687                 return -EFAULT;
4688         }
4689         DBG_871X("%s: string =\"%s\"\n", __func__, pbuf);
4690
4691         ptmp = (char*)pbuf;
4692         pch = strsep(&ptmp, delim);
4693         if ((pch == NULL) || (strlen(pch) == 0)) {
4694                 kfree(pbuf);
4695                 DBG_871X("%s: parameter error(level 1)!\n", __func__);
4696                 return -EFAULT;
4697         }
4698
4699         if (strcmp(pch, "bton") == 0)
4700                 rtw_btcoex_SetManualControl(padapter, false);
4701
4702         if (strcmp(pch, "btoff") == 0)
4703                 rtw_btcoex_SetManualControl(padapter, true);
4704
4705         if (strcmp(pch, "h2c") == 0) {
4706                 u8 param[8];
4707                 u8 count = 0;
4708                 u32 tmp;
4709                 u8 i;
4710                 u32 pos;
4711                 s32 ret;
4712
4713
4714                 do {
4715                         pch = strsep(&ptmp, delim);
4716                         if ((pch == NULL) || (strlen(pch) == 0))
4717                                 break;
4718
4719                         sscanf(pch, "%x", &tmp);
4720                         param[count++] = (u8)tmp;
4721                 } while (count < 8);
4722
4723                 if (count == 0) {
4724                         kfree(pbuf);
4725                         DBG_871X("%s: parameter error(level 2)!\n", __func__);
4726                         return -EFAULT;
4727                 }
4728
4729                 ret = rtw_hal_fill_h2c_cmd(padapter, param[0], count-1, &param[1]);
4730
4731                 pos = sprintf(extra, "H2C ID = 0x%02x content =", param[0]);
4732                 for (i = 1; i<count; i++)
4733                         pos += sprintf(extra+pos, "%02x,", param[i]);
4734                 extra[pos] = 0;
4735                 pos--;
4736                 pos += sprintf(extra+pos, " %s", ret == _FAIL?"FAIL":"OK");
4737
4738                 wrqu->data.length = strlen(extra) + 1;
4739         }
4740
4741         kfree(pbuf);
4742         return 0;
4743 }
4744
4745 static iw_handler rtw_handlers[] = {
4746         NULL,                                   /* SIOCSIWCOMMIT */
4747         rtw_wx_get_name,                /* SIOCGIWNAME */
4748         dummy,                                  /* SIOCSIWNWID */
4749         dummy,                                  /* SIOCGIWNWID */
4750         rtw_wx_set_freq,                /* SIOCSIWFREQ */
4751         rtw_wx_get_freq,                /* SIOCGIWFREQ */
4752         rtw_wx_set_mode,                /* SIOCSIWMODE */
4753         rtw_wx_get_mode,                /* SIOCGIWMODE */
4754         dummy,                                  /* SIOCSIWSENS */
4755         rtw_wx_get_sens,                /* SIOCGIWSENS */
4756         NULL,                                   /* SIOCSIWRANGE */
4757         rtw_wx_get_range,               /* SIOCGIWRANGE */
4758         rtw_wx_set_priv,                /* SIOCSIWPRIV */
4759         NULL,                                   /* SIOCGIWPRIV */
4760         NULL,                                   /* SIOCSIWSTATS */
4761         NULL,                                   /* SIOCGIWSTATS */
4762         dummy,                                  /* SIOCSIWSPY */
4763         dummy,                                  /* SIOCGIWSPY */
4764         NULL,                                   /* SIOCGIWTHRSPY */
4765         NULL,                                   /* SIOCWIWTHRSPY */
4766         rtw_wx_set_wap,         /* SIOCSIWAP */
4767         rtw_wx_get_wap,         /* SIOCGIWAP */
4768         rtw_wx_set_mlme,                /* request MLME operation; uses struct iw_mlme */
4769         dummy,                                  /* SIOCGIWAPLIST -- depricated */
4770         rtw_wx_set_scan,                /* SIOCSIWSCAN */
4771         rtw_wx_get_scan,                /* SIOCGIWSCAN */
4772         rtw_wx_set_essid,               /* SIOCSIWESSID */
4773         rtw_wx_get_essid,               /* SIOCGIWESSID */
4774         dummy,                                  /* SIOCSIWNICKN */
4775         rtw_wx_get_nick,                /* SIOCGIWNICKN */
4776         NULL,                                   /* -- hole -- */
4777         NULL,                                   /* -- hole -- */
4778         rtw_wx_set_rate,                /* SIOCSIWRATE */
4779         rtw_wx_get_rate,                /* SIOCGIWRATE */
4780         rtw_wx_set_rts,                 /* SIOCSIWRTS */
4781         rtw_wx_get_rts,                 /* SIOCGIWRTS */
4782         rtw_wx_set_frag,                /* SIOCSIWFRAG */
4783         rtw_wx_get_frag,                /* SIOCGIWFRAG */
4784         dummy,                                  /* SIOCSIWTXPOW */
4785         dummy,                                  /* SIOCGIWTXPOW */
4786         dummy,                                  /* SIOCSIWRETRY */
4787         rtw_wx_get_retry,               /* SIOCGIWRETRY */
4788         rtw_wx_set_enc,                 /* SIOCSIWENCODE */
4789         rtw_wx_get_enc,                 /* SIOCGIWENCODE */
4790         dummy,                                  /* SIOCSIWPOWER */
4791         rtw_wx_get_power,               /* SIOCGIWPOWER */
4792         NULL,                                   /*---hole---*/
4793         NULL,                                   /*---hole---*/
4794         rtw_wx_set_gen_ie,              /* SIOCSIWGENIE */
4795         NULL,                                   /* SIOCGWGENIE */
4796         rtw_wx_set_auth,                /* SIOCSIWAUTH */
4797         NULL,                                   /* SIOCGIWAUTH */
4798         rtw_wx_set_enc_ext,             /* SIOCSIWENCODEEXT */
4799         NULL,                                   /* SIOCGIWENCODEEXT */
4800         rtw_wx_set_pmkid,               /* SIOCSIWPMKSA */
4801         NULL,                                   /*---hole---*/
4802 };
4803
4804 static const struct iw_priv_args rtw_private_args[] = {
4805         {
4806                 SIOCIWFIRSTPRIV + 0x0,
4807                 IW_PRIV_TYPE_CHAR | 0x7FF, 0, "write"
4808         },
4809         {
4810                 SIOCIWFIRSTPRIV + 0x1,
4811                 IW_PRIV_TYPE_CHAR | 0x7FF,
4812                 IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "read"
4813         },
4814         {
4815                 SIOCIWFIRSTPRIV + 0x2, 0, 0, "driver_ext"
4816         },
4817         {
4818                 SIOCIWFIRSTPRIV + 0x3, 0, 0, "mp_ioctl"
4819         },
4820         {
4821                 SIOCIWFIRSTPRIV + 0x4,
4822                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "apinfo"
4823         },
4824         {
4825                 SIOCIWFIRSTPRIV + 0x5,
4826                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "setpid"
4827         },
4828         {
4829                 SIOCIWFIRSTPRIV + 0x6,
4830                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_start"
4831         },
4832 /* for PLATFORM_MT53XX */
4833         {
4834                 SIOCIWFIRSTPRIV + 0x7,
4835                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "get_sensitivity"
4836         },
4837         {
4838                 SIOCIWFIRSTPRIV + 0x8,
4839                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_prob_req_ie"
4840         },
4841         {
4842                 SIOCIWFIRSTPRIV + 0x9,
4843                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_assoc_req_ie"
4844         },
4845
4846 /* for RTK_DMP_PLATFORM */
4847         {
4848                 SIOCIWFIRSTPRIV + 0xA,
4849                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "channel_plan"
4850         },
4851
4852         {
4853                 SIOCIWFIRSTPRIV + 0xB,
4854                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "dbg"
4855         },
4856         {
4857                 SIOCIWFIRSTPRIV + 0xC,
4858                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 3, 0, "rfw"
4859         },
4860         {
4861                 SIOCIWFIRSTPRIV + 0xD,
4862                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "rfr"
4863         },
4864         {
4865                 SIOCIWFIRSTPRIV + 0x10,
4866                 IW_PRIV_TYPE_CHAR | 1024, 0, "p2p_set"
4867         },
4868         {
4869                 SIOCIWFIRSTPRIV + 0x11,
4870                 IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK , "p2p_get"
4871         },
4872         {
4873                 SIOCIWFIRSTPRIV + 0x12, 0, 0, "NULL"
4874         },
4875         {
4876                 SIOCIWFIRSTPRIV + 0x13,
4877                 IW_PRIV_TYPE_CHAR | 64, IW_PRIV_TYPE_CHAR | 64 , "p2p_get2"
4878         },
4879         {
4880                 SIOCIWFIRSTPRIV + 0x14,
4881                 IW_PRIV_TYPE_CHAR  | 64, 0, "tdls"
4882         },
4883         {
4884                 SIOCIWFIRSTPRIV + 0x15,
4885                 IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | 1024 , "tdls_get"
4886         },
4887         {
4888                 SIOCIWFIRSTPRIV + 0x16,
4889                 IW_PRIV_TYPE_CHAR | 64, 0, "pm_set"
4890         },
4891
4892         {SIOCIWFIRSTPRIV + 0x18, IW_PRIV_TYPE_CHAR | IFNAMSIZ , 0 , "rereg_nd_name"},
4893         {SIOCIWFIRSTPRIV + 0x1A, IW_PRIV_TYPE_CHAR | 1024, 0, "efuse_set"},
4894         {SIOCIWFIRSTPRIV + 0x1B, IW_PRIV_TYPE_CHAR | 128, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "efuse_get"},
4895         {
4896                 SIOCIWFIRSTPRIV + 0x1D,
4897                 IW_PRIV_TYPE_CHAR | 40, IW_PRIV_TYPE_CHAR | 0x7FF, "test"
4898         },
4899
4900 #ifdef CONFIG_INTEL_WIDI
4901         {
4902                 SIOCIWFIRSTPRIV + 0x1E,
4903                 IW_PRIV_TYPE_CHAR | 1024, 0, "widi_set"
4904         },
4905         {
4906                 SIOCIWFIRSTPRIV + 0x1F,
4907                 IW_PRIV_TYPE_CHAR | 128, 0, "widi_prob_req"
4908         },
4909 #endif /*  CONFIG_INTEL_WIDI */
4910
4911 #ifdef CONFIG_WOWLAN
4912                 { MP_WOW_ENABLE , IW_PRIV_TYPE_CHAR | 1024, 0, "wow_mode" }, /* set */
4913 #endif
4914 #ifdef CONFIG_AP_WOWLAN
4915                 { MP_AP_WOW_ENABLE , IW_PRIV_TYPE_CHAR | 1024, 0, "ap_wow_mode" }, /* set */
4916 #endif
4917 };
4918
4919 static iw_handler rtw_private_handler[] = {
4920         rtw_wx_write32,                                 /* 0x00 */
4921         rtw_wx_read32,                                  /* 0x01 */
4922         rtw_drvext_hdl,                                 /* 0x02 */
4923         rtw_mp_ioctl_hdl,                               /* 0x03 */
4924
4925 /*  for MM DTV platform */
4926         rtw_get_ap_info,                                        /* 0x04 */
4927
4928         rtw_set_pid,                                            /* 0x05 */
4929         rtw_wps_start,                                  /* 0x06 */
4930
4931 /*  for PLATFORM_MT53XX */
4932         rtw_wx_get_sensitivity,                 /* 0x07 */
4933         rtw_wx_set_mtk_wps_probe_ie,    /* 0x08 */
4934         rtw_wx_set_mtk_wps_ie,                  /* 0x09 */
4935
4936 /*  for RTK_DMP_PLATFORM */
4937 /*  Set Channel depend on the country code */
4938         rtw_wx_set_channel_plan,                /* 0x0A */
4939
4940         rtw_dbg_port,                                   /* 0x0B */
4941         rtw_wx_write_rf,                                        /* 0x0C */
4942         rtw_wx_read_rf,                                 /* 0x0D */
4943         rtw_wx_priv_null,                               /* 0x0E */
4944         rtw_wx_priv_null,                               /* 0x0F */
4945         rtw_p2p_set,                                    /* 0x10 */
4946         rtw_p2p_get,                                    /* 0x11 */
4947         NULL,                                                   /* 0x12 */
4948         rtw_p2p_get2,                                   /* 0x13 */
4949
4950         rtw_tdls,                                               /* 0x14 */
4951         rtw_tdls_get,                                   /* 0x15 */
4952
4953         rtw_pm_set,                                             /* 0x16 */
4954         rtw_wx_priv_null,                               /* 0x17 */
4955         rtw_rereg_nd_name,                              /* 0x18 */
4956         rtw_wx_priv_null,                               /* 0x19 */
4957         rtw_mp_efuse_set,                               /* 0x1A */
4958         rtw_mp_efuse_get,                               /* 0x1B */
4959         NULL,                                                   /*  0x1C is reserved for hostapd */
4960         rtw_test,                                               /*  0x1D */
4961 #ifdef CONFIG_INTEL_WIDI
4962         rtw_widi_set,                                   /* 0x1E */
4963         rtw_widi_set_probe_request,             /* 0x1F */
4964 #endif /*  CONFIG_INTEL_WIDI */
4965 };
4966
4967 static struct iw_statistics *rtw_get_wireless_stats(struct net_device *dev)
4968 {
4969         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
4970         struct iw_statistics *piwstats =&padapter->iwstats;
4971         int tmp_level = 0;
4972         int tmp_qual = 0;
4973         int tmp_noise = 0;
4974
4975         if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) != true) {
4976                 piwstats->qual.qual = 0;
4977                 piwstats->qual.level = 0;
4978                 piwstats->qual.noise = 0;
4979                 /* DBG_871X("No link  level:%d, qual:%d, noise:%d\n", tmp_level, tmp_qual, tmp_noise); */
4980         } else {
4981                 #ifdef CONFIG_SIGNAL_DISPLAY_DBM
4982                 tmp_level = translate_percentage_to_dbm(padapter->recvpriv.signal_strength);
4983                 #else
4984                 #ifdef CONFIG_SKIP_SIGNAL_SCALE_MAPPING
4985                 {
4986                         /* Do signal scale mapping when using percentage as the unit of signal strength, since the scale mapping is skipped in odm */
4987
4988                         struct hal_com_data *pHal = GET_HAL_DATA(padapter);
4989
4990                         tmp_level = (u8)odm_SignalScaleMapping(&pHal->odmpriv, padapter->recvpriv.signal_strength);
4991                 }
4992                 #else
4993                 tmp_level = padapter->recvpriv.signal_strength;
4994                 #endif
4995                 #endif
4996
4997                 tmp_qual = padapter->recvpriv.signal_qual;
4998 #if defined(CONFIG_SIGNAL_DISPLAY_DBM) && defined(CONFIG_BACKGROUND_NOISE_MONITOR)
4999                 if (rtw_linked_check(padapter)) {
5000                         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5001                         struct noise_info info;
5002                         info.bPauseDIG = true;
5003                         info.IGIValue = 0x1e;
5004                         info.max_time = 100;/* ms */
5005                         info.chan = pmlmeext->cur_channel ;/* rtw_get_oper_ch(padapter); */
5006                         rtw_ps_deny(padapter, PS_DENY_IOCTL);
5007                         LeaveAllPowerSaveModeDirect(padapter);
5008
5009                         rtw_hal_set_odm_var(padapter, HAL_ODM_NOISE_MONITOR,&info, false);
5010                         /* ODM_InbandNoise_Monitor(podmpriv, true, 0x20, 100); */
5011                         rtw_ps_deny_cancel(padapter, PS_DENY_IOCTL);
5012                         rtw_hal_get_odm_var(padapter, HAL_ODM_NOISE_MONITOR,&(info.chan), &(padapter->recvpriv.noise));
5013                         DBG_871X("chan:%d, noise_level:%d\n", info.chan, padapter->recvpriv.noise);
5014                 }
5015 #endif
5016                 tmp_noise = padapter->recvpriv.noise;
5017                 DBG_871X("level:%d, qual:%d, noise:%d, rssi (%d)\n", tmp_level, tmp_qual, tmp_noise, padapter->recvpriv.rssi);
5018
5019                 piwstats->qual.level = tmp_level;
5020                 piwstats->qual.qual = tmp_qual;
5021                 piwstats->qual.noise = tmp_noise;
5022         }
5023         piwstats->qual.updated = IW_QUAL_ALL_UPDATED ;/* IW_QUAL_DBM; */
5024
5025         #ifdef CONFIG_SIGNAL_DISPLAY_DBM
5026         piwstats->qual.updated = piwstats->qual.updated | IW_QUAL_DBM;
5027         #endif
5028
5029         return &padapter->iwstats;
5030 }
5031
5032 struct iw_handler_def rtw_handlers_def = {
5033         .standard = rtw_handlers,
5034         .num_standard = sizeof(rtw_handlers) / sizeof(iw_handler),
5035 #if defined(CONFIG_WEXT_PRIV)
5036         .private = rtw_private_handler,
5037         .private_args = (struct iw_priv_args *)rtw_private_args,
5038         .num_private = sizeof(rtw_private_handler) / sizeof(iw_handler),
5039         .num_private_args = sizeof(rtw_private_args) / sizeof(struct iw_priv_args),
5040 #endif
5041         .get_wireless_stats = rtw_get_wireless_stats,
5042 };
5043
5044 /*  copy from net/wireless/wext.c start */
5045 /* ---------------------------------------------------------------- */
5046 /*
5047  * Calculate size of private arguments
5048  */
5049 static const char iw_priv_type_size[] = {
5050         0,                              /* IW_PRIV_TYPE_NONE */
5051         1,                              /* IW_PRIV_TYPE_BYTE */
5052         1,                              /* IW_PRIV_TYPE_CHAR */
5053         0,                              /* Not defined */
5054         sizeof(__u32),                  /* IW_PRIV_TYPE_INT */
5055         sizeof(struct iw_freq),         /* IW_PRIV_TYPE_FLOAT */
5056         sizeof(struct sockaddr),        /* IW_PRIV_TYPE_ADDR */
5057         0,                              /* Not defined */
5058 };
5059
5060 static int get_priv_size(__u16 args)
5061 {
5062         int num = args & IW_PRIV_SIZE_MASK;
5063         int type = (args & IW_PRIV_TYPE_MASK) >> 12;
5064
5065         return num * iw_priv_type_size[type];
5066 }
5067 /*  copy from net/wireless/wext.c end */
5068
5069 static int rtw_ioctl_wext_private(struct net_device *dev, union iwreq_data *wrq_data)
5070 {
5071         int err = 0;
5072         u8 *input = NULL;
5073         u32 input_len = 0;
5074         const char delim[] = " ";
5075         u8 *output = NULL;
5076         u32 output_len = 0;
5077         u32 count = 0;
5078         u8 *buffer = NULL;
5079         u32 buffer_len = 0;
5080         char *ptr = NULL;
5081         u8 cmdname[17] = {0}; /*  IFNAMSIZ+1 */
5082         u32 cmdlen;
5083         s32 len;
5084         u8 *extra = NULL;
5085         u32 extra_size = 0;
5086
5087         s32 k;
5088         const iw_handler *priv;         /* Private ioctl */
5089         const struct iw_priv_args *priv_args;   /* Private ioctl description */
5090         u32 num_priv;                           /* Number of ioctl */
5091         u32 num_priv_args;                      /* Number of descriptions */
5092         iw_handler handler;
5093         int temp;
5094         int subcmd = 0;                         /* sub-ioctl index */
5095         int offset = 0;                         /* Space for sub-ioctl index */
5096
5097         union iwreq_data wdata;
5098
5099
5100         memcpy(&wdata, wrq_data, sizeof(wdata));
5101
5102         input_len = 2048;
5103         input = rtw_zmalloc(input_len);
5104         if (NULL == input)
5105                 return -ENOMEM;
5106         if (copy_from_user(input, wdata.data.pointer, input_len)) {
5107                 err = -EFAULT;
5108                 goto exit;
5109         }
5110         ptr = input;
5111         len = strlen(input);
5112
5113         sscanf(ptr, "%16s", cmdname);
5114         cmdlen = strlen(cmdname);
5115         DBG_8192C("%s: cmd =%s\n", __func__, cmdname);
5116
5117         /*  skip command string */
5118         if (cmdlen > 0)
5119                 cmdlen += 1; /*  skip one space */
5120         ptr += cmdlen;
5121         len -= cmdlen;
5122         DBG_8192C("%s: parameters =%s\n", __func__, ptr);
5123
5124         priv = rtw_private_handler;
5125         priv_args = rtw_private_args;
5126         num_priv = sizeof(rtw_private_handler) / sizeof(iw_handler);
5127         num_priv_args = sizeof(rtw_private_args) / sizeof(struct iw_priv_args);
5128
5129         if (num_priv_args == 0) {
5130                 err = -EOPNOTSUPP;
5131                 goto exit;
5132         }
5133
5134         /* Search the correct ioctl */
5135         k = -1;
5136         while ((++k < num_priv_args) && strcmp(priv_args[k].name, cmdname));
5137
5138         /* If not found... */
5139         if (k == num_priv_args) {
5140                 err = -EOPNOTSUPP;
5141                 goto exit;
5142         }
5143
5144         /* Watch out for sub-ioctls ! */
5145         if (priv_args[k].cmd < SIOCDEVPRIVATE) {
5146                 int j = -1;
5147
5148                 /* Find the matching *real* ioctl */
5149                 while ((++j < num_priv_args) && ((priv_args[j].name[0] != '\0') ||
5150                         (priv_args[j].set_args != priv_args[k].set_args) ||
5151                         (priv_args[j].get_args != priv_args[k].get_args)));
5152
5153                 /* If not found... */
5154                 if (j == num_priv_args) {
5155                         err = -EINVAL;
5156                         goto exit;
5157                 }
5158
5159                 /* Save sub-ioctl number */
5160                 subcmd = priv_args[k].cmd;
5161                 /* Reserve one int (simplify alignment issues) */
5162                 offset = sizeof(__u32);
5163                 /* Use real ioctl definition from now on */
5164                 k = j;
5165         }
5166
5167         buffer = rtw_zmalloc(4096);
5168         if (NULL == buffer) {
5169                 err = -ENOMEM;
5170                 goto exit;
5171         }
5172
5173         /* If we have to set some data */
5174         if ((priv_args[k].set_args & IW_PRIV_TYPE_MASK) &&
5175                 (priv_args[k].set_args & IW_PRIV_SIZE_MASK)) {
5176                 u8 *str;
5177
5178                 switch (priv_args[k].set_args & IW_PRIV_TYPE_MASK) {
5179                         case IW_PRIV_TYPE_BYTE:
5180                                 /* Fetch args */
5181                                 count = 0;
5182                                 do {
5183                                         str = strsep(&ptr, delim);
5184                                         if (NULL == str) break;
5185                                         sscanf(str, "%i", &temp);
5186                                         buffer[count++] = (u8)temp;
5187                                 } while (1);
5188                                 buffer_len = count;
5189
5190                                 /* Number of args to fetch */
5191                                 wdata.data.length = count;
5192                                 if (wdata.data.length > (priv_args[k].set_args & IW_PRIV_SIZE_MASK))
5193                                         wdata.data.length = priv_args[k].set_args & IW_PRIV_SIZE_MASK;
5194
5195                                 break;
5196
5197                         case IW_PRIV_TYPE_INT:
5198                                 /* Fetch args */
5199                                 count = 0;
5200                                 do {
5201                                         str = strsep(&ptr, delim);
5202                                         if (NULL == str) break;
5203                                         sscanf(str, "%i", &temp);
5204                                         ((s32*)buffer)[count++] = (s32)temp;
5205                                 } while (1);
5206                                 buffer_len = count * sizeof(s32);
5207
5208                                 /* Number of args to fetch */
5209                                 wdata.data.length = count;
5210                                 if (wdata.data.length > (priv_args[k].set_args & IW_PRIV_SIZE_MASK))
5211                                         wdata.data.length = priv_args[k].set_args & IW_PRIV_SIZE_MASK;
5212
5213                                 break;
5214
5215                         case IW_PRIV_TYPE_CHAR:
5216                                 if (len > 0) {
5217                                         /* Size of the string to fetch */
5218                                         wdata.data.length = len;
5219                                         if (wdata.data.length > (priv_args[k].set_args & IW_PRIV_SIZE_MASK))
5220                                                 wdata.data.length = priv_args[k].set_args & IW_PRIV_SIZE_MASK;
5221
5222                                         /* Fetch string */
5223                                         memcpy(buffer, ptr, wdata.data.length);
5224                                 } else {
5225                                         wdata.data.length = 1;
5226                                         buffer[0] = '\0';
5227                                 }
5228                                 buffer_len = wdata.data.length;
5229                                 break;
5230
5231                         default:
5232                                 DBG_8192C("%s: Not yet implemented...\n", __func__);
5233                                 err = -1;
5234                                 goto exit;
5235                 }
5236
5237                 if ((priv_args[k].set_args & IW_PRIV_SIZE_FIXED) &&
5238                         (wdata.data.length != (priv_args[k].set_args & IW_PRIV_SIZE_MASK))) {
5239                         DBG_8192C("%s: The command %s needs exactly %d argument(s)...\n",
5240                                         __func__, cmdname, priv_args[k].set_args & IW_PRIV_SIZE_MASK);
5241                         err = -EINVAL;
5242                         goto exit;
5243                 }
5244         } else { /* if args to set */
5245                 wdata.data.length = 0L;
5246         }
5247
5248         /* Those two tests are important. They define how the driver
5249         * will have to handle the data */
5250         if ((priv_args[k].set_args & IW_PRIV_SIZE_FIXED) &&
5251                 ((get_priv_size(priv_args[k].set_args) + offset) <= IFNAMSIZ)) {
5252                 /* First case : all SET args fit within wrq */
5253                 if (offset)
5254                         wdata.mode = subcmd;
5255                 memcpy(wdata.name + offset, buffer, IFNAMSIZ - offset);
5256         } else {
5257                 if ((priv_args[k].set_args == 0) &&
5258                         (priv_args[k].get_args & IW_PRIV_SIZE_FIXED) &&
5259                         (get_priv_size(priv_args[k].get_args) <= IFNAMSIZ)) {
5260                         /* Second case : no SET args, GET args fit within wrq */
5261                         if (offset)
5262                                 wdata.mode = subcmd;
5263                 } else {
5264                         /* Third case : args won't fit in wrq, or variable number of args */
5265                         if (copy_to_user(wdata.data.pointer, buffer, buffer_len)) {
5266                                 err = -EFAULT;
5267                                 goto exit;
5268                         }
5269                         wdata.data.flags = subcmd;
5270                 }
5271         }
5272
5273         kfree(input);
5274         input = NULL;
5275
5276         extra_size = 0;
5277         if (IW_IS_SET(priv_args[k].cmd)) {
5278                 /* Size of set arguments */
5279                 extra_size = get_priv_size(priv_args[k].set_args);
5280
5281                 /* Does it fits in iwr ? */
5282                 if ((priv_args[k].set_args & IW_PRIV_SIZE_FIXED) &&
5283                         ((extra_size + offset) <= IFNAMSIZ))
5284                         extra_size = 0;
5285         } else {
5286                 /* Size of get arguments */
5287                 extra_size = get_priv_size(priv_args[k].get_args);
5288
5289                 /* Does it fits in iwr ? */
5290                 if ((priv_args[k].get_args & IW_PRIV_SIZE_FIXED) &&
5291                         (extra_size <= IFNAMSIZ))
5292                         extra_size = 0;
5293         }
5294
5295         if (extra_size == 0) {
5296                 extra = (u8 *)&wdata;
5297                 kfree(buffer);
5298                 buffer = NULL;
5299         } else
5300                 extra = buffer;
5301
5302         handler = priv[priv_args[k].cmd - SIOCIWFIRSTPRIV];
5303         err = handler(dev, NULL, &wdata, extra);
5304
5305         /* If we have to get some data */
5306         if ((priv_args[k].get_args & IW_PRIV_TYPE_MASK) &&
5307                 (priv_args[k].get_args & IW_PRIV_SIZE_MASK)) {
5308                 int j;
5309                 int n = 0;      /* number of args */
5310                 u8 str[20] = {0};
5311
5312                 /* Check where is the returned data */
5313                 if ((priv_args[k].get_args & IW_PRIV_SIZE_FIXED) &&
5314                         (get_priv_size(priv_args[k].get_args) <= IFNAMSIZ))
5315                         n = priv_args[k].get_args & IW_PRIV_SIZE_MASK;
5316                 else
5317                         n = wdata.data.length;
5318
5319                 output = rtw_zmalloc(4096);
5320                 if (NULL == output) {
5321                         err =  -ENOMEM;
5322                         goto exit;
5323                 }
5324
5325                 switch (priv_args[k].get_args & IW_PRIV_TYPE_MASK) {
5326                         case IW_PRIV_TYPE_BYTE:
5327                                 /* Display args */
5328                                 for (j = 0; j < n; j++) {
5329                                         sprintf(str, "%d  ", extra[j]);
5330                                         len = strlen(str);
5331                                         output_len = strlen(output);
5332                                         if ((output_len + len + 1) > 4096) {
5333                                                 err = -E2BIG;
5334                                                 goto exit;
5335                                         }
5336                                         memcpy(output+output_len, str, len);
5337                                 }
5338                                 break;
5339
5340                         case IW_PRIV_TYPE_INT:
5341                                 /* Display args */
5342                                 for (j = 0; j < n; j++) {
5343                                         sprintf(str, "%d  ", ((__s32*)extra)[j]);
5344                                         len = strlen(str);
5345                                         output_len = strlen(output);
5346                                         if ((output_len + len + 1) > 4096) {
5347                                                 err = -E2BIG;
5348                                                 goto exit;
5349                                         }
5350                                         memcpy(output+output_len, str, len);
5351                                 }
5352                                 break;
5353
5354                         case IW_PRIV_TYPE_CHAR:
5355                                 /* Display args */
5356                                 memcpy(output, extra, n);
5357                                 break;
5358
5359                         default:
5360                                 DBG_8192C("%s: Not yet implemented...\n", __func__);
5361                                 err = -1;
5362                                 goto exit;
5363                 }
5364
5365                 output_len = strlen(output) + 1;
5366                 wrq_data->data.length = output_len;
5367                 if (copy_to_user(wrq_data->data.pointer, output, output_len)) {
5368                         err = -EFAULT;
5369                         goto exit;
5370                 }
5371         } else { /* if args to set */
5372                 wrq_data->data.length = 0;
5373         }
5374
5375 exit:
5376         kfree(input);
5377         kfree(buffer);
5378         kfree(output);
5379
5380         return err;
5381 }
5382
5383 int rtw_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
5384 {
5385         struct iwreq *wrq = (struct iwreq *)rq;
5386         int ret = 0;
5387
5388         switch (cmd) {
5389                 case RTL_IOCTL_WPA_SUPPLICANT:
5390                         ret = wpa_supplicant_ioctl(dev, &wrq->u.data);
5391                         break;
5392                 case RTL_IOCTL_HOSTAPD:
5393                         ret = rtw_hostapd_ioctl(dev, &wrq->u.data);
5394                         break;
5395                 case SIOCDEVPRIVATE:
5396                         ret = rtw_ioctl_wext_private(dev, &wrq->u);
5397                         break;
5398                 default:
5399                         ret = -EOPNOTSUPP;
5400                         break;
5401         }
5402
5403         return ret;
5404 }