drivers/staging/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
  23 #include <osdep_service.h>
  24 #include <drv_types.h>
  25 #include <rtw_ioctl_set.h>
  26 #include <hal_intf.h>
  27
  28 #include <usb_osintf.h>
  29 #include <usb_ops.h>
  30
  31 extern void indicate_wx_scan_complete_event(struct adapter *padapter);
  32
  33 #define IS_MAC_ADDRESS_BROADCAST(addr) \
  34 (\
  35         ((addr[0] == 0xff) && (addr[1] == 0xff) && \
  36                 (addr[2] == 0xff) && (addr[3] == 0xff) && \
  37                 (addr[4] == 0xff) && (addr[5] == 0xff))  ? true : false \
  38 )
  39
  40 u8 rtw_validate_ssid(struct ndis_802_11_ssid *ssid)
  41 {
  42         u8       i;
  43         u8      ret = true;
  44
  45
  46         if (ssid->SsidLength > 32) {
  47                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("ssid length >32\n"));
  48                 ret = false;
  49                 goto exit;
  50         }
  51
  52         for (i = 0; i < ssid->SsidLength; i++) {
  53                 /* wifi, printable ascii code must be supported */
  54                 if (!((ssid->Ssid[i] >= 0x20) && (ssid->Ssid[i] <= 0x7e))) {
  55                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("ssid has nonprintabl ascii\n"));
  56                         ret = false;
  57                         break;
  58                 }
  59         }
  60
  61 exit:
  62
  63         return ret;
  64 }
  65
  66 u8 rtw_do_join(struct adapter *padapter)
  67 {
  68         struct list_head *plist, *phead;
  69         u8 *pibss = NULL;
  70         struct  mlme_priv       *pmlmepriv = &(padapter->mlmepriv);
  71         struct __queue *queue   = &(pmlmepriv->scanned_queue);
  72         u8 ret = _SUCCESS;
  73
  74
  75         spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
  76         phead = get_list_head(queue);
  77         plist = phead->next;
  78
  79         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("\n rtw_do_join: phead = %p; plist = %p\n\n\n", phead, plist));
  80
  81         pmlmepriv->cur_network.join_res = -2;
  82
  83         set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
  84
  85         pmlmepriv->pscanned = plist;
  86
  87         pmlmepriv->to_join = true;
  88
  89         if (_rtw_queue_empty(queue)) {
  90                 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
  91                 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
  92
  93                 /* when set_ssid/set_bssid for rtw_do_join(), but scanning queue is empty */
  94                 /* we try to issue sitesurvey firstly */
  95
  96                 if (!pmlmepriv->LinkDetectInfo.bBusyTraffic ||
  97                     pmlmepriv->to_roaming > 0) {
  98                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("rtw_do_join(): site survey if scanned_queue is empty\n."));
  99                         /*  submit site_survey_cmd */
 100                         ret = rtw_sitesurvey_cmd(padapter, &pmlmepriv->assoc_ssid, 1, NULL, 0);
 101                         if (_SUCCESS != ret) {
 102                                 pmlmepriv->to_join = false;
 103                                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("rtw_do_join(): site survey return error\n."));
 104                         }
 105                 } else {
 106                         pmlmepriv->to_join = false;
 107                         ret = _FAIL;
 108                 }
 109
 110                 goto exit;
 111         } else {
 112                 int select_ret;
 113
 114                 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
 115                 select_ret = rtw_select_and_join_from_scanned_queue(pmlmepriv);
 116                 if (select_ret == _SUCCESS) {
 117                         pmlmepriv->to_join = false;
 118                         _set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT);
 119                 } else {
 120                         if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) {
 121                                 /*  submit createbss_cmd to change to a ADHOC_MASTER */
 122
 123                                 /* pmlmepriv->lock has been acquired by caller... */
 124                                 struct wlan_bssid_ex    *pdev_network = &(padapter->registrypriv.dev_network);
 125
 126                                 pmlmepriv->fw_state = WIFI_ADHOC_MASTER_STATE;
 127
 128                                 pibss = padapter->registrypriv.dev_network.MacAddress;
 129
 130                                 _rtw_memset(&pdev_network->Ssid, 0, sizeof(struct ndis_802_11_ssid));
 131                                 memcpy(&pdev_network->Ssid, &pmlmepriv->assoc_ssid, sizeof(struct ndis_802_11_ssid));
 132
 133                                 rtw_update_registrypriv_dev_network(padapter);
 134
 135                                 rtw_generate_random_ibss(pibss);
 136
 137                                 if (rtw_createbss_cmd(padapter) != _SUCCESS) {
 138                                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("***Error =>do_goin: rtw_createbss_cmd status FAIL***\n "));
 139                                         ret =  false;
 140                                         goto exit;
 141                                 }
 142                                 pmlmepriv->to_join = false;
 143
 144                                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
 145                                          ("***Error => rtw_select_and_join_from_scanned_queue FAIL under STA_Mode***\n "));
 146                         } else {
 147                                 /*  can't associate ; reset under-linking */
 148                                 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
 149
 150                                 /* when set_ssid/set_bssid for rtw_do_join(), but there are no desired bss in scanning queue */
 151                                 /* we try to issue sitesurvey firstly */
 152                                 if (!pmlmepriv->LinkDetectInfo.bBusyTraffic ||
 153                                     pmlmepriv->to_roaming > 0) {
 154                                         ret = rtw_sitesurvey_cmd(padapter, &pmlmepriv->assoc_ssid, 1, NULL, 0);
 155                                         if (_SUCCESS != ret) {
 156                                                 pmlmepriv->to_join = false;
 157                                                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("do_join(): site survey return error\n."));
 158                                         }
 159                                 } else {
 160                                         ret = _FAIL;
 161                                         pmlmepriv->to_join = false;
 162                                 }
 163                         }
 164                 }
 165         }
 166
 167 exit:
 168
 169
 170         return ret;
 171 }
 172
 173 u8 rtw_set_802_11_bssid(struct adapter *padapter, u8 *bssid)
 174 {
 175         u8 status = _SUCCESS;
 176         u32 cur_time = 0;
 177         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 178
 179
 180         DBG_88E_LEVEL(_drv_info_, "set bssid:%pM\n", bssid);
 181
 182         if ((bssid[0] == 0x00 && bssid[1] == 0x00 && bssid[2] == 0x00 &&
 183              bssid[3] == 0x00 && bssid[4] == 0x00 && bssid[5] == 0x00) ||
 184             (bssid[0] == 0xFF && bssid[1] == 0xFF && bssid[2] == 0xFF &&
 185              bssid[3] == 0xFF && bssid[4] == 0xFF && bssid[5] == 0xFF)) {
 186                 status = _FAIL;
 187                 goto exit;
 188         }
 189
 190         spin_lock_bh(&pmlmepriv->lock);
 191
 192
 193         DBG_88E("Set BSSID under fw_state = 0x%08x\n", get_fwstate(pmlmepriv));
 194         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true)
 195                 goto handle_tkip_countermeasure;
 196         else if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING))
 197                 goto release_mlme_lock;
 198
 199         if (check_fwstate(pmlmepriv, _FW_LINKED|WIFI_ADHOC_MASTER_STATE)) {
 200                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("set_bssid: _FW_LINKED||WIFI_ADHOC_MASTER_STATE\n"));
 201
 202                 if (!memcmp(&pmlmepriv->cur_network.network.MacAddress, bssid, ETH_ALEN)) {
 203                         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == false)
 204                                 goto release_mlme_lock;/* it means driver is in WIFI_ADHOC_MASTER_STATE, we needn't create bss again. */
 205                 } else {
 206                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("Set BSSID not the same bssid\n"));
 207                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("set_bssid =%pM\n", (bssid)));
 208                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("cur_bssid =%pM\n", (pmlmepriv->cur_network.network.MacAddress)));
 209
 210                         rtw_disassoc_cmd(padapter, 0, true);
 211
 212                         if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
 213                                 rtw_indicate_disconnect(padapter);
 214
 215                         rtw_free_assoc_resources(padapter, 1);
 216
 217                         if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true)) {
 218                                 _clr_fwstate_(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
 219                                 set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
 220                         }
 221                 }
 222         }
 223
 224 handle_tkip_countermeasure:
 225         /* should we add something here...? */
 226
 227         if (padapter->securitypriv.btkip_countermeasure) {
 228                 cur_time = jiffies;
 229
 230                 if ((cur_time - padapter->securitypriv.btkip_countermeasure_time) > 60 * HZ) {
 231                         padapter->securitypriv.btkip_countermeasure = false;
 232                         padapter->securitypriv.btkip_countermeasure_time = 0;
 233                 } else {
 234                         status = _FAIL;
 235                         goto release_mlme_lock;
 236                 }
 237         }
 238
 239         memcpy(&pmlmepriv->assoc_bssid, bssid, ETH_ALEN);
 240         pmlmepriv->assoc_by_bssid = true;
 241
 242         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
 243                 pmlmepriv->to_join = true;
 244         else
 245                 status = rtw_do_join(padapter);
 246
 247 release_mlme_lock:
 248         spin_unlock_bh(&pmlmepriv->lock);
 249
 250 exit:
 251         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 252                  ("rtw_set_802_11_bssid: status=%d\n", status));
 253
 254
 255         return status;
 256 }
 257
 258 u8 rtw_set_802_11_ssid(struct adapter *padapter, struct ndis_802_11_ssid *ssid)
 259 {
 260         u8 status = _SUCCESS;
 261         u32 cur_time = 0;
 262
 263         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 264         struct wlan_network *pnetwork = &pmlmepriv->cur_network;
 265
 266
 267         DBG_88E_LEVEL(_drv_info_, "set ssid [%s] fw_state=0x%08x\n",
 268                       ssid->Ssid, get_fwstate(pmlmepriv));
 269
 270         if (!padapter->hw_init_completed) {
 271                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 272                          ("set_ssid: hw_init_completed == false =>exit!!!\n"));
 273                 status = _FAIL;
 274                 goto exit;
 275         }
 276
 277         spin_lock_bh(&pmlmepriv->lock);
 278
 279         DBG_88E("Set SSID under fw_state = 0x%08x\n", get_fwstate(pmlmepriv));
 280         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true)
 281                 goto handle_tkip_countermeasure;
 282         else if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true)
 283                 goto release_mlme_lock;
 284
 285         if (check_fwstate(pmlmepriv, _FW_LINKED|WIFI_ADHOC_MASTER_STATE)) {
 286                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
 287                          ("set_ssid: _FW_LINKED||WIFI_ADHOC_MASTER_STATE\n"));
 288
 289                 if ((pmlmepriv->assoc_ssid.SsidLength == ssid->SsidLength) &&
 290                     (!memcmp(&pmlmepriv->assoc_ssid.Ssid, ssid->Ssid, ssid->SsidLength))) {
 291                         if ((check_fwstate(pmlmepriv, WIFI_STATION_STATE) == false)) {
 292                                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 293                                          ("Set SSID is the same ssid, fw_state = 0x%08x\n",
 294                                           get_fwstate(pmlmepriv)));
 295
 296                                 if (!rtw_is_same_ibss(padapter, pnetwork)) {
 297                                         /* if in WIFI_ADHOC_MASTER_STATE | WIFI_ADHOC_STATE, create bss or rejoin again */
 298                                         rtw_disassoc_cmd(padapter, 0, true);
 299
 300                                         if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
 301                                                 rtw_indicate_disconnect(padapter);
 302
 303                                         rtw_free_assoc_resources(padapter, 1);
 304
 305                                         if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) {
 306                                                 _clr_fwstate_(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
 307                                                 set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
 308                                         }
 309                                 } else {
 310                                         goto release_mlme_lock;/* it means driver is in WIFI_ADHOC_MASTER_STATE, we needn't create bss again. */
 311                                 }
 312                         } else {
 313                                 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_JOINBSS, 1);
 314                         }
 315                 } else {
 316                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("Set SSID not the same ssid\n"));
 317                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("set_ssid =[%s] len = 0x%x\n", ssid->Ssid, (unsigned int)ssid->SsidLength));
 318                         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));
 319
 320                         rtw_disassoc_cmd(padapter, 0, true);
 321
 322                         if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
 323                                 rtw_indicate_disconnect(padapter);
 324
 325                         rtw_free_assoc_resources(padapter, 1);
 326
 327                         if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) {
 328                                 _clr_fwstate_(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
 329                                 set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
 330                         }
 331                 }
 332         }
 333
 334 handle_tkip_countermeasure:
 335
 336         if (padapter->securitypriv.btkip_countermeasure) {
 337                 cur_time = jiffies;
 338
 339                 if ((cur_time - padapter->securitypriv.btkip_countermeasure_time) > 60 * HZ) {
 340                         padapter->securitypriv.btkip_countermeasure = false;
 341                         padapter->securitypriv.btkip_countermeasure_time = 0;
 342                 } else {
 343                         status = _FAIL;
 344                         goto release_mlme_lock;
 345                 }
 346         }
 347
 348         memcpy(&pmlmepriv->assoc_ssid, ssid, sizeof(struct ndis_802_11_ssid));
 349         pmlmepriv->assoc_by_bssid = false;
 350
 351         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true)
 352                 pmlmepriv->to_join = true;
 353         else
 354                 status = rtw_do_join(padapter);
 355
 356 release_mlme_lock:
 357         spin_unlock_bh(&pmlmepriv->lock);
 358
 359 exit:
 360         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 361                  ("-rtw_set_802_11_ssid: status =%d\n", status));
 362         return status;
 363 }
 364
 365 u8 rtw_set_802_11_infrastructure_mode(struct adapter *padapter,
 366         enum ndis_802_11_network_infra networktype)
 367 {
 368         struct  mlme_priv       *pmlmepriv = &padapter->mlmepriv;
 369         struct  wlan_network    *cur_network = &pmlmepriv->cur_network;
 370         enum ndis_802_11_network_infra *pold_state = &(cur_network->network.InfrastructureMode);
 371
 372
 373         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_notice_,
 374                  ("+rtw_set_802_11_infrastructure_mode: old =%d new =%d fw_state = 0x%08x\n",
 375                   *pold_state, networktype, get_fwstate(pmlmepriv)));
 376
 377         if (*pold_state != networktype) {
 378                 spin_lock_bh(&pmlmepriv->lock);
 379
 380                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, (" change mode!"));
 381                 /* DBG_88E("change mode, old_mode =%d, new_mode =%d, fw_state = 0x%x\n", *pold_state, networktype, get_fwstate(pmlmepriv)); */
 382
 383                 if (*pold_state == Ndis802_11APMode) {
 384                         /* change to other mode from Ndis802_11APMode */
 385                         cur_network->join_res = -1;
 386
 387 #ifdef CONFIG_88EU_AP_MODE
 388                         stop_ap_mode(padapter);
 389 #endif
 390                 }
 391
 392                 if ((check_fwstate(pmlmepriv, _FW_LINKED)) ||
 393                     (*pold_state == Ndis802_11IBSS))
 394                         rtw_disassoc_cmd(padapter, 0, true);
 395
 396                 if ((check_fwstate(pmlmepriv, _FW_LINKED)) ||
 397                     (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))
 398                         rtw_free_assoc_resources(padapter, 1);
 399
 400                 if ((*pold_state == Ndis802_11Infrastructure) || (*pold_state == Ndis802_11IBSS)) {
 401                         if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
 402                                 rtw_indicate_disconnect(padapter); /* will clr Linked_state; before this function, we must have checked whether  issue dis-assoc_cmd or not */
 403                }
 404
 405                 *pold_state = networktype;
 406
 407                 _clr_fwstate_(pmlmepriv, ~WIFI_NULL_STATE);
 408
 409                 switch (networktype) {
 410                 case Ndis802_11IBSS:
 411                         set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
 412                         break;
 413                 case Ndis802_11Infrastructure:
 414                         set_fwstate(pmlmepriv, WIFI_STATION_STATE);
 415                         break;
 416                 case Ndis802_11APMode:
 417                         set_fwstate(pmlmepriv, WIFI_AP_STATE);
 418 #ifdef CONFIG_88EU_AP_MODE
 419                         start_ap_mode(padapter);
 420 #endif
 421                         break;
 422                 case Ndis802_11AutoUnknown:
 423                 case Ndis802_11InfrastructureMax:
 424                         break;
 425                 }
 426                 spin_unlock_bh(&pmlmepriv->lock);
 427         }
 428
 429
 430         return true;
 431 }
 432
 433
 434 u8 rtw_set_802_11_disassociate(struct adapter *padapter)
 435 {
 436         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 437
 438
 439         spin_lock_bh(&pmlmepriv->lock);
 440
 441         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 442                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
 443                          ("MgntActrtw_set_802_11_disassociate: rtw_indicate_disconnect\n"));
 444
 445                 rtw_disassoc_cmd(padapter, 0, true);
 446                 rtw_indicate_disconnect(padapter);
 447                 rtw_free_assoc_resources(padapter, 1);
 448                 rtw_pwr_wakeup(padapter);
 449         }
 450
 451         spin_unlock_bh(&pmlmepriv->lock);
 452
 453
 454         return true;
 455 }
 456
 457 u8 rtw_set_802_11_bssid_list_scan(struct adapter *padapter, struct ndis_802_11_ssid *pssid, int ssid_max_num)
 458 {
 459         struct  mlme_priv               *pmlmepriv = &padapter->mlmepriv;
 460         u8      res = true;
 461
 462
 463         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("+rtw_set_802_11_bssid_list_scan(), fw_state =%x\n", get_fwstate(pmlmepriv)));
 464
 465         if (padapter == NULL) {
 466                 res = false;
 467                 goto exit;
 468         }
 469         if (!padapter->hw_init_completed) {
 470                 res = false;
 471                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("\n === rtw_set_802_11_bssid_list_scan:hw_init_completed == false ===\n"));
 472                 goto exit;
 473         }
 474
 475         if ((check_fwstate(pmlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING)) ||
 476             (pmlmepriv->LinkDetectInfo.bBusyTraffic)) {
 477                 /*  Scan or linking is in progress, do nothing. */
 478                 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)));
 479                 res = true;
 480
 481                 if (check_fwstate(pmlmepriv,
 482                                 (_FW_UNDER_SURVEY|_FW_UNDER_LINKING)) == true)
 483                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("\n###_FW_UNDER_SURVEY|_FW_UNDER_LINKING\n\n"));
 484                 else
 485                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("\n###pmlmepriv->sitesurveyctrl.traffic_busy == true\n\n"));
 486
 487         } else {
 488                 if (rtw_is_scan_deny(padapter)) {
 489                         DBG_88E(FUNC_ADPT_FMT": scan deny\n", FUNC_ADPT_ARG(padapter));
 490                         indicate_wx_scan_complete_event(padapter);
 491                         return _SUCCESS;
 492                 }
 493
 494                 spin_lock_bh(&pmlmepriv->lock);
 495
 496                 res = rtw_sitesurvey_cmd(padapter, pssid, ssid_max_num, NULL, 0);
 497
 498                 spin_unlock_bh(&pmlmepriv->lock);
 499         }
 500 exit:
 501
 502
 503         return res;
 504 }
 505
 506 u8 rtw_set_802_11_authentication_mode(struct adapter *padapter, enum ndis_802_11_auth_mode authmode)
 507 {
 508         struct security_priv *psecuritypriv = &padapter->securitypriv;
 509         int res;
 510         u8 ret;
 511
 512
 513         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("set_802_11_auth.mode(): mode =%x\n", authmode));
 514
 515         psecuritypriv->ndisauthtype = authmode;
 516
 517         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
 518                  ("rtw_set_802_11_authentication_mode:psecuritypriv->ndisauthtype=%d",
 519                  psecuritypriv->ndisauthtype));
 520
 521         if (psecuritypriv->ndisauthtype > 3)
 522                 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
 523
 524         res = rtw_set_auth(padapter, psecuritypriv);
 525
 526         if (res == _SUCCESS)
 527                 ret = true;
 528         else
 529                 ret = false;
 530
 531
 532         return ret;
 533 }
 534
 535 u8 rtw_set_802_11_add_wep(struct adapter *padapter, struct ndis_802_11_wep *wep)
 536 {
 537         int             keyid, res;
 538         struct security_priv *psecuritypriv = &(padapter->securitypriv);
 539         u8              ret = _SUCCESS;
 540
 541
 542         keyid = wep->KeyIndex & 0x3fffffff;
 543
 544         if (keyid >= 4) {
 545                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("MgntActrtw_set_802_11_add_wep:keyid>4 =>fail\n"));
 546                 ret = false;
 547                 goto exit;
 548         }
 549
 550         switch (wep->KeyLength) {
 551         case 5:
 552                 psecuritypriv->dot11PrivacyAlgrthm = _WEP40_;
 553                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("MgntActrtw_set_802_11_add_wep:wep->KeyLength = 5\n"));
 554                 break;
 555         case 13:
 556                 psecuritypriv->dot11PrivacyAlgrthm = _WEP104_;
 557                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("MgntActrtw_set_802_11_add_wep:wep->KeyLength = 13\n"));
 558                 break;
 559         default:
 560                 psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
 561                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_, ("MgntActrtw_set_802_11_add_wep:wep->KeyLength!= 5 or 13\n"));
 562                 break;
 563         }
 564         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
 565                  ("rtw_set_802_11_add_wep:before memcpy, wep->KeyLength = 0x%x wep->KeyIndex = 0x%x  keyid =%x\n",
 566                  wep->KeyLength, wep->KeyIndex, keyid));
 567
 568         memcpy(&(psecuritypriv->dot11DefKey[keyid].skey[0]), &(wep->KeyMaterial), wep->KeyLength);
 569
 570         psecuritypriv->dot11DefKeylen[keyid] = wep->KeyLength;
 571
 572         psecuritypriv->dot11PrivacyKeyIndex = keyid;
 573
 574         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
 575                  ("rtw_set_802_11_add_wep:security key material : %x %x %x %x %x %x %x %x %x %x %x %x %x\n",
 576                  psecuritypriv->dot11DefKey[keyid].skey[0],
 577                  psecuritypriv->dot11DefKey[keyid].skey[1],
 578                  psecuritypriv->dot11DefKey[keyid].skey[2],
 579                  psecuritypriv->dot11DefKey[keyid].skey[3],
 580                  psecuritypriv->dot11DefKey[keyid].skey[4],
 581                  psecuritypriv->dot11DefKey[keyid].skey[5],
 582                  psecuritypriv->dot11DefKey[keyid].skey[6],
 583                  psecuritypriv->dot11DefKey[keyid].skey[7],
 584                  psecuritypriv->dot11DefKey[keyid].skey[8],
 585                  psecuritypriv->dot11DefKey[keyid].skey[9],
 586                  psecuritypriv->dot11DefKey[keyid].skey[10],
 587                  psecuritypriv->dot11DefKey[keyid].skey[11],
 588                  psecuritypriv->dot11DefKey[keyid].skey[12]));
 589
 590         res = rtw_set_key(padapter, psecuritypriv, keyid, 1);
 591
 592         if (res == _FAIL)
 593                 ret = false;
 594 exit:
 595         return ret;
 596 }
 597
 598 u8 rtw_set_802_11_remove_wep(struct adapter *padapter, u32 keyindex)
 599 {
 600         u8 ret = _SUCCESS;
 601
 602         if (keyindex >= 0x80000000 || padapter == NULL) {
 603                 ret = false;
 604                 goto exit;
 605         } else {
 606                 int res;
 607                 struct security_priv *psecuritypriv = &(padapter->securitypriv);
 608                 if (keyindex < 4) {
 609                         _rtw_memset(&psecuritypriv->dot11DefKey[keyindex], 0, 16);
 610                         res = rtw_set_key(padapter, psecuritypriv, keyindex, 0);
 611                         psecuritypriv->dot11DefKeylen[keyindex] = 0;
 612                         if (res == _FAIL)
 613                                 ret = _FAIL;
 614                 } else {
 615                         ret = _FAIL;
 616                 }
 617         }
 618 exit:
 619
 620         return ret;
 621 }
 622
 623 u8 rtw_set_802_11_add_key(struct adapter *padapter, struct ndis_802_11_key *key)
 624 {
 625         uint    encryptionalgo;
 626         u8 *pbssid;
 627         struct sta_info *stainfo;
 628         u8      bgroup = false;
 629         u8      bgrouptkey = false;/* can be removed later */
 630         u8      ret = _SUCCESS;
 631
 632
 633         if (((key->KeyIndex & 0x80000000) == 0) && ((key->KeyIndex & 0x40000000) > 0)) {
 634                 /*  It is invalid to clear bit 31 and set bit 30. If the miniport driver encounters this combination, */
 635                 /*  it must fail the request and return NDIS_STATUS_INVALID_DATA. */
 636                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
 637                          ("rtw_set_802_11_add_key: ((key->KeyIndex & 0x80000000)==0)[=%d]",
 638                          (int)(key->KeyIndex & 0x80000000) == 0));
 639                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
 640                          ("rtw_set_802_11_add_key:((key->KeyIndex & 0x40000000)>0)[=%d]",
 641                          (int)(key->KeyIndex & 0x40000000) > 0));
 642                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
 643                          ("rtw_set_802_11_add_key: key->KeyIndex=%d\n",
 644                          (int)key->KeyIndex));
 645                 ret = _FAIL;
 646                 goto exit;
 647         }
 648
 649         if (key->KeyIndex & 0x40000000) {
 650                 /*  Pairwise key */
 651
 652                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("OID_802_11_ADD_KEY: +++++ Pairwise key +++++\n"));
 653
 654                 pbssid = get_bssid(&padapter->mlmepriv);
 655                 stainfo = rtw_get_stainfo(&padapter->stapriv, pbssid);
 656
 657                 if ((stainfo != NULL) && (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)) {
 658                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 659                                  ("OID_802_11_ADD_KEY:(stainfo!=NULL)&&(Adapter->securitypriv.dot11AuthAlgrthm==dot11AuthAlgrthm_8021X)\n"));
 660                         encryptionalgo = stainfo->dot118021XPrivacy;
 661                 } else {
 662                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("OID_802_11_ADD_KEY: stainfo == NULL)||(Adapter->securitypriv.dot11AuthAlgrthm!= dot11AuthAlgrthm_8021X)\n"));
 663                         encryptionalgo = padapter->securitypriv.dot11PrivacyAlgrthm;
 664                 }
 665
 666                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 667                          ("rtw_set_802_11_add_key: (encryptionalgo==%d)!\n",
 668                          encryptionalgo));
 669                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 670                          ("rtw_set_802_11_add_key: (Adapter->securitypriv.dot11PrivacyAlgrthm==%d)!\n",
 671                          padapter->securitypriv.dot11PrivacyAlgrthm));
 672                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 673                          ("rtw_set_802_11_add_key: (Adapter->securitypriv.dot11AuthAlgrthm==%d)!\n",
 674                          padapter->securitypriv.dot11AuthAlgrthm));
 675
 676                 if ((stainfo != NULL))
 677                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 678                                  ("rtw_set_802_11_add_key: (stainfo->dot118021XPrivacy==%d)!\n",
 679                                  stainfo->dot118021XPrivacy));
 680
 681                 if (key->KeyIndex & 0x000000FF) {
 682                         /*  The key index is specified in the lower 8 bits by values of zero to 255. */
 683                         /*  The key index should be set to zero for a Pairwise key, and the driver should fail with */
 684                         /*  NDIS_STATUS_INVALID_DATA if the lower 8 bits is not zero */
 685                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, (" key->KeyIndex & 0x000000FF.\n"));
 686                         ret = _FAIL;
 687                         goto exit;
 688                 }
 689
 690                 /*  check BSSID */
 691                 if (IS_MAC_ADDRESS_BROADCAST(key->BSSID) == true) {
 692                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("MacAddr_isBcst(key->BSSID)\n"));
 693                         ret = false;
 694                         goto exit;
 695                 }
 696
 697                 /*  Check key length for TKIP. */
 698                 if ((encryptionalgo == _TKIP_) && (key->KeyLength != 32)) {
 699                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("TKIP KeyLength:0x%x != 32\n", key->KeyLength));
 700                         ret = _FAIL;
 701                         goto exit;
 702                 }
 703
 704                 /*  Check key length for AES. */
 705                 if ((encryptionalgo == _AES_) && (key->KeyLength != 16)) {
 706                         /*  For our supplicant, EAPPkt9x.vxd, cannot differentiate TKIP and AES case. */
 707                         if (key->KeyLength == 32) {
 708                                 key->KeyLength = 16;
 709                         } else {
 710                                 ret = _FAIL;
 711                                 goto exit;
 712                         }
 713                 }
 714
 715                 /*  Check key length for WEP. For NDTEST, 2005.01.27, by rcnjko. */
 716                 if ((encryptionalgo == _WEP40_ || encryptionalgo == _WEP104_) &&
 717                     (key->KeyLength != 5 && key->KeyLength != 13)) {
 718                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("WEP KeyLength:0x%x != 5 or 13\n", key->KeyLength));
 719                         ret = _FAIL;
 720                         goto exit;
 721                 }
 722
 723                 bgroup = false;
 724
 725                 /*  Check the pairwise key. Added by Annie, 2005-07-06. */
 726                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("------------------------------------------\n"));
 727                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("[Pairwise Key set]\n"));
 728                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("------------------------------------------\n"));
 729                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("key index: 0x%8x(0x%8x)\n", key->KeyIndex, (key->KeyIndex&0x3)));
 730                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("key Length: %d\n", key->KeyLength));
 731                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("------------------------------------------\n"));
 732
 733         } else {
 734                 /*  Group key - KeyIndex(BIT30 == 0) */
 735                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("OID_802_11_ADD_KEY: +++++ Group key +++++\n"));
 736
 737
 738                 /*  when add wep key through add key and didn't assigned encryption type before */
 739                 if ((padapter->securitypriv.ndisauthtype <= 3) &&
 740                     (padapter->securitypriv.dot118021XGrpPrivacy == 0)) {
 741                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 742                                  ("keylen =%d(Adapter->securitypriv.dot11PrivacyAlgrthm=%x )padapter->securitypriv.dot118021XGrpPrivacy(%x)\n",
 743                                  key->KeyLength, padapter->securitypriv.dot11PrivacyAlgrthm,
 744                                  padapter->securitypriv.dot118021XGrpPrivacy));
 745                         switch (key->KeyLength) {
 746                         case 5:
 747                                 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
 748                                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 749                                          ("Adapter->securitypriv.dot11PrivacyAlgrthm=%x key->KeyLength=%u\n",
 750                                          padapter->securitypriv.dot11PrivacyAlgrthm, key->KeyLength));
 751                                 break;
 752                         case 13:
 753                                 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
 754                                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 755                                          ("Adapter->securitypriv.dot11PrivacyAlgrthm=%x key->KeyLength=%u\n",
 756                                          padapter->securitypriv.dot11PrivacyAlgrthm, key->KeyLength));
 757                                 break;
 758                         default:
 759                                 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
 760                                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 761                                          ("Adapter->securitypriv.dot11PrivacyAlgrthm=%x key->KeyLength=%u\n",
 762                                          padapter->securitypriv.dot11PrivacyAlgrthm, key->KeyLength));
 763                                 break;
 764                         }
 765
 766                         encryptionalgo = padapter->securitypriv.dot11PrivacyAlgrthm;
 767
 768                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 769                                  (" Adapter->securitypriv.dot11PrivacyAlgrthm=%x\n",
 770                                  padapter->securitypriv.dot11PrivacyAlgrthm));
 771
 772                 } else {
 773                         encryptionalgo = padapter->securitypriv.dot118021XGrpPrivacy;
 774                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 775                                  ("(Adapter->securitypriv.dot11PrivacyAlgrthm=%x)encryptionalgo(%x)=padapter->securitypriv.dot118021XGrpPrivacy(%x)keylen=%d\n",
 776                                  padapter->securitypriv.dot11PrivacyAlgrthm, encryptionalgo,
 777                                  padapter->securitypriv.dot118021XGrpPrivacy, key->KeyLength));
 778                 }
 779
 780                 if ((check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE) == true) && (IS_MAC_ADDRESS_BROADCAST(key->BSSID) == false)) {
 781                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 782                                  (" IBSS but BSSID is not Broadcast Address.\n"));
 783                         ret = _FAIL;
 784                         goto exit;
 785                 }
 786
 787                 /*  Check key length for TKIP */
 788                 if ((encryptionalgo == _TKIP_) && (key->KeyLength != 32)) {
 789                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 790                                  (" TKIP GTK KeyLength:%u != 32\n", key->KeyLength));
 791                         ret = _FAIL;
 792                         goto exit;
 793                 } else if (encryptionalgo == _AES_ && (key->KeyLength != 16 && key->KeyLength != 32)) {
 794                         /*  Check key length for AES */
 795                         /*  For NDTEST, we allow keylen = 32 in this case. 2005.01.27, by rcnjko. */
 796                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 797                                  ("<=== SetInfo, OID_802_11_ADD_KEY: AES GTK KeyLength:%u != 16 or 32\n",
 798                                  key->KeyLength));
 799                         ret = _FAIL;
 800                         goto exit;
 801                 }
 802
 803                 /*  Change the key length for EAPPkt9x.vxd. Added by Annie, 2005-11-03. */
 804                 if ((encryptionalgo ==  _AES_) && (key->KeyLength == 32)) {
 805                         key->KeyLength = 16;
 806                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("AES key length changed: %u\n", key->KeyLength));
 807                 }
 808
 809                 if (key->KeyIndex & 0x8000000) {/* error ??? 0x8000_0000 */
 810                         bgrouptkey = true;
 811                 }
 812
 813                 if ((check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE)) &&
 814                     (check_fwstate(&padapter->mlmepriv, _FW_LINKED)))
 815                         bgrouptkey = true;
 816                 bgroup = true;
 817                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("------------------------------------------\n"));
 818                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("[Group Key set]\n"));
 819                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("------------------------------------------\n")) ;
 820                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("key index: 0x%8x(0x%8x)\n", key->KeyIndex, (key->KeyIndex&0x3)));
 821                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("key Length: %d\n", key->KeyLength)) ;
 822                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("------------------------------------------\n"));
 823         }
 824
 825         /*  If WEP encryption algorithm, just call rtw_set_802_11_add_wep(). */
 826         if ((padapter->securitypriv.dot11AuthAlgrthm != dot11AuthAlgrthm_8021X) &&
 827             (encryptionalgo == _WEP40_ || encryptionalgo == _WEP104_)) {
 828                 u32 keyindex;
 829                 u32 len = FIELD_OFFSET(struct ndis_802_11_key, KeyMaterial) + key->KeyLength;
 830                 struct ndis_802_11_wep *wep = &padapter->securitypriv.ndiswep;
 831
 832                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("OID_802_11_ADD_KEY: +++++ WEP key +++++\n"));
 833
 834                 wep->Length = len;
 835                 keyindex = key->KeyIndex&0x7fffffff;
 836                 wep->KeyIndex = keyindex ;
 837                 wep->KeyLength = key->KeyLength;
 838
 839                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("OID_802_11_ADD_KEY:Before memcpy\n"));
 840
 841                 memcpy(wep->KeyMaterial, key->KeyMaterial, key->KeyLength);
 842                 memcpy(&(padapter->securitypriv.dot11DefKey[keyindex].skey[0]), key->KeyMaterial, key->KeyLength);
 843
 844                 padapter->securitypriv.dot11DefKeylen[keyindex] = key->KeyLength;
 845                 padapter->securitypriv.dot11PrivacyKeyIndex = keyindex;
 846
 847                 ret = rtw_set_802_11_add_wep(padapter, wep);
 848                 goto exit;
 849         }
 850         if (key->KeyIndex & 0x20000000) {
 851                 /*  SetRSC */
 852                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("OID_802_11_ADD_KEY: +++++ SetRSC+++++\n"));
 853                 if (bgroup) {
 854                         unsigned long long keysrc = key->KeyRSC & 0x00FFFFFFFFFFFFULL;
 855                         memcpy(&padapter->securitypriv.dot11Grprxpn, &keysrc, 8);
 856                 } else {
 857                         unsigned long long keysrc = key->KeyRSC & 0x00FFFFFFFFFFFFULL;
 858                         memcpy(&padapter->securitypriv.dot11Grptxpn, &keysrc, 8);
 859                 }
 860         }
 861
 862         /*  Indicate this key idx is used for TX */
 863         /*  Save the key in KeyMaterial */
 864         if (bgroup) { /*  Group transmit key */
 865                 int res;
 866
 867                 if (bgrouptkey)
 868                         padapter->securitypriv.dot118021XGrpKeyid = (u8)key->KeyIndex;
 869                 if ((key->KeyIndex&0x3) == 0) {
 870                         ret = _FAIL;
 871                         goto exit;
 872                 }
 873                 _rtw_memset(&padapter->securitypriv.dot118021XGrpKey[(u8)((key->KeyIndex) & 0x03)], 0, 16);
 874                 _rtw_memset(&padapter->securitypriv.dot118021XGrptxmickey[(u8)((key->KeyIndex) & 0x03)], 0, 16);
 875                 _rtw_memset(&padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)], 0, 16);
 876
 877                 if ((key->KeyIndex & 0x10000000)) {
 878                         memcpy(&padapter->securitypriv.dot118021XGrptxmickey[(u8)((key->KeyIndex) & 0x03)], key->KeyMaterial + 16, 8);
 879                         memcpy(&padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)], key->KeyMaterial + 24, 8);
 880
 881                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 882                                  ("\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",
 883                                  padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[0],
 884                                  padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[1],
 885                                  padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[2],
 886                                  padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[3],
 887                                  padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[4],
 888                                  padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[5],
 889                                  padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[6],
 890                                  padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[7]));
 891                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("\n rtw_set_802_11_add_key:set Group mic key!!!!!!!!\n"));
 892                 } else {
 893                         memcpy(&padapter->securitypriv.dot118021XGrptxmickey[(u8)((key->KeyIndex) & 0x03)], key->KeyMaterial + 24, 8);
 894                         memcpy(&padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)], key->KeyMaterial + 16, 8);
 895
 896                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 897                                  ("\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",
 898                                  padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[0],
 899                                  padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[1],
 900                                  padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[2],
 901                                  padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[3],
 902                                  padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[4],
 903                                  padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[5],
 904                                  padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex) & 0x03)].skey[6],
 905                                  padapter->securitypriv.dot118021XGrprxmickey[(u8)((key->KeyIndex-1) & 0x03)].skey[7]));
 906                         RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
 907                                  ("\n rtw_set_802_11_add_key:set Group mic key!!!!!!!!\n"));
 908                 }
 909
 910                 /* set group key by index */
 911                 memcpy(&padapter->securitypriv.dot118021XGrpKey[(u8)((key->KeyIndex) & 0x03)], key->KeyMaterial, key->KeyLength);
 912
 913                 key->KeyIndex = key->KeyIndex & 0x03;
 914
 915                 padapter->securitypriv.binstallGrpkey = true;
 916
 917                 padapter->securitypriv.bcheck_grpkey = false;
 918
 919                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("reset group key"));
 920
 921                 res = rtw_set_key(padapter, &padapter->securitypriv, key->KeyIndex, 1);
 922
 923                 if (res == _FAIL)
 924                         ret = _FAIL;
 925
 926                 goto exit;
 927
 928         } else { /*  Pairwise Key */
 929                 u8 res;
 930
 931                 pbssid = get_bssid(&padapter->mlmepriv);
 932                 stainfo = rtw_get_stainfo(&padapter->stapriv, pbssid);
 933
 934                 if (stainfo != NULL) {
 935                         _rtw_memset(&stainfo->dot118021x_UncstKey, 0, 16);/*  clear keybuffer */
 936
 937                         memcpy(&stainfo->dot118021x_UncstKey, key->KeyMaterial, 16);
 938
 939                         if (encryptionalgo == _TKIP_) {
 940                                 padapter->securitypriv.busetkipkey = false;
 941
 942                                 /* _set_timer(&padapter->securitypriv.tkip_timer, 50); */
 943
 944                                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("\n========== _set_timer\n"));
 945
 946                                 /*  if TKIP, save the Receive/Transmit MIC key in KeyMaterial[128-255] */
 947                                 if ((key->KeyIndex & 0x10000000)) {
 948                                         memcpy(&stainfo->dot11tkiptxmickey, key->KeyMaterial + 16, 8);
 949                                         memcpy(&stainfo->dot11tkiprxmickey, key->KeyMaterial + 24, 8);
 950
 951                                 } else {
 952                                         memcpy(&stainfo->dot11tkiptxmickey, key->KeyMaterial + 24, 8);
 953                                         memcpy(&stainfo->dot11tkiprxmickey, key->KeyMaterial + 16, 8);
 954                                 }
 955                         }
 956
 957
 958                         /* Set key to CAM through H2C command */
 959                         if (bgrouptkey) { /* never go to here */
 960                                 res = rtw_setstakey_cmd(padapter, (unsigned char *)stainfo, false);
 961                                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("\n rtw_set_802_11_add_key:rtw_setstakey_cmd(group)\n"));
 962                         } else {
 963                                 res = rtw_setstakey_cmd(padapter, (unsigned char *)stainfo, true);
 964                                 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_, ("\n rtw_set_802_11_add_key:rtw_setstakey_cmd(unicast)\n"));
 965                         }
 966                         if (!res)
 967                                 ret = _FAIL;
 968                 }
 969         }
 970 exit:
 971
 972         return ret;
 973 }
 974
 975 u8 rtw_set_802_11_remove_key(struct adapter *padapter, struct ndis_802_11_remove_key *key)
 976 {
 977         u8 *pbssid;
 978         struct sta_info *stainfo;
 979         u8      bgroup = (key->KeyIndex & 0x4000000) > 0 ? false : true;
 980         u8      keyIndex = (u8)key->KeyIndex & 0x03;
 981         u8      ret = _SUCCESS;
 982
 983
 984         if ((key->KeyIndex & 0xbffffffc) > 0) {
 985                 ret = _FAIL;
 986                 goto exit;
 987         }
 988
 989         if (bgroup) {
 990                 /*  clear group key by index */
 991
 992                 _rtw_memset(&padapter->securitypriv.dot118021XGrpKey[keyIndex], 0, 16);
 993
 994                 /*  \todo Send a H2C Command to Firmware for removing this Key in CAM Entry. */
 995         } else {
 996                 pbssid = get_bssid(&padapter->mlmepriv);
 997                 stainfo = rtw_get_stainfo(&padapter->stapriv, pbssid);
 998                 if (stainfo) {
 999                         /*  clear key by BSSID */
1000                         _rtw_memset(&stainfo->dot118021x_UncstKey, 0, 16);
1001
1002                         /*  \todo Send a H2C Command to Firmware for disable this Key in CAM Entry. */
1003                 } else {
1004                         ret = _FAIL;
1005                         goto exit;
1006                 }
1007         }
1008 exit:
1009
1010         return ret;
1011 }
1012
1013 /*
1014 * rtw_get_cur_max_rate -
1015 * @adapter: pointer to struct adapter structure
1016 *
1017 * Return 0 or 100Kbps
1018 */
1019 u16 rtw_get_cur_max_rate(struct adapter *adapter)
1020 {
1021         int     i = 0;
1022         u8      *p;
1023         u16     rate = 0, max_rate = 0;
1024         struct mlme_ext_priv    *pmlmeext = &adapter->mlmeextpriv;
1025         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
1026         struct registry_priv *pregistrypriv = &adapter->registrypriv;
1027         struct mlme_priv        *pmlmepriv = &adapter->mlmepriv;
1028         struct wlan_bssid_ex  *pcur_bss = &pmlmepriv->cur_network.network;
1029         struct rtw_ieee80211_ht_cap *pht_capie;
1030         u8      rf_type = 0;
1031         u8      bw_40MHz = 0, short_GI_20 = 0, short_GI_40 = 0;
1032         u16     mcs_rate = 0;
1033         u32     ht_ielen = 0;
1034
1035         if (adapter->registrypriv.mp_mode == 1) {
1036                 if (check_fwstate(pmlmepriv, WIFI_MP_STATE))
1037                         return 0;
1038         }
1039
1040         if ((!check_fwstate(pmlmepriv, _FW_LINKED)) &&
1041             (!check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)))
1042                 return 0;
1043
1044         if (pmlmeext->cur_wireless_mode & (WIRELESS_11_24N|WIRELESS_11_5N)) {
1045                 p = rtw_get_ie(&pcur_bss->IEs[12], _HT_CAPABILITY_IE_, &ht_ielen, pcur_bss->IELength-12);
1046                 if (p && ht_ielen > 0) {
1047                         pht_capie = (struct rtw_ieee80211_ht_cap *)(p+2);
1048
1049                         memcpy(&mcs_rate, pht_capie->supp_mcs_set, 2);
1050
1051                         /* cur_bwmod is updated by beacon, pmlmeinfo is updated by association response */
1052                         bw_40MHz = (pmlmeext->cur_bwmode && (HT_INFO_HT_PARAM_REC_TRANS_CHNL_WIDTH & pmlmeinfo->HT_info.infos[0])) ? 1 : 0;
1053
1054                         short_GI_20 = (le16_to_cpu(pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info) & IEEE80211_HT_CAP_SGI_20) ? 1 : 0;
1055                         short_GI_40 = (le16_to_cpu(pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info) & IEEE80211_HT_CAP_SGI_40) ? 1 : 0;
1056
1057                         rtw_hal_get_hwreg(adapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
1058                         max_rate = rtw_mcs_rate(
1059                                 rf_type,
1060                                 bw_40MHz & (pregistrypriv->cbw40_enable),
1061                                 short_GI_20,
1062                                 short_GI_40,
1063                                 pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate
1064                         );
1065                 }
1066         } else {
1067                 while ((pcur_bss->SupportedRates[i] != 0) && (pcur_bss->SupportedRates[i] != 0xFF)) {
1068                         rate = pcur_bss->SupportedRates[i]&0x7F;
1069                         if (rate > max_rate)
1070                                 max_rate = rate;
1071                         i++;
1072                 }
1073
1074                 max_rate = max_rate*10/2;
1075         }
1076
1077         return max_rate;
1078 }
1079
1080 /*
1081 * rtw_set_scan_mode -
1082 * @adapter: pointer to struct adapter structure
1083 * @scan_mode:
1084 *
1085 * Return _SUCCESS or _FAIL
1086 */
1087 int rtw_set_scan_mode(struct adapter *adapter, enum rt_scan_type scan_mode)
1088 {
1089         if (scan_mode != SCAN_ACTIVE && scan_mode != SCAN_PASSIVE)
1090                 return _FAIL;
1091
1092         adapter->mlmepriv.scan_mode = scan_mode;
1093
1094         return _SUCCESS;
1095 }
1096
1097 /*
1098 * rtw_set_channel_plan -
1099 * @adapter: pointer to struct adapter structure
1100 * @channel_plan:
1101 *
1102 * Return _SUCCESS or _FAIL
1103 */
1104 int rtw_set_channel_plan(struct adapter *adapter, u8 channel_plan)
1105 {
1106         /* handle by cmd_thread to sync with scan operation */
1107         return rtw_set_chplan_cmd(adapter, channel_plan, 1);
1108 }
1109
1110 /*
1111 * rtw_set_country -
1112 * @adapter: pointer to struct adapter structure
1113 * @country_code: string of country code
1114 *
1115 * Return _SUCCESS or _FAIL
1116 */
1117 int rtw_set_country(struct adapter *adapter, const char *country_code)
1118 {
1119         int channel_plan = RT_CHANNEL_DOMAIN_WORLD_WIDE_5G;
1120
1121         DBG_88E("%s country_code:%s\n", __func__, country_code);
1122
1123         /* TODO: should have a table to match country code and RT_CHANNEL_DOMAIN */
1124         /* TODO: should consider 2-character and 3-character country code */
1125         if (0 == strcmp(country_code, "US"))
1126                 channel_plan = RT_CHANNEL_DOMAIN_FCC;
1127         else if (0 == strcmp(country_code, "EU"))
1128                 channel_plan = RT_CHANNEL_DOMAIN_ETSI;
1129         else if (0 == strcmp(country_code, "JP"))
1130                 channel_plan = RT_CHANNEL_DOMAIN_MKK;
1131         else if (0 == strcmp(country_code, "CN"))
1132                 channel_plan = RT_CHANNEL_DOMAIN_CHINA;
1133         else
1134                 DBG_88E("%s unknown country_code:%s\n", __func__, country_code);
1135
1136         return rtw_set_channel_plan(adapter, channel_plan);
1137 }