drivers/net/wireless/rtl8723au/core/rtw_ioctl_set.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 _RTW_IOCTL_SET_C_
  21
  22
  23 #include <drv_conf.h>
  24 #include <osdep_service.h>
  25 #include <drv_types.h>
  26 #include <rtw_ioctl_set.h>
  27 #include <hal_intf.h>
  28
  29 #ifdef CONFIG_USB_HCI
  30 #include <usb_osintf.h>
  31 #include <usb_ops.h>
  32 #endif
  33 #ifdef CONFIG_SDIO_HCI
  34 #include <sdio_osintf.h>
  35 #endif
  36
  37 #ifdef CONFIG_GSPI_HCI
  38 #include <gspi_osintf.h>
  39 #endif
  40
  41 extern void indicate_wx_scan_complete_event(_adapter *padapter);
  42
  43 #define IS_MAC_ADDRESS_BROADCAST(addr) \
  44 ( \
  45         ( (addr[0] == 0xff) && (addr[1] == 0xff) && \
  46                 (addr[2] == 0xff) && (addr[3] == 0xff) && \
  47                 (addr[4] == 0xff) && (addr[5] == 0xff) )  ? _TRUE : _FALSE \
  48 )
  49
  50 u8 rtw_validate_bssid(u8 *bssid)
  51 {
  52         u8 ret = _TRUE;
  53
  54         if (is_zero_mac_addr(bssid)
  55                 || is_broadcast_mac_addr(bssid)
  56                 || is_multicast_mac_addr(bssid)
  57         ) {
  58                 ret = _FALSE;
  59         }
  60
  61         return ret;
  62 }
  63
  64 u8 rtw_validate_ssid(NDIS_802_11_SSID *ssid)
  65 {
  66         u8       i;
  67         u8      ret=_TRUE;
  68
  69 _func_enter_;
  70
  71         if (ssid->SsidLength > 32) {
  72                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("ssid length >32\n"));
  73                 ret= _FALSE;
  74                 goto exit;
  75         }
  76
  77 #ifdef CONFIG_VALIDATE_SSID
  78         for(i = 0; i < ssid->SsidLength; i++)
  79         {
  80                 //wifi, printable ascii code must be supported
  81                 if(!( (ssid->Ssid[i] >= 0x20) && (ssid->Ssid[i] <= 0x7e) )){
  82                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("ssid has nonprintabl ascii\n"));
  83                         ret= _FALSE;
  84                         break;
  85                 }
  86         }
  87 #endif /* CONFIG_VALIDATE_SSID */
  88
  89 exit:
  90
  91 _func_exit_;
  92
  93         return ret;
  94 }
  95
  96 u8 rtw_do_join(_adapter * padapter);
  97 u8 rtw_do_join(_adapter * padapter)
  98 {
  99         _irqL   irqL;
 100         _list   *plist, *phead;
 101         u8* pibss = NULL;
 102         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
 103         _queue  *queue  = &(pmlmepriv->scanned_queue);
 104         u8 ret=_SUCCESS;
 105
 106 _func_enter_;
 107
 108         _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
 109         phead = get_list_head(queue);
 110         plist = get_next(phead);
 111
 112         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("\n rtw_do_join: phead = %p; plist = %p \n\n\n", phead, plist));
 113
 114         pmlmepriv->cur_network.join_res = -2;
 115
 116         set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
 117
 118         pmlmepriv->pscanned = plist;
 119
 120         pmlmepriv->to_join = _TRUE;
 121
 122         if(_rtw_queue_empty(queue)== _TRUE)
 123         {
 124                 _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
 125                 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
 126
 127                 //when set_ssid/set_bssid for rtw_do_join(), but scanning queue is empty
 128                 //we try to issue sitesurvey firstly
 129
 130                 if (pmlmepriv->LinkDetectInfo.bBusyTraffic ==_FALSE
 131                         || rtw_to_roaming(padapter) > 0
 132                 )
 133                 {
 134                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("rtw_do_join(): site survey if scanned_queue is empty\n."));
 135                         // submit site_survey_cmd
 136                         if(_SUCCESS!=(ret=rtw_sitesurvey_cmd(padapter, &pmlmepriv->assoc_ssid, 1, NULL, 0)) ) {
 137                                 pmlmepriv->to_join = _FALSE;
 138                                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("rtw_do_join(): site survey return error\n."));
 139                         }
 140                 }
 141                 else
 142                 {
 143                         pmlmepriv->to_join = _FALSE;
 144                         ret = _FAIL;
 145                 }
 146
 147                 goto exit;
 148         }
 149         else
 150         {
 151                 int select_ret;
 152                 _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
 153                 if((select_ret=rtw_select_and_join_from_scanned_queue(pmlmepriv))==_SUCCESS)
 154                 {
 155                         pmlmepriv->to_join = _FALSE;
 156                         _set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT);
 157                 }
 158                 else
 159                 {
 160                         if(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)==_TRUE)
 161                         {
 162                                 // submit createbss_cmd to change to a ADHOC_MASTER
 163
 164                                 //pmlmepriv->lock has been acquired by caller...
 165                                 WLAN_BSSID_EX    *pdev_network = &(padapter->registrypriv.dev_network);
 166
 167                                 pmlmepriv->fw_state = WIFI_ADHOC_MASTER_STATE;
 168
 169                                 pibss = padapter->registrypriv.dev_network.MacAddress;
 170
 171                                 _rtw_memset(&pdev_network->Ssid, 0, sizeof(NDIS_802_11_SSID));
 172                                 _rtw_memcpy(&pdev_network->Ssid, &pmlmepriv->assoc_ssid, sizeof(NDIS_802_11_SSID));
 173
 174                                 rtw_update_registrypriv_dev_network(padapter);
 175
 176                                 rtw_generate_random_ibss(pibss);
 177
 178                                 if(rtw_createbss_cmd(padapter)!=_SUCCESS)
 179                                 {
 180                                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("***Error=>do_goin: rtw_createbss_cmd status FAIL*** \n "));
 181                                         ret =  _FALSE;
 182                                         goto exit;
 183                                 }
 184
 185                                 pmlmepriv->to_join = _FALSE;
 186
 187                                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("***Error=> rtw_select_and_join_from_scanned_queue FAIL under STA_Mode*** \n "));
 188
 189                         }
 190                         else
 191                         {
 192                                 // can't associate ; reset under-linking
 193                                 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
 194
 195 #if 0
 196                                 if((check_fwstate(pmlmepriv, WIFI_STATION_STATE) == _TRUE))
 197                                 {
 198                                         if(_rtw_memcmp(pmlmepriv->cur_network.network.Ssid.Ssid, pmlmepriv->assoc_ssid.Ssid, pmlmepriv->assoc_ssid.SsidLength))
 199                                         {
 200                                                 // for funk to do roaming
 201                                                 // funk will reconnect, but funk will not sitesurvey before reconnect
 202                                                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("for funk to do roaming"));
 203                                                 if(pmlmepriv->sitesurveyctrl.traffic_busy==_FALSE)
 204                                                         rtw_sitesurvey_cmd(padapter, &pmlmepriv->assoc_ssid, 1, NULL, 0);
 205                                         }
 206
 207                                 }
 208 #endif
 209
 210                                 //when set_ssid/set_bssid for rtw_do_join(), but there are no desired bss in scanning queue
 211                                 //we try to issue sitesurvey firstly
 212                                 if(pmlmepriv->LinkDetectInfo.bBusyTraffic==_FALSE
 213                                         || rtw_to_roaming(padapter) > 0
 214                                 )
 215                                 {
 216                                         //DBG_871X("rtw_do_join() when   no desired bss in scanning queue \n");
 217                                         if( _SUCCESS!=(ret=rtw_sitesurvey_cmd(padapter, &pmlmepriv->assoc_ssid, 1, NULL, 0)) ){
 218                                                 pmlmepriv->to_join = _FALSE;
 219                                                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("do_join(): site survey return error\n."));
 220                                         }
 221                                 }
 222                                 else
 223                                 {
 224                                         ret = _FAIL;
 225                                         pmlmepriv->to_join = _FALSE;
 226                                 }
 227                         }
 228
 229                 }
 230
 231         }
 232
 233 exit:
 234
 235 _func_exit_;
 236
 237         return ret;
 238 }
 239
 240 #ifdef PLATFORM_WINDOWS
 241 u8 rtw_pnp_set_power_wakeup(_adapter* padapter)
 242 {
 243         u8 res=_SUCCESS;
 244
 245 _func_enter_;
 246
 247         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("==>rtw_pnp_set_power_wakeup!!!\n"));
 248
 249         res = rtw_setstandby_cmd(padapter, 0);
 250
 251         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("<==rtw_pnp_set_power_wakeup!!!\n"));
 252
 253 _func_exit_;
 254
 255         return res;
 256 }
 257
 258 u8 rtw_pnp_set_power_sleep(_adapter* padapter)
 259 {
 260         u8 res=_SUCCESS;
 261
 262 _func_enter_;
 263
 264         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("==>rtw_pnp_set_power_sleep!!!\n"));
 265         //DbgPrint("+rtw_pnp_set_power_sleep\n");
 266
 267         res = rtw_setstandby_cmd(padapter, 1);
 268
 269         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("<==rtw_pnp_set_power_sleep!!!\n"));
 270
 271 _func_exit_;
 272
 273         return res;
 274 }
 275
 276 u8 rtw_set_802_11_reload_defaults(_adapter * padapter, NDIS_802_11_RELOAD_DEFAULTS reloadDefaults)
 277 {
 278 _func_enter_;
 279
 280         switch( reloadDefaults)
 281         {
 282                 case Ndis802_11ReloadWEPKeys:
 283                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("SetInfo OID_802_11_RELOAD_DEFAULTS : Ndis802_11ReloadWEPKeys\n"));
 284                         break;
 285         }
 286
 287         // SecClearAllKeys(Adapter);
 288         // 8711 CAM was not for En/Decrypt only
 289         // so, we can't clear all keys.
 290         // should we disable WPAcfg (ox0088) bit 1-2, instead of clear all CAM
 291
 292         //TO DO...
 293
 294 _func_exit_;
 295
 296         return _TRUE;
 297 }
 298
 299 u8 set_802_11_test(_adapter* padapter, NDIS_802_11_TEST *test)
 300 {
 301         u8 ret=_TRUE;
 302
 303 _func_enter_;
 304
 305         switch(test->Type)
 306         {
 307                 case 1:
 308                         NdisMIndicateStatus(padapter->hndis_adapter, NDIS_STATUS_MEDIA_SPECIFIC_INDICATION, (PVOID)&test->AuthenticationEvent, test->Length - 8);
 309                         NdisMIndicateStatusComplete(padapter->hndis_adapter);
 310                         break;
 311
 312                 case 2:
 313                         NdisMIndicateStatus(padapter->hndis_adapter, NDIS_STATUS_MEDIA_SPECIFIC_INDICATION, (PVOID)&test->RssiTrigger, sizeof(NDIS_802_11_RSSI));
 314                         NdisMIndicateStatusComplete(padapter->hndis_adapter);
 315                         break;
 316
 317                 default:
 318                         ret=_FALSE;
 319                         break;
 320         }
 321
 322 _func_exit_;
 323
 324         return ret;
 325 }
 326
 327 u8      rtw_set_802_11_pmkid(_adapter*  padapter, NDIS_802_11_PMKID *pmkid)
 328 {
 329         u8      ret=_SUCCESS;
 330
 331         return ret;
 332 }
 333
 334 #endif
 335
 336 u8 rtw_set_802_11_bssid(_adapter* padapter, u8 *bssid)
 337 {
 338         _irqL irqL;
 339         u8 status=_SUCCESS;
 340         u32 cur_time = 0;
 341
 342         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 343
 344 _func_enter_;
 345
 346         DBG_871X_LEVEL(_drv_always_, "set bssid:%pM\n", bssid);
 347
 348         if ((bssid[0]==0x00 && bssid[1]==0x00 && bssid[2]==0x00 && bssid[3]==0x00 && bssid[4]==0x00 &&bssid[5]==0x00) ||
 349             (bssid[0]==0xFF && bssid[1]==0xFF && bssid[2]==0xFF && bssid[3]==0xFF && bssid[4]==0xFF &&bssid[5]==0xFF))
 350         {
 351                 status = _FAIL;
 352                 goto exit;
 353         }
 354
 355         _enter_critical_bh(&pmlmepriv->lock, &irqL);
 356
 357
 358         DBG_871X("Set BSSID under fw_state=0x%08x\n", get_fwstate(pmlmepriv));
 359         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == _TRUE) {
 360                 goto handle_tkip_countermeasure;
 361         } else if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == _TRUE) {
 362                 goto release_mlme_lock;
 363         }
 364
 365         if (check_fwstate(pmlmepriv, _FW_LINKED|WIFI_ADHOC_MASTER_STATE) == _TRUE)
 366         {
 367                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("set_bssid: _FW_LINKED||WIFI_ADHOC_MASTER_STATE\n"));
 368
 369                 if (_rtw_memcmp(&pmlmepriv->cur_network.network.MacAddress, bssid, ETH_ALEN) == _TRUE)
 370                 {
 371                         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == _FALSE)
 372                                 goto release_mlme_lock;//it means driver is in WIFI_ADHOC_MASTER_STATE, we needn't create bss again.
 373                 } else {
 374                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("Set BSSID not the same bssid\n"));
 375                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("set_bssid="MAC_FMT"\n", MAC_ARG(bssid) ));
 376                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("cur_bssid="MAC_FMT"\n", MAC_ARG(pmlmepriv->cur_network.network.MacAddress) ));
 377
 378                         rtw_disassoc_cmd(padapter, 0, _TRUE);
 379
 380                         if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)
 381                                 rtw_indicate_disconnect(padapter);
 382
 383                         rtw_free_assoc_resources(padapter, 1);
 384
 385                         if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE)) {
 386                                 _clr_fwstate_(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
 387                                 set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
 388                         }
 389                 }
 390         }
 391
 392 handle_tkip_countermeasure:
 393         if (rtw_handle_tkip_countermeasure(padapter, __func__) == _FAIL) {
 394                 status = _FAIL;
 395                 goto release_mlme_lock;
 396         }
 397
 398         _rtw_memcpy(&pmlmepriv->assoc_bssid, bssid, ETH_ALEN);
 399         pmlmepriv->assoc_by_bssid=_TRUE;
 400
 401         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == _TRUE) {
 402                 pmlmepriv->to_join = _TRUE;
 403         }
 404         else {
 405                 status = rtw_do_join(padapter);
 406         }
 407
 408 release_mlme_lock:
 409         _exit_critical_bh(&pmlmepriv->lock, &irqL);
 410
 411 exit:
 412         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 413                 ("rtw_set_802_11_bssid: status=%d\n", status));
 414
 415 _func_exit_;
 416
 417         return status;
 418 }
 419
 420 u8 rtw_set_802_11_ssid(_adapter* padapter, NDIS_802_11_SSID *ssid)
 421 {
 422         _irqL irqL;
 423         u8 status = _SUCCESS;
 424         u32 cur_time = 0;
 425
 426         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 427         struct wlan_network *pnetwork = &pmlmepriv->cur_network;
 428
 429 _func_enter_;
 430
 431         DBG_871X_LEVEL(_drv_always_, "set ssid [%s] fw_state=0x%08x\n",
 432                         ssid->Ssid, get_fwstate(pmlmepriv));
 433
 434         if(padapter->hw_init_completed==_FALSE){
 435                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 436                          ("set_ssid: hw_init_completed==_FALSE=>exit!!!\n"));
 437                 status = _FAIL;
 438                 goto exit;
 439         }
 440
 441         _enter_critical_bh(&pmlmepriv->lock, &irqL);
 442
 443         DBG_871X("Set SSID under fw_state=0x%08x\n", get_fwstate(pmlmepriv));
 444         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == _TRUE) {
 445                 goto handle_tkip_countermeasure;
 446         } else if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == _TRUE) {
 447                 goto release_mlme_lock;
 448         }
 449
 450         if (check_fwstate(pmlmepriv, _FW_LINKED|WIFI_ADHOC_MASTER_STATE) == _TRUE)
 451         {
 452                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
 453                          ("set_ssid: _FW_LINKED||WIFI_ADHOC_MASTER_STATE\n"));
 454
 455                 if ((pmlmepriv->assoc_ssid.SsidLength == ssid->SsidLength) &&
 456                     (_rtw_memcmp(&pmlmepriv->assoc_ssid.Ssid, ssid->Ssid, ssid->SsidLength) == _TRUE))
 457                 {
 458                         if((check_fwstate(pmlmepriv, WIFI_STATION_STATE) == _FALSE))
 459                         {
 460                                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 461                                          ("Set SSID is the same ssid, fw_state=0x%08x\n",
 462                                           get_fwstate(pmlmepriv)));
 463
 464                                 if(rtw_is_same_ibss(padapter, pnetwork) == _FALSE)
 465                                 {
 466                                         //if in WIFI_ADHOC_MASTER_STATE | WIFI_ADHOC_STATE, create bss or rejoin again
 467                                         rtw_disassoc_cmd(padapter, 0, _TRUE);
 468
 469                                         if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)
 470                                                 rtw_indicate_disconnect(padapter);
 471
 472                                         rtw_free_assoc_resources(padapter, 1);
 473
 474                                         if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE) {
 475                                                 _clr_fwstate_(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
 476                                                 set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
 477                                         }
 478                                 }
 479                                 else
 480                                 {
 481                                         goto release_mlme_lock;//it means driver is in WIFI_ADHOC_MASTER_STATE, we needn't create bss again.
 482                                 }
 483                         }
 484 #ifdef CONFIG_LPS
 485                         else {
 486                                 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_JOINBSS, 1);
 487                         }
 488 #endif
 489                 }
 490                 else
 491                 {
 492                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("Set SSID not the same ssid\n"));
 493                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("set_ssid=[%s] len=0x%x\n", ssid->Ssid, (unsigned int)ssid->SsidLength));
 494                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("assoc_ssid=[%s] len=0x%x\n", pmlmepriv->assoc_ssid.Ssid, (unsigned int)pmlmepriv->assoc_ssid.SsidLength));
 495
 496                         rtw_disassoc_cmd(padapter, 0, _TRUE);
 497
 498                         if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)
 499                                 rtw_indicate_disconnect(padapter);
 500
 501                         rtw_free_assoc_resources(padapter, 1);
 502
 503                         if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == _TRUE) {
 504                                 _clr_fwstate_(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
 505                                 set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
 506                         }
 507                 }
 508         }
 509
 510 handle_tkip_countermeasure:
 511         if (rtw_handle_tkip_countermeasure(padapter, __func__) == _FAIL) {
 512                 status = _FAIL;
 513                 goto release_mlme_lock;
 514         }
 515
 516         if (rtw_validate_ssid(ssid) == _FALSE) {
 517                 status = _FAIL;
 518                 goto release_mlme_lock;
 519         }
 520
 521         _rtw_memcpy(&pmlmepriv->assoc_ssid, ssid, sizeof(NDIS_802_11_SSID));
 522         pmlmepriv->assoc_by_bssid=_FALSE;
 523
 524         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == _TRUE) {
 525                 pmlmepriv->to_join = _TRUE;
 526         }
 527         else {
 528                 status = rtw_do_join(padapter);
 529         }
 530
 531 release_mlme_lock:
 532         _exit_critical_bh(&pmlmepriv->lock, &irqL);
 533
 534 exit:
 535         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 536                 ("-rtw_set_802_11_ssid: status=%d\n", status));
 537
 538 _func_exit_;
 539
 540         return status;
 541
 542 }
 543
 544 u8 rtw_set_802_11_connect(_adapter* padapter, u8 *bssid, NDIS_802_11_SSID *ssid)
 545 {
 546         _irqL irqL;
 547         u8 status = _SUCCESS;
 548         u32 cur_time = 0;
 549         bool bssid_valid = _TRUE;
 550         bool ssid_valid = _TRUE;
 551         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 552
 553 _func_enter_;
 554
 555         if (!ssid || rtw_validate_ssid(ssid) == _FALSE)
 556                 ssid_valid = _FALSE;
 557
 558         if (!bssid || rtw_validate_bssid(bssid) == _FALSE)
 559                 bssid_valid = _FALSE;
 560
 561         if (ssid_valid == _FALSE && bssid_valid == _FALSE) {
 562                 DBG_871X(FUNC_ADPT_FMT" ssid:%p, ssid_valid:%d, bssid:%p, bssid_valid:%d\n",
 563                         FUNC_ADPT_ARG(padapter), ssid, ssid_valid, bssid, bssid_valid);
 564                 status = _FAIL;
 565                 goto exit;
 566         }
 567
 568         if(padapter->hw_init_completed==_FALSE){
 569                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 570                          ("set_ssid: hw_init_completed==_FALSE=>exit!!!\n"));
 571                 status = _FAIL;
 572                 goto exit;
 573         }
 574
 575         _enter_critical_bh(&pmlmepriv->lock, &irqL);
 576
 577         DBG_871X_LEVEL(_drv_always_, FUNC_ADPT_FMT"  fw_state=0x%08x\n",
 578                 FUNC_ADPT_ARG(padapter), get_fwstate(pmlmepriv));
 579
 580         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == _TRUE) {
 581                 goto handle_tkip_countermeasure;
 582         } else if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == _TRUE) {
 583                 goto release_mlme_lock;
 584         }
 585
 586 handle_tkip_countermeasure:
 587         if (rtw_handle_tkip_countermeasure(padapter, __func__) == _FAIL) {
 588                 status = _FAIL;
 589                 goto release_mlme_lock;
 590         }
 591
 592         if (ssid && ssid_valid)
 593                 _rtw_memcpy(&pmlmepriv->assoc_ssid, ssid, sizeof(NDIS_802_11_SSID));
 594
 595         if (bssid && bssid_valid) {
 596                 _rtw_memcpy(&pmlmepriv->assoc_bssid, bssid, ETH_ALEN);
 597                 pmlmepriv->assoc_by_bssid = _TRUE;
 598         }
 599
 600         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == _TRUE) {
 601                 pmlmepriv->to_join = _TRUE;
 602         }
 603         else {
 604                 status = rtw_do_join(padapter);
 605         }
 606
 607 release_mlme_lock:
 608         _exit_critical_bh(&pmlmepriv->lock, &irqL);
 609
 610 exit:
 611
 612 _func_exit_;
 613
 614         return status;
 615 }
 616
 617 u8 rtw_set_802_11_infrastructure_mode(_adapter* padapter,
 618         NDIS_802_11_NETWORK_INFRASTRUCTURE networktype)
 619 {
 620         _irqL irqL;
 621         struct  mlme_priv       *pmlmepriv = &padapter->mlmepriv;
 622         struct  wlan_network    *cur_network = &pmlmepriv->cur_network;
 623         NDIS_802_11_NETWORK_INFRASTRUCTURE* pold_state = &(cur_network->network.InfrastructureMode);
 624
 625 _func_enter_;
 626
 627         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_notice_,
 628                  ("+rtw_set_802_11_infrastructure_mode: old=%d new=%d fw_state=0x%08x\n",
 629                   *pold_state, networktype, get_fwstate(pmlmepriv)));
 630
 631         if(*pold_state != networktype)
 632         {
 633                 _enter_critical_bh(&pmlmepriv->lock, &irqL);
 634
 635                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,(" change mode!"));
 636                 //DBG_871X("change mode, old_mode=%d, new_mode=%d, fw_state=0x%x\n", *pold_state, networktype, get_fwstate(pmlmepriv));
 637
 638                 if(*pold_state==Ndis802_11APMode)
 639                 {
 640                         //change to other mode from Ndis802_11APMode
 641                         cur_network->join_res = -1;
 642
 643 #ifdef CONFIG_NATIVEAP_MLME
 644                         stop_ap_mode(padapter);
 645 #endif
 646                 }
 647
 648                 if((check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE) ||(*pold_state==Ndis802_11IBSS))
 649                         rtw_disassoc_cmd(padapter, 0, _TRUE);
 650
 651                 if((check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE) ||
 652                         (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)== _TRUE) )
 653                         rtw_free_assoc_resources(padapter, 1);
 654
 655                 if((*pold_state == Ndis802_11Infrastructure) ||(*pold_state == Ndis802_11IBSS))
 656                {
 657                         if(check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)
 658                         {
 659                                 rtw_indicate_disconnect(padapter); //will clr Linked_state; before this function, we must have chked whether  issue dis-assoc_cmd or not
 660                         }
 661                }
 662
 663                 *pold_state = networktype;
 664
 665                 _clr_fwstate_(pmlmepriv, ~WIFI_NULL_STATE);
 666
 667                 switch(networktype)
 668                 {
 669                         case Ndis802_11IBSS:
 670                                 set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
 671                                 break;
 672
 673                         case Ndis802_11Infrastructure:
 674                                 set_fwstate(pmlmepriv, WIFI_STATION_STATE);
 675                                 break;
 676
 677                         case Ndis802_11APMode:
 678                                 set_fwstate(pmlmepriv, WIFI_AP_STATE);
 679 #ifdef CONFIG_NATIVEAP_MLME
 680                                 start_ap_mode(padapter);
 681                                 //rtw_indicate_connect(padapter);
 682 #endif
 683
 684                                 break;
 685
 686                         case Ndis802_11AutoUnknown:
 687                         case Ndis802_11InfrastructureMax:
 688                                 break;
 689                 }
 690
 691                 //SecClearAllKeys(adapter);
 692
 693                 //RT_TRACE(COMP_OID_SET, DBG_LOUD, ("set_infrastructure: fw_state:%x after changing mode\n",
 694                 //                                                                      get_fwstate(pmlmepriv) ));
 695
 696                 _exit_critical_bh(&pmlmepriv->lock, &irqL);
 697         }
 698
 699 _func_exit_;
 700
 701         return _TRUE;
 702 }
 703
 704
 705 u8 rtw_set_802_11_disassociate(_adapter *padapter)
 706 {
 707         _irqL irqL;
 708         struct mlme_priv * pmlmepriv = &padapter->mlmepriv;
 709
 710 _func_enter_;
 711
 712         _enter_critical_bh(&pmlmepriv->lock, &irqL);
 713
 714         if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)
 715         {
 716                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("MgntActrtw_set_802_11_disassociate: rtw_indicate_disconnect\n"));
 717
 718                 rtw_disassoc_cmd(padapter, 0, _TRUE);
 719                 rtw_indicate_disconnect(padapter);
 720                 //modify for CONFIG_IEEE80211W, none 11w can use it
 721                 rtw_free_assoc_resources_cmd(padapter);
 722                 rtw_pwr_wakeup(padapter);
 723         }
 724
 725         _exit_critical_bh(&pmlmepriv->lock, &irqL);
 726
 727 _func_exit_;
 728
 729         return _TRUE;
 730 }
 731
 732 u8 rtw_set_802_11_bssid_list_scan(_adapter* padapter, NDIS_802_11_SSID *pssid, int ssid_max_num)
 733 {
 734         _irqL   irqL;
 735         struct  mlme_priv               *pmlmepriv= &padapter->mlmepriv;
 736         u8      res=_TRUE;
 737
 738 _func_enter_;
 739
 740         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("+rtw_set_802_11_bssid_list_scan(), fw_state=%x\n", get_fwstate(pmlmepriv)));
 741
 742         if (padapter == NULL) {
 743                 res=_FALSE;
 744                 goto exit;
 745         }
 746         if (padapter->hw_init_completed==_FALSE){
 747                 res = _FALSE;
 748                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n===rtw_set_802_11_bssid_list_scan:hw_init_completed==_FALSE===\n"));
 749                 goto exit;
 750         }
 751
 752         if ((check_fwstate(pmlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING) == _TRUE) ||
 753                 (pmlmepriv->LinkDetectInfo.bBusyTraffic == _TRUE))
 754         {
 755                 // Scan or linking is in progress, do nothing.
 756                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("rtw_set_802_11_bssid_list_scan fail since fw_state = %x\n", get_fwstate(pmlmepriv)));
 757                 res = _TRUE;
 758
 759                 if(check_fwstate(pmlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING))== _TRUE){
 760                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n###_FW_UNDER_SURVEY|_FW_UNDER_LINKING\n\n"));
 761                 } else {
 762                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n###pmlmepriv->sitesurveyctrl.traffic_busy==_TRUE\n\n"));
 763                 }
 764         } else {
 765                 if (rtw_is_scan_deny(padapter)) {
 766                         DBG_871X(FUNC_ADPT_FMT": scan deny\n", FUNC_ADPT_ARG(padapter));
 767                         indicate_wx_scan_complete_event(padapter);
 768                         return _SUCCESS;
 769                 }
 770
 771                 _enter_critical_bh(&pmlmepriv->lock, &irqL);
 772
 773                 res = rtw_sitesurvey_cmd(padapter, pssid, ssid_max_num, NULL, 0);
 774
 775                 _exit_critical_bh(&pmlmepriv->lock, &irqL);
 776         }
 777 exit:
 778
 779 _func_exit_;
 780
 781         return res;
 782 }
 783
 784 u8 rtw_set_802_11_authentication_mode(_adapter* padapter, NDIS_802_11_AUTHENTICATION_MODE authmode)
 785 {
 786         struct security_priv *psecuritypriv = &padapter->securitypriv;
 787         int res;
 788         u8 ret;
 789
 790 _func_enter_;
 791
 792         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("set_802_11_auth.mode(): mode=%x\n", authmode));
 793
 794         psecuritypriv->ndisauthtype=authmode;
 795
 796         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("rtw_set_802_11_authentication_mode:psecuritypriv->ndisauthtype=%d", psecuritypriv->ndisauthtype));
 797
 798         if(psecuritypriv->ndisauthtype>3)
 799                 psecuritypriv->dot11AuthAlgrthm=dot11AuthAlgrthm_8021X;
 800
 801 #ifdef CONFIG_WAPI_SUPPORT
 802         if(psecuritypriv->ndisauthtype == 6)
 803                 psecuritypriv->dot11AuthAlgrthm=dot11AuthAlgrthm_WAPI;
 804 #endif
 805
 806         res=rtw_set_auth(padapter,psecuritypriv);
 807
 808         if(res==_SUCCESS)
 809                 ret=_TRUE;
 810         else
 811                 ret=_FALSE;
 812
 813 _func_exit_;
 814
 815         return ret;
 816 }
 817
 818 u8 rtw_set_802_11_add_wep(_adapter* padapter, NDIS_802_11_WEP *wep){
 819
 820         u8              bdefaultkey;
 821         u8              btransmitkey;
 822         sint            keyid,res;
 823         struct security_priv* psecuritypriv=&(padapter->securitypriv);
 824         u8              ret=_SUCCESS;
 825
 826 _func_enter_;
 827
 828         bdefaultkey=(wep->KeyIndex & 0x40000000) > 0 ? _FALSE : _TRUE;   //for ???
 829         btransmitkey= (wep->KeyIndex & 0x80000000) > 0 ? _TRUE  : _FALSE;       //for ???
 830         keyid=wep->KeyIndex & 0x3fffffff;
 831
 832         if(keyid>4)
 833         {
 834                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("MgntActrtw_set_802_11_add_wep:keyid>4=>fail\n"));
 835                 ret=_FALSE;
 836                 goto exit;
 837         }
 838
 839         switch(wep->KeyLength)
 840         {
 841                 case 5:
 842                         psecuritypriv->dot11PrivacyAlgrthm=_WEP40_;
 843                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("MgntActrtw_set_802_11_add_wep:wep->KeyLength=5\n"));
 844                         break;
 845                 case 13:
 846                         psecuritypriv->dot11PrivacyAlgrthm=_WEP104_;
 847                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("MgntActrtw_set_802_11_add_wep:wep->KeyLength=13\n"));
 848                         break;
 849                 default:
 850                         psecuritypriv->dot11PrivacyAlgrthm=_NO_PRIVACY_;
 851                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("MgntActrtw_set_802_11_add_wep:wep->KeyLength!=5 or 13\n"));
 852                         break;
 853         }
 854
 855         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("rtw_set_802_11_add_wep:befor memcpy, wep->KeyLength=0x%x wep->KeyIndex=0x%x  keyid =%x\n",wep->KeyLength,wep->KeyIndex,keyid));
 856
 857         _rtw_memcpy(&(psecuritypriv->dot11DefKey[keyid].skey[0]),&(wep->KeyMaterial),wep->KeyLength);
 858
 859         psecuritypriv->dot11DefKeylen[keyid]=wep->KeyLength;
 860
 861         psecuritypriv->dot11PrivacyKeyIndex=keyid;
 862
 863         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("rtw_set_802_11_add_wep:security key material : %x %x %x %x %x %x %x %x %x %x %x %x %x \n",
 864                 psecuritypriv->dot11DefKey[keyid].skey[0],psecuritypriv->dot11DefKey[keyid].skey[1],psecuritypriv->dot11DefKey[keyid].skey[2],
 865                 psecuritypriv->dot11DefKey[keyid].skey[3],psecuritypriv->dot11DefKey[keyid].skey[4],psecuritypriv->dot11DefKey[keyid].skey[5],
 866                 psecuritypriv->dot11DefKey[keyid].skey[6],psecuritypriv->dot11DefKey[keyid].skey[7],psecuritypriv->dot11DefKey[keyid].skey[8],
 867                 psecuritypriv->dot11DefKey[keyid].skey[9],psecuritypriv->dot11DefKey[keyid].skey[10],psecuritypriv->dot11DefKey[keyid].skey[11],
 868                 psecuritypriv->dot11DefKey[keyid].skey[12]));
 869
 870         res=rtw_set_key(padapter,psecuritypriv, keyid, 1,_TRUE);
 871
 872         if(res==_FAIL)
 873                 ret= _FALSE;
 874 exit:
 875
 876 _func_exit_;
 877
 878         return ret;
 879
 880 }
 881
 882 u8 rtw_set_802_11_remove_wep(_adapter* padapter, u32 keyindex){
 883
 884         u8 ret=_SUCCESS;
 885
 886 _func_enter_;
 887
 888         if (keyindex >= 0x80000000 || padapter == NULL){
 889
 890                 ret=_FALSE;
 891                 goto exit;
 892
 893         }
 894         else
 895         {
 896                 int res;
 897                 struct security_priv* psecuritypriv=&(padapter->securitypriv);
 898                 if( keyindex < 4 ){
 899
 900                         _rtw_memset(&psecuritypriv->dot11DefKey[keyindex], 0, 16);
 901
 902                         res=rtw_set_key(padapter,psecuritypriv,keyindex, 0,_TRUE);
 903
 904                         psecuritypriv->dot11DefKeylen[keyindex]=0;
 905
 906                         if(res==_FAIL)
 907                                 ret=_FAIL;
 908
 909                 }
 910                 else
 911                 {
 912                         ret=_FAIL;
 913                 }
 914
 915         }
 916
 917 exit:
 918
 919 _func_exit_;
 920
 921         return ret;
 922
 923 }
 924
 925 u8 rtw_set_802_11_add_key(_adapter* padapter, NDIS_802_11_KEY *key){
 926
 927         uint    encryptionalgo;
 928         u8 * pbssid;
 929         struct sta_info *stainfo;
 930         u8      bgroup = _FALSE;
 931         u8      bgrouptkey = _FALSE;//can be remove later
 932         u8      ret=_SUCCESS;
 933
 934 _func_enter_;
 935
 936         if (((key->KeyIndex & 0x80000000) == 0) && ((key->KeyIndex & 0x40000000) > 0)){
 937
 938                 // It is invalid to clear bit 31 and set bit 30. If the miniport driver encounters this combination,
 939                 // it must fail the request and return NDIS_STATUS_INVALID_DATA.
 940                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("rtw_set_802_11_add_key: ((key->KeyIndex & 0x80000000) == 0)[=%d] ",(int)(key->KeyIndex & 0x80000000) == 0));
 941                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("rtw_set_802_11_add_key:((key->KeyIndex & 0x40000000) > 0)[=%d]" , (int)(key->KeyIndex & 0x40000000) > 0));
 942                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("rtw_set_802_11_add_key: key->KeyIndex=%d \n" ,(int)key->KeyIndex));
 943                 ret= _FAIL;
 944                 goto exit;
 945         }
 946
 947         if(key->KeyIndex & 0x40000000)
 948         {
 949                 // Pairwise key
 950
 951                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("OID_802_11_ADD_KEY: +++++ Pairwise key +++++\n"));
 952
 953                 pbssid=get_bssid(&padapter->mlmepriv);
 954                 stainfo=rtw_get_stainfo(&padapter->stapriv, pbssid);
 955
 956                 if((stainfo!=NULL)&&(padapter->securitypriv.dot11AuthAlgrthm==dot11AuthAlgrthm_8021X)){
 957                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("OID_802_11_ADD_KEY:( stainfo!=NULL)&&(Adapter->securitypriv.dot11AuthAlgrthm==dot11AuthAlgrthm_8021X)\n"));
 958                         encryptionalgo=stainfo->dot118021XPrivacy;
 959                 }
 960                 else{
 961                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("OID_802_11_ADD_KEY: stainfo==NULL)||(Adapter->securitypriv.dot11AuthAlgrthm!=dot11AuthAlgrthm_8021X)\n"));
 962                         encryptionalgo=padapter->securitypriv.dot11PrivacyAlgrthm;
 963                 }
 964
 965                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("rtw_set_802_11_add_key: (encryptionalgo ==%d)!\n",encryptionalgo ));
 966                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("rtw_set_802_11_add_key: (Adapter->securitypriv.dot11PrivacyAlgrthm ==%d)!\n",padapter->securitypriv.dot11PrivacyAlgrthm));
 967                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("rtw_set_802_11_add_key: (Adapter->securitypriv.dot11AuthAlgrthm ==%d)!\n",padapter->securitypriv.dot11AuthAlgrthm));
 968
 969                 if((stainfo!=NULL)){
 970                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("rtw_set_802_11_add_key: (stainfo->dot118021XPrivacy ==%d)!\n", stainfo->dot118021XPrivacy));
 971                 }
 972
 973                 if(key->KeyIndex & 0x000000FF){
 974                         // The key index is specified in the lower 8 bits by values of zero to 255.
 975                         // The key index should be set to zero for a Pairwise key, and the driver should fail with
 976                         // NDIS_STATUS_INVALID_DATA if the lower 8 bits is not zero
 977                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,(" key->KeyIndex & 0x000000FF.\n"));
 978                         ret= _FAIL;
 979                         goto exit;
 980                 }
 981
 982                 // check BSSID
 983                 if (IS_MAC_ADDRESS_BROADCAST(key->BSSID) == _TRUE){
 984
 985                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("MacAddr_isBcst(key->BSSID)\n"));
 986                         ret= _FALSE;
 987                         goto exit;
 988                 }
 989
 990                 // Check key length for TKIP.
 991                 //if(encryptionAlgorithm == RT_ENC_TKIP_ENCRYPTION && key->KeyLength != 32)
 992                 if((encryptionalgo== _TKIP_)&& (key->KeyLength != 32)){
 993                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("TKIP KeyLength:0x%x != 32\n", key->KeyLength));
 994                         ret=_FAIL;
 995                         goto exit;
 996
 997                 }
 998
 999                 // Check key length for AES.
