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 #include <hal_data.h>
  24
  25
  26 extern void indicate_wx_scan_complete_event(_adapter *padapter);
  27
  28 #define IS_MAC_ADDRESS_BROADCAST(addr) \
  29 ( \
  30         ( (addr[0] == 0xff) && (addr[1] == 0xff) && \
  31                 (addr[2] == 0xff) && (addr[3] == 0xff) && \
  32                 (addr[4] == 0xff) && (addr[5] == 0xff) )  ? _TRUE : _FALSE \
  33 )
  34
  35 u8 rtw_validate_bssid(u8 *bssid)
  36 {
  37         u8 ret = _TRUE;
  38
  39         if (is_zero_mac_addr(bssid)
  40                 || is_broadcast_mac_addr(bssid)
  41                 || is_multicast_mac_addr(bssid)
  42         ) {
  43                 ret = _FALSE;
  44         }
  45
  46         return ret;
  47 }
  48
  49 u8 rtw_validate_ssid(NDIS_802_11_SSID *ssid)
  50 {
  51         u8       i;
  52         u8      ret=_TRUE;
  53
  54 _func_enter_;
  55
  56         if (ssid->SsidLength > 32) {
  57                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("ssid length >32\n"));
  58                 ret= _FALSE;
  59                 goto exit;
  60         }
  61
  62 #ifdef CONFIG_VALIDATE_SSID
  63         for(i = 0; i < ssid->SsidLength; i++)
  64         {
  65                 //wifi, printable ascii code must be supported
  66                 if(!( (ssid->Ssid[i] >= 0x20) && (ssid->Ssid[i] <= 0x7e) )){
  67                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("ssid has nonprintabl ascii\n"));
  68                         ret= _FALSE;
  69                         break;
  70                 }
  71         }
  72 #endif /* CONFIG_VALIDATE_SSID */
  73
  74 exit:
  75
  76 _func_exit_;
  77
  78         return ret;
  79 }
  80
  81 u8 rtw_do_join(_adapter * padapter);
  82 u8 rtw_do_join(_adapter * padapter)
  83 {
  84         _irqL   irqL;
  85         _list   *plist, *phead;
  86         u8* pibss = NULL;
  87         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
  88         _queue  *queue  = &(pmlmepriv->scanned_queue);
  89         u8 ret=_SUCCESS;
  90
  91 _func_enter_;
  92
  93         _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
  94         phead = get_list_head(queue);
  95         plist = get_next(phead);
  96
  97         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("\n rtw_do_join: phead = %p; plist = %p \n\n\n", phead, plist));
  98
  99         pmlmepriv->cur_network.join_res = -2;
 100
 101         set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
 102
 103         pmlmepriv->pscanned = plist;
 104
 105         pmlmepriv->to_join = _TRUE;
 106
 107         if(_rtw_queue_empty(queue)== _TRUE)
 108         {
 109                 _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
 110                 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
 111
 112                 //when set_ssid/set_bssid for rtw_do_join(), but scanning queue is empty
 113                 //we try to issue sitesurvey firstly
 114
 115                 if (pmlmepriv->LinkDetectInfo.bBusyTraffic ==_FALSE
 116                         || rtw_to_roam(padapter) > 0
 117                 )
 118                 {
 119                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("rtw_do_join(): site survey if scanned_queue is empty\n."));
 120                         // submit site_survey_cmd
 121                         if(_SUCCESS!=(ret=rtw_sitesurvey_cmd(padapter, &pmlmepriv->assoc_ssid, 1, NULL, 0)) ) {
 122                                 pmlmepriv->to_join = _FALSE;
 123                                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("rtw_do_join(): site survey return error\n."));
 124                         }
 125                 }
 126                 else
 127                 {
 128                         pmlmepriv->to_join = _FALSE;
 129                         ret = _FAIL;
 130                 }
 131
 132                 goto exit;
 133         }
 134         else
 135         {
 136                 int select_ret;
 137                 _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
 138                 if((select_ret=rtw_select_and_join_from_scanned_queue(pmlmepriv))==_SUCCESS)
 139                 {
 140                         pmlmepriv->to_join = _FALSE;
 141                         _set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT);
 142                 }
 143                 else
 144                 {
 145                         if(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)==_TRUE)
 146                         {
 147                                 // submit createbss_cmd to change to a ADHOC_MASTER
 148
 149                                 //pmlmepriv->lock has been acquired by caller...
 150                                 WLAN_BSSID_EX    *pdev_network = &(padapter->registrypriv.dev_network);
 151
 152                                 pmlmepriv->fw_state = WIFI_ADHOC_MASTER_STATE;
 153
 154                                 pibss = padapter->registrypriv.dev_network.MacAddress;
 155
 156                                 _rtw_memset(&pdev_network->Ssid, 0, sizeof(NDIS_802_11_SSID));
 157                                 _rtw_memcpy(&pdev_network->Ssid, &pmlmepriv->assoc_ssid, sizeof(NDIS_802_11_SSID));
 158
 159                                 rtw_update_registrypriv_dev_network(padapter);
 160
 161                                 rtw_generate_random_ibss(pibss);
 162
 163                                 if (rtw_create_ibss_cmd(padapter, 0) != _SUCCESS) {
 164                                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("***Error=>do_goin: rtw_create_ibss_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 (!rtw_is_hw_init_completed(padapter)) {
 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 (!rtw_is_hw_init_completed(padapter)) {
 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                         case Ndis802_11Monitor:
 678                                 set_fwstate(pmlmepriv, WIFI_MONITOR_STATE);
 679                                 break;
 680                 }
 681
 682                 //SecClearAllKeys(adapter);
 683
 684                 //RT_TRACE(COMP_OID_SET, DBG_LOUD, ("set_infrastructure: fw_state:%x after changing mode\n",
 685                 //                                                                      get_fwstate(pmlmepriv) ));
 686
 687                 _exit_critical_bh(&pmlmepriv->lock, &irqL);
 688         }
 689
 690 _func_exit_;
 691
 692         return _TRUE;
 693 }
 694
 695
 696 u8 rtw_set_802_11_disassociate(_adapter *padapter)
 697 {
 698         _irqL irqL;
 699         struct mlme_priv * pmlmepriv = &padapter->mlmepriv;
 700
 701 _func_enter_;
 702
 703         _enter_critical_bh(&pmlmepriv->lock, &irqL);
 704
 705         if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)
 706         {
 707                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("MgntActrtw_set_802_11_disassociate: rtw_indicate_disconnect\n"));
 708
 709                 rtw_disassoc_cmd(padapter, 0, _TRUE);
 710                 rtw_indicate_disconnect(padapter);
 711                 //modify for CONFIG_IEEE80211W, none 11w can use it
 712                 rtw_free_assoc_resources_cmd(padapter);
 713                 if (_FAIL == rtw_pwr_wakeup(padapter))
 714                         DBG_871X("%s(): rtw_pwr_wakeup fail !!!\n",__FUNCTION__);
 715         }
 716
 717         _exit_critical_bh(&pmlmepriv->lock, &irqL);
 718
 719 _func_exit_;
 720
 721         return _TRUE;
 722 }
 723
 724 u8 rtw_set_802_11_bssid_list_scan(_adapter* padapter, NDIS_802_11_SSID *pssid, int ssid_max_num)
 725 {
 726         _irqL   irqL;
 727         struct  mlme_priv               *pmlmepriv= &padapter->mlmepriv;
 728         u8      res=_TRUE;
 729
 730 _func_enter_;
 731
 732         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("+rtw_set_802_11_bssid_list_scan(), fw_state=%x\n", get_fwstate(pmlmepriv)));
 733
 734         if (padapter == NULL) {
 735                 res=_FALSE;
 736                 goto exit;
 737         }
 738         if (!rtw_is_hw_init_completed(padapter)) {
 739                 res = _FALSE;
 740                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n===rtw_set_802_11_bssid_list_scan:hw_init_completed==_FALSE===\n"));
 741                 goto exit;
 742         }
 743
 744         if ((check_fwstate(pmlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING) == _TRUE) ||
 745                 (pmlmepriv->LinkDetectInfo.bBusyTraffic == _TRUE))
 746         {
 747                 // Scan or linking is in progress, do nothing.
 748                 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)));
 749                 res = _TRUE;
 750
 751                 if(check_fwstate(pmlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING))== _TRUE){
 752                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n###_FW_UNDER_SURVEY|_FW_UNDER_LINKING\n\n"));
 753                 } else {
 754                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n###pmlmepriv->sitesurveyctrl.traffic_busy==_TRUE\n\n"));
 755                 }
 756         } else {
 757                 if (rtw_is_scan_deny(padapter)) {
 758                         DBG_871X(FUNC_ADPT_FMT": scan deny\n", FUNC_ADPT_ARG(padapter));
 759                         indicate_wx_scan_complete_event(padapter);
 760                         return _SUCCESS;
 761                 }
 762
 763                 _enter_critical_bh(&pmlmepriv->lock, &irqL);
 764
 765                 res = rtw_sitesurvey_cmd(padapter, pssid, ssid_max_num, NULL, 0);
 766
 767                 _exit_critical_bh(&pmlmepriv->lock, &irqL);
 768         }
 769 exit:
 770
 771 _func_exit_;
 772
 773         return res;
 774 }
 775
 776 u8 rtw_set_802_11_authentication_mode(_adapter* padapter, NDIS_802_11_AUTHENTICATION_MODE authmode)
 777 {
 778         struct security_priv *psecuritypriv = &padapter->securitypriv;
 779         int res;
 780         u8 ret;
 781
 782 _func_enter_;
 783
 784         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("set_802_11_auth.mode(): mode=%x\n", authmode));
 785
 786         psecuritypriv->ndisauthtype=authmode;
 787
 788         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("rtw_set_802_11_authentication_mode:psecuritypriv->ndisauthtype=%d", psecuritypriv->ndisauthtype));
 789
 790         if(psecuritypriv->ndisauthtype>3)
 791                 psecuritypriv->dot11AuthAlgrthm=dot11AuthAlgrthm_8021X;
 792
 793 #ifdef CONFIG_WAPI_SUPPORT
 794         if(psecuritypriv->ndisauthtype == 6)
 795                 psecuritypriv->dot11AuthAlgrthm=dot11AuthAlgrthm_WAPI;
 796 #endif
 797
 798         res=rtw_set_auth(padapter,psecuritypriv);
 799
 800         if(res==_SUCCESS)
 801                 ret=_TRUE;
 802         else
 803                 ret=_FALSE;
 804
 805 _func_exit_;
 806
 807         return ret;
 808 }
 809
 810 u8 rtw_set_802_11_add_wep(_adapter* padapter, NDIS_802_11_WEP *wep){
 811
 812         u8              bdefaultkey;
 813         u8              btransmitkey;
 814         sint            keyid,res;
 815         struct security_priv* psecuritypriv=&(padapter->securitypriv);
 816         u8              ret=_SUCCESS;
 817
 818 _func_enter_;
 819
 820         bdefaultkey=(wep->KeyIndex & 0x40000000) > 0 ? _FALSE : _TRUE;   //for ???
 821         btransmitkey= (wep->KeyIndex & 0x80000000) > 0 ? _TRUE  : _FALSE;       //for ???
 822         keyid=wep->KeyIndex & 0x3fffffff;
 823
 824         if(keyid>=4)
 825         {
 826                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("MgntActrtw_set_802_11_add_wep:keyid>4=>fail\n"));
 827                 ret=_FALSE;
 828                 goto exit;
 829         }
 830
 831         switch(wep->KeyLength)
 832         {
 833                 case 5:
 834                         psecuritypriv->dot11PrivacyAlgrthm=_WEP40_;
 835                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("MgntActrtw_set_802_11_add_wep:wep->KeyLength=5\n"));
 836                         break;
 837                 case 13:
 838                         psecuritypriv->dot11PrivacyAlgrthm=_WEP104_;
 839                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("MgntActrtw_set_802_11_add_wep:wep->KeyLength=13\n"));
 840                         break;
 841                 default:
 842                         psecuritypriv->dot11PrivacyAlgrthm=_NO_PRIVACY_;
 843                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("MgntActrtw_set_802_11_add_wep:wep->KeyLength!=5 or 13\n"));
 844                         break;
 845         }
 846
 847         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));
 848
 849         _rtw_memcpy(&(psecuritypriv->dot11DefKey[keyid].skey[0]),&(wep->KeyMaterial),wep->KeyLength);
 850
 851         psecuritypriv->dot11DefKeylen[keyid]=wep->KeyLength;
 852
 853         psecuritypriv->dot11PrivacyKeyIndex=keyid;
 854
 855         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",
 856                 psecuritypriv->dot11DefKey[keyid].skey[0],psecuritypriv->dot11DefKey[keyid].skey[1],psecuritypriv->dot11DefKey[keyid].skey[2],
 857                 psecuritypriv->dot11DefKey[keyid].skey[3],psecuritypriv->dot11DefKey[keyid].skey[4],psecuritypriv->dot11DefKey[keyid].skey[5],
 858                 psecuritypriv->dot11DefKey[keyid].skey[6],psecuritypriv->dot11DefKey[keyid].skey[7],psecuritypriv->dot11DefKey[keyid].skey[8],
 859                 psecuritypriv->dot11DefKey[keyid].skey[9],psecuritypriv->dot11DefKey[keyid].skey[10],psecuritypriv->dot11DefKey[keyid].skey[11],
 860                 psecuritypriv->dot11DefKey[keyid].skey[12]));
 861
 862         res=rtw_set_key(padapter,psecuritypriv, keyid, 1, _TRUE);
 863
 864         if(res==_FAIL)
 865                 ret= _FALSE;
 866 exit:
 867
 868 _func_exit_;
 869
 870         return ret;
 871
 872 }
 873
 874 u8 rtw_set_802_11_remove_wep(_adapter* padapter, u32 keyindex){
 875
 876         u8 ret=_SUCCESS;
 877
 878 _func_enter_;
 879
 880         if (keyindex >= 0x80000000 || padapter == NULL){
 881
 882                 ret=_FALSE;
 883                 goto exit;
 884
 885         }
 886         else
 887         {
 888                 int res;
 889                 struct security_priv* psecuritypriv=&(padapter->securitypriv);
 890                 if( keyindex < 4 ){
 891
 892                         _rtw_memset(&psecuritypriv->dot11DefKey[keyindex], 0, 16);
 893
 894                         res=rtw_set_key(padapter,psecuritypriv,keyindex, 0, _TRUE);
 895
 896                         psecuritypriv->dot11DefKeylen[keyindex]=0;
 897
 898                         if(res==_FAIL)
 899                                 ret=_FAIL;
 900
 901                 }
 902                 else
 903                 {
 904                         ret=_FAIL;
 905                 }
 906
 907         }
 908
 909 exit:
 910
 911 _func_exit_;
 912
 913         return ret;
 914
 915 }
 916
 917 u8 rtw_set_802_11_add_key(_adapter* padapter, NDIS_802_11_KEY *key){
 918
 919         uint    encryptionalgo;
 920         u8 * pbssid;
 921         struct sta_info *stainfo;
 922         u8      bgroup = _FALSE;
 923         u8      bgrouptkey = _FALSE;//can be remove later
 924         u8      ret=_SUCCESS;
 925
 926 _func_enter_;
 927
 928         if (((key->KeyIndex & 0x80000000) == 0) && ((key->KeyIndex & 0x40000000) > 0)){
 929
 930                 // It is invalid to clear bit 31 and set bit 30. If the miniport driver encounters this combination,
 931                 // it must fail the request and return NDIS_STATUS_INVALID_DATA.
 932                 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));
 933                 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));
 934                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_info_,("rtw_set_802_11_add_key: key->KeyIndex=%d \n" ,(int)key->KeyIndex));
 935                 ret= _FAIL;
 936                 goto exit;
 937         }
 938
 939         if(key->KeyIndex & 0x40000000)
 940         {
 941                 // Pairwise key
 942
 943                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("OID_802_11_ADD_KEY: +++++ Pairwise key +++++\n"));
 944
 945                 pbssid=get_bssid(&padapter->mlmepriv);
 946                 stainfo=rtw_get_stainfo(&padapter->stapriv, pbssid);
 947
 948                 if((stainfo!=NULL)&&(padapter->securitypriv.dot11AuthAlgrthm==dot11AuthAlgrthm_8021X)){
 949                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("OID_802_11_ADD_KEY:( stainfo!=NULL)&&(Adapter->securitypriv.dot11AuthAlgrthm==dot11AuthAlgrthm_8021X)\n"));
 950                         encryptionalgo=stainfo->dot118021XPrivacy;
 951                 }
 952                 else{
 953                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("OID_802_11_ADD_KEY: stainfo==NULL)||(Adapter->securitypriv.dot11AuthAlgrthm!=dot11AuthAlgrthm_8021X)\n"));
 954                         encryptionalgo=padapter->securitypriv.dot11PrivacyAlgrthm;
 955                 }
 956
 957                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("rtw_set_802_11_add_key: (encryptionalgo ==%d)!\n",encryptionalgo ));
 958                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("rtw_set_802_11_add_key: (Adapter->securitypriv.dot11PrivacyAlgrthm ==%d)!\n",padapter->securitypriv.dot11PrivacyAlgrthm));
 959                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("rtw_set_802_11_add_key: (Adapter->securitypriv.dot11AuthAlgrthm ==%d)!\n",padapter->securitypriv.dot11AuthAlgrthm));
 960
 961                 if((stainfo!=NULL)){
 962                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("rtw_set_802_11_add_key: (stainfo->dot118021XPrivacy ==%d)!\n", stainfo->dot118021XPrivacy));
 963                 }
 964
 965                 if(key->KeyIndex & 0x000000FF){
 966                         // The key index is specified in the lower 8 bits by values of zero to 255.
 967                         // The key index should be set to zero for a Pairwise key, and the driver should fail with
 968                         // NDIS_STATUS_INVALID_DATA if the lower 8 bits is not zero
 969                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,(" key->KeyIndex & 0x000000FF.\n"));
 970                         ret= _FAIL;
 971                         goto exit;
 972                 }
 973
 974                 // check BSSID
 975                 if (IS_MAC_ADDRESS_BROADCAST(key->BSSID) == _TRUE){
 976
 977                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("MacAddr_isBcst(key->BSSID)\n"));
 978                         ret= _FALSE;
 979                         goto exit;
 980                 }
 981
 982                 // Check key length for TKIP.
 983                 //if(encryptionAlgorithm == RT_ENC_TKIP_ENCRYPTION && key->KeyLength != 32)
 984                 if((encryptionalgo== _TKIP_)&& (key->KeyLength != 32)){
 985                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("TKIP KeyLength:0x%x != 32\n", key->KeyLength));
 986                         ret=_FAIL;
 987                         goto exit;
 988
 989                 }
 990
 991                 // Check key length for AES.
 992                 if((encryptionalgo== _AES_)&& (key->KeyLength != 16)) {
 993                         // For our supplicant, EAPPkt9x.vxd, cannot differentiate TKIP and AES case.
 994                         if(key->KeyLength == 32) {
 995                                 key->KeyLength = 16;
 996                         } else {
 997                                 ret= _FAIL;
 998                                 goto exit;
 999                         }
1000                 }
1001
1002                 /* Check key length for WEP. For NDTEST, 2005.01.27, by rcnjko. -> modify checking condition*/
1003                 if (((encryptionalgo == _WEP40_) && (key->KeyLength != 5)) || ((encryptionalgo == _WEP104_) && (key->KeyLength != 13))) {
1004                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("WEP KeyLength:0x%x != 5 or 13\n", key->KeyLength));
1005                         ret=_FAIL;
1006                         goto exit;
1007                 }
1008
1009                 bgroup = _FALSE;
1010
1011                 // Check the pairwise key. Added by Annie, 2005-07-06.
1012                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("------------------------------------------\n"));
1013                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("[Pairwise Key set]\n"));
1014                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("------------------------------------------\n"));
1015                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("key index: 0x%8x(0x%8x)\n", key->KeyIndex,(key->KeyIndex&0x3)));
1016                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("key Length: %d\n", key->KeyLength));
1017                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("------------------------------------------\n"));
1018
1019         }
1020         else
1021         {
1022                 // Group key - KeyIndex(BIT30==0)
1023                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("OID_802_11_ADD_KEY: +++++ Group key +++++\n"));
1024
1025
1026                 // when add wep key through add key and didn't assigned encryption type before
1027                 if((padapter->securitypriv.ndisauthtype<=3)&&(padapter->securitypriv.dot118021XGrpPrivacy==0))
1028                 {
1029                         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));
1030
1031                         switch(key->KeyLength)
1032                         {
1033                                 case 5:
1034                                         padapter->securitypriv.dot11PrivacyAlgrthm=_WEP40_;
1035                                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("Adapter->securitypriv.dot11PrivacyAlgrthm= %x key->KeyLength=%u\n", padapter->securitypriv.dot11PrivacyAlgrthm,key->KeyLength));
1036                                         break;
1037                                 case 13:
1038                                         padapter->securitypriv.dot11PrivacyAlgrthm=_WEP104_;
1039                                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("Adapter->securitypriv.dot11PrivacyAlgrthm= %x key->KeyLength=%u\n", padapter->securitypriv.dot11PrivacyAlgrthm,key->KeyLength));
1040                                         break;
1041                                 default:
1042                                         padapter->securitypriv.dot11PrivacyAlgrthm=_NO_PRIVACY_;
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                         }
1046
1047                         encryptionalgo=padapter->securitypriv.dot11PrivacyAlgrthm;
1048
1049                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,(" Adapter->securitypriv.dot11PrivacyAlgrthm=%x\n", padapter->securitypriv.dot11PrivacyAlgrthm));
1050
1051                 }
1052                 else
1053                 {
1054                         encryptionalgo=padapter->securitypriv.dot118021XGrpPrivacy;
1055                         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));
1056
1057                 }
1058
1059                 if((check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE)==_TRUE) && (IS_MAC_ADDRESS_BROADCAST(key->BSSID) == _FALSE)) {
1060                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,(" IBSS but BSSID is not Broadcast Address.\n"));
1061                         ret= _FAIL;
1062                         goto exit;
1063                 }
1064
1065                 // Check key length for TKIP
1066                 if((encryptionalgo== _TKIP_) && (key->KeyLength != 32)) {
1067
1068                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,(" TKIP GTK KeyLength:%u != 32\n", key->KeyLength));
1069                         ret= _FAIL;
1070                         goto exit;
1071
1072                 } else if(encryptionalgo== _AES_ && (key->KeyLength != 16 && key->KeyLength != 32) ) {
1073
1074                         // Check key length for AES
1075                         // For NDTEST, we allow keylen=32 in this case. 2005.01.27, by rcnjko.
1076                         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));
1077                         ret= _FAIL;
1078                         goto exit;
1079                 }
1080
1081                 // Change the key length for EAPPkt9x.vxd. Added by Annie, 2005-11-03.
1082                 if((encryptionalgo==  _AES_) && (key->KeyLength == 32) ) {
1083                         key->KeyLength = 16;
1084                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("AES key length changed: %u\n", key->KeyLength) );
1085                 }
1086
1087                 if(key->KeyIndex & 0x8000000) {//error ??? 0x8000_0000
1088                         bgrouptkey = _TRUE;
1089                 }
1090
1091                 if((check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE)==_TRUE)&&(check_fwstate(&padapter->mlmepriv, _FW_LINKED)==_TRUE))
1092                 {
1093                         bgrouptkey = _TRUE;
1094                 }
1095
1096                 bgroup = _TRUE;
1097
1098                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("------------------------------------------\n") );
1099                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("[Group Key set]\n") );
1100                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("------------------------------------------\n")) ;
1101                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("key index: 0x%8x(0x%8x)\n", key->KeyIndex,(key->KeyIndex&0x3)));
1102                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("key Length: %d\n", key->KeyLength)) ;
1103                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("------------------------------------------\n"));
1104
1105         }
1106
1107         // If WEP encryption algorithm, just call rtw_set_802_11_add_wep().
1108         if((padapter->securitypriv.dot11AuthAlgrthm !=dot11AuthAlgrthm_8021X)&&(encryptionalgo== _WEP40_  || encryptionalgo== _WEP104_))
1109         {
1110                 u8 ret;
1111                 u32 keyindex;
1112                 u32 len = FIELD_OFFSET(NDIS_802_11_KEY, KeyMaterial) + key->KeyLength;
1113                 NDIS_802_11_WEP *wep = &padapter->securitypriv.ndiswep;
1114
1115                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("OID_802_11_ADD_KEY: +++++ WEP key +++++\n"));
1116
1117                 wep->Length = len;
1118                 keyindex = key->KeyIndex&0x7fffffff;
1119                 wep->KeyIndex = keyindex ;
1120                 wep->KeyLength = key->KeyLength;
1121
1122                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("OID_802_11_ADD_KEY:Before memcpy \n"));
1123
1124                 _rtw_memcpy(wep->KeyMaterial, key->KeyMaterial, key->KeyLength);
1125                 _rtw_memcpy(&(padapter->securitypriv.dot11DefKey[keyindex].skey[0]), key->KeyMaterial, key->KeyLength);
1126
1127                 padapter->securitypriv.dot11DefKeylen[keyindex]=key->KeyLength;
1128                 padapter->securitypriv.dot11PrivacyKeyIndex=keyindex;
1129
1130                 ret = rtw_set_802_11_add_wep(padapter, wep);
1131
1132                 goto exit;
1133
1134         }
1135
1136         if(key->KeyIndex & 0x20000000){
1137                 // SetRSC
1138                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("OID_802_11_ADD_KEY: +++++ SetRSC+++++\n"));
1139                 if(bgroup == _TRUE)
1140                 {
1141                         NDIS_802_11_KEY_RSC keysrc=key->KeyRSC & 0x00FFFFFFFFFFFFULL;
1142                         _rtw_memcpy(&padapter->securitypriv.dot11Grprxpn, &keysrc, 8);
1143                 }
1144                 else
1145                 {
1146                         NDIS_802_11_KEY_RSC keysrc=key->KeyRSC & 0x00FFFFFFFFFFFFULL;
1147                         _rtw_memcpy(&padapter->securitypriv.dot11Grptxpn, &keysrc, 8);
1148                 }
1149
1150         }
1151
1152         // Indicate this key idx is used for TX
1153         // Save the key in KeyMaterial
1154         if(bgroup == _TRUE) // Group transmit key
1155         {
1156                 int res;
1157
1158                 if(bgrouptkey == _TRUE)
1159                 {
1160                         padapter->securitypriv.dot118021XGrpKeyid=(u8)key->KeyIndex;
1161                 }
1162
1163                 if((key->KeyIndex&0x3) == 0){
1164                         ret = _FAIL;
1165                         goto exit;
1166                 }
1167
1168                 _rtw_memset(&padapter->securitypriv.dot118021XGrpKey[(u8)((key->KeyIndex) & 0x03)], 0, 16);
1169                 _rtw_memset(&padapter->securitypriv.dot118021XGrptxmickey[(u8)((key->KeyIndex) & 0x03)], 0, 16);
1170                 _rtw_memset(&padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)], 0, 16);
1171
1172                 if((key->KeyIndex & 0x10000000))
1173                 {
1174                         _rtw_memcpy(&padapter->securitypriv.dot118021XGrptxmickey[(u8)((key->KeyIndex) & 0x03)], key->KeyMaterial + 16, 8);
1175                         _rtw_memcpy(&padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)], key->KeyMaterial + 24, 8);
1176
1177                         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",
1178                                 padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[0],padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[1],
1179                                 padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[2],padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[3],
1180                                 padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[4],padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[5],
1181                                 padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[6],padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[7]));
1182                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n rtw_set_802_11_add_key:set Group mic key!!!!!!!!\n"));
1183
1184                 }
1185                 else
1186                 {
1187                         _rtw_memcpy(&padapter->securitypriv.dot118021XGrptxmickey[(u8)((key->KeyIndex) & 0x03)], key->KeyMaterial + 24, 8);
1188                         _rtw_memcpy(&padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)], key->KeyMaterial + 16, 8);
1189
1190                         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",
1191                                 padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[0],padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[1],
1192                                 padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[2],padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[3],
1193                                 padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[4],padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[5],
1194                                 padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[6],padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[7]));
1195                         RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n rtw_set_802_11_add_key:set Group mic key!!!!!!!!\n"));
1196
1197                 }
1198
1199                 //set group key by index
1200                 _rtw_memcpy(&padapter->securitypriv.dot118021XGrpKey[(u8)((key->KeyIndex) & 0x03)], key->KeyMaterial, key->KeyLength);
1201
1202                 key->KeyIndex=key->KeyIndex & 0x03;
1203
1204                 padapter->securitypriv.binstallGrpkey=_TRUE;
1205
1206                 padapter->securitypriv.bcheck_grpkey=_FALSE;
1207
1208                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("reset group key"));
1209
1210                 res=rtw_set_key(padapter,&padapter->securitypriv, key->KeyIndex, 1, _TRUE);
1211
1212                 if(res==_FAIL)
1213                         ret= _FAIL;
1214
1215                 goto exit;
1216
1217         }
1218         else // Pairwise Key
1219         {
1220                 u8 res;
1221
1222                 pbssid=get_bssid(&padapter->mlmepriv);
1223                 stainfo=rtw_get_stainfo(&padapter->stapriv , pbssid );
1224
1225                 if(stainfo!=NULL)
1226                 {
1227                         _rtw_memset( &stainfo->dot118021x_UncstKey, 0, 16);// clear keybuffer
1228
1229                         _rtw_memcpy(&stainfo->dot118021x_UncstKey, key->KeyMaterial, 16);
1230
1231                         if(encryptionalgo== _TKIP_)
1232                         {
1233                                 padapter->securitypriv.busetkipkey=_FALSE;
1234
1235                                 //_set_timer(&padapter->securitypriv.tkip_timer, 50);
1236
1237                                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n ==========_set_timer\n"));
1238
1239                                 // if TKIP, save the Receive/Transmit MIC key in KeyMaterial[128-255]
1240                                 if((key->KeyIndex & 0x10000000)){
1241                                         _rtw_memcpy(&stainfo->dot11tkiptxmickey, key->KeyMaterial + 16, 8);
1242                                         _rtw_memcpy(&stainfo->dot11tkiprxmickey, key->KeyMaterial + 24, 8);
1243
1244                                 } else {
1245                                         _rtw_memcpy(&stainfo->dot11tkiptxmickey, key->KeyMaterial + 24, 8);
1246                                         _rtw_memcpy(&stainfo->dot11tkiprxmickey, key->KeyMaterial + 16, 8);
1247
1248                                 }
1249
1250                         }
1251                         else if(encryptionalgo == _AES_)
1252                         {
1253
1254                         }
1255
1256
1257                         //Set key to CAM through H2C command
1258                         #if 0
1259                         if(bgrouptkey)//never go to here
1260                         {
1261                                 res=rtw_setstakey_cmd(padapter, stainfo, GROUP_KEY, _TRUE);
1262                                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n rtw_set_802_11_add_key:rtw_setstakey_cmd(group)\n"));
1263                         }
1264                         else{
1265                                 res=rtw_setstakey_cmd(padapter, stainfo, UNICAST_KEY, _TRUE);
1266                                 RT_TRACE(_module_rtl871x_ioctl_set_c_,_drv_err_,("\n rtw_set_802_11_add_key:rtw_setstakey_cmd(unicast)\n"));
1267                         }
1268                         #else
1269
1270                         res = rtw_setstakey_cmd(padapter, stainfo, UNICAST_KEY, _TRUE);
1271                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("\n rtw_set_802_11_add_key:rtw_setstakey_cmd(unicast)\n"));
1272                         #endif
1273
1274                         if(res ==_FALSE)
1275                                 ret= _FAIL;
1276
1277                 }
1278
1279         }
1280
1281 exit:
1282
1283 _func_exit_;
1284
1285         return ret;
1286 }
1287
1288 u8 rtw_set_802_11_remove_key(_adapter*  padapter, NDIS_802_11_REMOVE_KEY *key){
1289
1290         uint                            encryptionalgo;
1291         u8 * pbssid;
1292         struct sta_info *stainfo;
1293         u8      bgroup = (key->KeyIndex & 0x4000000) > 0 ? _FALSE: _TRUE;
1294         u8      keyIndex = (u8)key->KeyIndex & 0x03;
1295         u8      ret=_SUCCESS;
1296
1297 _func_enter_;
1298
1299         if ((key->KeyIndex & 0xbffffffc) > 0) {
1300                 ret=_FAIL;
1301                 goto exit;
1302         }
1303
1304         if (bgroup == _TRUE) {
1305                 encryptionalgo= padapter->securitypriv.dot118021XGrpPrivacy;
1306                 // clear group key by index
1307                 //NdisZeroMemory(Adapter->MgntInfo.SecurityInfo.KeyBuf[keyIndex], MAX_WEP_KEY_LEN);
1308                 //Adapter->MgntInfo.SecurityInfo.KeyLen[keyIndex] = 0;
1309
1310                 _rtw_memset(&padapter->securitypriv.dot118021XGrpKey[keyIndex], 0, 16);
1311
1312                 //! \todo Send a H2C Command to Firmware for removing this Key in CAM Entry.
1313
1314         } else {
1315
1316                 pbssid=get_bssid(&padapter->mlmepriv);
1317                 stainfo=rtw_get_stainfo(&padapter->stapriv , pbssid );
1318                 if(stainfo !=NULL){
1319                         encryptionalgo=stainfo->dot118021XPrivacy;
1320
1321                 // clear key by BSSID
1322                 _rtw_memset(&stainfo->dot118021x_UncstKey, 0, 16);
1323
1324                 //! \todo Send a H2C Command to Firmware for disable this Key in CAM Entry.
1325
1326                 }
1327                 else{
1328                         ret= _FAIL;
1329                         goto exit;
1330                 }
1331         }
1332
1333 exit:
1334
1335 _func_exit_;
1336
1337         return _TRUE;
1338
1339 }
1340
1341 /*
1342 * rtw_get_cur_max_rate -
1343 * @adapter: pointer to _adapter structure
1344 *
1345 * Return 0 or 100Kbps
1346 */
1347 u16 rtw_get_cur_max_rate(_adapter *adapter)
1348 {
1349         int     i = 0;
1350         u16     rate = 0, max_rate = 0;
1351         struct mlme_priv        *pmlmepriv = &adapter->mlmepriv;
1352         WLAN_BSSID_EX   *pcur_bss = &pmlmepriv->cur_network.network;
1353         struct sta_info *psta = NULL;
1354         u8      short_GI=0;
1355 #ifdef CONFIG_80211N_HT
1356         u8      rf_type = 0;
1357 #endif
1358
1359 #ifdef CONFIG_MP_INCLUDED
1360         if (adapter->registrypriv.mp_mode == 1)
1361         {
1362                 if (check_fwstate(pmlmepriv, WIFI_MP_STATE) == _TRUE)
1363                         return 0;
1364         }
1365 #endif
1366
1367         if((check_fwstate(pmlmepriv, _FW_LINKED) != _TRUE)
1368                 && (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) != _TRUE))
1369                 return 0;
1370
1371         psta = rtw_get_stainfo(&adapter->stapriv, get_bssid(pmlmepriv));
1372         if (psta == NULL)
1373                 return 0;
1374
1375         short_GI = query_ra_short_GI(psta);
1376
1377 #ifdef CONFIG_80211N_HT
1378         if (IsSupportedHT(psta->wireless_mode)) {
1379                 rtw_hal_get_hwreg(adapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
1380
1381                 max_rate = rtw_mcs_rate(
1382                         rf_type,
1383                         ((psta->bw_mode == CHANNEL_WIDTH_40)?1:0),
1384                         short_GI,
1385                         psta->htpriv.ht_cap.supp_mcs_set
1386                 );
1387         }
1388 #ifdef CONFIG_80211AC_VHT
1389         else if (IsSupportedVHT(psta->wireless_mode)) {
1390                 max_rate = ((rtw_vht_mcs_to_data_rate(psta->bw_mode, short_GI, pmlmepriv->vhtpriv.vht_highest_rate) + 1) >> 1) * 10;
1391         }
1392 #endif //CONFIG_80211AC_VHT
1393         else
1394 #endif //CONFIG_80211N_HT
1395         {
1396                 while( (pcur_bss->SupportedRates[i]!=0) && (pcur_bss->SupportedRates[i]!=0xFF))
1397                 {
1398                         rate = pcur_bss->SupportedRates[i]&0x7F;
1399                         if(rate>max_rate)
1400                                 max_rate = rate;
1401                         i++;
1402                 }
1403
1404                 max_rate = max_rate*10/2;
1405         }
1406
1407         return max_rate;
1408 }
1409
1410 /*
1411 * rtw_set_scan_mode -
1412 * @adapter: pointer to _adapter structure
1413 * @scan_mode:
1414 *
1415 * Return _SUCCESS or _FAIL
1416 */
1417 int rtw_set_scan_mode(_adapter *adapter, RT_SCAN_TYPE scan_mode)
1418 {
1419         if(scan_mode != SCAN_ACTIVE && scan_mode != SCAN_PASSIVE)
1420                 return _FAIL;
1421
1422         adapter->mlmepriv.scan_mode = scan_mode;
1423
1424         return _SUCCESS;
1425 }
1426
1427 /*
1428 * rtw_set_channel_plan -
1429 * @adapter: pointer to _adapter structure
1430 * @channel_plan:
1431 *
1432 * Return _SUCCESS or _FAIL
1433 */
1434 int rtw_set_channel_plan(_adapter *adapter, u8 channel_plan)
1435 {
1436         struct registry_priv *pregistrypriv = &adapter->registrypriv;
1437         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1438
1439         //handle by cmd_thread to sync with scan operation
1440         return rtw_set_chplan_cmd(adapter, RTW_CMDF_WAIT_ACK, channel_plan, 1);
1441 }
1442
1443 /*
1444 * rtw_set_country -
1445 * @adapter: pointer to _adapter structure
1446 * @country_code: string of country code
1447 *
1448 * Return _SUCCESS or _FAIL
1449 */
1450 int rtw_set_country(_adapter *adapter, const char *country_code)
1451 {
1452 #ifdef CONFIG_RTW_IOCTL_SET_COUNTRY
1453         return rtw_set_country_cmd(adapter, RTW_CMDF_WAIT_ACK, country_code, 1);
1454 #else
1455         return _FAIL;
1456 #endif
1457 }
1458
1459 /*
1460 * rtw_set_band -
1461 * @adapter: pointer to _adapter structure
1462 * @band: band to set
1463 *
1464 * Return _SUCCESS or _FAIL
1465 */
1466 int rtw_set_band(_adapter *adapter, u8 band)
1467 {
1468         if (rtw_band_valid(band)) {
1469                 DBG_871X(FUNC_ADPT_FMT" band:%d\n", FUNC_ADPT_ARG(adapter), band);
1470                 adapter->setband = band;
1471                 return _SUCCESS;
1472         }
1473
1474         DBG_871X_LEVEL(_drv_always_, FUNC_ADPT_FMT" band:%d fail\n", FUNC_ADPT_ARG(adapter), band);
1475         return _FAIL;
1476 }
1477