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