drivers/net/wireless/rockchip_wlan/rtl8723bs/os_dep/linux/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  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  *
  19  ******************************************************************************/
  20 #define _IOCTL_LINUX_C_
  21
  22 #include <drv_types.h>
  23
  24 //#ifdef CONFIG_MP_INCLUDED
  25 #include <rtw_mp_ioctl.h>
  26 #include "../../hal/OUTSRC/odm_precomp.h"
  27 //#endif
  28
  29 #if defined(CONFIG_RTL8723A)
  30 #include "rtl8723a_hal.h"
  31 #include <rtw_bt_mp.h>
  32 #endif
  33
  34 #if defined(CONFIG_RTL8723B)
  35 #include <rtw_bt_mp.h>
  36 #endif
  37
  38 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27))
  39 #define  iwe_stream_add_event(a, b, c, d, e)  iwe_stream_add_event(b, c, d, e)
  40 #define  iwe_stream_add_point(a, b, c, d, e)  iwe_stream_add_point(b, c, d, e)
  41 #endif
  42
  43 #ifdef CONFIG_80211N_HT
  44 extern int rtw_ht_enable;
  45 #endif
  46
  47
  48 #define RTL_IOCTL_WPA_SUPPLICANT        SIOCIWFIRSTPRIV+30
  49
  50 #define SCAN_ITEM_SIZE 768
  51 #define MAX_CUSTOM_LEN 64
  52 #define RATE_COUNT 4
  53
  54 #ifdef CONFIG_GLOBAL_UI_PID
  55 extern int ui_pid[3];
  56 #endif
  57
  58 // combo scan
  59 #define WEXT_CSCAN_AMOUNT 9
  60 #define WEXT_CSCAN_BUF_LEN              360
  61 #define WEXT_CSCAN_HEADER               "CSCAN S\x01\x00\x00S\x00"
  62 #define WEXT_CSCAN_HEADER_SIZE          12
  63 #define WEXT_CSCAN_SSID_SECTION         'S'
  64 #define WEXT_CSCAN_CHANNEL_SECTION      'C'
  65 #define WEXT_CSCAN_NPROBE_SECTION       'N'
  66 #define WEXT_CSCAN_ACTV_DWELL_SECTION   'A'
  67 #define WEXT_CSCAN_PASV_DWELL_SECTION   'P'
  68 #define WEXT_CSCAN_HOME_DWELL_SECTION   'H'
  69 #define WEXT_CSCAN_TYPE_SECTION         'T'
  70
  71
  72 extern u8 key_2char2num(u8 hch, u8 lch);
  73 extern u8 str_2char2num(u8 hch, u8 lch);
  74 extern void macstr2num(u8 *dst, u8 *src);
  75 extern u8 convert_ip_addr(u8 hch, u8 mch, u8 lch);
  76
  77 u32 rtw_rates[] = {1000000,2000000,5500000,11000000,
  78         6000000,9000000,12000000,18000000,24000000,36000000,48000000,54000000};
  79
  80 static const char * const iw_operation_mode[] =
  81 {
  82         "Auto", "Ad-Hoc", "Managed",  "Master", "Repeater", "Secondary", "Monitor"
  83 };
  84
  85 static int hex2num_i(char c)
  86 {
  87         if (c >= '0' && c <= '9')
  88                 return c - '0';
  89         if (c >= 'a' && c <= 'f')
  90                 return c - 'a' + 10;
  91         if (c >= 'A' && c <= 'F')
  92                 return c - 'A' + 10;
  93         return -1;
  94 }
  95
  96 static int hex2byte_i(const char *hex)
  97 {
  98         int a, b;
  99         a = hex2num_i(*hex++);
 100         if (a < 0)
 101                 return -1;
 102         b = hex2num_i(*hex++);
 103         if (b < 0)
 104                 return -1;
 105         return (a << 4) | b;
 106 }
 107
 108 /**
 109  * hwaddr_aton - Convert ASCII string to MAC address
 110  * @txt: MAC address as a string (e.g., "00:11:22:33:44:55")
 111  * @addr: Buffer for the MAC address (ETH_ALEN = 6 bytes)
 112  * Returns: 0 on success, -1 on failure (e.g., string not a MAC address)
 113  */
 114 static int hwaddr_aton_i(const char *txt, u8 *addr)
 115 {
 116         int i;
 117
 118         for (i = 0; i < 6; i++) {
 119                 int a, b;
 120
 121                 a = hex2num_i(*txt++);
 122                 if (a < 0)
 123                         return -1;
 124                 b = hex2num_i(*txt++);
 125                 if (b < 0)
 126                         return -1;
 127                 *addr++ = (a << 4) | b;
 128                 if (i < 5 && *txt++ != ':')
 129                         return -1;
 130         }
 131
 132         return 0;
 133 }
 134
 135 static void indicate_wx_custom_event(_adapter *padapter, char *msg)
 136 {
 137         u8 *buff, *p;
 138         union iwreq_data wrqu;
 139
 140         if (strlen(msg) > IW_CUSTOM_MAX) {
 141                 DBG_871X("%s strlen(msg):%zu > IW_CUSTOM_MAX:%u\n", __FUNCTION__ , strlen(msg), IW_CUSTOM_MAX);
 142                 return;
 143         }
 144
 145         buff = rtw_zmalloc(IW_CUSTOM_MAX+1);
 146         if(!buff)
 147                 return;
 148
 149         _rtw_memcpy(buff, msg, strlen(msg));
 150
 151         _rtw_memset(&wrqu,0,sizeof(wrqu));
 152         wrqu.data.length = strlen(msg);
 153
 154         DBG_871X("%s %s\n", __FUNCTION__, buff);
 155 #ifndef CONFIG_IOCTL_CFG80211
 156         wireless_send_event(padapter->pnetdev, IWEVCUSTOM, &wrqu, buff);
 157 #endif
 158
 159         rtw_mfree(buff, IW_CUSTOM_MAX+1);
 160
 161 }
 162
 163
 164 static void request_wps_pbc_event(_adapter *padapter)
 165 {
 166         u8 *buff, *p;
 167         union iwreq_data wrqu;
 168
 169
 170         buff = rtw_malloc(IW_CUSTOM_MAX);
 171         if(!buff)
 172                 return;
 173
 174         _rtw_memset(buff, 0, IW_CUSTOM_MAX);
 175
 176         p=buff;
 177
 178         p+=sprintf(p, "WPS_PBC_START.request=TRUE");
 179
 180         _rtw_memset(&wrqu,0,sizeof(wrqu));
 181
 182         wrqu.data.length = p-buff;
 183
 184         wrqu.data.length = (wrqu.data.length<IW_CUSTOM_MAX) ? wrqu.data.length:IW_CUSTOM_MAX;
 185
 186         DBG_871X("%s\n", __FUNCTION__);
 187
 188 #ifndef CONFIG_IOCTL_CFG80211
 189         wireless_send_event(padapter->pnetdev, IWEVCUSTOM, &wrqu, buff);
 190 #endif
 191
 192         if(buff)
 193         {
 194                 rtw_mfree(buff, IW_CUSTOM_MAX);
 195         }
 196
 197 }
 198
 199 #ifdef CONFIG_SUPPORT_HW_WPS_PBC
 200 void rtw_request_wps_pbc_event(_adapter *padapter)
 201 {
 202 #ifdef RTK_DMP_PLATFORM
 203 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,12))
 204         kobject_uevent(&padapter->pnetdev->dev.kobj, KOBJ_NET_PBC);
 205 #else
 206         kobject_hotplug(&padapter->pnetdev->class_dev.kobj, KOBJ_NET_PBC);
 207 #endif
 208 #else
 209
 210         if ( padapter->pid[0] == 0 )
 211         {       //      0 is the default value and it means the application monitors the HW PBC doesn't privde its pid to driver.
 212                 return;
 213         }
 214
 215         rtw_signal_process(padapter->pid[0], SIGUSR1);
 216
 217 #endif
 218
 219         rtw_led_control(padapter, LED_CTL_START_WPS_BOTTON);
 220 }
 221 #endif//#ifdef CONFIG_SUPPORT_HW_WPS_PBC
 222
 223 void indicate_wx_scan_complete_event(_adapter *padapter)
 224 {
 225         union iwreq_data wrqu;
 226         struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
 227
 228         _rtw_memset(&wrqu, 0, sizeof(union iwreq_data));
 229
 230         //DBG_871X("+rtw_indicate_wx_scan_complete_event\n");
 231 #ifndef CONFIG_IOCTL_CFG80211
 232         wireless_send_event(padapter->pnetdev, SIOCGIWSCAN, &wrqu, NULL);
 233 #endif
 234 }
 235
 236
 237 void rtw_indicate_wx_assoc_event(_adapter *padapter)
 238 {
 239         union iwreq_data wrqu;
 240         struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
 241         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 242         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 243         WLAN_BSSID_EX           *pnetwork = (WLAN_BSSID_EX*)(&(pmlmeinfo->network));
 244
 245         _rtw_memset(&wrqu, 0, sizeof(union iwreq_data));
 246
 247         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
 248
 249         if(check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)==_TRUE )
 250                 _rtw_memcpy(wrqu.ap_addr.sa_data, pnetwork->MacAddress, ETH_ALEN);
 251         else
 252                 _rtw_memcpy(wrqu.ap_addr.sa_data, pmlmepriv->cur_network.network.MacAddress, ETH_ALEN);
 253
 254         DBG_871X_LEVEL(_drv_always_, "assoc success\n");
 255 #ifndef CONFIG_IOCTL_CFG80211
 256         wireless_send_event(padapter->pnetdev, SIOCGIWAP, &wrqu, NULL);
 257 #endif
 258 }
 259
 260 void rtw_indicate_wx_disassoc_event(_adapter *padapter)
 261 {
 262         union iwreq_data wrqu;
 263
 264         _rtw_memset(&wrqu, 0, sizeof(union iwreq_data));
 265
 266         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
 267         _rtw_memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
 268
 269 #ifndef CONFIG_IOCTL_CFG80211
 270         DBG_871X_LEVEL(_drv_always_, "indicate disassoc\n");
 271         wireless_send_event(padapter->pnetdev, SIOCGIWAP, &wrqu, NULL);
 272 #endif
 273 }
 274
 275 /*
 276 uint    rtw_is_cckrates_included(u8 *rate)
 277 {
 278                 u32     i = 0;
 279
 280                 while(rate[i]!=0)
 281                 {
 282                         if  (  (((rate[i]) & 0x7f) == 2)        || (((rate[i]) & 0x7f) == 4) ||
 283                         (((rate[i]) & 0x7f) == 11)  || (((rate[i]) & 0x7f) == 22) )
 284                         return _TRUE;
 285                         i++;
 286                 }
 287
 288                 return _FALSE;
 289 }
 290
 291 uint    rtw_is_cckratesonly_included(u8 *rate)
 292 {
 293         u32 i = 0;
 294
 295         while(rate[i]!=0)
 296         {
 297                         if  (  (((rate[i]) & 0x7f) != 2) && (((rate[i]) & 0x7f) != 4) &&
 298                                 (((rate[i]) & 0x7f) != 11)  && (((rate[i]) & 0x7f) != 22) )
 299                         return _FALSE;
 300                         i++;
 301         }
 302
 303         return _TRUE;
 304 }
 305 */
 306
 307 static char *translate_scan(_adapter *padapter,
 308                                 struct iw_request_info* info, struct wlan_network *pnetwork,
 309                                 char *start, char *stop)
 310 {
 311         struct iw_event iwe;
 312         u16 cap;
 313         u32 ht_ielen = 0, vht_ielen = 0;
 314         char custom[MAX_CUSTOM_LEN];
 315         char *p;
 316         u16 max_rate=0, rate, ht_cap=_FALSE, vht_cap = _FALSE;
 317         u32 i = 0;
 318         char    *current_val;
 319         long rssi;
 320         u8 bw_40MHz=0, short_GI=0, bw_160MHz=0, vht_highest_rate = 0;
 321         u16 mcs_rate=0, vht_data_rate=0;
 322         u8 ie_offset = (pnetwork->network.Reserved[0] == 2? 0:12);
 323         struct registry_priv *pregpriv = &padapter->registrypriv;
 324 #ifdef CONFIG_P2P
 325         struct wifidirect_info  *pwdinfo = &padapter->wdinfo;
 326 #endif //CONFIG_P2P
 327
 328 #ifdef CONFIG_P2P
 329 #ifdef CONFIG_WFD
 330         if ( SCAN_RESULT_ALL == pwdinfo->wfd_info->scan_result_type )
 331         {
 332
 333         }
 334         else if ( ( SCAN_RESULT_P2P_ONLY == pwdinfo->wfd_info->scan_result_type ) ||
 335                       ( SCAN_RESULT_WFD_TYPE == pwdinfo->wfd_info->scan_result_type ) )
 336 #endif // CONFIG_WFD
 337         {
 338                 if(!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
 339                 {
 340                         u32     blnGotP2PIE = _FALSE;
 341
 342                         //      User is doing the P2P device discovery
 343                         //      The prefix of SSID should be "DIRECT-" and the IE should contains the P2P IE.
 344                         //      If not, the driver should ignore this AP and go to the next AP.
 345
 346                         //      Verifying the SSID
 347                         if ( _rtw_memcmp( pnetwork->network.Ssid.Ssid, pwdinfo->p2p_wildcard_ssid, P2P_WILDCARD_SSID_LEN ) )
 348                         {
 349                                 u32     p2pielen = 0;
 350
 351                                 //      Verifying the P2P IE
 352                                 if (rtw_get_p2p_ie_from_scan_queue(&pnetwork->network.IEs[0], pnetwork->network.IELength, NULL, &p2pielen, pnetwork->network.Reserved[0]))
 353                                 {
 354                                         blnGotP2PIE = _TRUE;
 355                                 }
 356                         }
 357
 358                         if ( blnGotP2PIE == _FALSE )
 359                         {
 360                                 return start;
 361                         }
 362
 363                 }
 364         }
 365
 366 #ifdef CONFIG_WFD
 367         if ( SCAN_RESULT_WFD_TYPE == pwdinfo->wfd_info->scan_result_type )
 368         {
 369                 u32     blnGotWFD = _FALSE;
 370                 u8      wfd_ie[ 128 ] = { 0x00 };
 371                 uint    wfd_ielen = 0;
 372
 373                 if ( rtw_get_wfd_ie_from_scan_queue( &pnetwork->network.IEs[0], pnetwork->network.IELength,  wfd_ie, &wfd_ielen, pnetwork->network.Reserved[0]) )
 374                 {
 375                         u8      wfd_devinfo[ 6 ] = { 0x00 };
 376                         uint    wfd_devlen = 6;
 377
 378                         if ( rtw_get_wfd_attr_content( wfd_ie, wfd_ielen, WFD_ATTR_DEVICE_INFO, wfd_devinfo, &wfd_devlen) )
 379                         {
 380                                 if ( pwdinfo->wfd_info->wfd_device_type == WFD_DEVINFO_PSINK )
 381                                 {
 382                                         //      the first two bits will indicate the WFD device type
 383                                         if ( ( wfd_devinfo[ 1 ] & 0x03 ) == WFD_DEVINFO_SOURCE )
 384                                         {
 385                                                 //      If this device is Miracast PSink device, the scan reuslt should just provide the Miracast source.
 386                                                 blnGotWFD = _TRUE;
 387                                         }
 388                                 }
 389                                 else if ( pwdinfo->wfd_info->wfd_device_type == WFD_DEVINFO_SOURCE )
 390                                 {
 391                                         //      the first two bits will indicate the WFD device type
 392                                         if ( ( wfd_devinfo[ 1 ] & 0x03 ) == WFD_DEVINFO_PSINK )
 393                                         {
 394                                                 //      If this device is Miracast source device, the scan reuslt should just provide the Miracast PSink.
 395                                                 //      Todo: How about the SSink?!
 396                                                 blnGotWFD = _TRUE;
 397                                         }
 398                                 }
 399                         }
 400                 }
 401
 402                 if ( blnGotWFD == _FALSE )
 403                 {
 404                         return start;
 405                 }
 406         }
 407 #endif // CONFIG_WFD
 408
 409 #endif //CONFIG_P2P
 410
 411         /*  AP MAC address  */
 412         iwe.cmd = SIOCGIWAP;
 413         iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
 414
 415         _rtw_memcpy(iwe.u.ap_addr.sa_data, pnetwork->network.MacAddress, ETH_ALEN);
 416         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_ADDR_LEN);
 417
 418         /* Add the ESSID */
 419         iwe.cmd = SIOCGIWESSID;
 420         iwe.u.data.flags = 1;
 421         iwe.u.data.length = min((u16)pnetwork->network.Ssid.SsidLength, (u16)32);
 422         start = iwe_stream_add_point(info, start, stop, &iwe, pnetwork->network.Ssid.Ssid);
 423
 424         //parsing HT_CAP_IE
 425         if (pnetwork->network.Reserved[0] == 2) // Probe Request
 426         {
 427                 p = rtw_get_ie(&pnetwork->network.IEs[0], _HT_CAPABILITY_IE_, &ht_ielen, pnetwork->network.IELength);
 428         }
 429         else
 430         {
 431                 p = rtw_get_ie(&pnetwork->network.IEs[12], _HT_CAPABILITY_IE_, &ht_ielen, pnetwork->network.IELength-12);
 432         }
 433         if(p && ht_ielen>0)
 434         {
 435                 struct rtw_ieee80211_ht_cap *pht_capie;
 436                 ht_cap = _TRUE;
 437                 pht_capie = (struct rtw_ieee80211_ht_cap *)(p+2);
 438                 _rtw_memcpy(&mcs_rate , pht_capie->supp_mcs_set, 2);
 439                 bw_40MHz = (pht_capie->cap_info&IEEE80211_HT_CAP_SUP_WIDTH) ? 1:0;
 440                 short_GI = (pht_capie->cap_info&(IEEE80211_HT_CAP_SGI_20|IEEE80211_HT_CAP_SGI_40)) ? 1:0;
 441         }
 442
 443 #ifdef CONFIG_80211AC_VHT
 444         //parsing VHT_CAP_IE
 445         p = rtw_get_ie(&pnetwork->network.IEs[ie_offset], EID_VHTCapability, &vht_ielen, pnetwork->network.IELength-ie_offset);
 446         if(p && vht_ielen>0)
 447         {
 448                 u8      mcs_map[2];
 449
 450                 vht_cap = _TRUE;
 451                 bw_160MHz = GET_VHT_CAPABILITY_ELE_CHL_WIDTH(p+2);
 452                 if(bw_160MHz)
 453                         short_GI = GET_VHT_CAPABILITY_ELE_SHORT_GI160M(p+2);
 454                 else
 455                         short_GI = GET_VHT_CAPABILITY_ELE_SHORT_GI80M(p+2);
 456
 457                 _rtw_memcpy(mcs_map, GET_VHT_CAPABILITY_ELE_TX_MCS(p+2), 2);
 458
 459                 vht_highest_rate = rtw_get_vht_highest_rate(mcs_map);
 460                 vht_data_rate = rtw_vht_mcs_to_data_rate(CHANNEL_WIDTH_80, short_GI, vht_highest_rate);
 461         }
 462 #endif
 463
 464         /* Add the protocol name */
 465         iwe.cmd = SIOCGIWNAME;
 466         if ((rtw_is_cckratesonly_included((u8*)&pnetwork->network.SupportedRates)) == _TRUE)
 467         {
 468                 if(ht_cap == _TRUE)
 469                         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bn");
 470                 else
 471                 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11b");
 472         }
 473         else if ((rtw_is_cckrates_included((u8*)&pnetwork->network.SupportedRates)) == _TRUE)
 474         {
 475                 if(ht_cap == _TRUE)
 476                         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bgn");
 477                 else
 478                         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bg");
 479         }
 480         else
 481         {
 482                 if(pnetwork->network.Configuration.DSConfig > 14)
 483                 {
 484                         if(vht_cap == _TRUE)
 485                                 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11AC");
 486                         else if(ht_cap == _TRUE)
 487                                 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11an");
 488                         else
 489                                 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11a");
 490                 }
 491                 else
 492                 {
 493                         if(ht_cap == _TRUE)
 494                                 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11gn");
 495                         else
 496                                 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11g");
 497                 }
 498         }
 499
 500         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_CHAR_LEN);
 501
 502           /* Add mode */
 503         if (pnetwork->network.Reserved[0] == 2) // Probe Request
 504         {
 505                 cap = 0;
 506         }
 507         else
 508         {
 509         iwe.cmd = SIOCGIWMODE;
 510                 _rtw_memcpy((u8 *)&cap, rtw_get_capability_from_ie(pnetwork->network.IEs), 2);
 511                 cap = le16_to_cpu(cap);
 512         }
 513
 514         if(cap & (WLAN_CAPABILITY_IBSS |WLAN_CAPABILITY_BSS)){
 515                 if (cap & WLAN_CAPABILITY_BSS)
 516                         iwe.u.mode = IW_MODE_MASTER;
 517                 else
 518                         iwe.u.mode = IW_MODE_ADHOC;
 519
 520                 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_UINT_LEN);
 521         }
 522
 523         if(pnetwork->network.Configuration.DSConfig<1 /*|| pnetwork->network.Configuration.DSConfig>14*/)
 524                 pnetwork->network.Configuration.DSConfig = 1;
 525
 526          /* Add frequency/channel */
 527         iwe.cmd = SIOCGIWFREQ;
 528         iwe.u.freq.m = rtw_ch2freq(pnetwork->network.Configuration.DSConfig) * 100000;
 529         iwe.u.freq.e = 1;
 530         iwe.u.freq.i = pnetwork->network.Configuration.DSConfig;
 531         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_FREQ_LEN);
 532
 533         /* Add encryption capability */
 534         iwe.cmd = SIOCGIWENCODE;
 535         if (cap & WLAN_CAPABILITY_PRIVACY)
 536                 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
 537         else
 538                 iwe.u.data.flags = IW_ENCODE_DISABLED;
 539         iwe.u.data.length = 0;
 540         start = iwe_stream_add_point(info, start, stop, &iwe, pnetwork->network.Ssid.Ssid);
 541
 542         /*Add basic and extended rates */
 543         max_rate = 0;
 544         p = custom;
 545         p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), " Rates (Mb/s): ");
 546         while(pnetwork->network.SupportedRates[i]!=0)
 547         {
 548                 rate = pnetwork->network.SupportedRates[i]&0x7F;
 549                 if (rate > max_rate)
 550                         max_rate = rate;
 551                 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
 552                               "%d%s ", rate >> 1, (rate & 1) ? ".5" : "");
 553                 i++;
 554         }
 555
 556         if(vht_cap == _TRUE) {
 557                 max_rate = vht_data_rate;
 558         }
 559         else if(ht_cap == _TRUE)
 560         {
 561                 if(mcs_rate&0x8000)//MCS15
 562                 {
 563                         max_rate = (bw_40MHz) ? ((short_GI)?300:270):((short_GI)?144:130);
 564
 565                 }
 566                 else if(mcs_rate&0x0080)//MCS7
 567                 {
 568                         max_rate = (bw_40MHz) ? ((short_GI)?150:135):((short_GI)?72:65);
 569                 }
 570                 else//default MCS7
 571                 {
 572                         //DBG_871X("wx_get_scan, mcs_rate_bitmap=0x%x\n", mcs_rate);
 573                         max_rate = (bw_40MHz) ? ((short_GI)?150:135):((short_GI)?72:65);
 574                 }
 575
 576                 max_rate = max_rate*2;//Mbps/2;
 577         }
 578
 579         iwe.cmd = SIOCGIWRATE;
 580         iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
 581         iwe.u.bitrate.value = max_rate * 500000;
 582         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_PARAM_LEN);
 583
 584         //parsing WPA/WPA2 IE
 585         if (pnetwork->network.Reserved[0] != 2) // Probe Request
 586         {
 587                 u8 buf[MAX_WPA_IE_LEN*2];
 588                 u8 wpa_ie[255],rsn_ie[255];
 589                 u16 wpa_len=0,rsn_len=0;
 590                 u8 *p;
 591                 sint out_len=0;
 592                 out_len=rtw_get_sec_ie(pnetwork->network.IEs ,pnetwork->network.IELength,rsn_ie,&rsn_len,wpa_ie,&wpa_len);
 593                 RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,("rtw_wx_get_scan: ssid=%s\n",pnetwork->network.Ssid.Ssid));
 594                 RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,("rtw_wx_get_scan: wpa_len=%d rsn_len=%d\n",wpa_len,rsn_len));
 595
 596                 if (wpa_len > 0)
 597                 {
 598                         p=buf;
 599                         _rtw_memset(buf, 0, MAX_WPA_IE_LEN*2);
 600                         p += sprintf(p, "wpa_ie=");
 601                         for (i = 0; i < wpa_len; i++) {
 602                                 p += sprintf(p, "%02x", wpa_ie[i]);
 603                         }
 604
 605                         if (wpa_len > 100) {
 606                                 printk("-----------------Len %d----------------\n", wpa_len);
 607                                 for (i = 0; i < wpa_len; i++) {
 608                                         printk("%02x ", wpa_ie[i]);
 609                                 }
 610                                 printk("\n");
 611                                 printk("-----------------Len %d----------------\n", wpa_len);
 612                         }
 613
 614                         _rtw_memset(&iwe, 0, sizeof(iwe));
 615                         iwe.cmd = IWEVCUSTOM;
 616                         iwe.u.data.length = strlen(buf);
 617                         start = iwe_stream_add_point(info, start, stop, &iwe,buf);
 618
 619                         _rtw_memset(&iwe, 0, sizeof(iwe));
 620                         iwe.cmd =IWEVGENIE;
 621                         iwe.u.data.length = wpa_len;
 622                         start = iwe_stream_add_point(info, start, stop, &iwe, wpa_ie);
 623                 }
 624                 if (rsn_len > 0)
 625                 {
 626                         p = buf;
 627                         _rtw_memset(buf, 0, MAX_WPA_IE_LEN*2);
 628                         p += sprintf(p, "rsn_ie=");
 629                         for (i = 0; i < rsn_len; i++) {
 630                                 p += sprintf(p, "%02x", rsn_ie[i]);
 631                         }
 632                         _rtw_memset(&iwe, 0, sizeof(iwe));
 633                         iwe.cmd = IWEVCUSTOM;
 634                         iwe.u.data.length = strlen(buf);
 635                         start = iwe_stream_add_point(info, start, stop, &iwe,buf);
 636
 637                         _rtw_memset(&iwe, 0, sizeof(iwe));
 638                         iwe.cmd =IWEVGENIE;
 639                         iwe.u.data.length = rsn_len;
 640                         start = iwe_stream_add_point(info, start, stop, &iwe, rsn_ie);
 641                 }
 642         }
 643
 644         { //parsing WPS IE
 645                 uint cnt = 0,total_ielen;
 646                 u8 *wpsie_ptr=NULL;
 647                 uint wps_ielen = 0;
 648
 649                 u8 *ie_ptr = pnetwork->network.IEs + ie_offset;
 650                 total_ielen= pnetwork->network.IELength - ie_offset;
 651
 652                 if (pnetwork->network.Reserved[0] == 2) // Probe Request
 653                 {
 654                         ie_ptr = pnetwork->network.IEs;
 655                         total_ielen = pnetwork->network.IELength;
 656                 }
 657                 else     // Beacon or Probe Respones
 658                 {
 659                         ie_ptr = pnetwork->network.IEs + _FIXED_IE_LENGTH_;
 660                         total_ielen = pnetwork->network.IELength - _FIXED_IE_LENGTH_;
 661                 }
 662
 663                 while(cnt < total_ielen)
 664                 {
 665                         if(rtw_is_wps_ie(&ie_ptr[cnt], &wps_ielen) && (wps_ielen>2))
 666                         {
 667                                 wpsie_ptr = &ie_ptr[cnt];
 668                                 iwe.cmd =IWEVGENIE;
 669                                 iwe.u.data.length = (u16)wps_ielen;
 670                                 start = iwe_stream_add_point(info, start, stop, &iwe, wpsie_ptr);
 671                         }
 672                         cnt+=ie_ptr[cnt+1]+2; //goto next
 673                 }
 674         }
 675
 676 #ifdef CONFIG_WAPI_SUPPORT
 677         if (pnetwork->network.Reserved[0] != 2) // Probe Request
 678         {
 679                 sint out_len_wapi=0;
 680                 /* here use static for stack size */
 681                 static u8 buf_wapi[MAX_WAPI_IE_LEN*2];
 682                 static u8 wapi_ie[MAX_WAPI_IE_LEN];
 683                 u16 wapi_len=0;
 684                 u16  i;
 685
 686                 _rtw_memset(buf_wapi, 0, MAX_WAPI_IE_LEN);
 687                 _rtw_memset(wapi_ie, 0, MAX_WAPI_IE_LEN);
 688
 689                 out_len_wapi=rtw_get_wapi_ie(pnetwork->network.IEs ,pnetwork->network.IELength,wapi_ie,&wapi_len);
 690                 RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,("rtw_wx_get_scan: ssid=%s\n",pnetwork->network.Ssid.Ssid));
 691                 RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,("rtw_wx_get_scan: wapi_len=%d \n",wapi_len));
 692
 693                 DBG_871X("rtw_wx_get_scan: %s ",pnetwork->network.Ssid.Ssid);
 694                 DBG_871X("rtw_wx_get_scan: ssid = %d ",wapi_len);
 695
 696
 697                 if (wapi_len > 0)
 698                 {
 699                         p=buf_wapi;
 700                         _rtw_memset(buf_wapi, 0, MAX_WAPI_IE_LEN*2);
 701                         p += sprintf(p, "wapi_ie=");
 702                         for (i = 0; i < wapi_len; i++) {
 703                                 p += sprintf(p, "%02x", wapi_ie[i]);
 704                         }
 705
 706                         _rtw_memset(&iwe, 0, sizeof(iwe));
 707                         iwe.cmd = IWEVCUSTOM;
 708                         iwe.u.data.length = strlen(buf_wapi);
 709                         start = iwe_stream_add_point(info, start, stop, &iwe,buf_wapi);
 710
 711                         _rtw_memset(&iwe, 0, sizeof(iwe));
 712                         iwe.cmd =IWEVGENIE;
 713                         iwe.u.data.length = wapi_len;
 714                         start = iwe_stream_add_point(info, start, stop, &iwe, wapi_ie);
 715                 }
 716         }
 717 #endif
 718
 719 {
 720         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 721         u8 ss, sq;
 722
 723         /* Add quality statistics */
 724         iwe.cmd = IWEVQUAL;
 725         iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED
 726         #if defined(CONFIG_SIGNAL_DISPLAY_DBM) && defined(CONFIG_BACKGROUND_NOISE_MONITOR)
 727                 | IW_QUAL_NOISE_UPDATED
 728         #else
 729                 | IW_QUAL_NOISE_INVALID
 730         #endif
 731         #ifdef CONFIG_SIGNAL_DISPLAY_DBM
 732                 | IW_QUAL_DBM
 733         #endif
 734         ;
 735
 736         if ( check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE &&
 737                 is_same_network(&pmlmepriv->cur_network.network, &pnetwork->network, 0)){
 738                 ss = padapter->recvpriv.signal_strength;
 739                 sq = padapter->recvpriv.signal_qual;
 740         } else {
 741                 ss = pnetwork->network.PhyInfo.SignalStrength;
 742                 sq = pnetwork->network.PhyInfo.SignalQuality;
 743         }
 744
 745
 746         #ifdef CONFIG_SIGNAL_DISPLAY_DBM
 747         iwe.u.qual.level = (u8) translate_percentage_to_dbm(ss);//dbm
 748         #else
 749         #ifdef CONFIG_SKIP_SIGNAL_SCALE_MAPPING
 750         {
 751                 /* Do signal scale mapping when using percentage as the unit of signal strength, since the scale mapping is skipped in odm */
 752
 753                 HAL_DATA_TYPE *pHal = GET_HAL_DATA(padapter);
 754
 755                 iwe.u.qual.level = (u8)odm_SignalScaleMapping(&pHal->odmpriv, ss);
 756         }
 757         #else
 758         iwe.u.qual.level = (u8)ss;//%
 759         #endif
 760         #endif
 761
 762         iwe.u.qual.qual = (u8)sq;   // signal quality
 763
 764         #ifdef CONFIG_PLATFORM_ROCKCHIPS
 765         iwe.u.qual.noise = -100; // noise level suggest by zhf@rockchips
 766         #else
 767         #if defined(CONFIG_SIGNAL_DISPLAY_DBM) && defined(CONFIG_BACKGROUND_NOISE_MONITOR)
 768         {
 769                 s16 tmp_noise=0;
 770                 rtw_hal_get_odm_var(padapter, HAL_ODM_NOISE_MONITOR,&(pnetwork->network.Configuration.DSConfig), &(tmp_noise));
 771                 iwe.u.qual.noise = tmp_noise ;
 772         }
 773         #else
 774         iwe.u.qual.noise = 0; // noise level
 775         #endif
 776         #endif //CONFIG_PLATFORM_ROCKCHIPS
 777
 778         //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);
 779
 780         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_QUAL_LEN);
 781 }
 782
 783         {
 784                 u8 buf[MAX_WPA_IE_LEN];
 785                 u8 * p,*pos;
 786                 int len;
 787                 p = buf;
 788                 pos = pnetwork->network.Reserved;
 789                 _rtw_memset(buf, 0, MAX_WPA_IE_LEN);
 790                 p += sprintf(p, "fm=%02X%02X", pos[1], pos[0]);
 791                 _rtw_memset(&iwe, 0, sizeof(iwe));
 792                 iwe.cmd = IWEVCUSTOM;
 793                 iwe.u.data.length = strlen(buf);
 794                 start = iwe_stream_add_point(info, start, stop, &iwe, buf);
 795         }
 796
 797         return start;
 798 }
 799
 800 static int wpa_set_auth_algs(struct net_device *dev, u32 value)
 801 {
 802         _adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
 803         int ret = 0;
 804
 805         if ((value & AUTH_ALG_SHARED_KEY)&&(value & AUTH_ALG_OPEN_SYSTEM))
 806         {
 807                 DBG_871X("wpa_set_auth_algs, AUTH_ALG_SHARED_KEY and  AUTH_ALG_OPEN_SYSTEM [value:0x%x]\n",value);
 808                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 809                 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeAutoSwitch;
 810                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
 811         }
 812         else if (value & AUTH_ALG_SHARED_KEY)
 813         {
 814                 DBG_871X("wpa_set_auth_algs, AUTH_ALG_SHARED_KEY  [value:0x%x]\n",value);
 815                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 816
 817 #ifdef CONFIG_PLATFORM_MT53XX
 818                 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeAutoSwitch;
 819                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
 820 #else
 821                 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeShared;
 822                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Shared;
 823 #endif
 824         }
 825         else if(value & AUTH_ALG_OPEN_SYSTEM)
 826         {
 827                 DBG_871X("wpa_set_auth_algs, AUTH_ALG_OPEN_SYSTEM\n");
 828                 //padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
 829                 if(padapter->securitypriv.ndisauthtype < Ndis802_11AuthModeWPAPSK)
 830                 {
 831 #ifdef CONFIG_PLATFORM_MT53XX
 832                         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeAutoSwitch;
 833                         padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
 834 #else
 835                         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen;
 836                         padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
 837 #endif
 838                 }
 839
 840         }
 841         else if(value & AUTH_ALG_LEAP)
 842         {
 843                 DBG_871X("wpa_set_auth_algs, AUTH_ALG_LEAP\n");
 844         }
 845         else
 846         {
 847                 DBG_871X("wpa_set_auth_algs, error!\n");
 848                 ret = -EINVAL;
 849         }
 850
 851         return ret;
 852
 853 }
 854
 855 static int wpa_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len)
 856 {
 857         int ret = 0;
 858         u32 wep_key_idx, wep_key_len,wep_total_len;
 859         NDIS_802_11_WEP  *pwep = NULL;
 860         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
 861         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
 862         struct security_priv *psecuritypriv = &padapter->securitypriv;
 863 #ifdef CONFIG_P2P
 864         struct wifidirect_info* pwdinfo = &padapter->wdinfo;
 865 #endif //CONFIG_P2P
 866
 867 _func_enter_;
 868
 869         param->u.crypt.err = 0;
 870         param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
 871
 872         if (param_len < (u32) ((u8 *) param->u.crypt.key - (u8 *) param) + param->u.crypt.key_len)
 873         {
 874                 ret =  -EINVAL;
 875                 goto exit;
 876         }
 877
 878         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
 879             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
 880             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff)
 881         {
 882
 883                 if (param->u.crypt.idx >= WEP_KEYS
 884 #ifdef CONFIG_IEEE80211W
 885                         && param->u.crypt.idx > BIP_MAX_KEYID
 886 #endif //CONFIG_IEEE80211W
 887                         )
 888                 {
 889                         ret = -EINVAL;
 890                         goto exit;
 891                 }
 892         }
 893         else
 894         {
 895 #ifdef CONFIG_WAPI_SUPPORT
 896                 if (strcmp(param->u.crypt.alg, "SMS4"))
 897 #endif
 898                 {
 899                         ret = -EINVAL;
 900                         goto exit;
 901                 }
 902         }
 903
 904         if (strcmp(param->u.crypt.alg, "WEP") == 0)
 905         {
 906                 RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_err_,("wpa_set_encryption, crypt.alg = WEP\n"));
 907                 DBG_871X("wpa_set_encryption, crypt.alg = WEP\n");
 908
 909                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
 910                 padapter->securitypriv.dot11PrivacyAlgrthm=_WEP40_;
 911                 padapter->securitypriv.dot118021XGrpPrivacy=_WEP40_;
 912
 913                 wep_key_idx = param->u.crypt.idx;
 914                 wep_key_len = param->u.crypt.key_len;
 915
 916                 RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_info_,("(1)wep_key_idx=%d\n", wep_key_idx));
 917                 DBG_871X("(1)wep_key_idx=%d\n", wep_key_idx);
 918
 919                 if (wep_key_idx > WEP_KEYS)
 920                         return -EINVAL;
 921
 922                 RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_info_,("(2)wep_key_idx=%d\n", wep_key_idx));
 923
 924                 if (wep_key_len > 0)
 925                 {
 926                         wep_key_len = wep_key_len <= 5 ? 5 : 13;
 927                         wep_total_len = wep_key_len + FIELD_OFFSET(NDIS_802_11_WEP, KeyMaterial);
 928                         pwep =(NDIS_802_11_WEP   *) rtw_malloc(wep_total_len);
 929                         if(pwep == NULL){
 930                                 RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_err_,(" wpa_set_encryption: pwep allocate fail !!!\n"));
 931                                 goto exit;
 932                         }
 933
 934                         _rtw_memset(pwep, 0, wep_total_len);
 935
 936                         pwep->KeyLength = wep_key_len;
 937                         pwep->Length = wep_total_len;
 938
 939                         if(wep_key_len==13)
 940                         {
 941                                 padapter->securitypriv.dot11PrivacyAlgrthm=_WEP104_;
 942                                 padapter->securitypriv.dot118021XGrpPrivacy=_WEP104_;
 943                         }
 944                 }
 945                 else {
 946                         ret = -EINVAL;
 947                         goto exit;
 948                 }
 949
 950                 pwep->KeyIndex = wep_key_idx;
 951                 pwep->KeyIndex |= 0x80000000;
 952
 953                 _rtw_memcpy(pwep->KeyMaterial,  param->u.crypt.key, pwep->KeyLength);
 954
 955                 if(param->u.crypt.set_tx)
 956                 {
 957                         DBG_871X("wep, set_tx=1\n");
 958
 959                         if(rtw_set_802_11_add_wep(padapter, pwep) == (u8)_FAIL)
 960                         {
 961                                 ret = -EOPNOTSUPP ;
 962                         }
 963                 }
 964                 else
 965                 {
 966                         DBG_871X("wep, set_tx=0\n");
 967
 968                         //don't update "psecuritypriv->dot11PrivacyAlgrthm" and
 969                         //"psecuritypriv->dot11PrivacyKeyIndex=keyid", but can rtw_set_key to fw/cam
 970
 971                         if (wep_key_idx >= WEP_KEYS) {
 972                                 ret = -EOPNOTSUPP ;
 973                                 goto exit;
 974                         }
 975
 976                       _rtw_memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength);
 977                         psecuritypriv->dot11DefKeylen[wep_key_idx]=pwep->KeyLength;
 978                         rtw_set_key(padapter, psecuritypriv, wep_key_idx, 0, _TRUE);
 979                 }
 980
 981                 goto exit;
 982         }
 983
 984         if(padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) // 802_1x
 985         {
 986                 struct sta_info * psta,*pbcmc_sta;
 987                 struct sta_priv * pstapriv = &padapter->stapriv;
 988
 989                 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | WIFI_MP_STATE) == _TRUE) //sta mode
 990                 {
 991                         psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
 992                         if (psta == NULL) {
 993                                 //DEBUG_ERR( ("Set wpa_set_encryption: Obtain Sta_info fail \n"));
 994                         }
 995                         else
 996                         {
 997                                 //Jeff: don't disable ieee8021x_blocked while clearing key
 998                                 if (strcmp(param->u.crypt.alg, "none") != 0)
 999                                         psta->ieee8021x_blocked = _FALSE;
1000
1001                                 if((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled)||
1002                                                 (padapter->securitypriv.ndisencryptstatus ==  Ndis802_11Encryption3Enabled))
1003                                 {
1004                                         psta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
1005                                 }
1006
1007                                 if(param->u.crypt.set_tx ==1)//pairwise key
1008                                 {
1009                                         _rtw_memcpy(psta->dot118021x_UncstKey.skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
1010
1011                                         if(strcmp(param->u.crypt.alg, "TKIP") == 0)//set mic key
1012                                         {
1013                                                 //DEBUG_ERR(("\nset key length :param->u.crypt.key_len=%d\n", param->u.crypt.key_len));
1014                                                 _rtw_memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8);
1015                                                 _rtw_memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8);
1016
1017                                                 padapter->securitypriv.busetkipkey=_FALSE;
1018                                                 //_set_timer(&padapter->securitypriv.tkip_timer, 50);
1019                                         }
1020
1021                                         //DEBUG_ERR((" param->u.crypt.key_len=%d\n",param->u.crypt.key_len));
1022                                         DBG_871X(" ~~~~set sta key:unicastkey\n");
1023
1024                                         rtw_setstakey_cmd(padapter, psta, _TRUE, _TRUE);
1025                                 }
1026                                 else//group key
1027                                 {
1028                                         if(strcmp(param->u.crypt.alg, "TKIP") == 0 || strcmp(param->u.crypt.alg, "CCMP") == 0)
1029                                         {
1030                                                 _rtw_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));
1031                                                 //only TKIP group key need to install this
1032                                                 if(param->u.crypt.key_len > 16)
1033                                                 {
1034                                                         _rtw_memcpy(padapter->securitypriv.dot118021XGrptxmickey[param->u.crypt.idx].skey,&(param->u.crypt.key[16]),8);
1035                                                         _rtw_memcpy(padapter->securitypriv.dot118021XGrprxmickey[param->u.crypt.idx].skey,&(param->u.crypt.key[24]),8);
1036                                                 }
1037                                                 padapter->securitypriv.binstallGrpkey = _TRUE;
1038                                                 //DEBUG_ERR((" param->u.crypt.key_len=%d\n", param->u.crypt.key_len));
1039                                                 DBG_871X(" ~~~~set sta key:groupkey\n");
1040
1041                                                 padapter->securitypriv.dot118021XGrpKeyid = param->u.crypt.idx;
1042
1043                                                 rtw_set_key(padapter,&padapter->securitypriv,param->u.crypt.idx, 1, _TRUE);
1044                                         }
1045 #ifdef CONFIG_IEEE80211W
1046                                         else if(strcmp(param->u.crypt.alg, "BIP") == 0)
1047                                         {
1048                                                 int no;
1049                                                 //printk("BIP key_len=%d , index=%d @@@@@@@@@@@@@@@@@@\n", param->u.crypt.key_len, param->u.crypt.idx);
1050                                                 //save the IGTK key, length 16 bytes
1051                                                 _rtw_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));
1052                                                 /*printk("IGTK key below:\n");
1053                                                 for(no=0;no<16;no++)
1054                                                         printk(" %02x ", padapter->securitypriv.dot11wBIPKey[param->u.crypt.idx].skey[no]);
1055                                                 printk("\n");*/
1056                                                 padapter->securitypriv.dot11wBIPKeyid = param->u.crypt.idx;
1057                                                 padapter->securitypriv.binstallBIPkey = _TRUE;
1058                                                 DBG_871X(" ~~~~set sta key:IGKT\n");
1059                                         }
1060 #endif //CONFIG_IEEE80211W
1061
1062 #ifdef CONFIG_P2P
1063                                         if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_PROVISIONING_ING))
1064                                         {
1065                                                 rtw_p2p_set_state(pwdinfo, P2P_STATE_PROVISIONING_DONE);
1066                                         }
1067 #endif //CONFIG_P2P
1068
1069                                 }
1070                         }
1071
1072                         pbcmc_sta=rtw_get_bcmc_stainfo(padapter);
1073                         if(pbcmc_sta==NULL)
1074                         {
1075                                 //DEBUG_ERR( ("Set OID_802_11_ADD_KEY: bcmc stainfo is null \n"));
1076                         }
1077                         else
1078                         {
1079                                 //Jeff: don't disable ieee8021x_blocked while clearing key
1080                                 if (strcmp(param->u.crypt.alg, "none") != 0)
1081                                         pbcmc_sta->ieee8021x_blocked = _FALSE;
1082
1083                                 if((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled)||
1084                                                 (padapter->securitypriv.ndisencryptstatus ==  Ndis802_11Encryption3Enabled))
1085                                 {
1086                                         pbcmc_sta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
1087                                 }
1088                         }
1089                 }
1090                 else if(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) //adhoc mode
1091                 {
1092                 }
1093         }
1094
1095 #ifdef CONFIG_WAPI_SUPPORT
1096         if (strcmp(param->u.crypt.alg, "SMS4") == 0)
1097         {
1098                 PRT_WAPI_T                      pWapiInfo = &padapter->wapiInfo;
1099                 PRT_WAPI_STA_INFO       pWapiSta;
1100                 u8                                      WapiASUEPNInitialValueSrc[16] = {0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C} ;
1101                 u8                                      WapiAEPNInitialValueSrc[16] = {0x37,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C} ;
1102                 u8                                      WapiAEMultiCastPNInitialValueSrc[16] = {0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C} ;
1103
1104                 if(param->u.crypt.set_tx == 1)
1105                 {
1106                         list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
1107                                 if(_rtw_memcmp(pWapiSta->PeerMacAddr,param->sta_addr,6))
1108                                 {
1109                                         _rtw_memcpy(pWapiSta->lastTxUnicastPN,WapiASUEPNInitialValueSrc,16);
1110
1111                                         pWapiSta->wapiUsk.bSet = true;
1112                                         _rtw_memcpy(pWapiSta->wapiUsk.dataKey,param->u.crypt.key,16);
1113                                         _rtw_memcpy(pWapiSta->wapiUsk.micKey,param->u.crypt.key+16,16);
1114                                         pWapiSta->wapiUsk.keyId = param->u.crypt.idx ;
1115                                         pWapiSta->wapiUsk.bTxEnable = true;
1116
1117                                         _rtw_memcpy(pWapiSta->lastRxUnicastPNBEQueue,WapiAEPNInitialValueSrc,16);
1118                                         _rtw_memcpy(pWapiSta->lastRxUnicastPNBKQueue,WapiAEPNInitialValueSrc,16);
1119                                         _rtw_memcpy(pWapiSta->lastRxUnicastPNVIQueue,WapiAEPNInitialValueSrc,16);
1120                                         _rtw_memcpy(pWapiSta->lastRxUnicastPNVOQueue,WapiAEPNInitialValueSrc,16);
1121                                         _rtw_memcpy(pWapiSta->lastRxUnicastPN,WapiAEPNInitialValueSrc,16);
1122                                         pWapiSta->wapiUskUpdate.bTxEnable = false;
1123                                         pWapiSta->wapiUskUpdate.bSet = false;
1124
1125                                         if (psecuritypriv->sw_encrypt== false || psecuritypriv->sw_decrypt == false)
1126                                         {
1127                                                 //set unicast key for ASUE
1128                                                 rtw_wapi_set_key(padapter, &pWapiSta->wapiUsk, pWapiSta, false, false);
1129                                         }
1130                                 }
1131                         }
1132                 }
1133                 else
1134                 {
1135                         list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
1136                                 if(_rtw_memcmp(pWapiSta->PeerMacAddr,get_bssid(pmlmepriv),6))
1137                                 {
1138                                         pWapiSta->wapiMsk.bSet = true;
1139                                         _rtw_memcpy(pWapiSta->wapiMsk.dataKey,param->u.crypt.key,16);
1140                                         _rtw_memcpy(pWapiSta->wapiMsk.micKey,param->u.crypt.key+16,16);
1141                                         pWapiSta->wapiMsk.keyId = param->u.crypt.idx ;
1142                                         pWapiSta->wapiMsk.bTxEnable = false;
1143                                         if(!pWapiSta->bSetkeyOk)
1144                                                 pWapiSta->bSetkeyOk = true;
1145                                         pWapiSta->bAuthenticateInProgress = false;
1146
1147                                         _rtw_memcpy(pWapiSta->lastRxMulticastPN, WapiAEMultiCastPNInitialValueSrc, 16);
1148
1149                                         if (psecuritypriv->sw_decrypt == false)
1150                                         {
1151                                                 //set rx broadcast key for ASUE
1152                                                 rtw_wapi_set_key(padapter, &pWapiSta->wapiMsk, pWapiSta, true, false);
1153                                         }
1154                                 }
1155
1156                         }
1157                 }
1158         }
1159 #endif
1160
1161 exit:
1162
1163         if (pwep) {
1164                 rtw_mfree((u8 *)pwep, wep_total_len);
1165         }
1166
1167 _func_exit_;
1168
1169         return ret;
1170 }
1171
1172 static int rtw_set_wpa_ie(_adapter *padapter, char *pie, unsigned short ielen)
1173 {
1174         u8 *buf=NULL, *pos=NULL;
1175         u32 left;
1176         int group_cipher = 0, pairwise_cipher = 0;
1177         int ret = 0;
1178         u8 null_addr[]= {0,0,0,0,0,0};
1179 #ifdef CONFIG_P2P
1180         struct wifidirect_info* pwdinfo = &padapter->wdinfo;
1181 #endif //CONFIG_P2P
1182
1183         if((ielen > MAX_WPA_IE_LEN) || (pie == NULL)){
1184                 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
1185                 if(pie == NULL)
1186                         return ret;
1187                 else
1188                         return -EINVAL;
1189         }
1190
1191         if(ielen)
1192         {
1193                 buf = rtw_zmalloc(ielen);
1194                 if (buf == NULL){
1195                         ret =  -ENOMEM;
1196                         goto exit;
1197                 }
1198
1199                 _rtw_memcpy(buf, pie , ielen);
1200
1201                 //dump
1202                 {
1203                         int i;
1204                         DBG_871X("\n wpa_ie(length:%d):\n", ielen);
1205                         for(i=0;i<ielen;i=i+8)
1206                                 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]);
1207                 }
1208
1209                 pos = buf;
1210                 if(ielen < RSN_HEADER_LEN){
1211                         RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_err_,("Ie len too short %d\n", ielen));
1212                         ret  = -1;
1213                         goto exit;
1214                 }
1215
1216 #if 0
1217                 pos += RSN_HEADER_LEN;
1218                 left  = ielen - RSN_HEADER_LEN;
1219
1220                 if (left >= RSN_SELECTOR_LEN){
1221                         pos += RSN_SELECTOR_LEN;
1222                         left -= RSN_SELECTOR_LEN;
1223                 }
1224                 else if (left > 0){
1225                         RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_err_,("Ie length mismatch, %u too much \n", left));
1226                         ret =-1;
1227                         goto exit;
1228                 }
1229 #endif
1230
1231                 if(rtw_parse_wpa_ie(buf, ielen, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS)
1232                 {
1233                         padapter->securitypriv.dot11AuthAlgrthm= dot11AuthAlgrthm_8021X;
1234                         padapter->securitypriv.ndisauthtype=Ndis802_11AuthModeWPAPSK;
1235                         _rtw_memcpy(padapter->securitypriv.supplicant_ie, &buf[0], ielen);
1236                 }
1237
1238                 if(rtw_parse_wpa2_ie(buf, ielen, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS)
1239                 {
1240                         padapter->securitypriv.dot11AuthAlgrthm= dot11AuthAlgrthm_8021X;
1241                         padapter->securitypriv.ndisauthtype=Ndis802_11AuthModeWPA2PSK;
1242                         _rtw_memcpy(padapter->securitypriv.supplicant_ie, &buf[0], ielen);
1243                 }
1244
1245                 if (group_cipher == 0)
1246                 {
1247                         group_cipher = WPA_CIPHER_NONE;
1248                 }
1249                 if (pairwise_cipher == 0)
1250                 {
1251                         pairwise_cipher = WPA_CIPHER_NONE;
1252                 }
1253
1254                 switch(group_cipher)
1255                 {
1256                         case WPA_CIPHER_NONE:
1257                                 padapter->securitypriv.dot118021XGrpPrivacy=_NO_PRIVACY_;
1258                                 padapter->securitypriv.ndisencryptstatus=Ndis802_11EncryptionDisabled;
1259                                 break;
1260                         case WPA_CIPHER_WEP40:
1261                                 padapter->securitypriv.dot118021XGrpPrivacy=_WEP40_;
1262                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
1263                                 break;
1264                         case WPA_CIPHER_TKIP:
1265                                 padapter->securitypriv.dot118021XGrpPrivacy=_TKIP_;
1266                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
1267                                 break;
1268                         case WPA_CIPHER_CCMP:
1269                                 padapter->securitypriv.dot118021XGrpPrivacy=_AES_;
1270                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
1271                                 break;
1272                         case WPA_CIPHER_WEP104:
1273                                 padapter->securitypriv.dot118021XGrpPrivacy=_WEP104_;
1274                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
1275                                 break;
1276                 }
1277
1278                 switch(pairwise_cipher)
1279                 {
1280                         case WPA_CIPHER_NONE:
1281                                 padapter->securitypriv.dot11PrivacyAlgrthm=_NO_PRIVACY_;
1282                                 padapter->securitypriv.ndisencryptstatus=Ndis802_11EncryptionDisabled;
1283                                 break;
1284                         case WPA_CIPHER_WEP40:
1285                                 padapter->securitypriv.dot11PrivacyAlgrthm=_WEP40_;
1286                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
1287                                 break;
1288                         case WPA_CIPHER_TKIP:
1289                                 padapter->securitypriv.dot11PrivacyAlgrthm=_TKIP_;
1290                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
1291                                 break;
1292                         case WPA_CIPHER_CCMP:
1293                                 padapter->securitypriv.dot11PrivacyAlgrthm=_AES_;
1294                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
1295                                 break;
1296                         case WPA_CIPHER_WEP104:
1297                                 padapter->securitypriv.dot11PrivacyAlgrthm=_WEP104_;
1298                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
1299                                 break;
1300                 }
1301
1302                 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
1303                 {//set wps_ie
1304                         u16 cnt = 0;
1305                         u8 eid, wps_oui[4]={0x0,0x50,0xf2,0x04};
1306
1307                         while( cnt < ielen )
1308                         {
1309                                 eid = buf[cnt];
1310
1311                                 if((eid==_VENDOR_SPECIFIC_IE_)&&(_rtw_memcmp(&buf[cnt+2], wps_oui, 4)==_TRUE))
1312                                 {
1313                                         DBG_871X("SET WPS_IE\n");
1314
1315                                         padapter->securitypriv.wps_ie_len = ((buf[cnt+1]+2) < MAX_WPS_IE_LEN) ? (buf[cnt+1]+2):MAX_WPS_IE_LEN;
1316
1317                                         _rtw_memcpy(padapter->securitypriv.wps_ie, &buf[cnt], padapter->securitypriv.wps_ie_len);
1318
1319                                         set_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS);
1320
1321 #ifdef CONFIG_P2P
1322                                         if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_OK))
1323                                         {
1324                                                 rtw_p2p_set_state(pwdinfo, P2P_STATE_PROVISIONING_ING);
1325                                         }
1326 #endif //CONFIG_P2P
1327                                         cnt += buf[cnt+1]+2;
1328
1329                                         break;
1330                                 } else {
1331                                         cnt += buf[cnt+1]+2; //goto next
1332                                 }
1333                         }
1334                 }
1335         }
1336
1337         //TKIP and AES disallow multicast packets until installing group key
1338         if(padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_
1339                 || padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_WTMIC_
1340                 || padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)
1341                 //WPS open need to enable multicast
1342                 //|| check_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS) == _TRUE)
1343                 rtw_hal_set_hwreg(padapter, HW_VAR_OFF_RCR_AM, null_addr);
1344
1345         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1346                  ("rtw_set_wpa_ie: pairwise_cipher=0x%08x padapter->securitypriv.ndisencryptstatus=%d padapter->securitypriv.ndisauthtype=%d\n",
1347                   pairwise_cipher, padapter->securitypriv.ndisencryptstatus, padapter->securitypriv.ndisauthtype));
1348
1349 exit:
1350
1351         if (buf) rtw_mfree(buf, ielen);
1352
1353         return ret;
1354 }
1355
1356 static int rtw_wx_get_name(struct net_device *dev,
1357                              struct iw_request_info *info,
1358                              union iwreq_data *wrqu, char *extra)
1359 {
1360         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1361         u16 cap;
1362         u32 ht_ielen = 0;
1363         char *p;
1364         u8 ht_cap=_FALSE, vht_cap=_FALSE;
1365         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
1366         WLAN_BSSID_EX  *pcur_bss = &pmlmepriv->cur_network.network;
1367         NDIS_802_11_RATES_EX* prates = NULL;
1368
1369         RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,("cmd_code=%x\n", info->cmd));
1370
1371         _func_enter_;
1372
1373         if (check_fwstate(pmlmepriv, _FW_LINKED|WIFI_ADHOC_MASTER_STATE) == _TRUE)
1374         {
1375                 //parsing HT_CAP_IE
1376                 p = rtw_get_ie(&pcur_bss->IEs[12], _HT_CAPABILITY_IE_, &ht_ielen, pcur_bss->IELength-12);
1377                 if(p && ht_ielen>0)
1378                 {
1379                         ht_cap = _TRUE;
1380                 }
1381
1382 #ifdef CONFIG_80211AC_VHT
1383                 if(pmlmepriv->vhtpriv.vht_option == _TRUE)
1384                         vht_cap = _TRUE;
1385 #endif
1386
1387                 prates = &pcur_bss->SupportedRates;
1388
1389                 if (rtw_is_cckratesonly_included((u8*)prates) == _TRUE)
1390                 {
1391                         if(ht_cap == _TRUE)
1392                                 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11bn");
1393                         else
1394                                 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11b");
1395                 }
1396                 else if ((rtw_is_cckrates_included((u8*)prates)) == _TRUE)
1397                 {
1398                         if(ht_cap == _TRUE)
1399                                 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11bgn");
1400                         else
1401                                 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11bg");
1402                 }
1403                 else
1404                 {
1405                         if(pcur_bss->Configuration.DSConfig > 14)
1406                         {
1407                                 if(vht_cap == _TRUE)
1408                                         snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11AC");
1409                                 else if(ht_cap == _TRUE)
1410                                         snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11an");
1411                                 else
1412                                         snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11a");
1413                         }
1414                         else
1415                         {
1416                                 if(ht_cap == _TRUE)
1417                                         snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11gn");
1418                                 else
1419                                         snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11g");
1420                         }
1421                 }
1422         }
1423         else
1424         {
1425                 //prates = &padapter->registrypriv.dev_network.SupportedRates;
1426                 //snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11g");
1427                 snprintf(wrqu->name, IFNAMSIZ, "unassociated");
1428         }
1429
1430         _func_exit_;
1431
1432         return 0;
1433 }
1434
1435 static int rtw_wx_set_freq(struct net_device *dev,
1436                              struct iw_request_info *info,
1437                              union iwreq_data *wrqu, char *extra)
1438 {
1439         _func_enter_;
1440
1441         RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_, ("+rtw_wx_set_freq\n"));
1442
1443         _func_exit_;
1444
1445         return 0;
1446 }
1447
1448 static int rtw_wx_get_freq(struct net_device *dev,
1449                              struct iw_request_info *info,
1450                              union iwreq_data *wrqu, char *extra)
1451 {
1452         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1453         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
1454         WLAN_BSSID_EX  *pcur_bss = &pmlmepriv->cur_network.network;
1455
1456         if(check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)
1457         {
1458                 //wrqu->freq.m = ieee80211_wlan_frequencies[pcur_bss->Configuration.DSConfig-1] * 100000;
1459                 wrqu->freq.m = rtw_ch2freq(pcur_bss->Configuration.DSConfig) * 100000;
1460                 wrqu->freq.e = 1;
1461                 wrqu->freq.i = pcur_bss->Configuration.DSConfig;
1462
1463         }
1464         else{
1465                 wrqu->freq.m = rtw_ch2freq(padapter->mlmeextpriv.cur_channel) * 100000;
1466                 wrqu->freq.e = 1;
1467                 wrqu->freq.i = padapter->mlmeextpriv.cur_channel;
1468         }
1469
1470         return 0;
1471 }
1472
1473 static int rtw_wx_set_mode(struct net_device *dev, struct iw_request_info *a,
1474                              union iwreq_data *wrqu, char *b)
1475 {
1476         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1477         NDIS_802_11_NETWORK_INFRASTRUCTURE networkType ;
1478         int ret = 0;
1479
1480         _func_enter_;
1481
1482         if(_FAIL == rtw_pwr_wakeup(padapter)) {
1483                 ret= -EPERM;
1484                 goto exit;
1485         }
1486
1487         if (padapter->hw_init_completed==_FALSE){
1488                 ret = -EPERM;
1489                 goto exit;
1490         }
1491
1492         switch(wrqu->mode)
1493         {
1494                 case IW_MODE_AUTO:
1495                         networkType = Ndis802_11AutoUnknown;
1496                         DBG_871X("set_mode = IW_MODE_AUTO\n");
1497                         break;
1498                 case IW_MODE_ADHOC:
1499                         networkType = Ndis802_11IBSS;
1500                         DBG_871X("set_mode = IW_MODE_ADHOC\n");
1501                         break;
1502                 case IW_MODE_MASTER:
1503                         networkType = Ndis802_11APMode;
1504                         DBG_871X("set_mode = IW_MODE_MASTER\n");
1505                         //rtw_setopmode_cmd(padapter, networkType,_TRUE);
1506                         break;
1507                 case IW_MODE_INFRA:
1508                         networkType = Ndis802_11Infrastructure;
1509                         DBG_871X("set_mode = IW_MODE_INFRA\n");
1510                         break;
1511
1512                 default :
1513                         ret = -EINVAL;;
1514                         RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_err_,("\n Mode: %s is not supported  \n", iw_operation_mode[wrqu->mode]));
1515                         goto exit;
1516         }
1517
1518 /*
1519         if(Ndis802_11APMode == networkType)
1520         {
1521                 rtw_setopmode_cmd(padapter, networkType,_TRUE);
1522         }
1523         else
1524         {
1525                 rtw_setopmode_cmd(padapter, Ndis802_11AutoUnknown,_TRUE);
1526         }
1527 */
1528
1529         if (rtw_set_802_11_infrastructure_mode(padapter, networkType) ==_FALSE){
1530
1531                 ret = -EPERM;
1532                 goto exit;
1533
1534         }
1535
1536         rtw_setopmode_cmd(padapter, networkType,_TRUE);
1537
1538 exit:
1539
1540         _func_exit_;
1541
1542         return ret;
1543
1544 }
1545
1546 static int rtw_wx_get_mode(struct net_device *dev, struct iw_request_info *a,
1547                              union iwreq_data *wrqu, char *b)
1548 {
1549         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1550         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
1551
1552         RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,(" rtw_wx_get_mode \n"));
1553
1554         _func_enter_;
1555
1556         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == _TRUE)
1557         {
1558                 wrqu->mode = IW_MODE_INFRA;
1559         }
1560         else if  ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE) ||
1561                        (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE))
1562
1563         {
1564                 wrqu->mode = IW_MODE_ADHOC;
1565         }
1566         else if(check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE)
1567         {
1568                 wrqu->mode = IW_MODE_MASTER;
1569         }
1570         else
1571         {
1572                 wrqu->mode = IW_MODE_AUTO;
1573         }
1574
1575         _func_exit_;
1576
1577         return 0;
1578
1579 }
1580
1581
1582 static int rtw_wx_set_pmkid(struct net_device *dev,
1583                              struct iw_request_info *a,
1584                              union iwreq_data *wrqu, char *extra)
1585 {
1586         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1587         u8          j,blInserted = _FALSE;
1588         int         intReturn = _FALSE;
1589         struct mlme_priv  *pmlmepriv = &padapter->mlmepriv;
1590         struct security_priv *psecuritypriv = &padapter->securitypriv;
1591         struct iw_pmksa*  pPMK = ( struct iw_pmksa* ) extra;
1592         u8     strZeroMacAddress[ ETH_ALEN ] = { 0x00 };
1593         u8     strIssueBssid[ ETH_ALEN ] = { 0x00 };
1594
1595 /*
1596         struct iw_pmksa
1597         {
1598             __u32   cmd;
1599             struct sockaddr bssid;
1600             __u8    pmkid[IW_PMKID_LEN];   //IW_PMKID_LEN=16
1601         }
1602         There are the BSSID information in the bssid.sa_data array.
1603         If cmd is IW_PMKSA_FLUSH, it means the wpa_suppplicant wants to clear all the PMKID information.
1604         If cmd is IW_PMKSA_ADD, it means the wpa_supplicant wants to add a PMKID/BSSID to driver.
1605         If cmd is IW_PMKSA_REMOVE, it means the wpa_supplicant wants to remove a PMKID/BSSID from driver.
1606         */
1607
1608         _rtw_memcpy( strIssueBssid, pPMK->bssid.sa_data, ETH_ALEN);
1609         if ( pPMK->cmd == IW_PMKSA_ADD )
1610         {
1611                 DBG_871X( "[rtw_wx_set_pmkid] IW_PMKSA_ADD!\n" );
1612                 if ( _rtw_memcmp( strIssueBssid, strZeroMacAddress, ETH_ALEN ) == _TRUE )
1613                 {
1614                     return( intReturn );
1615                 }
1616                 else
1617                 {
1618                     intReturn = _TRUE;
1619                 }
1620                 blInserted = _FALSE;
1621
1622                 //overwrite PMKID
1623                 for(j=0 ; j<NUM_PMKID_CACHE; j++)
1624                 {
1625                         if( _rtw_memcmp( psecuritypriv->PMKIDList[j].Bssid, strIssueBssid, ETH_ALEN) ==_TRUE )
1626                         { // BSSID is matched, the same AP => rewrite with new PMKID.
1627
1628                                 DBG_871X( "[rtw_wx_set_pmkid] BSSID exists in the PMKList.\n" );
1629
1630                                 _rtw_memcpy( psecuritypriv->PMKIDList[j].PMKID, pPMK->pmkid, IW_PMKID_LEN);
1631                                 psecuritypriv->PMKIDList[ j ].bUsed = _TRUE;
1632                                 psecuritypriv->PMKIDIndex = j+1;
1633                                 blInserted = _TRUE;
1634                                 break;
1635                         }
1636                 }
1637
1638                 if(!blInserted)
1639                 {
1640                     // Find a new entry
1641                     DBG_871X( "[rtw_wx_set_pmkid] Use the new entry index = %d for this PMKID.\n",
1642                             psecuritypriv->PMKIDIndex );
1643
1644                     _rtw_memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].Bssid, strIssueBssid, ETH_ALEN);
1645                     _rtw_memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].PMKID, pPMK->pmkid, IW_PMKID_LEN);
1646
1647                     psecuritypriv->PMKIDList[ psecuritypriv->PMKIDIndex ].bUsed = _TRUE;
1648                     psecuritypriv->PMKIDIndex++ ;
1649                     if(psecuritypriv->PMKIDIndex==16)
1650                     {
1651                         psecuritypriv->PMKIDIndex =0;
1652                     }
1653                 }
1654         }
1655         else if ( pPMK->cmd == IW_PMKSA_REMOVE )
1656         {
1657                 DBG_871X( "[rtw_wx_set_pmkid] IW_PMKSA_REMOVE!\n" );
1658                 intReturn = _TRUE;
1659                 for(j=0 ; j<NUM_PMKID_CACHE; j++)
1660                 {
1661                         if( _rtw_memcmp( psecuritypriv->PMKIDList[j].Bssid, strIssueBssid, ETH_ALEN) ==_TRUE )
1662                         { // BSSID is matched, the same AP => Remove this PMKID information and reset it.
1663                                 _rtw_memset( psecuritypriv->PMKIDList[ j ].Bssid, 0x00, ETH_ALEN );
1664                                 psecuritypriv->PMKIDList[ j ].bUsed = _FALSE;
1665                                 break;
1666                         }
1667                 }
1668         }
1669         else if ( pPMK->cmd == IW_PMKSA_FLUSH )
1670         {
1671             DBG_871X( "[rtw_wx_set_pmkid] IW_PMKSA_FLUSH!\n" );
1672             _rtw_memset( &psecuritypriv->PMKIDList[ 0 ], 0x00, sizeof( RT_PMKID_LIST ) * NUM_PMKID_CACHE );
1673             psecuritypriv->PMKIDIndex = 0;
1674             intReturn = _TRUE;
1675         }
1676     return( intReturn );
1677 }
1678
1679 static int rtw_wx_get_sens(struct net_device *dev,
1680                              struct iw_request_info *info,
1681                              union iwreq_data *wrqu, char *extra)
1682 {
1683         #ifdef CONFIG_PLATFORM_ROCKCHIPS
1684         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1685         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1686
1687         /*
1688         *  20110311 Commented by Jeff
1689         *  For rockchip platform's wpa_driver_wext_get_rssi
1690         */
1691         if(check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
1692                 //wrqu->sens.value=-padapter->recvpriv.signal_strength;
1693                 wrqu->sens.value=-padapter->recvpriv.rssi;
1694                 //DBG_871X("%s: %d\n", __FUNCTION__, wrqu->sens.value);
1695                 wrqu->sens.fixed = 0; /* no auto select */
1696         } else
1697         #endif
1698         {
1699                 wrqu->sens.value = 0;
1700                 wrqu->sens.fixed = 0;   /* no auto select */
1701                 wrqu->sens.disabled = 1;
1702         }
1703         return 0;
1704 }
1705
1706 static int rtw_wx_get_range(struct net_device *dev,
1707                                 struct iw_request_info *info,
1708                                 union iwreq_data *wrqu, char *extra)
1709 {
1710         struct iw_range *range = (struct iw_range *)extra;
1711         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1712         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
1713
1714         u16 val;
1715         int i;
1716
1717         _func_enter_;
1718
1719         RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,("rtw_wx_get_range. cmd_code=%x\n", info->cmd));
1720
1721         wrqu->data.length = sizeof(*range);
1722         _rtw_memset(range, 0, sizeof(*range));
1723
1724         /* Let's try to keep this struct in the same order as in
1725          * linux/include/wireless.h
1726          */
1727
1728         /* TODO: See what values we can set, and remove the ones we can't
1729          * set, or fill them with some default data.
1730          */
1731
1732         /* ~5 Mb/s real (802.11b) */
1733         range->throughput = 5 * 1000 * 1000;
1734
1735         // TODO: Not used in 802.11b?
1736 //      range->min_nwid;        /* Minimal NWID we are able to set */
1737         // TODO: Not used in 802.11b?
1738 //      range->max_nwid;        /* Maximal NWID we are able to set */
1739
1740         /* Old Frequency (backward compat - moved lower ) */
1741 //      range->old_num_channels;
1742 //      range->old_num_frequency;
1743 //      range->old_freq[6]; /* Filler to keep "version" at the same offset */
1744
1745         /* signal level threshold range */
1746
1747         //percent values between 0 and 100.
1748         range->max_qual.qual = 100;
1749         range->max_qual.level = 100;
1750         range->max_qual.noise = 100;
1751         range->max_qual.updated = 7; /* Updated all three */
1752
1753
1754         range->avg_qual.qual = 92; /* > 8% missed beacons is 'bad' */
1755         /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
1756         range->avg_qual.level = 20 + -98;
1757         range->avg_qual.noise = 0;
1758         range->avg_qual.updated = 7; /* Updated all three */
1759
1760         range->num_bitrates = RATE_COUNT;
1761
1762         for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++) {
1763                 range->bitrate[i] = rtw_rates[i];
1764         }
1765
1766         range->min_frag = MIN_FRAG_THRESHOLD;
1767         range->max_frag = MAX_FRAG_THRESHOLD;
1768
1769         range->pm_capa = 0;
1770
1771         range->we_version_compiled = WIRELESS_EXT;
1772         range->we_version_source = 16;
1773
1774 //      range->retry_capa;      /* What retry options are supported */
1775 //      range->retry_flags;     /* How to decode max/min retry limit */
1776 //      range->r_time_flags;    /* How to decode max/min retry life */
1777 //      range->min_retry;       /* Minimal number of retries */
1778 //      range->max_retry;       /* Maximal number of retries */
1779 //      range->min_r_time;      /* Minimal retry lifetime */
1780 //      range->max_r_time;      /* Maximal retry lifetime */
1781
1782         for (i = 0, val = 0; i < MAX_CHANNEL_NUM; i++) {
1783
1784                 // Include only legal frequencies for some countries
1785                 if(pmlmeext->channel_set[i].ChannelNum != 0)
1786                 {
1787                         range->freq[val].i = pmlmeext->channel_set[i].ChannelNum;
1788                         range->freq[val].m = rtw_ch2freq(pmlmeext->channel_set[i].ChannelNum) * 100000;
1789                         range->freq[val].e = 1;
1790                         val++;
1791                 }
1792
1793                 if (val == IW_MAX_FREQUENCIES)
1794                         break;
1795         }
1796
1797         range->num_channels = val;
1798         range->num_frequency = val;
1799
1800 // Commented by Albert 2009/10/13
1801 // The following code will proivde the security capability to network manager.
1802 // If the driver doesn't provide this capability to network manager,
1803 // the WPA/WPA2 routers can't be choosen in the network manager.
1804
1805 /*
1806 #define IW_SCAN_CAPA_NONE               0x00
1807 #define IW_SCAN_CAPA_ESSID              0x01
1808 #define IW_SCAN_CAPA_BSSID              0x02
1809 #define IW_SCAN_CAPA_CHANNEL    0x04
1810 #define IW_SCAN_CAPA_MODE               0x08
1811 #define IW_SCAN_CAPA_RATE               0x10
1812 #define IW_SCAN_CAPA_TYPE               0x20
1813 #define IW_SCAN_CAPA_TIME               0x40
1814 */
1815
1816 #if WIRELESS_EXT > 17
1817         range->enc_capa = IW_ENC_CAPA_WPA|IW_ENC_CAPA_WPA2|
1818                           IW_ENC_CAPA_CIPHER_TKIP|IW_ENC_CAPA_CIPHER_CCMP;
1819 #endif
1820
1821 #ifdef IW_SCAN_CAPA_ESSID //WIRELESS_EXT > 21
1822         range->scan_capa = IW_SCAN_CAPA_ESSID | IW_SCAN_CAPA_TYPE |IW_SCAN_CAPA_BSSID|
1823                                         IW_SCAN_CAPA_CHANNEL|IW_SCAN_CAPA_MODE|IW_SCAN_CAPA_RATE;
1824 #endif
1825
1826
1827         _func_exit_;
1828
1829         return 0;
1830
1831 }
1832
1833 //set bssid flow
1834 //s1. rtw_set_802_11_infrastructure_mode()
1835 //s2. rtw_set_802_11_authentication_mode()
1836 //s3. set_802_11_encryption_mode()
1837 //s4. rtw_set_802_11_bssid()
1838 static int rtw_wx_set_wap(struct net_device *dev,
1839                          struct iw_request_info *info,
1840                          union iwreq_data *awrq,
1841                          char *extra)
1842 {
1843         _irqL   irqL;
1844         uint ret = 0;
1845         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1846         struct sockaddr *temp = (struct sockaddr *)awrq;
1847         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
1848         _list   *phead;
1849         u8 *dst_bssid, *src_bssid;
1850         _queue  *queue  = &(pmlmepriv->scanned_queue);
1851         struct  wlan_network    *pnetwork = NULL;
1852         NDIS_802_11_AUTHENTICATION_MODE authmode;
1853
1854         _func_enter_;
1855 /*
1856 #ifdef CONFIG_CONCURRENT_MODE
1857         if(padapter->iface_type > PRIMARY_IFACE)
1858         {
1859                 ret = -EINVAL;
1860                 goto exit;
1861         }
1862 #endif
1863 */
1864
1865 #ifdef CONFIG_CONCURRENT_MODE
1866         if (check_buddy_fwstate(padapter, _FW_UNDER_SURVEY|_FW_UNDER_LINKING) == _TRUE)
1867         {
1868                 DBG_871X("set bssid, but buddy_intf is under scanning or linking\n");
1869
1870                 ret = -EINVAL;
1871
1872                 goto exit;
1873         }
1874 #endif
1875
1876 #ifdef CONFIG_DUALMAC_CONCURRENT
1877         if (dc_check_fwstate(padapter, _FW_UNDER_SURVEY|_FW_UNDER_LINKING)== _TRUE)
1878         {
1879                 DBG_871X("set bssid, but buddy_intf is under scanning or linking\n");
1880                 ret = -EINVAL;
1881                 goto exit;
1882         }
1883 #endif
1884
1885         rtw_ps_deny(padapter, PS_DENY_JOIN);
1886         if(_FAIL == rtw_pwr_wakeup(padapter))
1887         {
1888                 ret= -1;
1889                 goto exit;
1890         }
1891
1892         if(!padapter->bup){
1893                 ret = -1;
1894                 goto exit;
1895         }
1896
1897
1898         if (temp->sa_family != ARPHRD_ETHER){
1899                 ret = -EINVAL;
1900                 goto exit;
1901         }
1902
1903         authmode = padapter->securitypriv.ndisauthtype;
1904         _enter_critical_bh(&queue->lock, &irqL);
1905        phead = get_list_head(queue);
1906        pmlmepriv->pscanned = get_next(phead);
1907
1908         while (1)
1909          {
1910
1911                 if ((rtw_end_of_queue_search(phead, pmlmepriv->pscanned)) == _TRUE)
1912                 {
1913 #if 0
1914                         ret = -EINVAL;
1915                         goto exit;
1916
1917                         if(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE)
1918                         {
1919                                 rtw_set_802_11_bssid(padapter, temp->sa_data);
1920                                 goto exit;
1921                         }
1922                         else
1923                         {
1924                                 ret = -EINVAL;
1925                                 goto exit;
1926                         }
1927 #endif
1928
1929                         break;
1930                 }
1931
1932                 pnetwork = LIST_CONTAINOR(pmlmepriv->pscanned, struct wlan_network, list);
1933
1934                 pmlmepriv->pscanned = get_next(pmlmepriv->pscanned);
1935
1936                 dst_bssid = pnetwork->network.MacAddress;
1937
1938                 src_bssid = temp->sa_data;
1939
1940                 if ((_rtw_memcmp(dst_bssid, src_bssid, ETH_ALEN)) == _TRUE)
1941                 {
1942                         if(!rtw_set_802_11_infrastructure_mode(padapter, pnetwork->network.InfrastructureMode))
1943                         {
1944                                 ret = -1;
1945                                 _exit_critical_bh(&queue->lock, &irqL);
1946                                 goto exit;
1947                         }
1948
1949                                 break;
1950                 }
1951
1952         }
1953         _exit_critical_bh(&queue->lock, &irqL);
1954
1955         rtw_set_802_11_authentication_mode(padapter, authmode);
1956         //set_802_11_encryption_mode(padapter, padapter->securitypriv.ndisencryptstatus);
1957         if (rtw_set_802_11_bssid(padapter, temp->sa_data) == _FALSE) {
1958                 ret = -1;
1959                 goto exit;
1960         }
1961
1962 exit:
1963
1964         rtw_ps_deny_cancel(padapter, PS_DENY_JOIN);
1965
1966         _func_exit_;
1967
1968         return ret;
1969 }
1970
1971 static int rtw_wx_get_wap(struct net_device *dev,
1972                             struct iw_request_info *info,
1973                             union iwreq_data *wrqu, char *extra)
1974 {
1975
1976         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1977         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
1978         WLAN_BSSID_EX  *pcur_bss = &pmlmepriv->cur_network.network;
1979
1980         wrqu->ap_addr.sa_family = ARPHRD_ETHER;
1981
1982         _rtw_memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
1983
1984         RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,("rtw_wx_get_wap\n"));
1985
1986         _func_enter_;
1987
1988         if  ( ((check_fwstate(pmlmepriv, _FW_LINKED)) == _TRUE) ||
1989                         ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) == _TRUE) ||
1990                         ((check_fwstate(pmlmepriv, WIFI_AP_STATE)) == _TRUE) )
1991         {
1992
1993                 _rtw_memcpy(wrqu->ap_addr.sa_data, pcur_bss->MacAddress, ETH_ALEN);
1994         }
1995         else
1996         {
1997                 _rtw_memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
1998         }
1999
2000         _func_exit_;
2001
2002         return 0;
2003
2004 }
2005
2006 static int rtw_wx_set_mlme(struct net_device *dev,
2007                              struct iw_request_info *info,
2008                              union iwreq_data *wrqu, char *extra)
2009 {
2010 #if 0
2011 /* SIOCSIWMLME data */
2012 struct  iw_mlme
2013 {
2014         __u16           cmd; /* IW_MLME_* */
2015         __u16           reason_code;
2016         struct sockaddr addr;
2017 };
2018 #endif
2019
2020         int ret=0;
2021         u16 reason;
2022         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2023         struct iw_mlme *mlme = (struct iw_mlme *) extra;
2024
2025
2026         if(mlme==NULL)
2027                 return -1;
2028
2029         DBG_871X("%s\n", __FUNCTION__);
2030
2031         reason = cpu_to_le16(mlme->reason_code);
2032
2033
2034         DBG_871X("%s, cmd=%d, reason=%d\n", __FUNCTION__, mlme->cmd, reason);
2035
2036
2037         switch (mlme->cmd)
2038         {
2039                 case IW_MLME_DEAUTH:
2040                                 if(!rtw_set_802_11_disassociate(padapter))
2041                                 ret = -1;
2042                                 break;
2043
2044                 case IW_MLME_DISASSOC:
2045                                 if(!rtw_set_802_11_disassociate(padapter))
2046                                                 ret = -1;
2047
2048                                 break;
2049
2050                 default:
2051                         return -EOPNOTSUPP;
2052         }
2053
2054         return ret;
2055 }
2056
2057 static int rtw_wx_set_scan(struct net_device *dev, struct iw_request_info *a,
2058                              union iwreq_data *wrqu, char *extra)
2059 {
2060         u8 _status = _FALSE;
2061         int ret = 0;
2062         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2063         struct mlme_priv *pmlmepriv= &padapter->mlmepriv;
2064         NDIS_802_11_SSID ssid[RTW_SSID_SCAN_AMOUNT];
2065         _irqL   irqL;
2066 #ifdef CONFIG_P2P
2067         struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
2068 #endif //CONFIG_P2P
2069         RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,("rtw_wx_set_scan\n"));
2070
2071 _func_enter_;
2072
2073         #ifdef DBG_IOCTL
2074         DBG_871X("DBG_IOCTL %s:%d\n",__FUNCTION__, __LINE__);
2075         #endif
2076 /*
2077 #ifdef CONFIG_CONCURRENT_MODE
2078         if(padapter->iface_type > PRIMARY_IFACE)
2079         {
2080                 ret = -1;
2081                 goto exit;
2082         }
2083 #endif
2084 */
2085 #ifdef CONFIG_MP_INCLUDED
2086                 if (padapter->registrypriv.mp_mode == 1)
2087                 {
2088                                 DBG_871X(FUNC_ADPT_FMT ": MP mode block Scan request\n", FUNC_ADPT_ARG(padapter));
2089                                 ret = -1;
2090                                 goto exit;
2091                 }
2092 #ifdef CONFIG_CONCURRENT_MODE
2093                         if (padapter->pbuddy_adapter) {
2094                                 if (padapter->pbuddy_adapter->registrypriv.mp_mode == 1)
2095                                 {
2096                                         DBG_871X(FUNC_ADPT_FMT ": MP mode block Scan request\n", FUNC_ADPT_ARG(padapter->pbuddy_adapter));
2097                                         ret = -1;
2098                                         goto exit;
2099                                 }
2100                         }
2101 #endif //CONFIG_CONCURRENT_MODE
2102 #endif
2103
2104         rtw_ps_deny(padapter, PS_DENY_SCAN);
2105         if(_FAIL == rtw_pwr_wakeup(padapter))
2106         {
2107                 ret= -1;
2108                 goto exit;
2109         }
2110
2111         if(padapter->bDriverStopped){
2112            DBG_871X("bDriverStopped=%d\n", padapter->bDriverStopped);
2113                 ret= -1;
2114                 goto exit;
2115         }
2116
2117         if(!padapter->bup){
2118                 ret = -1;
2119                 goto exit;
2120         }
2121
2122         if (padapter->hw_init_completed==_FALSE){
2123                 ret = -1;
2124                 goto exit;
2125         }
2126
2127         // When Busy Traffic, driver do not site survey. So driver return success.
2128         // wpa_supplicant will not issue SIOCSIWSCAN cmd again after scan timeout.
2129         // modify by thomas 2011-02-22.
2130         if (pmlmepriv->LinkDetectInfo.bBusyTraffic == _TRUE
2131 #ifdef CONFIG_CONCURRENT_MODE
2132         || rtw_get_buddy_bBusyTraffic(padapter) == _TRUE
2133 #endif //CONFIG_CONCURRENT_MODE
2134         )
2135         {
2136                 indicate_wx_scan_complete_event(padapter);
2137                 goto exit;
2138         }
2139
2140         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING) == _TRUE)
2141         {
2142                 indicate_wx_scan_complete_event(padapter);
2143                 goto exit;
2144         }
2145
2146 #ifdef CONFIG_CONCURRENT_MODE
2147         if (check_buddy_fwstate(padapter,
2148                 _FW_UNDER_SURVEY|_FW_UNDER_LINKING|WIFI_UNDER_WPS) == _TRUE)
2149         {
2150                 indicate_wx_scan_complete_event(padapter);
2151                 goto exit;
2152         }
2153 #endif
2154
2155 #ifdef CONFIG_DUALMAC_CONCURRENT
2156         if (dc_check_fwstate(padapter, _FW_UNDER_SURVEY|_FW_UNDER_LINKING)== _TRUE)
2157         {
2158                 indicate_wx_scan_complete_event(padapter);
2159                 goto exit;
2160         }
2161 #endif
2162
2163 #ifdef CONFIG_P2P
2164         if ( pwdinfo->p2p_state != P2P_STATE_NONE )
2165         {
2166                 rtw_p2p_set_pre_state( pwdinfo, rtw_p2p_state( pwdinfo ) );
2167                 rtw_p2p_set_state(pwdinfo, P2P_STATE_FIND_PHASE_SEARCH);
2168                 rtw_p2p_findphase_ex_set(pwdinfo, P2P_FINDPHASE_EX_FULL);
2169                 rtw_free_network_queue(padapter, _TRUE);
2170         }
2171 #endif //CONFIG_P2P
2172
2173         _rtw_memset(ssid, 0, sizeof(NDIS_802_11_SSID)*RTW_SSID_SCAN_AMOUNT);
2174
2175 #if WIRELESS_EXT >= 17
2176         if (wrqu->data.length == sizeof(struct iw_scan_req))
2177         {
2178                 struct iw_scan_req *req = (struct iw_scan_req *)extra;
2179
2180                 if (wrqu->data.flags & IW_SCAN_THIS_ESSID)
2181                 {
2182                         int len = min((int)req->essid_len, IW_ESSID_MAX_SIZE);
2183
2184                         _rtw_memcpy(ssid[0].Ssid, req->essid, len);
2185                         ssid[0].SsidLength = len;
2186
2187                         DBG_871X("IW_SCAN_THIS_ESSID, ssid=%s, len=%d\n", req->essid, req->essid_len);
2188
2189                         _enter_critical_bh(&pmlmepriv->lock, &irqL);
2190
2191                         _status = rtw_sitesurvey_cmd(padapter, ssid, 1, NULL, 0);
2192
2193                         _exit_critical_bh(&pmlmepriv->lock, &irqL);
2194
2195                 }
2196                 else if (req->scan_type == IW_SCAN_TYPE_PASSIVE)
2197                 {
2198                         DBG_871X("rtw_wx_set_scan, req->scan_type == IW_SCAN_TYPE_PASSIVE\n");
2199                 }
2200
2201         }
2202         else
2203 #endif
2204
2205         if(     wrqu->data.length >= WEXT_CSCAN_HEADER_SIZE
2206                 && _rtw_memcmp(extra, WEXT_CSCAN_HEADER, WEXT_CSCAN_HEADER_SIZE) == _TRUE
2207         )
2208         {
2209                 int len = wrqu->data.length -WEXT_CSCAN_HEADER_SIZE;
2210                 char *pos = extra+WEXT_CSCAN_HEADER_SIZE;
2211                 char section;
2212                 char sec_len;
2213                 int ssid_index = 0;
2214
2215                 //DBG_871X("%s COMBO_SCAN header is recognized\n", __FUNCTION__);
2216
2217                 while(len >= 1) {
2218                         section = *(pos++); len-=1;
2219
2220                         switch(section) {
2221                                 case WEXT_CSCAN_SSID_SECTION:
2222                                         //DBG_871X("WEXT_CSCAN_SSID_SECTION\n");
2223                                         if(len < 1) {
2224                                                 len = 0;
2225                                                 break;
2226                                         }
2227
2228                                         sec_len = *(pos++); len-=1;
2229
2230                                         if(sec_len>0 && sec_len<=len) {
2231                                                 ssid[ssid_index].SsidLength = sec_len;
2232                                                 _rtw_memcpy(ssid[ssid_index].Ssid, pos, ssid[ssid_index].SsidLength);
2233                                                 //DBG_871X("%s COMBO_SCAN with specific ssid:%s, %d\n", __FUNCTION__
2234                                                 //      , ssid[ssid_index].Ssid, ssid[ssid_index].SsidLength);
2235                                                 ssid_index++;
2236                                         }
2237
2238                                         pos+=sec_len; len-=sec_len;
2239                                         break;
2240
2241
2242                                 case WEXT_CSCAN_CHANNEL_SECTION:
2243                                         //DBG_871X("WEXT_CSCAN_CHANNEL_SECTION\n");
2244                                         pos+=1; len-=1;
2245                                         break;
2246                                 case WEXT_CSCAN_ACTV_DWELL_SECTION:
2247                                         //DBG_871X("WEXT_CSCAN_ACTV_DWELL_SECTION\n");
2248                                         pos+=2; len-=2;
2249                                         break;
2250                                 case WEXT_CSCAN_PASV_DWELL_SECTION:
2251                                         //DBG_871X("WEXT_CSCAN_PASV_DWELL_SECTION\n");
2252                                         pos+=2; len-=2;
2253                                         break;
2254                                 case WEXT_CSCAN_HOME_DWELL_SECTION:
2255                                         //DBG_871X("WEXT_CSCAN_HOME_DWELL_SECTION\n");
2256                                         pos+=2; len-=2;
2257                                         break;
2258                                 case WEXT_CSCAN_TYPE_SECTION:
2259                                         //DBG_871X("WEXT_CSCAN_TYPE_SECTION\n");
2260                                         pos+=1; len-=1;
2261                                         break;
2262                                 #if 0
2263                                 case WEXT_CSCAN_NPROBE_SECTION:
2264                                         DBG_871X("WEXT_CSCAN_NPROBE_SECTION\n");
2265                                         break;
2266                                 #endif
2267
2268                                 default:
2269                                         //DBG_871X("Unknown CSCAN section %c\n", section);
2270                                         len = 0; // stop parsing
2271                         }
2272                         //DBG_871X("len:%d\n", len);
2273
2274                 }
2275
2276                 //jeff: it has still some scan paramater to parse, we only do this now...
2277                 _status = rtw_set_802_11_bssid_list_scan(padapter, ssid, RTW_SSID_SCAN_AMOUNT);
2278
2279         } else
2280
2281         {
2282                 _status = rtw_set_802_11_bssid_list_scan(padapter, NULL, 0);
2283         }
2284
2285         if(_status == _FALSE)
2286                 ret = -1;
2287
2288 exit:
2289
2290         rtw_ps_deny_cancel(padapter, PS_DENY_SCAN);
2291
2292         #ifdef DBG_IOCTL
2293         DBG_871X("DBG_IOCTL %s:%d return %d\n",__FUNCTION__, __LINE__, ret);
2294         #endif
2295
2296 _func_exit_;
2297
2298         return ret;
2299 }
2300
2301 static int rtw_wx_get_scan(struct net_device *dev, struct iw_request_info *a,
2302                              union iwreq_data *wrqu, char *extra)
2303 {
2304         _irqL   irqL;
2305         _list                                   *plist, *phead;
2306         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2307         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
2308         _queue                          *queue  = &(pmlmepriv->scanned_queue);
2309         struct  wlan_network    *pnetwork = NULL;
2310         char *ev = extra;
2311         char *stop = ev + wrqu->data.length;
2312         u32 ret = 0;
2313         u32 cnt=0;
2314         u32 wait_for_surveydone;
2315         sint wait_status;
2316 #ifdef CONFIG_CONCURRENT_MODE
2317         //PADAPTER pbuddy_adapter = padapter->pbuddy_adapter;
2318         //struct mlme_priv *pbuddy_mlmepriv = &(pbuddy_adapter->mlmepriv);
2319 #endif
2320 #ifdef CONFIG_P2P
2321         struct  wifidirect_info*        pwdinfo = &padapter->wdinfo;
2322 #endif //CONFIG_P2P
2323         RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,("rtw_wx_get_scan\n"));
2324         RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_info_, (" Start of Query SIOCGIWSCAN .\n"));
2325
2326         _func_enter_;
2327
2328         #ifdef DBG_IOCTL
2329         DBG_871X("DBG_IOCTL %s:%d\n",__FUNCTION__, __LINE__);
2330         #endif
2331 /*
2332 #ifdef CONFIG_CONCURRENT_MODE
2333         if(padapter->iface_type > PRIMARY_IFACE)
2334         {
2335                 ret = -EINVAL;
2336                 goto exit;
2337         }
2338 #endif
2339 */
2340         if(adapter_to_pwrctl(padapter)->brfoffbyhw && padapter->bDriverStopped)
2341         {
2342                 ret = -EINVAL;
2343                 goto exit;
2344         }
2345
2346 #ifdef CONFIG_P2P
2347         if(!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
2348         {
2349                 //      P2P is enabled
2350                 if ( padapter->chip_type == RTL8192D )
2351                         wait_for_surveydone = 300;      //      Because the 8192du supports more channels.
2352                 else
2353                         wait_for_surveydone = 200;
2354         }
2355         else
2356         {
2357                 //      P2P is disabled
2358                 wait_for_surveydone = 100;
2359         }
2360 #else
2361         {
2362                 wait_for_surveydone = 100;
2363         }
2364 #endif //CONFIG_P2P
2365
2366 #if 1 // Wireless Extension use EAGAIN to try
2367         wait_status = _FW_UNDER_SURVEY
2368 #ifndef CONFIG_ANDROID
2369                 | _FW_UNDER_LINKING
2370 #endif
2371         ;
2372
2373         while (check_fwstate(pmlmepriv, wait_status) == _TRUE)
2374         {
2375                 return -EAGAIN;
2376         }
2377 #else
2378         wait_status = _FW_UNDER_SURVEY
2379                 #ifndef CONFIG_ANDROID
2380                 |_FW_UNDER_LINKING
2381                 #endif
2382         ;
2383
2384 #ifdef CONFIG_DUALMAC_CONCURRENT
2385         while(dc_check_fwstate(padapter, wait_status)== _TRUE)
2386         {
2387                 rtw_msleep_os(30);
2388                 cnt++;
2389                 if(cnt > wait_for_surveydone )
2390                         break;
2391         }
2392 #endif // CONFIG_DUALMAC_CONCURRENT
2393
2394         while(check_fwstate(pmlmepriv, wait_status) == _TRUE)
2395         {
2396                 rtw_msleep_os(30);
2397                 cnt++;
2398                 if(cnt > wait_for_surveydone )
2399                         break;
2400         }
2401 #endif
2402         _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
2403
2404         phead = get_list_head(queue);
2405         plist = get_next(phead);
2406
2407         while(1)
2408         {
2409                 if (rtw_end_of_queue_search(phead,plist)== _TRUE)
2410                         break;
2411
2412                 if((stop - ev) < SCAN_ITEM_SIZE) {
2413                         ret = -E2BIG;
2414                         break;
2415                 }
2416
2417                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
2418
2419                 //report network only if the current channel set contains the channel to which this network belongs
2420                 if(rtw_ch_set_search_ch(padapter->mlmeextpriv.channel_set, pnetwork->network.Configuration.DSConfig) >= 0
2421                         && rtw_mlme_band_check(padapter, pnetwork->network.Configuration.DSConfig) == _TRUE
2422                         && _TRUE == rtw_validate_ssid(&(pnetwork->network.Ssid))
2423                 )
2424                 {
2425                         ev=translate_scan(padapter, a, pnetwork, ev, stop);
2426                 }
2427
2428                 plist = get_next(plist);
2429
2430         }
2431
2432         _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
2433
2434        wrqu->data.length = ev-extra;
2435         wrqu->data.flags = 0;
2436
2437 exit:
2438
2439         _func_exit_;
2440
2441         #ifdef DBG_IOCTL
2442         DBG_871X("DBG_IOCTL %s:%d return %d\n",__FUNCTION__, __LINE__, ret);
2443         #endif
2444
2445         return ret ;
2446
2447 }
2448
2449 //set ssid flow
2450 //s1. rtw_set_802_11_infrastructure_mode()
2451 //s2. set_802_11_authenticaion_mode()
2452 //s3. set_802_11_encryption_mode()
2453 //s4. rtw_set_802_11_ssid()
2454 static int rtw_wx_set_essid(struct net_device *dev,
2455                               struct iw_request_info *a,
2456                               union iwreq_data *wrqu, char *extra)
2457 {
2458         _irqL irqL;
2459         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2460         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2461         _queue *queue = &pmlmepriv->scanned_queue;
2462         _list *phead;
2463         s8 status = _TRUE;
2464         struct wlan_network *pnetwork = NULL;
2465         NDIS_802_11_AUTHENTICATION_MODE authmode;
2466         NDIS_802_11_SSID ndis_ssid;
2467         u8 *dst_ssid, *src_ssid;
2468
2469         uint ret = 0, len;
2470
2471         _func_enter_;
2472
2473         #ifdef DBG_IOCTL
2474         DBG_871X("DBG_IOCTL %s:%d\n",__FUNCTION__, __LINE__);
2475         #endif
2476
2477 /*
2478 #ifdef CONFIG_CONCURRENT_MODE
2479         if(padapter->iface_type > PRIMARY_IFACE)
2480         {
2481                 ret = -EINVAL;
2482                 goto exit;
2483         }
2484 #endif
2485 */
2486
2487 #ifdef CONFIG_CONCURRENT_MODE
2488         if (check_buddy_fwstate(padapter, _FW_UNDER_SURVEY|_FW_UNDER_LINKING) == _TRUE)
2489         {
2490                 DBG_871X("set ssid, but buddy_intf is under scanning or linking\n");
2491
2492                 ret = -EINVAL;
2493
2494                 goto exit;
2495         }
2496 #endif
2497
2498 #ifdef CONFIG_DUALMAC_CONCURRENT
2499         if (dc_check_fwstate(padapter, _FW_UNDER_SURVEY|_FW_UNDER_LINKING)== _TRUE)
2500         {
2501                 DBG_871X("set bssid, but buddy_intf is under scanning or linking\n");
2502                 ret = -EINVAL;
2503                 goto exit;
2504         }
2505 #endif
2506
2507         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
2508                  ("+rtw_wx_set_essid: fw_state=0x%08x\n", get_fwstate(pmlmepriv)));
2509
2510         rtw_ps_deny(padapter, PS_DENY_JOIN);
2511         if(_FAIL == rtw_pwr_wakeup(padapter))
2512         {
2513                 ret = -1;
2514                 goto exit;
2515         }
2516
2517         if(!padapter->bup){
2518                 ret = -1;
2519                 goto exit;
2520         }
2521
2522 #if WIRELESS_EXT <= 20
2523         if ((wrqu->essid.length-1) > IW_ESSID_MAX_SIZE){
2524 #else
2525         if (wrqu->essid.length > IW_ESSID_MAX_SIZE){
2526 #endif
2527                 ret= -E2BIG;
2528                 goto exit;
2529         }
2530
2531         if(check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
2532                 ret = -1;
2533                 goto exit;
2534         }
2535
2536         authmode = padapter->securitypriv.ndisauthtype;
2537         DBG_871X("=>%s\n",__FUNCTION__);
2538         if (wrqu->essid.flags && wrqu->essid.length)
2539         {
2540                 // Commented by Albert 20100519
2541                 // We got the codes in "set_info" function of iwconfig source code.
2542                 //      =========================================
2543                 //      wrq.u.essid.length = strlen(essid) + 1;
2544                 //      if(we_kernel_version > 20)
2545                 //              wrq.u.essid.length--;
2546                 //      =========================================
2547                 //      That means, if the WIRELESS_EXT less than or equal to 20, the correct ssid len should subtract 1.
2548 #if WIRELESS_EXT <= 20
2549                 len = ((wrqu->essid.length-1) < IW_ESSID_MAX_SIZE) ? (wrqu->essid.length-1) : IW_ESSID_MAX_SIZE;
2550 #else
2551                 len = (wrqu->essid.length < IW_ESSID_MAX_SIZE) ? wrqu->essid.length : IW_ESSID_MAX_SIZE;
2552 #endif
2553
2554                 if( wrqu->essid.length != 33 )
2555                         DBG_871X("ssid=%s, len=%d\n", extra, wrqu->essid.length);
2556
2557                 _rtw_memset(&ndis_ssid, 0, sizeof(NDIS_802_11_SSID));
2558                 ndis_ssid.SsidLength = len;
2559                 _rtw_memcpy(ndis_ssid.Ssid, extra, len);
2560                 src_ssid = ndis_ssid.Ssid;
2561
2562                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("rtw_wx_set_essid: ssid=[%s]\n", src_ssid));
2563                 _enter_critical_bh(&queue->lock, &irqL);
2564                phead = get_list_head(queue);
2565               pmlmepriv->pscanned = get_next(phead);
2566
2567                 while (1)
2568                 {
2569                         if (rtw_end_of_queue_search(phead, pmlmepriv->pscanned) == _TRUE)
2570                         {
2571 #if 0
2572                                 if(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE)
2573                                 {
2574                                         rtw_set_802_11_ssid(padapter, &ndis_ssid);
2575
2576                                         goto exit;
2577                                 }
2578                                 else
2579                                 {
2580                                         RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_info_,("rtw_wx_set_ssid(): scanned_queue is empty\n"));
2581                                         ret = -EINVAL;
2582                                         goto exit;
2583                                 }
2584 #endif
2585                                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_warning_,
2586                                          ("rtw_wx_set_essid: scan_q is empty, set ssid to check if scanning again!\n"));
2587
2588                                 break;
2589                         }
2590
2591                         pnetwork = LIST_CONTAINOR(pmlmepriv->pscanned, struct wlan_network, list);
2592
2593                         pmlmepriv->pscanned = get_next(pmlmepriv->pscanned);
2594
2595                         dst_ssid = pnetwork->network.Ssid.Ssid;
2596
2597                         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
2598                                  ("rtw_wx_set_essid: dst_ssid=%s\n",
2599                                   pnetwork->network.Ssid.Ssid));
2600
2601                         if ((_rtw_memcmp(dst_ssid, src_ssid, ndis_ssid.SsidLength) == _TRUE) &&
2602                                 (pnetwork->network.Ssid.SsidLength==ndis_ssid.SsidLength))
2603                         {
2604                                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
2605                                          ("rtw_wx_set_essid: find match, set infra mode\n"));
2606
2607                                 if(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == _TRUE)
2608                                 {
2609                                         if(pnetwork->network.InfrastructureMode != pmlmepriv->cur_network.network.InfrastructureMode)
2610                                                 continue;
2611                                 }
2612
2613                                 if (rtw_set_802_11_infrastructure_mode(padapter, pnetwork->network.InfrastructureMode) == _FALSE)
2614                                 {
2615                                         ret = -1;
2616                                         _exit_critical_bh(&queue->lock, &irqL);
2617                                         goto exit;
2618                                 }
2619
2620                                 break;
2621                         }
2622                 }
2623                 _exit_critical_bh(&queue->lock, &irqL);
2624                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
2625                          ("set ssid: set_802_11_auth. mode=%d\n", authmode));
2626                 rtw_set_802_11_authentication_mode(padapter, authmode);
2627                 //set_802_11_encryption_mode(padapter, padapter->securitypriv.ndisencryptstatus);
2628                 if (rtw_set_802_11_ssid(padapter, &ndis_ssid) == _FALSE) {
2629                         ret = -1;
2630                         goto exit;
2631                 }
2632         }
2633
2634 exit:
2635
2636         rtw_ps_deny_cancel(padapter, PS_DENY_JOIN);
2637
2638         DBG_871X("<=%s, ret %d\n",__FUNCTION__, ret);
2639
2640         #ifdef DBG_IOCTL
2641         DBG_871X("DBG_IOCTL %s:%d return %d\n",__FUNCTION__, __LINE__, ret);
2642         #endif
2643
2644         _func_exit_;
2645
2646         return ret;
2647 }
2648
2649 static int rtw_wx_get_essid(struct net_device *dev,
2650                               struct iw_request_info *a,
2651                               union iwreq_data *wrqu, char *extra)
2652 {
2653         u32 len,ret = 0;
2654         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2655         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
2656         WLAN_BSSID_EX  *pcur_bss = &pmlmepriv->cur_network.network;
2657
2658         RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,("rtw_wx_get_essid\n"));
2659
2660         _func_enter_;
2661
2662         if ( (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) ||
2663               (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE))
2664         {
2665                 len = pcur_bss->Ssid.SsidLength;
2666
2667                 wrqu->essid.length = len;
2668
2669                 _rtw_memcpy(extra, pcur_bss->Ssid.Ssid, len);
2670
2671                 wrqu->essid.flags = 1;
2672         }
2673         else
2674         {
2675                 ret = -1;
2676                 goto exit;
2677         }
2678
2679 exit:
2680
2681         _func_exit_;
2682
2683         return ret;
2684
2685 }
2686
2687 static int rtw_wx_set_rate(struct net_device *dev,
2688                               struct iw_request_info *a,
2689                               union iwreq_data *wrqu, char *extra)
2690 {
2691         int     i, ret = 0;
2692         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2693         u8      datarates[NumRates];
2694         u32     target_rate = wrqu->bitrate.value;
2695         u32     fixed = wrqu->bitrate.fixed;
2696         u32     ratevalue = 0;
2697          u8 mpdatarate[NumRates]={11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0xff};
2698
2699 _func_enter_;
2700
2701         RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,(" rtw_wx_set_rate \n"));
2702         RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_info_,("target_rate = %d, fixed = %d\n",target_rate,fixed));
2703
2704         if(target_rate == -1){
2705                 ratevalue = 11;
2706                 goto set_rate;
2707         }
2708         target_rate = target_rate/100000;
2709
2710         switch(target_rate){
2711                 case 10:
2712                         ratevalue = 0;
2713                         break;
2714                 case 20:
2715                         ratevalue = 1;
2716                         break;
2717                 case 55:
2718                         ratevalue = 2;
2719                         break;
2720                 case 60:
2721                         ratevalue = 3;
2722                         break;
2723                 case 90:
2724                         ratevalue = 4;
2725                         break;
2726                 case 110:
2727                         ratevalue = 5;
2728                         break;
2729                 case 120:
2730                         ratevalue = 6;
2731                         break;
2732                 case 180:
2733                         ratevalue = 7;
2734                         break;
2735                 case 240:
2736                         ratevalue = 8;
2737                         break;
2738                 case 360:
2739                         ratevalue = 9;
2740                         break;
2741                 case 480:
2742                         ratevalue = 10;
2743                         break;
2744                 case 540:
2745                         ratevalue = 11;
2746                         break;
2747                 default:
2748                         ratevalue = 11;
2749                         break;
2750         }
2751
2752 set_rate:
2753
2754         for(i=0; i<NumRates; i++)
2755         {
2756                 if(ratevalue==mpdatarate[i])
2757                 {
2758                         datarates[i] = mpdatarate[i];
2759                         if(fixed == 0)
2760                                 break;
2761                 }
2762                 else{
2763                         datarates[i] = 0xff;
2764                 }
2765
2766                 RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_info_,("datarate_inx=%d\n",datarates[i]));
2767         }
2768
2769         if( rtw_setdatarate_cmd(padapter, datarates) !=_SUCCESS){
2770                 RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_err_,("rtw_wx_set_rate Fail!!!\n"));
2771                 ret = -1;
2772         }
2773
2774 _func_exit_;
2775
2776         return ret;
2777 }
2778
2779 static int rtw_wx_get_rate(struct net_device *dev,
2780                              struct iw_request_info *info,
2781                              union iwreq_data *wrqu, char *extra)
2782 {
2783         u16 max_rate = 0;
2784
2785         max_rate = rtw_get_cur_max_rate((_adapter *)rtw_netdev_priv(dev));
2786
2787         if(max_rate == 0)
2788                 return -EPERM;
2789
2790         wrqu->bitrate.fixed = 0;        /* no auto select */
2791         wrqu->bitrate.value = max_rate * 100000;
2792
2793         return 0;
2794 }
2795
2796 static int rtw_wx_set_rts(struct net_device *dev,
2797                              struct iw_request_info *info,
2798                              union iwreq_data *wrqu, char *extra)
2799 {
2800         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2801
2802         _func_enter_;
2803
2804         if (wrqu->rts.disabled)
2805                 padapter->registrypriv.rts_thresh = 2347;
2806         else {
2807                 if (wrqu->rts.value < 0 ||
2808                     wrqu->rts.value > 2347)
2809                         return -EINVAL;
2810
2811                 padapter->registrypriv.rts_thresh = wrqu->rts.value;
2812         }
2813
2814         DBG_871X("%s, rts_thresh=%d\n", __func__, padapter->registrypriv.rts_thresh);
2815
2816         _func_exit_;
2817
2818         return 0;
2819
2820 }
2821
2822 static int rtw_wx_get_rts(struct net_device *dev,
2823                              struct iw_request_info *info,
2824                              union iwreq_data *wrqu, char *extra)
2825 {
2826         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2827
2828         _func_enter_;
2829
2830         DBG_871X("%s, rts_thresh=%d\n", __func__, padapter->registrypriv.rts_thresh);
2831
2832         wrqu->rts.value = padapter->registrypriv.rts_thresh;
2833         wrqu->rts.fixed = 0;    /* no auto select */
2834         //wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
2835
2836         _func_exit_;
2837
2838         return 0;
2839 }
2840
2841 static int rtw_wx_set_frag(struct net_device *dev,
2842                              struct iw_request_info *info,
2843                              union iwreq_data *wrqu, char *extra)
2844 {
2845         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2846
2847         _func_enter_;
2848
2849         if (wrqu->frag.disabled)
2850                 padapter->xmitpriv.frag_len = MAX_FRAG_THRESHOLD;
2851         else {
2852                 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
2853                     wrqu->frag.value > MAX_FRAG_THRESHOLD)
2854                         return -EINVAL;
2855
2856                 padapter->xmitpriv.frag_len = wrqu->frag.value & ~0x1;
2857         }
2858
2859         DBG_871X("%s, frag_len=%d\n", __func__, padapter->xmitpriv.frag_len);
2860
2861         _func_exit_;
2862
2863         return 0;
2864
2865 }
2866
2867 static int rtw_wx_get_frag(struct net_device *dev,
2868                              struct iw_request_info *info,
2869                              union iwreq_data *wrqu, char *extra)
2870 {
2871         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2872
2873         _func_enter_;
2874
2875         DBG_871X("%s, frag_len=%d\n", __func__, padapter->xmitpriv.frag_len);
2876
2877         wrqu->frag.value = padapter->xmitpriv.frag_len;
2878         wrqu->frag.fixed = 0;   /* no auto select */
2879         //wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FRAG_THRESHOLD);
2880
2881         _func_exit_;
2882
2883         return 0;
2884 }
2885
2886 static int rtw_wx_get_retry(struct net_device *dev,
2887                              struct iw_request_info *info,
2888                              union iwreq_data *wrqu, char *extra)
2889 {
2890         //_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2891
2892
2893         wrqu->retry.value = 7;
2894         wrqu->retry.fixed = 0;  /* no auto select */
2895         wrqu->retry.disabled = 1;
2896
2897         return 0;
2898
2899 }
2900
2901 #if 0
2902 #define IW_ENCODE_INDEX         0x00FF  /* Token index (if needed) */
2903 #define IW_ENCODE_FLAGS         0xFF00  /* Flags defined below */
2904 #define IW_ENCODE_MODE          0xF000  /* Modes defined below */
2905 #define IW_ENCODE_DISABLED      0x8000  /* Encoding disabled */
2906 #define IW_ENCODE_ENABLED       0x0000  /* Encoding enabled */
2907 #define IW_ENCODE_RESTRICTED    0x4000  /* Refuse non-encoded packets */
2908 #define IW_ENCODE_OPEN          0x2000  /* Accept non-encoded packets */
2909 #define IW_ENCODE_NOKEY         0x0800  /* Key is write only, so not present */
2910 #define IW_ENCODE_TEMP          0x0400  /* Temporary key */
2911 /*
2912 iwconfig wlan0 key on -> flags = 0x6001 -> maybe it means auto
2913 iwconfig wlan0 key off -> flags = 0x8800
2914 iwconfig wlan0 key open -> flags = 0x2800
2915 iwconfig wlan0 key open 1234567890 -> flags = 0x2000
2916 iwconfig wlan0 key restricted -> flags = 0x4800
2917 iwconfig wlan0 key open [3] 1234567890 -> flags = 0x2003
2918 iwconfig wlan0 key restricted [2] 1234567890 -> flags = 0x4002
2919 iwconfig wlan0 key open [3] -> flags = 0x2803
2920 iwconfig wlan0 key restricted [2] -> flags = 0x4802
2921 */
2922 #endif
2923
2924 static int rtw_wx_set_enc(struct net_device *dev,
2925                             struct iw_request_info *info,
2926                             union iwreq_data *wrqu, char *keybuf)
2927 {
2928         u32 key, ret = 0;
2929         u32 keyindex_provided;
2930         NDIS_802_11_WEP  wep;
2931         NDIS_802_11_AUTHENTICATION_MODE authmode;
2932
2933         struct iw_point *erq = &(wrqu->encoding);
2934         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2935         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
2936         DBG_871X("+rtw_wx_set_enc, flags=0x%x\n", erq->flags);
2937
2938         _rtw_memset(&wep, 0, sizeof(NDIS_802_11_WEP));
2939
2940         key = erq->flags & IW_ENCODE_INDEX;
2941
2942         _func_enter_;
2943
2944         if (erq->flags & IW_ENCODE_DISABLED)
2945         {
2946                 DBG_871X("EncryptionDisabled\n");
2947                 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
2948                 padapter->securitypriv.dot11PrivacyAlgrthm=_NO_PRIVACY_;
2949                 padapter->securitypriv.dot118021XGrpPrivacy=_NO_PRIVACY_;
2950                 padapter->securitypriv.dot11AuthAlgrthm= dot11AuthAlgrthm_Open; //open system
2951                 authmode = Ndis802_11AuthModeOpen;
2952                 padapter->securitypriv.ndisauthtype=authmode;
2953
2954                 goto exit;
2955         }
2956
2957         if (key) {
2958                 if (key > WEP_KEYS)
2959                         return -EINVAL;
2960                 key--;
2961                 keyindex_provided = 1;
2962         }
2963         else
2964         {
2965                 keyindex_provided = 0;
2966                 key = padapter->securitypriv.dot11PrivacyKeyIndex;
2967                 DBG_871X("rtw_wx_set_enc, key=%d\n", key);
2968         }
2969
2970         //set authentication mode
2971         if(erq->flags & IW_ENCODE_OPEN)
2972         {
2973                 DBG_871X("rtw_wx_set_enc():IW_ENCODE_OPEN\n");
2974                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;//Ndis802_11EncryptionDisabled;
2975
2976 #ifdef CONFIG_PLATFORM_MT53XX
2977                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
2978 #else
2979                 padapter->securitypriv.dot11AuthAlgrthm= dot11AuthAlgrthm_Open;
2980 #endif
2981
2982                 padapter->securitypriv.dot11PrivacyAlgrthm=_NO_PRIVACY_;
2983                 padapter->securitypriv.dot118021XGrpPrivacy=_NO_PRIVACY_;
2984                 authmode = Ndis802_11AuthModeOpen;
2985                 padapter->securitypriv.ndisauthtype=authmode;
2986         }
2987         else if(erq->flags & IW_ENCODE_RESTRICTED)
2988         {
2989                 DBG_871X("rtw_wx_set_enc():IW_ENCODE_RESTRICTED\n");
2990                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
2991
2992 #ifdef CONFIG_PLATFORM_MT53XX
2993                 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
2994 #else
2995                 padapter->securitypriv.dot11AuthAlgrthm= dot11AuthAlgrthm_Shared;
2996 #endif
2997
2998                 padapter->securitypriv.dot11PrivacyAlgrthm=_WEP40_;
2999                 padapter->securitypriv.dot118021XGrpPrivacy=_WEP40_;
3000                 authmode = Ndis802_11AuthModeShared;
3001                 padapter->securitypriv.ndisauthtype=authmode;
3002         }
3003         else
3004         {
3005                 DBG_871X("rtw_wx_set_enc():erq->flags=0x%x\n", erq->flags);
3006
3007                 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;//Ndis802_11EncryptionDisabled;
3008                 padapter->securitypriv.dot11AuthAlgrthm= dot11AuthAlgrthm_Open; //open system
3009                 padapter->securitypriv.dot11PrivacyAlgrthm=_NO_PRIVACY_;
3010                 padapter->securitypriv.dot118021XGrpPrivacy=_NO_PRIVACY_;
3011                 authmode = Ndis802_11AuthModeOpen;
3012                 padapter->securitypriv.ndisauthtype=authmode;
3013         }
3014
3015         wep.KeyIndex = key;
3016         if (erq->length > 0)
3017         {
3018                 wep.KeyLength = erq->length <= 5 ? 5 : 13;
3019
3020                 wep.Length = wep.KeyLength + FIELD_OFFSET(NDIS_802_11_WEP, KeyMaterial);
3021         }
3022         else
3023         {
3024                 wep.KeyLength = 0 ;
3025
3026                 if(keyindex_provided == 1)// set key_id only, no given KeyMaterial(erq->length==0).
3027                 {
3028                         padapter->securitypriv.dot11PrivacyKeyIndex = key;
3029
3030                         DBG_871X("(keyindex_provided == 1), keyid=%d, key_len=%d\n", key, padapter->securitypriv.dot11DefKeylen[key]);
3031
3032                         switch(padapter->securitypriv.dot11DefKeylen[key])
3033                         {
3034                                 case 5:
3035                                         padapter->securitypriv.dot11PrivacyAlgrthm=_WEP40_;
3036                                         break;
3037                                 case 13:
3038                                         padapter->securitypriv.dot11PrivacyAlgrthm=_WEP104_;
3039                                         break;
3040                                 default:
3041                                         padapter->securitypriv.dot11PrivacyAlgrthm=_NO_PRIVACY_;
3042                                         break;
3043                         }
3044
3045                         goto exit;
3046
3047                 }
3048
3049         }
3050
3051         wep.KeyIndex |= 0x80000000;
3052
3053         _rtw_memcpy(wep.KeyMaterial, keybuf, wep.KeyLength);
3054
3055         if (rtw_set_802_11_add_wep(padapter, &wep) == _FALSE) {
3056                 if(rf_on == pwrpriv->rf_pwrstate )
3057                         ret = -EOPNOTSUPP;
3058                 goto exit;
3059         }
3060
3061 exit:
3062
3063         _func_exit_;
3064
3065         return ret;
3066
3067 }
3068
3069 static int rtw_wx_get_enc(struct net_device *dev,
3070                             struct iw_request_info *info,
3071                             union iwreq_data *wrqu, char *keybuf)
3072 {
3073         uint key, ret =0;
3074         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3075         struct iw_point *erq = &(wrqu->encoding);
3076         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
3077
3078         _func_enter_;
3079
3080         if(check_fwstate(pmlmepriv, _FW_LINKED) != _TRUE)
3081         {
3082                  if(check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) != _TRUE)
3083                  {
3084                 erq->length = 0;
3085                 erq->flags |= IW_ENCODE_DISABLED;
3086                 return 0;
3087         }
3088         }
3089
3090
3091         key = erq->flags & IW_ENCODE_INDEX;
3092
3093         if (key) {
3094                 if (key > WEP_KEYS)
3095                         return -EINVAL;
3096                 key--;
3097         } else
3098         {
3099                 key = padapter->securitypriv.dot11PrivacyKeyIndex;
3100         }
3101
3102         erq->flags = key + 1;
3103
3104         //if(padapter->securitypriv.ndisauthtype == Ndis802_11AuthModeOpen)
3105         //{
3106         //      erq->flags |= IW_ENCODE_OPEN;
3107         //}
3108
3109         switch(padapter->securitypriv.ndisencryptstatus)
3110         {
3111                 case Ndis802_11EncryptionNotSupported:
3112                 case Ndis802_11EncryptionDisabled:
3113
3114                 erq->length = 0;
3115                 erq->flags |= IW_ENCODE_DISABLED;
3116
3117                 break;
3118
3119                 case Ndis802_11Encryption1Enabled:
3120
3121                 erq->length = padapter->securitypriv.dot11DefKeylen[key];
3122
3123                 if(erq->length)
3124                 {
3125                         _rtw_memcpy(keybuf, padapter->securitypriv.dot11DefKey[key].skey, padapter->securitypriv.dot11DefKeylen[key]);
3126
3127                 erq->flags |= IW_ENCODE_ENABLED;
3128
3129                         if(padapter->securitypriv.ndisauthtype == Ndis802_11AuthModeOpen)
3130                         {
3131                                 erq->flags |= IW_ENCODE_OPEN;
3132                         }
3133                         else if(padapter->securitypriv.ndisauthtype == Ndis802_11AuthModeShared)
3134                         {
3135                 erq->flags |= IW_ENCODE_RESTRICTED;
3136                         }
3137                 }
3138                 else
3139                 {
3140                         erq->length = 0;
3141                         erq->flags |= IW_ENCODE_DISABLED;
3142                 }
3143
3144                 break;
3145
3146                 case Ndis802_11Encryption2Enabled:
3147                 case Ndis802_11Encryption3Enabled:
3148
3149                 erq->length = 16;
3150                 erq->flags |= (IW_ENCODE_ENABLED | IW_ENCODE_OPEN | IW_ENCODE_NOKEY);
3151
3152                 break;
3153
3154                 default:
3155                 erq->length = 0;
3156                 erq->flags |= IW_ENCODE_DISABLED;
3157
3158                 break;
3159
3160         }
3161
3162         _func_exit_;
3163
3164         return ret;
3165
3166 }
3167
3168 static int rtw_wx_get_power(struct net_device *dev,
3169                              struct iw_request_info *info,
3170                              union iwreq_data *wrqu, char *extra)
3171 {
3172         //_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3173
3174         wrqu->power.value = 0;
3175         wrqu->power.fixed = 0;  /* no auto select */
3176         wrqu->power.disabled = 1;
3177
3178         return 0;
3179
3180 }
3181
3182 static int rtw_wx_set_gen_ie(struct net_device *dev,
3183                              struct iw_request_info *info,
3184                              union iwreq_data *wrqu, char *extra)
3185 {
3186         int ret;
3187         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3188
3189        ret = rtw_set_wpa_ie(padapter, extra, wrqu->data.length);
3190
3191         return ret;
3192 }
3193
3194 static int rtw_wx_set_auth(struct net_device *dev,
3195                              struct iw_request_info *info,
3196                              union iwreq_data *wrqu, char *extra)
3197 {
3198         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3199         struct iw_param *param = (struct iw_param*)&(wrqu->param);
3200         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
3201         struct security_priv *psecuritypriv = &padapter->securitypriv;
3202         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
3203         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
3204         u32 value = param->value;
3205         int ret = 0;
3206
3207         switch (param->flags & IW_AUTH_INDEX) {
3208
3209         case IW_AUTH_WPA_VERSION:
3210 #ifdef CONFIG_WAPI_SUPPORT
3211 #ifndef CONFIG_IOCTL_CFG80211
3212                  padapter->wapiInfo.bWapiEnable = false;
3213                  if(value == IW_AUTH_WAPI_VERSION_1)
3214                  {
3215                         padapter->wapiInfo.bWapiEnable = true;
3216                         psecuritypriv->dot11PrivacyAlgrthm = _SMS4_;
3217                         psecuritypriv->dot118021XGrpPrivacy = _SMS4_;
3218                         psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_WAPI;
3219                         pmlmeinfo->auth_algo = psecuritypriv->dot11AuthAlgrthm;
3220                         padapter->wapiInfo.extra_prefix_len = WAPI_EXT_LEN;
3221                         padapter->wapiInfo.extra_postfix_len = SMS4_MIC_LEN;
3222                 }
3223 #endif
3224 #endif
3225                 break;
3226         case IW_AUTH_CIPHER_PAIRWISE:
3227
3228                 break;
3229         case IW_AUTH_CIPHER_GROUP:
3230
3231                 break;
3232         case IW_AUTH_KEY_MGMT:
3233 #ifdef CONFIG_WAPI_SUPPORT
3234 #ifndef CONFIG_IOCTL_CFG80211
3235                 DBG_871X("rtw_wx_set_auth: IW_AUTH_KEY_MGMT case \n");
3236                 if(value == IW_AUTH_KEY_MGMT_WAPI_PSK)
3237                         padapter->wapiInfo.bWapiPSK = true;
3238                 else
3239                         padapter->wapiInfo.bWapiPSK = false;
3240                 DBG_871X("rtw_wx_set_auth: IW_AUTH_KEY_MGMT bwapipsk %d \n",padapter->wapiInfo.bWapiPSK);
3241 #endif
3242 #endif
3243                 /*
3244                  *  ??? does not use these parameters
3245                  */
3246                 break;
3247
3248         case IW_AUTH_TKIP_COUNTERMEASURES:
3249         {
3250             if ( param->value )
3251             {  // wpa_supplicant is enabling the tkip countermeasure.
3252                padapter->securitypriv.btkip_countermeasure = _TRUE;
3253             }
3254             else
3255             {  // wpa_supplicant is disabling the tkip countermeasure.
3256                padapter->securitypriv.btkip_countermeasure = _FALSE;
3257             }
3258                 break;
3259         }
3260         case IW_AUTH_DROP_UNENCRYPTED:
3261                 {
3262                         /* HACK:
3263                          *
3264                          * wpa_supplicant calls set_wpa_enabled when the driver
3265                          * is loaded and unloaded, regardless of if WPA is being
3266                          * used.  No other calls are made which can be used to
3267                          * determine if encryption will be used or not prior to
3268                          * association being expected.  If encryption is not being
3269                          * used, drop_unencrypted is set to false, else true -- we
3270                          * can use this to determine if the CAP_PRIVACY_ON bit should
3271                          * be set.
3272                          */
3273
3274                         if(padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption1Enabled)
3275                         {
3276                                 break;//it means init value, or using wep, ndisencryptstatus = Ndis802_11Encryption1Enabled,
3277                                                 // then it needn't reset it;
3278                         }
3279
3280                         if(param->value){
3281                                 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
3282                                 padapter->securitypriv.dot11PrivacyAlgrthm=_NO_PRIVACY_;
3283                                 padapter->securitypriv.dot118021XGrpPrivacy=_NO_PRIVACY_;
3284                                 padapter->securitypriv.dot11AuthAlgrthm= dot11AuthAlgrthm_Open; //open system
3285                                 padapter->securitypriv.ndisauthtype=Ndis802_11AuthModeOpen;
3286                         }
3287
3288                         break;
3289                 }
3290
3291         case IW_AUTH_80211_AUTH_ALG:
3292
3293                 #if defined(CONFIG_ANDROID) || 1
3294                 /*
3295                  *  It's the starting point of a link layer connection using wpa_supplicant
3296                 */
3297                 if(check_fwstate(&padapter->mlmepriv, _FW_LINKED)) {
3298                         LeaveAllPowerSaveMode(padapter);
3299                         rtw_disassoc_cmd(padapter, 500, _FALSE);
3300                         DBG_871X("%s...call rtw_indicate_disconnect\n ",__FUNCTION__);
3301                         rtw_indicate_disconnect(padapter);
3302                         rtw_free_assoc_resources(padapter, 1);
3303                 }
3304                 #endif
3305
3306
3307                 ret = wpa_set_auth_algs(dev, (u32)param->value);
3308
3309                 break;
3310
3311         case IW_AUTH_WPA_ENABLED:
3312
3313                 //if(param->value)
3314                 //      padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; //802.1x
3315                 //else
3316                 //      padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;//open system
3317
3318                 //_disassociate(priv);
3319
3320                 break;
3321
3322         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
3323                 //ieee->ieee802_1x = param->value;
3324                 break;
3325
3326         case IW_AUTH_PRIVACY_INVOKED:
3327                 //ieee->privacy_invoked = param->value;
3328                 break;
3329
3330 #ifdef CONFIG_WAPI_SUPPORT
3331 #ifndef CONFIG_IOCTL_CFG80211
3332         case IW_AUTH_WAPI_ENABLED:
3333                 break;
3334 #endif
3335 #endif
3336
3337         default:
3338                 return -EOPNOTSUPP;
3339
3340         }
3341
3342         return ret;
3343
3344 }
3345
3346 static int rtw_wx_set_enc_ext(struct net_device *dev,
3347                              struct iw_request_info *info,
3348                              union iwreq_data *wrqu, char *extra)
3349 {
3350         char *alg_name;
3351         u32 param_len;
3352         struct ieee_param *param = NULL;
3353         struct iw_point *pencoding = &wrqu->encoding;
3354         struct iw_encode_ext *pext = (struct iw_encode_ext *)extra;
3355         int ret=0;
3356
3357         param_len = sizeof(struct ieee_param) + pext->key_len;
3358         param = (struct ieee_param *)rtw_malloc(param_len);
3359         if (param == NULL)
3360                 return -1;
3361
3362         _rtw_memset(param, 0, param_len);
3363
3364         param->cmd = IEEE_CMD_SET_ENCRYPTION;
3365         _rtw_memset(param->sta_addr, 0xff, ETH_ALEN);
3366
3367
3368         switch (pext->alg) {
3369         case IW_ENCODE_ALG_NONE:
3370                 //todo: remove key
3371                 //remove = 1;
3372                 alg_name = "none";
3373                 break;
3374         case IW_ENCODE_ALG_WEP:
3375                 alg_name = "WEP";
3376                 break;
3377         case IW_ENCODE_ALG_TKIP:
3378                 alg_name = "TKIP";
3379                 break;
3380         case IW_ENCODE_ALG_CCMP:
3381                 alg_name = "CCMP";
3382                 break;
3383 #ifdef CONFIG_IEEE80211W
3384         case IW_ENCODE_ALG_AES_CMAC:
3385                 alg_name = "BIP";
3386                 break;
3387 #endif //CONFIG_IEEE80211W
3388 #ifdef CONFIG_WAPI_SUPPORT
3389 #ifndef CONFIG_IOCTL_CFG80211
3390         case IW_ENCODE_ALG_SM4:
3391                 alg_name= "SMS4";
3392                 _rtw_memcpy(param->sta_addr, pext->addr.sa_data, ETH_ALEN);
3393                 DBG_871X("rtw_wx_set_enc_ext: SMS4 case \n");
3394                 break;
3395 #endif
3396 #endif
3397         default:
3398                 ret = -1;
3399                 goto exit;
3400         }
3401
3402         strncpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN);
3403
3404         if (pext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
3405         {
3406                 param->u.crypt.set_tx = 1;
3407         }
3408
3409         /* cliW: WEP does not have group key
3410          * just not checking GROUP key setting
3411          */
3412         if ((pext->alg != IW_ENCODE_ALG_WEP) &&
3413                 ((pext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
3414 #ifdef CONFIG_IEEE80211W
3415                 || (pext->ext_flags & IW_ENCODE_ALG_AES_CMAC)
3416 #endif //CONFIG_IEEE80211W
3417         ))
3418         {
3419                 param->u.crypt.set_tx = 0;
3420         }
3421
3422         param->u.crypt.idx = (pencoding->flags&0x00FF) -1 ;
3423
3424         if (pext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID)
3425         {
3426 #ifdef CONFIG_WAPI_SUPPORT
3427 #ifndef CONFIG_IOCTL_CFG80211
3428                 if(pext->alg == IW_ENCODE_ALG_SM4)
3429                         _rtw_memcpy(param->u.crypt.seq, pext->rx_seq, 16);
3430                 else
3431 #endif //CONFIG_IOCTL_CFG80211
3432 #endif //CONFIG_WAPI_SUPPORT
3433                 _rtw_memcpy(param->u.crypt.seq, pext->rx_seq, 8);
3434         }
3435
3436         if(pext->key_len)
3437         {
3438                 param->u.crypt.key_len = pext->key_len;
3439                 //_rtw_memcpy(param + 1, pext + 1, pext->key_len);
3440                 _rtw_memcpy(param->u.crypt.key, pext + 1, pext->key_len);
3441         }
3442
3443         if (pencoding->flags & IW_ENCODE_DISABLED)
3444         {
3445                 //todo: remove key
3446                 //remove = 1;
3447         }
3448
3449         ret =  wpa_set_encryption(dev, param, param_len);
3450
3451 exit:
3452         if(param)
3453         {
3454                 rtw_mfree((u8*)param, param_len);
3455         }
3456
3457         return ret;
3458 }
3459
3460
3461 static int rtw_wx_get_nick(struct net_device *dev,
3462                              struct iw_request_info *info,
3463                              union iwreq_data *wrqu, char *extra)
3464 {
3465         //_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3466          //struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3467          //struct security_priv *psecuritypriv = &padapter->securitypriv;
3468
3469         if(extra)
3470         {
3471                 wrqu->data.length = 14;
3472                 wrqu->data.flags = 1;
3473                 _rtw_memcpy(extra, "<WIFI@REALTEK>", 14);
3474         }
3475
3476         //rtw_signal_process(pid, SIGUSR1); //for test
3477
3478         //dump debug info here
3479 /*
3480         u32 dot11AuthAlgrthm;           // 802.11 auth, could be open, shared, and 8021x
3481         u32 dot11PrivacyAlgrthm;        // This specify the privacy for shared auth. algorithm.
3482         u32 dot118021XGrpPrivacy;       // This specify the privacy algthm. used for Grp key
3483         u32 ndisauthtype;
3484         u32 ndisencryptstatus;
3485 */
3486
3487         //DBG_871X("auth_alg=0x%x, enc_alg=0x%x, auth_type=0x%x, enc_type=0x%x\n",
3488         //              psecuritypriv->dot11AuthAlgrthm, psecuritypriv->dot11PrivacyAlgrthm,
3489         //              psecuritypriv->ndisauthtype, psecuritypriv->ndisencryptstatus);
3490
3491         //DBG_871X("enc_alg=0x%x\n", psecuritypriv->dot11PrivacyAlgrthm);
3492         //DBG_871X("auth_type=0x%x\n", psecuritypriv->ndisauthtype);
3493         //DBG_871X("enc_type=0x%x\n", psecuritypriv->ndisencryptstatus);
3494
3495 #if 0
3496         DBG_871X("dbg(0x210)=0x%x\n", rtw_read32(padapter, 0x210));
3497         DBG_871X("dbg(0x608)=0x%x\n", rtw_read32(padapter, 0x608));
3498         DBG_871X("dbg(0x280)=0x%x\n", rtw_read32(padapter, 0x280));
3499         DBG_871X("dbg(0x284)=0x%x\n", rtw_read32(padapter, 0x284));
3500         DBG_871X("dbg(0x288)=0x%x\n", rtw_read32(padapter, 0x288));
3501
3502         DBG_871X("dbg(0x664)=0x%x\n", rtw_read32(padapter, 0x664));
3503
3504
3505         DBG_871X("\n");
3506
3507         DBG_871X("dbg(0x430)=0x%x\n", rtw_read32(padapter, 0x430));
3508         DBG_871X("dbg(0x438)=0x%x\n", rtw_read32(padapter, 0x438));
3509
3510         DBG_871X("dbg(0x440)=0x%x\n", rtw_read32(padapter, 0x440));
3511
3512         DBG_871X("dbg(0x458)=0x%x\n", rtw_read32(padapter, 0x458));
3513
3514         DBG_871X("dbg(0x484)=0x%x\n", rtw_read32(padapter, 0x484));
3515         DBG_871X("dbg(0x488)=0x%x\n", rtw_read32(padapter, 0x488));
3516
3517         DBG_871X("dbg(0x444)=0x%x\n", rtw_read32(padapter, 0x444));
3518         DBG_871X("dbg(0x448)=0x%x\n", rtw_read32(padapter, 0x448));
3519         DBG_871X("dbg(0x44c)=0x%x\n", rtw_read32(padapter, 0x44c));
3520         DBG_871X("dbg(0x450)=0x%x\n", rtw_read32(padapter, 0x450));
3521 #endif
3522
3523         return 0;
3524
3525 }
3526
3527 static int rtw_wx_read32(struct net_device *dev,
3528                             struct iw_request_info *info,
3529                             union iwreq_data *wrqu, char *extra)
3530 {
3531         PADAPTER padapter;
3532         struct iw_point *p;
3533         u16 len;
3534         u32 addr;
3535         u32 data32;
3536         u32 bytes;
3537         u8 *ptmp;
3538         int ret;
3539
3540
3541         ret = 0;
3542         padapter = (PADAPTER)rtw_netdev_priv(dev);
3543         p = &wrqu->data;
3544         len = p->length;
3545         if (0 == len)
3546                 return -EINVAL;
3547
3548         ptmp = (u8*)rtw_malloc(len);
3549         if (NULL == ptmp)
3550                 return -ENOMEM;
3551
3552         if (copy_from_user(ptmp, p->pointer, len)) {
3553                 ret = -EFAULT;
3554                 goto exit;
3555         }
3556
3557         bytes = 0;
3558         addr = 0;
3559         sscanf(ptmp, "%d,%x", &bytes, &addr);
3560
3561         switch (bytes) {
3562                 case 1:
3563                         data32 = rtw_read8(padapter, addr);
3564                         sprintf(extra, "0x%02X", data32);
3565                         break;
3566                 case 2:
3567                         data32 = rtw_read16(padapter, addr);
3568                         sprintf(extra, "0x%04X", data32);
3569                         break;
3570                 case 4:
3571                         data32 = rtw_read32(padapter, addr);
3572                         sprintf(extra, "0x%08X", data32);
3573                         break;
3574                 default:
3575                         DBG_871X(KERN_INFO "%s: usage> read [bytes],[address(hex)]\n", __func__);
3576                         ret = -EINVAL;
3577                         goto exit;
3578         }
3579         DBG_871X(KERN_INFO "%s: addr=0x%08X data=%s\n", __func__, addr, extra);
3580
3581 exit:
3582         rtw_mfree(ptmp, len);
3583
3584         return 0;
3585 }
3586
3587 static int rtw_wx_write32(struct net_device *dev,
3588                             struct iw_request_info *info,
3589                             union iwreq_data *wrqu, char *extra)
3590 {
3591         PADAPTER padapter = (PADAPTER)rtw_netdev_priv(dev);
3592
3593         u32 addr;
3594         u32 data32;
3595         u32 bytes;
3596
3597
3598         bytes = 0;
3599         addr = 0;
3600         data32 = 0;
3601         sscanf(extra, "%d,%x,%x", &bytes, &addr, &data32);
3602
3603         switch (bytes) {
3604                 case 1:
3605                         rtw_write8(padapter, addr, (u8)data32);
3606                         DBG_871X(KERN_INFO "%s: addr=0x%08X data=0x%02X\n", __func__, addr, (u8)data32);
3607                         break;
3608                 case 2:
3609                         rtw_write16(padapter, addr, (u16)data32);
3610                         DBG_871X(KERN_INFO "%s: addr=0x%08X data=0x%04X\n", __func__, addr, (u16)data32);
3611                         break;
3612                 case 4:
3613                         rtw_write32(padapter, addr, data32);
3614                         DBG_871X(KERN_INFO "%s: addr=0x%08X data=0x%08X\n", __func__, addr, data32);
3615                         break;
3616                 default:
3617                         DBG_871X(KERN_INFO "%s: usage> write [bytes],[address(hex)],[data(hex)]\n", __func__);
3618                         return -EINVAL;
3619         }
3620
3621         return 0;
3622 }
3623
3624 static int rtw_wx_read_rf(struct net_device *dev,
3625                             struct iw_request_info *info,
3626                             union iwreq_data *wrqu, char *extra)
3627 {
3628         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3629         u32 path, addr, data32;
3630
3631
3632         path = *(u32*)extra;
3633         addr = *((u32*)extra + 1);
3634         data32 = rtw_hal_read_rfreg(padapter, path, addr, 0xFFFFF);
3635 //      DBG_871X("%s: path=%d addr=0x%02x data=0x%05x\n", __func__, path, addr, data32);
3636         /*
3637          * IMPORTANT!!
3638          * Only when wireless private ioctl is at odd order,
3639          * "extra" would be copied to user space.
3640          */
3641         sprintf(extra, "0x%05x", data32);
3642
3643         return 0;
3644 }
3645
3646 static int rtw_wx_write_rf(struct net_device *dev,
3647                             struct iw_request_info *info,
3648                             union iwreq_data *wrqu, char *extra)
3649 {
3650         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3651         u32 path, addr, data32;
3652
3653
3654         path = *(u32*)extra;
3655         addr = *((u32*)extra + 1);
3656         data32 = *((u32*)extra + 2);
3657 //      DBG_871X("%s: path=%d addr=0x%02x data=0x%05x\n", __func__, path, addr, data32);
3658         rtw_hal_write_rfreg(padapter, path, addr, 0xFFFFF, data32);
3659
3660         return 0;
3661 }
3662
3663 static int rtw_wx_priv_null(struct net_device *dev, struct iw_request_info *a,
3664                  union iwreq_data *wrqu, char *b)
3665 {
3666         return -1;
3667 }
3668
3669 static int dummy(struct net_device *dev, struct iw_request_info *a,
3670                  union iwreq_data *wrqu, char *b)
3671 {
3672         //_adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3673         //struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3674
3675         //DBG_871X("cmd_code=%x, fwstate=0x%x\n", a->cmd, get_fwstate(pmlmepriv));
3676
3677         return -1;
3678
3679 }
3680
3681 static int rtw_wx_set_channel_plan(struct net_device *dev,
3682                                struct iw_request_info *info,
3683                                union iwreq_data *wrqu, char *extra)
3684 {
3685         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3686         struct registry_priv *pregistrypriv = &padapter->registrypriv;
3687         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3688         extern int rtw_channel_plan;
3689         u8 channel_plan_req = (u8) (*((int *)wrqu));
3690
3691         #if 0
3692         rtw_channel_plan = (int)wrqu->data.pointer;
3693         pregistrypriv->channel_plan = rtw_channel_plan;
3694         pmlmepriv->ChannelPlan = pregistrypriv->channel_plan;
3695         #endif
3696
3697         if (_SUCCESS == rtw_set_chplan_cmd(padapter, channel_plan_req, 1, 1)) {
3698                 DBG_871X("%s set channel_plan = 0x%02X\n", __func__, pmlmepriv->ChannelPlan);
3699         } else
3700                 return -EPERM;
3701
3702         return 0;
3703 }
3704
3705 static int rtw_wx_set_mtk_wps_probe_ie(struct net_device *dev,
3706                 struct iw_request_info *a,
3707                 union iwreq_data *wrqu, char *b)
3708 {
3709 #ifdef CONFIG_PLATFORM_MT53XX
3710         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3711         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3712
3713         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_notice_,
3714                  ("WLAN IOCTL: cmd_code=%x, fwstate=0x%x\n",
3715                   a->cmd, get_fwstate(pmlmepriv)));
3716 #endif
3717         return 0;
3718 }
3719
3720 static int rtw_wx_get_sensitivity(struct net_device *dev,
3721                                 struct iw_request_info *info,
3722                                 union iwreq_data *wrqu, char *buf)
3723 {
3724 #ifdef CONFIG_PLATFORM_MT53XX
3725         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3726
3727         //      Modified by Albert 20110914
3728         //      This is in dbm format for MTK platform.
3729         wrqu->qual.level = padapter->recvpriv.rssi;
3730         DBG_871X(" level = %u\n",  wrqu->qual.level );
3731 #endif
3732         return 0;
3733 }
3734
3735 static int rtw_wx_set_mtk_wps_ie(struct net_device *dev,
3736                                 struct iw_request_info *info,
3737                                 union iwreq_data *wrqu, char *extra)
3738 {
3739 #ifdef CONFIG_PLATFORM_MT53XX
3740         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3741
3742         return rtw_set_wpa_ie(padapter, wrqu->data.pointer, wrqu->data.length);
3743 #else
3744         return 0;
3745 #endif
3746 }
3747
3748 /*
3749 typedef int (*iw_handler)(struct net_device *dev, struct iw_request_info *info,
3750                           union iwreq_data *wrqu, char *extra);
3751 */
3752 /*
3753  *      For all data larger than 16 octets, we need to use a
3754  *      pointer to memory allocated in user space.
3755  */
3756 static  int rtw_drvext_hdl(struct net_device *dev, struct iw_request_info *info,
3757                                                 union iwreq_data *wrqu, char *extra)
3758 {
3759
3760  #if 0
3761 struct  iw_point
3762 {
3763   void __user   *pointer;       /* Pointer to the data  (in user space) */
3764   __u16         length;         /* number of fields or size in bytes */
3765   __u16         flags;          /* Optional params */
3766 };
3767  #endif
3768
3769 #ifdef CONFIG_DRVEXT_MODULE
3770         u8 res;
3771         struct drvext_handler *phandler;
3772         struct drvext_oidparam *poidparam;
3773         int ret;
3774         u16 len;
3775         u8 *pparmbuf, bset;
3776         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3777         struct iw_point *p = &wrqu->data;
3778
3779         if( (!p->length) || (!p->pointer)){
3780                 ret = -EINVAL;
3781                 goto _rtw_drvext_hdl_exit;
3782         }
3783
3784
3785         bset = (u8)(p->flags&0xFFFF);
3786         len = p->length;
3787         pparmbuf = (u8*)rtw_malloc(len);
3788         if (pparmbuf == NULL){
3789                 ret = -ENOMEM;
3790                 goto _rtw_drvext_hdl_exit;
3791         }
3792
3793         if(bset)//set info
3794         {
3795                 if (copy_from_user(pparmbuf, p->pointer,len)) {
3796                         rtw_mfree(pparmbuf, len);
3797                         ret = -EFAULT;
3798                         goto _rtw_drvext_hdl_exit;
3799                 }
3800         }
3801         else//query info
3802         {
3803
3804         }
3805
3806
3807         //
3808         poidparam = (struct drvext_oidparam *)pparmbuf;
3809
3810         RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_info_,("drvext set oid subcode [%d], len[%d], InformationBufferLength[%d]\r\n",
3811                                                  poidparam->subcode, poidparam->len, len));
3812
3813
3814         //check subcode
3815         if ( poidparam->subcode >= MAX_DRVEXT_HANDLERS)
3816         {
3817                 RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_err_,("no matching drvext handlers\r\n"));
3818                 ret = -EINVAL;
3819                 goto _rtw_drvext_hdl_exit;
3820         }
3821
3822
3823         if ( poidparam->subcode >= MAX_DRVEXT_OID_SUBCODES)
3824         {
3825                 RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_err_,("no matching drvext subcodes\r\n"));
3826                 ret = -EINVAL;
3827                 goto _rtw_drvext_hdl_exit;
3828         }
3829
3830
3831         phandler = drvextoidhandlers + poidparam->subcode;
3832
3833         if (poidparam->len != phandler->parmsize)
3834         {
3835                 RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_err_,("no matching drvext param size %d vs %d\r\n",
3836                                                 poidparam->len , phandler->parmsize));
3837                 ret = -EINVAL;
3838                 goto _rtw_drvext_hdl_exit;
3839         }
3840
3841
3842         res = phandler->handler(&padapter->drvextpriv, bset, poidparam->data);
3843
3844         if(res==0)
3845         {
3846                 ret = 0;
3847
3848                 if (bset == 0x00) {//query info
3849                         //_rtw_memcpy(p->pointer, pparmbuf, len);
3850                         if (copy_to_user(p->pointer, pparmbuf, len))
3851                                 ret = -EFAULT;
3852                 }
3853         }
3854         else
3855                 ret = -EFAULT;
3856
3857
3858 _rtw_drvext_hdl_exit:
3859
3860         return ret;
3861
3862 #endif
3863
3864         return 0;
3865
3866 }
3867
3868 static void rtw_dbg_mode_hdl(_adapter *padapter, u32 id, u8 *pdata, u32 len)
3869 {
3870         pRW_Reg         RegRWStruct;
3871         struct rf_reg_param *prfreg;
3872         u8 path;
3873         u8 offset;
3874         u32 value;
3875
3876         DBG_871X("%s\n", __FUNCTION__);
3877
3878         switch(id)
3879         {
3880                 case GEN_MP_IOCTL_SUBCODE(MP_START):
3881                         DBG_871X("871x_driver is only for normal mode, can't enter mp mode\n");
3882                         break;
3883                 case GEN_MP_IOCTL_SUBCODE(READ_REG):
3884                         RegRWStruct = (pRW_Reg)pdata;
3885                         switch (RegRWStruct->width)
3886                         {
3887                                 case 1:
3888                                         RegRWStruct->value = rtw_read8(padapter, RegRWStruct->offset);
3889                                         break;
3890                                 case 2:
3891                                         RegRWStruct->value = rtw_read16(padapter, RegRWStruct->offset);
3892                                         break;
3893                                 case 4:
3894                                         RegRWStruct->value = rtw_read32(padapter, RegRWStruct->offset);
3895                                         break;
3896                                 default:
3897                                         break;
3898                         }
3899
3900                         break;
3901                 case GEN_MP_IOCTL_SUBCODE(WRITE_REG):
3902                         RegRWStruct = (pRW_Reg)pdata;
3903                         switch (RegRWStruct->width)
3904                         {
3905                                 case 1:
3906                                         rtw_write8(padapter, RegRWStruct->offset, (u8)RegRWStruct->value);
3907                                         break;
3908                                 case 2:
3909                                         rtw_write16(padapter, RegRWStruct->offset, (u16)RegRWStruct->value);
3910                                         break;
3911                                 case 4:
3912                                         rtw_write32(padapter, RegRWStruct->offset, (u32)RegRWStruct->value);
3913                                         break;
3914                                 default:
3915                                 break;
3916                         }
3917
3918                         break;
3919                 case GEN_MP_IOCTL_SUBCODE(READ_RF_REG):
3920
3921                         prfreg = (struct rf_reg_param *)pdata;
3922
3923                         path = (u8)prfreg->path;
3924                         offset = (u8)prfreg->offset;
3925
3926                         value = rtw_hal_read_rfreg(padapter, path, offset, 0xffffffff);
3927
3928                         prfreg->value = value;
3929
3930                         break;
3931                 case GEN_MP_IOCTL_SUBCODE(WRITE_RF_REG):
3932
3933                         prfreg = (struct rf_reg_param *)pdata;
3934
3935                         path = (u8)prfreg->path;
3936                         offset = (u8)prfreg->offset;
3937                         value = prfreg->value;
3938
3939                         rtw_hal_write_rfreg(padapter, path, offset, 0xffffffff, value);
3940
3941                         break;
3942                 case GEN_MP_IOCTL_SUBCODE(TRIGGER_GPIO):
3943                         DBG_871X("==> trigger gpio 0\n");
3944                         rtw_hal_set_hwreg(padapter, HW_VAR_TRIGGER_GPIO_0, 0);
3945                         break;
3946 #ifdef CONFIG_BT_COEXIST
3947                 case GEN_MP_IOCTL_SUBCODE(SET_DM_BT):
3948                         DBG_871X("==> set dm_bt_coexist:%x\n",*(u8 *)pdata);
3949                         rtw_hal_set_hwreg(padapter, HW_VAR_BT_SET_COEXIST, pdata);
3950                         break;
3951                 case GEN_MP_IOCTL_SUBCODE(DEL_BA):
3952                         DBG_871X("==> delete ba:%x\n",*(u8 *)pdata);
3953                         rtw_hal_set_hwreg(padapter, HW_VAR_BT_ISSUE_DELBA, pdata);
3954                         break;
3955 #endif
3956 #ifdef DBG_CONFIG_ERROR_DETECT
3957                 case GEN_MP_IOCTL_SUBCODE(GET_WIFI_STATUS):
3958                         *pdata = rtw_hal_sreset_get_wifi_status(padapter);
3959                         break;
3960 #endif
3961
3962                 default:
3963                         break;
3964         }
3965
3966 }
3967
3968 static int rtw_mp_ioctl_hdl(struct net_device *dev, struct iw_request_info *info,
3969                                                 union iwreq_data *wrqu, char *extra)
3970 {
3971         int ret = 0;
3972         u32 BytesRead, BytesWritten, BytesNeeded;
3973         struct oid_par_priv     oid_par;
3974         struct mp_ioctl_handler *phandler;
3975         struct mp_ioctl_param   *poidparam;
3976         uint status=0;
3977         u16 len;
3978         u8 *pparmbuf = NULL, bset;
3979         PADAPTER padapter = (PADAPTER)rtw_netdev_priv(dev);
3980         struct iw_point *p = &wrqu->data;
3981
3982         //DBG_871X("+rtw_mp_ioctl_hdl\n");
3983
3984         //mutex_lock(&ioctl_mutex);
3985
3986         if ((!p->length) || (!p->pointer)) {
3987                 ret = -EINVAL;
3988                 goto _rtw_mp_ioctl_hdl_exit;
3989         }
3990
3991         pparmbuf = NULL;
3992         bset = (u8)(p->flags & 0xFFFF);
3993         len = p->length;
3994         pparmbuf = (u8*)rtw_malloc(len);
3995         if (pparmbuf == NULL){
3996                 ret = -ENOMEM;
3997                 goto _rtw_mp_ioctl_hdl_exit;
3998         }
3999
4000         if (copy_from_user(pparmbuf, p->pointer, len)) {
4001                 ret = -EFAULT;
4002                 goto _rtw_mp_ioctl_hdl_exit;
4003         }
4004
4005         poidparam = (struct mp_ioctl_param *)pparmbuf;
4006         RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
4007                  ("rtw_mp_ioctl_hdl: subcode [%d], len[%d], buffer_len[%d]\r\n",
4008                   poidparam->subcode, poidparam->len, len));
4009
4010         if (poidparam->subcode >= MAX_MP_IOCTL_SUBCODE) {
4011                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("no matching drvext subcodes\r\n"));
4012                 ret = -EINVAL;
4013                 goto _rtw_mp_ioctl_hdl_exit;
4014         }
4015
4016         //DBG_871X("%s: %d\n", __func__, poidparam->subcode);
4017 #ifdef CONFIG_MP_INCLUDED
4018 if (padapter->registrypriv.mp_mode == 1)
4019 {
4020         phandler = mp_ioctl_hdl + poidparam->subcode;
4021
4022         if ((phandler->paramsize != 0) && (poidparam->len < phandler->paramsize))
4023         {
4024                 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_,
4025                          ("no matching drvext param size %d vs %d\r\n",
4026                           poidparam->len, phandler->paramsize));
4027                 ret = -EINVAL;
4028                 goto _rtw_mp_ioctl_hdl_exit;
4029         }
4030
4031         if (phandler->handler)
4032         {
4033                 oid_par.adapter_context = padapter;
4034                 oid_par.oid = phandler->oid;
4035                 oid_par.information_buf = poidparam->data;
4036                 oid_par.information_buf_len = poidparam->len;
4037                 oid_par.dbg = 0;
4038
4039                 BytesWritten = 0;
4040                 BytesNeeded = 0;
4041
4042                 if (bset) {
4043                         oid_par.bytes_rw = &BytesRead;
4044                         oid_par.bytes_needed = &BytesNeeded;
4045                         oid_par.type_of_oid = SET_OID;
4046                 } else {
4047                         oid_par.bytes_rw = &BytesWritten;
4048                         oid_par.bytes_needed = &BytesNeeded;
4049                         oid_par.type_of_oid = QUERY_OID;
4050                 }
4051
4052                 status = phandler->handler(&oid_par);
4053
4054                 //todo:check status, BytesNeeded, etc.
4055         }
4056         else {
4057                 DBG_871X("rtw_mp_ioctl_hdl(): err!, subcode=%d, oid=%d, handler=%p\n",
4058                         poidparam->subcode, phandler->oid, phandler->handler);
4059                 ret = -EFAULT;
4060                 goto _rtw_mp_ioctl_hdl_exit;
4061         }
4062 }
4063 else
4064 #endif
4065 {
4066         rtw_dbg_mode_hdl(padapter, poidparam->subcode, poidparam->data, poidparam->len);
4067 }
4068
4069         if (bset == 0x00) {//query info
4070                 if (copy_to_user(p->pointer, pparmbuf, len))
4071                         ret = -EFAULT;
4072         }
4073
4074         if (status) {
4075                 ret = -EFAULT;
4076                 goto _rtw_mp_ioctl_hdl_exit;
4077         }
4078
4079 _rtw_mp_ioctl_hdl_exit:
4080
4081         if (pparmbuf)
4082                 rtw_mfree(pparmbuf, len);
4083
4084         //mutex_unlock(&ioctl_mutex);
4085
4086         return ret;
4087 }
4088
4089 static int rtw_get_ap_info(struct net_device *dev,
4090                                struct iw_request_info *info,
4091                                union iwreq_data *wrqu, char *extra)
4092 {
4093         int bssid_match, ret = 0;
4094         u32 cnt=0, wpa_ielen;
4095         _irqL   irqL;
4096         _list   *plist, *phead;
4097         unsigned char *pbuf;
4098         u8 bssid[ETH_ALEN];
4099         char data[32];
4100         struct wlan_network *pnetwork = NULL;
4101         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4102         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4103         _queue *queue = &(pmlmepriv->scanned_queue);
4104         struct iw_point *pdata = &wrqu->data;
4105
4106         DBG_871X("+rtw_get_aplist_info\n");
4107
4108         if((padapter->bDriverStopped) || (pdata==NULL))
4109         {
4110                 ret= -EINVAL;
4111                 goto exit;
4112         }
4113
4114         while((check_fwstate(pmlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING))) == _TRUE)
4115         {
4116                 rtw_msleep_os(30);
4117                 cnt++;
4118                 if(cnt > 100)
4119                         break;
4120         }
4121
4122
4123         //pdata->length = 0;//?
4124         pdata->flags = 0;
4125         if(pdata->length>=32)
4126         {
4127                 if(copy_from_user(data, pdata->pointer, 32))
4128                 {
4129                         ret= -EINVAL;
4130                         goto exit;
4131                 }
4132         }
4133         else
4134         {
4135                 ret= -EINVAL;
4136                 goto exit;
4137         }
4138
4139         _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
4140
4141         phead = get_list_head(queue);
4142         plist = get_next(phead);
4143
4144         while(1)
4145         {
4146                 if (rtw_end_of_queue_search(phead,plist)== _TRUE)
4147                         break;
4148
4149
4150                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
4151
4152                 //if(hwaddr_aton_i(pdata->pointer, bssid))
4153                 if(hwaddr_aton_i(data, bssid))
4154                 {
4155                         DBG_871X("Invalid BSSID '%s'.\n", (u8*)data);
4156                         _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
4157                         return -EINVAL;
4158                 }
4159
4160
4161                 if(_rtw_memcmp(bssid, pnetwork->network.MacAddress, ETH_ALEN) == _TRUE)//BSSID match, then check if supporting wpa/wpa2
4162                 {
4163                         DBG_871X("BSSID:" MAC_FMT "\n", MAC_ARG(bssid));
4164
4165                         pbuf = rtw_get_wpa_ie(&pnetwork->network.IEs[12], &wpa_ielen, pnetwork->network.IELength-12);
4166                         if(pbuf && (wpa_ielen>0))
4167                         {
4168                                 pdata->flags = 1;
4169                                 break;
4170                         }
4171
4172                         pbuf = rtw_get_wpa2_ie(&pnetwork->network.IEs[12], &wpa_ielen, pnetwork->network.IELength-12);
4173                         if(pbuf && (wpa_ielen>0))
4174                         {
4175                                 pdata->flags = 2;
4176                                 break;
4177                         }
4178
4179                 }
4180
4181                 plist = get_next(plist);
4182
4183         }
4184
4185         _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
4186
4187         if(pdata->length>=34)
4188         {
4189                 if(copy_to_user((u8*)pdata->pointer+32, (u8*)&pdata->flags, 1))
4190                 {
4191                         ret= -EINVAL;
4192                         goto exit;
4193                 }
4194         }
4195
4196 exit:
4197
4198         return ret;
4199
4200 }
4201
4202 static int rtw_set_pid(struct net_device *dev,
4203                                struct iw_request_info *info,
4204                                union iwreq_data *wrqu, char *extra)
4205 {
4206
4207         int ret = 0;
4208         _adapter *padapter = rtw_netdev_priv(dev);
4209         int *pdata = (int *)wrqu;
4210         int selector;
4211
4212         if((padapter->bDriverStopped) || (pdata==NULL))
4213         {
4214                 ret= -EINVAL;
4215                 goto exit;
4216         }
4217
4218         selector = *pdata;
4219         if(selector < 3 && selector >=0) {
4220                 padapter->pid[selector] = *(pdata+1);
4221                 #ifdef CONFIG_GLOBAL_UI_PID
4222                 ui_pid[selector] = *(pdata+1);
4223                 #endif
4224                 DBG_871X("%s set pid[%d]=%d\n", __FUNCTION__, selector ,padapter->pid[selector]);
4225         }
4226         else
4227                 DBG_871X("%s selector %d error\n", __FUNCTION__, selector);
4228
4229 exit:
4230
4231         return ret;
4232
4233 }
4234
4235 static int rtw_wps_start(struct net_device *dev,
4236                                struct iw_request_info *info,
4237                                union iwreq_data *wrqu, char *extra)
4238 {
4239
4240         int ret = 0;
4241         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4242         struct iw_point *pdata = &wrqu->data;
4243         u32   u32wps_start = 0;
4244         unsigned int uintRet = 0;
4245
4246         if((_TRUE == padapter->bDriverStopped) ||(_TRUE==padapter->bSurpriseRemoved) || (NULL== pdata))
4247         {
4248                 ret= -EINVAL;
4249                 goto exit;
4250         }
4251
4252         uintRet = copy_from_user( ( void* ) &u32wps_start, pdata->pointer, 4 );
4253         if ( u32wps_start == 0 )
4254         {
4255                 u32wps_start = *extra;
4256         }
4257
4258         DBG_871X( "[%s] wps_start = %d\n", __FUNCTION__, u32wps_start );
4259
4260         if ( u32wps_start == 1 ) // WPS Start
4261         {
4262                 rtw_led_control(padapter, LED_CTL_START_WPS);
4263         }
4264         else if ( u32wps_start == 2 ) // WPS Stop because of wps success
4265         {
4266                 rtw_led_control(padapter, LED_CTL_STOP_WPS);
4267         }
4268         else if ( u32wps_start == 3 ) // WPS Stop because of wps fail
4269         {
4270                 rtw_led_control(padapter, LED_CTL_STOP_WPS_FAIL);
4271         }
4272
4273 #ifdef CONFIG_INTEL_WIDI
4274         process_intel_widi_wps_status(padapter, u32wps_start);
4275 #endif //CONFIG_INTEL_WIDI
4276
4277 exit:
4278
4279         return ret;
4280
4281 }
4282
4283 #ifdef CONFIG_P2P
4284 static int rtw_wext_p2p_enable(struct net_device *dev,
4285                                struct iw_request_info *info,
4286                                union iwreq_data *wrqu, char *extra)
4287 {
4288
4289         int ret = 0;
4290         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4291         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4292         struct iw_point *pdata = &wrqu->data;
4293         struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
4294         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
4295         enum P2P_ROLE init_role = P2P_ROLE_DISABLE;
4296
4297         if(*extra == '0' )
4298                 init_role = P2P_ROLE_DISABLE;
4299         else if(*extra == '1')
4300                 init_role = P2P_ROLE_DEVICE;
4301         else if(*extra == '2')
4302                 init_role = P2P_ROLE_CLIENT;
4303         else if(*extra == '3')
4304                 init_role = P2P_ROLE_GO;
4305
4306         if(_FAIL == rtw_p2p_enable(padapter, init_role))
4307         {
4308                 ret = -EFAULT;
4309                 goto exit;
4310         }
4311
4312         //set channel/bandwidth
4313         if(init_role != P2P_ROLE_DISABLE)
4314         {
4315                 u8 channel, ch_offset;
4316                 u16 bwmode;
4317
4318                 if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_LISTEN))
4319                 {
4320                         //      Stay at the listen state and wait for discovery.
4321                         channel = pwdinfo->listen_channel;
4322                         pwdinfo->operating_channel = pwdinfo->listen_channel;
4323                         ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
4324                         bwmode = CHANNEL_WIDTH_20;
4325                 }
4326 #ifdef CONFIG_CONCURRENT_MODE
4327                 else if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_IDLE))
4328                 {
4329                         _adapter                                *pbuddy_adapter = padapter->pbuddy_adapter;
4330                         //struct wifidirect_info        *pbuddy_wdinfo = &pbuddy_adapter->wdinfo;
4331                         struct mlme_priv                *pbuddy_mlmepriv = &pbuddy_adapter->mlmepriv;
4332                         struct mlme_ext_priv    *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
4333
4334                         _set_timer( &pwdinfo->ap_p2p_switch_timer, pwdinfo->ext_listen_interval );
4335                         if ( check_fwstate( pbuddy_mlmepriv, _FW_LINKED ) )
4336                         {
4337                                 pwdinfo->operating_channel = pbuddy_mlmeext->cur_channel;
4338                                 //      How about the ch_offset and bwmode ??
4339                         }
4340                         else
4341                         {
4342                                 pwdinfo->operating_channel = pwdinfo->listen_channel;
4343                         }
4344
4345                         channel = pbuddy_mlmeext->cur_channel;
4346                         ch_offset = pbuddy_mlmeext->cur_ch_offset;
4347                         bwmode = pbuddy_mlmeext->cur_bwmode;
4348                 }
4349 #endif
4350                 else
4351                 {
4352                         pwdinfo->operating_channel = pmlmeext->cur_channel;
4353
4354                         channel = pwdinfo->operating_channel;
4355                         ch_offset = pmlmeext->cur_ch_offset;
4356                         bwmode = pmlmeext->cur_bwmode;
4357                 }
4358
4359                 set_channel_bwmode(padapter, channel, ch_offset, bwmode);
4360         }
4361
4362 exit:
4363         return ret;
4364
4365 }
4366
4367 static int rtw_p2p_set_go_nego_ssid(struct net_device *dev,
4368                                struct iw_request_info *info,
4369                                union iwreq_data *wrqu, char *extra)
4370 {
4371
4372         int ret = 0;
4373         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4374         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4375         struct iw_point *pdata = &wrqu->data;
4376         struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
4377
4378         DBG_871X( "[%s] ssid = %s, len = %zu\n", __FUNCTION__, extra, strlen( extra ) );
4379         _rtw_memcpy( pwdinfo->nego_ssid, extra, strlen( extra ) );
4380         pwdinfo->nego_ssidlen = strlen( extra );
4381
4382         return ret;
4383
4384 }
4385
4386
4387 static int rtw_p2p_set_intent(struct net_device *dev,
4388                                struct iw_request_info *info,
4389                                union iwreq_data *wrqu, char *extra)
4390 {
4391         int                                                     ret = 0;
4392         _adapter                                                *padapter = (_adapter *)rtw_netdev_priv(dev);
4393         struct wifidirect_info                  *pwdinfo= &(padapter->wdinfo);
4394         u8                                                      intent = pwdinfo->intent;
4395
4396         extra[ wrqu->data.length ] = 0x00;
4397
4398         intent = rtw_atoi( extra );
4399
4400         if ( intent <= 15 )
4401         {
4402                 pwdinfo->intent= intent;
4403         }
4404         else
4405         {
4406                 ret = -1;
4407         }
4408
4409         DBG_871X( "[%s] intent = %d\n", __FUNCTION__, intent);
4410
4411         return ret;
4412
4413 }
4414
4415 static int rtw_p2p_set_listen_ch(struct net_device *dev,
4416                                struct iw_request_info *info,
4417                                union iwreq_data *wrqu, char *extra)
4418 {
4419
4420         int ret = 0;
4421         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4422         struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
4423         u8      listen_ch = pwdinfo->listen_channel;    //      Listen channel number
4424
4425         extra[ wrqu->data.length ] = 0x00;
4426         listen_ch = rtw_atoi( extra );
4427
4428         if ( ( listen_ch == 1 ) || ( listen_ch == 6 ) || ( listen_ch == 11 ) )
4429         {
4430                 pwdinfo->listen_channel = listen_ch;
4431                 set_channel_bwmode(padapter, pwdinfo->listen_channel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20);
4432         }
4433         else
4434         {
4435                 ret = -1;
4436         }
4437
4438         DBG_871X( "[%s] listen_ch = %d\n", __FUNCTION__, pwdinfo->listen_channel );
4439
4440         return ret;
4441
4442 }
4443
4444 static int rtw_p2p_set_op_ch(struct net_device *dev,
4445                                struct iw_request_info *info,
4446                                union iwreq_data *wrqu, char *extra)
4447 {
4448 //      Commented by Albert 20110524
4449 //      This function is used to set the operating channel if the driver will become the group owner
4450
4451         int ret = 0;
4452         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4453         struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
4454         u8      op_ch = pwdinfo->operating_channel;     //      Operating channel number
4455
4456         extra[ wrqu->data.length ] = 0x00;
4457
4458         op_ch = ( u8 ) rtw_atoi( extra );
4459         if ( op_ch > 0 )
4460         {
4461                 pwdinfo->operating_channel = op_ch;
4462         }
4463         else
4464         {
4465                 ret = -1;
4466         }
4467
4468         DBG_871X( "[%s] op_ch = %d\n", __FUNCTION__, pwdinfo->operating_channel );
4469
4470         return ret;
4471
4472 }
4473
4474
4475 static int rtw_p2p_profilefound(struct net_device *dev,
4476                                struct iw_request_info *info,
4477                                union iwreq_data *wrqu, char *extra)
4478 {
4479
4480         int ret = 0;
4481         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4482         struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
4483
4484         //      Comment by Albert 2010/10/13
4485         //      Input data format:
4486         //      Ex:  0
4487         //      Ex:  1XX:XX:XX:XX:XX:XXYYSSID
4488         //      0 => Reflush the profile record list.
4489         //      1 => Add the profile list
4490         //      XX:XX:XX:XX:XX:XX => peer's MAC Address ( ex: 00:E0:4C:00:00:01 )
4491         //      YY => SSID Length
4492         //      SSID => SSID for persistence group
4493
4494         DBG_871X( "[%s] In value = %s, len = %d \n", __FUNCTION__, extra, wrqu->data.length -1);
4495
4496
4497         //      The upper application should pass the SSID to driver by using this rtw_p2p_profilefound function.
4498         if(!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
4499         {
4500                 if ( extra[ 0 ] == '0' )
4501                 {
4502                         //      Remove all the profile information of wifidirect_info structure.
4503                         _rtw_memset( &pwdinfo->profileinfo[ 0 ], 0x00, sizeof( struct profile_info ) * P2P_MAX_PERSISTENT_GROUP_NUM );
4504                         pwdinfo->profileindex = 0;
4505                 }
4506                 else
4507                 {
4508                         if ( pwdinfo->profileindex >= P2P_MAX_PERSISTENT_GROUP_NUM )
4509                 {
4510                                 ret = -1;
4511                 }
4512                 else
4513                 {
4514                                 int jj, kk;
4515
4516                                 //      Add this profile information into pwdinfo->profileinfo
4517                                 //      Ex:  1XX:XX:XX:XX:XX:XXYYSSID
4518                                 for( jj = 0, kk = 1; jj < ETH_ALEN; jj++, kk += 3 )
4519                                 {
4520                                         pwdinfo->profileinfo[ pwdinfo->profileindex ].peermac[ jj ] = key_2char2num(extra[ kk ], extra[ kk+ 1 ]);
4521                                 }
4522
4523                                 //pwdinfo->profileinfo[ pwdinfo->profileindex ].ssidlen = ( extra[18] - '0' ) * 10 + ( extra[ 19 ] - '0' );
4524                                 //_rtw_memcpy( pwdinfo->profileinfo[ pwdinfo->profileindex ].ssid, &extra[ 20 ], pwdinfo->profileinfo[ pwdinfo->profileindex ].ssidlen );
4525                                 pwdinfo->profileindex++;
4526                         }
4527                 }
4528         }
4529
4530         return ret;
4531
4532 }
4533
4534 static int rtw_p2p_setDN(struct net_device *dev,
4535                                struct iw_request_info *info,
4536                                union iwreq_data *wrqu, char *extra)
4537 {
4538
4539         int ret = 0;
4540         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4541         struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
4542
4543
4544         DBG_871X( "[%s] %s %d\n", __FUNCTION__, extra, wrqu->data.length -1  );
4545         _rtw_memset( pwdinfo->device_name, 0x00, WPS_MAX_DEVICE_NAME_LEN );
4546         _rtw_memcpy( pwdinfo->device_name, extra, wrqu->data.length - 1 );
4547         pwdinfo->device_name_len = wrqu->data.length - 1;
4548
4549         return ret;
4550
4551 }
4552
4553
4554 static int rtw_p2p_get_status(struct net_device *dev,
4555                                struct iw_request_info *info,
4556                                union iwreq_data *wrqu, char *extra)
4557 {
4558
4559         int ret = 0;
4560         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4561         struct iw_point *pdata = &wrqu->data;
4562         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
4563 #ifdef CONFIG_CONCURRENT_MODE
4564         _adapter                                *pbuddy_adapter = padapter->pbuddy_adapter;
4565         struct wifidirect_info  *pbuddy_wdinfo = &pbuddy_adapter->wdinfo;
4566         struct mlme_priv                *pbuddy_mlmepriv = &pbuddy_adapter->mlmepriv;
4567         struct mlme_ext_priv    *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
4568 #endif
4569
4570         if ( padapter->bShowGetP2PState )
4571         {
4572                 DBG_871X( "[%s] Role = %d, Status = %d, peer addr = %.2X:%.2X:%.2X:%.2X:%.2X:%.2X\n", __FUNCTION__, rtw_p2p_role(pwdinfo), rtw_p2p_state(pwdinfo),
4573                                 pwdinfo->p2p_peer_interface_addr[ 0 ], pwdinfo->p2p_peer_interface_addr[ 1 ], pwdinfo->p2p_peer_interface_addr[ 2 ],
4574                                 pwdinfo->p2p_peer_interface_addr[ 3 ], pwdinfo->p2p_peer_interface_addr[ 4 ], pwdinfo->p2p_peer_interface_addr[ 5 ]);
4575         }
4576
4577         //      Commented by Albert 2010/10/12
4578         //      Because of the output size limitation, I had removed the "Role" information.
4579         //      About the "Role" information, we will use the new private IOCTL to get the "Role" information.
4580         sprintf( extra, "\n\nStatus=%.2d\n", rtw_p2p_state(pwdinfo) );
4581         wrqu->data.length = strlen( extra );
4582
4583         return ret;
4584
4585 }
4586
4587 //      Commented by Albert 20110520
4588 //      This function will return the config method description
4589 //      This config method description will show us which config method the remote P2P device is intented to use
4590 //      by sending the provisioning discovery request frame.
4591
4592 static int rtw_p2p_get_req_cm(struct net_device *dev,
4593                                struct iw_request_info *info,
4594                                union iwreq_data *wrqu, char *extra)
4595 {
4596
4597         int ret = 0;
4598         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4599         struct iw_point *pdata = &wrqu->data;
4600         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
4601
4602         sprintf( extra, "\n\nCM=%s\n", pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req );
4603         wrqu->data.length = strlen( extra );
4604         return ret;
4605
4606 }
4607
4608
4609 static int rtw_p2p_get_role(struct net_device *dev,
4610                                struct iw_request_info *info,
4611                                union iwreq_data *wrqu, char *extra)
4612 {
4613
4614         int ret = 0;
4615         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4616         struct iw_point *pdata = &wrqu->data;
4617         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
4618
4619
4620         DBG_871X( "[%s] Role = %d, Status = %d, peer addr = %.2X:%.2X:%.2X:%.2X:%.2X:%.2X\n", __FUNCTION__, rtw_p2p_role(pwdinfo), rtw_p2p_state(pwdinfo),
4621                         pwdinfo->p2p_peer_interface_addr[ 0 ], pwdinfo->p2p_peer_interface_addr[ 1 ], pwdinfo->p2p_peer_interface_addr[ 2 ],
4622                         pwdinfo->p2p_peer_interface_addr[ 3 ], pwdinfo->p2p_peer_interface_addr[ 4 ], pwdinfo->p2p_peer_interface_addr[ 5 ]);
4623
4624         sprintf( extra, "\n\nRole=%.2d\n", rtw_p2p_role(pwdinfo) );
4625         wrqu->data.length = strlen( extra );
4626         return ret;
4627
4628 }
4629
4630
4631 static int rtw_p2p_get_peer_ifaddr(struct net_device *dev,
4632                                struct iw_request_info *info,
4633                                union iwreq_data *wrqu, char *extra)
4634 {
4635
4636         int ret = 0;
4637         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4638         struct iw_point *pdata = &wrqu->data;
4639         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
4640
4641
4642         DBG_871X( "[%s] Role = %d, Status = %d, peer addr = %.2X:%.2X:%.2X:%.2X:%.2X:%.2X\n", __FUNCTION__, rtw_p2p_role(pwdinfo), rtw_p2p_state(pwdinfo),
4643                         pwdinfo->p2p_peer_interface_addr[ 0 ], pwdinfo->p2p_peer_interface_addr[ 1 ], pwdinfo->p2p_peer_interface_addr[ 2 ],
4644                         pwdinfo->p2p_peer_interface_addr[ 3 ], pwdinfo->p2p_peer_interface_addr[ 4 ], pwdinfo->p2p_peer_interface_addr[ 5 ]);
4645
4646         sprintf( extra, "\nMAC %.2X:%.2X:%.2X:%.2X:%.2X:%.2X",
4647                         pwdinfo->p2p_peer_interface_addr[ 0 ], pwdinfo->p2p_peer_interface_addr[ 1 ], pwdinfo->p2p_peer_interface_addr[ 2 ],
4648                         pwdinfo->p2p_peer_interface_addr[ 3 ], pwdinfo->p2p_peer_interface_addr[ 4 ], pwdinfo->p2p_peer_interface_addr[ 5 ]);
4649         wrqu->data.length = strlen( extra );
4650         return ret;
4651
4652 }
4653
4654 static int rtw_p2p_get_peer_devaddr(struct net_device *dev,
4655                                struct iw_request_info *info,
4656                                union iwreq_data *wrqu, char *extra)
4657
4658 {
4659
4660         int ret = 0;
4661         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4662         struct iw_point *pdata = &wrqu->data;
4663         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
4664
4665         DBG_871X( "[%s] Role = %d, Status = %d, peer addr = %.2X:%.2X:%.2X:%.2X:%.2X:%.2X\n", __FUNCTION__, rtw_p2p_role(pwdinfo), rtw_p2p_state(pwdinfo),
4666                         pwdinfo->rx_prov_disc_info.peerDevAddr[ 0 ], pwdinfo->rx_prov_disc_info.peerDevAddr[ 1 ],
4667                         pwdinfo->rx_prov_disc_info.peerDevAddr[ 2 ], pwdinfo->rx_prov_disc_info.peerDevAddr[ 3 ],
4668                         pwdinfo->rx_prov_disc_info.peerDevAddr[ 4 ], pwdinfo->rx_prov_disc_info.peerDevAddr[ 5 ]);
4669         sprintf( extra, "\n%.2X%.2X%.2X%.2X%.2X%.2X",
4670                         pwdinfo->rx_prov_disc_info.peerDevAddr[ 0 ], pwdinfo->rx_prov_disc_info.peerDevAddr[ 1 ],
4671                         pwdinfo->rx_prov_disc_info.peerDevAddr[ 2 ], pwdinfo->rx_prov_disc_info.peerDevAddr[ 3 ],
4672                         pwdinfo->rx_prov_disc_info.peerDevAddr[ 4 ], pwdinfo->rx_prov_disc_info.peerDevAddr[ 5 ]);
4673         wrqu->data.length = strlen( extra );
4674         return ret;
4675
4676 }
4677
4678 static int rtw_p2p_get_peer_devaddr_by_invitation(struct net_device *dev,
4679                                struct iw_request_info *info,
4680                                union iwreq_data *wrqu, char *extra)
4681
4682 {
4683
4684         int ret = 0;
4685         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4686         struct iw_point *pdata = &wrqu->data;
4687         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
4688
4689         DBG_871X( "[%s] Role = %d, Status = %d, peer addr = %.2X:%.2X:%.2X:%.2X:%.2X:%.2X\n", __FUNCTION__, rtw_p2p_role(pwdinfo), rtw_p2p_state(pwdinfo),
4690                         pwdinfo->p2p_peer_device_addr[ 0 ], pwdinfo->p2p_peer_device_addr[ 1 ],
4691                         pwdinfo->p2p_peer_device_addr[ 2 ], pwdinfo->p2p_peer_device_addr[ 3 ],
4692                         pwdinfo->p2p_peer_device_addr[ 4 ], pwdinfo->p2p_peer_device_addr[ 5 ]);
4693         sprintf( extra, "\nMAC %.2X:%.2X:%.2X:%.2X:%.2X:%.2X",
4694                         pwdinfo->p2p_peer_device_addr[ 0 ], pwdinfo->p2p_peer_device_addr[ 1 ],
4695                         pwdinfo->p2p_peer_device_addr[ 2 ], pwdinfo->p2p_peer_device_addr[ 3 ],
4696                         pwdinfo->p2p_peer_device_addr[ 4 ], pwdinfo->p2p_peer_device_addr[ 5 ]);
4697         wrqu->data.length = strlen( extra );
4698         return ret;
4699
4700 }
4701
4702 static int rtw_p2p_get_groupid(struct net_device *dev,
4703                                struct iw_request_info *info,
4704                                union iwreq_data *wrqu, char *extra)
4705
4706 {
4707
4708         int ret = 0;
4709         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4710         struct iw_point *pdata = &wrqu->data;
4711         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
4712
4713         sprintf( extra, "\n%.2X:%.2X:%.2X:%.2X:%.2X:%.2X %s",
4714                         pwdinfo->groupid_info.go_device_addr[ 0 ], pwdinfo->groupid_info.go_device_addr[ 1 ],
4715                         pwdinfo->groupid_info.go_device_addr[ 2 ], pwdinfo->groupid_info.go_device_addr[ 3 ],
4716                         pwdinfo->groupid_info.go_device_addr[ 4 ], pwdinfo->groupid_info.go_device_addr[ 5 ],
4717                         pwdinfo->groupid_info.ssid);
4718         wrqu->data.length = strlen( extra );
4719         return ret;
4720
4721 }
4722
4723 static int rtw_p2p_get_op_ch(struct net_device *dev,
4724                                struct iw_request_info *info,
4725                                union iwreq_data *wrqu, char *extra)
4726
4727 {
4728
4729         int ret = 0;
4730         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4731         struct iw_point *pdata = &wrqu->data;
4732         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
4733
4734
4735         DBG_871X( "[%s] Op_ch = %02x\n", __FUNCTION__, pwdinfo->operating_channel);
4736
4737         sprintf( extra, "\n\nOp_ch=%.2d\n", pwdinfo->operating_channel );
4738         wrqu->data.length = strlen( extra );
4739         return ret;
4740
4741 }
4742
4743 static int rtw_p2p_get_wps_configmethod(struct net_device *dev,
4744                                                                                 struct iw_request_info *info,
4745                                                                                 union iwreq_data *wrqu, char *extra, char *subcmd)
4746 {
4747
4748         int ret = 0;
4749         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4750         u8 peerMAC[ETH_ALEN] = { 0x00 };
4751         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
4752         _irqL irqL;
4753         _list * plist,*phead;
4754         _queue *queue = &(pmlmepriv->scanned_queue);
4755         struct wlan_network *pnetwork = NULL;
4756         u8 blnMatch = 0;
4757         u16     attr_content = 0;
4758         uint attr_contentlen = 0;
4759         u8      attr_content_str[P2P_PRIVATE_IOCTL_SET_LEN] = { 0x00 };
4760
4761         //      Commented by Albert 20110727
4762         //      The input data is the MAC address which the application wants to know its WPS config method.
4763         //      After knowing its WPS config method, the application can decide the config method for provisioning discovery.
4764         //      Format: iwpriv wlanx p2p_get_wpsCM 00:E0:4C:00:00:05
4765
4766         DBG_871X("[%s] data = %s\n", __FUNCTION__, subcmd);
4767
4768         macstr2num(peerMAC, subcmd);
4769
4770         _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
4771
4772         phead = get_list_head(queue);
4773         plist = get_next(phead);
4774
4775         while (1)
4776         {
4777                 if (rtw_end_of_queue_search(phead, plist) == _TRUE) break;
4778
4779                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
4780                 if (_rtw_memcmp(pnetwork->network.MacAddress, peerMAC, ETH_ALEN))
4781                 {
4782                         u8 *wpsie;
4783                         uint    wpsie_len = 0;
4784
4785                         //      The mac address is matched.
4786
4787                         if ( (wpsie=rtw_get_wps_ie_from_scan_queue( &pnetwork->network.IEs[0], pnetwork->network.IELength, NULL, &wpsie_len, pnetwork->network.Reserved[0])) )
4788                         {
4789                                 rtw_get_wps_attr_content(wpsie, wpsie_len, WPS_ATTR_CONF_METHOD, (u8 *)&attr_content, &attr_contentlen);
4790                                 if (attr_contentlen)
4791                                 {
4792                                         attr_content = be16_to_cpu(attr_content);
4793                                         sprintf(attr_content_str, "\n\nM=%.4d", attr_content);
4794                                         blnMatch = 1;
4795                                 }
4796                         }
4797
4798                         break;
4799                 }
4800
4801                 plist = get_next(plist);
4802
4803         }
4804
4805         _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
4806
4807         if (!blnMatch)
4808         {
4809                 sprintf(attr_content_str, "\n\nM=0000");
4810         }
4811
4812         wrqu->data.length = strlen(attr_content_str);
4813         _rtw_memcpy(extra, attr_content_str, wrqu->data.length);
4814
4815         return ret;
4816
4817 }
4818
4819 #ifdef CONFIG_WFD
4820 static int rtw_p2p_get_peer_wfd_port(struct net_device *dev,
4821                                struct iw_request_info *info,
4822                                union iwreq_data *wrqu, char *extra)
4823 {
4824
4825         int ret = 0;
4826         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4827         struct iw_point *pdata = &wrqu->data;
4828         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
4829
4830         DBG_871X( "[%s] p2p_state = %d\n", __FUNCTION__, rtw_p2p_state(pwdinfo) );
4831
4832         sprintf( extra, "\n\nPort=%d\n", pwdinfo->wfd_info->peer_rtsp_ctrlport );
4833         DBG_871X( "[%s] remote port = %d\n", __FUNCTION__, pwdinfo->wfd_info->peer_rtsp_ctrlport );
4834
4835         wrqu->data.length = strlen( extra );
4836         return ret;
4837
4838 }
4839
4840 static int rtw_p2p_get_peer_wfd_preferred_connection(struct net_device *dev,
4841                                struct iw_request_info *info,
4842                                union iwreq_data *wrqu, char *extra)
4843 {
4844
4845         int ret = 0;
4846         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4847         struct iw_point *pdata = &wrqu->data;
4848         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
4849
4850         sprintf( extra, "\n\nwfd_pc=%d\n", pwdinfo->wfd_info->wfd_pc );
4851         DBG_871X( "[%s] wfd_pc = %d\n", __FUNCTION__, pwdinfo->wfd_info->wfd_pc );
4852
4853         wrqu->data.length = strlen( extra );
4854         pwdinfo->wfd_info->wfd_pc = _FALSE;     //      Reset the WFD preferred connection to P2P
4855         return ret;
4856
4857 }
4858
4859 static int rtw_p2p_get_peer_wfd_session_available(struct net_device *dev,
4860                                struct iw_request_info *info,
4861                                union iwreq_data *wrqu, char *extra)
4862 {
4863
4864         int ret = 0;
4865         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4866         struct iw_point *pdata = &wrqu->data;
4867         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
4868
4869         sprintf( extra, "\n\nwfd_sa=%d\n", pwdinfo->wfd_info->peer_session_avail );
4870         DBG_871X( "[%s] wfd_sa = %d\n", __FUNCTION__, pwdinfo->wfd_info->peer_session_avail );
4871
4872         wrqu->data.length = strlen( extra );
4873         pwdinfo->wfd_info->peer_session_avail = _TRUE;  //      Reset the WFD session available
4874         return ret;
4875
4876 }
4877
4878 #endif // CONFIG_WFD
4879
4880 static int rtw_p2p_get_go_device_address(struct net_device *dev,
4881                                                                                  struct iw_request_info *info,
4882                                                                                  union iwreq_data *wrqu, char *extra, char *subcmd)
4883 {
4884
4885         int ret = 0;
4886         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4887         u8 peerMAC[ETH_ALEN] = { 0x00 };
4888         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
4889         _irqL irqL;
4890         _list *plist, *phead;
4891         _queue *queue   = &(pmlmepriv->scanned_queue);
4892         struct wlan_network *pnetwork = NULL;
4893         u8 blnMatch = 0;
4894         u8 *p2pie;
4895         uint p2pielen = 0, attr_contentlen = 0;
4896         u8 attr_content[100] = { 0x00 };
4897         u8 go_devadd_str[P2P_PRIVATE_IOCTL_SET_LEN] = { 0x00 };
4898
4899         //      Commented by Albert 20121209
4900         //      The input data is the GO's interface address which the application wants to know its device address.
4901         //      Format: iwpriv wlanx p2p_get2 go_devadd=00:E0:4C:00:00:05
4902
4903         DBG_871X("[%s] data = %s\n", __FUNCTION__, subcmd);
4904
4905         macstr2num(peerMAC, subcmd);
4906
4907         _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
4908
4909         phead = get_list_head(queue);
4910         plist = get_next(phead);
4911
4912         while (1)
4913         {
4914                 if (rtw_end_of_queue_search(phead, plist) == _TRUE) break;
4915
4916                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
4917                 if (_rtw_memcmp(pnetwork->network.MacAddress, peerMAC, ETH_ALEN))
4918                 {
4919                         //      Commented by Albert 2011/05/18
4920                         //      Match the device address located in the P2P IE
4921                         //      This is for the case that the P2P device address is not the same as the P2P interface address.
4922
4923                         if ((p2pie = rtw_get_p2p_ie_from_scan_queue( &pnetwork->network.IEs[0], pnetwork->network.IELength, NULL, &p2pielen, pnetwork->network.Reserved[0])))
4924                         {
4925                                 while (p2pie)
4926                                 {
4927                                         //      The P2P Device ID attribute is included in the Beacon frame.
4928                                         //      The P2P Device Info attribute is included in the probe response frame.
4929
4930                                         _rtw_memset(attr_content, 0x00, 100);
4931                                         if (rtw_get_p2p_attr_content(p2pie, p2pielen, P2P_ATTR_DEVICE_ID, attr_content, &attr_contentlen))
4932                                         {
4933                                                 //      Handle the P2P Device ID attribute of Beacon first
4934                                                 blnMatch = 1;
4935                                                 break;
4936
4937                                         } else if (rtw_get_p2p_attr_content(p2pie, p2pielen, P2P_ATTR_DEVICE_INFO, attr_content, &attr_contentlen))
4938                                         {
4939                                                 //      Handle the P2P Device Info attribute of probe response
4940                                                 blnMatch = 1;
4941                                                 break;
4942                                         }
4943
4944                                         //Get the next P2P IE
4945                                         p2pie = rtw_get_p2p_ie(p2pie + p2pielen, pnetwork->network.IELength - 12 - (p2pie - &pnetwork->network.IEs[12] + p2pielen), NULL, &p2pielen);
4946                                 }
4947                         }
4948                 }
4949
4950                 plist = get_next(plist);
4951
4952         }
4953
4954         _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
4955
4956         if (!blnMatch)
4957         {
4958                 sprintf(go_devadd_str, "\n\ndev_add=NULL");
4959         } else
4960         {
4961                 sprintf(go_devadd_str, "\n\ndev_add=%.2X:%.2X:%.2X:%.2X:%.2X:%.2X",
4962                                 attr_content[0], attr_content[1], attr_content[2], attr_content[3], attr_content[4], attr_content[5]);
4963         }
4964
4965         wrqu->data.length = strlen(go_devadd_str);
4966         _rtw_memcpy(extra, go_devadd_str, wrqu->data.length);
4967
4968         return ret;
4969
4970 }
4971
4972 static int rtw_p2p_get_device_type(struct net_device *dev,
4973                                                                    struct iw_request_info *info,
4974                                                                    union iwreq_data *wrqu, char *extra, char *subcmd)
4975 {
4976
4977         int ret = 0;
4978         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4979         u8 peerMAC[ETH_ALEN] = { 0x00 };
4980         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
4981         _irqL irqL;
4982         _list *plist, *phead;
4983         _queue *queue = &(pmlmepriv->scanned_queue);
4984         struct wlan_network *pnetwork = NULL;
4985         u8 blnMatch = 0;
4986         u8 dev_type[8] = { 0x00 };
4987         uint dev_type_len = 0;
4988         u8 dev_type_str[P2P_PRIVATE_IOCTL_SET_LEN] = { 0x00 };    // +9 is for the str "dev_type=", we have to clear it at wrqu->data.pointer
4989
4990         //      Commented by Albert 20121209
4991         //      The input data is the MAC address which the application wants to know its device type.
4992         //      Such user interface could know the device type.
4993         //      Format: iwpriv wlanx p2p_get2 dev_type=00:E0:4C:00:00:05
4994
4995         DBG_871X("[%s] data = %s\n", __FUNCTION__, subcmd);
4996
4997         macstr2num(peerMAC, subcmd);
4998
4999         _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
5000
5001         phead = get_list_head(queue);
5002         plist = get_next(phead);
5003
5004         while (1)
5005         {
5006                 if (rtw_end_of_queue_search(phead, plist) == _TRUE) break;
5007
5008                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
5009                 if (_rtw_memcmp(pnetwork->network.MacAddress, peerMAC, ETH_ALEN))
5010                 {
5011                         u8 *wpsie;
5012                         uint    wpsie_len = 0;
5013
5014                         //      The mac address is matched.
5015
5016                         if ( (wpsie=rtw_get_wps_ie_from_scan_queue( &pnetwork->network.IEs[0], pnetwork->network.IELength, NULL, &wpsie_len, pnetwork->network.Reserved[0])) )
5017                         {
5018                                 rtw_get_wps_attr_content(wpsie, wpsie_len, WPS_ATTR_PRIMARY_DEV_TYPE, dev_type, &dev_type_len);
5019                                 if (dev_type_len)
5020                                 {
5021                                         u16     type = 0;
5022
5023                                         _rtw_memcpy(&type, dev_type, 2);
5024                                         type = be16_to_cpu(type);
5025                                         sprintf(dev_type_str, "\n\nN=%.2d", type);
5026                                         blnMatch = 1;
5027                                 }
5028                         }
5029                         break;
5030                 }
5031
5032                 plist = get_next(plist);
5033
5034         }
5035
5036         _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
5037
5038         if (!blnMatch)
5039         {
5040                 sprintf(dev_type_str, "\n\nN=00");
5041         }
5042
5043         wrqu->data.length = strlen(dev_type_str);
5044         _rtw_memcpy(extra, dev_type_str, wrqu->data.length);
5045
5046         return ret;
5047
5048 }
5049
5050 static int rtw_p2p_get_device_name(struct net_device *dev,
5051                                                                    struct iw_request_info *info,
5052                                                                    union iwreq_data *wrqu, char *extra, char *subcmd)
5053 {
5054
5055         int ret = 0;
5056         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5057         u8 peerMAC[ETH_ALEN] = { 0x00 };
5058         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
5059         _irqL irqL;
5060         _list *plist, *phead;
5061         _queue *queue = &(pmlmepriv->scanned_queue);
5062         struct wlan_network *pnetwork = NULL;
5063         u8 blnMatch = 0;
5064         u8 dev_name[WPS_MAX_DEVICE_NAME_LEN] = { 0x00 };
5065         uint dev_len = 0;
5066         u8 dev_name_str[P2P_PRIVATE_IOCTL_SET_LEN] = { 0x00 };
5067
5068         //      Commented by Albert 20121225
5069         //      The input data is the MAC address which the application wants to know its device name.
5070         //      Such user interface could show peer device's device name instead of ssid.
5071         //      Format: iwpriv wlanx p2p_get2 devN=00:E0:4C:00:00:05
5072
5073         DBG_871X("[%s] data = %s\n", __FUNCTION__, subcmd);
5074
5075         macstr2num(peerMAC, subcmd);
5076
5077         _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
5078
5079         phead = get_list_head(queue);
5080         plist = get_next(phead);
5081
5082         while (1)
5083         {
5084                 if (rtw_end_of_queue_search(phead, plist) == _TRUE) break;
5085
5086                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
5087                 if (_rtw_memcmp(pnetwork->network.MacAddress, peerMAC, ETH_ALEN))
5088                 {
5089                         u8 *wpsie;
5090                         uint    wpsie_len = 0;
5091
5092                         //      The mac address is matched.
5093
5094                         if ( (wpsie=rtw_get_wps_ie_from_scan_queue( &pnetwork->network.IEs[0], pnetwork->network.IELength, NULL, &wpsie_len, pnetwork->network.Reserved[0])) )
5095                         {
5096                                 rtw_get_wps_attr_content(wpsie, wpsie_len, WPS_ATTR_DEVICE_NAME, dev_name, &dev_len);
5097                                 if (dev_len)
5098                                 {
5099                                         sprintf(dev_name_str, "\n\nN=%s", dev_name);
5100                                         blnMatch = 1;
5101                                 }
5102                         }
5103                         break;
5104                 }
5105
5106                 plist = get_next(plist);
5107
5108         }
5109
5110         _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
5111
5112         if (!blnMatch)
5113         {
5114                 sprintf(dev_name_str, "\n\nN=0000");
5115         }
5116
5117         wrqu->data.length = strlen(dev_name_str);
5118         _rtw_memcpy(extra, dev_name_str, wrqu->data.length);
5119
5120         return ret;
5121
5122 }
5123
5124 static int rtw_p2p_get_invitation_procedure(struct net_device *dev,
5125                                                                                         struct iw_request_info *info,
5126                                                                                         union iwreq_data *wrqu, char *extra, char *subcmd)
5127 {
5128
5129         int ret = 0;
5130         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5131         u8 peerMAC[ETH_ALEN] = { 0x00 };
5132         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
5133         _irqL irqL;
5134         _list *plist, *phead;
5135         _queue *queue   = &(pmlmepriv->scanned_queue);
5136         struct wlan_network *pnetwork = NULL;
5137         u8 blnMatch = 0;
5138         u8 *p2pie;
5139         uint p2pielen = 0, attr_contentlen = 0;
5140         u8 attr_content[2] = { 0x00 };
5141         u8 inv_proc_str[P2P_PRIVATE_IOCTL_SET_LEN] = { 0x00 };
5142
5143         //      Commented by Ouden 20121226
5144         //      The application wants to know P2P initation procedure is support or not.
5145         //      Format: iwpriv wlanx p2p_get2 InvProc=00:E0:4C:00:00:05
5146
5147         DBG_871X("[%s] data = %s\n", __FUNCTION__, subcmd);
5148
5149         macstr2num(peerMAC, subcmd);
5150
5151         _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
5152
5153         phead = get_list_head(queue);
5154         plist = get_next(phead);
5155
5156         while (1)
5157         {
5158                 if (rtw_end_of_queue_search(phead, plist) == _TRUE) break;
5159
5160                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
5161                 if (_rtw_memcmp(pnetwork->network.MacAddress, peerMAC, ETH_ALEN))
5162                 {
5163                         //      Commented by Albert 20121226
5164                         //      Match the device address located in the P2P IE
5165                         //      This is for the case that the P2P device address is not the same as the P2P interface address.
5166
5167                         if ((p2pie = rtw_get_p2p_ie_from_scan_queue( &pnetwork->network.IEs[0], pnetwork->network.IELength, NULL, &p2pielen, pnetwork->network.Reserved[0])))
5168                         {
5169                                 while (p2pie)
5170                                 {
5171                                         //_rtw_memset( attr_content, 0x00, 2);
5172                                         if (rtw_get_p2p_attr_content(p2pie, p2pielen, P2P_ATTR_CAPABILITY, attr_content, &attr_contentlen))
5173                                         {
5174                                                 //      Handle the P2P capability attribute
5175                                                 blnMatch = 1;
5176                                                 break;
5177
5178                                         }
5179
5180                                         //Get the next P2P IE
5181                                         p2pie = rtw_get_p2p_ie(p2pie + p2pielen, pnetwork->network.IELength - 12 - (p2pie - &pnetwork->network.IEs[12] + p2pielen), NULL, &p2pielen);
5182                                 }
5183                         }
5184                 }
5185
5186                 plist = get_next(plist);
5187
5188         }
5189
5190         _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
5191
5192         if (!blnMatch)
5193         {
5194                 sprintf(inv_proc_str, "\nIP=-1");
5195         } else
5196         {
5197                 if (attr_content[0] && 0x20)
5198                 {
5199                         sprintf(inv_proc_str, "\nIP=1");
5200                 } else
5201                 {
5202                         sprintf(inv_proc_str, "\nIP=0");
5203                 }
5204         }
5205
5206         wrqu->data.length = strlen(inv_proc_str);
5207         _rtw_memcpy(extra, inv_proc_str, wrqu->data.length);
5208
5209         return ret;
5210
5211 }
5212
5213 static int rtw_p2p_connect(struct net_device *dev,
5214                                struct iw_request_info *info,
5215                                union iwreq_data *wrqu, char *extra)
5216 {
5217
5218         int ret = 0;
5219         _adapter                                *padapter = (_adapter *)rtw_netdev_priv(dev);
5220         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
5221         u8                                      peerMAC[ ETH_ALEN ] = { 0x00 };
5222         int                                     jj,kk;
5223         u8                                      peerMACStr[ ETH_ALEN * 2 ] = { 0x00 };
5224         struct mlme_priv                *pmlmepriv = &padapter->mlmepriv;
5225         _irqL                           irqL;
5226         _list                                   *plist, *phead;
5227         _queue                          *queue  = &(pmlmepriv->scanned_queue);
5228         struct  wlan_network    *pnetwork = NULL;
5229         uint                                    uintPeerChannel = 0;
5230 #ifdef CONFIG_CONCURRENT_MODE
5231         _adapter                                *pbuddy_adapter = padapter->pbuddy_adapter;
5232         struct mlme_priv                *pbuddy_mlmepriv = &pbuddy_adapter->mlmepriv;
5233         struct mlme_ext_priv    *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
5234 #endif // CONFIG_CONCURRENT_MODE
5235
5236         //      Commented by Albert 20110304
5237         //      The input data contains two informations.
5238         //      1. First information is the MAC address which wants to formate with
5239         //      2. Second information is the WPS PINCode or "pbc" string for push button method
5240         //      Format: 00:E0:4C:00:00:05
5241         //      Format: 00:E0:4C:00:00:05
5242
5243         DBG_871X( "[%s] data = %s\n", __FUNCTION__, extra );
5244
5245         if ( pwdinfo->p2p_state == P2P_STATE_NONE )
5246         {
5247                 DBG_871X( "[%s] WiFi Direct is disable!\n", __FUNCTION__ );
5248                 return ret;
5249         }
5250
5251 #ifdef CONFIG_INTEL_WIDI
5252         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == _TRUE) {
5253                 DBG_871X( "[%s] WiFi is under survey!\n", __FUNCTION__ );
5254                 return ret;
5255         }
5256 #endif //CONFIG_INTEL_WIDI
5257
5258         if ( pwdinfo->ui_got_wps_info == P2P_NO_WPSINFO )
5259         {
5260                 return -1;
5261         }
5262
5263         for( jj = 0, kk = 0; jj < ETH_ALEN; jj++, kk += 3 )
5264         {
5265                 peerMAC[ jj ] = key_2char2num( extra[kk], extra[kk+ 1] );
5266         }
5267
5268         _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
5269
5270         phead = get_list_head(queue);
5271         plist = get_next(phead);
5272
5273         while(1)
5274         {
5275                 if (rtw_end_of_queue_search(phead,plist)== _TRUE)
5276                         break;
5277
5278                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
5279                 if ( _rtw_memcmp( pnetwork->network.MacAddress, peerMAC, ETH_ALEN ) )
5280                 {
5281                         uintPeerChannel = pnetwork->network.Configuration.DSConfig;
5282                         break;
5283                 }
5284
5285                 plist = get_next(plist);
5286
5287         }
5288
5289         _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
5290
5291         if ( uintPeerChannel )
5292         {
5293 #ifdef CONFIG_CONCURRENT_MODE
5294                 if ( check_fwstate( pbuddy_mlmepriv, _FW_LINKED ) )
5295                 {
5296                         _cancel_timer_ex( &pwdinfo->ap_p2p_switch_timer );
5297                 }
5298 #endif // CONFIG_CONCURRENT_MODE
5299
5300                 _rtw_memset( &pwdinfo->nego_req_info, 0x00, sizeof( struct tx_nego_req_info ) );
5301                 _rtw_memset( &pwdinfo->groupid_info, 0x00, sizeof( struct group_id_info ) );
5302
5303                 pwdinfo->nego_req_info.peer_channel_num[ 0 ] = uintPeerChannel;
5304                 _rtw_memcpy( pwdinfo->nego_req_info.peerDevAddr, pnetwork->network.MacAddress, ETH_ALEN );
5305                 pwdinfo->nego_req_info.benable = _TRUE;
5306
5307                 _cancel_timer_ex( &pwdinfo->restore_p2p_state_timer );
5308                 if ( rtw_p2p_state(pwdinfo) != P2P_STATE_GONEGO_OK )
5309                 {
5310                         //      Restore to the listen state if the current p2p state is not nego OK
5311                         rtw_p2p_set_state(pwdinfo, P2P_STATE_LISTEN );
5312                 }
5313
5314                 rtw_p2p_set_pre_state(pwdinfo, rtw_p2p_state(pwdinfo));
5315                 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_ING);
5316
5317 #ifdef CONFIG_CONCURRENT_MODE
5318                 if ( check_fwstate( pbuddy_mlmepriv, _FW_LINKED ) )
5319                 {
5320                         //      Have to enter the power saving with the AP
5321                         set_channel_bwmode(padapter, pbuddy_mlmeext->cur_channel, pbuddy_mlmeext->cur_ch_offset, pbuddy_mlmeext->cur_bwmode);
5322
5323                         issue_nulldata(pbuddy_adapter, NULL, 1, 3, 500);
5324                 }
5325 #endif // CONFIG_CONCURRENT_MODE
5326
5327                 DBG_871X( "[%s] Start PreTx Procedure!\n", __FUNCTION__ );
5328                 _set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
5329 #ifdef CONFIG_CONCURRENT_MODE
5330                 if ( check_fwstate( pbuddy_mlmepriv, _FW_LINKED ) )
5331                 {
5332                         _set_timer( &pwdinfo->restore_p2p_state_timer, P2P_CONCURRENT_GO_NEGO_TIMEOUT );
5333                 }
5334                 else
5335                 {
5336                         _set_timer( &pwdinfo->restore_p2p_state_timer, P2P_GO_NEGO_TIMEOUT );
5337                 }
5338 #else
5339                 _set_timer( &pwdinfo->restore_p2p_state_timer, P2P_GO_NEGO_TIMEOUT );
5340 #endif // CONFIG_CONCURRENT_MODE
5341
5342         }
5343         else
5344         {
5345                 DBG_871X( "[%s] Not Found in Scanning Queue~\n", __FUNCTION__ );
5346 #ifdef CONFIG_INTEL_WIDI
5347                 _cancel_timer_ex( &pwdinfo->restore_p2p_state_timer );
5348                 rtw_p2p_set_state(pwdinfo, P2P_STATE_FIND_PHASE_SEARCH);
5349                 rtw_p2p_findphase_ex_set(pwdinfo, P2P_FINDPHASE_EX_NONE);
5350                 rtw_free_network_queue(padapter, _TRUE);
5351                 /**
5352                  * For WiDi, if we can't find candidate device in scanning queue,
5353                  * driver will do scanning itself
5354                  */
5355                 _enter_critical_bh(&pmlmepriv->lock, &irqL);
5356                 rtw_sitesurvey_cmd(padapter, NULL, 0, NULL, 0);
5357                 _exit_critical_bh(&pmlmepriv->lock, &irqL);
5358 #endif //CONFIG_INTEL_WIDI
5359                 ret = -1;
5360         }
5361 exit:
5362         return ret;
5363 }
5364
5365 static int rtw_p2p_invite_req(struct net_device *dev,
5366                                struct iw_request_info *info,
5367                                union iwreq_data *wrqu, char *extra)
5368 {
5369
5370         int ret = 0;
5371         _adapter                                        *padapter = (_adapter *)rtw_netdev_priv(dev);
5372         struct iw_point                         *pdata = &wrqu->data;
5373         struct wifidirect_info          *pwdinfo = &( padapter->wdinfo );
5374         int                                             jj,kk;
5375         u8                                              peerMACStr[ ETH_ALEN * 2 ] = { 0x00 };
5376         struct mlme_priv                        *pmlmepriv = &padapter->mlmepriv;
5377         _list                                           *plist, *phead;
5378         _queue                                  *queue  = &(pmlmepriv->scanned_queue);
5379         struct  wlan_network            *pnetwork = NULL;
5380         uint                                            uintPeerChannel = 0;
5381         u8                                              attr_content[50] = { 0x00 }, _status = 0;
5382         u8                                              *p2pie;
5383         uint                                            p2pielen = 0, attr_contentlen = 0;
5384         _irqL                                   irqL;
5385         struct tx_invite_req_info*      pinvite_req_info = &pwdinfo->invitereq_info;
5386         u8 ie_offset = 12;
5387 #ifdef CONFIG_CONCURRENT_MODE
5388         _adapter                                        *pbuddy_adapter = padapter->pbuddy_adapter;
5389         struct mlme_priv                        *pbuddy_mlmepriv = &pbuddy_adapter->mlmepriv;
5390         struct mlme_ext_priv            *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
5391 #endif // CONFIG_CONCURRENT_MODE
5392
5393 #ifdef CONFIG_WFD
5394         struct wifi_display_info*       pwfd_info = pwdinfo->wfd_info;
5395 #endif // CONFIG_WFD
5396
5397         //      Commented by Albert 20120321
5398         //      The input data contains two informations.
5399         //      1. First information is the P2P device address which you want to send to.
5400         //      2. Second information is the group id which combines with GO's mac address, space and GO's ssid.
5401         //      Command line sample: iwpriv wlan0 p2p_set invite="00:11:22:33:44:55 00:E0:4C:00:00:05 DIRECT-xy"
5402         //      Format: 00:11:22:33:44:55 00:E0:4C:00:00:05 DIRECT-xy
5403
5404         DBG_871X( "[%s] data = %s\n", __FUNCTION__, extra );
5405
5406         if ( wrqu->data.length <=  37 )
5407         {
5408                 DBG_871X( "[%s] Wrong format!\n", __FUNCTION__ );
5409                 return ret;
5410         }
5411
5412         if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
5413         {
5414                 DBG_871X( "[%s] WiFi Direct is disable!\n", __FUNCTION__ );
5415                 return ret;
5416         }
5417         else
5418         {
5419                 //      Reset the content of struct tx_invite_req_info
5420                 pinvite_req_info->benable = _FALSE;
5421                 _rtw_memset( pinvite_req_info->go_bssid, 0x00, ETH_ALEN );
5422                 _rtw_memset( pinvite_req_info->go_ssid, 0x00, WLAN_SSID_MAXLEN );
5423                 pinvite_req_info->ssidlen = 0x00;
5424                 pinvite_req_info->operating_ch = pwdinfo->operating_channel;
5425                 _rtw_memset( pinvite_req_info->peer_macaddr, 0x00, ETH_ALEN );
5426                 pinvite_req_info->token = 3;
5427         }
5428
5429         for( jj = 0, kk = 0; jj < ETH_ALEN; jj++, kk += 3 )
5430         {
5431                 pinvite_req_info->peer_macaddr[ jj ] = key_2char2num( extra[kk], extra[kk+ 1] );
5432         }
5433
5434         _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
5435
5436         phead = get_list_head(queue);
5437         plist = get_next(phead);
5438
5439         while(1)
5440         {
5441                 if (rtw_end_of_queue_search(phead,plist)== _TRUE)
5442                         break;
5443
5444                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
5445
5446                 //      Commented by Albert 2011/05/18
5447                 //      Match the device address located in the P2P IE
5448                 //      This is for the case that the P2P device address is not the same as the P2P interface address.
5449
5450                 ie_offset = (pnetwork->network.Reserved[0] == 2? 0:12);
5451                 if ( (p2pie=rtw_get_p2p_ie_from_scan_queue( &pnetwork->network.IEs[0], pnetwork->network.IELength, NULL, &p2pielen, pnetwork->network.Reserved[0])))
5452                 {
5453                         //      The P2P Device ID attribute is included in the Beacon frame.
5454                         //      The P2P Device Info attribute is included in the probe response frame.
5455
5456                         if ( rtw_get_p2p_attr_content( p2pie, p2pielen, P2P_ATTR_DEVICE_ID, attr_content, &attr_contentlen) )
5457                         {
5458                                 //      Handle the P2P Device ID attribute of Beacon first
5459                                 if ( _rtw_memcmp( attr_content, pinvite_req_info->peer_macaddr, ETH_ALEN ) )
5460                                 {
5461                                         uintPeerChannel = pnetwork->network.Configuration.DSConfig;
5462                                         break;
5463                                 }
5464                         }
5465                         else if ( rtw_get_p2p_attr_content( p2pie, p2pielen, P2P_ATTR_DEVICE_INFO, attr_content, &attr_contentlen) )
5466                         {
5467                                 //      Handle the P2P Device Info attribute of probe response
5468                                 if ( _rtw_memcmp( attr_content, pinvite_req_info->peer_macaddr, ETH_ALEN ) )
5469                                 {
5470                                         uintPeerChannel = pnetwork->network.Configuration.DSConfig;
5471                                         break;
5472                                 }
5473                         }
5474
5475                 }
5476
5477                 plist = get_next(plist);
5478
5479         }
5480
5481         _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
5482
5483 #ifdef CONFIG_WFD
5484         if ( uintPeerChannel )
5485         {
5486                 u8      wfd_ie[ 128 ] = { 0x00 };
5487                 uint    wfd_ielen = 0;
5488
5489                 if ( rtw_get_wfd_ie_from_scan_queue( &pnetwork->network.IEs[0], pnetwork->network.IELength,  wfd_ie, &wfd_ielen, pnetwork->network.Reserved[0]) )
5490                 {
5491                         u8      wfd_devinfo[ 6 ] = { 0x00 };
5492                         uint    wfd_devlen = 6;
5493
5494                         DBG_871X( "[%s] Found WFD IE!\n", __FUNCTION__ );
5495                         if ( rtw_get_wfd_attr_content( wfd_ie, wfd_ielen, WFD_ATTR_DEVICE_INFO, wfd_devinfo, &wfd_devlen ) )
5496                         {
5497                                 u16     wfd_devinfo_field = 0;
5498
5499                                 //      Commented by Albert 20120319
5500                                 //      The first two bytes are the WFD device information field of WFD device information subelement.
5501                                 //      In big endian format.
5502                                 wfd_devinfo_field = RTW_GET_BE16(wfd_devinfo);
5503                                 if ( wfd_devinfo_field & WFD_DEVINFO_SESSION_AVAIL )
5504                                 {
5505                                         pwfd_info->peer_session_avail = _TRUE;
5506                                 }
5507                                 else
5508                                 {
5509                                         pwfd_info->peer_session_avail = _FALSE;
5510                                 }
5511                         }
5512                 }
5513
5514                 if ( _FALSE == pwfd_info->peer_session_avail )
5515                 {
5516                         DBG_871X( "[%s] WFD Session not avaiable!\n", __FUNCTION__ );
5517                         goto exit;
5518                 }
5519         }
5520 #endif // CONFIG_WFD
5521
5522         if ( uintPeerChannel )
5523         {
5524 #ifdef CONFIG_CONCURRENT_MODE
5525                 if ( check_fwstate( pbuddy_mlmepriv, _FW_LINKED ) )
5526                 {
5527                         _cancel_timer_ex( &pwdinfo->ap_p2p_switch_timer );
5528                 }
5529 #endif // CONFIG_CONCURRENT_MODE
5530
5531                 //      Store the GO's bssid
5532                 for( jj = 0, kk = 18; jj < ETH_ALEN; jj++, kk += 3 )
5533                 {
5534                         pinvite_req_info->go_bssid[ jj ] = key_2char2num( extra[kk], extra[kk+ 1] );
5535                 }
5536
5537                 //      Store the GO's ssid
5538                 pinvite_req_info->ssidlen = wrqu->data.length - 36;
5539                 _rtw_memcpy( pinvite_req_info->go_ssid, &extra[ 36 ], (u32) pinvite_req_info->ssidlen );
5540                 pinvite_req_info->benable = _TRUE;
5541                 pinvite_req_info->peer_ch = uintPeerChannel;
5542
5543                 rtw_p2p_set_pre_state(pwdinfo, rtw_p2p_state(pwdinfo));
5544                 rtw_p2p_set_state(pwdinfo, P2P_STATE_TX_INVITE_REQ);
5545
5546 #ifdef CONFIG_CONCURRENT_MODE
5547                 if ( check_fwstate( pbuddy_mlmepriv, _FW_LINKED ) )
5548                 {
5549                         //      Have to enter the power saving with the AP
5550                         set_channel_bwmode(padapter, pbuddy_mlmeext->cur_channel, pbuddy_mlmeext->cur_ch_offset, pbuddy_mlmeext->cur_bwmode);
5551
5552                         issue_nulldata(pbuddy_adapter, NULL, 1, 3, 500);
5553                 }
5554                 else
5555                 {
5556                         set_channel_bwmode(padapter, uintPeerChannel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20);
5557                 }
5558 #else
5559                 set_channel_bwmode(padapter, uintPeerChannel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20);
5560 #endif
5561
5562                 _set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
5563
5564 #ifdef CONFIG_CONCURRENT_MODE
5565                 if ( check_fwstate( pbuddy_mlmepriv, _FW_LINKED ) )
5566                 {
5567                         _set_timer( &pwdinfo->restore_p2p_state_timer, P2P_CONCURRENT_INVITE_TIMEOUT );
5568                 }
5569                 else
5570                 {
5571                         _set_timer( &pwdinfo->restore_p2p_state_timer, P2P_INVITE_TIMEOUT );
5572                 }
5573 #else
5574                 _set_timer( &pwdinfo->restore_p2p_state_timer, P2P_INVITE_TIMEOUT );
5575 #endif // CONFIG_CONCURRENT_MODE
5576
5577
5578         }
5579         else
5580         {
5581                 DBG_871X( "[%s] NOT Found in the Scanning Queue!\n", __FUNCTION__ );
5582         }
5583 exit:
5584
5585         return ret;
5586
5587 }
5588
5589 static int rtw_p2p_set_persistent(struct net_device *dev,
5590                                struct iw_request_info *info,
5591                                union iwreq_data *wrqu, char *extra)
5592 {
5593
5594         int ret = 0;
5595         _adapter                                        *padapter = (_adapter *)rtw_netdev_priv(dev);
5596         struct iw_point                         *pdata = &wrqu->data;
5597         struct wifidirect_info          *pwdinfo = &( padapter->wdinfo );
5598         int                                             jj,kk;
5599         u8                                              peerMACStr[ ETH_ALEN * 2 ] = { 0x00 };
5600         struct mlme_priv                        *pmlmepriv = &padapter->mlmepriv;
5601         _list                                           *plist, *phead;
5602         _queue                                  *queue  = &(pmlmepriv->scanned_queue);
5603         struct  wlan_network            *pnetwork = NULL;
5604         uint                                            uintPeerChannel = 0;
5605         u8                                              attr_content[50] = { 0x00 }, _status = 0;
5606         u8                                              *p2pie;
5607         uint                                            p2pielen = 0, attr_contentlen = 0;
5608         _irqL                                   irqL;
5609         struct tx_invite_req_info*      pinvite_req_info = &pwdinfo->invitereq_info;
5610 #ifdef CONFIG_CONCURRENT_MODE
5611         _adapter                                        *pbuddy_adapter = padapter->pbuddy_adapter;
5612         struct mlme_priv                        *pbuddy_mlmepriv = &pbuddy_adapter->mlmepriv;
5613         struct mlme_ext_priv            *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
5614 #endif // CONFIG_CONCURRENT_MODE
5615
5616 #ifdef CONFIG_WFD
5617         struct wifi_display_info*       pwfd_info = pwdinfo->wfd_info;
5618 #endif // CONFIG_WFD
5619
5620         //      Commented by Albert 20120328
5621         //      The input data is 0 or 1
5622         //      0: disable persistent group functionality
5623         //      1: enable persistent group founctionality
5624
5625         DBG_871X( "[%s] data = %s\n", __FUNCTION__, extra );
5626
5627         if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
5628         {
5629                 DBG_871X( "[%s] WiFi Direct is disable!\n", __FUNCTION__ );
5630                 return ret;
5631         }
5632         else
5633         {
5634                 if ( extra[ 0 ] == '0' )        //      Disable the persistent group function.
5635                 {
5636                         pwdinfo->persistent_supported = _FALSE;
5637                 }
5638                 else if ( extra[ 0 ] == '1' )   //      Enable the persistent group function.
5639                 {
5640                         pwdinfo->persistent_supported = _TRUE;
5641                 }
5642                 else
5643                 {
5644                         pwdinfo->persistent_supported = _FALSE;
5645                 }
5646         }
5647         printk( "[%s] persistent_supported = %d\n", __FUNCTION__, pwdinfo->persistent_supported );
5648
5649 exit:
5650
5651         return ret;
5652
5653 }
5654
5655 static int hexstr2bin(const char *hex, u8 *buf, size_t len)
5656 {
5657         size_t i;
5658         int a;
5659         const char *ipos = hex;
5660         u8 *opos = buf;
5661
5662         for (i = 0; i < len; i++) {
5663                 a = hex2byte_i(ipos);
5664                 if (a < 0)
5665                         return -1;
5666                 *opos++ = a;
5667                 ipos += 2;
5668         }
5669         return 0;
5670 }
5671
5672 static int uuid_str2bin(const char *str, u8 *bin)
5673 {
5674         const char *pos;
5675         u8 *opos;
5676
5677         pos = str;
5678         opos = bin;
5679
5680         if (hexstr2bin(pos, opos, 4))
5681                 return -1;
5682         pos += 8;
5683         opos += 4;
5684
5685         if (*pos++ != '-' || hexstr2bin(pos, opos, 2))
5686                 return -1;
5687         pos += 4;
5688         opos += 2;
5689
5690         if (*pos++ != '-' || hexstr2bin(pos, opos, 2))
5691                 return -1;
5692         pos += 4;
5693         opos += 2;
5694
5695         if (*pos++ != '-' || hexstr2bin(pos, opos, 2))
5696                 return -1;
5697         pos += 4;
5698         opos += 2;
5699
5700         if (*pos++ != '-' || hexstr2bin(pos, opos, 6))
5701                 return -1;
5702
5703         return 0;
5704 }
5705
5706 static int rtw_p2p_set_wps_uuid(struct net_device *dev,
5707         struct iw_request_info *info,
5708         union iwreq_data *wrqu, char *extra)
5709 {
5710
5711         int ret = 0;
5712         _adapter                                *padapter = (_adapter *)rtw_netdev_priv(dev);
5713         struct wifidirect_info                  *pwdinfo = &(padapter->wdinfo);
5714
5715         DBG_871X("[%s] data = %s\n", __FUNCTION__, extra);
5716
5717         if ((36 == strlen(extra)) && (uuid_str2bin(extra, pwdinfo->uuid) == 0))
5718         {
5719                 pwdinfo->external_uuid = 1;
5720         } else {
5721                 pwdinfo->external_uuid = 0;
5722                 ret = -EINVAL;
5723         }
5724
5725         return ret;
5726
5727 }
5728 #ifdef CONFIG_WFD
5729 static int rtw_p2p_set_pc(struct net_device *dev,
5730                                struct iw_request_info *info,
5731                                union iwreq_data *wrqu, char *extra)
5732 {
5733
5734         int ret = 0;
5735         _adapter                                *padapter = (_adapter *)rtw_netdev_priv(dev);
5736         struct iw_point                 *pdata = &wrqu->data;
5737         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
5738         u8                                      peerMAC[ ETH_ALEN ] = { 0x00 };
5739         int                                     jj,kk;
5740         u8                                      peerMACStr[ ETH_ALEN * 2 ] = { 0x00 };
5741         struct mlme_priv                *pmlmepriv = &padapter->mlmepriv;
5742         _list                                   *plist, *phead;
5743         _queue                          *queue  = &(pmlmepriv->scanned_queue);
5744         struct  wlan_network    *pnetwork = NULL;
5745         u8                                      attr_content[50] = { 0x00 }, _status = 0;
5746         u8 *p2pie;
5747         uint                                    p2pielen = 0, attr_contentlen = 0;
5748         _irqL                           irqL;
5749         uint                                    uintPeerChannel = 0;
5750 #ifdef CONFIG_CONCURRENT_MODE
5751         _adapter                                *pbuddy_adapter = padapter->pbuddy_adapter;
5752         struct mlme_ext_priv    *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
5753 #endif // CONFIG_CONCURRENT_MODE
5754
5755         struct wifi_display_info*       pwfd_info = pwdinfo->wfd_info;
5756
5757         //      Commented by Albert 20120512
5758         //      1. Input information is the MAC address which wants to know the Preferred Connection bit (PC bit)
5759         //      Format: 00:E0:4C:00:00:05
5760
5761         DBG_871X( "[%s] data = %s\n", __FUNCTION__, extra );
5762
5763         if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
5764         {
5765                 DBG_871X( "[%s] WiFi Direct is disable!\n", __FUNCTION__ );
5766                 return ret;
5767         }
5768
5769         for( jj = 0, kk = 0; jj < ETH_ALEN; jj++, kk += 3 )
5770         {
5771                 peerMAC[ jj ] = key_2char2num( extra[kk], extra[kk+ 1] );
5772         }
5773
5774         _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
5775
5776         phead = get_list_head(queue);
5777         plist = get_next(phead);
5778
5779         while(1)
5780         {
5781                 if (rtw_end_of_queue_search(phead,plist)== _TRUE)
5782                         break;
5783
5784                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
5785
5786                 //      Commented by Albert 2011/05/18
5787                 //      Match the device address located in the P2P IE
5788                 //      This is for the case that the P2P device address is not the same as the P2P interface address.
5789
5790                 if ( (p2pie=rtw_get_p2p_ie_from_scan_queue( &pnetwork->network.IEs[0], pnetwork->network.IELength, NULL, &p2pielen, pnetwork->network.Reserved[0])))
5791                 {
5792                         //      The P2P Device ID attribute is included in the Beacon frame.
5793                         //      The P2P Device Info attribute is included in the probe response frame.
5794                         printk( "[%s] Got P2P IE\n", __FUNCTION__ );
5795                         if ( rtw_get_p2p_attr_content( p2pie, p2pielen, P2P_ATTR_DEVICE_ID, attr_content, &attr_contentlen) )
5796                         {
5797                                 //      Handle the P2P Device ID attribute of Beacon first
5798                                 printk( "[%s] P2P_ATTR_DEVICE_ID \n", __FUNCTION__ );
5799                                 if ( _rtw_memcmp( attr_content, peerMAC, ETH_ALEN ) )
5800                                 {
5801                                         uintPeerChannel = pnetwork->network.Configuration.DSConfig;
5802                                         break;
5803                                 }
5804                         }
5805                         else if ( rtw_get_p2p_attr_content( p2pie, p2pielen, P2P_ATTR_DEVICE_INFO, attr_content, &attr_contentlen) )
5806                         {
5807                                 //      Handle the P2P Device Info attribute of probe response
5808                                 printk( "[%s] P2P_ATTR_DEVICE_INFO \n", __FUNCTION__ );
5809                                 if ( _rtw_memcmp( attr_content, peerMAC, ETH_ALEN ) )
5810                                 {
5811                                         uintPeerChannel = pnetwork->network.Configuration.DSConfig;
5812                                         break;
5813                                 }
5814                         }
5815
5816                 }
5817
5818                 plist = get_next(plist);
5819
5820         }
5821
5822         _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
5823         printk( "[%s] channel = %d\n", __FUNCTION__, uintPeerChannel );
5824
5825         if ( uintPeerChannel )
5826         {
5827                 u8      wfd_ie[ 128 ] = { 0x00 };
5828                 uint    wfd_ielen = 0;
5829                 u8 ie_offset = (pnetwork->network.Reserved[0] == 2 ? 0:12);
5830
5831                 if ( rtw_get_wfd_ie_from_scan_queue( &pnetwork->network.IEs[0], pnetwork->network.IELength,  wfd_ie, &wfd_ielen, pnetwork->network.Reserved[0]) )
5832                 {
5833                         u8      wfd_devinfo[ 6 ] = { 0x00 };
5834                         uint    wfd_devlen = 6;
5835
5836                         DBG_871X( "[%s] Found WFD IE!\n", __FUNCTION__ );
5837                         if ( rtw_get_wfd_attr_content( wfd_ie, wfd_ielen, WFD_ATTR_DEVICE_INFO, wfd_devinfo, &wfd_devlen ) )
5838                         {
5839                                 u16     wfd_devinfo_field = 0;
5840
5841                                 //      Commented by Albert 20120319
5842                                 //      The first two bytes are the WFD device information field of WFD device information subelement.
5843                                 //      In big endian format.
5844                                 wfd_devinfo_field = RTW_GET_BE16(wfd_devinfo);
5845                                 if ( wfd_devinfo_field & WFD_DEVINFO_PC_TDLS )
5846                                 {
5847                                         pwfd_info->wfd_pc = _TRUE;
5848                                 }
5849                                 else
5850                                 {
5851                                         pwfd_info->wfd_pc = _FALSE;
5852                                 }
5853                         }
5854                 }
5855         }
5856         else
5857         {
5858                 DBG_871X( "[%s] NOT Found in the Scanning Queue!\n", __FUNCTION__ );
5859         }
5860
5861 exit:
5862
5863         return ret;
5864
5865 }
5866
5867 static int rtw_p2p_set_wfd_device_type(struct net_device *dev,
5868                                struct iw_request_info *info,
5869                                union iwreq_data *wrqu, char *extra)
5870 {
5871
5872         int ret = 0;
5873         _adapter                                        *padapter = (_adapter *)rtw_netdev_priv(dev);
5874         struct iw_point                         *pdata = &wrqu->data;
5875         struct wifidirect_info          *pwdinfo = &( padapter->wdinfo );
5876         struct wifi_display_info                *pwfd_info = pwdinfo->wfd_info;
5877
5878         //      Commented by Albert 20120328
5879         //      The input data is 0 or 1
5880         //      0: specify to Miracast source device
5881         //      1 or others: specify to Miracast sink device (display device)
5882
5883         DBG_871X( "[%s] data = %s\n", __FUNCTION__, extra );
5884
5885         if ( extra[ 0 ] == '0' )        //      Set to Miracast source device.
5886         {
5887                 pwfd_info->wfd_device_type = WFD_DEVINFO_SOURCE;
5888         }
5889         else                                    //      Set to Miracast sink device.
5890         {
5891                 pwfd_info->wfd_device_type = WFD_DEVINFO_PSINK;
5892         }
5893
5894 exit:
5895
5896         return ret;
5897
5898 }
5899
5900 static int rtw_p2p_set_wfd_enable(struct net_device *dev,
5901                                struct iw_request_info *info,
5902                                union iwreq_data *wrqu, char *extra)
5903 {
5904 //      Commented by Kurt 20121206
5905 //      This function is used to set wfd enabled
5906
5907         int ret = 0;
5908         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5909         struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
5910
5911         if(*extra == '0' )
5912                 pwdinfo->wfd_info->wfd_enable = _FALSE;
5913         else if(*extra == '1')
5914                 pwdinfo->wfd_info->wfd_enable = _TRUE;
5915
5916         DBG_871X( "[%s] wfd_enable = %d\n", __FUNCTION__, pwdinfo->wfd_info->wfd_enable );
5917
5918         return ret;
5919
5920 }
5921
5922 static int rtw_p2p_set_driver_iface(struct net_device *dev,
5923                                struct iw_request_info *info,
5924                                union iwreq_data *wrqu, char *extra)
5925 {
5926 //      Commented by Kurt 20121206
5927 //      This function is used to set driver iface is WEXT or CFG80211
5928         int ret = 0;
5929         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5930         struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
5931
5932         if(*extra == '1' )
5933         {
5934                 pwdinfo->driver_interface = DRIVER_WEXT;
5935                 DBG_871X( "[%s] driver_interface = WEXT\n", __FUNCTION__);
5936         }
5937         else if(*extra == '2')
5938         {
5939                 pwdinfo->driver_interface = DRIVER_CFG80211;
5940                 DBG_871X( "[%s] driver_interface = CFG80211\n", __FUNCTION__);
5941         }
5942
5943         return ret;
5944
5945 }
5946
5947 //      To set the WFD session available to enable or disable
5948 static int rtw_p2p_set_sa(struct net_device *dev,
5949                                struct iw_request_info *info,
5950                                union iwreq_data *wrqu, char *extra)
5951 {
5952
5953         int ret = 0;
5954         _adapter                                        *padapter = (_adapter *)rtw_netdev_priv(dev);
5955         struct iw_point                         *pdata = &wrqu->data;
5956         struct wifidirect_info          *pwdinfo = &( padapter->wdinfo );
5957         struct wifi_display_info                *pwfd_info = pwdinfo->wfd_info;
5958
5959         DBG_871X( "[%s] data = %s\n", __FUNCTION__, extra );
5960
5961         if( 0 )
5962         {
5963                 DBG_871X( "[%s] WiFi Direct is disable!\n", __FUNCTION__ );
5964                 return ret;
5965         }
5966         else
5967         {
5968                 if ( extra[ 0 ] == '0' )        //      Disable the session available.
5969                 {
5970                         pwdinfo->session_available = _FALSE;
5971                 }
5972                 else if ( extra[ 0 ] == '1' )   //      Enable the session available.
5973                 {
5974                         pwdinfo->session_available = _TRUE;
5975                 }
5976                 else
5977                 {
5978                         pwdinfo->session_available = _FALSE;
5979                 }
5980         }
5981         printk( "[%s] session available = %d\n", __FUNCTION__, pwdinfo->session_available );
5982
5983 exit:
5984
5985         return ret;
5986
5987 }
5988 #endif // CONFIG_WFD
5989
5990 static int rtw_p2p_prov_disc(struct net_device *dev,
5991                                struct iw_request_info *info,
5992                                union iwreq_data *wrqu, char *extra)
5993 {
5994         int ret = 0;
5995         _adapter                                *padapter = (_adapter *)rtw_netdev_priv(dev);
5996         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
5997         u8                                      peerMAC[ ETH_ALEN ] = { 0x00 };
5998         int                                     jj,kk;
5999         u8                                      peerMACStr[ ETH_ALEN * 2 ] = { 0x00 };
6000         struct mlme_priv                *pmlmepriv = &padapter->mlmepriv;
6001         _list                                   *plist, *phead;
6002         _queue                          *queue  = &(pmlmepriv->scanned_queue);
6003         struct  wlan_network    *pnetwork = NULL;
6004         uint                                    uintPeerChannel = 0;
6005         u8                                      attr_content[100] = { 0x00 }, _status = 0;
6006         u8 *p2pie;
6007         uint                                    p2pielen = 0, attr_contentlen = 0;
6008         _irqL                           irqL;
6009         u8                                      ie_offset = 12;
6010 #ifdef CONFIG_CONCURRENT_MODE
6011         _adapter                                *pbuddy_adapter = padapter->pbuddy_adapter;
6012         struct mlme_priv                *pbuddy_mlmepriv = &pbuddy_adapter->mlmepriv;
6013         struct mlme_ext_priv    *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
6014 #endif // CONFIG_CONCURRENT_MODE
6015 #ifdef CONFIG_WFD
6016         struct wifi_display_info*       pwfd_info = pwdinfo->wfd_info;
6017 #endif // CONFIG_WFD
6018
6019         //      Commented by Albert 20110301
6020         //      The input data contains two informations.
6021         //      1. First information is the MAC address which wants to issue the provisioning discovery request frame.
6022         //      2. Second information is the WPS configuration method which wants to discovery
6023         //      Format: 00:E0:4C:00:00:05_display
6024         //      Format: 00:E0:4C:00:00:05_keypad
6025         //      Format: 00:E0:4C:00:00:05_pbc
6026         //      Format: 00:E0:4C:00:00:05_label
6027
6028         DBG_871X( "[%s] data = %s\n", __FUNCTION__, extra );
6029
6030         if ( pwdinfo->p2p_state == P2P_STATE_NONE )
6031         {
6032                 DBG_871X( "[%s] WiFi Direct is disable!\n", __FUNCTION__ );
6033                 return ret;
6034         }
6035         else
6036         {
6037 #ifdef CONFIG_INTEL_WIDI
6038                 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == _TRUE) {
6039                         DBG_871X( "[%s] WiFi is under survey!\n", __FUNCTION__ );
6040                         return ret;
6041                 }
6042 #endif //CONFIG_INTEL_WIDI
6043
6044                 //      Reset the content of struct tx_provdisc_req_info excluded the wps_config_method_request.
6045                 _rtw_memset( pwdinfo->tx_prov_disc_info.peerDevAddr, 0x00, ETH_ALEN );
6046                 _rtw_memset( pwdinfo->tx_prov_disc_info.peerIFAddr, 0x00, ETH_ALEN );
6047                 _rtw_memset( &pwdinfo->tx_prov_disc_info.ssid, 0x00, sizeof( NDIS_802_11_SSID ) );
6048                 pwdinfo->tx_prov_disc_info.peer_channel_num[ 0 ] = 0;
6049                 pwdinfo->tx_prov_disc_info.peer_channel_num[ 1 ] = 0;
6050                 pwdinfo->tx_prov_disc_info.benable = _FALSE;
6051         }
6052
6053         for( jj = 0, kk = 0; jj < ETH_ALEN; jj++, kk += 3 )
6054         {
6055                 peerMAC[ jj ] = key_2char2num( extra[kk], extra[kk+ 1] );
6056         }
6057
6058         if ( _rtw_memcmp( &extra[ 18 ], "display", 7 ) )
6059         {
6060                 pwdinfo->tx_prov_disc_info.wps_config_method_request = WPS_CM_DISPLYA;
6061         }
6062         else if ( _rtw_memcmp( &extra[ 18 ], "keypad", 7 ) )
6063         {
6064                 pwdinfo->tx_prov_disc_info.wps_config_method_request = WPS_CM_KEYPAD;
6065         }
6066         else if ( _rtw_memcmp( &extra[ 18 ], "pbc", 3 ) )
6067         {
6068                 pwdinfo->tx_prov_disc_info.wps_config_method_request = WPS_CM_PUSH_BUTTON;
6069         }
6070         else if ( _rtw_memcmp( &extra[ 18 ], "label", 5 ) )
6071         {
6072                 pwdinfo->tx_prov_disc_info.wps_config_method_request = WPS_CM_LABEL;
6073         }
6074         else
6075         {
6076                 DBG_871X( "[%s] Unknown WPS config methodn", __FUNCTION__ );
6077                 return( ret );
6078         }
6079
6080         _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
6081
6082         phead = get_list_head(queue);
6083         plist = get_next(phead);
6084
6085         while(1)
6086         {
6087                 if (rtw_end_of_queue_search(phead,plist)== _TRUE)
6088                         break;
6089
6090                 if( uintPeerChannel != 0 )
6091                         break;
6092
6093                 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
6094
6095                 //      Commented by Albert 2011/05/18
6096                 //      Match the device address located in the P2P IE
6097                 //      This is for the case that the P2P device address is not the same as the P2P interface address.
6098
6099                 ie_offset = (pnetwork->network.Reserved[0] == 2? 0:12);
6100                 if ( (p2pie=rtw_get_p2p_ie_from_scan_queue( &pnetwork->network.IEs[0], pnetwork->network.IELength, NULL, &p2pielen, pnetwork->network.Reserved[0])))
6101                 {
6102                         while ( p2pie )
6103                         {
6104                                 //      The P2P Device ID attribute is included in the Beacon frame.
6105                                 //      The P2P Device Info attribute is included in the probe response frame.
6106
6107                                 if ( rtw_get_p2p_attr_content( p2pie, p2pielen, P2P_ATTR_DEVICE_ID, attr_content, &attr_contentlen) )
6108                                 {
6109                                         //      Handle the P2P Device ID attribute of Beacon first
6110                                         if ( _rtw_memcmp( attr_content, peerMAC, ETH_ALEN ) )
6111                                         {
6112                                                 uintPeerChannel = pnetwork->network.Configuration.DSConfig;
6113                                                 break;
6114                                         }
6115                                 }
6116                                 else if ( rtw_get_p2p_attr_content( p2pie, p2pielen, P2P_ATTR_DEVICE_INFO, attr_content, &attr_contentlen) )
6117                                 {
6118                                         //      Handle the P2P Device Info attribute of probe response
6119                                         if ( _rtw_memcmp( attr_content, peerMAC, ETH_ALEN ) )
6120                                         {
6121                                                 uintPeerChannel = pnetwork->network.Configuration.DSConfig;
6122                                                 break;
6123                                         }
6124                                 }
6125
6126                                 //Get the next P2P IE
6127                                 p2pie = rtw_get_p2p_ie(p2pie+p2pielen, pnetwork->network.IELength - ie_offset -(p2pie -&pnetwork->network.IEs[ie_offset] + p2pielen), NULL, &p2pielen);
6128                         }
6129
6130                 }
6131
6132 #ifdef CONFIG_INTEL_WIDI
6133                 // Some Intel WiDi source may not provide P2P IE,
6134                 // so we could only compare mac addr by 802.11 Source Address
6135                 if( pmlmepriv->widi_state == INTEL_WIDI_STATE_WFD_CONNECTION
6136                         && uintPeerChannel == 0 )
6137                 {
6138                         if ( _rtw_memcmp( pnetwork->network.MacAddress, peerMAC, ETH_ALEN ) )
6139                         {
6140                                 uintPeerChannel = pnetwork->network.Configuration.DSConfig;
6141                                 break;
6142                         }
6143                 }
6144 #endif //CONFIG_INTEL_WIDI
6145
6146                 plist = get_next(plist);
6147
6148         }
6149
6150         _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
6151
6152         if ( uintPeerChannel )
6153         {
6154 #ifdef CONFIG_WFD
6155                 {
6156                         u8      wfd_ie[ 128 ] = { 0x00 };
6157                         uint    wfd_ielen = 0;
6158
6159                         if ( rtw_get_wfd_ie_from_scan_queue( &pnetwork->network.IEs[0], pnetwork->network.IELength,  wfd_ie, &wfd_ielen, pnetwork->network.Reserved[0]) )
6160                         {
6161                                 u8      wfd_devinfo[ 6 ] = { 0x00 };
6162                                 uint    wfd_devlen = 6;
6163
6164                                 DBG_871X( "[%s] Found WFD IE!\n", __FUNCTION__ );
6165                                 if ( rtw_get_wfd_attr_content( wfd_ie, wfd_ielen, WFD_ATTR_DEVICE_INFO, wfd_devinfo, &wfd_devlen ) )
6166                                 {
6167                                         u16     wfd_devinfo_field = 0;
6168
6169                                         //      Commented by Albert 20120319
6170                                         //      The first two bytes are the WFD device information field of WFD device information subelement.
6171                                         //      In big endian format.
6172                                         wfd_devinfo_field = RTW_GET_BE16(wfd_devinfo);
6173                                         if ( wfd_devinfo_field & WFD_DEVINFO_SESSION_AVAIL )
6174                                         {
6175                                                 pwfd_info->peer_session_avail = _TRUE;
6176                                         }
6177                                         else
6178                                         {
6179                                                 pwfd_info->peer_session_avail = _FALSE;
6180                                         }
6181                                 }
6182                         }
6183
6184                         if ( _FALSE == pwfd_info->peer_session_avail )
6185                         {
6186                                 DBG_871X( "[%s] WFD Session not avaiable!\n", __FUNCTION__ );
6187                                 goto exit;
6188                         }
6189                 }
6190 #endif // CONFIG_WFD
6191
6192                 DBG_871X( "[%s] peer channel: %d!\n", __FUNCTION__, uintPeerChannel );
6193 #ifdef CONFIG_CONCURRENT_MODE
6194                 if ( check_fwstate( pbuddy_mlmepriv, _FW_LINKED ) )
6195                 {
6196                         _cancel_timer_ex( &pwdinfo->ap_p2p_switch_timer );
6197                 }
6198 #endif // CONFIG_CONCURRENT_MODE
6199                 _rtw_memcpy( pwdinfo->tx_prov_disc_info.peerIFAddr, pnetwork->network.MacAddress, ETH_ALEN );
6200                 _rtw_memcpy( pwdinfo->tx_prov_disc_info.peerDevAddr, peerMAC, ETH_ALEN );
6201                 pwdinfo->tx_prov_disc_info.peer_channel_num[0] = ( u16 ) uintPeerChannel;
6202                 pwdinfo->tx_prov_disc_info.benable = _TRUE;
6203                 rtw_p2p_set_pre_state(pwdinfo, rtw_p2p_state(pwdinfo));
6204                 rtw_p2p_set_state(pwdinfo, P2P_STATE_TX_PROVISION_DIS_REQ);
6205
6206                 if(rtw_p2p_chk_role(pwdinfo, P2P_ROLE_CLIENT))
6207                 {
6208                         _rtw_memcpy( &pwdinfo->tx_prov_disc_info.ssid, &pnetwork->network.Ssid, sizeof( NDIS_802_11_SSID ) );
6209                 }
6210                 else if(rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DEVICE) || rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
6211                 {
6212                         _rtw_memcpy( pwdinfo->tx_prov_disc_info.ssid.Ssid, pwdinfo->p2p_wildcard_ssid, P2P_WILDCARD_SSID_LEN );
6213                         pwdinfo->tx_prov_disc_info.ssid.SsidLength= P2P_WILDCARD_SSID_LEN;
6214                 }
6215
6216 #ifdef CONFIG_CONCURRENT_MODE
6217                 if ( check_fwstate( pbuddy_mlmepriv, _FW_LINKED ) )
6218                 {
6219                         //      Have to enter the power saving with the AP
6220                         set_channel_bwmode(padapter, pbuddy_mlmeext->cur_channel, pbuddy_mlmeext->cur_ch_offset, pbuddy_mlmeext->cur_bwmode);
6221
6222                         issue_nulldata(pbuddy_adapter, NULL, 1, 3, 500);
6223                 }
6224                 else
6225                 {
6226                         set_channel_bwmode(padapter, uintPeerChannel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20);
6227                 }
6228 #else
6229                 set_channel_bwmode(padapter, uintPeerChannel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20);
6230 #endif
6231
6232                 _set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
6233
6234 #ifdef CONFIG_CONCURRENT_MODE
6235                 if ( check_fwstate( pbuddy_mlmepriv, _FW_LINKED ) )
6236                 {
6237                         _set_timer( &pwdinfo->restore_p2p_state_timer, P2P_CONCURRENT_PROVISION_TIMEOUT );
6238                 }
6239                 else
6240                 {
6241                         _set_timer( &pwdinfo->restore_p2p_state_timer, P2P_PROVISION_TIMEOUT );
6242                 }
6243 #else
6244                 _set_timer( &pwdinfo->restore_p2p_state_timer, P2P_PROVISION_TIMEOUT );
6245 #endif // CONFIG_CONCURRENT_MODE
6246
6247         }
6248         else
6249         {
6250                 DBG_871X( "[%s] NOT Found in the Scanning Queue!\n", __FUNCTION__ );
6251 #ifdef CONFIG_INTEL_WIDI
6252                 _cancel_timer_ex( &pwdinfo->restore_p2p_state_timer );
6253                 rtw_p2p_set_state(pwdinfo, P2P_STATE_FIND_PHASE_SEARCH);
6254                 rtw_p2p_findphase_ex_set(pwdinfo, P2P_FINDPHASE_EX_NONE);
6255                 rtw_free_network_queue(padapter, _TRUE);
6256                 _enter_critical_bh(&pmlmepriv->lock, &irqL);
6257                 rtw_sitesurvey_cmd(padapter, NULL, 0, NULL, 0);
6258                 _exit_critical_bh(&pmlmepriv->lock, &irqL);
6259 #endif //CONFIG_INTEL_WIDI
6260         }
6261 exit:
6262
6263         return ret;
6264
6265 }
6266
6267 //      Added by Albert 20110328
6268 //      This function is used to inform the driver the user had specified the pin code value or pbc
6269 //      to application.
6270
6271 static int rtw_p2p_got_wpsinfo(struct net_device *dev,
6272                                struct iw_request_info *info,
6273                                union iwreq_data *wrqu, char *extra)
6274 {
6275
6276         int ret = 0;
6277         _adapter                                *padapter = (_adapter *)rtw_netdev_priv(dev);
6278         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
6279
6280
6281         DBG_871X( "[%s] data = %s\n", __FUNCTION__, extra );
6282         //      Added by Albert 20110328
6283         //      if the input data is P2P_NO_WPSINFO -> reset the wpsinfo
6284         //      if the input data is P2P_GOT_WPSINFO_PEER_DISPLAY_PIN -> the utility just input the PIN code got from the peer P2P device.
6285         //      if the input data is P2P_GOT_WPSINFO_SELF_DISPLAY_PIN -> the utility just got the PIN code from itself.
6286         //      if the input data is P2P_GOT_WPSINFO_PBC -> the utility just determine to use the PBC
6287
6288         if ( *extra == '0' )
6289         {
6290                 pwdinfo->ui_got_wps_info = P2P_NO_WPSINFO;
6291         }
6292         else if ( *extra == '1' )
6293         {
6294                 pwdinfo->ui_got_wps_info = P2P_GOT_WPSINFO_PEER_DISPLAY_PIN;
6295         }
6296         else if ( *extra == '2' )
6297         {
6298                 pwdinfo->ui_got_wps_info = P2P_GOT_WPSINFO_SELF_DISPLAY_PIN;
6299         }
6300         else if ( *extra == '3' )
6301         {
6302                 pwdinfo->ui_got_wps_info = P2P_GOT_WPSINFO_PBC;
6303         }
6304         else
6305         {
6306                 pwdinfo->ui_got_wps_info = P2P_NO_WPSINFO;
6307         }
6308
6309         return ret;
6310
6311 }
6312
6313 #endif //CONFIG_P2P
6314
6315 static int rtw_p2p_set(struct net_device *dev,
6316                                struct iw_request_info *info,
6317                                union iwreq_data *wrqu, char *extra)
6318 {
6319
6320         int ret = 0;
6321 #ifdef CONFIG_P2P
6322
6323         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6324         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
6325         struct iw_point *pdata = &wrqu->data;
6326         struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
6327         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
6328
6329         DBG_871X( "[%s] extra = %s\n", __FUNCTION__, extra );
6330
6331         if ( _rtw_memcmp( extra, "enable=", 7 ) )
6332         {
6333                 rtw_wext_p2p_enable( dev, info, wrqu, &extra[7] );
6334         }
6335         else if ( _rtw_memcmp( extra, "setDN=", 6 ) )
6336         {
6337                 wrqu->data.length -= 6;
6338                 rtw_p2p_setDN( dev, info, wrqu, &extra[6] );
6339         }
6340         else if ( _rtw_memcmp( extra, "profilefound=", 13 ) )
6341         {
6342                 wrqu->data.length -= 13;
6343                 rtw_p2p_profilefound( dev, info, wrqu, &extra[13] );
6344         }
6345         else if ( _rtw_memcmp( extra, "prov_disc=", 10 ) )
6346         {
6347                 wrqu->data.length -= 10;
6348                 rtw_p2p_prov_disc( dev, info, wrqu, &extra[10] );
6349         }
6350         else if ( _rtw_memcmp( extra, "nego=", 5 ) )
6351         {
6352                 wrqu->data.length -= 5;
6353                 rtw_p2p_connect( dev, info, wrqu, &extra[5] );
6354         }
6355         else if ( _rtw_memcmp( extra, "intent=", 7 ) )
6356         {
6357                 //      Commented by Albert 2011/03/23
6358                 //      The wrqu->data.length will include the null character
6359                 //      So, we will decrease 7 + 1
6360                 wrqu->data.length -= 8;
6361                 rtw_p2p_set_intent( dev, info, wrqu, &extra[7] );
6362         }
6363         else if ( _rtw_memcmp( extra, "ssid=", 5 ) )
6364         {
6365                 wrqu->data.length -= 5;
6366                 rtw_p2p_set_go_nego_ssid( dev, info, wrqu, &extra[5] );
6367         }
6368         else if ( _rtw_memcmp( extra, "got_wpsinfo=", 12 ) )
6369         {
6370                 wrqu->data.length -= 12;
6371                 rtw_p2p_got_wpsinfo( dev, info, wrqu, &extra[12] );
6372         }
6373         else if ( _rtw_memcmp( extra, "listen_ch=", 10 ) )
6374         {
6375                 //      Commented by Albert 2011/05/24
6376                 //      The wrqu->data.length will include the null character
6377                 //      So, we will decrease (10 + 1)
6378                 wrqu->data.length -= 11;
6379                 rtw_p2p_set_listen_ch( dev, info, wrqu, &extra[10] );
6380         }
6381         else if ( _rtw_memcmp( extra, "op_ch=", 6 ) )
6382         {
6383                 //      Commented by Albert 2011/05/24
6384                 //      The wrqu->data.length will include the null character
6385                 //      So, we will decrease (6 + 1)
6386                 wrqu->data.length -= 7;
6387                 rtw_p2p_set_op_ch( dev, info, wrqu, &extra[6] );
6388         }
6389         else if ( _rtw_memcmp( extra, "invite=", 7 ) )
6390         {
6391                 wrqu->data.length -= 8;
6392                 rtw_p2p_invite_req( dev, info, wrqu, &extra[7] );
6393         }
6394         else if ( _rtw_memcmp( extra, "persistent=", 11 ) )
6395         {
6396                 wrqu->data.length -= 11;
6397                 rtw_p2p_set_persistent( dev, info, wrqu, &extra[11] );
6398         }
6399         else if ( _rtw_memcmp ( extra, "uuid=", 5) )
6400         {
6401                 wrqu->data.length -= 5;
6402                 ret = rtw_p2p_set_wps_uuid( dev, info, wrqu, &extra[5] );
6403         }
6404 #ifdef CONFIG_WFD
6405         else if ( _rtw_memcmp( extra, "sa=", 3 ) )
6406         {
6407                 //      sa: WFD Session Available information
6408                 wrqu->data.length -= 3;
6409                 rtw_p2p_set_sa( dev, info, wrqu, &extra[3] );
6410         }
6411         else if ( _rtw_memcmp( extra, "pc=", 3 ) )
6412         {
6413                 //      pc: WFD Preferred Connection
6414                 wrqu->data.length -= 3;
6415                 rtw_p2p_set_pc( dev, info, wrqu, &extra[3] );
6416         }
6417         else if ( _rtw_memcmp( extra, "wfd_type=", 9 ) )
6418         {
6419                 //      pc: WFD Preferred Connection
6420                 wrqu->data.length -= 9;
6421                 rtw_p2p_set_wfd_device_type( dev, info, wrqu, &extra[9] );
6422         }
6423         else if ( _rtw_memcmp( extra, "wfd_enable=", 11 ) )
6424         {
6425                 wrqu->data.length -= 11;
6426                 rtw_p2p_set_wfd_enable( dev, info, wrqu, &extra[11] );
6427         }
6428         else if ( _rtw_memcmp( extra, "driver_iface=", 13 ) )
6429         {
6430                 wrqu->data.length -= 13;
6431                 rtw_p2p_set_driver_iface( dev, info, wrqu, &extra[13] );
6432         }
6433 #endif //CONFIG_WFD
6434
6435 #endif //CONFIG_P2P
6436
6437         return ret;
6438
6439 }
6440
6441 static int rtw_p2p_get(struct net_device *dev,
6442                                struct iw_request_info *info,
6443                                union iwreq_data *wrqu, char *extra)
6444 {
6445
6446         int ret = 0;
6447
6448 #ifdef CONFIG_P2P
6449
6450         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6451         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
6452         struct iw_point *pdata = &wrqu->data;
6453         struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
6454         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
6455
6456         if ( padapter->bShowGetP2PState )
6457         {
6458                 DBG_871X( "[%s] extra = %s\n", __FUNCTION__, (char*) wrqu->data.pointer );
6459         }
6460
6461         if ( _rtw_memcmp( wrqu->data.pointer, "status", 6 ) )
6462         {
6463                 rtw_p2p_get_status( dev, info, wrqu, extra );
6464         }
6465         else if ( _rtw_memcmp( wrqu->data.pointer, "role", 4 ) )
6466         {
6467                 rtw_p2p_get_role( dev, info, wrqu, extra);
6468         }
6469         else if ( _rtw_memcmp( wrqu->data.pointer, "peer_ifa", 8 ) )
6470         {
6471                 rtw_p2p_get_peer_ifaddr( dev, info, wrqu, extra);
6472         }
6473         else if ( _rtw_memcmp( wrqu->data.pointer, "req_cm", 6 ) )
6474         {
6475                 rtw_p2p_get_req_cm( dev, info, wrqu, extra);
6476         }
6477         else if ( _rtw_memcmp( wrqu->data.pointer, "peer_deva", 9 ) )
6478         {
6479                 //      Get the P2P device address when receiving the provision discovery request frame.
6480                 rtw_p2p_get_peer_devaddr( dev, info, wrqu, extra);
6481         }
6482         else if ( _rtw_memcmp( wrqu->data.pointer, "group_id", 8 ) )
6483         {
6484                 rtw_p2p_get_groupid( dev, info, wrqu, extra);
6485         }
6486         else if ( _rtw_memcmp( wrqu->data.pointer, "inv_peer_deva", 13 ) )
6487         {
6488                 //      Get the P2P device address when receiving the P2P Invitation request frame.
6489                 rtw_p2p_get_peer_devaddr_by_invitation( dev, info, wrqu, extra);
6490         }
6491         else if ( _rtw_memcmp( wrqu->data.pointer, "op_ch", 5 ) )
6492         {
6493                 rtw_p2p_get_op_ch( dev, info, wrqu, extra);
6494         }
6495 #ifdef CONFIG_WFD
6496         else if ( _rtw_memcmp( wrqu->data.pointer, "peer_port", 9 ) )
6497         {
6498                 rtw_p2p_get_peer_wfd_port( dev, info, wrqu, extra );
6499         }
6500         else if ( _rtw_memcmp( wrqu->data.pointer, "wfd_sa", 6 ) )
6501         {
6502                 rtw_p2p_get_peer_wfd_session_available( dev, info, wrqu, extra );
6503         }
6504         else if ( _rtw_memcmp( wrqu->data.pointer, "wfd_pc", 6 ) )
6505         {
6506                 rtw_p2p_get_peer_wfd_preferred_connection( dev, info, wrqu, extra );
6507         }
6508 #endif // CONFIG_WFD
6509
6510 #endif //CONFIG_P2P
6511
6512         return ret;
6513
6514 }
6515
6516 static int rtw_p2p_get2(struct net_device *dev,
6517                                                 struct iw_request_info *info,
6518                                                 union iwreq_data *wrqu, char *extra)
6519 {
6520
6521         int ret = 0;
6522
6523 #ifdef CONFIG_P2P
6524
6525         int length = wrqu->data.length;
6526         char *buffer = (u8 *)rtw_malloc(length);
6527
6528         if (buffer == NULL)
6529         {
6530                 ret = -ENOMEM;
6531                 goto bad;
6532         }
6533
6534         if (copy_from_user(buffer, wrqu->data.pointer, wrqu->data.length))
6535         {
6536                 ret - EFAULT;
6537                 goto bad;
6538         }
6539
6540         DBG_871X("[%s] buffer = %s\n", __FUNCTION__, buffer);
6541
6542         if (_rtw_memcmp(buffer, "wpsCM=", 6))
6543         {
6544                 ret = rtw_p2p_get_wps_configmethod(dev, info, wrqu, extra, &buffer[6]);
6545         } else if (_rtw_memcmp(buffer, "devN=", 5))
6546         {
6547                 ret = rtw_p2p_get_device_name(dev, info, wrqu, extra, &buffer[5]);
6548         } else if (_rtw_memcmp(buffer, "dev_type=", 9))
6549         {
6550                 ret = rtw_p2p_get_device_type(dev, info, wrqu, extra, &buffer[9]);
6551         } else if (_rtw_memcmp(buffer, "go_devadd=", 10))
6552         {
6553                 ret = rtw_p2p_get_go_device_address(dev, info, wrqu, extra, &buffer[10]);
6554         } else if (_rtw_memcmp(buffer, "InvProc=", 8))
6555         {
6556                 ret = rtw_p2p_get_invitation_procedure(dev, info, wrqu, extra, &buffer[8]);
6557         } else
6558         {
6559                 snprintf(extra, sizeof("Command not found."), "Command not found.");
6560                 wrqu->data.length = strlen(extra);
6561         }
6562
6563 bad:
6564         if (buffer)
6565         {
6566                 rtw_mfree(buffer, length);
6567         }
6568
6569 #endif //CONFIG_P2P
6570
6571         return ret;
6572
6573 }
6574
6575 static int rtw_cta_test_start(struct net_device *dev,
6576                                                            struct iw_request_info *info,
6577                                                            union iwreq_data *wrqu, char *extra)
6578 {
6579         int ret = 0;
6580         _adapter        *padapter = (_adapter *)rtw_netdev_priv(dev);
6581         DBG_871X("%s %s\n", __func__, extra);
6582         if (!strcmp(extra, "1"))
6583                 padapter->in_cta_test = 1;
6584         else
6585                 padapter->in_cta_test = 0;
6586
6587         if(padapter->in_cta_test)
6588         {
6589                 u32 v = rtw_read32(padapter, REG_RCR);
6590                 v &= ~(RCR_CBSSID_DATA | RCR_CBSSID_BCN );//| RCR_ADF
6591                 rtw_write32(padapter, REG_RCR, v);
6592                 DBG_871X("enable RCR_ADF\n");
6593         }
6594         else
6595         {
6596                 u32 v = rtw_read32(padapter, REG_RCR);
6597                 v |= RCR_CBSSID_DATA | RCR_CBSSID_BCN ;//| RCR_ADF
6598                 rtw_write32(padapter, REG_RCR, v);
6599                 DBG_871X("disable RCR_ADF\n");
6600         }
6601         return ret;
6602 }
6603
6604
6605 extern int rtw_change_ifname(_adapter *padapter, const char *ifname);
6606 static int rtw_rereg_nd_name(struct net_device *dev,
6607                                struct iw_request_info *info,
6608                                union iwreq_data *wrqu, char *extra)
6609 {
6610         int ret = 0;
6611         _adapter *padapter = rtw_netdev_priv(dev);
6612         struct rereg_nd_name_data *rereg_priv = &padapter->rereg_nd_name_priv;
6613         char new_ifname[IFNAMSIZ];
6614
6615         if(rereg_priv->old_ifname[0] == 0) {
6616                 char *reg_ifname;
6617 #ifdef CONFIG_CONCURRENT_MODE
6618                 if (padapter->isprimary)
6619                         reg_ifname = padapter->registrypriv.ifname;
6620                 else
6621 #endif
6622                 reg_ifname = padapter->registrypriv.if2name;
6623
6624                 strncpy(rereg_priv->old_ifname, reg_ifname, IFNAMSIZ);
6625                 rereg_priv->old_ifname[IFNAMSIZ-1] = 0;
6626         }
6627
6628         //DBG_871X("%s wrqu->data.length:%d\n", __FUNCTION__, wrqu->data.length);
6629         if(wrqu->data.length > IFNAMSIZ)
6630                 return -EFAULT;
6631
6632         if ( copy_from_user(new_ifname, wrqu->data.pointer, IFNAMSIZ) ) {
6633                 return -EFAULT;
6634         }
6635
6636         if( 0 == strcmp(rereg_priv->old_ifname, new_ifname) ) {
6637                 return ret;
6638         }
6639
6640         DBG_871X("%s new_ifname:%s\n", __FUNCTION__, new_ifname);
6641         if( 0 != (ret = rtw_change_ifname(padapter, new_ifname)) ) {
6642                 goto exit;
6643         }
6644
6645         if(_rtw_memcmp(rereg_priv->old_ifname, "disable%d", 9) == _TRUE) {
6646                 padapter->ledpriv.bRegUseLed= rereg_priv->old_bRegUseLed;
6647                 rtw_hal_sw_led_init(padapter);
6648                 //rtw_ips_mode_req(&padapter->pwrctrlpriv, rereg_priv->old_ips_mode);
6649         }
6650
6651         strncpy(rereg_priv->old_ifname, new_ifname, IFNAMSIZ);
6652         rereg_priv->old_ifname[IFNAMSIZ-1] = 0;
6653
6654         if(_rtw_memcmp(new_ifname, "disable%d", 9) == _TRUE) {
6655
6656                 DBG_871X("%s disable\n", __FUNCTION__);
6657                 // free network queue for Android's timming issue
6658                 rtw_free_network_queue(padapter, _TRUE);
6659
6660                 // close led
6661                 rtw_led_control(padapter, LED_CTL_POWER_OFF);
6662                 rereg_priv->old_bRegUseLed = padapter->ledpriv.bRegUseLed;
6663                 padapter->ledpriv.bRegUseLed= _FALSE;
6664                 rtw_hal_sw_led_deinit(padapter);
6665
6666                 // the interface is being "disabled", we can do deeper IPS
6667                 //rereg_priv->old_ips_mode = rtw_get_ips_mode_req(&padapter->pwrctrlpriv);
6668                 //rtw_ips_mode_req(&padapter->pwrctrlpriv, IPS_NORMAL);
6669         }
6670 exit:
6671         return ret;
6672
6673 }
6674
6675 #ifdef CONFIG_IOL
6676 #include <rtw_iol.h>
6677 #endif
6678 static int rtw_dbg_port(struct net_device *dev,
6679                                struct iw_request_info *info,
6680                                union iwreq_data *wrqu, char *extra)
6681 {
6682         _irqL irqL;
6683         int ret = 0;
6684         u8 major_cmd, minor_cmd;
6685         u16 arg;
6686         u32 extra_arg, *pdata, val32;
6687         struct sta_info *psta;
6688         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6689         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
6690         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
6691         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
6692         struct security_priv *psecuritypriv = &padapter->securitypriv;
6693         struct wlan_network *cur_network = &(pmlmepriv->cur_network);
6694         struct sta_priv *pstapriv = &padapter->stapriv;
6695
6696
6697         pdata = (u32*)&wrqu->data;
6698
6699         val32 = *pdata;
6700         arg = (u16)(val32&0x0000ffff);
6701         major_cmd = (u8)(val32>>24);
6702         minor_cmd = (u8)((val32>>16)&0x00ff);
6703
6704         extra_arg = *(pdata+1);
6705
6706         switch(major_cmd)
6707         {
6708                 case 0x70://read_reg
6709                         switch(minor_cmd)
6710                         {
6711                                 case 1:
6712                                         DBG_871X("rtw_read8(0x%x)=0x%02x\n", arg, rtw_read8(padapter, arg));
6713                                         break;
6714                                 case 2:
6715                                         DBG_871X("rtw_read16(0x%x)=0x%04x\n", arg, rtw_read16(padapter, arg));
6716                                         break;
6717                                 case 4:
6718                                         DBG_871X("rtw_read32(0x%x)=0x%08x\n", arg, rtw_read32(padapter, arg));
6719                                         break;
6720                         }
6721                         break;
6722                 case 0x71://write_reg
6723                         switch(minor_cmd)
6724                         {
6725                                 case 1:
6726                                         rtw_write8(padapter, arg, extra_arg);
6727                                         DBG_871X("rtw_write8(0x%x)=0x%02x\n", arg, rtw_read8(padapter, arg));
6728                                         break;
6729                                 case 2:
6730                                         rtw_write16(padapter, arg, extra_arg);
6731                                         DBG_871X("rtw_write16(0x%x)=0x%04x\n", arg, rtw_read16(padapter, arg));
6732                                         break;
6733                                 case 4:
6734                                         rtw_write32(padapter, arg, extra_arg);
6735                                         DBG_871X("rtw_write32(0x%x)=0x%08x\n", arg, rtw_read32(padapter, arg));
6736                                         break;
6737                         }
6738                         break;
6739                 case 0x72://read_bb
6740                         DBG_871X("read_bbreg(0x%x)=0x%x\n", arg, rtw_hal_read_bbreg(padapter, arg, 0xffffffff));
6741                         break;
6742                 case 0x73://write_bb
6743                         rtw_hal_write_bbreg(padapter, arg, 0xffffffff, extra_arg);
6744                         DBG_871X("write_bbreg(0x%x)=0x%x\n", arg, rtw_hal_read_bbreg(padapter, arg, 0xffffffff));
6745                         break;
6746                 case 0x74://read_rf
6747                         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));
6748                         break;
6749                 case 0x75://write_rf
6750                         rtw_hal_write_rfreg(padapter, minor_cmd, arg, 0xffffffff, extra_arg);
6751                         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));
6752                         break;
6753
6754                 case 0x76:
6755                         switch(minor_cmd)
6756                         {
6757                                 case 0x00: //normal mode,
6758                                         padapter->recvpriv.is_signal_dbg = 0;
6759                                         break;
6760                                 case 0x01: //dbg mode
6761                                         padapter->recvpriv.is_signal_dbg = 1;
6762                                         extra_arg = extra_arg>100?100:extra_arg;
6763                                         extra_arg = extra_arg<0?0:extra_arg;
6764                                         padapter->recvpriv.signal_strength_dbg=extra_arg;
6765                                         break;
6766                         }
6767                         break;
6768                 case 0x78: //IOL test
6769                         switch(minor_cmd)
6770                         {
6771                                 #ifdef CONFIG_IOL
6772                                 case 0x04: //LLT table initialization test
6773                                 {
6774                                         u8 page_boundary = 0xf9;
6775                                         {
6776                                                 struct xmit_frame       *xmit_frame;
6777
6778                                                 if((xmit_frame=rtw_IOL_accquire_xmit_frame(padapter)) == NULL) {
6779                                                         ret = -ENOMEM;
6780                                                         break;
6781                                                 }
6782
6783                                                 rtw_IOL_append_LLT_cmd(xmit_frame, page_boundary);
6784
6785
6786                                                 if(_SUCCESS != rtw_IOL_exec_cmds_sync(padapter, xmit_frame, 500,0) )
6787                                                         ret = -EPERM;
6788                                         }
6789                                 }
6790                                         break;
6791                                 case 0x05: //blink LED test
6792                                 {
6793                                         u16 reg = 0x4c;
6794                                         u32 blink_num = 50;
6795                                         u32 blink_delay_ms = 200;
6796                                         int i;
6797
6798                                         {
6799                                                 struct xmit_frame       *xmit_frame;
6800
6801                                                 if((xmit_frame=rtw_IOL_accquire_xmit_frame(padapter)) == NULL) {
6802                                                         ret = -ENOMEM;
6803                                                         break;
6804                                                 }
6805
6806                                                 for(i=0;i<blink_num;i++){
6807                                                         #ifdef CONFIG_IOL_NEW_GENERATION
6808                                                         rtw_IOL_append_WB_cmd(xmit_frame, reg, 0x00,0xff);
6809                                                         rtw_IOL_append_DELAY_MS_cmd(xmit_frame, blink_delay_ms);
6810                                                         rtw_IOL_append_WB_cmd(xmit_frame, reg, 0x08,0xff);
6811                                                         rtw_IOL_append_DELAY_MS_cmd(xmit_frame, blink_delay_ms);
6812                                                         #else
6813                                                         rtw_IOL_append_WB_cmd(xmit_frame, reg, 0x00);
6814                                                         rtw_IOL_append_DELAY_MS_cmd(xmit_frame, blink_delay_ms);
6815                                                         rtw_IOL_append_WB_cmd(xmit_frame, reg, 0x08);
6816                                                         rtw_IOL_append_DELAY_MS_cmd(xmit_frame, blink_delay_ms);
6817                                                         #endif
6818                                                 }
6819                                                 if(_SUCCESS != rtw_IOL_exec_cmds_sync(padapter, xmit_frame, (blink_delay_ms*blink_num*2)+200,0) )
6820                                                         ret = -EPERM;
6821                                         }
6822                                 }
6823                                         break;
6824
6825                                 case 0x06: //continuous wirte byte test
6826                                 {
6827                                         u16 reg = arg;
6828                                         u16 start_value = 0;
6829                                         u32 write_num = extra_arg;
6830                                         int i;
6831                                         u8 final;
6832
6833                                         {
6834                                                 struct xmit_frame       *xmit_frame;
6835
6836                                                 if((xmit_frame=rtw_IOL_accquire_xmit_frame(padapter)) == NULL) {
6837                                                         ret = -ENOMEM;
6838                                                         break;
6839                                                 }
6840
6841                                                 for(i=0;i<write_num;i++){
6842                                                         #ifdef CONFIG_IOL_NEW_GENERATION
6843                                                         rtw_IOL_append_WB_cmd(xmit_frame, reg, i+start_value,0xFF);
6844                                                         #else
6845                                                         rtw_IOL_append_WB_cmd(xmit_frame, reg, i+start_value);
6846                                                         #endif
6847                                                 }
6848                                                 if(_SUCCESS != rtw_IOL_exec_cmds_sync(padapter, xmit_frame, 5000,0))
6849                                                         ret = -EPERM;
6850                                         }
6851
6852                                         if(start_value+write_num-1 == (final=rtw_read8(padapter, reg)) ) {
6853                                                 DBG_871X("continuous IOL_CMD_WB_REG to 0x%x %u times Success, start:%u, final:%u\n", reg, write_num, start_value, final);
6854                                         } else {
6855                                                 DBG_871X("continuous IOL_CMD_WB_REG to 0x%x %u times Fail, start:%u, final:%u\n", reg, write_num, start_value, final);
6856                                         }
6857                                 }
6858                                         break;
6859
6860                                 case 0x07: //continuous wirte word test
6861                                 {
6862                                         u16 reg = arg;
6863                                         u16 start_value = 200;
6864                                         u32 write_num = extra_arg;
6865
6866                                         int i;
6867                                         u16 final;
6868
6869                                         {
6870                                                 struct xmit_frame       *xmit_frame;
6871
6872                                                 if((xmit_frame=rtw_IOL_accquire_xmit_frame(padapter)) == NULL) {
6873                                                         ret = -ENOMEM;
6874                                                         break;
6875                                                 }
6876
6877                                                 for(i=0;i<write_num;i++){
6878                                                         #ifdef CONFIG_IOL_NEW_GENERATION
6879                                                         rtw_IOL_append_WW_cmd(xmit_frame, reg, i+start_value,0xFFFF);
6880                                                         #else
6881                                                         rtw_IOL_append_WW_cmd(xmit_frame, reg, i+start_value);
6882                                                         #endif
6883                                                 }
6884                                                 if(_SUCCESS !=rtw_IOL_exec_cmds_sync(padapter, xmit_frame, 5000,0))
6885                                                         ret = -EPERM;
6886                                         }
6887
6888                                         if(start_value+write_num-1 == (final=rtw_read16(padapter, reg)) ) {
6889                                                 DBG_871X("continuous IOL_CMD_WW_REG to 0x%x %u times Success, start:%u, final:%u\n", reg, write_num, start_value, final);
6890                                         } else {
6891                                                 DBG_871X("continuous IOL_CMD_WW_REG to 0x%x %u times Fail, start:%u, final:%u\n", reg, write_num, start_value, final);
6892                                         }
6893                                 }
6894                                         break;
6895
6896                                 case 0x08: //continuous wirte dword test
6897                                 {
6898                                         u16 reg = arg;
6899                                         u32 start_value = 0x110000c7;
6900                                         u32 write_num = extra_arg;
6901
6902                                         int i;
6903                                         u32 final;
6904
6905                                         {
6906                                                 struct xmit_frame       *xmit_frame;
6907
6908                                                 if((xmit_frame=rtw_IOL_accquire_xmit_frame(padapter)) == NULL) {
6909                                                         ret = -ENOMEM;
6910                                                         break;
6911                                                 }
6912
6913                                                 for(i=0;i<write_num;i++){
6914                                                         #ifdef CONFIG_IOL_NEW_GENERATION
6915                                                         rtw_IOL_append_WD_cmd(xmit_frame, reg, i+start_value,0xFFFFFFFF);
6916                                                         #else
6917                                                         rtw_IOL_append_WD_cmd(xmit_frame, reg, i+start_value);
6918                                                         #endif
6919                                                 }
6920                                                 if(_SUCCESS !=rtw_IOL_exec_cmds_sync(padapter, xmit_frame, 5000,0))
6921                                                         ret = -EPERM;
6922
6923                                         }
6924
6925                                         if(start_value+write_num-1 == (final=rtw_read32(padapter, reg)) ) {
6926                                                 DBG_871X("continuous IOL_CMD_WD_REG to 0x%x %u times Success, start:%u, final:%u\n", reg, write_num, start_value, final);
6927                                         } else {
6928                                                 DBG_871X("continuous IOL_CMD_WD_REG to 0x%x %u times Fail, start:%u, final:%u\n", reg, write_num, start_value, final);
6929                                         }
6930                                 }
6931                                         break;
6932                                 #endif //CONFIG_IOL
6933                         }
6934                         break;
6935                 case 0x79:
6936                         {
6937                                 /*
6938                                 * dbg 0x79000000 [value], set RESP_TXAGC to + value, value:0~15
6939                                 * dbg 0x79010000 [value], set RESP_TXAGC to - value, value:0~15
6940                                 */
6941                                 u8 value =  extra_arg & 0x0f;
6942                                 u8 sign = minor_cmd;
6943                                 u16 write_value = 0;
6944
6945                                 DBG_871X("%s set RESP_TXAGC to %s %u\n", __func__, sign?"minus":"plus", value);
6946
6947                                 if (sign)
6948                                         value = value | 0x10;
6949
6950                                 write_value = value | (value << 5);
6951                                 rtw_write16(padapter, 0x6d9, write_value);
6952                         }
6953                         break;
6954                 case 0x7a:
6955                         receive_disconnect(padapter, pmlmeinfo->network.MacAddress
6956                                 , WLAN_REASON_EXPIRATION_CHK);
6957                         break;
6958                 case 0x7F:
6959                         switch(minor_cmd)
6960                         {
6961                                 case 0x0:
6962                                         DBG_871X("fwstate=0x%x\n", get_fwstate(pmlmepriv));
6963                                         break;
6964                                 case 0x01:
6965                                         DBG_871X("auth_alg=0x%x, enc_alg=0x%x, auth_type=0x%x, enc_type=0x%x\n",
6966                                                 psecuritypriv->dot11AuthAlgrthm, psecuritypriv->dot11PrivacyAlgrthm,
6967                                                 psecuritypriv->ndisauthtype, psecuritypriv->ndisencryptstatus);
6968                                         break;
6969                                 case 0x02:
6970                                         DBG_871X("pmlmeinfo->state=0x%x\n", pmlmeinfo->state);
6971                                         DBG_871X("DrvBcnEarly=%d\n", pmlmeext->DrvBcnEarly);
6972                                         DBG_871X("DrvBcnTimeOut=%d\n", pmlmeext->DrvBcnTimeOut);
6973                                         break;
6974                                 case 0x03:
6975                                         DBG_871X("qos_option=%d\n", pmlmepriv->qospriv.qos_option);
6976 #ifdef CONFIG_80211N_HT
6977                                         DBG_871X("ht_option=%d\n", pmlmepriv->htpriv.ht_option);
6978 #endif //CONFIG_80211N_HT
6979                                         break;
6980                                 case 0x04:
6981                                         DBG_871X("cur_ch=%d\n", pmlmeext->cur_channel);
6982                                         DBG_871X("cur_bw=%d\n", pmlmeext->cur_bwmode);
6983                                         DBG_871X("cur_ch_off=%d\n", pmlmeext->cur_ch_offset);
6984
6985                                         DBG_871X("oper_ch=%d\n", rtw_get_oper_ch(padapter));
6986                                         DBG_871X("oper_bw=%d\n", rtw_get_oper_bw(padapter));
6987                                         DBG_871X("oper_ch_offet=%d\n", rtw_get_oper_choffset(padapter));
6988
6989                                         break;
6990                                 case 0x05:
6991                                         psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
6992                                         if(psta)
6993                                         {
6994                                                 int i;
6995                                                 struct recv_reorder_ctrl *preorder_ctrl;
6996
6997                                                 DBG_871X("SSID=%s\n", cur_network->network.Ssid.Ssid);
6998                                                 DBG_871X("sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr));
6999                                                 DBG_871X("cur_channel=%d, cur_bwmode=%d, cur_ch_offset=%d\n", pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
7000                                                 DBG_871X("rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self);
7001                                                 DBG_871X("state=0x%x, aid=%d, macid=%d, raid=%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
7002 #ifdef CONFIG_80211N_HT
7003                                                 DBG_871X("qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
7004                                                 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);
7005                                                 DBG_871X("ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
7006                                                 DBG_871X("agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
7007 #endif //CONFIG_80211N_HT
7008
7009                                                 for(i=0;i<16;i++)
7010                                                 {
7011                                                         preorder_ctrl = &psta->recvreorder_ctrl[i];
7012                                                         if(preorder_ctrl->enable)
7013                                                         {
7014                                                                 DBG_871X("tid=%d, indicate_seq=%d\n", i, preorder_ctrl->indicate_seq);
7015                                                         }
7016                                                 }
7017
7018                                         }
7019                                         else
7020                                         {
7021                                                 DBG_871X("can't get sta's macaddr, cur_network's macaddr:" MAC_FMT "\n", MAC_ARG(cur_network->network.MacAddress));
7022                                         }
7023                                         break;
7024                                 case 0x06:
7025                                         {
7026                                                 u32     ODMFlag;
7027                                                 rtw_hal_get_hwreg(padapter, HW_VAR_DM_FLAG, (u8*)(&ODMFlag));
7028                                                 DBG_871X("(B)DMFlag=0x%x, arg=0x%x\n", ODMFlag, arg);
7029                                                 ODMFlag = (u32)(0x0f&arg);
7030                                                 DBG_871X("(A)DMFlag=0x%x\n", ODMFlag);
7031                                                 rtw_hal_set_hwreg(padapter, HW_VAR_DM_FLAG, (u8 *)(&ODMFlag));
7032                                         }
7033                                         break;
7034                                 case 0x07:
7035                                         DBG_871X("bSurpriseRemoved=%d, bDriverStopped=%d\n",
7036                                                 padapter->bSurpriseRemoved, padapter->bDriverStopped);
7037                                         break;
7038                                 case 0x08:
7039                                         {
7040                                                 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
7041                                                 struct recv_priv  *precvpriv = &padapter->recvpriv;
7042
7043                                                 DBG_871X("free_xmitbuf_cnt=%d, free_xmitframe_cnt=%d"
7044                                                         ", free_xmit_extbuf_cnt=%d, free_xframe_ext_cnt=%d"
7045                                                         ", free_recvframe_cnt=%d\n",
7046                                                         pxmitpriv->free_xmitbuf_cnt, pxmitpriv->free_xmitframe_cnt,
7047                                                         pxmitpriv->free_xmit_extbuf_cnt, pxmitpriv->free_xframe_ext_cnt,
7048                                                         precvpriv->free_recvframe_cnt);
7049                                                 #ifdef CONFIG_USB_HCI
7050                                                 DBG_871X("rx_urb_pending_cn=%d\n", precvpriv->rx_pending_cnt);
7051                                                 #endif
7052                                         }
7053                                         break;
7054                                 case 0x09:
7055                                         {
7056                                                 int i, j;
7057                                                 _list   *plist, *phead;
7058                                                 struct recv_reorder_ctrl *preorder_ctrl;
7059
7060 #ifdef CONFIG_AP_MODE
7061                                                 DBG_871X("sta_dz_bitmap=0x%x, tim_bitmap=0x%x\n", pstapriv->sta_dz_bitmap, pstapriv->tim_bitmap);
7062 #endif
7063                                                 _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
7064
7065                                                 for(i=0; i< NUM_STA; i++)
7066                                                 {
7067                                                         phead = &(pstapriv->sta_hash[i]);
7068                                                         plist = get_next(phead);
7069
7070                                                         while ((rtw_end_of_queue_search(phead, plist)) == _FALSE)
7071                                                         {
7072                                                                 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
7073
7074                                                                 plist = get_next(plist);
7075
7076                                                                 if(extra_arg == psta->aid)
7077                                                                 {
7078                                                                         DBG_871X("sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr));
7079                                                                         DBG_871X("rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self);
7080                                                                         DBG_871X("state=0x%x, aid=%d, macid=%d, raid=%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
7081 #ifdef CONFIG_80211N_HT
7082                                                                         DBG_871X("qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
7083                                                                         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);
7084                                                                         DBG_871X("ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
7085                                                                         DBG_871X("agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
7086 #endif //CONFIG_80211N_HT
7087
7088 #ifdef CONFIG_AP_MODE
7089                                                                         DBG_871X("capability=0x%x\n", psta->capability);
7090                                                                         DBG_871X("flags=0x%x\n", psta->flags);
7091                                                                         DBG_871X("wpa_psk=0x%x\n", psta->wpa_psk);
7092                                                                         DBG_871X("wpa2_group_cipher=0x%x\n", psta->wpa2_group_cipher);
7093                                                                         DBG_871X("wpa2_pairwise_cipher=0x%x\n", psta->wpa2_pairwise_cipher);
7094                                                                         DBG_871X("qos_info=0x%x\n", psta->qos_info);
7095 #endif
7096                                                                         DBG_871X("dot118021XPrivacy=0x%x\n", psta->dot118021XPrivacy);
7097
7098
7099
7100                                                                         for(j=0;j<16;j++)
7101                                                                         {
7102                                                                                 preorder_ctrl = &psta->recvreorder_ctrl[j];
7103                                                                                 if(preorder_ctrl->enable)
7104                                                                                 {
7105                                                                                         DBG_871X("tid=%d, indicate_seq=%d\n", j, preorder_ctrl->indicate_seq);
7106                                                                                 }
7107                                                                         }
7108
7109                                                                 }
7110
7111                                                         }
7112                                                 }
7113
7114                                                 _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
7115
7116                                         }
7117                                         break;
7118                                 case 0x0a:
7119                                         {
7120                                                 int max_mac_id = 0;
7121                                                 max_mac_id = rtw_search_max_mac_id( padapter);
7122                                                 printk("%s ==> max_mac_id = %d \n",__FUNCTION__,max_mac_id);
7123                                         }
7124                                         break;
7125                                 case 0x0b: //Enable=1, Disable=0 driver control vrtl_carrier_sense.
7126                                         {
7127                                                 //u8 driver_vcs_en; //Enable=1, Disable=0 driver control vrtl_carrier_sense.
7128                                                 //u8 driver_vcs_type;//force 0:disable VCS, 1:RTS-CTS, 2:CTS-to-self when vcs_en=1.
7129
7130                                                 if(arg == 0){
7131                                                         DBG_871X("disable driver ctrl vcs\n");
7132                                                         padapter->driver_vcs_en = 0;
7133                                                 }
7134                                                 else if(arg == 1){
7135                                                         DBG_871X("enable driver ctrl vcs = %d\n", extra_arg);
7136                                                         padapter->driver_vcs_en = 1;
7137
7138                                                         if(extra_arg>2)
7139                                                                 padapter->driver_vcs_type = 1;
7140                                                         else
7141                                                                 padapter->driver_vcs_type = extra_arg;
7142                                                 }
7143                                         }
7144                                         break;
7145                                 case 0x0c://dump rx/tx packet
7146                                         {
7147                                                 if(arg == 0){
7148                                                         DBG_871X("dump rx packet (%d)\n",extra_arg);
7149                                                         //pHalData->bDumpRxPkt =extra_arg;
7150                                                         rtw_hal_set_def_var(padapter, HAL_DEF_DBG_DUMP_RXPKT, &(extra_arg));
7151                                                 }
7152                                                 else if(arg==1){
7153                                                         DBG_871X("dump tx packet (%d)\n",extra_arg);
7154                                                         rtw_hal_set_def_var(padapter, HAL_DEF_DBG_DUMP_TXPKT, &(extra_arg));
7155                                                 }
7156                                         }
7157                                         break;
7158 #if 0
7159                                 case 0x0d://dump cam
7160                                         {
7161                                                 //u8 entry = (u8) extra_arg;
7162                                                 u8 entry=0;
7163                                                 //dump cam
7164                                                 for(entry=0;entry<32;entry++)
7165                                                         read_cam(padapter,entry);
7166                                         }
7167                                         break;
7168 #endif
7169                                 case 0x0e:
7170                                         {
7171                                                 if(arg == 0){
7172                                                         DBG_871X("disable driver ctrl rx_ampdu_factor\n");
7173                                                         padapter->driver_rx_ampdu_factor = 0xFF;
7174                                                 }
7175                                                 else if(arg == 1){
7176
7177                                                         DBG_871X("enable driver ctrl rx_ampdu_factor = %d\n", extra_arg);
7178
7179                                                         if((extra_arg & 0x03) > 0x03)
7180                                                                 padapter->driver_rx_ampdu_factor = 0xFF;
7181                                                         else
7182                                                                 padapter->driver_rx_ampdu_factor = extra_arg;
7183                                                 }
7184                                         }
7185                                         break;
7186                 #ifdef DBG_CONFIG_ERROR_DETECT
7187                                 case 0x0f:
7188                                                 {
7189                                                         if(extra_arg == 0){
7190                                                                 DBG_871X("###### silent reset test.......#####\n");
7191                                                                 rtw_hal_sreset_reset(padapter);
7192                                                         } else {
7193                                                                 HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
7194                                                                 struct sreset_priv *psrtpriv = &pHalData->srestpriv;
7195                                                                 psrtpriv->dbg_trigger_point = extra_arg;
7196                                                         }
7197
7198                                                 }
7199                                         break;
7200                                 case 0x15:
7201                                         {
7202                                                 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
7203                                                 DBG_871X("==>silent resete cnts:%d\n",pwrpriv->ips_enter_cnts);
7204                                         }
7205                                         break;
7206
7207                 #endif
7208
7209                                 case 0x10:// driver version display
7210                                         dump_drv_version(RTW_DBGDUMP);
7211                                         break;
7212                                 case 0x11://dump linked status
7213                                         {
7214                                                  linked_info_dump(padapter,extra_arg);
7215                                         }
7216                                         break;
7217 #ifdef CONFIG_80211N_HT
7218                                 case 0x12: //set rx_stbc
7219                                 {
7220                                         struct registry_priv    *pregpriv = &padapter->registrypriv;
7221                                         // 0: disable, bit(0):enable 2.4g, bit(1):enable 5g, 0x3: enable both 2.4g and 5g
7222                                         //default is set to enable 2.4GHZ for IOT issue with bufflao's AP at 5GHZ
7223                                         if( pregpriv && (extra_arg == 0 || extra_arg == 1|| extra_arg == 2 || extra_arg == 3))
7224                                         {
7225                                                 pregpriv->rx_stbc= extra_arg;
7226                                                 DBG_871X("set rx_stbc=%d\n",pregpriv->rx_stbc);
7227                                         }
7228                                         else
7229                                                 DBG_871X("get rx_stbc=%d\n",pregpriv->rx_stbc);
7230
7231                                 }
7232                                 break;
7233                                 case 0x13: //set ampdu_enable
7234                                 {
7235                                         struct registry_priv    *pregpriv = &padapter->registrypriv;
7236                                         // 0: disable, 0x1:enable (but wifi_spec should be 0), 0x2: force enable (don't care wifi_spec)
7237                                         if( pregpriv && extra_arg < 3 )
7238                                         {
7239                                                 pregpriv->ampdu_enable= extra_arg;
7240                                                 DBG_871X("set ampdu_enable=%d\n",pregpriv->ampdu_enable);
7241                                         }
7242                                         else
7243                                                 DBG_871X("get ampdu_enable=%d\n",pregpriv->ampdu_enable);
7244
7245                                 }
7246                                 break;
7247 #endif
7248                                 case 0x14: //get wifi_spec
7249                                 {
7250                                         struct registry_priv    *pregpriv = &padapter->registrypriv;
7251                                         DBG_871X("get wifi_spec=%d\n",pregpriv->wifi_spec);
7252
7253                                 }
7254                                 break;
7255                                 case 0x16:
7256                                 {
7257                                         if(arg == 0xff){
7258                                                 rtw_odm_dbg_comp_msg(RTW_DBGDUMP,padapter);
7259                                         }
7260                                         else{
7261                                                 u64 dbg_comp = (u64)extra_arg;
7262                                                 rtw_odm_dbg_comp_set(padapter, dbg_comp);
7263                                         }
7264                                 }
7265                                         break;
7266 #ifdef DBG_FIXED_CHAN
7267                                 case 0x17:
7268                                         {
7269                                                 struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
7270                                                 printk("===>  Fixed channel to %d \n",extra_arg);
7271                                                 pmlmeext->fixed_chan = extra_arg;
7272
7273                                         }
7274                                         break;
7275 #endif
7276                                 case 0x18:
7277                                         {
7278                                                 printk("===>  Switch USB Mode %d \n",extra_arg);
7279                                                 rtw_hal_set_hwreg(padapter, HW_VAR_USB_MODE, (u8 *)&extra_arg);
7280                                         }
7281                                         break;
7282 #ifdef CONFIG_80211N_HT
7283                                 case 0x19:
7284                                         {
7285                                                 struct registry_priv    *pregistrypriv = &padapter->registrypriv;
7286                                                 // extra_arg :
7287                                                 // BIT0: Enable VHT LDPC Rx, BIT1: Enable VHT LDPC Tx,
7288                                                 // BIT4: Enable HT LDPC Rx, BIT5: Enable HT LDPC Tx
7289                                                 if(arg == 0){
7290                                                         DBG_871X("driver disable LDPC\n");
7291                                                         pregistrypriv->ldpc_cap = 0x00;
7292                                                 }
7293                                                 else if(arg == 1){
7294                                                         DBG_871X("driver set LDPC cap = 0x%x\n", extra_arg);
7295                                                         pregistrypriv->ldpc_cap = (u8)(extra_arg&0x33);
7296                                                 }
7297                                         }
7298                                         break;
7299                                 case 0x1a:
7300                                         {
7301                                                 struct registry_priv    *pregistrypriv = &padapter->registrypriv;
7302                                                 // extra_arg :
7303                                                 // BIT0: Enable VHT STBC Rx, BIT1: Enable VHT STBC Tx,
7304                                                 // BIT4: Enable HT STBC Rx, BIT5: Enable HT STBC Tx
7305                                                 if(arg == 0){
7306                                                         DBG_871X("driver disable STBC\n");
7307                                                         pregistrypriv->stbc_cap = 0x00;
7308                                                 }
7309                                                 else if(arg == 1){
7310                                                         DBG_871X("driver set STBC cap = 0x%x\n", extra_arg);
7311                                                         pregistrypriv->stbc_cap = (u8)(extra_arg&0x33);
7312                                                 }
7313                                         }
7314                                         break;
7315 #endif //CONFIG_80211N_HT
7316                                 case 0x1b:
7317                                         {
7318                                                 struct registry_priv    *pregistrypriv = &padapter->registrypriv;
7319
7320                                                 if(arg == 0){
7321                                                         DBG_871X("disable driver ctrl max_rx_rate, reset to default_rate_set\n");
7322                                                         init_mlme_default_rate_set(padapter);
7323 #ifdef CONFIG_80211N_HT
7324                                                         pregistrypriv->ht_enable = (u8)rtw_ht_enable;
7325 #endif //CONFIG_80211N_HT
7326                                                 }
7327                                                 else if(arg == 1){
7328
7329                                                         int i;
7330                                                         u8 max_rx_rate;
7331
7332                                                         DBG_871X("enable driver ctrl max_rx_rate = 0x%x\n", extra_arg);
7333
7334                                                         max_rx_rate = (u8)extra_arg;
7335
7336                                                         if(max_rx_rate < 0xc) // max_rx_rate < MSC0 -> B or G -> disable HT
7337                                                         {
7338 #ifdef CONFIG_80211N_HT
7339                                                                 pregistrypriv->ht_enable = 0;
7340 #endif //CONFIG_80211N_HT
7341                                                                 for(i=0; i<NumRates; i++)
7342                                                                 {
7343                                                                         if(pmlmeext->datarate[i] > max_rx_rate)
7344                                                                                 pmlmeext->datarate[i] = 0xff;
7345                                                                 }
7346
7347                                                         }
7348 #ifdef CONFIG_80211N_HT
7349                                                         else if(max_rx_rate < 0x1c) // mcs0~mcs15
7350                                                         {
7351                                                                 u32 mcs_bitmap=0x0;
7352
7353                                                                 for(i=0; i<((max_rx_rate+1)-0xc); i++)
7354                                                                         mcs_bitmap |= BIT(i);
7355
7356                                                                 set_mcs_rate_by_mask(pmlmeext->default_supported_mcs_set, mcs_bitmap);
7357                                                         }
7358 #endif //CONFIG_80211N_HT
7359                                                 }
7360                                         }
7361                                         break;
7362                                 case 0x1c: //enable/disable driver control AMPDU Density for peer sta's rx
7363                                         {
7364                                                 if(arg == 0){
7365                                                         DBG_871X("disable driver ctrl ampdu density\n");
7366                                                         padapter->driver_ampdu_spacing = 0xFF;
7367                                                 }
7368                                                 else if(arg == 1){
7369
7370                                                         DBG_871X("enable driver ctrl ampdu density = %d\n", extra_arg);
7371
7372                                                         if((extra_arg & 0x07) > 0x07)
7373                                                                 padapter->driver_ampdu_spacing = 0xFF;
7374                                                         else
7375                                                                 padapter->driver_ampdu_spacing = extra_arg;
7376                                                 }
7377                                         }
7378                                         break;
7379 #ifdef CONFIG_BACKGROUND_NOISE_MONITOR
7380                                 case 0x1e:
7381                                         {
7382                                                 HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
7383                                                 PDM_ODM_T pDM_Odm = &pHalData->odmpriv;
7384                                                 u8 chan = rtw_get_oper_ch(padapter);
7385                                                 DBG_871X("===========================================\n");
7386                                                 ODM_InbandNoise_Monitor(pDM_Odm,_TRUE,0x1e,100);
7387                                                 DBG_871X("channel(%d),noise_a = %d, noise_b = %d , noise_all:%d \n",
7388                                                         chan,pDM_Odm->noise_level.noise[ODM_RF_PATH_A],
7389                                                         pDM_Odm->noise_level.noise[ODM_RF_PATH_B],
7390                                                         pDM_Odm->noise_level.noise_all);
7391                                                 DBG_871X("===========================================\n");
7392
7393                                         }
7394                                         break;
7395 #endif
7396                                 case 0x23:
7397                                         {
7398                                                 DBG_871X("turn %s the bNotifyChannelChange Variable\n",(extra_arg==1)?"on":"off");
7399                                                 padapter->bNotifyChannelChange = extra_arg;
7400                                                 break;
7401                                         }
7402                                 case 0x24:
7403                                         {
7404 #ifdef CONFIG_P2P
7405                                                 DBG_871X("turn %s the bShowGetP2PState Variable\n",(extra_arg==1)?"on":"off");
7406                                                 padapter->bShowGetP2PState = extra_arg;
7407 #endif // CONFIG_P2P
7408                                                 break;
7409                                         }
7410 #ifdef CONFIG_GPIO_API
7411                             case 0x25: //Get GPIO register
7412                                     {
7413                                             /*
7414                                             * dbg 0x7f250000 [gpio_num], Get gpio value, gpio_num:0~7
7415                                             */
7416
7417                                             int value;
7418                                             DBG_871X("Read GPIO Value  extra_arg = %d\n",extra_arg);
7419                                             value = rtw_get_gpio(dev,extra_arg);
7420                                             DBG_871X("Read GPIO Value = %d\n",value);
7421                                             break;
7422                                     }
7423                             case 0x26: //Set GPIO direction
7424                                     {
7425
7426                                             /* dbg 0x7f26000x [y], Set gpio direction,
7427                                             * x: gpio_num,4~7  y: indicate direction, 0~1
7428                                             */
7429
7430                                             int value;
7431                                             DBG_871X("Set GPIO Direction! arg = %d ,extra_arg=%d\n",arg ,extra_arg);
7432                                             value = rtw_config_gpio(dev, arg, extra_arg);
7433                                             DBG_871X("Set GPIO Direction %s \n",(value==-1)?"Fail!!!":"Success");
7434                                             break;
7435                                         }
7436                                 case 0x27: //Set GPIO output direction value
7437                                         {
7438                                                 /*
7439                                                 * dbg 0x7f27000x [y], Set gpio output direction value,
7440                                                 * x: gpio_num,4~7  y: indicate direction, 0~1
7441                                                 */
7442
7443                                                 int value;
7444                                                 DBG_871X("Set GPIO Value! arg = %d ,extra_arg=%d\n",arg ,extra_arg);
7445                                                 value = rtw_set_gpio_output_value(dev,arg,extra_arg);
7446                                                 DBG_871X("Set GPIO Value %s \n",(value==-1)?"Fail!!!":"Success");
7447                                                 break;
7448                                         }
7449 #endif
7450                                 case 0xaa:
7451                                         {
7452                                                 if((extra_arg & 0x7F)> 0x3F) extra_arg = 0xFF;
7453                                                 DBG_871X("chang data rate to :0x%02x\n",extra_arg);
7454                                                 padapter->fix_rate = extra_arg;
7455                                         }
7456                                         break;
7457                                 case 0xdd://registers dump , 0 for mac reg,1 for bb reg, 2 for rf reg
7458                                         {
7459                                                 if(extra_arg==0){
7460                                                         mac_reg_dump(RTW_DBGDUMP, padapter);
7461                                                 }
7462                                                 else if(extra_arg==1){
7463                                                         bb_reg_dump(RTW_DBGDUMP, padapter);
7464                                                 }
7465                                                 else if(extra_arg==2){
7466                                                         rf_reg_dump(RTW_DBGDUMP, padapter);
7467                                                 }
7468                                         }
7469                                         break;
7470
7471                                 case 0xee://turn on/off dynamic funcs
7472                                         {
7473                                                 u32 odm_flag;
7474
7475                                                 if(0xf==extra_arg){
7476                                                         rtw_hal_get_def_var(padapter, HAL_DEF_DBG_DM_FUNC,&odm_flag);
7477                                                         DBG_871X(" === DMFlag(0x%08x) === \n",odm_flag);
7478                                                         DBG_871X("extra_arg = 0  - disable all dynamic func \n");
7479                                                         DBG_871X("extra_arg = 1  - disable DIG- BIT(0)\n");
7480                                                         DBG_871X("extra_arg = 2  - disable High power - BIT(1)\n");
7481                                                         DBG_871X("extra_arg = 3  - disable tx power tracking - BIT(2)\n");
7482                                                         DBG_871X("extra_arg = 4  - disable BT coexistence - BIT(3)\n");
7483                                                         DBG_871X("extra_arg = 5  - disable antenna diversity - BIT(4)\n");
7484                                                         DBG_871X("extra_arg = 6  - enable all dynamic func \n");
7485                                                 }
7486                                                 else{
7487                                                         /*      extra_arg = 0  - disable all dynamic func
7488                                                                 extra_arg = 1  - disable DIG
7489                                                                 extra_arg = 2  - disable tx power tracking
7490                                                                 extra_arg = 3  - turn on all dynamic func
7491                                                         */
7492                                                         rtw_hal_set_def_var(padapter, HAL_DEF_DBG_DM_FUNC, &(extra_arg));
7493                                                         rtw_hal_get_def_var(padapter, HAL_DEF_DBG_DM_FUNC,&odm_flag);
7494                                                         DBG_871X(" === DMFlag(0x%08x) === \n",odm_flag);
7495                                                 }
7496                                         }
7497                                         break;
7498
7499                                 case 0xfd:
7500                                         rtw_write8(padapter, 0xc50, arg);
7501                                         DBG_871X("wr(0xc50)=0x%x\n", rtw_read8(padapter, 0xc50));
7502                                         rtw_write8(padapter, 0xc58, arg);
7503                                         DBG_871X("wr(0xc58)=0x%x\n", rtw_read8(padapter, 0xc58));
7504                                         break;
7505                                 case 0xfe:
7506                                         DBG_871X("rd(0xc50)=0x%x\n", rtw_read8(padapter, 0xc50));
7507                                         DBG_871X("rd(0xc58)=0x%x\n", rtw_read8(padapter, 0xc58));
7508                                         break;
7509                                 case 0xff:
7510                                         {
7511                                                 DBG_871X("dbg(0x210)=0x%x\n", rtw_read32(padapter, 0x210));
7512                                                 DBG_871X("dbg(0x608)=0x%x\n", rtw_read32(padapter, 0x608));
7513                                                 DBG_871X("dbg(0x280)=0x%x\n", rtw_read32(padapter, 0x280));
7514                                                 DBG_871X("dbg(0x284)=0x%x\n", rtw_read32(padapter, 0x284));
7515                                                 DBG_871X("dbg(0x288)=0x%x\n", rtw_read32(padapter, 0x288));
7516
7517                                                 DBG_871X("dbg(0x664)=0x%x\n", rtw_read32(padapter, 0x664));
7518
7519
7520                                                 DBG_871X("\n");
7521
7522                                                 DBG_871X("dbg(0x430)=0x%x\n", rtw_read32(padapter, 0x430));
7523                                                 DBG_871X("dbg(0x438)=0x%x\n", rtw_read32(padapter, 0x438));
7524
7525                                                 DBG_871X("dbg(0x440)=0x%x\n", rtw_read32(padapter, 0x440));
7526
7527                                                 DBG_871X("dbg(0x458)=0x%x\n", rtw_read32(padapter, 0x458));
7528
7529                                                 DBG_871X("dbg(0x484)=0x%x\n", rtw_read32(padapter, 0x484));
7530                                                 DBG_871X("dbg(0x488)=0x%x\n", rtw_read32(padapter, 0x488));
7531
7532                                                 DBG_871X("dbg(0x444)=0x%x\n", rtw_read32(padapter, 0x444));
7533                                                 DBG_871X("dbg(0x448)=0x%x\n", rtw_read32(padapter, 0x448));
7534                                                 DBG_871X("dbg(0x44c)=0x%x\n", rtw_read32(padapter, 0x44c));
7535                                                 DBG_871X("dbg(0x450)=0x%x\n", rtw_read32(padapter, 0x450));
7536                                         }
7537                                         break;
7538                         }
7539                         break;
7540                 default:
7541                         DBG_871X("error dbg cmd!\n");
7542                         break;
7543         }
7544
7545
7546         return ret;
7547
7548 }
7549
7550 static int wpa_set_param(struct net_device *dev, u8 name, u32 value)
7551 {
7552         uint ret=0;
7553         u32 flags;
7554         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
7555
7556         switch (name){
7557         case IEEE_PARAM_WPA_ENABLED:
7558
7559                 padapter->securitypriv.dot11AuthAlgrthm= dot11AuthAlgrthm_8021X; //802.1x
7560
7561                 //ret = ieee80211_wpa_enable(ieee, value);
7562
7563                 switch((value)&0xff)
7564                 {
7565                         case 1 : //WPA
7566                         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPAPSK; //WPA_PSK
7567                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
7568                                 break;
7569                         case 2: //WPA2
7570                         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPA2PSK; //WPA2_PSK
7571                         padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
7572                                 break;
7573                 }
7574
7575                 RT_TRACE(_module_rtl871x_ioctl_os_c,_drv_info_,("wpa_set_param:padapter->securitypriv.ndisauthtype=%d\n", padapter->securitypriv.ndisauthtype));
7576
7577                 break;
7578
7579         case IEEE_PARAM_TKIP_COUNTERMEASURES:
7580                 //ieee->tkip_countermeasures=value;
7581                 break;
7582
7583         case IEEE_PARAM_DROP_UNENCRYPTED:
7584         {
7585                 /* HACK:
7586                  *
7587                  * wpa_supplicant calls set_wpa_enabled when the driver
7588                  * is loaded and unloaded, regardless of if WPA is being
7589                  * used.  No other calls are made which can be used to
7590                  * determine if encryption will be used or not prior to
7591                  * association being expected.  If encryption is not being
7592                  * used, drop_unencrypted is set to false, else true -- we
7593                  * can use this to determine if the CAP_PRIVACY_ON bit should
7594                  * be set.
7595                  */
7596
7597 #if 0
7598                 struct ieee80211_security sec = {
7599                         .flags = SEC_ENABLED,
7600                         .enabled = value,
7601                 };
7602                 ieee->drop_unencrypted = value;
7603                 /* We only change SEC_LEVEL for open mode. Others
7604                  * are set by ipw_wpa_set_encryption.
7605                  */
7606                 if (!value) {
7607                         sec.flags |= SEC_LEVEL;
7608                         sec.level = SEC_LEVEL_0;
7609                 }
7610                 else {
7611                         sec.flags |= SEC_LEVEL;
7612                         sec.level = SEC_LEVEL_1;
7613                 }
7614                 if (ieee->set_security)
7615                         ieee->set_security(ieee->dev, &sec);
7616 #endif
7617                 break;
7618
7619         }
7620         case IEEE_PARAM_PRIVACY_INVOKED:
7621
7622                 //ieee->privacy_invoked=value;
7623
7624                 break;
7625
7626         case IEEE_PARAM_AUTH_ALGS:
7627
7628                 ret = wpa_set_auth_algs(dev, value);
7629
7630                 break;
7631
7632         case IEEE_PARAM_IEEE_802_1X:
7633
7634                 //ieee->ieee802_1x=value;
7635
7636                 break;
7637
7638         case IEEE_PARAM_WPAX_SELECT:
7639
7640                 // added for WPA2 mixed mode
7641                 //DBG_871X(KERN_WARNING "------------------------>wpax value = %x\n", value);
7642                 /*
7643                 spin_lock_irqsave(&ieee->wpax_suitlist_lock,flags);
7644                 ieee->wpax_type_set = 1;
7645                 ieee->wpax_type_notify = value;
7646                 spin_unlock_irqrestore(&ieee->wpax_suitlist_lock,flags);
7647                 */
7648
7649                 break;
7650
7651         default:
7652
7653
7654
7655                 ret = -EOPNOTSUPP;
7656
7657
7658                 break;
7659
7660         }
7661
7662         return ret;
7663
7664 }
7665
7666 static int wpa_mlme(struct net_device *dev, u32 command, u32 reason)
7667 {
7668         int ret = 0;
7669         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
7670
7671         switch (command)
7672         {
7673                 case IEEE_MLME_STA_DEAUTH:
7674
7675                         if(!rtw_set_802_11_disassociate(padapter))
7676                                 ret = -1;
7677
7678                         break;
7679
7680                 case IEEE_MLME_STA_DISASSOC:
7681
7682                         if(!rtw_set_802_11_disassociate(padapter))
7683                                 ret = -1;
7684
7685                         break;
7686
7687                 default:
7688                         ret = -EOPNOTSUPP;
7689                         break;
7690         }
7691
7692         return ret;
7693
7694 }
7695
7696 static int wpa_supplicant_ioctl(struct net_device *dev, struct iw_point *p)
7697 {
7698         struct ieee_param *param;
7699         uint ret=0;
7700
7701         //down(&ieee->wx_sem);
7702
7703         if (p->length < sizeof(struct ieee_param) || !p->pointer){
7704                 ret = -EINVAL;
7705                 goto out;
7706         }
7707
7708         param = (struct ieee_param *)rtw_malloc(p->length);
7709         if (param == NULL)
7710         {
7711                 ret = -ENOMEM;
7712                 goto out;
7713         }
7714
7715         if (copy_from_user(param, p->pointer, p->length))
7716         {
7717                 rtw_mfree((u8*)param, p->length);
7718                 ret = -EFAULT;
7719                 goto out;
7720         }
7721
7722         switch (param->cmd) {
7723
7724         case IEEE_CMD_SET_WPA_PARAM:
7725                 ret = wpa_set_param(dev, param->u.wpa_param.name, param->u.wpa_param.value);
7726                 break;
7727
7728         case IEEE_CMD_SET_WPA_IE:
7729                 //ret = wpa_set_wpa_ie(dev, param, p->length);
7730                 ret =  rtw_set_wpa_ie((_adapter *)rtw_netdev_priv(dev), (char*)param->u.wpa_ie.data, (u16)param->u.wpa_ie.len);
7731                 break;
7732
7733         case IEEE_CMD_SET_ENCRYPTION:
7734                 ret = wpa_set_encryption(dev, param, p->length);
7735                 break;
7736
7737         case IEEE_CMD_MLME:
7738                 ret = wpa_mlme(dev, param->u.mlme.command, param->u.mlme.reason_code);
7739                 break;
7740
7741         default:
7742                 DBG_871X("Unknown WPA supplicant request: %d\n", param->cmd);
7743                 ret = -EOPNOTSUPP;
7744                 break;
7745
7746         }
7747
7748         if (ret == 0 && copy_to_user(p->pointer, param, p->length))
7749                 ret = -EFAULT;
7750
7751         rtw_mfree((u8 *)param, p->length);
7752
7753 out:
7754
7755         //up(&ieee->wx_sem);
7756
7757         return ret;
7758
7759 }
7760
7761 #ifdef CONFIG_AP_MODE
7762 static int rtw_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len)
7763 {
7764         int ret = 0;
7765         u32 wep_key_idx, wep_key_len,wep_total_len;
7766         NDIS_802_11_WEP  *pwep = NULL;
7767         struct sta_info *psta = NULL, *pbcmc_sta = NULL;
7768         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
7769         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
7770         struct security_priv* psecuritypriv=&(padapter->securitypriv);
7771         struct sta_priv *pstapriv = &padapter->stapriv;
7772
7773         DBG_871X("%s\n", __FUNCTION__);
7774
7775         param->u.crypt.err = 0;
7776         param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
7777
7778         //sizeof(struct ieee_param) = 64 bytes;
7779         //if (param_len !=  (u32) ((u8 *) param->u.crypt.key - (u8 *) param) + param->u.crypt.key_len)
7780         if (param_len !=  sizeof(struct ieee_param) + param->u.crypt.key_len)
7781         {
7782                 ret =  -EINVAL;
7783                 goto exit;
7784         }
7785
7786         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
7787             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
7788             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff)
7789         {
7790                 if (param->u.crypt.idx >= WEP_KEYS)
7791                 {
7792                         ret = -EINVAL;
7793                         goto exit;
7794                 }
7795         }
7796         else
7797         {
7798                 psta = rtw_get_stainfo(pstapriv, param->sta_addr);
7799                 if(!psta)
7800                 {
7801                         //ret = -EINVAL;
7802                         DBG_871X("rtw_set_encryption(), sta has already been removed or never been added\n");
7803                         goto exit;
7804                 }
7805         }
7806
7807         if (strcmp(param->u.crypt.alg, "none") == 0 && (psta==NULL))
7808         {
7809                 //todo:clear default encryption keys
7810
7811                 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
7812                 psecuritypriv->ndisencryptstatus = Ndis802_11EncryptionDisabled;
7813                 psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
7814                 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
7815
7816                 DBG_871X("clear default encryption keys, keyid=%d\n", param->u.crypt.idx);
7817
7818                 goto exit;
7819         }
7820
7821
7822         if (strcmp(param->u.crypt.alg, "WEP") == 0 && (psta==NULL))
7823         {
7824                 DBG_871X("r871x_set_encryption, crypt.alg = WEP\n");
7825
7826                 wep_key_idx = param->u.crypt.idx;
7827                 wep_key_len = param->u.crypt.key_len;
7828
7829                 DBG_871X("r871x_set_encryption, wep_key_idx=%d, len=%d\n", wep_key_idx, wep_key_len);
7830
7831                 if((wep_key_idx >= WEP_KEYS) || (wep_key_len<=0))
7832                 {
7833                         ret = -EINVAL;
7834                         goto exit;
7835                 }
7836
7837
7838                 if (wep_key_len > 0)
7839                 {
7840                         wep_key_len = wep_key_len <= 5 ? 5 : 13;
7841                         wep_total_len = wep_key_len + FIELD_OFFSET(NDIS_802_11_WEP, KeyMaterial);
7842                         pwep =(NDIS_802_11_WEP *)rtw_malloc(wep_total_len);
7843                         if(pwep == NULL){
7844                                 DBG_871X(" r871x_set_encryption: pwep allocate fail !!!\n");
7845                                 goto exit;
7846                         }
7847
7848                         _rtw_memset(pwep, 0, wep_total_len);
7849
7850                         pwep->KeyLength = wep_key_len;
7851                         pwep->Length = wep_total_len;
7852
7853                 }
7854
7855                 pwep->KeyIndex = wep_key_idx;
7856
7857                 _rtw_memcpy(pwep->KeyMaterial,  param->u.crypt.key, pwep->KeyLength);
7858
7859                 if(param->u.crypt.set_tx)
7860                 {
7861                         DBG_871X("wep, set_tx=1\n");
7862
7863                         psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
7864                         psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled;
7865                         psecuritypriv->dot11PrivacyAlgrthm=_WEP40_;
7866                         psecuritypriv->dot118021XGrpPrivacy=_WEP40_;
7867
7868                         if(pwep->KeyLength==13)
7869                         {
7870                                 psecuritypriv->dot11PrivacyAlgrthm=_WEP104_;
7871                                 psecuritypriv->dot118021XGrpPrivacy=_WEP104_;
7872                         }
7873
7874
7875                         psecuritypriv->dot11PrivacyKeyIndex = wep_key_idx;
7876
7877                         _rtw_memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength);
7878
7879                         psecuritypriv->dot11DefKeylen[wep_key_idx]=pwep->KeyLength;
7880
7881                         rtw_ap_set_wep_key(padapter, pwep->KeyMaterial, pwep->KeyLength, wep_key_idx, 1);
7882                 }
7883                 else
7884                 {
7885                         DBG_871X("wep, set_tx=0\n");
7886
7887                         //don't update "psecuritypriv->dot11PrivacyAlgrthm" and
7888                         //"psecuritypriv->dot11PrivacyKeyIndex=keyid", but can rtw_set_key to cam
7889
7890                       _rtw_memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength);
7891
7892                         psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->KeyLength;
7893
7894                         rtw_ap_set_wep_key(padapter, pwep->KeyMaterial, pwep->KeyLength, wep_key_idx, 0);
7895                 }
7896
7897                 goto exit;
7898
7899         }
7900
7901
7902         if(!psta && check_fwstate(pmlmepriv, WIFI_AP_STATE)) // //group key
7903         {
7904                 if(param->u.crypt.set_tx ==1)
7905                 {
7906                         if(strcmp(param->u.crypt.alg, "WEP") == 0)
7907                         {
7908                                 DBG_871X("%s, set group_key, WEP\n", __FUNCTION__);
7909
7910                                 _rtw_memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
7911
7912                                 psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
7913                                 if(param->u.crypt.key_len==13)
7914                                 {
7915                                                 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
7916                                 }
7917
7918                         }
7919                         else if(strcmp(param->u.crypt.alg, "TKIP") == 0)
7920                         {
7921                                 DBG_871X("%s, set group_key, TKIP\n", __FUNCTION__);
7922
7923                                 psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
7924
7925                                 _rtw_memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
7926
7927                                 //DEBUG_ERR("set key length :param->u.crypt.key_len=%d\n", param->u.crypt.key_len);
7928                                 //set mic key
7929                                 _rtw_memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8);
7930                                 _rtw_memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8);
7931
7932                                 psecuritypriv->busetkipkey = _TRUE;
7933
7934                         }
7935                         else if(strcmp(param->u.crypt.alg, "CCMP") == 0)
7936                         {
7937                                 DBG_871X("%s, set group_key, CCMP\n", __FUNCTION__);
7938
7939                                 psecuritypriv->dot118021XGrpPrivacy = _AES_;
7940
7941                                 _rtw_memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
7942                         }
7943                         else
7944                         {
7945                                 DBG_871X("%s, set group_key, none\n", __FUNCTION__);
7946
7947                                 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
7948                         }
7949
7950                         psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
7951
7952                         psecuritypriv->binstallGrpkey = _TRUE;
7953
7954                         psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;//!!!
7955
7956                         rtw_ap_set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx);
7957
7958                         pbcmc_sta=rtw_get_bcmc_stainfo(padapter);
7959                         if(pbcmc_sta)
7960                         {
7961                                 pbcmc_sta->ieee8021x_blocked = _FALSE;
7962                                 pbcmc_sta->dot118021XPrivacy= psecuritypriv->dot118021XGrpPrivacy;//rx will use bmc_sta's dot118021XPrivacy
7963                         }
7964
7965                 }
7966
7967                 goto exit;
7968
7969         }
7970
7971         if(psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X && psta) // psk/802_1x
7972         {
7973                 if(check_fwstate(pmlmepriv, WIFI_AP_STATE))
7974                 {
7975                         if(param->u.crypt.set_tx ==1)
7976                         {
7977                                 _rtw_memcpy(psta->dot118021x_UncstKey.skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
7978
7979                                 if(strcmp(param->u.crypt.alg, "WEP") == 0)
7980                                 {
7981                                         DBG_871X("%s, set pairwise key, WEP\n", __FUNCTION__);
7982
7983                                         psta->dot118021XPrivacy = _WEP40_;
7984                                         if(param->u.crypt.key_len==13)
7985                                         {
7986                                                 psta->dot118021XPrivacy = _WEP104_;
7987                                         }
7988                                 }
7989                                 else if(strcmp(param->u.crypt.alg, "TKIP") == 0)
7990                                 {
7991                                         DBG_871X("%s, set pairwise key, TKIP\n", __FUNCTION__);
7992
7993                                         psta->dot118021XPrivacy = _TKIP_;
7994
7995                                         //DEBUG_ERR("set key length :param->u.crypt.key_len=%d\n", param->u.crypt.key_len);
7996                                         //set mic key
7997                                         _rtw_memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8);
7998                                         _rtw_memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8);
7999
8000                                         psecuritypriv->busetkipkey = _TRUE;
8001
8002                                 }
8003                                 else if(strcmp(param->u.crypt.alg, "CCMP") == 0)
8004                                 {
8005
8006                                         DBG_871X("%s, set pairwise key, CCMP\n", __FUNCTION__);
8007
8008                                         psta->dot118021XPrivacy = _AES_;
8009                                 }
8010                                 else
8011                                 {
8012                                         DBG_871X("%s, set pairwise key, none\n", __FUNCTION__);
8013
8014                                         psta->dot118021XPrivacy = _NO_PRIVACY_;
8015                                 }
8016
8017                                 rtw_ap_set_pairwise_key(padapter, psta);
8018
8019                                 psta->ieee8021x_blocked = _FALSE;
8020
8021                         }
8022                         else//group key???
8023                         {
8024                                 if(strcmp(param->u.crypt.alg, "WEP") == 0)
8025                                 {
8026                                         _rtw_memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
8027
8028                                         psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
8029                                         if(param->u.crypt.key_len==13)
8030                                         {
8031                                                 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
8032                                         }
8033                                 }
8034                                 else if(strcmp(param->u.crypt.alg, "TKIP") == 0)
8035                                 {
8036                                         psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
8037
8038                                         _rtw_memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
8039
8040                                         //DEBUG_ERR("set key length :param->u.crypt.key_len=%d\n", param->u.crypt.key_len);
8041                                         //set mic key
8042                                         _rtw_memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8);
8043                                         _rtw_memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8);
8044
8045                                         psecuritypriv->busetkipkey = _TRUE;
8046
8047                                 }
8048                                 else if(strcmp(param->u.crypt.alg, "CCMP") == 0)
8049                                 {
8050                                         psecuritypriv->dot118021XGrpPrivacy = _AES_;
8051
8052                                         _rtw_memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,  param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
8053                                 }
8054                                 else
8055                                 {
8056                                         psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
8057                                 }
8058
8059                                 psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
8060
8061                                 psecuritypriv->binstallGrpkey = _TRUE;
8062
8063                                 psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;//!!!
8064
8065                                 rtw_ap_set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx);
8066
8067                                 pbcmc_sta=rtw_get_bcmc_stainfo(padapter);
8068                                 if(pbcmc_sta)
8069                                 {
8070                                         pbcmc_sta->ieee8021x_blocked = _FALSE;
8071                                         pbcmc_sta->dot118021XPrivacy= psecuritypriv->dot118021XGrpPrivacy;//rx will use bmc_sta's dot118021XPrivacy
8072                                 }
8073
8074                         }
8075
8076                 }
8077
8078         }
8079
8080 exit:
8081
8082         if(pwep)
8083         {
8084                 rtw_mfree((u8 *)pwep, wep_total_len);
8085         }
8086
8087         return ret;
8088
8089 }
8090
8091 static int rtw_set_beacon(struct net_device *dev, struct ieee_param *param, int len)
8092 {
8093         int ret=0;
8094         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
8095         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
8096         struct sta_priv *pstapriv = &padapter->stapriv;
8097         unsigned char *pbuf = param->u.bcn_ie.buf;
8098
8099
8100         DBG_871X("%s, len=%d\n", __FUNCTION__, len);
8101
8102         if(check_fwstate(pmlmepriv, WIFI_AP_STATE) != _TRUE)
8103                 return -EINVAL;
8104
8105         _rtw_memcpy(&pstapriv->max_num_sta, param->u.bcn_ie.reserved, 2);
8106
8107         if((pstapriv->max_num_sta>NUM_STA) || (pstapriv->max_num_sta<=0))
8108                 pstapriv->max_num_sta = NUM_STA;
8109
8110
8111         if(rtw_check_beacon_data(padapter, pbuf,  (len-12-2)) == _SUCCESS)// 12 = param header, 2:no packed
8112                 ret = 0;
8113         else
8114                 ret = -EINVAL;
8115
8116
8117         return ret;
8118
8119 }
8120
8121 static int rtw_hostapd_sta_flush(struct net_device *dev)
8122 {
8123         //_irqL irqL;
8124         //_list *phead, *plist;
8125         int ret=0;
8126         //struct sta_info *psta = NULL;
8127         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
8128         //struct sta_priv *pstapriv = &padapter->stapriv;
8129
8130         DBG_871X("%s\n", __FUNCTION__);
8131
8132         flush_all_cam_entry(padapter);  //clear CAM
8133
8134         ret = rtw_sta_flush(padapter);
8135
8136         return ret;
8137
8138 }
8139
8140 static int rtw_add_sta(struct net_device *dev, struct ieee_param *param)
8141 {
8142         _irqL irqL;
8143         int ret=0;
8144         struct sta_info *psta = NULL;
8145         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
8146         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
8147         struct sta_priv *pstapriv = &padapter->stapriv;
8148
8149         DBG_871X("rtw_add_sta(aid=%d)=" MAC_FMT "\n", param->u.add_sta.aid, MAC_ARG(param->sta_addr));
8150
8151         if(check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != _TRUE)
8152         {
8153                 return -EINVAL;
8154         }
8155
8156         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
8157             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
8158             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff)
8159         {
8160                 return -EINVAL;
8161         }
8162
8163 /*
8164         psta = rtw_get_stainfo(pstapriv, param->sta_addr);
8165         if(psta)
8166         {
8167                 DBG_871X("rtw_add_sta(), free has been added psta=%p\n", psta);
8168                 _enter_critical_bh(&(pstapriv->sta_hash_lock), &irqL);
8169                 rtw_free_stainfo(padapter,  psta);
8170                 _exit_critical_bh(&(pstapriv->sta_hash_lock), &irqL);
8171
8172                 psta = NULL;
8173         }
8174 */
8175         //psta = rtw_alloc_stainfo(pstapriv, param->sta_addr);
8176         psta = rtw_get_stainfo(pstapriv, param->sta_addr);
8177         if(psta)
8178         {
8179                 int flags = param->u.add_sta.flags;
8180
8181                 //DBG_871X("rtw_add_sta(), init sta's variables, psta=%p\n", psta);
8182
8183                 psta->aid = param->u.add_sta.aid;//aid=1~2007
8184
8185                 _rtw_memcpy(psta->bssrateset, param->u.add_sta.tx_supp_rates, 16);
8186
8187
8188                 //check wmm cap.
8189                 if(WLAN_STA_WME&flags)
8190                         psta->qos_option = 1;
8191                 else
8192                         psta->qos_option = 0;
8193
8194                 if(pmlmepriv->qospriv.qos_option == 0)
8195                         psta->qos_option = 0;
8196
8197
8198 #ifdef CONFIG_80211N_HT
8199                 //chec 802.11n ht cap.
8200                 if(WLAN_STA_HT&flags)
8201                 {
8202                         psta->htpriv.ht_option = _TRUE;
8203                         psta->qos_option = 1;
8204                         _rtw_memcpy((void*)&psta->htpriv.ht_cap, (void*)&param->u.add_sta.ht_cap, sizeof(struct rtw_ieee80211_ht_cap));
8205                 }
8206                 else
8207                 {
8208                         psta->htpriv.ht_option = _FALSE;
8209                 }
8210
8211                 if(pmlmepriv->htpriv.ht_option == _FALSE)
8212                         psta->htpriv.ht_option = _FALSE;
8213 #endif
8214
8215
8216                 update_sta_info_apmode(padapter, psta);
8217
8218
8219         }
8220         else
8221         {
8222                 ret = -ENOMEM;
8223         }
8224
8225         return ret;
8226
8227 }
8228
8229 static int rtw_del_sta(struct net_device *dev, struct ieee_param *param)
8230 {
8231         _irqL irqL;
8232         int ret=0;
8233         struct sta_info *psta = NULL;
8234         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
8235         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
8236         struct sta_priv *pstapriv = &padapter->stapriv;
8237
8238         DBG_871X("rtw_del_sta=" MAC_FMT "\n", MAC_ARG(param->sta_addr));
8239
8240         if(check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != _TRUE)
8241         {
8242                 return -EINVAL;
8243         }
8244
8245         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
8246             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
8247             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff)
8248         {
8249                 return -EINVAL;
8250         }
8251
8252         psta = rtw_get_stainfo(pstapriv, param->sta_addr);
8253         if(psta)
8254         {
8255                 u8 updated=_FALSE;
8256
8257                 //DBG_871X("free psta=%p, aid=%d\n", psta, psta->aid);
8258
8259                 _enter_critical_bh(&pstapriv->asoc_list_lock, &irqL);
8260                 if(rtw_is_list_empty(&psta->asoc_list)==_FALSE)
8261                 {
8262                         rtw_list_delete(&psta->asoc_list);
8263                         pstapriv->asoc_list_cnt--;
8264                         updated = ap_free_sta(padapter, psta, _TRUE, WLAN_REASON_DEAUTH_LEAVING);
8265
8266                 }
8267                 _exit_critical_bh(&pstapriv->asoc_list_lock, &irqL);
8268
8269                 associated_clients_update(padapter, updated);
8270
8271                 psta = NULL;
8272
8273         }
8274         else
8275         {
8276                 DBG_871X("rtw_del_sta(), sta has already been removed or never been added\n");
8277
8278                 //ret = -1;
8279         }
8280
8281
8282         return ret;
8283
8284 }
8285
8286 static int rtw_ioctl_get_sta_data(struct net_device *dev, struct ieee_param *param, int len)
8287 {
8288         int ret=0;
8289         struct sta_info *psta = NULL;
8290         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
8291         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
8292         struct sta_priv *pstapriv = &padapter->stapriv;
8293         struct ieee_param_ex *param_ex = (struct ieee_param_ex *)param;
8294         struct sta_data *psta_data = (struct sta_data *)param_ex->data;
8295
8296         DBG_871X("rtw_ioctl_get_sta_info, sta_addr: " MAC_FMT "\n", MAC_ARG(param_ex->sta_addr));
8297
8298         if(check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != _TRUE)
8299         {
8300                 return -EINVAL;
8301         }
8302
8303         if (param_ex->sta_addr[0] == 0xff && param_ex->sta_addr[1] == 0xff &&
8304             param_ex->sta_addr[2] == 0xff && param_ex->sta_addr[3] == 0xff &&
8305             param_ex->sta_addr[4] == 0xff && param_ex->sta_addr[5] == 0xff)
8306         {
8307                 return -EINVAL;
8308         }
8309
8310         psta = rtw_get_stainfo(pstapriv, param_ex->sta_addr);
8311         if(psta)
8312         {
8313 #if 0
8314                 struct {
8315                         u16 aid;
8316                         u16 capability;
8317                         int flags;
8318                         u32 sta_set;
8319                         u8 tx_supp_rates[16];
8320                         u32 tx_supp_rates_len;
8321                         struct rtw_ieee80211_ht_cap ht_cap;
8322                         u64     rx_pkts;
8323                         u64     rx_bytes;
8324                         u64     rx_drops;
8325                         u64     tx_pkts;
8326                         u64     tx_bytes;
8327                         u64     tx_drops;
8328                 } get_sta;
8329 #endif
8330                 psta_data->aid = (u16)psta->aid;
8331                 psta_data->capability = psta->capability;
8332                 psta_data->flags = psta->flags;
8333
8334 /*
8335                 nonerp_set : BIT(0)
8336                 no_short_slot_time_set : BIT(1)
8337                 no_short_preamble_set : BIT(2)
8338                 no_ht_gf_set : BIT(3)
8339                 no_ht_set : BIT(4)
8340                 ht_20mhz_set : BIT(5)
8341 */
8342
8343                 psta_data->sta_set =((psta->nonerp_set) |
8344                                                         (psta->no_short_slot_time_set <<1) |
8345                                                         (psta->no_short_preamble_set <<2) |
8346                                                         (psta->no_ht_gf_set <<3) |
8347                                                         (psta->no_ht_set <<4) |
8348                                                         (psta->ht_20mhz_set <<5));
8349
8350                 psta_data->tx_supp_rates_len =  psta->bssratelen;
8351                 _rtw_memcpy(psta_data->tx_supp_rates, psta->bssrateset, psta->bssratelen);
8352 #ifdef CONFIG_80211N_HT
8353                 _rtw_memcpy(&psta_data->ht_cap, &psta->htpriv.ht_cap, sizeof(struct rtw_ieee80211_ht_cap));
8354 #endif //CONFIG_80211N_HT
8355                 psta_data->rx_pkts = psta->sta_stats.rx_data_pkts;
8356                 psta_data->rx_bytes = psta->sta_stats.rx_bytes;
8357                 psta_data->rx_drops = psta->sta_stats.rx_drops;
8358
8359                 psta_data->tx_pkts = psta->sta_stats.tx_pkts;
8360                 psta_data->tx_bytes = psta->sta_stats.tx_bytes;
8361                 psta_data->tx_drops = psta->sta_stats.tx_drops;
8362
8363
8364         }
8365         else
8366         {
8367                 ret = -1;
8368         }
8369
8370         return ret;
8371
8372 }
8373
8374 static int rtw_get_sta_wpaie(struct net_device *dev, struct ieee_param *param)
8375 {
8376         int ret=0;
8377         struct sta_info *psta = NULL;
8378         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
8379         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
8380         struct sta_priv *pstapriv = &padapter->stapriv;
8381
8382         DBG_871X("rtw_get_sta_wpaie, sta_addr: " MAC_FMT "\n", MAC_ARG(param->sta_addr));
8383
8384         if(check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != _TRUE)
8385         {
8386                 return -EINVAL;
8387         }
8388
8389         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
8390             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
8391             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff)
8392         {
8393                 return -EINVAL;
8394         }
8395
8396         psta = rtw_get_stainfo(pstapriv, param->sta_addr);
8397         if(psta)
8398         {
8399                 if((psta->wpa_ie[0] == WLAN_EID_RSN) || (psta->wpa_ie[0] == WLAN_EID_GENERIC))
8400                 {
8401                         int wpa_ie_len;
8402                         int copy_len;
8403
8404                         wpa_ie_len = psta->wpa_ie[1];
8405
8406                         copy_len = ((wpa_ie_len+2) > sizeof(psta->wpa_ie)) ? (sizeof(psta->wpa_ie)):(wpa_ie_len+2);
8407
8408                         param->u.wpa_ie.len = copy_len;
8409
8410                         _rtw_memcpy(param->u.wpa_ie.reserved, psta->wpa_ie, copy_len);
8411                 }
8412                 else
8413                 {
8414                         //ret = -1;
8415                         DBG_871X("sta's wpa_ie is NONE\n");
8416                 }
8417         }
8418         else
8419         {
8420                 ret = -1;
8421         }
8422
8423         return ret;
8424
8425 }
8426
8427 static int rtw_set_wps_beacon(struct net_device *dev, struct ieee_param *param, int len)
8428 {
8429         int ret=0;
8430         unsigned char wps_oui[4]={0x0,0x50,0xf2,0x04};
8431         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
8432         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
8433         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
8434         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
8435         int ie_len;
8436
8437         DBG_871X("%s, len=%d\n", __FUNCTION__, len);
8438
8439         if(check_fwstate(pmlmepriv, WIFI_AP_STATE) != _TRUE)
8440                 return -EINVAL;
8441
8442         ie_len = len-12-2;// 12 = param header, 2:no packed
8443
8444
8445         if(pmlmepriv->wps_beacon_ie)
8446         {
8447                 rtw_mfree(pmlmepriv->wps_beacon_ie, pmlmepriv->wps_beacon_ie_len);
8448                 pmlmepriv->wps_beacon_ie = NULL;
8449         }
8450
8451         if(ie_len>0)
8452         {
8453                 pmlmepriv->wps_beacon_ie = rtw_malloc(ie_len);
8454                 pmlmepriv->wps_beacon_ie_len = ie_len;
8455                 if ( pmlmepriv->wps_beacon_ie == NULL) {
8456                         DBG_871X("%s()-%d: rtw_malloc() ERROR!\n", __FUNCTION__, __LINE__);
8457                         return -EINVAL;
8458                 }
8459
8460                 _rtw_memcpy(pmlmepriv->wps_beacon_ie, param->u.bcn_ie.buf, ie_len);
8461
8462                 update_beacon(padapter, _VENDOR_SPECIFIC_IE_, wps_oui, _TRUE);
8463
8464                 pmlmeext->bstart_bss = _TRUE;
8465
8466         }
8467
8468
8469         return ret;
8470
8471 }
8472
8473 static int rtw_set_wps_probe_resp(struct net_device *dev, struct ieee_param *param, int len)
8474 {
8475         int ret=0;
8476         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
8477         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
8478         int ie_len;
8479
8480         DBG_871X("%s, len=%d\n", __FUNCTION__, len);
8481
8482         if(check_fwstate(pmlmepriv, WIFI_AP_STATE) != _TRUE)
8483                 return -EINVAL;
8484
8485         ie_len = len-12-2;// 12 = param header, 2:no packed
8486
8487
8488         if(pmlmepriv->wps_probe_resp_ie)
8489         {
8490                 rtw_mfree(pmlmepriv->wps_probe_resp_ie, pmlmepriv->wps_probe_resp_ie_len);
8491                 pmlmepriv->wps_probe_resp_ie = NULL;
8492         }
8493
8494         if(ie_len>0)
8495         {
8496                 pmlmepriv->wps_probe_resp_ie = rtw_malloc(ie_len);
8497                 pmlmepriv->wps_probe_resp_ie_len = ie_len;
8498                 if ( pmlmepriv->wps_probe_resp_ie == NULL) {
8499                         DBG_871X("%s()-%d: rtw_malloc() ERROR!\n", __FUNCTION__, __LINE__);
8500                         return -EINVAL;
8501                 }
8502                 _rtw_memcpy(pmlmepriv->wps_probe_resp_ie, param->u.bcn_ie.buf, ie_len);
8503         }
8504
8505
8506         return ret;
8507
8508 }
8509
8510 static int rtw_set_wps_assoc_resp(struct net_device *dev, struct ieee_param *param, int len)
8511 {
8512         int ret=0;
8513         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
8514         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
8515         int ie_len;
8516
8517         DBG_871X("%s, len=%d\n", __FUNCTION__, len);
8518
8519         if(check_fwstate(pmlmepriv, WIFI_AP_STATE) != _TRUE)
8520                 return -EINVAL;
8521
8522         ie_len = len-12-2;// 12 = param header, 2:no packed
8523
8524
8525         if(pmlmepriv->wps_assoc_resp_ie)
8526         {
8527                 rtw_mfree(pmlmepriv->wps_assoc_resp_ie, pmlmepriv->wps_assoc_resp_ie_len);
8528                 pmlmepriv->wps_assoc_resp_ie = NULL;
8529         }
8530
8531         if(ie_len>0)
8532         {
8533                 pmlmepriv->wps_assoc_resp_ie = rtw_malloc(ie_len);
8534                 pmlmepriv->wps_assoc_resp_ie_len = ie_len;
8535                 if ( pmlmepriv->wps_assoc_resp_ie == NULL) {
8536                         DBG_871X("%s()-%d: rtw_malloc() ERROR!\n", __FUNCTION__, __LINE__);
8537                         return -EINVAL;
8538                 }
8539
8540                 _rtw_memcpy(pmlmepriv->wps_assoc_resp_ie, param->u.bcn_ie.buf, ie_len);
8541         }
8542
8543
8544         return ret;
8545
8546 }
8547
8548 static int rtw_set_hidden_ssid(struct net_device *dev, struct ieee_param *param, int len)
8549 {
8550         int ret=0;
8551         _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
8552         struct mlme_priv *mlmepriv = &(adapter->mlmepriv);
8553         struct mlme_ext_priv    *mlmeext = &(adapter->mlmeextpriv);
8554         struct mlme_ext_info    *mlmeinfo = &(mlmeext->mlmext_info);
8555         int ie_len;
8556         u8 *ssid_ie;
8557         char ssid[NDIS_802_11_LENGTH_SSID + 1];
8558         sint ssid_len;
8559         u8 ignore_broadcast_ssid;
8560
8561         if(check_fwstate(mlmepriv, WIFI_AP_STATE) != _TRUE)
8562                 return -EPERM;
8563
8564         if (param->u.bcn_ie.reserved[0] != 0xea)
8565                 return -EINVAL;
8566
8567         mlmeinfo->hidden_ssid_mode = ignore_broadcast_ssid = param->u.bcn_ie.reserved[1];
8568
8569         ie_len = len-12-2;// 12 = param header, 2:no packed
8570         ssid_ie = rtw_get_ie(param->u.bcn_ie.buf,  WLAN_EID_SSID, &ssid_len, ie_len);
8571
8572         if (ssid_ie && ssid_len > 0 && ssid_len <= NDIS_802_11_LENGTH_SSID) {
8573                 WLAN_BSSID_EX *pbss_network = &mlmepriv->cur_network.network;
8574                 WLAN_BSSID_EX *pbss_network_ext = &mlmeinfo->network;
8575
8576                 _rtw_memcpy(ssid, ssid_ie+2, ssid_len);
8577                 ssid[ssid_len] = 0x0;
8578
8579                 if(0)
8580                 DBG_871X(FUNC_ADPT_FMT" ssid:(%s,%d), from ie:(%s,%d), (%s,%d)\n", FUNC_ADPT_ARG(adapter),
8581                         ssid, ssid_len,
8582                         pbss_network->Ssid.Ssid, pbss_network->Ssid.SsidLength,
8583                         pbss_network_ext->Ssid.Ssid, pbss_network_ext->Ssid.SsidLength);
8584
8585                 _rtw_memcpy(pbss_network->Ssid.Ssid, (void *)ssid, ssid_len);
8586                 pbss_network->Ssid.SsidLength = ssid_len;
8587                 _rtw_memcpy(pbss_network_ext->Ssid.Ssid, (void *)ssid, ssid_len);
8588                 pbss_network_ext->Ssid.SsidLength = ssid_len;
8589
8590                 if(0)
8591                 DBG_871X(FUNC_ADPT_FMT" after ssid:(%s,%d), (%s,%d)\n", FUNC_ADPT_ARG(adapter),
8592                         pbss_network->Ssid.Ssid, pbss_network->Ssid.SsidLength,
8593                         pbss_network_ext->Ssid.Ssid, pbss_network_ext->Ssid.SsidLength);
8594         }
8595
8596         DBG_871X(FUNC_ADPT_FMT" ignore_broadcast_ssid:%d, %s,%d\n", FUNC_ADPT_ARG(adapter),
8597                 ignore_broadcast_ssid, ssid, ssid_len);
8598
8599         return ret;
8600 }
8601
8602 static int rtw_ioctl_acl_remove_sta(struct net_device *dev, struct ieee_param *param, int len)
8603 {
8604         int ret=0;
8605         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
8606         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
8607
8608         if(check_fwstate(pmlmepriv, WIFI_AP_STATE) != _TRUE)
8609                 return -EINVAL;
8610
8611         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
8612             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
8613             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff)
8614         {
8615                 return -EINVAL;
8616         }
8617
8618         ret = rtw_acl_remove_sta(padapter, param->sta_addr);
8619
8620         return ret;
8621
8622 }
8623
8624 static int rtw_ioctl_acl_add_sta(struct net_device *dev, struct ieee_param *param, int len)
8625 {
8626         int ret=0;
8627         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
8628         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
8629
8630         if(check_fwstate(pmlmepriv, WIFI_AP_STATE) != _TRUE)
8631                 return -EINVAL;
8632
8633         if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
8634             param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
8635             param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff)
8636         {
8637                 return -EINVAL;
8638         }
8639
8640         ret = rtw_acl_add_sta(padapter, param->sta_addr);
8641
8642         return ret;
8643
8644 }
8645
8646 static int rtw_ioctl_set_macaddr_acl(struct net_device *dev, struct ieee_param *param, int len)
8647 {
8648         int ret=0;
8649         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
8650         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
8651
8652         if(check_fwstate(pmlmepriv, WIFI_AP_STATE) != _TRUE)
8653                 return -EINVAL;
8654
8655         rtw_set_macaddr_acl(padapter, param->u.mlme.command);
8656
8657         return ret;
8658 }
8659
8660 static int rtw_hostapd_ioctl(struct net_device *dev, struct iw_point *p)
8661 {
8662         struct ieee_param *param;
8663         int ret=0;
8664         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
8665
8666         //DBG_871X("%s\n", __FUNCTION__);
8667
8668         /*
8669         * this function is expect to call in master mode, which allows no power saving
8670         * so, we just check hw_init_completed
8671         */
8672
8673         if (padapter->hw_init_completed==_FALSE){
8674                 ret = -EPERM;
8675                 goto out;
8676         }
8677
8678
8679         //if (p->length < sizeof(struct ieee_param) || !p->pointer){
8680         if(!p->pointer){
8681                 ret = -EINVAL;
8682                 goto out;
8683         }
8684
8685         param = (struct ieee_param *)rtw_malloc(p->length);
8686         if (param == NULL)
8687         {
8688                 ret = -ENOMEM;
8689                 goto out;
8690         }
8691
8692         if (copy_from_user(param, p->pointer, p->length))
8693         {
8694                 rtw_mfree((u8*)param, p->length);
8695                 ret = -EFAULT;
8696                 goto out;
8697         }
8698
8699         //DBG_871X("%s, cmd=%d\n", __FUNCTION__, param->cmd);
8700
8701         switch (param->cmd)
8702         {
8703                 case RTL871X_HOSTAPD_FLUSH:
8704
8705                         ret = rtw_hostapd_sta_flush(dev);
8706
8707                         break;
8708
8709                 case RTL871X_HOSTAPD_ADD_STA:
8710
8711                         ret = rtw_add_sta(dev, param);
8712
8713                         break;
8714
8715                 case RTL871X_HOSTAPD_REMOVE_STA:
8716
8717                         ret = rtw_del_sta(dev, param);
8718
8719                         break;
8720
8721                 case RTL871X_HOSTAPD_SET_BEACON:
8722
8723                         ret = rtw_set_beacon(dev, param, p->length);
8724
8725                         break;
8726
8727                 case RTL871X_SET_ENCRYPTION:
8728
8729                         ret = rtw_set_encryption(dev, param, p->length);
8730
8731                         break;
8732
8733                 case RTL871X_HOSTAPD_GET_WPAIE_STA:
8734
8735                         ret = rtw_get_sta_wpaie(dev, param);
8736
8737                         break;
8738
8739                 case RTL871X_HOSTAPD_SET_WPS_BEACON:
8740
8741                         ret = rtw_set_wps_beacon(dev, param, p->length);
8742
8743                         break;
8744
8745                 case RTL871X_HOSTAPD_SET_WPS_PROBE_RESP:
8746
8747                         ret = rtw_set_wps_probe_resp(dev, param, p->length);
8748
8749                         break;
8750
8751                 case RTL871X_HOSTAPD_SET_WPS_ASSOC_RESP:
8752
8753                         ret = rtw_set_wps_assoc_resp(dev, param, p->length);
8754
8755                         break;
8756
8757                 case RTL871X_HOSTAPD_SET_HIDDEN_SSID:
8758
8759                         ret = rtw_set_hidden_ssid(dev, param, p->length);
8760
8761                         break;
8762
8763                 case RTL871X_HOSTAPD_GET_INFO_STA:
8764
8765                         ret = rtw_ioctl_get_sta_data(dev, param, p->length);
8766
8767                         break;
8768
8769                 case RTL871X_HOSTAPD_SET_MACADDR_ACL:
8770
8771                         ret = rtw_ioctl_set_macaddr_acl(dev, param, p->length);
8772
8773                         break;
8774
8775                 case RTL871X_HOSTAPD_ACL_ADD_STA:
8776
8777                         ret = rtw_ioctl_acl_add_sta(dev, param, p->length);
8778
8779                         break;
8780
8781                 case RTL871X_HOSTAPD_ACL_REMOVE_STA:
8782
8783                         ret = rtw_ioctl_acl_remove_sta(dev, param, p->length);
8784
8785                         break;
8786
8787                 default:
8788                         DBG_871X("Unknown hostapd request: %d\n", param->cmd);
8789                         ret = -EOPNOTSUPP;
8790                         break;
8791
8792         }
8793
8794         if (ret == 0 && copy_to_user(p->pointer, param, p->length))
8795                 ret = -EFAULT;
8796
8797
8798         rtw_mfree((u8 *)param, p->length);
8799
8800 out:
8801
8802         return ret;
8803
8804 }
8805 #endif
8806
8807 static int rtw_wx_set_priv(struct net_device *dev,
8808                                 struct iw_request_info *info,
8809                                 union iwreq_data *awrq,
8810                                 char *extra)
8811 {
8812
8813 #ifdef CONFIG_DEBUG_RTW_WX_SET_PRIV
8814         char *ext_dbg;
8815 #endif
8816
8817         int ret = 0;
8818         int len = 0;
8819         char *ext;
8820         int i;
8821
8822         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
8823         struct iw_point *dwrq = (struct iw_point*)awrq;
8824
8825         //RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_notice_, ("+rtw_wx_set_priv\n"));
8826         if(dwrq->length == 0)
8827                 return -EFAULT;
8828
8829         len = dwrq->length;
8830         if (!(ext = rtw_vmalloc(len)))
8831                 return -ENOMEM;
8832
8833         if (copy_from_user(ext, dwrq->pointer, len)) {
8834                 rtw_vmfree(ext, len);
8835                 return -EFAULT;
8836         }
8837
8838
8839         //RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_notice_,
8840         //       ("rtw_wx_set_priv: %s req=%s\n",
8841         //        dev->name, ext));
8842
8843         #ifdef CONFIG_DEBUG_RTW_WX_SET_PRIV
8844         if (!(ext_dbg = rtw_vmalloc(len)))
8845         {
8846                 rtw_vmfree(ext, len);
8847                 return -ENOMEM;
8848         }
8849
8850         _rtw_memcpy(ext_dbg, ext, len);
8851         #endif
8852
8853         //added for wps2.0 @20110524
8854         if(dwrq->flags == 0x8766 && len > 8)
8855         {
8856                 u32 cp_sz;
8857                 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
8858                 u8 *probereq_wpsie = ext;
8859                 int probereq_wpsie_len = len;
8860                 u8 wps_oui[4]={0x0,0x50,0xf2,0x04};
8861
8862                 if((_VENDOR_SPECIFIC_IE_ == probereq_wpsie[0]) &&
8863                         (_rtw_memcmp(&probereq_wpsie[2], wps_oui, 4) ==_TRUE))
8864                 {
8865                         cp_sz = probereq_wpsie_len>MAX_WPS_IE_LEN ? MAX_WPS_IE_LEN:probereq_wpsie_len;
8866
8867                         if(pmlmepriv->wps_probe_req_ie)
8868                         {
8869                                 u32 free_len = pmlmepriv->wps_probe_req_ie_len;
8870                                 pmlmepriv->wps_probe_req_ie_len = 0;
8871                                 rtw_mfree(pmlmepriv->wps_probe_req_ie, free_len);
8872                                 pmlmepriv->wps_probe_req_ie = NULL;
8873                         }
8874
8875                         pmlmepriv->wps_probe_req_ie = rtw_malloc(cp_sz);
8876                         if ( pmlmepriv->wps_probe_req_ie == NULL) {
8877                                 printk("%s()-%d: rtw_malloc() ERROR!\n", __FUNCTION__, __LINE__);
8878                                 ret =  -EINVAL;
8879                                 goto FREE_EXT;
8880
8881                         }
8882
8883                         _rtw_memcpy(pmlmepriv->wps_probe_req_ie, probereq_wpsie, cp_sz);
8884                         pmlmepriv->wps_probe_req_ie_len = cp_sz;
8885
8886                 }
8887
8888                 goto FREE_EXT;
8889
8890         }
8891
8892         if(     len >= WEXT_CSCAN_HEADER_SIZE
8893                 && _rtw_memcmp(ext, WEXT_CSCAN_HEADER, WEXT_CSCAN_HEADER_SIZE) == _TRUE
8894         ){
8895                 ret = rtw_wx_set_scan(dev, info, awrq, ext);
8896                 goto FREE_EXT;
8897         }
8898
8899 #ifdef CONFIG_ANDROID
8900         //DBG_871X("rtw_wx_set_priv: %s req=%s\n", dev->name, ext);
8901
8902         i = rtw_android_cmdstr_to_num(ext);
8903
8904         switch(i) {
8905                 case ANDROID_WIFI_CMD_START :
8906                         indicate_wx_custom_event(padapter, "START");
8907                         break;
8908                 case ANDROID_WIFI_CMD_STOP :
8909                         indicate_wx_custom_event(padapter, "STOP");
8910                         break;
8911                 case ANDROID_WIFI_CMD_RSSI :
8912                         {
8913                                 struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
8914                                 struct  wlan_network    *pcur_network = &pmlmepriv->cur_network;
8915
8916                                 if(check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) {
8917                                         sprintf(ext, "%s rssi %d", pcur_network->network.Ssid.Ssid, padapter->recvpriv.rssi);
8918                                 } else {
8919                                         sprintf(ext, "OK");
8920                                 }
8921                         }
8922                         break;
8923                 case ANDROID_WIFI_CMD_LINKSPEED :
8924                         {
8925                                 u16 mbps = rtw_get_cur_max_rate(padapter)/10;
8926                                 sprintf(ext, "LINKSPEED %d", mbps);
8927                         }
8928                         break;
8929                 case ANDROID_WIFI_CMD_MACADDR :
8930                         sprintf(ext, "MACADDR = " MAC_FMT, MAC_ARG(dev->dev_addr));
8931                         break;
8932                 case ANDROID_WIFI_CMD_SCAN_ACTIVE :
8933                         {
8934                                 //rtw_set_scan_mode(padapter, SCAN_ACTIVE);
8935                                 sprintf(ext, "OK");
8936                         }
8937                         break;
8938                 case ANDROID_WIFI_CMD_SCAN_PASSIVE :
8939                         {
8940                                 //rtw_set_scan_mode(padapter, SCAN_PASSIVE);
8941                                 sprintf(ext, "OK");
8942                         }
8943                         break;
8944
8945                 case ANDROID_WIFI_CMD_COUNTRY :
8946                         {
8947                                 char country_code[10];
8948                                 sscanf(ext, "%*s %s", country_code);
8949                                 rtw_set_country(padapter, country_code);
8950                                 sprintf(ext, "OK");
8951                         }
8952                         break;
8953                 default :
8954                         #ifdef  CONFIG_DEBUG_RTW_WX_SET_PRIV
8955                         DBG_871X("%s: %s unknowned req=%s\n", __FUNCTION__,
8956                                 dev->name, ext_dbg);
8957                         #endif
8958
8959                         sprintf(ext, "OK");
8960
8961         }
8962
8963         if (copy_to_user(dwrq->pointer, ext, min(dwrq->length, (u16)(strlen(ext)+1)) ) )
8964                 ret = -EFAULT;
8965
8966         #ifdef CONFIG_DEBUG_RTW_WX_SET_PRIV
8967         DBG_871X("%s: %s req=%s rep=%s dwrq->length=%d, strlen(ext)+1=%d\n", __FUNCTION__,
8968                 dev->name, ext_dbg ,ext, dwrq->length, (u16)(strlen(ext)+1));
8969         #endif
8970 #endif //end of CONFIG_ANDROID
8971
8972
8973 FREE_EXT:
8974
8975         rtw_vmfree(ext, len);
8976         #ifdef CONFIG_DEBUG_RTW_WX_SET_PRIV
8977         rtw_vmfree(ext_dbg, len);
8978         #endif
8979
8980         //DBG_871X("rtw_wx_set_priv: (SIOCSIWPRIV) %s ret=%d\n",
8981         //              dev->name, ret);
8982
8983         return ret;
8984
8985 }
8986 #ifdef CONFIG_WOWLAN
8987 static int rtw_wowlan_ctrl(struct net_device *dev,
8988                                                 struct iw_request_info *info,
8989                                                 union iwreq_data *wrqu, char *extra)
8990 {
8991         _adapter *padapter =  (_adapter *)rtw_netdev_priv(dev);
8992         struct wowlan_ioctl_param poidparam;
8993         struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
8994         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
8995         struct net_device *pnetdev = padapter->pnetdev;
8996 #ifdef CONFIG_CONCURRENT_MODE
8997         struct net_device *pbuddy_netdev = padapter->pbuddy_adapter->pnetdev;
8998 #endif
8999         struct sta_info *psta = NULL;
9000         int ret = 0;
9001         u32 start_time = rtw_get_current_time();
9002         poidparam.subcode = 0;
9003
9004         DBG_871X("+rtw_wowlan_ctrl: %s\n", extra);
9005
9006         if(pwrctrlpriv->bSupportRemoteWakeup==_FALSE){
9007                 ret = -EPERM;
9008                 DBG_871X("+rtw_wowlan_ctrl: Device didn't support the remote wakeup!!\n");
9009                 goto _rtw_wowlan_ctrl_exit_free;
9010         }
9011
9012         if (!check_fwstate(pmlmepriv, _FW_LINKED) &&
9013                         check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
9014                         DBG_871X("[%s] WARNING: Please Connect With AP First!!\n", __func__);
9015                         goto _rtw_wowlan_ctrl_exit_free;
9016         }
9017
9018         if (_rtw_memcmp( extra, "enable", 6 )) {
9019
9020                 padapter->registrypriv.mp_mode = 1;
9021
9022                 while (pwrctrlpriv->bips_processing == _TRUE)
9023                         rtw_msleep_os(1);
9024
9025                 rtw_ps_deny(padapter, PS_DENY_SUSPEND);
9026
9027                 rtw_cancel_all_timer(padapter);
9028
9029 #ifdef CONFIG_CONCURRENT_MODE
9030                 if (padapter->pbuddy_adapter){
9031                         rtw_cancel_all_timer(padapter->pbuddy_adapter);
9032                 }
9033 #endif // CONFIG_CONCURRENT_MODE
9034
9035                 LeaveAllPowerSaveModeDirect(padapter);
9036
9037                 rtw_stop_cmd_thread(padapter);
9038
9039                 rtw_ps_deny_cancel(padapter, PS_DENY_SUSPEND);
9040
9041                 rtw_suspend_wow(padapter);
9042
9043         } else if (_rtw_memcmp( extra, "disable", 6 )) {
9044                 rtw_resume_process_wow(padapter);
9045                 padapter->registrypriv.mp_mode = 0;
9046         } else {
9047                 DBG_871X("[%s] Invalid Parameter.\n", __func__);
9048                 goto _rtw_wowlan_ctrl_exit_free;
9049         }
9050         //mutex_lock(&ioctl_mutex);
9051 _rtw_wowlan_ctrl_exit_free:
9052         DBG_871X("-rtw_wowlan_ctrl( subcode = %d)\n", poidparam.subcode);
9053         DBG_871X_LEVEL(_drv_always_, "%s in %d ms\n", __func__,
9054                         rtw_get_passing_time_ms(start_time));
9055 _rtw_wowlan_ctrl_exit:
9056         return ret;
9057 }
9058 #endif //CONFIG_WOWLAN
9059
9060 #ifdef CONFIG_AP_WOWLAN
9061 static int rtw_ap_wowlan_ctrl(struct net_device *dev,
9062                                                 struct iw_request_info *info,
9063                                                 union iwreq_data *wrqu, char *extra)
9064 {
9065         _adapter *padapter =  (_adapter *)rtw_netdev_priv(dev);
9066         struct wowlan_ioctl_param poidparam;
9067         struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
9068         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
9069         struct sta_info *psta = NULL;
9070         int ret = 0;
9071         u32 start_time = rtw_get_current_time();
9072         poidparam.subcode = 0;
9073
9074         DBG_871X("+rtw_ap_wowlan_ctrl: %s\n", extra);
9075
9076         if(pwrctrlpriv->bSupportRemoteWakeup==_FALSE){
9077                 ret = -EPERM;
9078                 DBG_871X("+rtw_wowlan_ctrl: Device didn't support the remote wakeup!!\n");
9079                 goto _rtw_ap_wowlan_ctrl_exit_free;
9080         }
9081
9082         if (!check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
9083                 DBG_871X("[%s] It is not AP mode!!\n", __func__);
9084                 goto _rtw_ap_wowlan_ctrl_exit_free;
9085         }
9086
9087         if (_rtw_memcmp( extra, "enable", 6 )) {
9088                 pwrctrlpriv->wowlan_ap_mode = _TRUE;
9089                 while (pwrctrlpriv->bips_processing == _TRUE)
9090                         rtw_msleep_os(1);
9091
9092                 rtw_cancel_all_timer(padapter);
9093
9094                 padapter->bDriverStopped = _TRUE;       //for stop thread
9095                 rtw_stop_drv_threads(padapter);
9096                 padapter->bDriverStopped = _FALSE;      //for 32k command
9097
9098 #ifdef CONFIG_LPS
9099                 LeaveAllPowerSaveModeDirect(padapter);
9100 #endif
9101                 rtw_hal_disable_interrupt(padapter); // It need wait for leaving 32K.
9102
9103                 // 2.1 clean interupt
9104                 if (padapter->HalFunc.clear_interrupt)
9105                         padapter->HalFunc.clear_interrupt(padapter);
9106
9107                 poidparam.subcode = WOWLAN_AP_ENABLE;
9108
9109                 rtw_hal_set_hwreg(padapter, HW_VAR_AP_WOWLAN,(u8 *)&poidparam);
9110         } else if (_rtw_memcmp( extra, "disable", 6 )) {
9111 #ifdef CONFIG_LPS
9112                 LeaveAllPowerSaveModeDirect(padapter);
9113 #endif //CONFIG_LPS
9114                 pwrctrlpriv->bFwCurrentInPSMode = _FALSE;
9115
9116                 rtw_hal_disable_interrupt(padapter);
9117
9118                 if (padapter->HalFunc.clear_interrupt)
9119                         padapter->HalFunc.clear_interrupt(padapter);
9120
9121                 poidparam.subcode = WOWLAN_AP_ENABLE;
9122
9123                 rtw_hal_set_hwreg(padapter, HW_VAR_AP_WOWLAN,(u8 *)&poidparam);
9124
9125                 pwrctrlpriv->wowlan_ap_mode = _FALSE;
9126
9127                 psta = rtw_get_stainfo(&padapter->stapriv, get_bssid(&padapter->mlmepriv));
9128                 if (psta) {
9129                         set_sta_rate(padapter, psta);
9130                 }
9131
9132                 padapter->bDriverStopped = _FALSE;
9133                 DBG_871X("%s: wowmode resuming, DriverStopped:%d\n", __func__, padapter->bDriverStopped);
9134                 rtw_start_drv_threads(padapter);
9135
9136                 rtw_hal_enable_interrupt(padapter);
9137
9138                 _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
9139                 pwrctrlpriv->bips_processing = _FALSE;
9140                 rtw_set_pwr_state_check_timer(pwrctrlpriv);
9141
9142         } else {
9143                 DBG_871X("[%s] Invalid Parameter.\n", __func__);
9144                 goto _rtw_ap_wowlan_ctrl_exit_free;
9145         }
9146         //mutex_lock(&ioctl_mutex);
9147 _rtw_ap_wowlan_ctrl_exit_free:
9148         DBG_871X("-rtw_ap_wowlan_ctrl( subcode = %d)\n", poidparam.subcode);
9149         DBG_871X_LEVEL(_drv_always_, "%s in %d ms\n", __func__,
9150                         rtw_get_passing_time_ms(start_time));
9151 _rtw_ap_wowlan_ctrl_exit:
9152         return ret;
9153 }
9154 #endif //CONFIG_AP_WOWLAN
9155
9156 static int rtw_pm_set(struct net_device *dev,
9157                                struct iw_request_info *info,
9158                                union iwreq_data *wrqu, char *extra)
9159 {
9160         int ret = 0;
9161         unsigned        mode = 0;
9162         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
9163
9164         DBG_871X( "[%s] extra = %s\n", __FUNCTION__, extra );
9165
9166         if ( _rtw_memcmp( extra, "lps=", 4 ) )
9167         {
9168                 sscanf(extra+4, "%u", &mode);
9169                 ret = rtw_pm_set_lps(padapter,mode);
9170         }
9171         else if ( _rtw_memcmp( extra, "ips=", 4 ) )
9172         {
9173                 sscanf(extra+4, "%u", &mode);
9174                 ret = rtw_pm_set_ips(padapter,mode);
9175         }
9176         else{
9177                 ret = -EINVAL;
9178         }
9179
9180         return ret;
9181 }
9182
9183 static int rtw_mp_efuse_get(struct net_device *dev,
9184                         struct iw_request_info *info,
9185                         union iwreq_data *wdata, char *extra)
9186 {
9187         PADAPTER padapter = rtw_netdev_priv(dev);
9188         EEPROM_EFUSE_PRIV *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
9189         PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
9190         PEFUSE_HAL pEfuseHal;
9191         struct iw_point *wrqu;
9192
9193         u8      *PROMContent = pEEPROM->efuse_eeprom_data;
9194         u8 ips_mode = IPS_NUM; // init invalid value
9195         u8 lps_mode = PS_MODE_NUM; // init invalid value
9196         struct pwrctrl_priv *pwrctrlpriv ;
9197         u8 *data = NULL;
9198         u8 *rawdata = NULL;
9199         char *pch, *ptmp, *token, *tmp[3]={0x00,0x00,0x00};
9200         u16 i=0, j=0, mapLen=0, addr=0, cnts=0;
9201         u16 max_available_size=0, raw_cursize=0, raw_maxsize=0;
9202         int err;
9203         #ifdef CONFIG_IOL
9204         u8 org_fw_iol = padapter->registrypriv.fw_iol;// 0:Disable, 1:enable, 2:by usb speed
9205         #endif
9206
9207         wrqu = (struct iw_point*)wdata;
9208         pwrctrlpriv = adapter_to_pwrctl(padapter);
9209         pEfuseHal = &pHalData->EfuseHal;
9210
9211         err = 0;
9212         data = rtw_zmalloc(EFUSE_BT_MAX_MAP_LEN);
9213         if (data == NULL)
9214         {
9215                 err = -ENOMEM;
9216                 goto exit;
9217         }
9218         rawdata = rtw_zmalloc(EFUSE_BT_MAX_MAP_LEN);
9219         if (rawdata == NULL)
9220         {
9221                 err = -ENOMEM;
9222                 goto exit;
9223         }
9224
9225         if (copy_from_user(extra, wrqu->pointer, wrqu->length))
9226         {
9227                 err = -EFAULT;
9228                 goto exit;
9229         }
9230         #ifdef CONFIG_LPS
9231         lps_mode = pwrctrlpriv->power_mgnt;//keep org value
9232         rtw_pm_set_lps(padapter,PS_MODE_ACTIVE);
9233         #endif
9234
9235         #ifdef CONFIG_IPS
9236         ips_mode = pwrctrlpriv->ips_mode;//keep org value
9237         rtw_pm_set_ips(padapter,IPS_NONE);
9238         #endif
9239
9240         pch = extra;
9241         DBG_871X("%s: in=%s\n", __FUNCTION__, extra);
9242
9243         i = 0;
9244         //mac 16 "00e04c871200" rmap,00,2
9245         while ((token = strsep(&pch, ",")) != NULL)
9246         {
9247                 if (i > 2) break;
9248                 tmp[i] = token;
9249                 i++;
9250         }
9251         #ifdef CONFIG_IOL
9252         padapter->registrypriv.fw_iol = 0;// 0:Disable, 1:enable, 2:by usb speed
9253         #endif
9254
9255         if(strcmp(tmp[0], "status") == 0){
9256                 sprintf(extra, "Load File efuse=%s,Load File MAC=%s",(pEEPROM->bloadfile_fail_flag? "FAIL" : "OK"),(pEEPROM->bloadmac_fail_flag? "FAIL" : "OK"));
9257
9258                   goto exit;
9259         }
9260         else if (strcmp(tmp[0], "drvmap") == 0)
9261         {
9262                 mapLen = EFUSE_MAP_SIZE;
9263
9264                 sprintf(extra, "\n");
9265                 for (i = 0; i < EFUSE_MAP_SIZE; i += 16)
9266                 {
9267 //                      DBG_871X("0x%02x\t", i);
9268                         sprintf(extra, "%s0x%02x\t", extra, i);
9269                         for (j=0; j<8; j++) {
9270 //                              DBG_871X("%02X ", data[i+j]);
9271                                 sprintf(extra, "%s%02X ", extra, PROMContent[i+j]);
9272                         }
9273 //                      DBG_871X("\t");
9274                         sprintf(extra, "%s\t", extra);
9275                         for (; j<16; j++) {
9276 //                              DBG_871X("%02X ", data[i+j]);
9277                                 sprintf(extra, "%s%02X ", extra, PROMContent[i+j]);
9278                         }
9279 //                      DBG_871X("\n");
9280                         sprintf(extra,"%s\n",extra);
9281                 }
9282 //              DBG_871X("\n");
9283         }
9284         else if (strcmp(tmp[0], "realmap") == 0)
9285         {
9286                 mapLen = EFUSE_MAP_SIZE;
9287                 if (rtw_efuse_map_read(padapter, EFUSE_WIFI , mapLen, pEfuseHal->fakeEfuseInitMap) == _FAIL)
9288                 {
9289                         DBG_871X("%s: read realmap Fail!!\n", __FUNCTION__);
9290                         err = -EFAULT;
9291                         goto exit;
9292                 }
9293
9294 //              DBG_871X("OFFSET\tVALUE(hex)\n");
9295                 sprintf(extra, "\n");
9296                 for (i = 0; i < EFUSE_MAP_SIZE; i += 16)
9297                 {
9298 //                      DBG_871X("0x%02x\t", i);
9299                         sprintf(extra, "%s0x%02x\t", extra, i);
9300                         for (j=0; j<8; j++) {
9301 //                              DBG_871X("%02X ", data[i+j]);
9302                                 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeEfuseInitMap[i+j]);
9303                         }
9304 //                      DBG_871X("\t");
9305                         sprintf(extra, "%s\t", extra);
9306                         for (; j<16; j++) {
9307 //                              DBG_871X("%02X ", data[i+j]);
9308                                 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeEfuseInitMap[i+j]);
9309                         }
9310 //                      DBG_871X("\n");
9311                         sprintf(extra,"%s\n",extra);
9312                 }
9313 //              DBG_871X("\n");
9314         }
9315         else if (strcmp(tmp[0], "rmap") == 0)
9316         {
9317                 if ((tmp[1]==NULL) || (tmp[2]==NULL))
9318                 {
9319                         DBG_871X("%s: rmap Fail!! Parameters error!\n", __FUNCTION__);
9320                         err = -EINVAL;
9321                         goto exit;
9322                 }
9323
9324                 // rmap addr cnts
9325                 addr = simple_strtoul(tmp[1], &ptmp, 16);
9326                 DBG_871X("%s: addr=%x\n", __FUNCTION__, addr);
9327
9328                 cnts = simple_strtoul(tmp[2], &ptmp, 10);
9329                 if (cnts == 0)
9330                 {
9331                         DBG_871X("%s: rmap Fail!! cnts error!\n", __FUNCTION__);
9332                         err = -EINVAL;
9333                         goto exit;
9334                 }
9335                 DBG_871X("%s: cnts=%d\n", __FUNCTION__, cnts);
9336
9337                 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN , (PVOID)&max_available_size, _FALSE);
9338                 if ((addr+ cnts) > max_available_size)
9339                 {
9340                         DBG_871X("%s: addr(0x%X)+cnts(%d) parameter error!\n", __FUNCTION__, addr, cnts);
9341                         err = -EINVAL;
9342                         goto exit;
9343                 }
9344
9345                 if (rtw_efuse_map_read(padapter, addr, cnts, data) == _FAIL)
9346                 {
9347                         DBG_871X("%s: rtw_efuse_map_read error!\n", __FUNCTION__);
9348                         err = -EFAULT;
9349                         goto exit;
9350                 }
9351
9352 //              DBG_871X("%s: data={", __FUNCTION__);
9353                 *extra = 0;
9354                 for (i=0; i<cnts; i++) {
9355 //                      DBG_871X("0x%02x ", data[i]);
9356                         sprintf(extra, "%s0x%02X ", extra, data[i]);
9357                 }
9358 //              DBG_871X("}\n");
9359         }
9360         else if (strcmp(tmp[0], "realraw") == 0)
9361         {
9362                 addr = 0;
9363                 mapLen = EFUSE_MAX_SIZE;
9364                 if (rtw_efuse_access(padapter, _FALSE, addr, mapLen, rawdata) == _FAIL)
9365                 {
9366                         DBG_871X("%s: rtw_efuse_access Fail!!\n", __FUNCTION__);
9367                         err = -EFAULT;
9368                         goto exit;
9369                 }
9370                 _rtw_memset(extra,'\0',strlen(extra));
9371                 //              DBG_871X("%s: realraw={\n", __FUNCTION__);
9372                                 sprintf(extra, "\n0x00\t");
9373                                 for (i=0; i< mapLen; i++)
9374                                 {
9375                 //                      DBG_871X("%02X", rawdata[i]);
9376                                         sprintf(extra, "%s%02X", extra, rawdata[i]);
9377                                         if ((i & 0xF) == 0xF) {
9378                 //                              DBG_871X("\n");
9379                                                 sprintf(extra, "%s\n", extra);
9380                                                 sprintf(extra, "%s0x%02x\t", extra, i+1);
9381                                         }
9382                                         else if ((i & 0x7) == 0x7){
9383                 //                              DBG_871X("\t");
9384                                                 sprintf(extra, "%s \t", extra);
9385                                         } else {
9386                 //                              DBG_871X(" ");
9387                                                 sprintf(extra, "%s ", extra);
9388                                         }
9389                                 }
9390                 //              DBG_871X("}\n");
9391         }
9392         else if (strcmp(tmp[0], "mac") == 0)
9393         {
9394                 #ifdef CONFIG_RTL8192C
9395                 addr = EEPROM_MAC_ADDR_92C;
9396                 #endif // CONFIG_RTL8192C
9397                 #ifdef CONFIG_RTL8192D
9398                         #ifdef CONFIG_USB_HCI
9399                         if (pHalData->interfaceIndex == 0)
9400                                 addr = EEPROM_MAC_ADDR_MAC0_92DU;
9401                         else
9402                                 addr = EEPROM_MAC_ADDR_MAC1_92DU;
9403                         #else
9404                         if (pHalData->interfaceIndex == 0)
9405                                 addr = EEPROM_MAC_ADDR_MAC0_92DE;
9406                         else
9407                                 addr = EEPROM_MAC_ADDR_MAC1_92DE;
9408                         #endif
9409                 #endif // CONFIG_RTL8192D
9410                 #ifdef CONFIG_RTL8723A
9411                         #ifdef CONFIG_SDIO_HCI
9412                         addr = EEPROM_MAC_ADDR_8723AS;
9413                         #endif
9414                         #ifdef CONFIG_GSPI_HCI
9415                         addr = EEPROM_MAC_ADDR_8723AS;
9416                         #endif
9417                         #ifdef CONFIG_USB_HCI
9418                         addr = EEPROM_MAC_ADDR_8723AU;
9419                         #endif
9420                 #endif // CONFIG_RTL8723A
9421                 #ifdef CONFIG_RTL8188E
9422                         #ifdef CONFIG_USB_HCI
9423                         addr = EEPROM_MAC_ADDR_88EU;
9424                         #endif
9425                         #ifdef CONFIG_SDIO_HCI
9426                         addr = EEPROM_MAC_ADDR_88ES;
9427                         #endif
9428                         #ifdef CONFIG_PCI_HCI
9429                         addr = EEPROM_MAC_ADDR_88EE;
9430                         #endif
9431                 #endif // CONFIG_RTL8188E
9432
9433                 #ifdef CONFIG_RTL8192E
9434                         #ifdef CONFIG_USB_HCI
9435                         addr = EEPROM_MAC_ADDR_8192EU;
9436                         #endif
9437                         #ifdef CONFIG_SDIO_HCI
9438                         addr = EEPROM_MAC_ADDR_8192ES;
9439                         #endif
9440                         #ifdef CONFIG_PCI_HCI
9441                         addr = EEPROM_MAC_ADDR_8192EE;
9442                         #endif
9443                 #endif
9444                 #ifdef CONFIG_RTL8723B
9445                 #ifdef CONFIG_SDIO_HCI
9446                 addr = EEPROM_MAC_ADDR_8723BS;
9447                 #endif
9448                 #ifdef CONFIG_GSPI_HCI
9449                 addr = EEPROM_MAC_ADDR_8723BS;
9450                 #endif
9451                 #ifdef CONFIG_USB_HCI
9452                 addr = EEPROM_MAC_ADDR_8723BU;
9453                 #endif
9454                 #endif // CONFIG_RTL8723B
9455                 cnts = 6;
9456
9457                 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (PVOID)&max_available_size, _FALSE);
9458                 if ((addr + cnts) > max_available_size) {
9459                         DBG_871X("%s: addr(0x%02x)+cnts(%d) parameter error!\n", __FUNCTION__, addr, cnts);
9460                         err = -EFAULT;
9461                         goto exit;
9462                 }
9463
9464                 if (rtw_efuse_map_read(padapter, addr, cnts, data) == _FAIL)
9465                 {
9466                         DBG_871X("%s: rtw_efuse_map_read error!\n", __FUNCTION__);
9467                         err = -EFAULT;
9468                         goto exit;
9469                 }
9470
9471 //              DBG_871X("%s: MAC address={", __FUNCTION__);
9472                 *extra = 0;
9473                 for (i=0; i<cnts; i++)
9474                 {
9475 //                      DBG_871X("%02X", data[i]);
9476                         sprintf(extra, "%s%02X", extra, data[i]);
9477                         if (i != (cnts-1))
9478                         {
9479 //                              DBG_871X(":");
9480                                 sprintf(extra,"%s:",extra);
9481                         }
9482                 }
9483 //              DBG_871X("}\n");
9484         }
9485         else if (strcmp(tmp[0], "vidpid") == 0)
9486         {
9487                 #ifdef CONFIG_RTL8192C
9488                 addr = EEPROM_VID_92C;
9489                 #endif // CONFIG_RTL8192C
9490                 #ifdef CONFIG_RTL8192D
9491                         #ifdef CONFIG_USB_HCI
9492                         addr = EEPROM_VID_92DU;
9493                         #else
9494                         addr = EEPROM_VID_92DE;
9495                         #endif
9496                 #endif // CONFIG_RTL8192D
9497                 #ifdef CONFIG_RTL8723A
9498                         #ifdef CONFIG_USB_HCI
9499                         addr = EEPROM_VID_8723AU;
9500                         #endif
9501                 #endif // CONFIG_RTL8723A
9502                 #ifdef CONFIG_RTL8188E
9503                         #ifdef CONFIG_USB_HCI
9504                         addr = EEPROM_VID_88EU;
9505                         #endif
9506                         #ifdef CONFIG_PCI_HCI
9507                         addr = EEPROM_VID_88EE;
9508                         #endif
9509                 #endif // CONFIG_RTL8188E
9510
9511                 #ifdef CONFIG_RTL8192E
9512                         #ifdef CONFIG_USB_HCI
9513                         addr = EEPROM_VID_8192EU;
9514                         #endif
9515                         #ifdef CONFIG_PCI_HCI
9516                         addr = EEPROM_VID_8192EE;
9517                         #endif
9518                 #endif // CONFIG_RTL8192E
9519                 #ifdef CONFIG_RTL8723B
9520                 addr = EEPROM_VID_8723BU;
9521                 #endif // CONFIG_RTL8192E
9522                 cnts = 4;
9523
9524                 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (PVOID)&max_available_size, _FALSE);
9525                 if ((addr + cnts) > max_available_size)
9526                 {
9527                         DBG_871X("%s: addr(0x%02x)+cnts(%d) parameter error!\n", __FUNCTION__, addr, cnts);
9528                         err = -EFAULT;
9529                         goto exit;
9530                 }
9531                 if (rtw_efuse_map_read(padapter, addr, cnts, data) == _FAIL)
9532                 {
9533                         DBG_871X("%s: rtw_efuse_access error!!\n", __FUNCTION__);
9534                         err = -EFAULT;
9535                         goto exit;
9536                 }
9537
9538 //              DBG_871X("%s: {VID,PID}={", __FUNCTION__);
9539                 *extra = 0;
9540                 for (i=0; i<cnts; i++)
9541                 {
9542 //                      DBG_871X("0x%02x", data[i]);
9543                         sprintf(extra, "%s0x%02X", extra, data[i]);
9544                         if (i != (cnts-1))
9545                         {
9546 //                              DBG_871X(",");
9547                                 sprintf(extra,"%s,",extra);
9548                         }
9549                 }
9550 //              DBG_871X("}\n");
9551         }
9552         else if (strcmp(tmp[0], "ableraw") == 0)
9553         {
9554                 efuse_GetCurrentSize(padapter,&raw_cursize);
9555                 raw_maxsize = efuse_GetMaxSize(padapter);
9556                 sprintf(extra, "[available raw size]= %d bytes", raw_maxsize-raw_cursize);
9557         }
9558         else if (strcmp(tmp[0], "btfmap") == 0)
9559         {
9560                 BTEfuse_PowerSwitch(padapter,1,_TRUE);
9561
9562                 mapLen = EFUSE_BT_MAX_MAP_LEN;
9563                 if (rtw_BT_efuse_map_read(padapter, 0, mapLen, pEfuseHal->BTEfuseInitMap) == _FAIL)
9564                 {
9565                         DBG_871X("%s: rtw_BT_efuse_map_read Fail!!\n", __FUNCTION__);
9566                         err = -EFAULT;
9567                         goto exit;
9568                 }
9569
9570 //              DBG_871X("OFFSET\tVALUE(hex)\n");
9571                 sprintf(extra, "\n");
9572                 for (i=0; i<512; i+=16) // set 512 because the iwpriv's extra size have limit 0x7FF
9573                 {
9574 //                      DBG_871X("0x%03x\t", i);
9575                         sprintf(extra, "%s0x%03x\t", extra, i);
9576                         for (j=0; j<8; j++) {
9577 //                              DBG_871X("%02X ", pEfuseHal->BTEfuseInitMap[i+j]);
9578                                 sprintf(extra, "%s%02X ", extra, pEfuseHal->BTEfuseInitMap[i+j]);
9579                         }
9580 //                      DBG_871X("\t");
9581                         sprintf(extra,"%s\t",extra);
9582                         for (; j<16; j++) {
9583 //                              DBG_871X("%02X ", pEfuseHal->BTEfuseInitMap[i+j]);
9584                                 sprintf(extra, "%s%02X ", extra, pEfuseHal->BTEfuseInitMap[i+j]);
9585                         }
9586 //                      DBG_871X("\n");
9587                         sprintf(extra, "%s\n", extra);
9588                 }
9589 //              DBG_871X("\n");
9590         }
9591         else if (strcmp(tmp[0],"btbmap") == 0)
9592         {
9593                 BTEfuse_PowerSwitch(padapter,1,_TRUE);
9594
9595                 mapLen = EFUSE_BT_MAX_MAP_LEN;
9596                 if (rtw_BT_efuse_map_read(padapter, 0, mapLen, pEfuseHal->BTEfuseInitMap) == _FAIL)
9597                 {
9598                         DBG_871X("%s: rtw_BT_efuse_map_read Fail!!\n", __FUNCTION__);
9599                         err = -EFAULT;
9600                         goto exit;
9601                 }
9602
9603 //              DBG_871X("OFFSET\tVALUE(hex)\n");
9604                 sprintf(extra, "\n");
9605                 for (i=512; i<1024 ; i+=16)
9606                 {
9607 //                      DBG_871X("0x%03x\t", i);
9608                         sprintf(extra, "%s0x%03x\t", extra, i);
9609                         for (j=0; j<8; j++)
9610                         {
9611 //                              DBG_871X("%02X ", data[i+j]);
9612                                 sprintf(extra, "%s%02X ", extra, pEfuseHal->BTEfuseInitMap[i+j]);
9613                         }
9614 //                      DBG_871X("\t");
9615                         sprintf(extra,"%s\t",extra);
9616                         for (; j<16; j++) {
9617 //                              DBG_871X("%02X ", data[i+j]);
9618                                 sprintf(extra, "%s%02X ", extra, pEfuseHal->BTEfuseInitMap[i+j]);
9619                         }
9620 //                      DBG_871X("\n");
9621                         sprintf(extra, "%s\n", extra);
9622                 }
9623 //              DBG_871X("\n");
9624         }
9625         else if (strcmp(tmp[0],"btrmap") == 0)
9626         {
9627                 if ((tmp[1]==NULL) || (tmp[2]==NULL))
9628                 {
9629                         err = -EINVAL;
9630                         goto exit;
9631                 }
9632
9633                 BTEfuse_PowerSwitch(padapter,1,_TRUE);
9634
9635                 // rmap addr cnts
9636                 addr = simple_strtoul(tmp[1], &ptmp, 16);
9637                 DBG_871X("%s: addr=0x%X\n", __FUNCTION__, addr);
9638
9639                 cnts = simple_strtoul(tmp[2], &ptmp, 10);
9640                 if (cnts == 0)
9641                 {
9642                         DBG_871X("%s: btrmap Fail!! cnts error!\n", __FUNCTION__);
9643                         err = -EINVAL;
9644                         goto exit;
9645                 }
9646                 DBG_871X("%s: cnts=%d\n", __FUNCTION__, cnts);
9647
9648                 EFUSE_GetEfuseDefinition(padapter, EFUSE_BT, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (PVOID)&max_available_size, _FALSE);
9649                 if ((addr + cnts) > max_available_size)
9650                 {
9651                         DBG_871X("%s: addr(0x%X)+cnts(%d) parameter error!\n", __FUNCTION__, addr, cnts);
9652                         err = -EFAULT;
9653                         goto exit;
9654                 }
9655
9656                 if (rtw_BT_efuse_map_read(padapter, addr, cnts, data) == _FAIL)
9657                 {
9658                         DBG_871X("%s: rtw_BT_efuse_map_read error!!\n", __FUNCTION__);
9659                         err = -EFAULT;
9660                         goto exit;
9661                 }
9662
9663                 *extra = 0;
9664 //              DBG_871X("%s: bt efuse data={", __FUNCTION__);
9665                 for (i=0; i<cnts; i++)
9666                 {
9667 //                      DBG_871X("0x%02x ", data[i]);
9668                         sprintf(extra, "%s 0x%02X ", extra, data[i]);
9669                 }
9670 //              DBG_871X("}\n");
9671                 DBG_871X(FUNC_ADPT_FMT ": BT MAC=[%s]\n", FUNC_ADPT_ARG(padapter), extra);
9672         }
9673         else if (strcmp(tmp[0], "btffake") == 0)
9674         {
9675 //              DBG_871X("OFFSET\tVALUE(hex)\n");
9676                 sprintf(extra, "\n");
9677                 for (i=0; i<512; i+=16)
9678                 {
9679 //                      DBG_871X("0x%03x\t", i);
9680                         sprintf(extra, "%s0x%03x\t", extra, i);
9681                         for (j=0; j<8; j++) {
9682 //                              DBG_871X("%02X ", pEfuseHal->fakeBTEfuseModifiedMap[i+j]);
9683                                 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeBTEfuseModifiedMap[i+j]);
9684                         }
9685 //                      DBG_871X("\t");
9686                         sprintf(extra, "%s\t", extra);
9687                         for (; j<16; j++) {
9688 //                              DBG_871X("%02X ", pEfuseHal->fakeBTEfuseModifiedMap[i+j]);
9689                                 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeBTEfuseModifiedMap[i+j]);
9690                         }
9691 //                      DBG_871X("\n");
9692                         sprintf(extra, "%s\n", extra);
9693                 }
9694 //              DBG_871X("\n");
9695         }
9696         else if (strcmp(tmp[0],"btbfake") == 0)
9697         {
9698 //              DBG_871X("OFFSET\tVALUE(hex)\n");
9699                 sprintf(extra, "\n");
9700                 for (i=512; i<1024; i+=16)
9701                 {
9702 //                      DBG_871X("0x%03x\t", i);
9703                         sprintf(extra, "%s0x%03x\t", extra, i);
9704                         for (j=0; j<8; j++) {
9705 //                              DBG_871X("%02X ", pEfuseHal->fakeBTEfuseModifiedMap[i+j]);
9706                                 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeBTEfuseModifiedMap[i+j]);
9707                         }
9708 //                      DBG_871X("\t");
9709                         sprintf(extra, "%s\t", extra);
9710                         for (; j<16; j++) {
9711 //                              DBG_871X("%02X ", pEfuseHal->fakeBTEfuseModifiedMap[i+j]);
9712                                 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeBTEfuseModifiedMap[i+j]);
9713                         }
9714 //                      DBG_871X("\n");
9715                         sprintf(extra, "%s\n", extra);
9716                 }
9717 //              DBG_871X("\n");
9718         }
9719         else if (strcmp(tmp[0],"wlrfkmap")== 0)
9720         {
9721 //              DBG_871X("OFFSET\tVALUE(hex)\n");
9722                 sprintf(extra, "\n");
9723                 for (i=0; i<EFUSE_MAP_SIZE; i+=16)
9724                 {
9725 //                      DBG_871X("\t0x%02x\t", i);
9726                         sprintf(extra, "%s0x%02x\t", extra, i);
9727                         for (j=0; j<8; j++) {
9728 //                              DBG_871X("%02X ", pEfuseHal->fakeEfuseModifiedMap[i+j]);
9729                                 sprintf(extra, "%s%02X ", extra, pEfuseHal->fakeEfuseModifiedMap[i+j]);
9730                         }
9731 //                      DBG_871X("\t");
9732                         sprintf(extra, "%s\t", extra);
9733                         for (; j<16; j++) {
9734 //                              DBG_871X("%02X ", pEfuseHal->fakeEfuseModifiedMap[i+j]);
9735                                 sprintf(extra, "%s %02X", extra, pEfuseHal->fakeEfuseModifiedMap[i+j]);
9736                         }
9737 //                      DBG_871X("\n");
9738                         sprintf(extra, "%s\n", extra);
9739                 }
9740 //              DBG_871X("\n");
9741
9742         }
9743         else if (strcmp(tmp[0],"wlrfkrmap")== 0)
9744         {
9745                 if ((tmp[1]==NULL) || (tmp[2]==NULL))
9746                                 {
9747                                         DBG_871X("%s: rmap Fail!! Parameters error!\n", __FUNCTION__);
9748                                         err = -EINVAL;
9749                                         goto exit;
9750                                 }
9751                                 // rmap addr cnts
9752                                 addr = simple_strtoul(tmp[1], &ptmp, 16);
9753                                 DBG_871X("%s: addr=%x\n", __FUNCTION__, addr);
9754
9755                                 cnts = simple_strtoul(tmp[2], &ptmp, 10);
9756                                 if (cnts == 0)
9757                                 {
9758                                         DBG_871X("%s: rmap Fail!! cnts error!\n", __FUNCTION__);
9759                                         err = -EINVAL;
9760                                         goto exit;
9761                                 }
9762                                 DBG_871X("%s: cnts=%d\n", __FUNCTION__, cnts);
9763
9764                 //              DBG_871X("%s: data={", __FUNCTION__);
9765                         *extra = 0;
9766                         for (i=0; i<cnts; i++) {
9767                                         DBG_871X("wlrfkrmap = 0x%02x \n", pEfuseHal->fakeEfuseModifiedMap[addr+i]);
9768                                         sprintf(extra, "%s0x%02X ", extra, pEfuseHal->fakeEfuseModifiedMap[addr+i]);
9769                         }
9770         }
9771         else if (strcmp(tmp[0],"btrfkrmap")== 0)
9772         {
9773                 if ((tmp[1]==NULL) || (tmp[2]==NULL))
9774                                 {
9775                                         DBG_871X("%s: rmap Fail!! Parameters error!\n", __FUNCTION__);
9776                                         err = -EINVAL;
9777                                         goto exit;
9778                                 }
9779                                 // rmap addr cnts
9780                                 addr = simple_strtoul(tmp[1], &ptmp, 16);
9781                                 DBG_871X("%s: addr=%x\n", __FUNCTION__, addr);
9782
9783                                 cnts = simple_strtoul(tmp[2], &ptmp, 10);
9784                                 if (cnts == 0)
9785                                 {
9786                                         DBG_871X("%s: rmap Fail!! cnts error!\n", __FUNCTION__);
9787                                         err = -EINVAL;
9788                                         goto exit;
9789                                 }
9790                                 DBG_871X("%s: cnts=%d\n", __FUNCTION__, cnts);
9791
9792                 //              DBG_871X("%s: data={", __FUNCTION__);
9793                         *extra = 0;
9794                         for (i=0; i<cnts; i++) {
9795                                         DBG_871X("wlrfkrmap = 0x%02x \n", pEfuseHal->fakeBTEfuseModifiedMap[addr+i]);
9796                                         sprintf(extra, "%s0x%02X ", extra, pEfuseHal->fakeBTEfuseModifiedMap[addr+i]);
9797                         }
9798         }
9799         else
9800         {
9801                  sprintf(extra, "Command not found!");
9802         }
9803
9804 exit:
9805         if (data)
9806                 rtw_mfree(data, EFUSE_BT_MAX_MAP_LEN);
9807         if (rawdata)
9808                 rtw_mfree(rawdata, EFUSE_BT_MAX_MAP_LEN);
9809         if (!err)
9810                 wrqu->length = strlen(extra);
9811
9812         if (padapter->registrypriv.mp_mode == 0)
9813         {
9814         #ifdef CONFIG_IPS
9815         rtw_pm_set_ips(padapter, ips_mode);
9816 #endif // CONFIG_IPS
9817
9818         #ifdef CONFIG_LPS
9819         rtw_pm_set_lps(padapter, lps_mode);
9820 #endif // CONFIG_LPS
9821         }
9822
9823         #ifdef CONFIG_IOL
9824         padapter->registrypriv.fw_iol = org_fw_iol;// 0:Disable, 1:enable, 2:by usb speed
9825         #endif
9826         return err;
9827 }
9828
9829 static int rtw_mp_efuse_set(struct net_device *dev,
9830                         struct iw_request_info *info,
9831                         union iwreq_data *wdata, char *extra)
9832 {
9833         struct iw_point *wrqu;
9834         PADAPTER padapter;
9835         struct pwrctrl_priv *pwrctrlpriv ;
9836         PHAL_DATA_TYPE pHalData;
9837         PEFUSE_HAL pEfuseHal;
9838
9839         u8 ips_mode = IPS_NUM; // init invalid value
9840         u8 lps_mode = PS_MODE_NUM; // init invalid value
9841         u32 i=0,j=0, jj, kk;
9842         u8 *setdata = NULL;
9843         u8 *ShadowMapBT = NULL;
9844         u8 *ShadowMapWiFi = NULL;
9845         u8 *setrawdata = NULL;
9846         char *pch, *ptmp, *token, *tmp[3]={0x00,0x00,0x00};
9847         u16 addr=0, cnts=0, BTStatus=0 , max_available_size=0;
9848         int err;
9849
9850         wrqu = (struct iw_point*)wdata;
9851         padapter = rtw_netdev_priv(dev);
9852         pwrctrlpriv = adapter_to_pwrctl(padapter);
9853         pHalData = GET_HAL_DATA(padapter);
9854         pEfuseHal = &pHalData->EfuseHal;
9855         err = 0;
9856
9857         if (copy_from_user(extra, wrqu->pointer, wrqu->length))
9858                         return -EFAULT;
9859
9860         setdata = rtw_zmalloc(1024);
9861         if (setdata == NULL)
9862         {
9863                 err = -ENOMEM;
9864                 goto exit;
9865         }
9866         ShadowMapBT = rtw_malloc(EFUSE_BT_MAX_MAP_LEN);
9867         if (ShadowMapBT == NULL)
9868         {
9869                 err = -ENOMEM;
9870                 goto exit;
9871         }
9872         ShadowMapWiFi = rtw_malloc(EFUSE_MAP_SIZE);
9873         if (ShadowMapWiFi == NULL)
9874         {
9875                 err = -ENOMEM;
9876                 goto exit;
9877         }
9878         setrawdata = rtw_malloc(EFUSE_MAX_SIZE);
9879         if (setrawdata == NULL)
9880         {
9881                 err = -ENOMEM;
9882                 goto exit;
9883         }
9884
9885         #ifdef CONFIG_LPS
9886         lps_mode = pwrctrlpriv->power_mgnt;//keep org value
9887         rtw_pm_set_lps(padapter,PS_MODE_ACTIVE);
9888         #endif
9889
9890         #ifdef CONFIG_IPS
9891         ips_mode = pwrctrlpriv->ips_mode;//keep org value
9892         rtw_pm_set_ips(padapter,IPS_NONE);
9893         #endif
9894
9895         pch = extra;
9896         DBG_871X("%s: in=%s\n", __FUNCTION__, extra);
9897
9898         i = 0;
9899         while ((token = strsep(&pch, ",")) != NULL)
9900         {
9901                 if (i > 2) break;
9902                 tmp[i] = token;
9903                 i++;
9904         }
9905
9906         // tmp[0],[1],[2]
9907         // wmap,addr,00e04c871200
9908         if (strcmp(tmp[0], "wmap") == 0)
9909         {
9910                 if ((tmp[1]==NULL) || (tmp[2]==NULL))
9911                 {
9912                         err = -EINVAL;
9913                         goto exit;
9914                 }
9915
9916 #if 1
9917                 // unknown bug workaround, need to fix later
9918                 addr=0x1ff;
9919                 rtw_write8(padapter, EFUSE_CTRL+1, (addr & 0xff));
9920                 rtw_msleep_os(10);
9921                 rtw_write8(padapter, EFUSE_CTRL+2, ((addr >> 8) & 0x03));
9922                 rtw_msleep_os(10);
9923                 rtw_write8(padapter, EFUSE_CTRL+3, 0x72);
9924                 rtw_msleep_os(10);
9925                 rtw_read8(padapter, EFUSE_CTRL);
9926 #endif
9927
9928                 addr = simple_strtoul(tmp[1], &ptmp, 16);
9929                 addr &= 0xFFF;
9930
9931                 cnts = strlen(tmp[2]);
9932                 if (cnts%2)
9933                 {
9934                         err = -EINVAL;
9935                         goto exit;
9936                 }
9937                 cnts /= 2;
9938                 if (cnts == 0)
9939                 {
9940                         err = -EINVAL;
9941                         goto exit;
9942                 }
9943
9944                 DBG_871X("%s: addr=0x%X\n", __FUNCTION__, addr);
9945                 DBG_871X("%s: cnts=%d\n", __FUNCTION__, cnts);
9946                 DBG_871X("%s: map data=%s\n", __FUNCTION__, tmp[2]);
9947
9948                 for (jj=0, kk=0; jj<cnts; jj++, kk+=2)
9949                 {
9950                         setdata[jj] = key_2char2num(tmp[2][kk], tmp[2][kk+1]);
9951                 }
9952 #ifndef CONFIG_RTL8188E
9953                 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (PVOID)&max_available_size, _FALSE);
9954 #else
9955                 //Change to check TYPE_EFUSE_MAP_LEN ,beacuse 8188E raw 256,logic map over 256.
9956                 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (PVOID)&max_available_size, _FALSE);
9957 #endif
9958                 if ((addr+cnts) > max_available_size)
9959                 {
9960                         DBG_871X("%s: addr(0x%X)+cnts(%d) parameter error!\n", __FUNCTION__, addr, cnts);
9961                         err = -EFAULT;
9962                         goto exit;
9963                 }
9964
9965                 if (rtw_efuse_map_write(padapter, addr, cnts, setdata) == _FAIL)
9966                 {
9967                         DBG_871X("%s: rtw_efuse_map_write error!!\n", __FUNCTION__);
9968                         err = -EFAULT;
9969                         goto exit;
9970                 }
9971                 *extra = 0;
9972                 DBG_871X("%s: after rtw_BT_efuse_map_write to _rtw_memcmp \n", __FUNCTION__);
9973                 if ( (rtw_efuse_map_read(padapter, addr, cnts, ShadowMapWiFi) == _SUCCESS ) )
9974                 {
9975                         if (_rtw_memcmp((void*)ShadowMapWiFi ,(void*)setdata,cnts))
9976                         {
9977                                 DBG_871X("%s: WiFi write map afterf compare success\n", __FUNCTION__);
9978                                 sprintf(extra, "WiFi write map compare OK\n");
9979                                 err = 0;
9980                                 goto exit;
9981                         }
9982                         else
9983                         {
9984                                 sprintf(extra, "WiFi write map compare FAIL\n");
9985                                 DBG_871X("%s: WiFi write map compare Fail\n", __FUNCTION__);
9986                                 err = 0;
9987                                 goto exit;
9988                         }
9989                 }
9990         }
9991         else if (strcmp(tmp[0], "wraw") == 0)
9992         {
9993                 if ((tmp[1]==NULL) || (tmp[2]==NULL))
9994                 {
9995                         err = -EINVAL;
9996                         goto exit;
9997                 }
9998
9999                 addr = simple_strtoul( tmp[1], &ptmp, 16 );
10000                 addr &= 0xFFF;
10001
10002                 cnts = strlen(tmp[2]);
10003                 if (cnts%2)
10004                 {
10005                         err = -EINVAL;
10006                         goto exit;
10007                 }
10008                 cnts /= 2;
10009                 if (cnts == 0)
10010                 {
10011                         err = -EINVAL;
10012                         goto exit;
10013                 }
10014
10015                 DBG_871X("%s: addr=0x%X\n", __FUNCTION__, addr);
10016                 DBG_871X("%s: cnts=%d\n", __FUNCTION__, cnts);
10017                 DBG_871X("%s: raw data=%s\n", __FUNCTION__, tmp[2]);
10018
10019                 for (jj=0, kk=0; jj<cnts; jj++, kk+=2)
10020                 {
10021                         setrawdata[jj] = key_2char2num(tmp[2][kk], tmp[2][kk+1]);
10022                 }
10023
10024                 if (rtw_efuse_access(padapter, _TRUE, addr, cnts, setrawdata) == _FAIL)
10025                 {
10026                         DBG_871X("%s: rtw_efuse_access error!!\n", __FUNCTION__);
10027                         err = -EFAULT;
10028                         goto exit;
10029                 }
10030         }
10031         else if (strcmp(tmp[0], "mac") == 0)
10032         {
10033                 if (tmp[1]==NULL)
10034                 {
10035                         err = -EINVAL;
10036                         goto exit;
10037                 }
10038
10039                 //mac,00e04c871200
10040                 #ifdef CONFIG_RTL8192C
10041                 addr = EEPROM_MAC_ADDR_92C;
10042                 #endif
10043                 #ifdef CONFIG_RTL8192D
10044                         #ifdef CONFIG_USB_HCI
10045                         if (pHalData->interfaceIndex == 0)
10046                                 addr = EEPROM_MAC_ADDR_MAC0_92DU;
10047                         else
10048                                 addr = EEPROM_MAC_ADDR_MAC1_92DU;
10049                         #else
10050                         if (pHalData->interfaceIndex == 0)
10051                                 addr = EEPROM_MAC_ADDR_MAC0_92DE;
10052                         else
10053                                 addr = EEPROM_MAC_ADDR_MAC1_92DE;
10054                         #endif
10055                 #endif
10056                 #ifdef CONFIG_RTL8723A
10057                 #ifdef CONFIG_SDIO_HCI
10058                 addr = EEPROM_MAC_ADDR_8723AS;
10059                 #endif
10060                 #ifdef CONFIG_GSPI_HCI
10061                 addr = EEPROM_MAC_ADDR_8723AS;
10062                 #endif
10063                 #ifdef CONFIG_USB_HCI
10064                 addr = EEPROM_MAC_ADDR_8723AU;
10065                 #endif
10066                 #endif // CONFIG_RTL8723A
10067                 #ifdef CONFIG_RTL8188E
10068                         #ifdef CONFIG_USB_HCI
10069                         addr = EEPROM_MAC_ADDR_88EU;
10070                         #endif
10071                         #ifdef CONFIG_SDIO_HCI
10072                         addr = EEPROM_MAC_ADDR_88ES;
10073                         #endif
10074                         #ifdef CONFIG_PCI_HCI
10075                         addr = EEPROM_MAC_ADDR_88EE;
10076                         #endif
10077                 #endif //#ifdef CONFIG_RTL8188E
10078
10079                 #ifdef CONFIG_RTL8192E
10080                         #ifdef CONFIG_USB_HCI
10081                         addr = EEPROM_MAC_ADDR_8192EU;
10082                         #endif
10083                         #ifdef CONFIG_SDIO_HCI
10084                         addr = EEPROM_MAC_ADDR_8192ES;
10085                         #endif
10086                         #ifdef CONFIG_PCI_HCI
10087                         addr = EEPROM_MAC_ADDR_8192EE;
10088                         #endif
10089                 #endif //#ifdef CONFIG_RTL8192E
10090
10091                 #ifdef CONFIG_RTL8723B
10092                 #ifdef CONFIG_SDIO_HCI
10093                 addr = EEPROM_MAC_ADDR_8723BS;
10094                 #endif
10095                 #ifdef CONFIG_GSPI_HCI
10096                 addr = EEPROM_MAC_ADDR_8723BS;
10097                 #endif
10098                 #ifdef CONFIG_USB_HCI
10099                 addr = EEPROM_MAC_ADDR_8723BU;
10100                 #endif
10101                 #endif // CONFIG_RTL8723B
10102
10103                 cnts = strlen(tmp[1]);
10104                 if (cnts%2)
10105                 {
10106                         err = -EINVAL;
10107                         goto exit;
10108                 }
10109                 cnts /= 2;
10110                 if (cnts == 0)
10111                 {
10112                         err = -EINVAL;
10113                         goto exit;
10114                 }
10115                 if (cnts > 6)
10116                 {
10117                         DBG_871X("%s: error data for mac addr=\"%s\"\n", __FUNCTION__, tmp[1]);
10118                         err = -EFAULT;
10119                         goto exit;
10120                 }
10121
10122                 DBG_871X("%s: addr=0x%X\n", __FUNCTION__, addr);
10123                 DBG_871X("%s: cnts=%d\n", __FUNCTION__, cnts);
10124                 DBG_871X("%s: MAC address=%s\n", __FUNCTION__, tmp[1]);
10125
10126                 for (jj=0, kk=0; jj<cnts; jj++, kk+=2)
10127                 {
10128                         setdata[jj] = key_2char2num(tmp[1][kk], tmp[1][kk+1]);
10129                 }
10130 #ifndef CONFIG_RTL8188E
10131                 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (PVOID)&max_available_size, _FALSE);
10132 #else
10133                 //Change to check TYPE_EFUSE_MAP_LEN ,beacuse 8188E raw 256,logic map over 256.
10134                 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (PVOID)&max_available_size, _FALSE);
10135 #endif
10136                 if ((addr+cnts) > max_available_size)
10137                 {
10138                         DBG_871X("%s: addr(0x%X)+cnts(%d) parameter error!\n", __FUNCTION__, addr, cnts);
10139                         err = -EFAULT;
10140                         goto exit;
10141                 }
10142
10143                 if (rtw_efuse_map_write(padapter, addr, cnts, setdata) == _FAIL)
10144                 {
10145                         DBG_871X("%s: rtw_efuse_map_write error!!\n", __FUNCTION__);
10146                         err = -EFAULT;
10147                         goto exit;
10148                 }
10149         }
10150         else if (strcmp(tmp[0], "vidpid") == 0)
10151         {
10152                 if (tmp[1]==NULL)
10153                 {
10154                         err = -EINVAL;
10155                         goto exit;
10156                 }
10157
10158                 // pidvid,da0b7881
10159                 #ifdef CONFIG_RTL8192C
10160                 addr = EEPROM_VID_92C;
10161                 #endif // CONFIG_RTL8192C
10162                 #ifdef CONFIG_RTL8192D
10163                         #ifdef CONFIG_USB_HCI
10164                         addr = EEPROM_VID_92DU;
10165                         #else
10166                         addr = EEPROM_VID_92DE;
10167                         #endif
10168                 #endif // CONFIG_RTL8192D
10169                 #ifdef CONFIG_RTL8723A
10170                         #ifdef CONFIG_USB_HCI
10171                         addr = EEPROM_VID_8723AU;
10172                         #endif
10173                 #endif // CONFIG_RTL8723A
10174                 #ifdef CONFIG_RTL8188E
10175                         #ifdef CONFIG_USB_HCI
10176                         addr = EEPROM_VID_88EU;
10177                         #endif
10178                         #ifdef CONFIG_PCI_HCI
10179                         addr = EEPROM_VID_88EE;
10180                         #endif
10181                 #endif // CONFIG_RTL8188E
10182
10183                 #ifdef CONFIG_RTL8192E
10184                         #ifdef CONFIG_USB_HCI
10185                         addr = EEPROM_VID_8192EU;
10186                         #endif
10187                         #ifdef CONFIG_PCI_HCI
10188                         addr = EEPROM_VID_8192EE;
10189                         #endif
10190                 #endif // CONFIG_RTL8188E
10191
10192                 #ifdef CONFIG_RTL8723B
10193                 addr = EEPROM_VID_8723BU;
10194                 #endif
10195
10196                 cnts = strlen(tmp[1]);
10197                 if (cnts%2)
10198                 {
10199                         err = -EINVAL;
10200                         goto exit;
10201                 }
10202                 cnts /= 2;
10203                 if (cnts == 0)
10204                 {
10205                         err = -EINVAL;
10206                         goto exit;
10207                 }
10208
10209                 DBG_871X("%s: addr=0x%X\n", __FUNCTION__, addr);
10210                 DBG_871X("%s: cnts=%d\n", __FUNCTION__, cnts);
10211                 DBG_871X("%s: VID/PID=%s\n", __FUNCTION__, tmp[1]);
10212
10213                 for (jj=0, kk=0; jj<cnts; jj++, kk+=2)
10214                 {
10215                         setdata[jj] = key_2char2num(tmp[1][kk], tmp[1][kk+1]);
10216                 }
10217
10218                 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (PVOID)&max_available_size, _FALSE);
10219                 if ((addr+cnts) > max_available_size)
10220                 {
10221                         DBG_871X("%s: addr(0x%X)+cnts(%d) parameter error!\n", __FUNCTION__, addr, cnts);
10222                         err = -EFAULT;
10223                         goto exit;
10224                 }
10225
10226                 if (rtw_efuse_map_write(padapter, addr, cnts, setdata) == _FAIL)
10227                 {
10228                         DBG_871X("%s: rtw_efuse_map_write error!!\n", __FUNCTION__);
10229                         err = -EFAULT;
10230                         goto exit;
10231                 }
10232         }
10233         else if (strcmp(tmp[0], "wldumpfake") == 0)
10234         {
10235                 if (rtw_efuse_map_read(padapter, 0, EFUSE_MAP_SIZE,  pEfuseHal->fakeEfuseModifiedMap) == _SUCCESS) {
10236                         DBG_871X("%s: WiFi hw efuse dump to Fake map success \n", __FUNCTION__);
10237                 } else {
10238                         DBG_871X("%s: WiFi hw efuse dump to Fake map Fail \n", __FUNCTION__);
10239                         err = -EFAULT;
10240                 }
10241         }
10242         else if (strcmp(tmp[0], "btwmap") == 0)
10243         {
10244                 rtw_write8(padapter, 0xa3, 0x05); //For 8723AB ,8821S ?
10245                 BTStatus=rtw_read8(padapter, 0xa0);
10246                 DBG_871X("%s: btwmap before read 0xa0 BT Status =0x%x \n", __FUNCTION__,BTStatus);
10247                 if (BTStatus != 0x04)
10248                 {
10249                         sprintf(extra, "BT Status not Active Write FAIL\n");
10250                         goto exit;
10251                 }
10252
10253                 if ((tmp[1]==NULL) || (tmp[2]==NULL))
10254                 {
10255                         err = -EINVAL;
10256                         goto exit;
10257                 }
10258                 BTEfuse_PowerSwitch(padapter,1,_TRUE);
10259
10260                 addr=0x1ff;
10261                 rtw_write8(padapter, EFUSE_CTRL+1, (addr & 0xff));
10262                 rtw_msleep_os(10);
10263                 rtw_write8(padapter, EFUSE_CTRL+2, ((addr >> 8) & 0x03));
10264                 rtw_msleep_os(10);
10265                 rtw_write8(padapter, EFUSE_CTRL+3, 0x72);
10266                 rtw_msleep_os(10);
10267                 rtw_read8(padapter, EFUSE_CTRL);
10268
10269                 addr = simple_strtoul(tmp[1], &ptmp, 16);
10270                 addr &= 0xFFF;
10271
10272                 cnts = strlen(tmp[2]);
10273                 if (cnts%2)
10274                 {
10275                         err = -EINVAL;
10276                         goto exit;
10277                 }
10278                 cnts /= 2;
10279                 if (cnts == 0)
10280                 {
10281                         err = -EINVAL;
10282                         goto exit;
10283                 }
10284
10285                 DBG_871X("%s: addr=0x%X\n", __FUNCTION__, addr);
10286                 DBG_871X("%s: cnts=%d\n", __FUNCTION__, cnts);
10287                 DBG_871X("%s: BT data=%s\n", __FUNCTION__, tmp[2]);
10288
10289                 for (jj=0, kk=0; jj<cnts; jj++, kk+=2)
10290                 {
10291                         setdata[jj] = key_2char2num(tmp[2][kk], tmp[2][kk+1]);
10292                 }
10293
10294                 EFUSE_GetEfuseDefinition(padapter, EFUSE_BT, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (PVOID)&max_available_size, _FALSE);
10295                 if ((addr+cnts) > max_available_size)
10296                 {
10297                         DBG_871X("%s: addr(0x%X)+cnts(%d) parameter error!\n", __FUNCTION__, addr, cnts);
10298                         err = -EFAULT;
10299                         goto exit;
10300                 }
10301
10302                 if (rtw_BT_efuse_map_write(padapter, addr, cnts, setdata) == _FAIL)
10303                 {
10304                         DBG_871X("%s: rtw_BT_efuse_map_write error!!\n", __FUNCTION__);
10305                         err = -EFAULT;
10306                         goto exit;
10307                 }
10308                 *extra = 0;
10309                 DBG_871X("%s: after rtw_BT_efuse_map_write to _rtw_memcmp \n", __FUNCTION__);
10310                 if ( (rtw_BT_efuse_map_read(padapter, addr, cnts, ShadowMapBT ) == _SUCCESS ) )
10311                 {
10312                         if (_rtw_memcmp((void*)ShadowMapBT ,(void*)setdata,cnts))
10313                         {
10314                                 DBG_871X("%s: BT write map compare OK BTStatus=0x%x\n", __FUNCTION__,BTStatus);
10315                                 sprintf(extra, "BT write map compare OK");
10316                                 err = 0;
10317                                 goto exit;
10318                         }
10319                         else
10320                         {
10321                                 sprintf(extra, "BT write map compare FAIL");
10322                                 DBG_871X("%s: BT write map compare FAIL BTStatus=0x%x\n", __FUNCTION__,BTStatus);
10323                                 err = 0;
10324                                 goto exit;
10325                         }
10326                 }
10327         }
10328         else if (strcmp(tmp[0], "btwfake") == 0)
10329         {
10330                 if ((tmp[1]==NULL) || (tmp[2]==NULL))
10331                 {
10332                         err = -EINVAL;
10333                         goto exit;
10334                 }
10335
10336                 addr = simple_strtoul(tmp[1], &ptmp, 16);
10337                 addr &= 0xFFF;
10338
10339                 cnts = strlen(tmp[2]);
10340                 if (cnts%2)
10341                 {
10342                         err = -EINVAL;
10343                         goto exit;
10344                 }
10345                 cnts /= 2;
10346                 if (cnts == 0)
10347                 {
10348                         err = -EINVAL;
10349                         goto exit;
10350                 }
10351
10352                 DBG_871X("%s: addr=0x%X\n", __FUNCTION__, addr);
10353                 DBG_871X("%s: cnts=%d\n", __FUNCTION__, cnts);
10354                 DBG_871X("%s: BT tmp data=%s\n", __FUNCTION__, tmp[2]);
10355
10356                 for (jj=0, kk=0; jj<cnts; jj++, kk+=2)
10357                 {
10358                         pEfuseHal->fakeBTEfuseModifiedMap[addr+jj] = key_2char2num(tmp[2][kk], tmp[2][kk+1]);
10359                 }
10360         }
10361         else if (strcmp(tmp[0], "btdumpfake") == 0)
10362         {
10363                 if (rtw_BT_efuse_map_read(padapter, 0, EFUSE_BT_MAX_MAP_LEN, pEfuseHal->fakeBTEfuseModifiedMap) == _SUCCESS) {
10364                         DBG_871X("%s: BT read all map success\n", __FUNCTION__);
10365                 } else {
10366                         DBG_871X("%s: BT read all map Fail!\n", __FUNCTION__);
10367                         err = -EFAULT;
10368                 }
10369         }
10370         else if (strcmp(tmp[0], "btfk2map") == 0)
10371         {
10372                 rtw_write8(padapter, 0xa3, 0x05);
10373                 BTStatus=rtw_read8(padapter, 0xa0);
10374                 DBG_871X("%s: btwmap before read 0xa0 BT Status =0x%x \n", __FUNCTION__,BTStatus);
10375                 if (BTStatus != 0x04)
10376                 {
10377                         sprintf(extra, "BT Status not Active Write FAIL\n");
10378                         goto exit;
10379                 }
10380
10381                 BTEfuse_PowerSwitch(padapter,1,_TRUE);
10382
10383                 addr=0x1ff;
10384                 rtw_write8(padapter, EFUSE_CTRL+1, (addr & 0xff));
10385                 rtw_msleep_os(10);
10386                 rtw_write8(padapter, EFUSE_CTRL+2, ((addr >> 8) & 0x03));
10387                 rtw_msleep_os(10);
10388                 rtw_write8(padapter, EFUSE_CTRL+3, 0x72);
10389                 rtw_msleep_os(10);
10390                 rtw_read8(padapter, EFUSE_CTRL);
10391
10392                 _rtw_memcpy(pEfuseHal->BTEfuseModifiedMap, pEfuseHal->fakeBTEfuseModifiedMap, EFUSE_BT_MAX_MAP_LEN);
10393
10394                 EFUSE_GetEfuseDefinition(padapter, EFUSE_BT, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (PVOID)&max_available_size, _FALSE);
10395                 if (max_available_size < 1)
10396                 {
10397                         err = -EFAULT;
10398                         goto exit;
10399                 }
10400
10401                 if (rtw_BT_efuse_map_write(padapter, 0x00, EFUSE_BT_MAX_MAP_LEN, pEfuseHal->fakeBTEfuseModifiedMap) == _FAIL)
10402                 {
10403                         DBG_871X("%s: rtw_BT_efuse_map_write error!\n", __FUNCTION__);
10404                         err = -EFAULT;
10405                         goto exit;
10406                 }
10407
10408                 DBG_871X("pEfuseHal->fakeBTEfuseModifiedMap OFFSET\tVALUE(hex)\n");
10409                 for (i = 0; i < EFUSE_BT_MAX_MAP_LEN; i += 16)
10410                 {
10411                         printk("0x%02x\t", i);
10412                         for (j=0; j<8; j++) {
10413                                 printk("%02X ", pEfuseHal->fakeBTEfuseModifiedMap[i+j]);
10414                         }
10415                         printk("\t");
10416
10417                         for (; j<16; j++) {
10418                                 printk("%02X ", pEfuseHal->fakeBTEfuseModifiedMap[i+j]);
10419                         }
10420                         printk("\n");
10421                 }
10422                 printk("\n");
10423 #if 1
10424                 err = -EFAULT;
10425                 DBG_871X("%s: rtw_BT_efuse_map_read _rtw_memcmp \n", __FUNCTION__);
10426                 if ( (rtw_BT_efuse_map_read(padapter, 0x00, EFUSE_BT_MAX_MAP_LEN, pEfuseHal->fakeBTEfuseInitMap) == _SUCCESS ) )
10427                 {
10428                         if (_rtw_memcmp((void*)pEfuseHal->fakeBTEfuseModifiedMap,(void*)pEfuseHal->fakeBTEfuseInitMap,EFUSE_BT_MAX_MAP_LEN))
10429                         {
10430                                 sprintf(extra, "BT write map compare OK");
10431                                 DBG_871X("%s: BT write map afterf compare success BTStatus=0x%x \n", __FUNCTION__,BTStatus);
10432                                 err = 0;
10433                                 goto exit;
10434                         }
10435                         else
10436                         {
10437                                 sprintf(extra, "BT write map compare FAIL");
10438                                 if (rtw_BT_efuse_map_write(padapter, 0x00, EFUSE_BT_MAX_MAP_LEN, pEfuseHal->fakeBTEfuseModifiedMap) == _FAIL)
10439                                 {
10440                                         DBG_871X("%s: rtw_BT_efuse_map_write compare error,retry = %d!\n", __FUNCTION__,i);
10441                                 }
10442
10443                                 if (rtw_BT_efuse_map_read(padapter, EFUSE_BT, EFUSE_BT_MAX_MAP_LEN, pEfuseHal->fakeBTEfuseInitMap) == _SUCCESS)
10444                                 {
10445                                         DBG_871X("pEfuseHal->fakeBTEfuseInitMap OFFSET\tVALUE(hex)\n");
10446
10447                                         for (i = 0; i < EFUSE_BT_MAX_MAP_LEN; i += 16)
10448                                         {
10449                                                 printk("0x%02x\t", i);
10450                                                 for (j=0; j<8; j++) {
10451                                                         printk("%02X ", pEfuseHal->fakeBTEfuseInitMap[i+j]);
10452                                                 }
10453                                                 printk("\t");
10454                                                 for (; j<16; j++) {
10455                                                         printk("%02X ", pEfuseHal->fakeBTEfuseInitMap[i+j]);
10456                                                 }
10457                                                 printk("\n");
10458                                         }
10459                                         printk("\n");
10460                                 }
10461                                 DBG_871X("%s: BT write map afterf compare not match to write efuse try write Map again , BTStatus=0x%x\n", __FUNCTION__,BTStatus);
10462                                 goto exit;
10463                         }
10464                 }
10465 #endif
10466
10467         }
10468         else if (strcmp(tmp[0], "wlfk2map") == 0)
10469         {
10470                 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (PVOID)&max_available_size, _FALSE);
10471                 if (max_available_size < 1)
10472                 {
10473                         err = -EFAULT;
10474                         goto exit;
10475                 }
10476                 if (rtw_efuse_map_write(padapter, 0x00, EFUSE_MAP_SIZE, pEfuseHal->fakeEfuseModifiedMap) == _FAIL)
10477                 {
10478                         DBG_871X("%s: rtw_efuse_map_write fakeEfuseModifiedMap error!\n", __FUNCTION__);
10479                         err = -EFAULT;
10480                         goto exit;
10481                 }
10482                 *extra = 0;
10483                 DBG_871X("%s: after rtw_BT_efuse_map_write to _rtw_memcmp \n", __FUNCTION__);
10484                 if ( (rtw_efuse_map_read(padapter, 0x00, EFUSE_MAP_SIZE, ShadowMapWiFi) == _SUCCESS ) )
10485                 {
10486                         if (_rtw_memcmp((void*)ShadowMapWiFi ,(void*)setdata,cnts))
10487                         {
10488                                 DBG_871X("%s: WiFi write map afterf compare OK\n", __FUNCTION__);
10489                                 sprintf(extra, "WiFi write map compare OK\n");
10490                                 err = 0;
10491                                 goto exit;
10492                         }
10493                         else
10494                         {
10495                                 sprintf(extra, "WiFi write map compare FAIL\n");
10496                                 DBG_871X("%s: WiFi write map compare Fail\n", __FUNCTION__);
10497                                 err = 0;
10498                                 goto exit;
10499                         }
10500                 }
10501         }
10502         else if (strcmp(tmp[0], "wlwfake") == 0)
10503         {
10504                 if ((tmp[1]==NULL) || (tmp[2]==NULL))
10505                 {
10506                         err = -EINVAL;
10507                         goto exit;
10508                 }
10509
10510                 addr = simple_strtoul(tmp[1], &ptmp, 16);
10511                 addr &= 0xFFF;
10512
10513                 cnts = strlen(tmp[2]);
10514                 if (cnts%2)
10515                 {
10516                         err = -EINVAL;
10517                         goto exit;
10518                 }
10519                 cnts /= 2;
10520                 if (cnts == 0)
10521                 {
10522                         err = -EINVAL;
10523                         goto exit;
10524                 }
10525
10526                 DBG_871X("%s: addr=0x%X\n", __FUNCTION__, addr);
10527                 DBG_871X("%s: cnts=%d\n", __FUNCTION__, cnts);
10528                 DBG_871X("%s: map tmp data=%s\n", __FUNCTION__, tmp[2]);
10529
10530                 for (jj=0, kk=0; jj<cnts; jj++, kk+=2)
10531                 {
10532                         pEfuseHal->fakeEfuseModifiedMap[addr+jj] = key_2char2num(tmp[2][kk], tmp[2][kk+1]);
10533                 }
10534         }
10535
10536 exit:
10537         if (setdata)
10538                 rtw_mfree(setdata, 1024);
10539         if (ShadowMapBT)
10540                 rtw_mfree(ShadowMapBT, EFUSE_BT_MAX_MAP_LEN);
10541         if (ShadowMapWiFi)
10542                 rtw_mfree(ShadowMapWiFi, EFUSE_MAP_SIZE);
10543         if (setrawdata)
10544                 rtw_mfree(setrawdata, EFUSE_MAX_SIZE);
10545
10546         wrqu->length = strlen(extra);
10547
10548         if (padapter->registrypriv.mp_mode == 0)
10549         {
10550         #ifdef CONFIG_IPS
10551         rtw_pm_set_ips(padapter, ips_mode);
10552         #endif // CONFIG_IPS
10553
10554         #ifdef CONFIG_LPS
10555         rtw_pm_set_lps(padapter, lps_mode);
10556         #endif // CONFIG_LPS
10557         }
10558
10559         return err;
10560 }
10561
10562 #if defined(CONFIG_MP_INCLUDED) && defined(CONFIG_MP_IWPRIV_SUPPORT)
10563 /*
10564  * Input Format: %s,%d,%d
10565  *      %s is width, could be
10566  *              "b" for 1 byte
10567  *              "w" for WORD (2 bytes)
10568  *              "dw" for DWORD (4 bytes)
10569  *      1st %d is address(offset)
10570  *      2st %d is data to write
10571  */
10572 static int rtw_mp_write_reg(struct net_device *dev,
10573                         struct iw_request_info *info,
10574                         struct iw_point *wrqu, char *extra)
10575 {
10576         char *pch, *pnext, *ptmp;
10577         char *width_str;
10578         char width;
10579         u32 addr, data;
10580         int ret;
10581         PADAPTER padapter = rtw_netdev_priv(dev);
10582         char input[wrqu->length];
10583
10584         if (copy_from_user(input, wrqu->pointer, wrqu->length))
10585                                  return -EFAULT;
10586
10587         _rtw_memset(extra, 0, wrqu->length);
10588
10589         pch = input;
10590
10591         pnext = strpbrk(pch, " ,.-");
10592         if (pnext == NULL) return -EINVAL;
10593         *pnext = 0;
10594         width_str = pch;
10595
10596         pch = pnext + 1;
10597         pnext = strpbrk(pch, " ,.-");
10598         if (pnext == NULL) return -EINVAL;
10599         *pnext = 0;
10600         addr = simple_strtoul(pch, &ptmp, 16);
10601         if (addr > 0x3FFF) return -EINVAL;
10602
10603         pch = pnext + 1;
10604         if ((pch - extra) >= wrqu->length) return -EINVAL;
10605         data = simple_strtoul(pch, &ptmp, 16);
10606
10607         ret = 0;
10608         width = width_str[0];
10609         switch (width) {
10610                 case 'b':
10611                         // 1 byte
10612                         if (data > 0xFF) {
10613                                 ret = -EINVAL;
10614                                 break;
10615                         }
10616                         rtw_write8(padapter, addr, data);
10617                         break;
10618                 case 'w':
10619                         // 2 bytes
10620                         if (data > 0xFFFF) {
10621                                 ret = -EINVAL;
10622                                 break;
10623                         }
10624                         rtw_write16(padapter, addr, data);
10625                         break;
10626                 case 'd':
10627                         // 4 bytes
10628                         rtw_write32(padapter, addr, data);
10629                         break;
10630                 default:
10631                         ret = -EINVAL;
10632                         break;
10633         }
10634
10635         return ret;
10636 }
10637
10638 /*
10639  * Input Format: %s,%d
10640  *      %s is width, could be
10641  *              "b" for 1 byte
10642  *              "w" for WORD (2 bytes)
10643  *              "dw" for DWORD (4 bytes)
10644  *      %d is address(offset)
10645  *
10646  * Return:
10647  *      %d for data readed
10648  */
10649 static int rtw_mp_read_reg(struct net_device *dev,
10650                         struct iw_request_info *info,
10651                         struct iw_point *wrqu, char *extra)
10652 {
10653         char input[wrqu->length];
10654         char *pch, *pnext, *ptmp;
10655         char *width_str;
10656         char width;
10657         char data[20],tmp[20];
10658         u32 addr;
10659         //u32 *data = (u32*)extra;
10660         u32 ret, i=0, j=0, strtout=0;
10661         PADAPTER padapter = rtw_netdev_priv(dev);
10662
10663
10664         if (wrqu->length > 128)
10665                 return -EFAULT;
10666
10667         if (copy_from_user(input, wrqu->pointer, wrqu->length))
10668                 return -EFAULT;
10669
10670         _rtw_memset(data, 0, 20);
10671         _rtw_memset(tmp, 0, 20);
10672         _rtw_memset(extra, 0, wrqu->length);
10673
10674         pch = input;
10675         pnext = strpbrk(pch, " ,.-");
10676         if (pnext == NULL) return -EINVAL;
10677         *pnext = 0;
10678         width_str = pch;
10679
10680         pch = pnext + 1;
10681         if ((pch - input) >= wrqu->length) return -EINVAL;
10682
10683         addr = simple_strtoul(pch, &ptmp, 16);
10684         if (addr > 0x3FFF) return -EINVAL;
10685
10686         ret = 0;
10687         width = width_str[0];
10688         switch (width)
10689         {
10690                 case 'b':
10691                         // 1 byte
10692                         // *(u8*)data = rtw_read8(padapter, addr);
10693                         sprintf(extra, "%d\n",  rtw_read8(padapter, addr));
10694                         wrqu->length = strlen(extra);
10695                         break;
10696                 case 'w':
10697                         // 2 bytes
10698                         //*(u16*)data = rtw_read16(padapter, addr);
10699                         sprintf(data, "%04x\n", rtw_read16(padapter, addr));
10700                         for( i=0 ; i <= strlen(data) ; i++)
10701                                 {
10702                                           if( i%2==0 )
10703                                           {
10704                                                    tmp[j]=' ';
10705                                                    j++;
10706                                           }
10707                                           if ( data[i] != '\0' )
10708                                                  tmp[j] = data[i];
10709
10710                                                  j++;
10711                                 }
10712                                 pch = tmp;
10713                                 DBG_871X("pch=%s",pch);
10714
10715                                 while( *pch != '\0' )
10716                                 {
10717                                         pnext = strpbrk(pch, " ");
10718                                         if (!pnext)
10719                                                 break;
10720
10721                                         pnext++;
10722                                         if ( *pnext != '\0' )
10723                                         {
10724                                                   strtout = simple_strtoul (pnext , &ptmp, 16);
10725                                                   sprintf( extra, "%s %d" ,extra ,strtout );
10726                                         }
10727                                         else{
10728                                                   break;
10729                                         }
10730                                         pch = pnext;
10731                                 }
10732                         wrqu->length = 7;
10733                         break;
10734                 case 'd':
10735                         // 4 bytes
10736                         //*data = rtw_read32(padapter, addr);
10737                         sprintf(data, "%08x", rtw_read32(padapter, addr));
10738                                 //add read data format blank
10739                                 for( i=0 ; i <= strlen(data) ; i++)
10740                                 {
10741                                           if( i%2==0 )
10742                                           {
10743                                                    tmp[j]=' ';
10744                                                    j++;
10745                                           }
10746                                           if ( data[i] != '\0' )
10747                                           tmp[j] = data[i];
10748
10749                                           j++;
10750                                 }
10751                                 pch = tmp;
10752                                 DBG_871X("pch=%s",pch);
10753
10754                                 while( *pch != '\0' )
10755                                 {
10756                                         pnext = strpbrk(pch, " ");
10757                                         if (!pnext)
10758                                                 break;
10759
10760                                         pnext++;
10761                                         if ( *pnext != '\0' )
10762                                         {
10763                                                   strtout = simple_strtoul (pnext , &ptmp, 16);
10764                                                   sprintf( extra, "%s %d" ,extra ,strtout );
10765                                         }
10766                                         else{
10767                         break;
10768                                         }
10769                                         pch = pnext;
10770                                 }
10771                         wrqu->length = strlen(extra);
10772                         break;
10773
10774                 default:
10775                         wrqu->length = 0;
10776                         ret = -EINVAL;
10777                         break;
10778
10779         }
10780
10781         return ret;
10782 }
10783
10784 /*
10785  * Input Format: %d,%x,%x
10786  *      %d is RF path, should be smaller than MAX_RF_PATH_NUMS
10787  *      1st %x is address(offset)
10788  *      2st %x is data to write
10789  */
10790  static int rtw_mp_write_rf(struct net_device *dev,
10791                         struct iw_request_info *info,
10792                         struct iw_point *wrqu, char *extra)
10793 {
10794 /*static int rtw_mp_write_rf(struct net_device *dev,
10795                         struct iw_request_info *info,
10796                         union iwreq_data *wrqu, char *extra)
10797 */
10798         u32 path, addr, data;
10799         int ret;
10800         PADAPTER padapter = rtw_netdev_priv(dev);
10801         char input[wrqu->length];
10802
10803         if (copy_from_user(input, wrqu->pointer, wrqu->length))
10804                          return -EFAULT;
10805
10806
10807         ret = sscanf(input, "%d,%x,%x", &path, &addr, &data);
10808         if (ret < 3) return -EINVAL;
10809
10810         if (path >= GET_HAL_RFPATH_NUM(padapter)) return -EINVAL;
10811         if (addr > 0xFF) return -EINVAL;
10812         if (data > 0xFFFFF) return -EINVAL;
10813
10814         _rtw_memset(extra, 0, wrqu->length);
10815
10816         write_rfreg(padapter, path, addr, data);
10817
10818         sprintf(extra, "write_rf completed \n");
10819         wrqu->length = strlen(extra);
10820
10821         return 0;
10822 }
10823
10824 /*
10825  * Input Format: %d,%x
10826  *      %d is RF path, should be smaller than MAX_RF_PATH_NUMS
10827  *      %x is address(offset)
10828  *
10829  * Return:
10830  *      %d for data readed
10831  */
10832 static int rtw_mp_read_rf(struct net_device *dev,
10833                         struct iw_request_info *info,
10834                         struct iw_point *wrqu, char *extra)
10835 {
10836         char input[wrqu->length];
10837         char *pch, *pnext, *ptmp;
10838         char data[20],tmp[20];
10839         //u32 *data = (u32*)extra;
10840         u32 path, addr;
10841         u32 ret,i=0 ,j=0,strtou=0;
10842         PADAPTER padapter = rtw_netdev_priv(dev);
10843
10844
10845         if (wrqu->length > 128) return -EFAULT;
10846         if (copy_from_user(input, wrqu->pointer, wrqu->length))
10847                 return -EFAULT;
10848
10849         ret = sscanf(input, "%d,%x", &path, &addr);
10850         if (ret < 2) return -EINVAL;
10851
10852         if (path >= GET_HAL_RFPATH_NUM(padapter)) return -EINVAL;
10853         if (addr > 0xFF) return -EINVAL;
10854
10855         _rtw_memset(extra, 0, wrqu->length);
10856
10857         //*data = read_rfreg(padapter, path, addr);
10858         sprintf(data, "%08x", read_rfreg(padapter, path, addr));
10859                                 //add read data format blank
10860                                 for( i=0 ; i <= strlen(data) ; i++)
10861                                 {
10862                                           if( i%2==0 )
10863                                           {
10864                                                    tmp[j]=' ';
10865                                                    j++;
10866                                           }
10867                                           tmp[j] = data[i];
10868                                           j++;
10869                                 }
10870                                 pch = tmp;
10871                                 DBG_871X("pch=%s",pch);
10872
10873                                 while( *pch != '\0' )
10874                                 {
10875                                         pnext = strpbrk(pch, " ");
10876                                         pnext++;
10877                                         if ( *pnext != '\0' )
10878                                         {
10879                                                   strtou = simple_strtoul (pnext , &ptmp, 16);
10880                                                   sprintf( extra, "%s %d" ,extra ,strtou );
10881                                         }
10882                                         else{
10883                                                   break;
10884                                         }
10885                                         pch = pnext;
10886                                 }
10887                         wrqu->length = strlen(extra);
10888
10889         return 0;
10890 }
10891
10892 static int rtw_mp_start(struct net_device *dev,
10893                         struct iw_request_info *info,
10894                         struct iw_point *wrqu, char *extra)
10895 {
10896         u8 val8;
10897         PADAPTER padapter = rtw_netdev_priv(dev);
10898         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
10899         struct dm_priv  *pdmpriv = &pHalData->dmpriv;
10900         struct hal_ops *pHalFunc = &padapter->HalFunc;
10901
10902         rtw_pm_set_ips(padapter,IPS_NONE);
10903         LeaveAllPowerSaveMode(padapter);
10904
10905         if(padapter->registrypriv.mp_mode ==0)
10906         {
10907
10908 #ifdef CONFIG_BT_COEXIST
10909                 pdmpriv->DMFlag &= ~DYNAMIC_FUNC_BT;
10910 #endif
10911                 pHalFunc->hal_deinit(padapter);
10912                 padapter->registrypriv.mp_mode =1;
10913                 pHalFunc->hal_init(padapter);
10914
10915                 rtw_pm_set_ips(padapter,IPS_NONE);
10916                 LeaveAllPowerSaveMode(padapter);
10917         }
10918
10919         if (padapter->registrypriv.mp_mode == 0)
10920                 return -EPERM;
10921
10922         if (padapter->mppriv.mode == MP_OFF) {
10923                 if (mp_start_test(padapter) == _FAIL)
10924                         return -EPERM;
10925                 padapter->mppriv.mode = MP_ON;
10926                 MPT_PwrCtlDM(padapter,0);
10927         }
10928         padapter->mppriv.bmac_filter = _FALSE;
10929 #ifdef CONFIG_RTL8723B
10930 #ifdef CONFIG_USB_HCI
10931         rtw_write32(padapter, 0x765, 0x0000);
10932         rtw_write32(padapter, 0x948, 0x0280);
10933 #else
10934         rtw_write32(padapter, 0x765, 0x0000);
10935         rtw_write32(padapter, 0x948, 0x0000);
10936 #endif
10937 #endif
10938 #ifdef CONFIG_RTL8723B
10939         rtw_write8(padapter, 0x66, 0x27); //Open BT uart Log
10940         rtw_write8(padapter, 0xc50, 0x20); //for RX init Gain
10941 #endif
10942         ODM_Write_DIG(&pHalData->odmpriv,0x20);
10943
10944         return 0;
10945 }
10946
10947 static int rtw_mp_stop(struct net_device *dev,
10948                         struct iw_request_info *info,
10949                         struct iw_point *wrqu, char *extra)
10950 {
10951         PADAPTER padapter = rtw_netdev_priv(dev);
10952         struct hal_ops *pHalFunc = &padapter->HalFunc;
10953
10954         if(padapter->registrypriv.mp_mode ==1)
10955         {
10956
10957                 MPT_DeInitAdapter(padapter);
10958                 pHalFunc->hal_deinit(padapter);
10959                 padapter->registrypriv.mp_mode=0;
10960                 pHalFunc->hal_init(padapter);
10961         }
10962
10963         if (padapter->mppriv.mode != MP_OFF) {
10964                 mp_stop_test(padapter);
10965                 padapter->mppriv.mode = MP_OFF;
10966         }
10967
10968         return 0;
10969 }
10970
10971 extern int wifirate2_ratetbl_inx(unsigned char rate);
10972
10973 static int rtw_mp_rate(struct net_device *dev,
10974                         struct iw_request_info *info,
10975                         struct iw_point *wrqu, char *extra)
10976 {
10977         u32 rate = MPT_RATE_1M;
10978         u8              input[wrqu->length];
10979         PADAPTER padapter = rtw_netdev_priv(dev);
10980
10981         if (copy_from_user(input, wrqu->pointer, wrqu->length))
10982                         return -EFAULT;
10983
10984         rate = rtw_atoi(input);
10985         sprintf( extra, "Set data rate to %d" , rate );
10986
10987         if(rate <= 0x7f)
10988                 rate = wifirate2_ratetbl_inx( (u8)rate);
10989         else if (rate < 0x90)
10990         //HT  rate 0x80(MCS0)        ~ 0x8F(MCS15)       128~143
10991                 rate =(rate - 0x80 + MPT_RATE_MCS0);
10992         else
10993                 //VHT rate 0x90(VHT1SS_MCS0) ~ 0x99(VHT1SS_MCS9) 144~153
10994                 rate =(rate - MPT_RATE_VHT1SS_MCS0);
10995
10996         //DBG_871X("%s: rate=%d\n", __func__, rate);
10997
10998         if (rate >= MPT_RATE_LAST )
10999         return -EINVAL;
11000
11001         padapter->mppriv.rateidx = rate;
11002         Hal_SetDataRate(padapter);
11003
11004         wrqu->length = strlen(extra) + 1;
11005         return 0;
11006 }
11007
11008 static int rtw_mp_channel(struct net_device *dev,
11009                         struct iw_request_info *info,
11010                         struct iw_point *wrqu, char *extra)
11011 {
11012
11013         PADAPTER padapter = rtw_netdev_priv(dev);
11014         HAL_DATA_TYPE   *pHalData       = GET_HAL_DATA(padapter);
11015         u8              input[wrqu->length];
11016         u32     channel = 1;
11017         int cur_ch_offset;
11018
11019         if (copy_from_user(input, wrqu->pointer, wrqu->length))
11020                         return -EFAULT;
11021
11022         channel = rtw_atoi(input);
11023         //DBG_871X("%s: channel=%d\n", __func__, channel);
11024         sprintf( extra, "Change channel %d to channel %d", padapter->mppriv.channel , channel );
11025         padapter->mppriv.channel = channel;
11026         pHalData->CurrentChannel = channel;
11027         Hal_SetChannel(padapter);
11028
11029         //cur_ch_offset =  rtw_get_offset_by_ch(padapter->mppriv.channel);
11030         //set_channel_bwmode(padapter, padapter->mppriv.channel, cur_ch_offset, padapter->mppriv.bandwidth);
11031         wrqu->length = strlen(extra) + 1;
11032         return 0;
11033 }
11034
11035 static int rtw_mp_bandwidth(struct net_device *dev,
11036                         struct iw_request_info *info,
11037                         struct iw_point *wrqu, char *extra)
11038 {
11039         u32 bandwidth=0, sg=0;
11040         int cur_ch_offset;
11041         //u8 buffer[40];
11042         PADAPTER padapter = rtw_netdev_priv(dev);
11043         HAL_DATA_TYPE   *pHalData       = GET_HAL_DATA(padapter);
11044         //if (copy_from_user(buffer, (void*)wrqu->data.pointer, wrqu->data.length))
11045     //            return -EFAULT;
11046
11047         //DBG_871X("%s:iwpriv in=%s\n", __func__, extra);
11048
11049         sscanf(extra, "40M=%d,shortGI=%d", &bandwidth, &sg);
11050
11051         if (bandwidth == 1)
11052                 bandwidth=CHANNEL_WIDTH_40;
11053         else if (bandwidth == 2)
11054                 bandwidth=CHANNEL_WIDTH_80;
11055         DBG_871X("%s: bw=%d sg=%d \n", __func__, bandwidth , sg);
11056
11057         padapter->mppriv.bandwidth = (u8)bandwidth;
11058         pHalData->CurrentChannelBW = bandwidth;
11059         padapter->mppriv.preamble = sg;
11060
11061         SetBandwidth(padapter);
11062         //cur_ch_offset =  rtw_get_offset_by_ch(padapter->mppriv.channel);
11063         //set_channel_bwmode(padapter, padapter->mppriv.channel, cur_ch_offset, bandwidth);
11064
11065         return 0;
11066 }
11067
11068
11069 static int rtw_mp_txpower_index(struct net_device *dev,
11070                         struct iw_request_info *info,
11071                         struct iw_point *wrqu, char *extra)
11072 {
11073         PADAPTER padapter = rtw_netdev_priv(dev);
11074         char input[wrqu->length];
11075         u32 rfpath;
11076         u32 txpower_inx;
11077
11078         if (wrqu->length > 128)
11079                 return -EFAULT;
11080
11081         if (copy_from_user(input, wrqu->pointer, wrqu->length))
11082                 return -EFAULT;
11083
11084         rfpath = rtw_atoi(input);
11085         txpower_inx = mpt_ProQueryCalTxPower(padapter, rfpath);
11086         sprintf(extra, " %d", txpower_inx);
11087         wrqu->length = strlen(extra) + 1;
11088
11089         return 0;
11090 }
11091
11092
11093 static int rtw_mp_txpower(struct net_device *dev,
11094                         struct iw_request_info *info,
11095                         struct iw_point *wrqu, char *extra)
11096 {
11097         u32             idx_a=0,idx_b=0,MsetPower=1;
11098         u8              input[wrqu->length];
11099
11100         PADAPTER padapter = rtw_netdev_priv(dev);
11101
11102         if (copy_from_user(input, wrqu->pointer, wrqu->length))
11103                         return -EFAULT;
11104
11105         MsetPower = strncmp(input, "off", 3);
11106         sscanf(input,"patha=%d,pathb=%d",&idx_a,&idx_b);
11107         //DBG_871X("%s: tx_pwr_idx_a=%x b=%x\n", __func__, idx_a, idx_b);
11108         if(MsetPower==0)
11109         {
11110                 padapter->mppriv.bSetTxPower = 0;
11111                 sprintf( extra, "MP Set power off");
11112         }
11113         else
11114         {
11115         sprintf( extra, "Set power level path_A:%d path_B:%d", idx_a , idx_b );
11116         padapter->mppriv.txpoweridx = (u8)idx_a;
11117         padapter->mppriv.txpoweridx_b = (u8)idx_b;
11118         padapter->mppriv.bSetTxPower = 1;
11119                 Hal_SetAntennaPathPower(padapter);
11120         }
11121         wrqu->length = strlen(extra) + 1;
11122         return 0;
11123 }
11124
11125 static int rtw_mp_ant_tx(struct net_device *dev,
11126                         struct iw_request_info *info,
11127                         struct iw_point *wrqu, char *extra)
11128 {
11129         u8 i;
11130         u8              input[wrqu->length];
11131         u16 antenna = 0;
11132         PADAPTER padapter = rtw_netdev_priv(dev);
11133
11134         if (copy_from_user(input, wrqu->pointer, wrqu->length))
11135                         return -EFAULT;
11136
11137         //DBG_871X("%s: input=%s\n", __func__, input);
11138
11139         sprintf( extra, "switch Tx antenna to %s", input );
11140
11141         for (i=0; i < strlen(input); i++)
11142         {
11143                 switch(input[i])
11144                         {
11145                                 case 'a' :
11146                                                                 antenna|=ANTENNA_A;
11147                                                                 break;
11148                                 case 'b':
11149                                                                 antenna|=ANTENNA_B;
11150                                                                 break;
11151                         }
11152         }
11153         //antenna |= BIT(extra[i]-'a');
11154         //DBG_871X("%s: antenna=0x%x\n", __func__, antenna);
11155         padapter->mppriv.antenna_tx = antenna;
11156         //DBG_871X("%s:mppriv.antenna_rx=%d\n", __func__, padapter->mppriv.antenna_tx);
11157
11158         Hal_SetAntenna(padapter);
11159
11160         wrqu->length = strlen(extra) + 1;
11161         return 0;
11162 }
11163
11164 static int rtw_mp_ant_rx(struct net_device *dev,
11165                         struct iw_request_info *info,
11166                         struct iw_point *wrqu, char *extra)
11167 {
11168         u8 i;
11169         u16 antenna = 0;
11170         u8              input[wrqu->length];
11171         PADAPTER padapter = rtw_netdev_priv(dev);
11172
11173         if (copy_from_user(input, wrqu->pointer, wrqu->length))
11174                         return -EFAULT;
11175         //DBG_871X("%s: input=%s\n", __func__, input);
11176         _rtw_memset(extra, 0, wrqu->length);
11177
11178         sprintf( extra, "switch Rx antenna to %s", input );
11179
11180         for (i=0; i < strlen(input); i++) {
11181         switch( input[i] )
11182                         {
11183                                 case 'a' :
11184                                                                 antenna|=ANTENNA_A;
11185                                                                 break;
11186                                 case 'b':
11187                                                                 antenna|=ANTENNA_B;
11188                                                                 break;
11189                                 case 'c' :
11190                                                                 antenna|=ANTENNA_C;
11191                                                                 break;
11192                         }
11193         }
11194
11195         //DBG_871X("%s: antenna=0x%x\n", __func__, antenna);
11196         padapter->mppriv.antenna_rx = antenna;
11197         //DBG_871X("%s:mppriv.antenna_rx=%d\n", __func__, padapter->mppriv.antenna_rx);
11198         Hal_SetAntenna(padapter);
11199         wrqu->length = strlen(extra);
11200
11201         return 0;
11202 }
11203
11204 static int rtw_mp_ctx(struct net_device *dev,
11205                         struct iw_request_info *info,
11206                         struct iw_point *wrqu, char *extra)
11207 {
11208         u32 pkTx = 1, countPkTx = 1, cotuTx = 1, CarrSprTx = 1, scTx = 1, sgleTx = 1, stop = 1;
11209         u32 bStartTest = 1;
11210         u32 count = 0,pktinterval=0;
11211         struct mp_priv *pmp_priv;
11212         struct pkt_attrib *pattrib;
11213
11214         PADAPTER padapter = rtw_netdev_priv(dev);
11215
11216
11217         pmp_priv = &padapter->mppriv;
11218
11219         if (copy_from_user(extra, wrqu->pointer, wrqu->length))
11220                         return -EFAULT;
11221
11222         DBG_871X("%s: in=%s\n", __func__, extra);
11223
11224         countPkTx = strncmp(extra, "count=", 5); // strncmp TRUE is 0
11225         cotuTx = strncmp(extra, "background", 20);
11226         CarrSprTx = strncmp(extra, "background,cs", 20);
11227         scTx = strncmp(extra, "background,sc", 20);
11228         sgleTx = strncmp(extra, "background,stone", 20);
11229         pkTx = strncmp(extra, "background,pkt", 20);
11230         stop = strncmp(extra, "stop", 4);
11231         sscanf(extra, "count=%d,pkt", &count);
11232         sscanf(extra, "pktinterval=%d", &pktinterval);
11233
11234         //DBG_871X("%s: count=%d countPkTx=%d cotuTx=%d CarrSprTx=%d scTx=%d sgleTx=%d pkTx=%d stop=%d\n", __func__, count, countPkTx, cotuTx, CarrSprTx, pkTx, sgleTx, scTx, stop);
11235         _rtw_memset(extra, '\0', sizeof(extra));
11236
11237         if( pktinterval !=0 )
11238         {
11239                 sprintf( extra, "Pkt Interval = %d",pktinterval);
11240                 padapter->mppriv.pktInterval = pktinterval;
11241
11242                 wrqu->length = strlen(extra);
11243                 return 0;
11244         }
11245
11246         if (stop == 0) {
11247                 bStartTest = 0; // To set Stop
11248                 pmp_priv->tx.stop = 1;
11249                 sprintf( extra, "Stop continuous Tx");
11250         } else {
11251                 bStartTest = 1;
11252                 if (pmp_priv->mode != MP_ON) {
11253                         if (pmp_priv->tx.stop != 1) {
11254                                 DBG_871X("%s: MP_MODE != ON %d\n", __func__, pmp_priv->mode);
11255                                 return  -EFAULT;
11256                         }
11257                 }
11258         }
11259
11260         if (pkTx == 0 || countPkTx == 0)
11261                 pmp_priv->mode = MP_PACKET_TX;
11262         if (sgleTx == 0)
11263                 pmp_priv->mode = MP_SINGLE_TONE_TX;
11264         if (cotuTx == 0)
11265                 pmp_priv->mode = MP_CONTINUOUS_TX;
11266         if (CarrSprTx == 0)
11267                 pmp_priv->mode = MP_CARRIER_SUPPRISSION_TX;
11268         if (scTx == 0)
11269                 pmp_priv->mode = MP_SINGLE_CARRIER_TX;
11270
11271         switch (pmp_priv->mode)
11272         {
11273                 case MP_PACKET_TX:
11274
11275                         //DBG_871X("%s:pkTx %d\n", __func__,bStartTest);
11276                         if (bStartTest == 0)
11277                         {
11278                                 pmp_priv->tx.stop = 1;
11279                                 pmp_priv->mode = MP_ON;
11280                                 sprintf( extra, "Stop continuous Tx");
11281                         }
11282                         else if (pmp_priv->tx.stop == 1)
11283                         {
11284                                 sprintf( extra, "Start continuous DA=ffffffffffff len=1500 count=%u,\n",count);
11285                                 //DBG_871X("%s:countPkTx %d\n", __func__,count);
11286                                 pmp_priv->tx.stop = 0;
11287                                 pmp_priv->tx.count = count;
11288                                 pmp_priv->tx.payload = 2;
11289 #ifdef CONFIG_80211N_HT
11290                                 pmp_priv->tx.attrib.ht_en = 1;
11291 #endif
11292 #ifdef CONFIG_80211AC_VHT
11293                                 pmp_priv->tx.attrib.raid = RATEID_IDX_VHT_1SS; //10
11294 #endif
11295                                 pattrib = &pmp_priv->tx.attrib;
11296                                 pattrib->pktlen = 1000;
11297                                 _rtw_memset(pattrib->dst, 0xFF, ETH_ALEN);
11298                                 SetPacketTx(padapter);
11299                         }
11300                         else {
11301                                 //DBG_871X("%s: pkTx not stop\n", __func__);
11302                                 return -EFAULT;
11303                         }
11304                                 wrqu->length = strlen(extra);
11305                                 return 0;
11306
11307                 case MP_SINGLE_TONE_TX:
11308                         //DBG_871X("%s: sgleTx %d \n", __func__, bStartTest);
11309                         if (bStartTest != 0){
11310                                 sprintf( extra, "Start continuous DA=ffffffffffff len=1500 \n infinite=yes.");
11311             }
11312                         Hal_SetSingleToneTx(padapter, (u8)bStartTest);
11313                         break;
11314
11315                 case MP_CONTINUOUS_TX:
11316                         //DBG_871X("%s: cotuTx %d\n", __func__, bStartTest);
11317                         if (bStartTest != 0){
11318                                 sprintf( extra, "Start continuous DA=ffffffffffff len=1500 \n infinite=yes.");
11319                          }
11320                         Hal_SetContinuousTx(padapter, (u8)bStartTest);
11321                         break;
11322
11323                 case MP_CARRIER_SUPPRISSION_TX:
11324                         //DBG_871X("%s: CarrSprTx %d\n", __func__, bStartTest);
11325                         if (bStartTest != 0){
11326                                 if( pmp_priv->rateidx <= MPT_RATE_11M )
11327                                 {
11328                                         sprintf( extra, "Start continuous DA=ffffffffffff len=1500 \n infinite=yes.");
11329
11330                                 }else
11331                                         sprintf( extra, "Specify carrier suppression but not CCK rate");
11332                         }
11333                         Hal_SetCarrierSuppressionTx(padapter, (u8)bStartTest);
11334                         break;
11335
11336                 case MP_SINGLE_CARRIER_TX:
11337                         //DBG_871X("%s: scTx %d\n", __func__, bStartTest);
11338                         if (bStartTest != 0){
11339                                 sprintf( extra, "Start continuous DA=ffffffffffff len=1500 \n infinite=yes.");
11340                         }
11341                         Hal_SetSingleCarrierTx(padapter, (u8)bStartTest);
11342                         break;
11343
11344                 default:
11345                         //DBG_871X("%s:No Match MP_MODE\n", __func__);
11346                         sprintf( extra, "Error! Continuous-Tx is not on-going.");
11347                         return -EFAULT;
11348         }
11349
11350         if ( bStartTest==1 && pmp_priv->mode != MP_ON) {
11351                 struct mp_priv *pmp_priv = &padapter->mppriv;
11352                 if (pmp_priv->tx.stop == 0) {
11353                         pmp_priv->tx.stop = 1;
11354                         //DBG_871X("%s: pkt tx is running...\n", __func__);
11355                         rtw_msleep_os(5);
11356                 }
11357 #ifdef CONFIG_80211N_HT
11358                 pmp_priv->tx.attrib.ht_en = 1;
11359 #endif
11360 #ifdef CONFIG_80211AC_VHT
11361                 pmp_priv->tx.attrib.raid = RATEID_IDX_VHT_1SS; //10
11362 #endif
11363                 pmp_priv->tx.stop = 0;
11364                 pmp_priv->tx.count = 1;
11365                 SetPacketTx(padapter);
11366         } else {
11367                 pmp_priv->mode = MP_ON;
11368         }
11369
11370         wrqu->length = strlen(extra);
11371         return 0;
11372 }
11373
11374
11375 static int rtw_mp_disable_bt_coexist(struct net_device *dev,
11376                         struct iw_request_info *info,
11377                         union iwreq_data *wrqu, char *extra)
11378 {
11379         PADAPTER padapter = (PADAPTER)rtw_netdev_priv(dev);
11380         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
11381         struct dm_priv  *pdmpriv = &pHalData->dmpriv;
11382         struct hal_ops *pHalFunc = &padapter->HalFunc;
11383
11384         u8 input[wrqu->data.length];
11385         u32 bt_coexist;
11386
11387         if (copy_from_user(input, wrqu->data.pointer, wrqu->data.length))
11388                 return -EFAULT;
11389
11390         bt_coexist = rtw_atoi(input);
11391
11392         if( bt_coexist == 0 )
11393         {
11394                 RT_TRACE(_module_mp_, _drv_info_,
11395                         ("Set OID_RT_SET_DISABLE_BT_COEXIST: disable BT_COEXIST\n"));
11396                 DBG_871X("Set OID_RT_SET_DISABLE_BT_COEXIST: disable BT_COEXIST\n");
11397 #ifdef CONFIG_BT_COEXIST
11398                 rtw_btcoex_HaltNotify(padapter);
11399                 rtw_btcoex_SetManualControl(padapter, _TRUE);
11400                 pdmpriv->DMFlag &= ~DYNAMIC_FUNC_BT;
11401                 // Force to switch Antenna to WiFi
11402                 rtw_write16(padapter, 0x870, 0x300);
11403                 rtw_write16(padapter, 0x860, 0x110);
11404 #endif // CONFIG_BT_COEXIST
11405         }
11406         else
11407         {
11408                 RT_TRACE(_module_mp_, _drv_info_,
11409                         ("Set OID_RT_SET_DISABLE_BT_COEXIST: enable BT_COEXIST\n"));
11410 #ifdef CONFIG_BT_COEXIST
11411                 pdmpriv->DMFlag |= DYNAMIC_FUNC_BT;
11412                 rtw_btcoex_SetManualControl(padapter, _FALSE);
11413 #endif
11414         }
11415
11416         return 0;
11417 }
11418
11419
11420 static int rtw_mp_arx(struct net_device *dev,
11421                         struct iw_request_info *info,
11422                         struct iw_point *wrqu, char *extra)
11423 {
11424         u8 bStartRx=0,bStopRx=0,bQueryPhy=0,bQueryMac=0,bSetBssid=0;
11425         u8 bmac_filter = 0,bfilter_init=0;
11426         u32 cckok=0,cckcrc=0,ofdmok=0,ofdmcrc=0,htok=0,htcrc=0,OFDM_FA=0,CCK_FA=0,DropPacket=0,vht_ok=0,vht_err=0;
11427         u32             mac_cck_ok=0, mac_ofdm_ok=0, mac_ht_ok=0, mac_vht_ok=0;
11428         u32             mac_cck_err=0, mac_ofdm_err=0, mac_ht_err=0, mac_vht_err=0;
11429         u8              input[wrqu->length];
11430         char *pch, *ptmp, *token, *tmp[2]={0x00,0x00};
11431         u32 i=0,ii=0,jj=0,kk=0,cnts=0,bmon=0;
11432         PADAPTER padapter = rtw_netdev_priv(dev);
11433         struct mp_priv *pmppriv = &padapter->mppriv;
11434
11435         if (copy_from_user(input, wrqu->pointer, wrqu->length))
11436                         return -EFAULT;
11437
11438         DBG_871X("%s: %s\n", __func__, input);
11439
11440         bStartRx = (strncmp(input, "start", 5)==0)?1:0; // strncmp TRUE is 0
11441         bStopRx = (strncmp(input, "stop", 5)==0)?1:0; // strncmp TRUE is 0
11442         bQueryPhy = (strncmp(input, "phy", 3)==0)?1:0; // strncmp TRUE is 0
11443         bQueryMac = (strncmp(input, "mac", 3)==0)?1:0; // strncmp TRUE is 0
11444         bSetBssid = (strncmp(input, "setbssid=", 8)==0)?1:0; // strncmp TRUE is 0
11445         //bfilter_init = (strncmp(input, "filter_init",11)==0)?1:0;
11446         bmac_filter = (strncmp(input, "accept_mac",10)==0)?1:0;
11447         bmon = (strncmp(input, "mon=",4)==0)?1:0;
11448
11449         if(bSetBssid==1){
11450                 pch = input;
11451                 while ((token = strsep(&pch, "=")) != NULL)
11452                 {
11453                         if (i > 1) break;
11454                         tmp[i] = token;
11455                         i++;
11456                 }
11457                 if ((tmp[0]==NULL) && (tmp[1]==NULL)){
11458                         return -EFAULT;
11459                 }
11460                 else{
11461                         cnts = strlen(tmp[1])/2;
11462                         if (cnts<1) return -EFAULT;
11463                         DBG_871X("%s: cnts=%d\n", __FUNCTION__, cnts);
11464                         DBG_871X("%s: data=%s\n", __FUNCTION__, tmp[1]);
11465                         for (jj=0, kk=0; jj < cnts ; jj++, kk+=2){
11466                                          pmppriv->network_macaddr[jj] = key_2char2num(tmp[1][kk], tmp[1][kk+1]);
11467                                         DBG_871X("network_macaddr[%d]=%x \n",jj, pmppriv->network_macaddr[jj]);
11468                         }
11469                 }
11470                 pmppriv->bSetRxBssid = _TRUE;
11471         }
11472
11473         if(bmac_filter)
11474         {
11475                 pmppriv->bmac_filter = bmac_filter;
11476                 pch = input;
11477                 while ((token = strsep(&pch, "=")) != NULL)
11478                 {
11479                         if (i > 1) break;
11480                         tmp[i] = token;
11481                         i++;
11482                 }
11483                 if ((tmp[0]==NULL) && (tmp[1]==NULL)){
11484                         return -EFAULT;
11485                 }
11486                 else{
11487                         cnts = strlen(tmp[1])/2;
11488                         if (cnts<1) return -EFAULT;
11489                         DBG_871X("%s: cnts=%d\n", __FUNCTION__, cnts);
11490                         DBG_871X("%s: data=%s\n", __FUNCTION__, tmp[1]);
11491                         for (jj=0, kk=0; jj < cnts ; jj++, kk+=2){
11492                                         pmppriv->mac_filter[jj] = key_2char2num(tmp[1][kk], tmp[1][kk+1]);
11493                                         DBG_871X("%s mac_filter[%d]=%x \n",__FUNCTION__,jj, pmppriv->mac_filter[jj]);
11494                         }
11495                 }
11496         }
11497
11498         if(bStartRx)
11499         {
11500                 sprintf( extra, "start");
11501                 SetPacketRx(padapter, bStartRx);
11502         }
11503         else if(bStopRx)
11504         {
11505                 SetPacketRx(padapter, 0);
11506                 pmppriv->bmac_filter = _FALSE;
11507                 sprintf( extra, "Received packet OK:%d CRC error:%d ,Filter out:%d",padapter->mppriv.rx_pktcount,padapter->mppriv.rx_crcerrpktcount,padapter->mppriv.rx_pktcount_filter_out);
11508         }
11509         else if(bQueryPhy)
11510         {
11511
11512                 if (IS_HARDWARE_TYPE_JAGUAR(padapter))
11513                 {
11514                         cckok      = PHY_QueryBBReg(padapter, 0xF04, 0x3FFF);        // [13:0]
11515                         ofdmok     = PHY_QueryBBReg(padapter, 0xF14, 0x3FFF);        // [13:0]
11516                         htok       = PHY_QueryBBReg(padapter, 0xF10, 0x3FFF);     // [13:0]
11517                         vht_ok      = PHY_QueryBBReg(padapter, 0xF0C, 0x3FFF);     // [13:0]
11518
11519                         cckcrc     = PHY_QueryBBReg(padapter, 0xF04, 0x3FFF0000); // [29:16]
11520                         ofdmcrc    = PHY_QueryBBReg(padapter, 0xF14, 0x3FFF0000); // [29:16]
11521                         htcrc      = PHY_QueryBBReg(padapter, 0xF10, 0x3FFF0000); // [29:16]
11522                         vht_err     = PHY_QueryBBReg(padapter, 0xF0C, 0x3FFF0000); // [29:16]
11523
11524                         CCK_FA = PHY_QueryBBReg(padapter, 0xa5c, bMaskLWord);
11525                         OFDM_FA = PHY_QueryBBReg(padapter, 0xF48, bMaskLWord);
11526                 }
11527                 else
11528                 {
11529                         cckok      = PHY_QueryBBReg(padapter, 0xF88, bMaskDWord);
11530                         ofdmok     = PHY_QueryBBReg(padapter, 0xF94, bMaskLWord);
11531                             htok       = PHY_QueryBBReg(padapter, 0xF90, bMaskLWord);
11532                         vht_ok      = 0;
11533
11534                         cckcrc     = PHY_QueryBBReg(padapter, 0xF84, bMaskDWord);
11535                         ofdmcrc    = PHY_QueryBBReg(padapter, 0xF94, bMaskHWord);
11536                         htcrc      = PHY_QueryBBReg(padapter, 0xF90, bMaskHWord);
11537                         vht_err     = 0;
11538
11539                 OFDM_FA = PHY_QueryBBReg(padapter, 0xCF0, bMaskLWord) + PHY_QueryBBReg(padapter, 0xCF2, bMaskLWord) +
11540                                         PHY_QueryBBReg(padapter, 0xDA2, bMaskLWord)+ PHY_QueryBBReg(padapter, 0xDA4, bMaskLWord) +
11541                                         PHY_QueryBBReg(padapter, 0xDA6, bMaskLWord) + PHY_QueryBBReg(padapter, 0xDA8, bMaskLWord);
11542
11543                 CCK_FA=(rtw_read8(padapter, 0xa5b )<<8 ) | (rtw_read8(padapter, 0xa5c));
11544                 }
11545                 DBG_871X("%s: OFDM_FA =%d\n", __FUNCTION__, OFDM_FA);
11546                 DBG_871X("%s: CCK_FA =%d\n", __FUNCTION__, CCK_FA);
11547                 sprintf( extra, "Phy Received packet OK:%d CRC error:%d FA Counter: %d",cckok+ofdmok+htok+vht_ok,cckcrc+ofdmcrc+htcrc+vht_err,OFDM_FA+CCK_FA);
11548         }
11549         else if(bQueryMac)
11550         {
11551                 // for 8723A
11552                 {
11553                         PHY_SetMacReg(padapter, 0x664, BIT28|BIT29|BIT30|BIT31, 0x3);
11554                         mac_cck_ok      = PHY_QueryMacReg(padapter, 0x664, bMaskLWord);      // [15:0]
11555                         PHY_SetMacReg(padapter, 0x664, BIT28|BIT29|BIT30|BIT31, 0x0);
11556                         mac_ofdm_ok     = PHY_QueryMacReg(padapter, 0x664, bMaskLWord);      // [15:0]
11557                         PHY_SetMacReg(padapter, 0x664, BIT28|BIT29|BIT30|BIT31, 0x6);
11558                         mac_ht_ok       = PHY_QueryMacReg(padapter, 0x664, bMaskLWord);     // [15:0]
11559                         mac_vht_ok      = 0;
11560
11561                         PHY_SetMacReg(padapter, 0x664, BIT28|BIT29|BIT30|BIT31, 0x4);
11562                         mac_cck_err     = PHY_QueryMacReg(padapter, 0x664, bMaskLWord); // [15:0]
11563                         PHY_SetMacReg(padapter, 0x664, BIT28|BIT29|BIT30|BIT31, 0x1);
11564                         mac_ofdm_err    = PHY_QueryMacReg(padapter, 0x664, bMaskLWord); // [15:0]
11565                         PHY_SetMacReg(padapter, 0x664, BIT28|BIT29|BIT30|BIT31, 0x7);
11566                         mac_ht_err      = PHY_QueryMacReg(padapter, 0x664, bMaskLWord); // [15:0]
11567                         mac_vht_err     = 0;
11568                         //Mac_DropPacket
11569                         rtw_write32(padapter, 0x664, (rtw_read32(padapter, 0x0664)& 0x0FFFFFFF)| Mac_DropPacket);
11570                         DropPacket = rtw_read32(padapter, 0x664)& 0x0000FFFF;
11571                 }
11572
11573                 sprintf( extra, "Mac Received packet OK: %d , CRC error: %d , Drop Packets: %d\n",
11574                                 mac_cck_ok+mac_ofdm_ok+mac_ht_ok+mac_vht_ok,mac_cck_err+mac_ofdm_err+mac_ht_err+mac_vht_err,DropPacket);
11575         }
11576
11577         if( bmon==1 ) {
11578                 sscanf(input, "mon=%d", &bmon);
11579
11580                 if(bmon==1)
11581                 {
11582                         pmppriv->rx_bindicatePkt= _TRUE;
11583                         sprintf( extra, "Indicating Receive Packet to network start\n");
11584                 }else {
11585                         pmppriv->rx_bindicatePkt= _FALSE;
11586                         sprintf( extra, "Indicating Receive Packet to network Stop\n");
11587                 }
11588         }
11589
11590         wrqu->length = strlen(extra) + 1;
11591
11592         return 0;
11593 }
11594
11595 static int rtw_mp_trx_query(struct net_device *dev,
11596                         struct iw_request_info *info,
11597                         struct iw_point *wrqu, char *extra)
11598 {
11599         u32 txok,txfail,rxok,rxfail,rxfilterout;
11600         PADAPTER padapter = rtw_netdev_priv(dev);
11601         //if (copy_from_user(extra, wrqu->data.pointer, wrqu->data.length))
11602         //      return -EFAULT;
11603
11604         txok=padapter->mppriv.tx.sended;
11605         txfail=0;
11606         rxok = padapter->mppriv.rx_pktcount;
11607         rxfail = padapter->mppriv.rx_crcerrpktcount;
11608         rxfilterout = padapter->mppriv.rx_pktcount_filter_out;
11609
11610         _rtw_memset(extra, '\0', 128);
11611
11612         sprintf(extra, "Tx OK:%d, Tx Fail:%d, Rx OK:%d, CRC error:%d ,Rx Filter out:%d \n", txok, txfail,rxok,rxfail,rxfilterout);
11613
11614         wrqu->length=strlen(extra)+1;
11615
11616         return 0;
11617 }
11618
11619 static int rtw_mp_pwrtrk(struct net_device *dev,
11620                         struct iw_request_info *info,
11621                         struct iw_point *wrqu, char *extra)
11622 {
11623         u8 enable;
11624         u32 thermal;
11625         s32 ret;
11626         PADAPTER padapter = rtw_netdev_priv(dev);
11627         HAL_DATA_TYPE                   *pHalData = GET_HAL_DATA(padapter);
11628         u8              input[wrqu->length];
11629
11630         if (copy_from_user(input, wrqu->pointer, wrqu->length))
11631                         return -EFAULT;
11632
11633         _rtw_memset(extra, 0, wrqu->length);
11634
11635         enable = 1;
11636         if (wrqu->length > 1) { // not empty string
11637                 if (strncmp(input, "stop", 4) == 0)
11638                 {
11639                         enable = 0;
11640                         sprintf(extra, "mp tx power tracking stop");
11641                         pHalData->TxPowerTrackControl = _FALSE;
11642                 }
11643                 else if (sscanf(input, "ther=%d", &thermal)) {
11644                         pHalData->TxPowerTrackControl = _TRUE;
11645                         ret = Hal_SetThermalMeter(padapter, (u8)thermal);
11646                         if (ret == _FAIL) return -EPERM;
11647                                 sprintf(extra, "mp tx power tracking start,target value=%d ok ",thermal);
11648                 }else{
11649                         return -EINVAL;
11650                 }
11651         }
11652
11653         ret = Hal_SetPowerTracking(padapter, enable);
11654         if (ret == _FAIL) return -EPERM;
11655
11656         wrqu->length = strlen(extra);
11657
11658         return 0;
11659 }
11660
11661 static int rtw_mp_psd(struct net_device *dev,
11662                         struct iw_request_info *info,
11663                         struct iw_point *wrqu, char *extra)
11664 {
11665         PADAPTER padapter = rtw_netdev_priv(dev);
11666         u8              input[wrqu->length];
11667
11668         if (copy_from_user(input, wrqu->pointer, wrqu->length))
11669                 return -EFAULT;
11670
11671         strcpy(extra,input);
11672
11673         wrqu->length = mp_query_psd(padapter, extra);
11674
11675         return 0;
11676 }
11677
11678 static int rtw_mp_thermal(struct net_device *dev,
11679                         struct iw_request_info *info,
11680                         struct iw_point *wrqu, char *extra)
11681 {
11682         u8 val;
11683         u16 bwrite=1;
11684
11685         #ifdef CONFIG_RTL8192C
11686                         u16 addr=EEPROM_THERMAL_METER_92C;
11687         #endif
11688         #ifdef CONFIG_RTL8192D
11689                         u16 addr=EEPROM_THERMAL_METER_92D;
11690         #endif
11691         #ifdef CONFIG_RTL8723A
11692                         u16 addr=EEPROM_THERMAL_METER_8723A;
11693         #endif
11694         #ifdef CONFIG_RTL8188E
11695                         u16 addr=EEPROM_THERMAL_METER_88E;
11696         #endif
11697         #if defined(CONFIG_RTL8812A) || defined(CONFIG_RTL8821A)
11698                         u16 addr=EEPROM_THERMAL_METER_8812;
11699         #endif
11700         #ifdef CONFIG_RTL8192E
11701                         u16 addr=EEPROM_THERMAL_METER_8192E;
11702         #endif
11703         #ifdef CONFIG_RTL8723B
11704                         u16 addr=EEPROM_THERMAL_METER_8723B;
11705         #endif
11706         u16 cnt=1;
11707         u16 max_available_size=0;
11708         PADAPTER padapter = rtw_netdev_priv(dev);
11709
11710         if (copy_from_user(extra, wrqu->pointer, wrqu->length))
11711                 return -EFAULT;
11712
11713         //DBG_871X("print extra %s \n",extra);
11714
11715          bwrite = strncmp(extra, "write", 6); // strncmp TRUE is 0
11716
11717          Hal_GetThermalMeter(padapter, &val);
11718
11719          if( bwrite == 0 )
11720          {
11721                  //DBG_871X("to write val:%d",val);
11722                         EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, (PVOID)&max_available_size, _FALSE);
11723                         if( 2 > max_available_size )
11724                         {
11725                                 DBG_871X("no available efuse!\n");
11726                                 return -EFAULT;
11727                         }
11728                         if ( rtw_efuse_map_write(padapter, addr, cnt, &val) == _FAIL )
11729                         {
11730                                 DBG_871X("rtw_efuse_map_write error \n");
11731                                 return -EFAULT;
11732                         }
11733                         else
11734                         {
11735                                  sprintf(extra, " efuse write ok :%d", val);
11736                         }
11737           }
11738           else
11739           {
11740                          sprintf(extra, "%d", val);
11741           }
11742         wrqu->length = strlen(extra);
11743
11744         return 0;
11745 }
11746
11747 static int rtw_mp_reset_stats(struct net_device *dev,
11748                         struct iw_request_info *info,
11749                         struct iw_point *wrqu, char *extra)
11750 {
11751         struct mp_priv *pmp_priv;
11752         struct pkt_attrib *pattrib;
11753         PADAPTER padapter = rtw_netdev_priv(dev);
11754
11755         pmp_priv = &padapter->mppriv;
11756
11757         pmp_priv->tx.sended = 0;
11758         pmp_priv->tx_pktcount = 0;
11759         pmp_priv->rx_pktcount = 0;
11760         pmp_priv->rx_pktcount_filter_out=0;
11761         pmp_priv->rx_crcerrpktcount = 0;
11762
11763         //reset phy counter
11764         if (IS_HARDWARE_TYPE_JAGUAR(padapter))
11765         {
11766                 write_bbreg(padapter, 0xB58, BIT0, 0x1);
11767                 write_bbreg(padapter, 0xB58, BIT0, 0x0);
11768
11769                 write_bbreg(padapter, 0x9A4, BIT17, 0x1);//reset  OFDA FA counter
11770                 write_bbreg(padapter, 0x9A4, BIT17, 0x0);
11771
11772                 write_bbreg(padapter, 0xA5C, BIT15, 0x0);//reset  CCK FA counter
11773                 write_bbreg(padapter, 0xA5C, BIT15, 0x1);
11774         }
11775         else
11776         {
11777                 write_bbreg(padapter, 0xF14, BIT16, 0x1);
11778                 rtw_msleep_os(10);
11779                 write_bbreg(padapter, 0xF14, BIT16, 0x0);
11780
11781                 write_bbreg(padapter, 0xD00, BIT27, 0x1);//reset  OFDA FA counter
11782                 write_bbreg(padapter, 0xC0C, BIT31, 0x1);//reset  OFDA FA counter
11783                 write_bbreg(padapter, 0xD00, BIT27, 0x0);
11784                 write_bbreg(padapter, 0xC0C, BIT31, 0x0);
11785
11786                 write_bbreg(padapter, 0xA2C, BIT15, 0x0);//reset  CCK FA counter
11787                 write_bbreg(padapter, 0xA2C, BIT15, 0x1);
11788         }
11789         //reset mac counter
11790         PHY_SetMacReg(padapter, 0x664, BIT27, 0x1);
11791         PHY_SetMacReg(padapter, 0x664, BIT27, 0x0);
11792         return 0;
11793 }
11794
11795 static int rtw_mp_dump(struct net_device *dev,
11796                         struct iw_request_info *info,
11797                         struct iw_point *wrqu, char *extra)
11798 {
11799         struct mp_priv *pmp_priv;
11800         struct pkt_attrib *pattrib;
11801         u32 value;
11802     u8          input[wrqu->length];
11803         u8 rf_type,path_nums = 0;
11804         u32 i,j=1,path;
11805         PADAPTER padapter = rtw_netdev_priv(dev);
11806
11807         pmp_priv = &padapter->mppriv;
11808
11809         if (copy_from_user(input, wrqu->pointer, wrqu->length))
11810                 return -EFAULT;
11811
11812         if ( strncmp(input, "all", 4)==0 )
11813         {
11814                 mac_reg_dump(RTW_DBGDUMP, padapter);
11815                 bb_reg_dump(RTW_DBGDUMP, padapter);
11816                 rf_reg_dump(RTW_DBGDUMP, padapter);
11817         }
11818         return 0;
11819 }
11820
11821 static int rtw_mp_phypara(struct net_device *dev,
11822                         struct iw_request_info *info,
11823                         struct iw_point *wrqu, char *extra)
11824 {
11825
11826         PADAPTER padapter = rtw_netdev_priv(dev);
11827         HAL_DATA_TYPE   *pHalData       = GET_HAL_DATA(padapter);
11828         char    input[wrqu->length];
11829         u32             valxcap;
11830
11831         if (copy_from_user(input, wrqu->pointer, wrqu->length))
11832                         return -EFAULT;
11833
11834         DBG_871X("%s:iwpriv in=%s\n", __func__, input);
11835
11836         sscanf(input, "xcap=%d", &valxcap);
11837
11838         pHalData->CrystalCap = (u8)valxcap;
11839         Hal_ProSetCrystalCap( padapter , valxcap );
11840
11841         sprintf( extra, "Set xcap=%d",valxcap );
11842         wrqu->length = strlen(extra) + 1;
11843
11844 return 0;
11845
11846 }
11847
11848 static int rtw_mp_SetRFPath(struct net_device *dev,
11849                         struct iw_request_info *info,
11850                         union iwreq_data *wrqu, char *extra)
11851 {
11852         PADAPTER padapter = rtw_netdev_priv(dev);
11853         char    input[wrqu->data.length];
11854         s32             bMain=1,bTurnoff=1;
11855
11856         if (copy_from_user(input, wrqu->data.pointer, wrqu->data.length))
11857                         return -EFAULT;
11858         DBG_871X("%s:iwpriv in=%s\n", __func__, input);
11859
11860         bMain = strncmp(input, "1", 2); // strncmp TRUE is 0
11861         bTurnoff = strncmp(input, "0", 3); // strncmp TRUE is 0
11862
11863         if(bMain==0)
11864         {
11865                 MP_PHY_SetRFPathSwitch(padapter,_TRUE);
11866                 DBG_871X("%s:PHY_SetRFPathSwitch=TRUE\n", __func__);
11867         }
11868         else if(bTurnoff==0)
11869         {
11870                 MP_PHY_SetRFPathSwitch(padapter,_FALSE);
11871                 DBG_871X("%s:PHY_SetRFPathSwitch=FALSE\n", __func__);
11872         }
11873
11874         return 0;
11875 }
11876
11877 static int rtw_mp_QueryDrv(struct net_device *dev,
11878                         struct iw_request_info *info,
11879                         union iwreq_data *wrqu, char *extra)
11880 {
11881         PADAPTER padapter = rtw_netdev_priv(dev);
11882         char    input[wrqu->data.length];
11883         s32     qAutoLoad=1;
11884
11885         EEPROM_EFUSE_PRIV *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
11886
11887         if (copy_from_user(input, wrqu->data.pointer, wrqu->data.length))
11888                         return -EFAULT;
11889         DBG_871X("%s:iwpriv in=%s\n", __func__, input);
11890
11891         qAutoLoad = strncmp(input, "autoload", 8); // strncmp TRUE is 0
11892
11893         if(qAutoLoad==0)
11894         {
11895                 DBG_871X("%s:qAutoLoad\n", __func__);
11896
11897                 if(pEEPROM->bautoload_fail_flag)
11898                         sprintf(extra, "fail");
11899                 else
11900                 sprintf(extra, "ok");
11901         }
11902                 wrqu->data.length = strlen(extra) + 1;
11903         return 0;
11904 }
11905
11906 /* update Tx AGC offset */
11907 static int rtw_mp_antBdiff(struct net_device *dev,
11908                         struct iw_request_info *info,
11909                         struct iw_point *wrqu, char *extra)
11910 {
11911
11912
11913         // MPT_ProSetTxAGCOffset
11914         return 0;
11915 }
11916
11917
11918 static int rtw_mp_PwrCtlDM(struct net_device *dev,
11919                         struct iw_request_info *info,
11920                         struct iw_point *wrqu, char *extra)
11921 {
11922         PADAPTER padapter = rtw_netdev_priv(dev);
11923         u8              input[wrqu->length];
11924         u8              bstart=1;
11925
11926         if (copy_from_user(input, wrqu->pointer, wrqu->length))
11927                         return -EFAULT;
11928
11929         bstart = strncmp(input, "start", 5); // strncmp TRUE is 0
11930         if(bstart==0){
11931                 sprintf(extra, "PwrCtlDM start \n");
11932                 MPT_PwrCtlDM(padapter,1);
11933         }else{
11934                 sprintf(extra, "PwrCtlDM stop \n");
11935                 MPT_PwrCtlDM(padapter,0);
11936         }
11937         wrqu->length = strlen(extra);
11938
11939         return 0;
11940 }
11941
11942 #if (defined(CONFIG_RTL8723A) || defined(CONFIG_RTL8723B))
11943 /* update Tx AGC offset */
11944 static int rtw_mp_SetBT(struct net_device *dev,
11945                         struct iw_request_info *info,
11946                         union iwreq_data *wrqu, char *extra)
11947 {
11948         PADAPTER padapter = rtw_netdev_priv(dev);
11949         struct hal_ops *pHalFunc = &padapter->HalFunc;
11950         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
11951
11952         BT_REQ_CMD      BtReq;
11953         PMPT_CONTEXT    pMptCtx=&(padapter->mppriv.MptCtx);
11954         PBT_RSP_CMD     pBtRsp=(PBT_RSP_CMD)&pMptCtx->mptOutBuf[0];
11955         char    input[128];
11956         char *pch, *ptmp, *token, *tmp[2]={0x00,0x00};
11957         u8 setdata[100];
11958         u8 resetbt=0x00;
11959         u8 tempval,BTStatus;
11960         u8 H2cSetbtmac[6];
11961         u8 u1H2CBtMpOperParm[4]={0x01};
11962         u16 testmode=1,ready=1,trxparam=1,setgen=1,getgen=1,testctrl=1,testbt=1,readtherm=1,setbtmac=1;
11963         u32 i=0,ii=0,jj=0,kk=0,cnts=0,status=0;
11964         PRT_MP_FIRMWARE pBTFirmware = NULL;
11965
11966         if (copy_from_user(extra, wrqu->data.pointer, wrqu->data.length))
11967                         return -EFAULT;
11968         if(strlen(extra)<1) return -EFAULT;
11969
11970         DBG_871X("%s:iwpriv in=%s\n", __FUNCTION__, extra);
11971         ready = strncmp(extra, "ready", 5);
11972         testmode = strncmp(extra, "testmode", 8); // strncmp TRUE is 0
11973         trxparam = strncmp(extra, "trxparam", 8);
11974         setgen = strncmp(extra, "setgen", 6);
11975         getgen = strncmp(extra, "getgen", 6);
11976         testctrl = strncmp(extra, "testctrl", 8);
11977         testbt = strncmp(extra, "testbt", 6);
11978         readtherm = strncmp(extra, "readtherm", 9);
11979         setbtmac = strncmp(extra, "setbtmac", 8);
11980
11981         if ( strncmp(extra, "dlbt", 4) == 0)
11982         {
11983                 pHalData->LastHMEBoxNum=0;
11984                 padapter->bBTFWReady = _FALSE;
11985                 rtw_write8(padapter, 0xa3, 0x05);
11986                 BTStatus=rtw_read8(padapter, 0xa0);
11987                 DBG_871X("%s: btwmap before read 0xa0 BT Status =0x%x \n", __FUNCTION__,BTStatus);
11988                 if (BTStatus != 0x04)
11989                 {
11990                         sprintf(extra, "BT Status not Active DLFW FAIL\n");
11991                         goto exit;
11992                 }
11993
11994                 tempval = rtw_read8(padapter, 0x6B);
11995                 tempval |= BIT7;
11996                 rtw_write8(padapter, 0x6B, tempval);
11997
11998                 // Attention!! Between 0x6A[14] and 0x6A[15] setting need 100us delay
11999                 // So don't wirte 0x6A[14]=1 and 0x6A[15]=0 together!
12000                 rtw_usleep_os(100);
12001                 // disable BT power cut
12002                 // 0x6A[14] = 0
12003                 tempval = rtw_read8(padapter, 0x6B);
12004                 tempval &= ~BIT6;
12005                 rtw_write8(padapter, 0x6B, tempval);
12006                 rtw_usleep_os(100);
12007                 MPT_PwrCtlDM(padapter,0);
12008                 rtw_write32(padapter, 0xcc, (rtw_read32(padapter, 0xcc)| 0x00000004));
12009                 rtw_write32(padapter, 0x6b, (rtw_read32(padapter, 0x6b)& 0xFFFFFFEF));
12010                 rtw_msleep_os(600);
12011                 rtw_write32(padapter, 0x6b, (rtw_read32(padapter, 0x6b)| 0x00000010));
12012                 rtw_write32(padapter, 0xcc, (rtw_read32(padapter, 0xcc)& 0xFFFFFFFB));
12013                 rtw_msleep_os(1200);
12014                 pBTFirmware = (PRT_MP_FIRMWARE)rtw_zmalloc(sizeof(RT_MP_FIRMWARE));
12015                 if(pBTFirmware==NULL)
12016                         goto exit;
12017                 padapter->bBTFWReady = _FALSE;
12018                 FirmwareDownloadBT(padapter, pBTFirmware);
12019                 if (pBTFirmware)
12020                         rtw_mfree((u8*)pBTFirmware, sizeof(RT_MP_FIRMWARE));
12021
12022                 DBG_871X("Wait for FirmwareDownloadBT fw boot!\n");
12023                 rtw_msleep_os(2000);
12024                 _rtw_memset(extra,'\0', wrqu->data.length);
12025                 BtReq.opCodeVer = 1;
12026                 BtReq.OpCode = 0;
12027                 BtReq.paraLength = 0;
12028                 mptbt_BtControlProcess(padapter, &BtReq);
12029                 rtw_msleep_os(100);
12030
12031                 DBG_8192C("FirmwareDownloadBT ready = 0x%x 0x%x", pMptCtx->mptOutBuf[4],pMptCtx->mptOutBuf[5]);
12032                 if( (pMptCtx->mptOutBuf[4]==0x00) && (pMptCtx->mptOutBuf[5]==0x00))
12033                         {
12034                                 if(padapter->mppriv.bTxBufCkFail==_TRUE)
12035                                         sprintf(extra, "check TxBuf Fail.\n");
12036                                 else
12037                                         sprintf(extra, "download FW Fail.\n");
12038                         }
12039                         else
12040                         {
12041                                 sprintf(extra, "download FW OK.\n");
12042                                 goto exit;
12043                         }
12044                 goto exit;
12045                 goto exit;
12046         }
12047         if ( strncmp(extra, "dlfw", 4) == 0)
12048         {
12049                 pHalData->LastHMEBoxNum=0;
12050                 padapter->bBTFWReady = _FALSE;
12051                 rtw_write8(padapter, 0xa3, 0x05);
12052                 BTStatus=rtw_read8(padapter, 0xa0);
12053                 DBG_871X("%s: btwmap before read 0xa0 BT Status =0x%x \n", __FUNCTION__,BTStatus);
12054                 if (BTStatus != 0x04)
12055                 {
12056                         sprintf(extra, "BT Status not Active DLFW FAIL\n");
12057                         goto exit;
12058                 }
12059
12060                 tempval = rtw_read8(padapter, 0x6B);
12061                 tempval |= BIT7;
12062                 rtw_write8(padapter, 0x6B, tempval);
12063
12064                 // Attention!! Between 0x6A[14] and 0x6A[15] setting need 100us delay
12065                 // So don't wirte 0x6A[14]=1 and 0x6A[15]=0 together!
12066                 rtw_usleep_os(100);
12067                 // disable BT power cut
12068                 // 0x6A[14] = 0
12069                 tempval = rtw_read8(padapter, 0x6B);
12070                 tempval &= ~BIT6;
12071                 rtw_write8(padapter, 0x6B, tempval);
12072                 rtw_usleep_os(100);
12073
12074                 MPT_PwrCtlDM(padapter,0);
12075                 rtw_write32(padapter, 0xcc, (rtw_read32(padapter, 0xcc)| 0x00000004));
12076                 rtw_write32(padapter, 0x6b, (rtw_read32(padapter, 0x6b)& 0xFFFFFFEF));
12077                 rtw_msleep_os(600);
12078                 rtw_write32(padapter, 0x6b, (rtw_read32(padapter, 0x6b)| 0x00000010));
12079                 rtw_write32(padapter, 0xcc, (rtw_read32(padapter, 0xcc)& 0xFFFFFFFB));
12080                 rtw_msleep_os(1200);
12081
12082 #if defined(CONFIG_PLATFORM_SPRD) && (MP_DRIVER == 1)
12083                 // Pull up BT reset pin.
12084                 DBG_871X("%s: pull up BT reset pin when bt start mp test\n", __FUNCTION__);
12085                 rtw_wifi_gpio_wlan_ctrl(WLAN_BT_PWDN_ON);
12086 #endif
12087                 DBG_871X(" rtl8723a_FirmwareDownload!\n");
12088
12089 #ifdef CONFIG_RTL8723A
12090                 status = rtl8723a_FirmwareDownload(padapter);
12091 #elif defined(CONFIG_RTL8723B)
12092                 status = rtl8723b_FirmwareDownload(padapter, _FALSE);
12093 #endif
12094                 DBG_871X("Wait for FirmwareDownloadBT fw boot!\n");
12095                 rtw_msleep_os(1000);
12096 #ifdef CONFIG_BT_COEXIST
12097                 rtw_btcoex_HaltNotify(padapter);
12098                 DBG_871X("SetBT btcoex HaltNotify !\n");
12099                 //hal_btcoex1ant_SetAntPath(padapter);
12100                 rtw_btcoex_SetManualControl(padapter, _TRUE);
12101 #endif
12102                 _rtw_memset(extra,'\0', wrqu->data.length);
12103                 BtReq.opCodeVer = 1;
12104                 BtReq.OpCode = 0;
12105                 BtReq.paraLength = 0;
12106                 mptbt_BtControlProcess(padapter, &BtReq);
12107                 rtw_msleep_os(200);
12108
12109                 DBG_8192C("FirmwareDownloadBT ready = 0x%x 0x%x", pMptCtx->mptOutBuf[4],pMptCtx->mptOutBuf[5]);
12110                 if( (pMptCtx->mptOutBuf[4]==0x00) && (pMptCtx->mptOutBuf[5]==0x00))
12111                         {
12112                                 if(padapter->mppriv.bTxBufCkFail==_TRUE)
12113                                         sprintf(extra, "check TxBuf Fail.\n");
12114                                 else
12115                                         sprintf(extra, "download FW Fail.\n");
12116                         }
12117                         else
12118                         {
12119                                 #ifdef CONFIG_BT_COEXIST
12120                                 rtw_btcoex_SwitchBtTRxMask(padapter);
12121                                 #endif
12122                                 rtw_msleep_os(200);
12123                                 sprintf(extra, "download FW OK.\n");
12124                                 goto exit;
12125                         }
12126                 goto exit;
12127         }
12128
12129         if ( strncmp(extra, "down", 4) == 0){
12130                 DBG_871X("SetBT down for to hal_init !\n");
12131 #ifdef CONFIG_BT_COEXIST
12132                 rtw_btcoex_SetManualControl(padapter, _FALSE);
12133                 rtw_btcoex_Initialize(padapter);
12134 #endif
12135                 pHalFunc->read_adapter_info(padapter);
12136                 pHalFunc->hal_deinit(padapter);
12137                 pHalFunc->hal_init(padapter);
12138                 rtw_pm_set_ips(padapter,IPS_NONE);
12139                 LeaveAllPowerSaveMode(padapter);
12140                 MPT_PwrCtlDM(padapter,0);
12141                 rtw_write32(padapter, 0xcc, (rtw_read32(padapter, 0xcc)| 0x00000004));
12142                 rtw_write32(padapter, 0x6b, (rtw_read32(padapter, 0x6b)& 0xFFFFFFEF));
12143                 rtw_msleep_os(600);
12144                         //rtw_write32(padapter, 0x6a, (rtw_read32(padapter, 0x6a)& 0xFFFFFFFE));
12145                 rtw_write32(padapter, 0x6b, (rtw_read32(padapter, 0x6b)| 0x00000010));
12146                 rtw_write32(padapter, 0xcc, (rtw_read32(padapter, 0xcc)& 0xFFFFFFFB));
12147                 rtw_msleep_os(1200);
12148                 goto exit;
12149         }
12150         if ( strncmp(extra, "disable", 7) == 0){
12151                 DBG_871X("SetBT disable !\n");
12152                 rtw_write32(padapter, 0x6a, (rtw_read32(padapter, 0x6a)& 0xFFFFFFFB));
12153                 rtw_msleep_os(500);
12154                 goto exit;
12155                 }
12156         if ( strncmp(extra, "enable", 6) == 0){
12157                 DBG_871X("SetBT enable !\n");
12158                 rtw_write32(padapter, 0x6a, (rtw_read32(padapter, 0x6a)| 0x00000004));
12159                 rtw_msleep_os(500);
12160                 goto exit;
12161         }
12162         if ( strncmp(extra, "h2c", 3) == 0){
12163                         DBG_871X("SetBT h2c !\n");
12164                         padapter->bBTFWReady = _TRUE;
12165                         FillH2CCmd(padapter, 0x63, 1, u1H2CBtMpOperParm);
12166                         goto exit;
12167                 }
12168         if ( strncmp(extra, "2ant", 4) == 0){
12169                 DBG_871X("Set BT 2ant use!\n");
12170                 PHY_SetMacReg(padapter,0x67,BIT5,0x1);
12171                 rtw_write32(padapter, 0x948, 0000);
12172
12173                 goto exit;
12174         }
12175
12176         if( ready!=0 && testmode!=0 && trxparam!=0 && setgen!=0 && getgen!=0 && testctrl!=0 && testbt!=0 && readtherm!=0 &&setbtmac!=0)
12177                 return -EFAULT;
12178
12179         if( testbt==0 )
12180         {
12181                         BtReq.opCodeVer=1;
12182                         BtReq.OpCode=6;
12183                         BtReq.paraLength=cnts/2;
12184                         goto todo;
12185         }
12186         if( ready==0 )
12187         {
12188                 BtReq.opCodeVer=1;
12189                 BtReq.OpCode=0;
12190                 BtReq.paraLength=0;
12191                 goto todo;
12192         }
12193
12194         pch = extra;
12195         i = 0;
12196         while ((token = strsep(&pch, ",")) != NULL)
12197         {
12198                 if (i > 1) break;
12199                 tmp[i] = token;
12200                 i++;
12201         }
12202
12203         if ((tmp[0]==NULL) && (tmp[1]==NULL))
12204         {
12205                 return -EFAULT;
12206         }
12207         else
12208         {
12209                 cnts = strlen(tmp[1]);
12210                 if (cnts<1) return -EFAULT;
12211
12212                 DBG_871X("%s: cnts=%d\n", __FUNCTION__, cnts);
12213                 DBG_871X("%s: data=%s\n", __FUNCTION__, tmp[1]);
12214
12215                 for (jj=0, kk=0; jj<cnts; jj++, kk+=2)
12216                 {
12217                         BtReq.pParamStart[jj] = key_2char2num(tmp[1][kk], tmp[1][kk+1]);
12218 //                      DBG_871X("BtReq.pParamStart[%d]=0x%02x\n", jj, BtReq.pParamStart[jj]);
12219                 }
12220         }
12221
12222         if( testmode==0 )
12223         {
12224                 BtReq.opCodeVer=1;
12225                 BtReq.OpCode=1;
12226                 BtReq.paraLength=1;
12227         }
12228         if( trxparam==0 )
12229         {
12230                 BtReq.opCodeVer=1;
12231                 BtReq.OpCode=2;
12232                 BtReq.paraLength=cnts/2;
12233         }
12234         if( setgen==0 )
12235         {
12236                 DBG_871X("%s: BT_SET_GENERAL \n", __func__);
12237                 BtReq.opCodeVer=1;
12238                 BtReq.OpCode=3; //BT_SET_GENERAL        3
12239                 BtReq.paraLength=cnts/2;
12240         }
12241         if( getgen==0 )
12242         {
12243                 DBG_871X("%s: BT_GET_GENERAL \n", __func__);
12244                 BtReq.opCodeVer=1;
12245                 BtReq.OpCode=4;         //BT_GET_GENERAL        4
12246                 BtReq.paraLength=cnts/2;
12247         }
12248         if( readtherm==0 )
12249         {
12250                 DBG_871X("%s: BT_GET_GENERAL \n", __func__);
12251                 BtReq.opCodeVer=1;
12252                 BtReq.OpCode=4;         //BT_GET_GENERAL        4
12253                 BtReq.paraLength=cnts/2;
12254         }
12255
12256         if( testctrl==0 )
12257         {
12258                 DBG_871X("%s: BT_TEST_CTRL \n", __func__);
12259                 BtReq.opCodeVer=1;
12260                 BtReq.OpCode=5;         //BT_TEST_CTRL  5
12261                 BtReq.paraLength=cnts/2;
12262         }
12263
12264         DBG_871X("%s: Req opCodeVer=%d OpCode=%d paraLength=%d\n",
12265                 __FUNCTION__, BtReq.opCodeVer, BtReq.OpCode, BtReq.paraLength);
12266
12267         if(BtReq.paraLength<1)
12268                 goto todo;
12269         for (i=0; i<BtReq.paraLength; i++)
12270         {
12271                 DBG_871X("%s: BtReq.pParamStart[%d] = 0x%02x \n",
12272                         __FUNCTION__, i, BtReq.pParamStart[i]);
12273         }
12274
12275 todo:
12276         _rtw_memset(extra,'\0', wrqu->data.length);
12277
12278         if (padapter->bBTFWReady == _FALSE)
12279         {
12280                 sprintf(extra, "BTFWReady = FALSE.\n");
12281                 goto exit;
12282         }
12283
12284         mptbt_BtControlProcess(padapter, &BtReq);
12285
12286         if (readtherm == 0)
12287         {
12288                 sprintf(extra, "BT thermal=");
12289                 for (i=4; i<pMptCtx->mptOutLen; i++)
12290                 {
12291                         if ((pMptCtx->mptOutBuf[i]==0x00) && (pMptCtx->mptOutBuf[i+1]==0x00))
12292                                 goto exit;
12293
12294 #ifdef CONFIG_RTL8723A
12295                         sprintf(extra, "%s %d ", extra, (pMptCtx->mptOutBuf[i]& 0x3f));
12296 #else
12297                         sprintf(extra, "%s %d ", extra, (pMptCtx->mptOutBuf[i]& 0x1f));
12298 #endif
12299                 }
12300         }
12301         else
12302         {
12303                 for (i=4; i<pMptCtx->mptOutLen; i++)
12304                 {
12305                         sprintf(extra, "%s 0x%x ", extra, pMptCtx->mptOutBuf[i]);
12306                 }
12307         }
12308
12309 exit:
12310         wrqu->data.length = strlen(extra) + 1;
12311         DBG_871X("-%s: output len=%d data=%s\n", __FUNCTION__, wrqu->data.length, extra);
12312
12313         return status;
12314 }
12315
12316 #endif //#ifdef CONFIG_RTL8723A
12317
12318 static int rtw_mp_set(struct net_device *dev,
12319                         struct iw_request_info *info,
12320                         union iwreq_data *wdata, char *extra)
12321 {
12322         struct iw_point *wrqu = (struct iw_point *)wdata;
12323         u32 subcmd = wrqu->flags;
12324         PADAPTER padapter = rtw_netdev_priv(dev);
12325
12326         if (padapter == NULL)
12327         {
12328                 return -ENETDOWN;
12329         }
12330
12331         if((padapter->bup == _FALSE ))
12332         {
12333                 DBG_871X(" %s fail =>(padapter->bup == _FALSE )\n",__FUNCTION__);
12334                 return -ENETDOWN;
12335         }
12336
12337         if( (padapter->bSurpriseRemoved == _TRUE) || ( padapter->bDriverStopped == _TRUE))
12338        {
12339         DBG_871X("%s fail =>(padapter->bSurpriseRemoved == _TRUE) || ( padapter->bDriverStopped == _TRUE) \n",__FUNCTION__);
12340              return -ENETDOWN;
12341        }
12342
12343
12344         //_rtw_memset(extra, 0x00, IW_PRIV_SIZE_MASK);
12345
12346         if (extra == NULL)
12347         {
12348                 wrqu->length = 0;
12349                 return -EIO;
12350         }
12351
12352         switch(subcmd)
12353         {
12354         case MP_START:
12355                         DBG_871X("set case mp_start \n");
12356                         rtw_mp_start (dev,info,wrqu,extra);
12357                          break;
12358
12359         case MP_STOP:
12360                         DBG_871X("set case mp_stop \n");
12361                         rtw_mp_stop (dev,info,wrqu,extra);
12362                          break;
12363
12364         case MP_BANDWIDTH:
12365                         DBG_871X("set case mp_bandwidth \n");
12366                         rtw_mp_bandwidth (dev,info,wrqu,extra);
12367                         break;
12368
12369         case MP_RESET_STATS:
12370                         DBG_871X("set case MP_RESET_STATS \n");
12371                         rtw_mp_reset_stats      (dev,info,wrqu,extra);
12372                         break;
12373         case MP_SetRFPathSwh:
12374                         DBG_871X("set MP_SetRFPathSwitch \n");
12375                         rtw_mp_SetRFPath  (dev,info,wdata,extra);
12376                         break;
12377         case CTA_TEST:
12378                         DBG_871X("set CTA_TEST\n");
12379                         rtw_cta_test_start (dev, info, wdata, extra);
12380                         break;
12381         case MP_DISABLE_BT_COEXIST:
12382                         DBG_871X("set case MP_DISABLE_BT_COEXIST \n");
12383                         rtw_mp_disable_bt_coexist(dev, info, wdata, extra);
12384                 break;
12385 #ifdef CONFIG_WOWLAN
12386         case MP_WOW_ENABLE:
12387                         DBG_871X("set case MP_WOW_ENABLE: %s \n", extra);
12388                         rtw_wowlan_ctrl(dev, info, wdata, extra);
12389         break;
12390 #endif
12391 #ifdef CONFIG_AP_WOWLAN
12392         case MP_AP_WOW_ENABLE:
12393                         DBG_871X("set case MP_AP_WOW_ENABLE: %s \n", extra);
12394                         rtw_ap_wowlan_ctrl(dev, info, wdata, extra);
12395         break;
12396 #endif
12397         }
12398
12399
12400         return 0;
12401 }
12402
12403
12404 static int rtw_mp_get(struct net_device *dev,
12405                         struct iw_request_info *info,
12406                         union iwreq_data *wdata, char *extra)
12407 {
12408         struct iw_point *wrqu = (struct iw_point *)wdata;
12409         u32 subcmd = wrqu->flags;
12410         PADAPTER padapter = rtw_netdev_priv(dev);
12411
12412         //DBG_871X("in mp_get extra= %s \n",extra);
12413
12414         if (padapter == NULL)
12415         {
12416                 return -ENETDOWN;
12417         }
12418         if((padapter->bup == _FALSE ))
12419         {
12420                 DBG_871X(" %s fail =>(padapter->bup == _FALSE )\n",__FUNCTION__);
12421                 return -ENETDOWN;
12422         }
12423
12424         if( (padapter->bSurpriseRemoved == _TRUE) || ( padapter->bDriverStopped == _TRUE))
12425        {
12426         DBG_871X("%s fail =>(padapter->bSurpriseRemoved == _TRUE) || ( padapter->bDriverStopped == _TRUE) \n",__FUNCTION__);
12427              return -ENETDOWN;
12428        }
12429
12430         if (extra == NULL)
12431         {
12432                 wrqu->length = 0;
12433                 return -EIO;
12434         }
12435
12436         switch(subcmd)
12437         {
12438         case WRITE_REG :
12439                         rtw_mp_write_reg (dev,info,wrqu,extra);
12440                          break;
12441
12442         case WRITE_RF:
12443                         rtw_mp_write_rf (dev,info,wrqu,extra);
12444                          break;
12445
12446         case MP_PHYPARA:
12447                         DBG_871X("mp_get  MP_PHYPARA \n");
12448                         rtw_mp_phypara(dev,info,wrqu,extra);
12449                         break;
12450
12451         case MP_CHANNEL:
12452                         DBG_871X("set case mp_channel \n");
12453                         rtw_mp_channel (dev,info,wrqu,extra);
12454                         break;
12455
12456         case READ_REG:
12457                         DBG_871X("mp_get  READ_REG \n");
12458                         rtw_mp_read_reg (dev,info,wrqu,extra);
12459                          break;
12460         case READ_RF:
12461                         DBG_871X("mp_get  READ_RF \n");
12462                         rtw_mp_read_rf (dev,info,wrqu,extra);
12463                         break;
12464
12465         case MP_RATE:
12466                         DBG_871X("set case mp_rate \n");
12467                         rtw_mp_rate (dev,info,wrqu,extra);
12468                         break;
12469
12470         case MP_TXPOWER:
12471                         DBG_871X("set case MP_TXPOWER \n");
12472                         rtw_mp_txpower (dev,info,wrqu,extra);
12473                         break;
12474
12475         case MP_ANT_TX:
12476                         DBG_871X("set case MP_ANT_TX \n");
12477                         rtw_mp_ant_tx (dev,info,wrqu,extra);
12478                         break;
12479
12480         case MP_ANT_RX:
12481                         DBG_871X("set case MP_ANT_RX \n");
12482                         rtw_mp_ant_rx (dev,info,wrqu,extra);
12483                         break;
12484
12485         case MP_QUERY:
12486                         //DBG_871X("mp_get mp_query MP_QUERY \n");
12487                         rtw_mp_trx_query(dev,info,wrqu,extra);
12488                         break;
12489
12490         case MP_CTX:
12491                         DBG_871X("set case MP_CTX \n");
12492                         rtw_mp_ctx (dev,info,wrqu,extra);
12493                         break;
12494
12495         case MP_ARX:
12496                         DBG_871X("set case MP_ARX \n");
12497                         rtw_mp_arx (dev,info,wrqu,extra);
12498                         break;
12499
12500         case EFUSE_GET:
12501                         DBG_871X("efuse get EFUSE_GET \n");
12502                         rtw_mp_efuse_get(dev,info,wdata,extra);
12503                  break;
12504
12505         case MP_DUMP:
12506                         DBG_871X("set case MP_DUMP \n");
12507                         rtw_mp_dump (dev,info,wrqu,extra);
12508                  break;
12509         case MP_PSD:
12510                         DBG_871X("set case MP_PSD \n");
12511                         rtw_mp_psd (dev,info,wrqu,extra);
12512                  break;
12513         case MP_THER:
12514                         DBG_871X("set case MP_THER \n");
12515                         rtw_mp_thermal (dev,info,wrqu,extra);
12516                 break;
12517         case MP_PwrCtlDM:
12518                         DBG_871X("set MP_PwrCtlDM\n");
12519                         rtw_mp_PwrCtlDM (dev,info,wrqu,extra);
12520                 break;
12521         case MP_QueryDrvStats:
12522                         DBG_871X("mp_get MP_QueryDrvStats \n");
12523                         rtw_mp_QueryDrv(dev,info,wdata,extra);
12524                         break;
12525                 case MP_PWRTRK:
12526                         DBG_871X("set case MP_PWRTRK \n");
12527                         rtw_mp_pwrtrk(dev,info,wrqu,extra);
12528                         break;
12529         case EFUSE_SET:
12530                         DBG_871X("set case efuse set \n");
12531                         rtw_mp_efuse_set(dev,info,wdata,extra);
12532                         break;
12533         case MP_GET_TXPOWER_INX:
12534                         DBG_871X("mp_get MP_GET_TXPOWER_INX \n");
12535                         rtw_mp_txpower_index(dev,info,wrqu,extra);
12536                 break;
12537
12538 #if defined(CONFIG_RTL8723A) || defined(CONFIG_RTL8723B)
12539         case MP_SetBT:
12540                         DBG_871X("set MP_SetBT \n");
12541                         rtw_mp_SetBT(dev,info,wdata,extra);
12542                         break;
12543 #endif
12544
12545         }
12546
12547         rtw_msleep_os(10); //delay 5ms for sending pkt before exit adb shell operation
12548 return 0;
12549 }
12550
12551 #endif //#if defined(CONFIG_MP_INCLUDED) && defined(CONFIG_MP_IWPRIV_SUPPORT)
12552
12553 static int rtw_wfd_tdls_enable(struct net_device *dev,
12554                                 struct iw_request_info *info,
12555                                 union iwreq_data *wrqu, char *extra)
12556 {
12557         int ret = 0;
12558
12559 #ifdef CONFIG_TDLS
12560 #ifdef CONFIG_WFD
12561
12562         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
12563
12564         printk( "[%s] %s %d\n", __FUNCTION__, extra, wrqu->data.length -1  );
12565
12566         if ( extra[ 0 ] == '0' )
12567         {
12568                 padapter->wdinfo.wfd_tdls_enable = 0;
12569         }
12570         else
12571         {
12572                 padapter->wdinfo.wfd_tdls_enable = 1;
12573         }
12574
12575 #endif //CONFIG_WFD
12576 #endif //CONFIG_TDLS
12577
12578         return ret;
12579 }
12580
12581 static int rtw_tdls_weaksec(struct net_device *dev,
12582                                 struct iw_request_info *info,
12583                                 union iwreq_data *wrqu, char *extra)
12584 {
12585         int ret = 0;
12586
12587 #ifdef CONFIG_TDLS
12588
12589         u8 i, j;
12590         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
12591
12592         DBG_871X( "[%s] %s %d\n", __FUNCTION__, extra, wrqu->data.length -1  );
12593
12594         if ( extra[ 0 ] == '0' )
12595         {
12596                 padapter->wdinfo.wfd_tdls_weaksec = 0;
12597         }
12598         else
12599         {
12600                 padapter->wdinfo.wfd_tdls_weaksec = 1;
12601         }
12602 #endif
12603
12604         return ret;
12605 }
12606
12607
12608 static int rtw_tdls_enable(struct net_device *dev,
12609                                 struct iw_request_info *info,
12610                                 union iwreq_data *wrqu, char *extra)
12611 {
12612         int ret = 0;
12613
12614 #ifdef CONFIG_TDLS
12615
12616         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
12617         struct tdls_info        *ptdlsinfo = &padapter->tdlsinfo;
12618         _irqL    irqL;
12619         _list   *plist, *phead;
12620         s32     index;
12621         struct sta_info *psta = NULL;
12622         struct  sta_priv *pstapriv = &padapter->stapriv;
12623         u8 tdls_sta[NUM_STA][ETH_ALEN];
12624         u8 empty_hwaddr[ETH_ALEN] = { 0x00 };
12625         struct tdls_txmgmt txmgmt;
12626
12627         printk( "[%s] %s %d\n", __FUNCTION__, extra, wrqu->data.length -1  );
12628
12629         _rtw_memset(tdls_sta, 0x00, sizeof(tdls_sta));
12630         _rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
12631
12632         if ( extra[ 0 ] == '0' )
12633         {
12634                 ptdlsinfo->tdls_enable = 0;
12635
12636                 if(pstapriv->asoc_sta_count==1)
12637                         return ret;
12638
12639                 _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
12640                 for(index=0; index< NUM_STA; index++)
12641                 {
12642                         phead = &(pstapriv->sta_hash[index]);
12643                         plist = get_next(phead);
12644
12645                         while ((rtw_end_of_queue_search(phead, plist)) == _FALSE)
12646                         {
12647                                 psta = LIST_CONTAINOR(plist, struct sta_info ,hash_list);
12648
12649                                 plist = get_next(plist);
12650
12651                                 if(psta->tdls_sta_state != TDLS_STATE_NONE)
12652                                 {
12653                                         _rtw_memcpy(tdls_sta[index], psta->hwaddr, ETH_ALEN);
12654                                 }
12655                         }
12656                 }
12657                 _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
12658
12659                 for(index=0; index< NUM_STA; index++)
12660                 {
12661                         if( !_rtw_memcmp(tdls_sta[index], empty_hwaddr, ETH_ALEN) )
12662                         {
12663                                 printk("issue tear down to "MAC_FMT"\n", MAC_ARG(tdls_sta[index]));
12664                                 txmgmt.status_code = _RSON_TDLS_TEAR_UN_RSN_;
12665                                 _rtw_memcpy(txmgmt.peer, tdls_sta[index], ETH_ALEN);
12666                                 issue_tdls_teardown(padapter, &txmgmt, _FALSE);
12667                         }
12668                 }
12669                 rtw_tdls_cmd(padapter, myid(&(padapter->eeprompriv)), TDLS_RS_RCR);
12670                 rtw_reset_tdls_info(padapter);
12671         }
12672         else if ( extra[ 0 ] == '1' )
12673         {
12674                 ptdlsinfo->tdls_enable = 1;
12675         }
12676 #endif //CONFIG_TDLS
12677
12678         return ret;
12679 }
12680
12681 static int rtw_tdls_setup(struct net_device *dev,
12682                                 struct iw_request_info *info,
12683                                 union iwreq_data *wrqu, char *extra)
12684 {
12685         int ret = 0;
12686 #ifdef CONFIG_TDLS
12687         u8 i, j;
12688         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
12689         struct tdls_txmgmt txmgmt;
12690 #ifdef CONFIG_WFD
12691         struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
12692 #endif // CONFIG_WFD
12693
12694         printk( "[%s] %s %d\n", __FUNCTION__, extra, wrqu->data.length -1  );
12695
12696         if(wrqu->data.length - 1 != 17 )
12697         {
12698                 printk( "[%s] length:%d != 17\n", __FUNCTION__, (wrqu->data.length -1)  );
12699                 return ret;
12700         }
12701
12702         _rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
12703         for( i=0, j=0 ; i < ETH_ALEN; i++, j+=3 ){
12704                 txmgmt.peer[i]=key_2char2num(*(extra+j), *(extra+j+1));
12705         }
12706
12707 #ifdef CONFIG_WFD
12708         if ( _AES_ != padapter->securitypriv.dot11PrivacyAlgrthm )
12709         {
12710                 //      Weak Security situation with AP.
12711                 if ( 0 == pwdinfo->wfd_tdls_weaksec )
12712                 {
12713                         //      Can't send the tdls setup request out!!
12714                         DBG_871X( "[%s] Current link is not AES, SKIP sending the tdls setup request!!\n", __FUNCTION__ );
12715                 }
12716                 else
12717                 {
12718                         issue_tdls_setup_req(padapter, &txmgmt, _TRUE);
12719                 }
12720         }
12721         else
12722 #endif // CONFIG_WFD
12723         {
12724                 issue_tdls_setup_req(padapter, &txmgmt, _TRUE);
12725         }
12726 #endif
12727
12728         return ret;
12729 }
12730
12731 static int rtw_tdls_teardown(struct net_device *dev,
12732                                 struct iw_request_info *info,
12733                                 union iwreq_data *wrqu, char *extra)
12734 {
12735         int ret = 0;
12736
12737 #ifdef CONFIG_TDLS
12738
12739         u8 i,j;
12740         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
12741         struct sta_info *ptdls_sta = NULL;
12742         struct tdls_txmgmt txmgmt;
12743
12744         DBG_871X( "[%s] %s %d\n", __FUNCTION__, extra, wrqu->data.length -1  );
12745
12746         if(wrqu->data.length - 1 != 17 && wrqu->data.length - 1 != 19)
12747         {
12748                 printk( "[%s] length:%d != 17 or 19\n", __FUNCTION__, (wrqu->data.length -1)  );
12749                 return ret;
12750         }
12751
12752         _rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
12753         for( i=0, j=0 ; i < ETH_ALEN; i++, j+=3 ){
12754                 txmgmt.peer[i]=key_2char2num(*(extra+j), *(extra+j+1));
12755         }
12756
12757         ptdls_sta = rtw_get_stainfo( &(padapter->stapriv), txmgmt.peer);
12758
12759         if(ptdls_sta != NULL)
12760         {
12761                 txmgmt.status_code = _RSON_TDLS_TEAR_UN_RSN_;
12762                 if(wrqu->data.length - 1 == 17)
12763                         issue_tdls_teardown(padapter, &txmgmt, _FALSE);
12764                 else if(wrqu->data.length - 1 == 19)
12765                         issue_tdls_teardown(padapter, &txmgmt, _TRUE);
12766         }
12767         else
12768                 DBG_871X( "TDLS peer not found\n");
12769 #endif //CONFIG_TDLS
12770
12771         return ret;
12772 }
12773
12774 static int rtw_tdls_discovery(struct net_device *dev,
12775                                 struct iw_request_info *info,
12776                                 union iwreq_data *wrqu, char *extra)
12777 {
12778         int ret = 0;
12779
12780 #ifdef CONFIG_TDLS
12781
12782         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
12783         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
12784         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
12785         struct tdls_txmgmt      txmgmt;
12786         int i = 0, j=0;
12787
12788         DBG_871X( "[%s] %s %d\n", __FUNCTION__, extra, wrqu->data.length -1  );
12789
12790         _rtw_memset(&txmgmt, 0x00, sizeof(struct tdls_txmgmt));
12791         for( i=0, j=0 ; i < ETH_ALEN; i++, j+=3 ){
12792                 txmgmt.peer[i]=key_2char2num(*(extra+j), *(extra+j+1));
12793         }
12794
12795         issue_tdls_dis_req(padapter, &txmgmt);
12796
12797 #endif //CONFIG_TDLS
12798
12799         return ret;
12800 }
12801
12802 static int rtw_tdls_ch_switch(struct net_device *dev,
12803                                 struct iw_request_info *info,
12804                                 union iwreq_data *wrqu, char *extra)
12805 {
12806         int ret = 0;
12807
12808 #ifdef CONFIG_TDLS
12809
12810         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
12811         struct tdls_info        *ptdlsinfo = &padapter->tdlsinfo;
12812         u8 i, j, mac_addr[ETH_ALEN];
12813         struct sta_info *ptdls_sta = NULL;
12814
12815         DBG_8192C( "[%s] %s %d\n", __FUNCTION__, extra, wrqu->data.length -1  );
12816
12817         for( i=0, j=0 ; i < ETH_ALEN; i++, j+=3 ){
12818                 mac_addr[i]=key_2char2num(*(extra+j), *(extra+j+1));
12819         }
12820
12821         ptdls_sta = rtw_get_stainfo(&padapter->stapriv, mac_addr);
12822         if( ptdls_sta == NULL )
12823                 return ret;
12824
12825 //      ptdlsinfo->ch_sensing=1;
12826
12827 //      rtw_tdls_cmd(padapter, ptdls_sta->hwaddr, TDLS_INIT_CH_SEN);
12828
12829 #endif //CONFIG_TDLS
12830
12831                 return ret;
12832 }
12833
12834 static int rtw_tdls_pson(struct net_device *dev,
12835                                 struct iw_request_info *info,
12836                                 union iwreq_data *wrqu, char *extra)
12837 {
12838         int ret = 0;
12839
12840 #ifdef CONFIG_TDLS
12841
12842         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
12843         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
12844         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
12845         u8 i, j, mac_addr[ETH_ALEN];
12846         struct sta_info *ptdls_sta = NULL;
12847
12848         DBG_871X( "[%s] %s %d\n", __FUNCTION__, extra, wrqu->data.length -1  );
12849
12850         for( i=0, j=0 ; i < ETH_ALEN; i++, j+=3 ){
12851                 mac_addr[i]=key_2char2num(*(extra+j), *(extra+j+1));
12852         }
12853
12854         ptdls_sta = rtw_get_stainfo(&padapter->stapriv, mac_addr);
12855
12856         issue_nulldata_to_TDLS_peer_STA(padapter, ptdls_sta->hwaddr, 1, 3, 500);
12857
12858 #endif //CONFIG_TDLS
12859
12860                 return ret;
12861 }
12862
12863 static int rtw_tdls_psoff(struct net_device *dev,
12864                                 struct iw_request_info *info,
12865                                 union iwreq_data *wrqu, char *extra)
12866 {
12867         int ret = 0;
12868
12869 #ifdef CONFIG_TDLS
12870
12871         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
12872         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
12873         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
12874         u8 i, j, mac_addr[ETH_ALEN];
12875         struct sta_info *ptdls_sta = NULL;
12876
12877         DBG_8192C( "[%s] %s %d\n", __FUNCTION__, extra, wrqu->data.length -1  );
12878
12879         for( i=0, j=0 ; i < ETH_ALEN; i++, j+=3 ){
12880                 mac_addr[i]=key_2char2num(*(extra+j), *(extra+j+1));
12881         }
12882
12883         ptdls_sta = rtw_get_stainfo(&padapter->stapriv, mac_addr);
12884
12885         if(ptdls_sta)
12886         {
12887                 //issue_tdls_peer_traffic_rsp(padapter, ptdls_sta);
12888                 issue_nulldata_to_TDLS_peer_STA(padapter, ptdls_sta->hwaddr, 0, 3, 500);
12889         }
12890 #endif //CONFIG_TDLS
12891
12892         return ret;
12893 }
12894
12895 static int rtw_tdls_setip(struct net_device *dev,
12896                                 struct iw_request_info *info,
12897                                 union iwreq_data *wrqu, char *extra)
12898 {
12899         int ret = 0;
12900
12901 #ifdef CONFIG_TDLS
12902 #ifdef CONFIG_WFD
12903
12904         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
12905         struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
12906         struct wifi_display_info *pwfd_info = ptdlsinfo->wfd_info;
12907         u8 i=0, j=0, k=0, tag=0, ip[3] = { 0xff }, *ptr = extra;
12908
12909         printk( "[%s] %s %d\n", __FUNCTION__, extra, wrqu->data.length - 1  );
12910
12911
12912         while( i < 4 )
12913         {
12914                 for( j=0; j < 4; j++)
12915                 {
12916                         if( *( extra + j + tag ) == '.' || *( extra + j + tag ) == '\0' )
12917                         {
12918                                 if( j == 1 )
12919                                         pwfd_info->ip_address[i]=convert_ip_addr( '0', '0', *(extra+(j-1)+tag));
12920                                 if( j == 2 )
12921                                         pwfd_info->ip_address[i]=convert_ip_addr( '0', *(extra+(j-2)+tag), *(extra+(j-1)+tag));
12922                                 if( j == 3 )
12923                                         pwfd_info->ip_address[i]=convert_ip_addr( *(extra+(j-3)+tag), *(extra+(j-2)+tag), *(extra+(j-1)+tag));
12924
12925                                 tag += j + 1;
12926                                 break;
12927                         }
12928                 }
12929                 i++;
12930         }
12931
12932         printk( "[%s] Set IP = %u.%u.%u.%u \n", __FUNCTION__,
12933                 ptdlsinfo->wfd_info->ip_address[0], ptdlsinfo->wfd_info->ip_address[1],
12934                 ptdlsinfo->wfd_info->ip_address[2], ptdlsinfo->wfd_info->ip_address[3]
12935         );
12936
12937 #endif //CONFIG_WFD
12938 #endif //CONFIG_TDLS
12939
12940         return ret;
12941 }
12942
12943 static int rtw_tdls_getip(struct net_device *dev,
12944                                 struct iw_request_info *info,
12945                                 union iwreq_data *wrqu, char *extra)
12946 {
12947         int ret = 0;
12948
12949 #ifdef CONFIG_TDLS
12950 #ifdef CONFIG_WFD
12951
12952         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
12953         struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
12954         struct wifi_display_info *pwfd_info = ptdlsinfo->wfd_info;
12955
12956         printk( "[%s]\n", __FUNCTION__);
12957
12958         sprintf( extra, "\n\n%u.%u.%u.%u\n",
12959                 pwfd_info->peer_ip_address[0], pwfd_info->peer_ip_address[1],
12960                 pwfd_info->peer_ip_address[2], pwfd_info->peer_ip_address[3]
12961                 );
12962
12963         printk( "[%s] IP=%u.%u.%u.%u\n", __FUNCTION__,
12964                 pwfd_info->peer_ip_address[0], pwfd_info->peer_ip_address[1],
12965                 pwfd_info->peer_ip_address[2], pwfd_info->peer_ip_address[3]
12966                 );
12967
12968         wrqu->data.length = strlen( extra );
12969
12970 #endif //CONFIG_WFD
12971 #endif //CONFIG_TDLS
12972
12973         return ret;
12974 }
12975
12976 static int rtw_tdls_getport(struct net_device *dev,
12977                                struct iw_request_info *info,
12978                                union iwreq_data *wrqu, char *extra)
12979 {
12980
12981         int ret = 0;
12982
12983 #ifdef CONFIG_TDLS
12984 #ifdef CONFIG_WFD
12985
12986         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
12987         struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
12988         struct wifi_display_info *pwfd_info = ptdlsinfo->wfd_info;
12989
12990         printk( "[%s]\n", __FUNCTION__);
12991
12992         sprintf( extra, "\n\n%d\n", pwfd_info->peer_rtsp_ctrlport );
12993         printk( "[%s] remote port = %d\n", __FUNCTION__, pwfd_info->peer_rtsp_ctrlport );
12994
12995         wrqu->data.length = strlen( extra );
12996
12997 #endif //CONFIG_WFD
12998 #endif //CONFIG_TDLS
12999
13000         return ret;
13001
13002 }
13003
13004 //WFDTDLS, for sigma test
13005 static int rtw_tdls_dis_result(struct net_device *dev,
13006                                struct iw_request_info *info,
13007                                union iwreq_data *wrqu, char *extra)
13008 {
13009
13010         int ret = 0;
13011
13012 #ifdef CONFIG_TDLS
13013 #ifdef CONFIG_WFD
13014
13015         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
13016         struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
13017         struct wifi_display_info *pwfd_info = ptdlsinfo->wfd_info;
13018
13019         printk( "[%s]\n", __FUNCTION__);
13020
13021         if(ptdlsinfo->dev_discovered == 1 )
13022         {
13023                 sprintf( extra, "\n\nDis=1\n" );
13024                 ptdlsinfo->dev_discovered = 0;
13025         }
13026
13027         wrqu->data.length = strlen( extra );
13028
13029 #endif //CONFIG_WFD
13030 #endif //CONFIG_TDLS
13031
13032         return ret;
13033
13034 }
13035
13036 //WFDTDLS, for sigma test
13037 static int rtw_wfd_tdls_status(struct net_device *dev,
13038                                struct iw_request_info *info,
13039                                union iwreq_data *wrqu, char *extra)
13040 {
13041
13042         int ret = 0;
13043
13044 #ifdef CONFIG_TDLS
13045
13046         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
13047         struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
13048
13049         printk( "[%s]\n", __FUNCTION__);
13050
13051         sprintf( extra, "\nlink_established:0x%08x \n"
13052                 "sta_cnt:%d \n"
13053                 "sta_maximum:%d \n"
13054                 "cur_channel:%d \n"
13055                 "tdls_enable:%d",
13056                 ptdlsinfo->link_established, ptdlsinfo->sta_cnt, ptdlsinfo->sta_maximum,
13057                 ptdlsinfo->cur_channel, ptdlsinfo->tdls_enable
13058                 );
13059
13060         wrqu->data.length = strlen( extra );
13061
13062 #endif //CONFIG_TDLS
13063
13064         return ret;
13065
13066         }
13067
13068 static int rtw_tdls_getsta(struct net_device *dev,
13069                                struct iw_request_info *info,
13070                                union iwreq_data *wrqu, char *extra)
13071         {
13072
13073         int ret = 0;
13074 #ifdef CONFIG_TDLS
13075         u8 i, j;
13076         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
13077         u8 addr[ETH_ALEN] = {0};
13078         char charmac[17];
13079         struct sta_info *ptdls_sta = NULL;
13080
13081         printk( "[%s] %s %d\n", __FUNCTION__, (char *)wrqu->data.pointer, wrqu->data.length -1  );
13082
13083         if(copy_from_user(charmac, wrqu->data.pointer+9, 17)){
13084                 ret = -EFAULT;
13085                 goto exit;
13086         }
13087
13088         printk("[%s] %d, charmac:%s\n", __FUNCTION__, __LINE__, charmac);
13089         for( i=0, j=0 ; i < ETH_ALEN; i++, j+=3 ){
13090                 addr[i]=key_2char2num(*(charmac+j), *(charmac+j+1));
13091         }
13092
13093         printk("[%s] %d, charmac:%s, addr:"MAC_FMT"\n", __FUNCTION__, __LINE__, charmac, MAC_ARG(addr));
13094         ptdls_sta = rtw_get_stainfo(&padapter->stapriv, addr);
13095         if(ptdls_sta) {
13096                 sprintf(extra, "\n\ntdls_sta_state=%d\n", ptdls_sta->tdls_sta_state);
13097                 printk("\n\ntdls_sta_state=%d\n", ptdls_sta->tdls_sta_state);
13098         }
13099         else {
13100                 sprintf(extra, "\n\nNot found this sta\n");
13101                 printk("\n\nNot found this sta\n");
13102         }
13103         wrqu->data.length = strlen( extra );
13104
13105 #endif //CONFIG_TDLS
13106 exit:
13107         return ret;
13108
13109 }
13110
13111 static int rtw_tdls_ch_switch_off(struct net_device *dev,
13112                                 struct iw_request_info *info,
13113                                 union iwreq_data *wrqu, char *extra)
13114 {
13115         int ret = 0;
13116
13117 #ifdef CONFIG_TDLS
13118
13119         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
13120         u8 i, j, mac_addr[ETH_ALEN];
13121         struct sta_info *ptdls_sta = NULL;
13122
13123         DBG_871X( "[%s] %s %d\n", __FUNCTION__, extra, wrqu->data.length -1  );
13124
13125         for( i=0, j=0 ; i < ETH_ALEN; i++, j+=3 ){
13126                 mac_addr[i]=key_2char2num(*(extra+j), *(extra+j+1));
13127         }
13128
13129         ptdls_sta = rtw_get_stainfo(&padapter->stapriv, mac_addr);
13130
13131         ptdls_sta->tdls_sta_state |= TDLS_SW_OFF_STATE;
13132 /*
13133         if((ptdls_sta->tdls_sta_state & TDLS_AT_OFF_CH_STATE) && (ptdls_sta->tdls_sta_state & TDLS_PEER_AT_OFF_STATE)){
13134                 pmlmeinfo->tdls_candidate_ch= pmlmeext->cur_channel;
13135                 issue_tdls_ch_switch_req(padapter, mac_addr);
13136                 DBG_871X("issue tdls ch switch req back to base channel\n");
13137         }
13138 */
13139
13140 #endif //CONFIG_TDLS
13141
13142         return ret;
13143 }
13144
13145 static int rtw_tdls(struct net_device *dev,
13146                                 struct iw_request_info *info,
13147                                 union iwreq_data *wrqu, char *extra)
13148 {
13149         int ret = 0;
13150
13151 #ifdef CONFIG_TDLS
13152         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
13153
13154
13155
13156         DBG_871X( "[%s] extra = %s\n", __FUNCTION__, extra );
13157         //      WFD Sigma will use the tdls enable command to let the driver know we want to test the tdls now!
13158         if ( _rtw_memcmp( extra, "wfdenable=", 10 ) )
13159         {
13160                 wrqu->data.length -=10;
13161                 rtw_wfd_tdls_enable( dev, info, wrqu, &extra[10] );
13162                 return ret;
13163         }
13164         else if ( _rtw_memcmp( extra, "weaksec=", 8 ) )
13165         {
13166                 wrqu->data.length -=8;
13167                 rtw_tdls_weaksec( dev, info, wrqu, &extra[8] );
13168                 return ret;
13169         }
13170         else if ( _rtw_memcmp( extra, "tdlsenable=", 11 ) )
13171         {
13172                 wrqu->data.length -=11;
13173                 rtw_tdls_enable( dev, info, wrqu, &extra[11] );
13174                 return ret;
13175         }
13176
13177         if( padapter->tdlsinfo.tdls_enable == 0 )
13178         {
13179                 printk("tdls haven't enabled\n");
13180                 return 0;
13181         }
13182
13183         if ( _rtw_memcmp( extra, "setup=", 6 ) )
13184         {
13185                 wrqu->data.length -=6;
13186                 rtw_tdls_setup( dev, info, wrqu, &extra[6] );
13187         }
13188         else if (_rtw_memcmp( extra, "tear=", 5 ) )
13189         {
13190                 wrqu->data.length -= 5;
13191                 rtw_tdls_teardown( dev, info, wrqu, &extra[5] );
13192         }
13193         else if (_rtw_memcmp( extra, "dis=", 4 ) )
13194         {
13195                 wrqu->data.length -= 4;
13196                 rtw_tdls_discovery( dev, info, wrqu, &extra[4] );
13197         }
13198         else if (_rtw_memcmp( extra, "sw=", 3 ) )
13199         {
13200                 wrqu->data.length -= 3;
13201                 rtw_tdls_ch_switch( dev, info, wrqu, &extra[3] );
13202         }
13203         else if (_rtw_memcmp( extra, "swoff=", 6 ) )
13204         {
13205                 wrqu->data.length -= 6;
13206                 rtw_tdls_ch_switch_off( dev, info, wrqu, &extra[6] );
13207         }
13208         else if (_rtw_memcmp( extra, "pson=", 5 ) )
13209         {
13210                 wrqu->data.length -= 5;
13211                 rtw_tdls_pson( dev, info, wrqu, &extra[5] );
13212         }
13213         else if (_rtw_memcmp( extra, "psoff=", 6 ) )
13214         {
13215                 wrqu->data.length -= 6;
13216                 rtw_tdls_psoff( dev, info, wrqu, &extra[6] );
13217         }
13218 #ifdef CONFIG_WFD
13219         else if (_rtw_memcmp( extra, "setip=", 6 ) )
13220         {
13221                 wrqu->data.length -= 6;
13222                 rtw_tdls_setip( dev, info, wrqu, &extra[6] );
13223         }
13224         else if (_rtw_memcmp( extra, "tprobe=", 6 ) )
13225         {
13226                 issue_tunneled_probe_req((_adapter *)rtw_netdev_priv(dev));
13227         }
13228 #endif //CONFIG_WFD
13229
13230 #endif //CONFIG_TDLS
13231
13232         return ret;
13233 }
13234
13235
13236 static int rtw_tdls_get(struct net_device *dev,
13237                                 struct iw_request_info *info,
13238                                 union iwreq_data *wrqu, char *extra)
13239 {
13240         int ret = 0;
13241
13242 #ifdef CONFIG_WFD
13243
13244         DBG_871X( "[%s] extra = %s\n", __FUNCTION__, (char*) wrqu->data.pointer );
13245
13246         if ( _rtw_memcmp( wrqu->data.pointer, "ip", 2 ) )
13247         {
13248                 rtw_tdls_getip( dev, info, wrqu, extra );
13249         }
13250         if ( _rtw_memcmp( wrqu->data.pointer, "port", 4 ) )
13251         {
13252                 rtw_tdls_getport( dev, info, wrqu, extra );
13253         }
13254         //WFDTDLS, for sigma test
13255         if ( _rtw_memcmp( wrqu->data.pointer, "dis", 3 ) )
13256         {
13257                 rtw_tdls_dis_result( dev, info, wrqu, extra );
13258         }
13259         if ( _rtw_memcmp( wrqu->data.pointer, "status", 6 ) )
13260         {
13261                 rtw_wfd_tdls_status( dev, info, wrqu, extra );
13262         }
13263         if ( _rtw_memcmp( wrqu->data.pointer, "tdls_sta=", 9 ) )
13264         {
13265                 rtw_tdls_getsta( dev, info, wrqu, extra );
13266         }
13267
13268 #endif //CONFIG_WFD
13269
13270         return ret;
13271 }
13272
13273
13274
13275
13276
13277 #ifdef CONFIG_INTEL_WIDI
13278 static int rtw_widi_set(struct net_device *dev,
13279                                struct iw_request_info *info,
13280                                union iwreq_data *wrqu, char *extra)
13281 {
13282         int ret = 0;
13283         _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
13284
13285         process_intel_widi_cmd(padapter, extra);
13286
13287         return ret;
13288 }
13289
13290 static int rtw_widi_set_probe_request(struct net_device *dev,
13291                                struct iw_request_info *info,
13292                                union iwreq_data *wrqu, char *extra)
13293 {
13294         int     ret = 0;
13295         u8      *pbuf = NULL;
13296         _adapter        *padapter = (_adapter *)rtw_netdev_priv(dev);
13297
13298         pbuf = rtw_malloc(sizeof(l2_msg_t));
13299         if(pbuf)
13300         {
13301                 if ( copy_from_user(pbuf, wrqu->data.pointer, wrqu->data.length) )
13302                         ret = -EFAULT;
13303                 //_rtw_memcpy(pbuf, wrqu->data.pointer, wrqu->data.length);
13304
13305                 if( wrqu->data.flags == 0 )
13306                         intel_widi_wk_cmd(padapter, INTEL_WIDI_ISSUE_PROB_WK, pbuf, sizeof(l2_msg_t));
13307                 else if( wrqu->data.flags == 1 )
13308                         rtw_set_wfd_rds_sink_info( padapter, (l2_msg_t *)pbuf );
13309         }
13310         return ret;
13311 }
13312 #endif // CONFIG_INTEL_WIDI
13313
13314 #ifdef CONFIG_MAC_LOOPBACK_DRIVER
13315
13316 #ifdef CONFIG_RTL8723A
13317 extern void rtl8723a_cal_txdesc_chksum(struct tx_desc *ptxdesc);
13318 #define cal_txdesc_chksum rtl8723a_cal_txdesc_chksum
13319 extern void rtl8723a_fill_default_txdesc(struct xmit_frame *pxmitframe, u8 *pbuf);
13320 #define fill_default_txdesc rtl8723a_fill_default_txdesc
13321 #endif
13322 #if defined(CONFIG_RTL8188E)
13323 #include <rtl8188e_hal.h>
13324 extern void rtl8188e_cal_txdesc_chksum(struct tx_desc *ptxdesc);
13325 #define cal_txdesc_chksum rtl8188e_cal_txdesc_chksum
13326 #ifdef CONFIG_SDIO_HCI || defined(CONFIG_GSPI_HCI)
13327 extern void rtl8188es_fill_default_txdesc(struct xmit_frame *pxmitframe, u8 *pbuf);
13328 #define fill_default_txdesc rtl8188es_fill_default_txdesc
13329 #endif // CONFIG_SDIO_HCI
13330 #endif // CONFIG_RTL8188E
13331 #if defined(CONFIG_RTL8723B)
13332 extern void rtl8723b_cal_txdesc_chksum(struct tx_desc *ptxdesc);
13333 #define cal_txdesc_chksum rtl8723b_cal_txdesc_chksum
13334 extern void rtl8723b_fill_default_txdesc(struct xmit_frame *pxmitframe, u8 *pbuf);
13335 #define fill_default_txdesc rtl8723b_fill_default_txdesc
13336 #endif // CONFIG_RTL8723B
13337
13338 static s32 initLoopback(PADAPTER padapter)
13339 {
13340         PLOOPBACKDATA ploopback;
13341
13342
13343         if (padapter->ploopback == NULL) {
13344                 ploopback = (PLOOPBACKDATA)rtw_zmalloc(sizeof(LOOPBACKDATA));
13345                 if (ploopback == NULL) return -ENOMEM;
13346
13347                 _rtw_init_sema(&ploopback->sema, 0);
13348                 ploopback->bstop = _TRUE;
13349                 ploopback->cnt = 0;
13350                 ploopback->size = 300;
13351                 _rtw_memset(ploopback->msg, 0, sizeof(ploopback->msg));
13352
13353                 padapter->ploopback = ploopback;
13354         }
13355
13356         return 0;
13357 }
13358
13359 static void freeLoopback(PADAPTER padapter)
13360 {
13361         PLOOPBACKDATA ploopback;
13362
13363
13364         ploopback = padapter->ploopback;
13365         if (ploopback) {
13366                 rtw_mfree((u8*)ploopback, sizeof(LOOPBACKDATA));
13367                 padapter->ploopback = NULL;
13368         }
13369 }
13370
13371 static s32 initpseudoadhoc(PADAPTER padapter)
13372 {
13373         NDIS_802_11_NETWORK_INFRASTRUCTURE networkType;
13374         s32 err;
13375
13376         networkType = Ndis802_11IBSS;
13377         err = rtw_set_802_11_infrastructure_mode(padapter, networkType);
13378         if (err == _FALSE) return _FAIL;
13379
13380         err = rtw_setopmode_cmd(padapter, networkType,_TRUE);
13381         if (err == _FAIL) return _FAIL;
13382
13383         return _SUCCESS;
13384 }
13385
13386 static s32 createpseudoadhoc(PADAPTER padapter)
13387 {
13388         NDIS_802_11_AUTHENTICATION_MODE authmode;
13389         struct mlme_priv *pmlmepriv;
13390         NDIS_802_11_SSID *passoc_ssid;
13391         WLAN_BSSID_EX *pdev_network;
13392         u8 *pibss;
13393         u8 ssid[] = "pseduo_ad-hoc";
13394         s32 err;
13395         _irqL irqL;
13396
13397
13398         pmlmepriv = &padapter->mlmepriv;
13399
13400         authmode = Ndis802_11AuthModeOpen;
13401         err = rtw_set_802_11_authentication_mode(padapter, authmode);
13402         if (err == _FALSE) return _FAIL;
13403
13404         passoc_ssid = &pmlmepriv->assoc_ssid;
13405         _rtw_memset(passoc_ssid, 0, sizeof(NDIS_802_11_SSID));
13406         passoc_ssid->SsidLength = sizeof(ssid) - 1;
13407         _rtw_memcpy(passoc_ssid->Ssid, ssid, passoc_ssid->SsidLength);
13408
13409         pdev_network = &padapter->registrypriv.dev_network;
13410         pibss = padapter->registrypriv.dev_network.MacAddress;
13411         _rtw_memcpy(&pdev_network->Ssid, passoc_ssid, sizeof(NDIS_802_11_SSID));
13412
13413         rtw_update_registrypriv_dev_network(padapter);
13414         rtw_generate_random_ibss(pibss);
13415
13416         _enter_critical_bh(&pmlmepriv->lock, &irqL);
13417         pmlmepriv->fw_state = WIFI_ADHOC_MASTER_STATE;
13418         _exit_critical_bh(&pmlmepriv->lock, &irqL);
13419
13420 #if 0
13421         err = rtw_createbss_cmd(padapter);
13422         if (err == _FAIL) return _FAIL;
13423 #else
13424 {
13425         struct wlan_network *pcur_network;
13426         struct sta_info *psta;
13427
13428         //3  create a new psta
13429         pcur_network = &pmlmepriv->cur_network;
13430
13431         //clear psta in the cur_network, if any
13432         psta = rtw_get_stainfo(&padapter->stapriv, pcur_network->network.MacAddress);
13433         if (psta) rtw_free_stainfo(padapter, psta);
13434
13435         psta = rtw_alloc_stainfo(&padapter->stapriv, pibss);
13436         if (psta == NULL) return _FAIL;
13437
13438         //3  join psudo AdHoc
13439         pcur_network->join_res = 1;
13440         pcur_network->aid = psta->aid = 1;
13441         _rtw_memcpy(&pcur_network->network, pdev_network, get_WLAN_BSSID_EX_sz(pdev_network));
13442
13443         // set msr to WIFI_FW_ADHOC_STATE
13444 #if 0
13445         Set_NETYPE0_MSR(padapter, WIFI_FW_ADHOC_STATE);
13446 #else
13447         {
13448                 u8 val8;
13449
13450                 val8 = rtw_read8(padapter, MSR);
13451                 val8 &= 0xFC; // clear NETYPE0
13452                 val8 |= WIFI_FW_ADHOC_STATE & 0x3;
13453                 rtw_write8(padapter, MSR, val8);
13454         }
13455 #endif
13456 }
13457 #endif
13458
13459         return _SUCCESS;
13460 }
13461
13462 static struct xmit_frame* createloopbackpkt(PADAPTER padapter, u32 size)
13463 {
13464         struct xmit_priv *pxmitpriv;
13465         struct xmit_frame *pframe;
13466         struct xmit_buf *pxmitbuf;
13467         struct pkt_attrib *pattrib;
13468         struct tx_desc *desc;
13469         u8 *pkt_start, *pkt_end, *ptr;
13470         struct rtw_ieee80211_hdr *hdr;
13471         s32 bmcast;
13472         _irqL irqL;
13473
13474
13475         if ((TXDESC_SIZE + WLANHDR_OFFSET + size) > MAX_XMITBUF_SZ) return NULL;
13476
13477         pxmitpriv = &padapter->xmitpriv;
13478         pframe = NULL;
13479
13480         //2 1. allocate xmit frame
13481         pframe = rtw_alloc_xmitframe(pxmitpriv);
13482         if (pframe == NULL) return NULL;
13483         pframe->padapter = padapter;
13484
13485         //2 2. allocate xmit buffer
13486         _enter_critical_bh(&pxmitpriv->lock, &irqL);
13487         pxmitbuf = rtw_alloc_xmitbuf(pxmitpriv);
13488         _exit_critical_bh(&pxmitpriv->lock, &irqL);
13489         if (pxmitbuf == NULL) {
13490                 rtw_free_xmitframe(pxmitpriv, pframe);
13491                 return NULL;
13492         }
13493
13494         pframe->pxmitbuf = pxmitbuf;
13495         pframe->buf_addr = pxmitbuf->pbuf;
13496         pxmitbuf->priv_data = pframe;
13497
13498         //2 3. update_attrib()
13499         pattrib = &pframe->attrib;
13500
13501         // init xmitframe attribute
13502         _rtw_memset(pattrib, 0, sizeof(struct pkt_attrib));
13503
13504         pattrib->ether_type = 0x8723;
13505         _rtw_memcpy(pattrib->src, padapter->eeprompriv.mac_addr, ETH_ALEN);
13506         _rtw_memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
13507         _rtw_memset(pattrib->dst, 0xFF, ETH_ALEN);
13508         _rtw_memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
13509
13510 //      pattrib->dhcp_pkt = 0;
13511 //      pattrib->pktlen = 0;
13512         pattrib->ack_policy = 0;
13513 //      pattrib->pkt_hdrlen = ETH_HLEN;
13514         pattrib->hdrlen = WLAN_HDR_A3_LEN;
13515         pattrib->subtype = WIFI_DATA;
13516         pattrib->priority = 0;
13517         pattrib->qsel = pattrib->priority;
13518 //      do_queue_select(padapter, pattrib);
13519         pattrib->nr_frags = 1;
13520         pattrib->encrypt = 0;
13521         pattrib->bswenc = _FALSE;
13522         pattrib->qos_en = _FALSE;
13523
13524         bmcast = IS_MCAST(pattrib->ra);
13525         if (bmcast) {
13526                 pattrib->mac_id = 1;
13527                 pattrib->psta = rtw_get_bcmc_stainfo(padapter);
13528         } else {
13529                 pattrib->mac_id = 0;
13530                 pattrib->psta = rtw_get_stainfo(&padapter->stapriv, get_bssid(&padapter->mlmepriv));
13531         }
13532
13533         pattrib->pktlen = size;
13534         pattrib->last_txcmdsz = pattrib->hdrlen + pattrib->pktlen;
13535
13536         //2 4. fill TX descriptor
13537         desc = (struct tx_desc*)pframe->buf_addr;
13538         _rtw_memset(desc, 0, TXDESC_SIZE);
13539
13540         fill_default_txdesc(pframe, (u8*)desc);
13541
13542         // Hw set sequence number
13543         ((PTXDESC)desc)->hwseq_en = 0; // HWSEQ_EN, 0:disable, 1:enable
13544 //      ((PTXDESC)desc)->hwseq_sel = 0; // HWSEQ_SEL
13545
13546         ((PTXDESC)desc)->disdatafb = 1;
13547
13548         // convert to little endian
13549         desc->txdw0 = cpu_to_le32(desc->txdw0);
13550         desc->txdw1 = cpu_to_le32(desc->txdw1);
13551         desc->txdw2 = cpu_to_le32(desc->txdw2);
13552         desc->txdw3 = cpu_to_le32(desc->txdw3);
13553         desc->txdw4 = cpu_to_le32(desc->txdw4);
13554         desc->txdw5 = cpu_to_le32(desc->txdw5);
13555         desc->txdw6 = cpu_to_le32(desc->txdw6);
13556         desc->txdw7 = cpu_to_le32(desc->txdw7);
13557 #ifdef CONFIG_PCI_HCI
13558         desc->txdw8 = cpu_to_le32(desc->txdw8);
13559         desc->txdw9 = cpu_to_le32(desc->txdw9);
13560         desc->txdw10 = cpu_to_le32(desc->txdw10);
13561         desc->txdw11 = cpu_to_le32(desc->txdw11);
13562         desc->txdw12 = cpu_to_le32(desc->txdw12);
13563         desc->txdw13 = cpu_to_le32(desc->txdw13);
13564         desc->txdw14 = cpu_to_le32(desc->txdw14);
13565         desc->txdw15 = cpu_to_le32(desc->txdw15);
13566 #endif
13567
13568         cal_txdesc_chksum(desc);
13569
13570         //2 5. coalesce
13571         pkt_start = pframe->buf_addr + TXDESC_SIZE;
13572         pkt_end = pkt_start + pattrib->last_txcmdsz;
13573
13574         //3 5.1. make wlan header, make_wlanhdr()
13575         hdr = (struct rtw_ieee80211_hdr *)pkt_start;
13576         SetFrameSubType(&hdr->frame_ctl, pattrib->subtype);
13577         _rtw_memcpy(hdr->addr1, pattrib->dst, ETH_ALEN); // DA
13578         _rtw_memcpy(hdr->addr2, pattrib->src, ETH_ALEN); // SA
13579         _rtw_memcpy(hdr->addr3, get_bssid(&padapter->mlmepriv), ETH_ALEN); // RA, BSSID
13580
13581         //3 5.2. make payload
13582         ptr = pkt_start + pattrib->hdrlen;
13583         get_random_bytes(ptr, pkt_end - ptr);
13584
13585         pxmitbuf->len = TXDESC_SIZE + pattrib->last_txcmdsz;
13586         pxmitbuf->ptail += pxmitbuf->len;
13587
13588         return pframe;
13589 }
13590
13591 static void freeloopbackpkt(PADAPTER padapter, struct xmit_frame *pframe)
13592 {
13593         struct xmit_priv *pxmitpriv;
13594         struct xmit_buf *pxmitbuf;
13595
13596
13597         pxmitpriv = &padapter->xmitpriv;
13598         pxmitbuf = pframe->pxmitbuf;
13599
13600         rtw_free_xmitframe(pxmitpriv, pframe);
13601         rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
13602 }
13603
13604 static void printdata(u8 *pbuf, u32 len)
13605 {
13606         u32 i, val;
13607
13608
13609         for (i = 0; (i+4) <= len; i+=4) {
13610                 printk("%08X", *(u32*)(pbuf + i));
13611                 if ((i+4) & 0x1F) printk(" ");
13612                 else printk("\n");
13613         }
13614
13615         if (i < len)
13616         {
13617 #ifdef CONFIG_BIG_ENDIAN
13618                 for (; i < len, i++)
13619                         printk("%02X", pbuf+i);
13620 #else // CONFIG_LITTLE_ENDIAN
13621 #if 0
13622                 val = 0;
13623                 _rtw_memcpy(&val, pbuf + i, len - i);
13624                 printk("%8X", val);
13625 #else
13626                 u8 str[9];
13627                 u8 n;
13628                 val = 0;
13629                 n = len - i;
13630                 _rtw_memcpy(&val, pbuf+i, n);
13631                 sprintf(str, "%08X", val);
13632                 n = (4 - n) * 2;
13633                 printk("%8s", str+n);
13634 #endif
13635 #endif // CONFIG_LITTLE_ENDIAN
13636         }
13637         printk("\n");
13638 }
13639
13640 static u8 pktcmp(PADAPTER padapter, u8 *txbuf, u32 txsz, u8 *rxbuf, u32 rxsz)
13641 {
13642         PHAL_DATA_TYPE phal;
13643         struct recv_stat *prxstat;
13644         struct recv_stat report;
13645         PRXREPORT prxreport;
13646         u32 drvinfosize;
13647         u32 rxpktsize;
13648         u8 fcssize;
13649         u8 ret = _FALSE;
13650
13651         prxstat = (struct recv_stat*)rxbuf;
13652         report.rxdw0 = le32_to_cpu(prxstat->rxdw0);
13653         report.rxdw1 = le32_to_cpu(prxstat->rxdw1);
13654         report.rxdw2 = le32_to_cpu(prxstat->rxdw2);
13655         report.rxdw3 = le32_to_cpu(prxstat->rxdw3);
13656         report.rxdw4 = le32_to_cpu(prxstat->rxdw4);
13657         report.rxdw5 = le32_to_cpu(prxstat->rxdw5);
13658
13659         prxreport = (PRXREPORT)&report;
13660         drvinfosize = prxreport->drvinfosize << 3;
13661         rxpktsize = prxreport->pktlen;
13662
13663         phal = GET_HAL_DATA(padapter);
13664         if (phal->ReceiveConfig & RCR_APPFCS) fcssize = IEEE80211_FCS_LEN;
13665         else fcssize = 0;
13666
13667         if ((txsz - TXDESC_SIZE) != (rxpktsize - fcssize)) {
13668                 DBG_8192C("%s: ERROR! size not match tx/rx=%d/%d !\n",
13669                         __func__, txsz - TXDESC_SIZE, rxpktsize - fcssize);
13670                 ret = _FALSE;
13671         } else {
13672                 ret = _rtw_memcmp(txbuf + TXDESC_SIZE,\
13673                                                   rxbuf + RXDESC_SIZE + drvinfosize,\
13674                                                   txsz - TXDESC_SIZE);
13675                 if (ret == _FALSE) {
13676                         DBG_8192C("%s: ERROR! pkt content mismatch!\n", __func__);
13677                 }
13678         }
13679
13680         if (ret == _FALSE)
13681         {
13682                 DBG_8192C("\n%s: TX PKT total=%d, desc=%d, content=%d\n",
13683                         __func__, txsz, TXDESC_SIZE, txsz - TXDESC_SIZE);
13684                 DBG_8192C("%s: TX DESC size=%d\n", __func__, TXDESC_SIZE);
13685                 printdata(txbuf, TXDESC_SIZE);
13686                 DBG_8192C("%s: TX content size=%d\n", __func__, txsz - TXDESC_SIZE);
13687                 printdata(txbuf + TXDESC_SIZE, txsz - TXDESC_SIZE);
13688
13689                 DBG_8192C("\n%s: RX PKT read=%d offset=%d(%d,%d) content=%d\n",
13690                         __func__, rxsz, RXDESC_SIZE + drvinfosize, RXDESC_SIZE, drvinfosize, rxpktsize);
13691                 if (rxpktsize != 0)
13692                 {
13693                         DBG_8192C("%s: RX DESC size=%d\n", __func__, RXDESC_SIZE);
13694                         printdata(rxbuf, RXDESC_SIZE);
13695                         DBG_8192C("%s: RX drvinfo size=%d\n", __func__, drvinfosize);
13696                         printdata(rxbuf + RXDESC_SIZE, drvinfosize);
13697                         DBG_8192C("%s: RX content size=%d\n", __func__, rxpktsize);
13698                         printdata(rxbuf + RXDESC_SIZE + drvinfosize, rxpktsize);
13699                 } else {
13700                         DBG_8192C("%s: RX data size=%d\n", __func__, rxsz);
13701                         printdata(rxbuf, rxsz);
13702                 }
13703         }
13704
13705         return ret;
13706 }
13707
13708 thread_return lbk_thread(thread_context context)
13709 {
13710         s32 err;
13711         PADAPTER padapter;
13712         PLOOPBACKDATA ploopback;
13713         struct xmit_frame *pxmitframe;
13714         u32 cnt, ok, fail, headerlen;
13715         u32 pktsize;
13716         u32 ff_hwaddr;
13717
13718
13719         padapter = (PADAPTER)context;
13720         ploopback = padapter->ploopback;
13721         if (ploopback == NULL) return -1;
13722         cnt = 0;
13723         ok = 0;
13724         fail = 0;
13725
13726         daemonize("%s", "RTW_LBK_THREAD");
13727         allow_signal(SIGTERM);
13728
13729         do {
13730                 if (ploopback->size == 0) {
13731                         get_random_bytes(&pktsize, 4);
13732                         pktsize = (pktsize % 1535) + 1; // 1~1535
13733                 } else
13734                         pktsize = ploopback->size;
13735
13736                 pxmitframe = createloopbackpkt(padapter, pktsize);
13737                 if (pxmitframe == NULL) {
13738                         sprintf(ploopback->msg, "loopback FAIL! 3. create Packet FAIL!");
13739                         break;
13740                 }
13741
13742                 ploopback->txsize = TXDESC_SIZE + pxmitframe->attrib.last_txcmdsz;
13743                 _rtw_memcpy(ploopback->txbuf, pxmitframe->buf_addr, ploopback->txsize);
13744                 ff_hwaddr = rtw_get_ff_hwaddr(pxmitframe);
13745                 cnt++;
13746                 DBG_8192C("%s: wirte port cnt=%d size=%d\n", __func__, cnt, ploopback->txsize);
13747                 pxmitframe->pxmitbuf->pdata = ploopback->txbuf;
13748                 rtw_write_port(padapter, ff_hwaddr, ploopback->txsize, (u8 *)pxmitframe->pxmitbuf);
13749
13750                 // wait for rx pkt
13751                 _rtw_down_sema(&ploopback->sema);
13752
13753                 err = pktcmp(padapter, ploopback->txbuf, ploopback->txsize, ploopback->rxbuf, ploopback->rxsize);
13754                 if (err == _TRUE)
13755                         ok++;
13756                 else
13757                         fail++;
13758
13759                 ploopback->txsize = 0;
13760                 _rtw_memset(ploopback->txbuf, 0, 0x8000);
13761                 ploopback->rxsize = 0;
13762                 _rtw_memset(ploopback->rxbuf, 0, 0x8000);
13763
13764                 freeloopbackpkt(padapter, pxmitframe);
13765                 pxmitframe = NULL;
13766
13767                 if (signal_pending(current)) {
13768                         flush_signals(current);
13769                 }
13770
13771                 if ((ploopback->bstop == _TRUE) ||
13772                         ((ploopback->cnt != 0) && (ploopback->cnt == cnt)))
13773                 {
13774                         u32 ok_rate, fail_rate, all;
13775                         all = cnt;
13776                         ok_rate = (ok*100)/all;
13777                         fail_rate = (fail*100)/all;
13778                         sprintf(ploopback->msg,\
13779                                         "loopback result: ok=%d%%(%d/%d),error=%d%%(%d/%d)",\
13780                                         ok_rate, ok, all, fail_rate, fail, all);
13781                         break;
13782                 }
13783         } while (1);
13784
13785         ploopback->bstop = _TRUE;
13786
13787         thread_exit();
13788 }
13789
13790 static void loopbackTest(PADAPTER padapter, u32 cnt, u32 size, u8* pmsg)
13791 {
13792         PLOOPBACKDATA ploopback;
13793         u32 len;
13794         s32 err;
13795
13796
13797         ploopback = padapter->ploopback;
13798
13799         if (ploopback)
13800         {
13801                 if (ploopback->bstop == _FALSE) {
13802                         ploopback->bstop = _TRUE;
13803                         _rtw_up_sema(&ploopback->sema);
13804                 }
13805                 len = 0;
13806                 do {
13807                         len = strlen(ploopback->msg);
13808                         if (len) break;
13809                         rtw_msleep_os(1);
13810                 } while (1);
13811                 _rtw_memcpy(pmsg, ploopback->msg, len+1);
13812                 freeLoopback(padapter);
13813
13814                 return;
13815         }
13816
13817         // disable dynamic algorithm
13818         {
13819         u32 DMFlag = DYNAMIC_FUNC_DISABLE;
13820         rtw_hal_get_hwreg(padapter, HW_VAR_DM_FLAG, (u8*)&DMFlag);
13821         }
13822
13823         // create pseudo ad-hoc connection
13824         err = initpseudoadhoc(padapter);
13825         if (err == _FAIL) {
13826                 sprintf(pmsg, "loopback FAIL! 1.1 init ad-hoc FAIL!");
13827                 return;
13828         }
13829
13830         err = createpseudoadhoc(padapter);
13831         if (err == _FAIL) {
13832                 sprintf(pmsg, "loopback FAIL! 1.2 create ad-hoc master FAIL!");
13833                 return;
13834         }
13835
13836         err = initLoopback(padapter);
13837         if (err) {
13838                 sprintf(pmsg, "loopback FAIL! 2. init FAIL! error code=%d", err);
13839                 return;
13840         }
13841
13842         ploopback = padapter->ploopback;
13843
13844         ploopback->bstop = _FALSE;
13845         ploopback->cnt = cnt;
13846         ploopback->size = size;
13847         ploopback->lbkthread = kthread_run(lbk_thread, padapter, "RTW_LBK_THREAD");
13848         if (IS_ERR(padapter->lbkthread))
13849         {
13850                 freeLoopback(padapter);
13851                 sprintf(pmsg, "loopback start FAIL! cnt=%d", cnt);
13852                 return;
13853         }
13854
13855         sprintf(pmsg, "loopback start! cnt=%d", cnt);
13856 }
13857 #endif // CONFIG_MAC_LOOPBACK_DRIVER
13858
13859 static int rtw_test(
13860         struct net_device *dev,
13861         struct iw_request_info *info,
13862         union iwreq_data *wrqu, char *extra)
13863 {
13864         u32 len;
13865         u8 *pbuf, *pch;
13866         char *ptmp;
13867         u8 *delim = ",";
13868         PADAPTER padapter = rtw_netdev_priv(dev);
13869
13870
13871         DBG_871X("+%s\n", __func__);
13872         len = wrqu->data.length;
13873
13874         pbuf = (u8*)rtw_zmalloc(len);
13875         if (pbuf == NULL) {
13876                 DBG_871X("%s: no memory!\n", __func__);
13877                 return -ENOMEM;
13878         }
13879
13880         if (copy_from_user(pbuf, wrqu->data.pointer, len)) {
13881                 rtw_mfree(pbuf, len);
13882                 DBG_871X("%s: copy from user fail!\n", __func__);
13883                 return -EFAULT;
13884         }
13885         DBG_871X("%s: string=\"%s\"\n", __func__, pbuf);
13886
13887         ptmp = (char*)pbuf;
13888         pch = strsep(&ptmp, delim);
13889         if ((pch == NULL) || (strlen(pch) == 0)) {
13890                 rtw_mfree(pbuf, len);
13891                 DBG_871X("%s: parameter error(level 1)!\n", __func__);
13892                 return -EFAULT;
13893         }
13894
13895 #ifdef CONFIG_MAC_LOOPBACK_DRIVER
13896         if (strcmp(pch, "loopback") == 0)
13897         {
13898                 s32 cnt = 0;
13899                 u32 size = 64;
13900
13901                 pch = strsep(&ptmp, delim);
13902                 if ((pch == NULL) || (strlen(pch) == 0)) {
13903                         rtw_mfree(pbuf, len);
13904                         DBG_871X("%s: parameter error(level 2)!\n", __func__);
13905                         return -EFAULT;
13906                 }
13907
13908                 sscanf(pch, "%d", &cnt);
13909                 DBG_871X("%s: loopback cnt=%d\n", __func__, cnt);
13910
13911                 pch = strsep(&ptmp, delim);
13912                 if ((pch == NULL) || (strlen(pch) == 0)) {
13913                         rtw_mfree(pbuf, len);
13914                         DBG_871X("%s: parameter error(level 2)!\n", __func__);
13915                         return -EFAULT;
13916                 }
13917
13918                 sscanf(pch, "%d", &size);
13919                 DBG_871X("%s: loopback size=%d\n", __func__, size);
13920
13921                 loopbackTest(padapter, cnt, size, extra);
13922                 wrqu->data.length = strlen(extra) + 1;
13923
13924                 rtw_mfree(pbuf, len);
13925                 return 0;
13926         }
13927 #endif
13928
13929 #if 0
13930 //#ifdef CONFIG_RTL8723A
13931         if (strcmp(pch, "poweron") == 0)
13932         {
13933                 s32 ret;
13934
13935                 ret = _InitPowerOn(padapter);
13936                 DBG_871X("%s: power on %s\n", __func__, (_FAIL==ret) ? "FAIL!":"OK.");
13937                 sprintf(extra, "Power ON %s", (_FAIL==ret) ? "FAIL!":"OK.");
13938                 wrqu->data.length = strlen(extra) + 1;
13939
13940                 rtw_mfree(pbuf, len);
13941                 return 0;
13942         }
13943
13944         if (strcmp(pch, "dlfw") == 0)
13945         {
13946                 s32 ret;
13947
13948                 ret = rtl8723a_FirmwareDownload(padapter);
13949                 DBG_871X("%s: download FW %s\n", __func__, (_FAIL==ret) ? "FAIL!":"OK.");
13950                 sprintf(extra, "download FW %s", (_FAIL==ret) ? "FAIL!":"OK.");
13951                 wrqu->data.length = strlen(extra) + 1;
13952
13953                 rtw_mfree(pbuf, len);
13954                 return 0;
13955         }
13956 #endif
13957
13958 #ifdef CONFIG_BT_COEXIST
13959         if (strcmp(pch, "bton") == 0)
13960         {
13961                 rtw_btcoex_SetManualControl(padapter, _FALSE);
13962         }
13963
13964         if (strcmp(pch, "btoff") == 0)
13965         {
13966                 rtw_btcoex_SetManualControl(padapter, _TRUE);
13967         }
13968
13969         if (strcmp(pch, "h2c") == 0)
13970         {
13971                 u8 param[8];
13972                 u8 count = 0;
13973                 u32 tmp;
13974                 u8 i;
13975                 u32 pos;
13976                 s32 ret;
13977
13978
13979                 do {
13980                         pch = strsep(&ptmp, delim);
13981                         if ((pch == NULL) || (strlen(pch) == 0))
13982                                 break;
13983
13984                         sscanf(pch, "%x", &tmp);
13985                         param[count++] = (u8)tmp;
13986                 } while (count < 8);
13987
13988                 if (count == 0) {
13989                         rtw_mfree(pbuf, len);
13990                         DBG_871X("%s: parameter error(level 2)!\n", __func__);
13991                         return -EFAULT;
13992                 }
13993
13994                 ret = rtw_hal_fill_h2c_cmd(padapter, param[0], count-1, &param[1]);
13995
13996                 pos = sprintf(extra, "H2C ID=0x%02x content=", param[0]);
13997                 for (i=1; i<count; i++) {
13998                         pos += sprintf(extra+pos, "%02x,", param[i]);
13999                 }
14000                 extra[pos] = 0;
14001                 pos--;
14002                 pos += sprintf(extra+pos, " %s", ret==_FAIL?"FAIL":"OK");
14003
14004                 wrqu->data.length = strlen(extra) + 1;
14005         }
14006 #endif // CONFIG_BT_COEXIST
14007
14008         rtw_mfree(pbuf, len);
14009         return 0;
14010 }
14011
14012 static iw_handler rtw_handlers[] =
14013 {
14014         NULL,                                   /* SIOCSIWCOMMIT */
14015         rtw_wx_get_name,                /* SIOCGIWNAME */
14016         dummy,                                  /* SIOCSIWNWID */
14017         dummy,                                  /* SIOCGIWNWID */
14018         rtw_wx_set_freq,                /* SIOCSIWFREQ */
14019         rtw_wx_get_freq,                /* SIOCGIWFREQ */
14020         rtw_wx_set_mode,                /* SIOCSIWMODE */
14021         rtw_wx_get_mode,                /* SIOCGIWMODE */
14022         dummy,                                  /* SIOCSIWSENS */
14023         rtw_wx_get_sens,                /* SIOCGIWSENS */
14024         NULL,                                   /* SIOCSIWRANGE */
14025         rtw_wx_get_range,               /* SIOCGIWRANGE */
14026         rtw_wx_set_priv,                /* SIOCSIWPRIV */
14027         NULL,                                   /* SIOCGIWPRIV */
14028         NULL,                                   /* SIOCSIWSTATS */
14029         NULL,                                   /* SIOCGIWSTATS */
14030         dummy,                                  /* SIOCSIWSPY */
14031         dummy,                                  /* SIOCGIWSPY */
14032         NULL,                                   /* SIOCGIWTHRSPY */
14033         NULL,                                   /* SIOCWIWTHRSPY */
14034         rtw_wx_set_wap,         /* SIOCSIWAP */
14035         rtw_wx_get_wap,         /* SIOCGIWAP */
14036         rtw_wx_set_mlme,                /* request MLME operation; uses struct iw_mlme */
14037         dummy,                                  /* SIOCGIWAPLIST -- depricated */
14038         rtw_wx_set_scan,                /* SIOCSIWSCAN */
14039         rtw_wx_get_scan,                /* SIOCGIWSCAN */
14040         rtw_wx_set_essid,               /* SIOCSIWESSID */
14041         rtw_wx_get_essid,               /* SIOCGIWESSID */
14042         dummy,                                  /* SIOCSIWNICKN */
14043         rtw_wx_get_nick,                /* SIOCGIWNICKN */
14044         NULL,                                   /* -- hole -- */
14045         NULL,                                   /* -- hole -- */
14046         rtw_wx_set_rate,                /* SIOCSIWRATE */
14047         rtw_wx_get_rate,                /* SIOCGIWRATE */
14048         rtw_wx_set_rts,                 /* SIOCSIWRTS */
14049         rtw_wx_get_rts,                 /* SIOCGIWRTS */
14050         rtw_wx_set_frag,                /* SIOCSIWFRAG */
14051         rtw_wx_get_frag,                /* SIOCGIWFRAG */
14052         dummy,                                  /* SIOCSIWTXPOW */
14053         dummy,                                  /* SIOCGIWTXPOW */
14054         dummy,                                  /* SIOCSIWRETRY */
14055         rtw_wx_get_retry,               /* SIOCGIWRETRY */
14056         rtw_wx_set_enc,                 /* SIOCSIWENCODE */
14057         rtw_wx_get_enc,                 /* SIOCGIWENCODE */
14058         dummy,                                  /* SIOCSIWPOWER */
14059         rtw_wx_get_power,               /* SIOCGIWPOWER */
14060         NULL,                                   /*---hole---*/
14061         NULL,                                   /*---hole---*/
14062         rtw_wx_set_gen_ie,              /* SIOCSIWGENIE */
14063         NULL,                                   /* SIOCGWGENIE */
14064         rtw_wx_set_auth,                /* SIOCSIWAUTH */
14065         NULL,                                   /* SIOCGIWAUTH */
14066         rtw_wx_set_enc_ext,             /* SIOCSIWENCODEEXT */
14067         NULL,                                   /* SIOCGIWENCODEEXT */
14068         rtw_wx_set_pmkid,               /* SIOCSIWPMKSA */
14069         NULL,                                   /*---hole---*/
14070 };
14071
14072 #if 0
14073 //defined(CONFIG_MP_INCLUDED) && defined(CONFIG_MP_IWPRIV_SUPPORT)
14074 static const struct iw_priv_args rtw_private_args[] =
14075 {
14076         { SIOCIWFIRSTPRIV + 0x00, IW_PRIV_TYPE_CHAR | 1024, 0 , ""},  //set
14077         { SIOCIWFIRSTPRIV + 0x01, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK , ""},//get
14078 /* --- sub-ioctls definitions --- */
14079                 { MP_START , IW_PRIV_TYPE_CHAR | 1024, 0, "mp_start" }, //set
14080                 { MP_PHYPARA, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_phypara" },//get
14081                 { MP_STOP , IW_PRIV_TYPE_CHAR | 1024, 0, "mp_stop" }, //set
14082                 { MP_CHANNEL , IW_PRIV_TYPE_CHAR | 1024 , IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_channel" },//get
14083                 { MP_BANDWIDTH , IW_PRIV_TYPE_CHAR | 1024, 0, "mp_bandwidth"}, //set
14084                 { MP_RATE , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_rate" },//get
14085                 { MP_RESET_STATS , IW_PRIV_TYPE_CHAR | 1024, 0, "mp_reset_stats"},
14086                 { MP_QUERY , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK , "mp_query"}, //get
14087                 { MP_NULL, IW_PRIV_TYPE_CHAR | 128, 0,"NULL"},//set
14088                 { READ_REG , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "read_reg" },
14089                 { MP_NULL, IW_PRIV_TYPE_CHAR | 128, 0,"NULL"},//set
14090                 { MP_RATE , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_rate" },
14091                 { MP_NULL, IW_PRIV_TYPE_CHAR | 128, 0,"NULL"},//set
14092                 { READ_RF , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "read_rf" },
14093                 { MP_NULL, IW_PRIV_TYPE_CHAR | 128, 0,"NULL"},//set
14094                 { MP_PSD , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_psd"},
14095                 { MP_NULL, IW_PRIV_TYPE_CHAR | 128, 0,"NULL"},//set
14096                 { MP_DUMP, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_dump" },
14097                 { MP_NULL, IW_PRIV_TYPE_CHAR | 128, 0,"NULL"},//set
14098                 { MP_TXPOWER , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_txpower"},
14099                 { MP_NULL, IW_PRIV_TYPE_CHAR | 128, 0,"NULL"},//set
14100                 { MP_ANT_TX , IW_PRIV_TYPE_CHAR | 1024,  IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_ant_tx"},
14101                 { MP_NULL, IW_PRIV_TYPE_CHAR | 128, 0,"NULL"},//set
14102                 { MP_ANT_RX , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_ant_rx"},
14103                 { WRITE_REG, IW_PRIV_TYPE_CHAR | 1024, 0,"write_reg"},//set
14104                 { MP_NULL, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "NULL" },
14105                 { WRITE_RF, IW_PRIV_TYPE_CHAR | 1024, 0,"write_rf"},//set
14106                 { MP_NULL, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "NULL" },
14107                 { MP_NULL, IW_PRIV_TYPE_CHAR | 128, 0,"NULL"},//set
14108                 { MP_CTX , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_ctx"},
14109                 { MP_NULL, IW_PRIV_TYPE_CHAR | 128, 0,"NULL"},//set
14110                 { MP_ARX , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_arx"},
14111                 { MP_NULL, IW_PRIV_TYPE_CHAR | 128, 0,"NULL"},//set
14112                 { MP_THER , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_ther"},
14113                 { EFUSE_SET, IW_PRIV_TYPE_CHAR | 1024, 0, "efuse_set" },
14114                 { EFUSE_GET, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "efuse_get" },
14115                 { MP_PWRTRK , IW_PRIV_TYPE_CHAR | 1024, 0, "mp_pwrtrk"},
14116                 { MP_QueryDrvStats, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_drvquery" },
14117                 { MP_IOCTL, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_ioctl"}, // mp_ioctl
14118                 { MP_SetRFPathSwh, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_setrfpath" },
14119 #ifdef CONFIG_RTL8723A
14120                 { MP_SetBT, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_setbt" },
14121 #endif
14122         { SIOCIWFIRSTPRIV + 0x02, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK , "test"},//set
14123 };
14124 static iw_handler rtw_private_handler[] =
14125 {
14126         rtw_mp_set,
14127         rtw_mp_get,
14128 };
14129 #else // not inlucde MP
14130
14131 static const struct iw_priv_args rtw_private_args[] = {
14132         {
14133                 SIOCIWFIRSTPRIV + 0x0,
14134                 IW_PRIV_TYPE_CHAR | 0x7FF, 0, "write"
14135         },
14136         {
14137                 SIOCIWFIRSTPRIV + 0x1,
14138                 IW_PRIV_TYPE_CHAR | 0x7FF,
14139                 IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "read"
14140         },
14141         {
14142                 SIOCIWFIRSTPRIV + 0x2, 0, 0, "driver_ext"
14143         },
14144         {
14145                 SIOCIWFIRSTPRIV + 0x3, 0, 0, "mp_ioctl"
14146         },
14147         {
14148                 SIOCIWFIRSTPRIV + 0x4,
14149                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "apinfo"
14150         },
14151         {
14152                 SIOCIWFIRSTPRIV + 0x5,
14153                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "setpid"
14154         },
14155         {
14156                 SIOCIWFIRSTPRIV + 0x6,
14157                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_start"
14158         },
14159 //for PLATFORM_MT53XX
14160         {
14161                 SIOCIWFIRSTPRIV + 0x7,
14162                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "get_sensitivity"
14163         },
14164         {
14165                 SIOCIWFIRSTPRIV + 0x8,
14166                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_prob_req_ie"
14167         },
14168         {
14169                 SIOCIWFIRSTPRIV + 0x9,
14170                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_assoc_req_ie"
14171         },
14172
14173 //for RTK_DMP_PLATFORM
14174         {
14175                 SIOCIWFIRSTPRIV + 0xA,
14176                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "channel_plan"
14177         },
14178
14179         {
14180                 SIOCIWFIRSTPRIV + 0xB,
14181                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "dbg"
14182         },
14183         {
14184                 SIOCIWFIRSTPRIV + 0xC,
14185                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 3, 0, "rfw"
14186         },
14187         {
14188                 SIOCIWFIRSTPRIV + 0xD,
14189                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "rfr"
14190         },
14191 #if 0
14192         {
14193                 SIOCIWFIRSTPRIV + 0xE,0,0, "wowlan_ctrl"
14194         },
14195 #endif
14196         {
14197                 SIOCIWFIRSTPRIV + 0x10,
14198                 IW_PRIV_TYPE_CHAR | 1024, 0, "p2p_set"
14199         },
14200         {
14201                 SIOCIWFIRSTPRIV + 0x11,
14202                 IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK , "p2p_get"
14203         },
14204         {
14205                 SIOCIWFIRSTPRIV + 0x12, 0, 0, "NULL"
14206         },
14207         {
14208                 SIOCIWFIRSTPRIV + 0x13,
14209                 IW_PRIV_TYPE_CHAR | 64, IW_PRIV_TYPE_CHAR | 64 , "p2p_get2"
14210         },
14211         {
14212                 SIOCIWFIRSTPRIV + 0x14,
14213                 IW_PRIV_TYPE_CHAR  | 64, 0, "tdls"
14214         },
14215         {
14216                 SIOCIWFIRSTPRIV + 0x15,
14217                 IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | 1024 , "tdls_get"
14218         },
14219         {
14220                 SIOCIWFIRSTPRIV + 0x16,
14221                 IW_PRIV_TYPE_CHAR | 64, 0, "pm_set"
14222         },
14223
14224         {SIOCIWFIRSTPRIV + 0x18, IW_PRIV_TYPE_CHAR | IFNAMSIZ , 0 , "rereg_nd_name"},
14225 #ifdef CONFIG_MP_INCLUDED
14226         {SIOCIWFIRSTPRIV + 0x1A, IW_PRIV_TYPE_CHAR | 1024, 0,  "NULL"},
14227         {SIOCIWFIRSTPRIV + 0x1B, IW_PRIV_TYPE_CHAR | 128, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "NULL"},
14228 #else
14229         {SIOCIWFIRSTPRIV + 0x1A, IW_PRIV_TYPE_CHAR | 1024, 0, "efuse_set"},
14230         {SIOCIWFIRSTPRIV + 0x1B, IW_PRIV_TYPE_CHAR | 128, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "efuse_get"},
14231 #endif
14232         {
14233                 SIOCIWFIRSTPRIV + 0x1D,
14234                 IW_PRIV_TYPE_CHAR | 40, IW_PRIV_TYPE_CHAR | 0x7FF, "test"
14235         },
14236
14237 #ifdef CONFIG_INTEL_WIDI
14238         {
14239                 SIOCIWFIRSTPRIV + 0x1E,
14240                 IW_PRIV_TYPE_CHAR | 1024, 0, "widi_set"
14241         },
14242         {
14243                 SIOCIWFIRSTPRIV + 0x1F,
14244                 IW_PRIV_TYPE_CHAR | 128, 0, "widi_prob_req"
14245         },
14246 #endif // CONFIG_INTEL_WIDI
14247
14248 #ifdef CONFIG_MP_INCLUDED
14249         { SIOCIWFIRSTPRIV + 0x0E, IW_PRIV_TYPE_CHAR | 1024, 0 , ""},  //set
14250         { SIOCIWFIRSTPRIV + 0x0F, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK , ""},//get
14251 /* --- sub-ioctls definitions --- */
14252                 { MP_START , IW_PRIV_TYPE_CHAR | 1024, 0, "mp_start" }, //set
14253                 { MP_PHYPARA, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_phypara" },//get
14254                 { MP_STOP , IW_PRIV_TYPE_CHAR | 1024, 0, "mp_stop" }, //set
14255                 { MP_CHANNEL , IW_PRIV_TYPE_CHAR | 1024 , IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_channel" },//get
14256                 { MP_BANDWIDTH , IW_PRIV_TYPE_CHAR | 1024, 0, "mp_bandwidth"}, //set
14257                 { MP_RATE , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_rate" },//get
14258                 { MP_RESET_STATS , IW_PRIV_TYPE_CHAR | 1024, 0, "mp_reset_stats"},
14259                 { MP_QUERY , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK , "mp_query"}, //get
14260                 { READ_REG , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "read_reg" },
14261                 { MP_RATE , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_rate" },
14262                 { READ_RF , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "read_rf" },
14263                 { MP_PSD , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_psd"},
14264                 { MP_DUMP, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_dump" },
14265                 { MP_TXPOWER , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_txpower"},
14266                 { MP_ANT_TX , IW_PRIV_TYPE_CHAR | 1024,  IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_ant_tx"},
14267                 { MP_ANT_RX , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_ant_rx"},
14268                 { WRITE_REG , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "write_reg" },
14269                 { WRITE_RF , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "write_rf" },
14270                 { MP_CTX , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_ctx"},
14271                 { MP_ARX , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_arx"},
14272                 { MP_THER , IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_ther"},
14273                 { EFUSE_SET, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "efuse_set" },
14274                 { EFUSE_GET, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "efuse_get" },
14275                 { MP_PWRTRK , IW_PRIV_TYPE_CHAR | 1024, 0, "mp_pwrtrk"},
14276                 { MP_QueryDrvStats, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_drvquery" },
14277                 { MP_IOCTL, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_ioctl"}, // mp_ioctl
14278                 { MP_SetRFPathSwh, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_setrfpath" },
14279                 { MP_PwrCtlDM, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_pwrctldm" },
14280                 { MP_GET_TXPOWER_INX, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_get_txpower" },
14281
14282 #if defined(CONFIG_RTL8723A) || defined(CONFIG_RTL8723B)
14283                 { MP_SetBT, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "mp_setbt" },
14284         { MP_DISABLE_BT_COEXIST, IW_PRIV_TYPE_CHAR | 1024, 0, "mp_disa_btcoex"},
14285 #endif
14286                 { CTA_TEST, IW_PRIV_TYPE_CHAR | 1024, 0, "cta_test"},
14287 #endif
14288 #ifdef CONFIG_WOWLAN
14289                 { MP_WOW_ENABLE , IW_PRIV_TYPE_CHAR | 1024, 0, "wow_mode" }, //set
14290 #endif
14291 #ifdef CONFIG_AP_WOWLAN
14292                 { MP_AP_WOW_ENABLE , IW_PRIV_TYPE_CHAR | 1024, 0, "ap_wow_mode" }, //set
14293 #endif
14294 };
14295
14296 static iw_handler rtw_private_handler[] =
14297 {
14298         rtw_wx_write32,                                 //0x00
14299         rtw_wx_read32,                                  //0x01
14300         rtw_drvext_hdl,                                 //0x02
14301         rtw_mp_ioctl_hdl,                               //0x03
14302
14303 // for MM DTV platform
14304         rtw_get_ap_info,                                        //0x04
14305
14306         rtw_set_pid,                                            //0x05
14307         rtw_wps_start,                                  //0x06
14308
14309 // for PLATFORM_MT53XX
14310         rtw_wx_get_sensitivity,                 //0x07
14311         rtw_wx_set_mtk_wps_probe_ie,    //0x08
14312         rtw_wx_set_mtk_wps_ie,                  //0x09
14313
14314 // for RTK_DMP_PLATFORM
14315 // Set Channel depend on the country code
14316         rtw_wx_set_channel_plan,                //0x0A
14317
14318         rtw_dbg_port,                                   //0x0B
14319         rtw_wx_write_rf,                                        //0x0C
14320         rtw_wx_read_rf,                                 //0x0D
14321 #ifdef CONFIG_MP_INCLUDED
14322         rtw_mp_set,                                     //0x0E
14323         rtw_mp_get,                                     //0x0F
14324 #else
14325         rtw_wx_priv_null,                               //0x0E
14326         rtw_wx_priv_null,                               //0x0F
14327 #endif
14328         rtw_p2p_set,                                    //0x10
14329         rtw_p2p_get,                                    //0x11
14330         NULL,                                                   //0x12
14331         rtw_p2p_get2,                                   //0x13
14332
14333         rtw_tdls,                                               //0x14
14334         rtw_tdls_get,                                   //0x15
14335
14336         rtw_pm_set,                                             //0x16
14337         rtw_wx_priv_null,                               //0x17
14338         rtw_rereg_nd_name,                              //0x18
14339         rtw_wx_priv_null,                               //0x19
14340 #ifdef CONFIG_MP_INCLUDED
14341         rtw_wx_priv_null,                               //0x1A
14342         rtw_wx_priv_null,                               //0x1B
14343 #else
14344         rtw_mp_efuse_set,                               //0x1A
14345         rtw_mp_efuse_get,                               //0x1B
14346 #endif
14347         NULL,                                                   // 0x1C is reserved for hostapd
14348         rtw_test,                                               // 0x1D
14349 #ifdef CONFIG_INTEL_WIDI
14350         rtw_widi_set,                                   //0x1E
14351         rtw_widi_set_probe_request,             //0x1F
14352 #endif // CONFIG_INTEL_WIDI
14353 };
14354
14355 #endif // #if defined(CONFIG_MP_INCLUDED) && defined(CONFIG_MP_IWPRIV_SUPPORT)
14356
14357 #if WIRELESS_EXT >= 17
14358 static struct iw_statistics *rtw_get_wireless_stats(struct net_device *dev)
14359 {
14360        _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
14361            struct iw_statistics *piwstats=&padapter->iwstats;
14362         int tmp_level = 0;
14363         int tmp_qual = 0;
14364         int tmp_noise = 0;
14365
14366         if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) != _TRUE)
14367         {
14368                 piwstats->qual.qual = 0;
14369                 piwstats->qual.level = 0;
14370                 piwstats->qual.noise = 0;
14371                 //DBG_871X("No link  level:%d, qual:%d, noise:%d\n", tmp_level, tmp_qual, tmp_noise);
14372         }
14373         else{
14374                 #ifdef CONFIG_SIGNAL_DISPLAY_DBM
14375                 tmp_level = translate_percentage_to_dbm(padapter->recvpriv.signal_strength);
14376                 #else
14377                 #ifdef CONFIG_SKIP_SIGNAL_SCALE_MAPPING
14378                 {
14379                         /* Do signal scale mapping when using percentage as the unit of signal strength, since the scale mapping is skipped in odm */
14380
14381                         HAL_DATA_TYPE *pHal = GET_HAL_DATA(padapter);
14382
14383                         tmp_level = (u8)odm_SignalScaleMapping(&pHal->odmpriv, padapter->recvpriv.signal_strength);
14384                 }
14385                 #else
14386                 tmp_level = padapter->recvpriv.signal_strength;
14387                 #endif
14388                 #endif
14389
14390                 tmp_qual = padapter->recvpriv.signal_qual;
14391 #if defined(CONFIG_SIGNAL_DISPLAY_DBM) && defined(CONFIG_BACKGROUND_NOISE_MONITOR)
14392                 if(rtw_linked_check(padapter)){
14393                         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
14394                         struct noise_info info;
14395                         info.bPauseDIG = _TRUE;
14396                         info.IGIValue = 0x1e;
14397                         info.max_time = 100;//ms
14398                         info.chan = pmlmeext->cur_channel ;//rtw_get_oper_ch(padapter);
14399                         rtw_ps_deny(padapter, PS_DENY_IOCTL);
14400                         LeaveAllPowerSaveModeDirect(padapter);
14401
14402                         rtw_hal_set_odm_var(padapter, HAL_ODM_NOISE_MONITOR,&info, _FALSE);
14403                         //ODM_InbandNoise_Monitor(podmpriv,_TRUE,0x20,100);
14404                         rtw_ps_deny_cancel(padapter, PS_DENY_IOCTL);
14405                         rtw_hal_get_odm_var(padapter, HAL_ODM_NOISE_MONITOR,&(info.chan), &(padapter->recvpriv.noise));
14406                         DBG_871X("chan:%d,noise_level:%d\n",info.chan,padapter->recvpriv.noise);
14407                 }
14408 #endif
14409                 tmp_noise = padapter->recvpriv.noise;
14410                 DBG_871X("level:%d, qual:%d, noise:%d, rssi (%d)\n", tmp_level, tmp_qual, tmp_noise,padapter->recvpriv.rssi);
14411
14412                 piwstats->qual.level = tmp_level;
14413                 piwstats->qual.qual = tmp_qual;
14414                 piwstats->qual.noise = tmp_noise;
14415         }
14416 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14))
14417         piwstats->qual.updated = IW_QUAL_ALL_UPDATED ;//|IW_QUAL_DBM;
14418 #else
14419 #ifdef RTK_DMP_PLATFORM
14420         //IW_QUAL_DBM= 0x8, if driver use this flag, wireless extension will show value of dbm.
14421         //remove this flag for show percentage 0~100
14422         piwstats->qual.updated = 0x07;
14423 #else
14424         piwstats->qual.updated = 0x0f;
14425 #endif
14426 #endif
14427
14428         #ifdef CONFIG_SIGNAL_DISPLAY_DBM
14429         piwstats->qual.updated = piwstats->qual.updated | IW_QUAL_DBM;
14430         #endif
14431
14432         return &padapter->iwstats;
14433 }
14434 #endif
14435
14436 #ifdef CONFIG_WIRELESS_EXT
14437 struct iw_handler_def rtw_handlers_def =
14438 {
14439         .standard = rtw_handlers,
14440         .num_standard = sizeof(rtw_handlers) / sizeof(iw_handler),
14441 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33)) || defined(CONFIG_WEXT_PRIV)
14442         .private = rtw_private_handler,
14443         .private_args = (struct iw_priv_args *)rtw_private_args,
14444         .num_private = sizeof(rtw_private_handler) / sizeof(iw_handler),
14445         .num_private_args = sizeof(rtw_private_args) / sizeof(struct iw_priv_args),
14446 #endif
14447 #if WIRELESS_EXT >= 17
14448         .get_wireless_stats = rtw_get_wireless_stats,
14449 #endif
14450 };
14451 #endif
14452
14453 // copy from net/wireless/wext.c start
14454 /* ---------------------------------------------------------------- */
14455 /*
14456  * Calculate size of private arguments
14457  */
14458 static const char iw_priv_type_size[] = {
14459         0,                              /* IW_PRIV_TYPE_NONE */
14460         1,                              /* IW_PRIV_TYPE_BYTE */
14461         1,                              /* IW_PRIV_TYPE_CHAR */
14462         0,                              /* Not defined */
14463         sizeof(__u32),                  /* IW_PRIV_TYPE_INT */
14464         sizeof(struct iw_freq),         /* IW_PRIV_TYPE_FLOAT */
14465         sizeof(struct sockaddr),        /* IW_PRIV_TYPE_ADDR */
14466         0,                              /* Not defined */
14467 };
14468
14469 static int get_priv_size(__u16 args)
14470 {
14471         int num = args & IW_PRIV_SIZE_MASK;
14472         int type = (args & IW_PRIV_TYPE_MASK) >> 12;
14473
14474         return num * iw_priv_type_size[type];
14475 }
14476 // copy from net/wireless/wext.c end
14477
14478 static int rtw_ioctl_wext_private(struct net_device *dev, union iwreq_data *wrq_data)
14479 {
14480         int err = 0;
14481         u8 *input = NULL;
14482         u32 input_len = 0;
14483         const char delim[] = " ";
14484         u8 *output = NULL;
14485         u32 output_len = 0;
14486         u32 count = 0;
14487         u8 *buffer= NULL;
14488         u32 buffer_len = 0;
14489         char *ptr = NULL;
14490         u8 cmdname[17] = {0}; // IFNAMSIZ+1
14491         u32 cmdlen;
14492         s32 len;
14493         u8 *extra = NULL;
14494         u32 extra_size = 0;
14495
14496         s32 k;
14497         const iw_handler *priv;         /* Private ioctl */
14498         const struct iw_priv_args *priv_args;   /* Private ioctl description */
14499         u32 num_priv;                           /* Number of ioctl */
14500         u32 num_priv_args;                      /* Number of descriptions */
14501         iw_handler handler;
14502         int temp;
14503         int subcmd = 0;                         /* sub-ioctl index */
14504         int offset = 0;                         /* Space for sub-ioctl index */
14505
14506         union iwreq_data wdata;
14507
14508
14509         _rtw_memcpy(&wdata, wrq_data, sizeof(wdata));
14510
14511         input_len = 2048;
14512         input = rtw_zmalloc(input_len);
14513         if (NULL == input)
14514                 return -ENOMEM;
14515         if (copy_from_user(input, wdata.data.pointer, input_len)) {
14516                 err = -EFAULT;
14517                 goto exit;
14518         }
14519         ptr = input;
14520         len = strlen(input);
14521
14522         sscanf(ptr, "%16s", cmdname);
14523         cmdlen = strlen(cmdname);
14524         DBG_8192C("%s: cmd=%s\n", __func__, cmdname);
14525
14526         // skip command string
14527         if (cmdlen > 0)
14528                 cmdlen += 1; // skip one space
14529         ptr += cmdlen;
14530         len -= cmdlen;
14531         DBG_8192C("%s: parameters=%s\n", __func__, ptr);
14532
14533         priv = rtw_private_handler;
14534         priv_args = rtw_private_args;
14535         num_priv = sizeof(rtw_private_handler) / sizeof(iw_handler);
14536         num_priv_args = sizeof(rtw_private_args) / sizeof(struct iw_priv_args);
14537
14538         if (num_priv_args == 0) {
14539                 err = -EOPNOTSUPP;
14540                 goto exit;
14541         }
14542
14543         /* Search the correct ioctl */
14544         k = -1;
14545         while((++k < num_priv_args) && strcmp(priv_args[k].name, cmdname));
14546
14547         /* If not found... */
14548         if (k == num_priv_args) {
14549                 err = -EOPNOTSUPP;
14550                 goto exit;
14551         }
14552
14553         /* Watch out for sub-ioctls ! */
14554         if (priv_args[k].cmd < SIOCDEVPRIVATE)
14555         {
14556                 int j = -1;
14557
14558                 /* Find the matching *real* ioctl */
14559                 while ((++j < num_priv_args) && ((priv_args[j].name[0] != '\0') ||
14560                         (priv_args[j].set_args != priv_args[k].set_args) ||
14561                         (priv_args[j].get_args != priv_args[k].get_args)));
14562
14563                 /* If not found... */
14564                 if (j == num_priv_args) {
14565                         err = -EINVAL;
14566                         goto exit;
14567                 }
14568
14569                 /* Save sub-ioctl number */
14570                 subcmd = priv_args[k].cmd;
14571                 /* Reserve one int (simplify alignment issues) */
14572                 offset = sizeof(__u32);
14573                 /* Use real ioctl definition from now on */
14574                 k = j;
14575         }
14576
14577         buffer = rtw_zmalloc(4096);
14578         if (NULL == buffer) {
14579                 err = -ENOMEM;
14580                 goto exit;
14581         }
14582
14583         /* If we have to set some data */
14584         if ((priv_args[k].set_args & IW_PRIV_TYPE_MASK) &&
14585                 (priv_args[k].set_args & IW_PRIV_SIZE_MASK))
14586         {
14587                 u8 *str;
14588
14589                 switch (priv_args[k].set_args & IW_PRIV_TYPE_MASK)
14590                 {
14591                         case IW_PRIV_TYPE_BYTE:
14592                                 /* Fetch args */
14593                                 count = 0;
14594                                 do {
14595                                         str = strsep(&ptr, delim);
14596                                         if (NULL == str) break;
14597                                         sscanf(str, "%i", &temp);
14598                                         buffer[count++] = (u8)temp;
14599                                 } while (1);
14600                                 buffer_len = count;
14601
14602                                 /* Number of args to fetch */
14603                                 wdata.data.length = count;
14604                                 if (wdata.data.length > (priv_args[k].set_args & IW_PRIV_SIZE_MASK))
14605                                         wdata.data.length = priv_args[k].set_args & IW_PRIV_SIZE_MASK;
14606
14607                                 break;
14608
14609                         case IW_PRIV_TYPE_INT:
14610                                 /* Fetch args */
14611                                 count = 0;
14612                                 do {
14613                                         str = strsep(&ptr, delim);
14614                                         if (NULL == str) break;
14615                                         sscanf(str, "%i", &temp);
14616                                         ((s32*)buffer)[count++] = (s32)temp;
14617                                 } while (1);
14618                                 buffer_len = count * sizeof(s32);
14619
14620                                 /* Number of args to fetch */
14621                                 wdata.data.length = count;
14622                                 if (wdata.data.length > (priv_args[k].set_args & IW_PRIV_SIZE_MASK))
14623                                         wdata.data.length = priv_args[k].set_args & IW_PRIV_SIZE_MASK;
14624
14625                                 break;
14626
14627                         case IW_PRIV_TYPE_CHAR:
14628                                 if (len > 0)
14629                                 {
14630                                         /* Size of the string to fetch */
14631                                         wdata.data.length = len;
14632                                         if (wdata.data.length > (priv_args[k].set_args & IW_PRIV_SIZE_MASK))
14633                                                 wdata.data.length = priv_args[k].set_args & IW_PRIV_SIZE_MASK;
14634
14635                                         /* Fetch string */
14636                                         _rtw_memcpy(buffer, ptr, wdata.data.length);
14637                                 }
14638                                 else
14639                                 {
14640                                         wdata.data.length = 1;
14641                                         buffer[0] = '\0';
14642                                 }
14643                                 buffer_len = wdata.data.length;
14644                                 break;
14645
14646                         default:
14647                                 DBG_8192C("%s: Not yet implemented...\n", __func__);
14648                                 err = -1;
14649                                 goto exit;
14650                 }
14651
14652                 if ((priv_args[k].set_args & IW_PRIV_SIZE_FIXED) &&
14653                         (wdata.data.length != (priv_args[k].set_args & IW_PRIV_SIZE_MASK)))
14654                 {
14655                         DBG_8192C("%s: The command %s needs exactly %d argument(s)...\n",
14656                                         __func__, cmdname, priv_args[k].set_args & IW_PRIV_SIZE_MASK);
14657                         err = -EINVAL;
14658                         goto exit;
14659                 }
14660         }   /* if args to set */
14661         else
14662         {
14663                 wdata.data.length = 0L;
14664         }
14665
14666         /* Those two tests are important. They define how the driver
14667         * will have to handle the data */
14668         if ((priv_args[k].set_args & IW_PRIV_SIZE_FIXED) &&
14669                 ((get_priv_size(priv_args[k].set_args) + offset) <= IFNAMSIZ))
14670         {
14671                 /* First case : all SET args fit within wrq */
14672                 if (offset)
14673                         wdata.mode = subcmd;
14674                 _rtw_memcpy(wdata.name + offset, buffer, IFNAMSIZ - offset);
14675         }
14676         else
14677         {
14678                 if ((priv_args[k].set_args == 0) &&
14679                         (priv_args[k].get_args & IW_PRIV_SIZE_FIXED) &&
14680                         (get_priv_size(priv_args[k].get_args) <= IFNAMSIZ))
14681                 {
14682                         /* Second case : no SET args, GET args fit within wrq */
14683                         if (offset)
14684                                 wdata.mode = subcmd;
14685                 }
14686                 else
14687                 {
14688                         /* Third case : args won't fit in wrq, or variable number of args */
14689                         if (copy_to_user(wdata.data.pointer, buffer, buffer_len)) {
14690                                 err = -EFAULT;
14691                                 goto exit;
14692                         }
14693                         wdata.data.flags = subcmd;
14694                 }
14695         }
14696
14697         rtw_mfree(input, input_len);
14698         input = NULL;
14699
14700         extra_size = 0;
14701         if (IW_IS_SET(priv_args[k].cmd))
14702         {
14703                 /* Size of set arguments */
14704                 extra_size = get_priv_size(priv_args[k].set_args);
14705
14706                 /* Does it fits in iwr ? */
14707                 if ((priv_args[k].set_args & IW_PRIV_SIZE_FIXED) &&
14708                         ((extra_size + offset) <= IFNAMSIZ))
14709                         extra_size = 0;
14710         } else {
14711                 /* Size of get arguments */
14712                 extra_size = get_priv_size(priv_args[k].get_args);
14713
14714                 /* Does it fits in iwr ? */
14715                 if ((priv_args[k].get_args & IW_PRIV_SIZE_FIXED) &&
14716                         (extra_size <= IFNAMSIZ))
14717                         extra_size = 0;
14718         }
14719
14720         if (extra_size == 0) {
14721                 extra = (u8*)&wdata;
14722                 rtw_mfree(buffer, 4096);
14723                 buffer = NULL;
14724         } else
14725                 extra = buffer;
14726
14727         handler = priv[priv_args[k].cmd - SIOCIWFIRSTPRIV];
14728         err = handler(dev, NULL, &wdata, extra);
14729
14730         /* If we have to get some data */
14731         if ((priv_args[k].get_args & IW_PRIV_TYPE_MASK) &&
14732                 (priv_args[k].get_args & IW_PRIV_SIZE_MASK))
14733         {
14734                 int j;
14735                 int n = 0;      /* number of args */
14736                 u8 str[20] = {0};
14737
14738                 /* Check where is the returned data */
14739                 if ((priv_args[k].get_args & IW_PRIV_SIZE_FIXED) &&
14740                         (get_priv_size(priv_args[k].get_args) <= IFNAMSIZ))
14741                         n = priv_args[k].get_args & IW_PRIV_SIZE_MASK;
14742                 else
14743                         n = wdata.data.length;
14744
14745                 output = rtw_zmalloc(4096);
14746                 if (NULL == output) {
14747                         err =  -ENOMEM;
14748                         goto exit;
14749                 }
14750
14751                 switch (priv_args[k].get_args & IW_PRIV_TYPE_MASK)
14752                 {
14753                         case IW_PRIV_TYPE_BYTE:
14754                                 /* Display args */
14755                                 for (j = 0; j < n; j++)
14756                                 {
14757                                         sprintf(str, "%d  ", extra[j]);
14758                                         len = strlen(str);
14759                                         output_len = strlen(output);
14760                                         if ((output_len + len + 1) > 4096) {
14761                                                 err = -E2BIG;
14762                                                 goto exit;
14763                                         }
14764                                         _rtw_memcpy(output+output_len, str, len);
14765                                 }
14766                                 break;
14767
14768                         case IW_PRIV_TYPE_INT:
14769                                 /* Display args */
14770                                 for (j = 0; j < n; j++)
14771                                 {
14772                                         sprintf(str, "%d  ", ((__s32*)extra)[j]);
14773                                         len = strlen(str);
14774                                         output_len = strlen(output);
14775                                         if ((output_len + len + 1) > 4096) {
14776                                                 err = -E2BIG;
14777                                                 goto exit;
14778                                         }
14779                                         _rtw_memcpy(output+output_len, str, len);
14780                                 }
14781                                 break;
14782
14783                         case IW_PRIV_TYPE_CHAR:
14784                                 /* Display args */
14785                                 _rtw_memcpy(output, extra, n);
14786                                 break;
14787
14788                         default:
14789                                 DBG_8192C("%s: Not yet implemented...\n", __func__);
14790                                 err = -1;
14791                                 goto exit;
14792                 }
14793
14794                 output_len = strlen(output) + 1;
14795                 wrq_data->data.length = output_len;
14796                 if (copy_to_user(wrq_data->data.pointer, output, output_len)) {
14797                         err = -EFAULT;
14798                         goto exit;
14799                 }
14800         }   /* if args to set */
14801         else
14802         {
14803                 wrq_data->data.length = 0;
14804         }
14805
14806 exit:
14807         if (input)
14808                 rtw_mfree(input, input_len);
14809         if (buffer)
14810                 rtw_mfree(buffer, 4096);
14811         if (output)
14812                 rtw_mfree(output, 4096);
14813
14814         return err;
14815 }
14816
14817 int rtw_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
14818 {
14819         struct iwreq *wrq = (struct iwreq *)rq;
14820         int ret=0;
14821
14822         switch (cmd)
14823         {
14824                 case RTL_IOCTL_WPA_SUPPLICANT:
14825                         ret = wpa_supplicant_ioctl(dev, &wrq->u.data);
14826                         break;
14827 #ifdef CONFIG_AP_MODE
14828                 case RTL_IOCTL_HOSTAPD:
14829                         ret = rtw_hostapd_ioctl(dev, &wrq->u.data);
14830                         break;
14831 #ifdef CONFIG_NO_WIRELESS_HANDLERS
14832                 case SIOCSIWMODE:
14833                         ret = rtw_wx_set_mode(dev, NULL, &wrq->u, NULL);
14834                         break;
14835 #endif
14836 #endif // CONFIG_AP_MODE
14837                 case SIOCDEVPRIVATE:
14838                         ret = rtw_ioctl_wext_private(dev, &wrq->u);
14839                         break;
14840                 case (SIOCDEVPRIVATE+1):
14841                         ret = rtw_android_priv_cmd(dev, rq, cmd);
14842                         break;
14843                 default:
14844                         ret = -EOPNOTSUPP;
14845                         break;
14846         }
14847
14848         return ret;
14849 }
14850
14851