1000                 if((encryptionalgo== _AES_)&& (key->KeyLength != 16)) {
1001                         // For our supplicant, EAPPkt9x.vxd, cannot differentiate TKIP and AES case.
1002                         if(key->KeyLength == 32) {
1003                                 key->KeyLength = 16;
1004                         } else {
1005                                 ret= _FAIL;
1006                                 goto exit;
1007                         }
1008                 }
1009
1010                 // Check key length for WEP. For NDTEST, 2005.01.27, by rcnjko.
1011                 if(     (encryptionalgo== _WEP40_|| encryptionalgo== _WEP104_) && (key->KeyLength != 5 || key->KeyLength != 13)) {
1012                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("WEP KeyLength:0x%x != 5 or 13\n", key->KeyLength));
1013                         ret=_FAIL;
1014                         goto exit;
1015                 }
1016
1017                 bgroup = _FALSE;
1018
1019                 // Check the pairwise key. Added by Annie, 2005-07-06.
1020                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("------------------------------------------\n"));
1021                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("[Pairwise Key set]\n"));
1022                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("------------------------------------------\n"));
1023                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("key index: 0x%8x(0x%8x)\n", key->KeyIndex,(key->KeyIndex&0x3)));
1024                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("key Length: %d\n", key->KeyLength));
1025                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("------------------------------------------\n"));
1026
1027         }
1028         else
1029         {
1030                 // Group key - KeyIndex(BIT30==0)
1031                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("OID_802_11_ADD_KEY: +++++ Group key +++++\n"));
1032
1033
1034                 // when add wep key through add key and didn't assigned encryption type before
1035                 if((padapter->securitypriv.ndisauthtype<=3)&&(padapter->securitypriv.dot118021XGrpPrivacy==0))
1036                 {
1037                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("keylen=%d( Adapter->securitypriv.dot11PrivacyAlgrthm=%x  )padapter->securitypriv.dot118021XGrpPrivacy(%x)\n", key->KeyLength,padapter->securitypriv.dot11PrivacyAlgrthm,padapter->securitypriv.dot118021XGrpPrivacy));
1038
1039                         switch(key->KeyLength)
1040                         {
1041                                 case 5:
1042                                         padapter->securitypriv.dot11PrivacyAlgrthm=_WEP40_;
1043                                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("Adapter->securitypriv.dot11PrivacyAlgrthm= %x key->KeyLength=%u\n", padapter->securitypriv.dot11PrivacyAlgrthm,key->KeyLength));
1044                                         break;
1045                                 case 13:
1046                                         padapter->securitypriv.dot11PrivacyAlgrthm=_WEP104_;
1047                                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("Adapter->securitypriv.dot11PrivacyAlgrthm= %x key->KeyLength=%u\n", padapter->securitypriv.dot11PrivacyAlgrthm,key->KeyLength));
1048                                         break;
1049                                 default:
1050                                         padapter->securitypriv.dot11PrivacyAlgrthm=_NO_PRIVACY_;
1051                                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("Adapter->securitypriv.dot11PrivacyAlgrthm= %x key->KeyLength=%u \n", padapter->securitypriv.dot11PrivacyAlgrthm,key->KeyLength));
1052                                         break;
1053                         }
1054
1055                         encryptionalgo=padapter->securitypriv.dot11PrivacyAlgrthm;
1056
1057                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,(" Adapter->securitypriv.dot11PrivacyAlgrthm=%x\n", padapter->securitypriv.dot11PrivacyAlgrthm));
1058
1059                 }
1060                 else
1061                 {
1062                         encryptionalgo=padapter->securitypriv.dot118021XGrpPrivacy;
1063                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("( Adapter->securitypriv.dot11PrivacyAlgrthm=%x  )encryptionalgo(%x)=padapter->securitypriv.dot118021XGrpPrivacy(%x)keylen=%d\n", padapter->securitypriv.dot11PrivacyAlgrthm,encryptionalgo,padapter->securitypriv.dot118021XGrpPrivacy,key->KeyLength));
1064
1065                 }
1066
1067                 if((check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE)==_TRUE) && (IS_MAC_ADDRESS_BROADCAST(key->BSSID) == _FALSE)) {
1068                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,(" IBSS but BSSID is not Broadcast Address.\n"));
1069                         ret= _FAIL;
1070                         goto exit;
1071                 }
1072
1073                 // Check key length for TKIP
1074                 if((encryptionalgo== _TKIP_) && (key->KeyLength != 32)) {
1075
1076                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,(" TKIP GTK KeyLength:%u != 32\n", key->KeyLength));
1077                         ret= _FAIL;
1078                         goto exit;
1079
1080                 } else if(encryptionalgo== _AES_ && (key->KeyLength != 16 && key->KeyLength != 32) ) {
1081
1082                         // Check key length for AES
1083                         // For NDTEST, we allow keylen=32 in this case. 2005.01.27, by rcnjko.
1084                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("<=== SetInfo, OID_802_11_ADD_KEY: AES GTK KeyLength:%u != 16 or 32\n", key->KeyLength));
1085                         ret= _FAIL;
1086                         goto exit;
1087                 }
1088
1089                 // Change the key length for EAPPkt9x.vxd. Added by Annie, 2005-11-03.
1090                 if((encryptionalgo==  _AES_) && (key->KeyLength == 32) ) {
1091                         key->KeyLength = 16;
1092                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("AES key length changed: %u\n", key->KeyLength) );
1093                 }
1094
1095                 if(key->KeyIndex & 0x8000000) {//error ??? 0x8000_0000
1096                         bgrouptkey = _TRUE;
1097                 }
1098
1099                 if((check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE)==_TRUE)&&(check_fwstate(&padapter->mlmepriv, _FW_LINKED)==_TRUE))
1100                 {
1101                         bgrouptkey = _TRUE;
1102                 }
1103
1104                 bgroup = _TRUE;
1105
1106                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("------------------------------------------\n") );
1107                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("[Group Key set]\n") );
1108                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("------------------------------------------\n")) ;
1109                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("key index: 0x%8x(0x%8x)\n", key->KeyIndex,(key->KeyIndex&0x3)));
1110                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("key Length: %d\n", key->KeyLength)) ;
1111                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("------------------------------------------\n"));
1112
1113         }
1114
1115         // If WEP encryption algorithm, just call rtw_set_802_11_add_wep().
1116         if((padapter->securitypriv.dot11AuthAlgrthm !=dot11AuthAlgrthm_8021X)&&(encryptionalgo== _WEP40_  || encryptionalgo== _WEP104_))
1117         {
1118                 u8 ret;
1119                 u32 keyindex;
1120                 u32 len = FIELD_OFFSET(NDIS_802_11_KEY, KeyMaterial) + key->KeyLength;
1121                 NDIS_802_11_WEP *wep = &padapter->securitypriv.ndiswep;
1122
1123                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("OID_802_11_ADD_KEY: +++++ WEP key +++++\n"));
1124
1125                 wep->Length = len;
1126                 keyindex = key->KeyIndex&0x7fffffff;
1127                 wep->KeyIndex = keyindex ;
1128                 wep->KeyLength = key->KeyLength;
1129
1130                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("OID_802_11_ADD_KEY:Before memcpy \n"));
1131
1132                 _rtw_memcpy(wep->KeyMaterial, key->KeyMaterial, key->KeyLength);
1133                 _rtw_memcpy(&(padapter->securitypriv.dot11DefKey[keyindex].skey[0]), key->KeyMaterial, key->KeyLength);
1134
1135                 padapter->securitypriv.dot11DefKeylen[keyindex]=key->KeyLength;
1136                 padapter->securitypriv.dot11PrivacyKeyIndex=keyindex;
1137
1138                 ret = rtw_set_802_11_add_wep(padapter, wep);
1139
1140                 goto exit;
1141
1142         }
1143
1144         if(key->KeyIndex & 0x20000000){
1145                 // SetRSC
1146                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("OID_802_11_ADD_KEY: +++++ SetRSC+++++\n"));
1147                 if(bgroup == _TRUE)
1148                 {
1149                         NDIS_802_11_KEY_RSC keysrc=key->KeyRSC & 0x00FFFFFFFFFFFFULL;
1150                         _rtw_memcpy(&padapter->securitypriv.dot11Grprxpn, &keysrc, 8);
1151                 }
1152                 else
1153                 {
1154                         NDIS_802_11_KEY_RSC keysrc=key->KeyRSC & 0x00FFFFFFFFFFFFULL;
1155                         _rtw_memcpy(&padapter->securitypriv.dot11Grptxpn, &keysrc, 8);
1156                 }
1157
1158         }
1159
1160         // Indicate this key idx is used for TX
1161         // Save the key in KeyMaterial
1162         if(bgroup == _TRUE) // Group transmit key
1163         {
1164                 int res;
1165
1166                 if(bgrouptkey == _TRUE)
1167                 {
1168                         padapter->securitypriv.dot118021XGrpKeyid=(u8)key->KeyIndex;
1169                 }
1170
1171                 if((key->KeyIndex&0x3) == 0){
1172                         ret = _FAIL;
1173                         goto exit;
1174                 }
1175
1176                 _rtw_memset(&padapter->securitypriv.dot118021XGrpKey[(u8)((key->KeyIndex) & 0x03)], 0, 16);
1177                 _rtw_memset(&padapter->securitypriv.dot118021XGrptxmickey[(u8)((key->KeyIndex) & 0x03)], 0, 16);
1178                 _rtw_memset(&padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)], 0, 16);
1179
1180                 if((key->KeyIndex & 0x10000000))
1181                 {
1182                         _rtw_memcpy(&padapter->securitypriv.dot118021XGrptxmickey[(u8)((key->KeyIndex) & 0x03)], key->KeyMaterial + 16, 8);
1183                         _rtw_memcpy(&padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)], key->KeyMaterial + 24, 8);
1184
1185                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n rtw_set_802_11_add_key:rx mic :0x%02x:0x%02x:0x%02x:0x%02x:0x%02x:0x%02x:0x%02x:0x%02x\n",
1186                                 padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[0],padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[1],
1187                                 padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[2],padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[3],
1188                                 padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[4],padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[5],
1189                                 padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[6],padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[7]));
1190                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n rtw_set_802_11_add_key:set Group mic key!!!!!!!!\n"));
1191
1192                 }
1193                 else
1194                 {
1195                         _rtw_memcpy(&padapter->securitypriv.dot118021XGrptxmickey[(u8)((key->KeyIndex) & 0x03)], key->KeyMaterial + 24, 8);
1196                         _rtw_memcpy(&padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)], key->KeyMaterial + 16, 8);
1197
1198                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n rtw_set_802_11_add_key:rx mic :0x%02x:0x%02x:0x%02x:0x%02x:0x%02x:0x%02x:0x%02x:0x%02x\n",
1199                                 padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[0],padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[1],
1200                                 padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[2],padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[3],
1201                                 padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[4],padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[5],
1202                                 padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[6],padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[7]));
1203                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n rtw_set_802_11_add_key:set Group mic key!!!!!!!!\n"));
1204
1205                 }
1206
1207                 //set group key by index
1208                 _rtw_memcpy(&padapter->securitypriv.dot118021XGrpKey[(u8)((key->KeyIndex) & 0x03)], key->KeyMaterial, key->KeyLength);
1209
1210                 key->KeyIndex=key->KeyIndex & 0x03;
1211
1212                 padapter->securitypriv.binstallGrpkey=_TRUE;
1213
1214                 padapter->securitypriv.bcheck_grpkey=_FALSE;
1215
1216                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("reset group key"));
1217
1218                 res=rtw_set_key(padapter,&padapter->securitypriv, key->KeyIndex, 1,_TRUE);
1219
1220                 if(res==_FAIL)
1221                         ret= _FAIL;
1222
1223                 goto exit;
1224
1225         }
1226         else // Pairwise Key
1227         {
1228                 u8 res;
1229
1230                 pbssid=get_bssid(&padapter->mlmepriv);
1231                 stainfo=rtw_get_stainfo(&padapter->stapriv , pbssid );
1232
1233                 if(stainfo!=NULL)
1234                 {
1235                         _rtw_memset( &stainfo->dot118021x_UncstKey, 0, 16);// clear keybuffer
1236
1237                         _rtw_memcpy(&stainfo->dot118021x_UncstKey, key->KeyMaterial, 16);
1238
1239                         if(encryptionalgo== _TKIP_)
1240                         {
1241                                 padapter->securitypriv.busetkipkey=_FALSE;
1242
1243                                 //_set_timer(&padapter->securitypriv.tkip_timer, 50);
1244
1245                                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n ==========_set_timer\n"));
1246
1247                                 // if TKIP, save the Receive/Transmit MIC key in KeyMaterial[128-255]
1248                                 if((key->KeyIndex & 0x10000000)){
1249                                         _rtw_memcpy(&stainfo->dot11tkiptxmickey, key->KeyMaterial + 16, 8);
1250                                         _rtw_memcpy(&stainfo->dot11tkiprxmickey, key->KeyMaterial + 24, 8);
1251
1252                                 } else {
1253                                         _rtw_memcpy(&stainfo->dot11tkiptxmickey, key->KeyMaterial + 24, 8);
1254                                         _rtw_memcpy(&stainfo->dot11tkiprxmickey, key->KeyMaterial + 16, 8);
1255
1256                                 }
1257
1258                         }
1259                         else if(encryptionalgo == _AES_)
1260                         {
1261
1262                         }
1263
1264
1265                         //Set key to CAM through H2C command
1266                         if(bgrouptkey)//never go to here
1267                         {
1268                                 res=rtw_setstakey_cmd(padapter, (unsigned char *)stainfo, _FALSE, _TRUE);
1269                                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n rtw_set_802_11_add_key:rtw_setstakey_cmd(group)\n"));
1270                         }
1271                         else{
1272                                 res=rtw_setstakey_cmd(padapter, (unsigned char *)stainfo, _TRUE, _TRUE);
1273                                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n rtw_set_802_11_add_key:rtw_setstakey_cmd(unicast)\n"));
1274                         }
1275
1276                         if(res ==_FALSE)
1277                                 ret= _FAIL;
1278
1279                 }
1280
1281         }
1282
1283 exit:
1284
1285 _func_exit_;
1286
1287         return ret;
1288 }
1289
1290 u8 rtw_set_802_11_remove_key(_adapter*  padapter, NDIS_802_11_REMOVE_KEY *key){
1291
1292         uint                            encryptionalgo;
1293         u8 * pbssid;
1294         struct sta_info *stainfo;
1295         u8      bgroup = (key->KeyIndex & 0x4000000) > 0 ? _FALSE: _TRUE;
1296         u8      keyIndex = (u8)key->KeyIndex & 0x03;
1297         u8      ret=_SUCCESS;
1298
1299 _func_enter_;
1300
1301         if ((key->KeyIndex & 0xbffffffc) > 0) {
1302                 ret=_FAIL;
1303                 goto exit;
1304         }
1305
1306         if (bgroup == _TRUE) {
1307                 encryptionalgo= padapter->securitypriv.dot118021XGrpPrivacy;
1308                 // clear group key by index
1309                 //NdisZeroMemory(Adapter->MgntInfo.SecurityInfo.KeyBuf[keyIndex], MAX_WEP_KEY_LEN);
1310                 //Adapter->MgntInfo.SecurityInfo.KeyLen[keyIndex] = 0;
1311
1312                 _rtw_memset(&padapter->securitypriv.dot118021XGrpKey[keyIndex], 0, 16);
1313
1314                 //! \todo Send a H2C Command to Firmware for removing this Key in CAM Entry.
1315
1316         } else {
1317
1318                 pbssid=get_bssid(&padapter->mlmepriv);
1319                 stainfo=rtw_get_stainfo(&padapter->stapriv , pbssid );
1320                 if(stainfo !=NULL){
1321                         encryptionalgo=stainfo->dot118021XPrivacy;
1322
1323                 // clear key by BSSID
1324                 _rtw_memset(&stainfo->dot118021x_UncstKey, 0, 16);
1325
1326                 //! \todo Send a H2C Command to Firmware for disable this Key in CAM Entry.
1327
1328                 }
1329                 else{
1330                         ret= _FAIL;
1331                         goto exit;
1332                 }
1333         }
1334
1335 exit:
1336
1337 _func_exit_;
1338
1339         return _TRUE;
1340
1341 }
1342
1343 /*
1344 * rtw_get_cur_max_rate -
1345 * @adapter: pointer to _adapter structure
1346 *
1347 * Return 0 or 100Kbps
1348 */
1349 u16 rtw_get_cur_max_rate(_adapter *adapter)
1350 {
1351         int     i = 0;
1352         u8      *p;
1353         u16     rate = 0, max_rate = 0;
1354         struct mlme_ext_priv    *pmlmeext = &adapter->mlmeextpriv;
1355         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
1356         struct registry_priv *pregistrypriv = &adapter->registrypriv;
1357         struct mlme_priv        *pmlmepriv = &adapter->mlmepriv;
1358         WLAN_BSSID_EX  *pcur_bss = &pmlmepriv->cur_network.network;
1359 #ifdef CONFIG_80211N_HT
1360         struct rtw_ieee80211_ht_cap *pht_capie;
1361         u8      rf_type = 0;
1362         u8      bw_40MHz=0, short_GI_20=0, short_GI_40=0;
1363         u16     mcs_rate=0;
1364         u32     ht_ielen = 0;
1365 #endif
1366
1367 #ifdef CONFIG_MP_INCLUDED
1368         if (adapter->registrypriv.mp_mode == 1)
1369         {
1370                 if (check_fwstate(pmlmepriv, WIFI_MP_STATE) == _TRUE)
1371                         return 0;
1372         }
1373 #endif
1374
1375         if((check_fwstate(pmlmepriv, _FW_LINKED) != _TRUE)
1376                 && (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) != _TRUE))
1377                 return 0;
1378
1379 #ifdef CONFIG_80211N_HT
1380         if (pmlmeext->cur_wireless_mode & (WIRELESS_11_24N|WIRELESS_11_5N)) {
1381                 p = rtw_get_ie(&pcur_bss->IEs[12], _HT_CAPABILITY_IE_, &ht_ielen, pcur_bss->IELength-12);
1382                 if(p && ht_ielen>0)
1383                 {
1384                         pht_capie = (struct rtw_ieee80211_ht_cap *)(p+2);
1385
1386                         _rtw_memcpy(&mcs_rate , pht_capie->supp_mcs_set, 2);
1387
1388                         //bw_40MHz = (pht_capie->cap_info&IEEE80211_HT_CAP_SUP_WIDTH) ? 1:0;
1389                         //cur_bwmod is updated by beacon, pmlmeinfo is updated by association response
1390                         bw_40MHz = (pmlmeext->cur_bwmode && (HT_INFO_HT_PARAM_REC_TRANS_CHNL_WIDTH & pmlmeinfo->HT_info.infos[0])) ? 1:0;
1391
1392                         //short_GI = (pht_capie->cap_info&(IEEE80211_HT_CAP_SGI_20|IEEE80211_HT_CAP_SGI_40)) ? 1:0;
1393                         short_GI_20 = (pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info&IEEE80211_HT_CAP_SGI_20) ? 1:0;
1394                         short_GI_40 = (pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info&IEEE80211_HT_CAP_SGI_40) ? 1:0;
1395
1396                         rtw_hal_get_hwreg(adapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
1397                         max_rate = rtw_mcs_rate(
1398                                 rf_type,
1399                                 bw_40MHz & (pregistrypriv->cbw40_enable),
1400                                 short_GI_20,
1401                                 short_GI_40,
1402                                 pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate
1403                         );
1404                 }
1405         }
1406         else
1407 #endif //CONFIG_80211N_HT
1408         {
1409                 while( (pcur_bss->SupportedRates[i]!=0) && (pcur_bss->SupportedRates[i]!=0xFF))
1410                 {
1411                         rate = pcur_bss->SupportedRates[i]&0x7F;
1412                         if(rate>max_rate)
1413                                 max_rate = rate;
1414                         i++;
1415                 }
1416
1417                 max_rate = max_rate*10/2;
1418         }
1419
1420         return max_rate;
1421 }
1422
1423 /*
1424 * rtw_set_scan_mode -
1425 * @adapter: pointer to _adapter structure
1426 * @scan_mode:
1427 *
1428 * Return _SUCCESS or _FAIL
1429 */
1430 int rtw_set_scan_mode(_adapter *adapter, RT_SCAN_TYPE scan_mode)
1431 {
1432         if(scan_mode != SCAN_ACTIVE && scan_mode != SCAN_PASSIVE)
1433                 return _FAIL;
1434
1435         adapter->mlmepriv.scan_mode = scan_mode;
1436
1437         return _SUCCESS;
1438 }
1439
1440 /*
1441 * rtw_set_channel_plan -
1442 * @adapter: pointer to _adapter structure
1443 * @channel_plan:
1444 *
1445 * Return _SUCCESS or _FAIL
1446 */
1447 int rtw_set_channel_plan(_adapter *adapter, u8 channel_plan)
1448 {
1449         struct registry_priv *pregistrypriv = &adapter->registrypriv;
1450         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1451
1452         //handle by cmd_thread to sync with scan operation
1453         return rtw_set_chplan_cmd(adapter, channel_plan, 1);
1454 }
1455
1456 /*
1457 * rtw_set_country -
1458 * @adapter: pointer to _adapter structure
1459 * @country_code: string of country code
1460 *
1461 * Return _SUCCESS or _FAIL
1462 */
1463 int rtw_set_country(_adapter *adapter, const char *country_code)
1464 {
1465         int channel_plan = RT_CHANNEL_DOMAIN_WORLD_WIDE_5G;
1466
1467         DBG_871X("%s country_code:%s\n", __func__, country_code);
1468
1469         //TODO: should have a table to match country code and RT_CHANNEL_DOMAIN
1470         //TODO: should consider 2-character and 3-character country code
1471         if(0 == strcmp(country_code, "US"))
1472                 channel_plan = RT_CHANNEL_DOMAIN_FCC;
1473         else if(0 == strcmp(country_code, "EU"))
1474                 channel_plan = RT_CHANNEL_DOMAIN_ETSI;
1475         else if(0 == strcmp(country_code, "JP"))
1476                 channel_plan = RT_CHANNEL_DOMAIN_MKK;
1477         else if(0 == strcmp(country_code, "CN"))
1478                 channel_plan = RT_CHANNEL_DOMAIN_CHINA;
1479         else if(0 == strcmp(country_code, "IN"))
1480                 channel_plan = RT_CHANNEL_DOMAIN_GLOBAL_DOAMIN;
1481         else
1482                 DBG_871X("%s unknown country_code:%s\n", __FUNCTION__, country_code);
1483
1484         return rtw_set_channel_plan(adapter, channel_plan);
1485 }
1486