drivers/staging/rtl8723bs/core/rtw_ap.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
   5  *
   6  ******************************************************************************/
   7 #define _RTW_AP_C_
   8
   9 #include <drv_types.h>
  10 #include <rtw_debug.h>
  11 #include <asm/unaligned.h>
  12
  13 void init_mlme_ap_info(struct adapter *padapter)
  14 {
  15         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
  16         struct sta_priv *pstapriv = &padapter->stapriv;
  17         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
  18
  19         spin_lock_init(&pmlmepriv->bcn_update_lock);
  20
  21         /* for ACL */
  22         _rtw_init_queue(&pacl_list->acl_node_q);
  23
  24         /* pmlmeext->bstart_bss = false; */
  25
  26         start_ap_mode(padapter);
  27 }
  28
  29 void free_mlme_ap_info(struct adapter *padapter)
  30 {
  31         struct sta_info *psta = NULL;
  32         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
  33         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
  34         struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
  35
  36         /* stop_ap_mode(padapter); */
  37
  38         pmlmepriv->update_bcn = false;
  39         pmlmeext->bstart_bss = false;
  40
  41         rtw_sta_flush(padapter);
  42
  43         pmlmeinfo->state = _HW_STATE_NOLINK_;
  44
  45         /* free_assoc_sta_resources */
  46         rtw_free_all_stainfo(padapter);
  47
  48         /* free bc/mc sta_info */
  49         psta = rtw_get_bcmc_stainfo(padapter);
  50         rtw_free_stainfo(padapter, psta);
  51 }
  52
  53 static void update_BCNTIM(struct adapter *padapter)
  54 {
  55         struct sta_priv *pstapriv = &padapter->stapriv;
  56         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
  57         struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
  58         struct wlan_bssid_ex *pnetwork_mlmeext = &pmlmeinfo->network;
  59         unsigned char *pie = pnetwork_mlmeext->IEs;
  60
  61         /* update TIM IE */
  62         u8 *p, *dst_ie, *premainder_ie = NULL, *pbackup_remainder_ie = NULL;
  63         __le16 tim_bitmap_le;
  64         uint offset, tmp_len, tim_ielen, tim_ie_offset, remainder_ielen;
  65
  66         tim_bitmap_le = cpu_to_le16(pstapriv->tim_bitmap);
  67
  68         p = rtw_get_ie(pie + _FIXED_IE_LENGTH_,
  69                        WLAN_EID_TIM,
  70                        &tim_ielen,
  71                        pnetwork_mlmeext->IELength - _FIXED_IE_LENGTH_
  72         );
  73         if (p && tim_ielen > 0) {
  74                 tim_ielen += 2;
  75
  76                 premainder_ie = p + tim_ielen;
  77
  78                 tim_ie_offset = (signed int)(p - pie);
  79
  80                 remainder_ielen = pnetwork_mlmeext->IELength - tim_ie_offset - tim_ielen;
  81
  82                 /* append TIM IE from dst_ie offset */
  83                 dst_ie = p;
  84         } else {
  85                 tim_ielen = 0;
  86
  87                 /* calculate head_len */
  88                 offset = _FIXED_IE_LENGTH_;
  89
  90                 /* get ssid_ie len */
  91                 p = rtw_get_ie(pie + _BEACON_IE_OFFSET_,
  92                                WLAN_EID_SSID,
  93                                &tmp_len,
  94                                (pnetwork_mlmeext->IELength - _BEACON_IE_OFFSET_)
  95                 );
  96                 if (p)
  97                         offset += tmp_len + 2;
  98
  99                 /*  get supported rates len */
 100                 p = rtw_get_ie(pie + _BEACON_IE_OFFSET_,
 101                                WLAN_EID_SUPP_RATES, &tmp_len,
 102                                (pnetwork_mlmeext->IELength - _BEACON_IE_OFFSET_)
 103                 );
 104                 if (p)
 105                         offset += tmp_len + 2;
 106
 107                 /* DS Parameter Set IE, len =3 */
 108                 offset += 3;
 109
 110                 premainder_ie = pie + offset;
 111
 112                 remainder_ielen = pnetwork_mlmeext->IELength - offset - tim_ielen;
 113
 114                 /* append TIM IE from offset */
 115                 dst_ie = pie + offset;
 116         }
 117
 118         if (remainder_ielen > 0) {
 119                 pbackup_remainder_ie = rtw_malloc(remainder_ielen);
 120                 if (pbackup_remainder_ie && premainder_ie)
 121                         memcpy(pbackup_remainder_ie, premainder_ie, remainder_ielen);
 122         }
 123
 124         *dst_ie++ = WLAN_EID_TIM;
 125
 126         if ((pstapriv->tim_bitmap & 0xff00) && (pstapriv->tim_bitmap & 0x00fe))
 127                 tim_ielen = 5;
 128         else
 129                 tim_ielen = 4;
 130
 131         *dst_ie++ = tim_ielen;
 132
 133         *dst_ie++ = 0;/* DTIM count */
 134         *dst_ie++ = 1;/* DTIM period */
 135
 136         if (pstapriv->tim_bitmap & BIT(0))/* for bc/mc frames */
 137                 *dst_ie++ = BIT(0);/* bitmap ctrl */
 138         else
 139                 *dst_ie++ = 0;
 140
 141         if (tim_ielen == 4) {
 142                 __le16 pvb;
 143
 144                 if (pstapriv->tim_bitmap & 0xff00)
 145                         pvb = cpu_to_le16(pstapriv->tim_bitmap >> 8);
 146                 else
 147                         pvb = tim_bitmap_le;
 148
 149                 *dst_ie++ = le16_to_cpu(pvb);
 150
 151         } else if (tim_ielen == 5) {
 152                 memcpy(dst_ie, &tim_bitmap_le, 2);
 153                 dst_ie += 2;
 154         }
 155
 156         /* copy remainder IE */
 157         if (pbackup_remainder_ie) {
 158                 memcpy(dst_ie, pbackup_remainder_ie, remainder_ielen);
 159
 160                 kfree(pbackup_remainder_ie);
 161         }
 162
 163         offset =  (uint)(dst_ie - pie);
 164         pnetwork_mlmeext->IELength = offset + remainder_ielen;
 165 }
 166
 167 static u8 chk_sta_is_alive(struct sta_info *psta)
 168 {
 169         sta_update_last_rx_pkts(psta);
 170
 171         return true;
 172 }
 173
 174 void expire_timeout_chk(struct adapter *padapter)
 175 {
 176         struct list_head *phead, *plist, *tmp;
 177         u8 updated = false;
 178         struct sta_info *psta = NULL;
 179         struct sta_priv *pstapriv = &padapter->stapriv;
 180         u8 chk_alive_num = 0;
 181         char chk_alive_list[NUM_STA];
 182         int i;
 183
 184         spin_lock_bh(&pstapriv->auth_list_lock);
 185
 186         phead = &pstapriv->auth_list;
 187         /* check auth_queue */
 188         list_for_each_safe(plist, tmp, phead) {
 189                 psta = list_entry(plist, struct sta_info, auth_list);
 190
 191                 if (psta->expire_to > 0) {
 192                         psta->expire_to--;
 193                         if (psta->expire_to == 0) {
 194                                 list_del_init(&psta->auth_list);
 195                                 pstapriv->auth_list_cnt--;
 196
 197                                 spin_unlock_bh(&pstapriv->auth_list_lock);
 198
 199                                 rtw_free_stainfo(padapter, psta);
 200
 201                                 spin_lock_bh(&pstapriv->auth_list_lock);
 202                         }
 203                 }
 204         }
 205
 206         spin_unlock_bh(&pstapriv->auth_list_lock);
 207         psta = NULL;
 208
 209         spin_lock_bh(&pstapriv->asoc_list_lock);
 210
 211         phead = &pstapriv->asoc_list;
 212         /* check asoc_queue */
 213         list_for_each_safe(plist, tmp, phead) {
 214                 psta = list_entry(plist, struct sta_info, asoc_list);
 215                 if (chk_sta_is_alive(psta) || !psta->expire_to) {
 216                         psta->expire_to = pstapriv->expire_to;
 217                         psta->keep_alive_trycnt = 0;
 218                         psta->under_exist_checking = 0;
 219                 } else {
 220                         if (psta->expire_to > 0)
 221                                 psta->expire_to--;
 222                 }
 223
 224                 if (psta->expire_to == 0) {
 225                         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 226
 227                         if (padapter->registrypriv.wifi_spec == 1) {
 228                                 psta->expire_to = pstapriv->expire_to;
 229                                 continue;
 230                         }
 231
 232                         if (psta->state & WIFI_SLEEP_STATE) {
 233                                 if (!(psta->state & WIFI_STA_ALIVE_CHK_STATE)) {
 234                                         /* to check if alive by another methods */
 235                                         /* if station is at ps mode. */
 236                                         psta->expire_to = pstapriv->expire_to;
 237                                         psta->state |= WIFI_STA_ALIVE_CHK_STATE;
 238
 239                                         /* to update bcn with tim_bitmap for this station */
 240                                         pstapriv->tim_bitmap |= BIT(psta->aid);
 241                                         update_beacon(padapter, WLAN_EID_TIM, NULL, true);
 242
 243                                         if (!pmlmeext->active_keep_alive_check)
 244                                                 continue;
 245                                 }
 246                         }
 247                         if (pmlmeext->active_keep_alive_check) {
 248                                 int stainfo_offset;
 249
 250                                 stainfo_offset = rtw_stainfo_offset(pstapriv, psta);
 251                                 if (stainfo_offset_valid(stainfo_offset))
 252                                         chk_alive_list[chk_alive_num++] = stainfo_offset;
 253
 254                                 continue;
 255                         }
 256                         list_del_init(&psta->asoc_list);
 257                         pstapriv->asoc_list_cnt--;
 258                         updated = ap_free_sta(padapter, psta, false, WLAN_REASON_DEAUTH_LEAVING);
 259                 } else {
 260                         /* TODO: Aging mechanism to digest frames in sleep_q to */
 261                         /* avoid running out of xmitframe */
 262                         if (psta->sleepq_len > (NR_XMITFRAME / pstapriv->asoc_list_cnt)
 263                                 && padapter->xmitpriv.free_xmitframe_cnt < ((
 264                                         NR_XMITFRAME / pstapriv->asoc_list_cnt
 265                                 ) / 2)
 266                         )
 267                                 wakeup_sta_to_xmit(padapter, psta);
 268                 }
 269         }
 270
 271         spin_unlock_bh(&pstapriv->asoc_list_lock);
 272
 273         if (chk_alive_num) {
 274                 u8 backup_oper_channel = 0;
 275                 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 276
 277                 /* switch to correct channel of current network  before issue keep-alive frames */
 278                 if (rtw_get_oper_ch(padapter) != pmlmeext->cur_channel) {
 279                         backup_oper_channel = rtw_get_oper_ch(padapter);
 280                         SelectChannel(padapter, pmlmeext->cur_channel);
 281                 }
 282
 283                 /* issue null data to check sta alive*/
 284                 for (i = 0; i < chk_alive_num; i++) {
 285                         int ret = _FAIL;
 286
 287                         psta = rtw_get_stainfo_by_offset(pstapriv, chk_alive_list[i]);
 288                         if (!(psta->state & _FW_LINKED))
 289                                 continue;
 290
 291                         if (psta->state & WIFI_SLEEP_STATE)
 292                                 ret = issue_nulldata(padapter, psta->hwaddr, 0, 1, 50);
 293                         else
 294                                 ret = issue_nulldata(padapter, psta->hwaddr, 0, 3, 50);
 295
 296                         psta->keep_alive_trycnt++;
 297                         if (ret == _SUCCESS) {
 298                                 psta->expire_to = pstapriv->expire_to;
 299                                 psta->keep_alive_trycnt = 0;
 300                                 continue;
 301                         } else if (psta->keep_alive_trycnt <= 3) {
 302                                 psta->expire_to = 1;
 303                                 continue;
 304                         }
 305
 306                         psta->keep_alive_trycnt = 0;
 307                         spin_lock_bh(&pstapriv->asoc_list_lock);
 308                         if (list_empty(&psta->asoc_list) == false) {
 309                                 list_del_init(&psta->asoc_list);
 310                                 pstapriv->asoc_list_cnt--;
 311                                 updated = ap_free_sta(padapter, psta, false,
 312                                                       WLAN_REASON_DEAUTH_LEAVING);
 313                         }
 314                         spin_unlock_bh(&pstapriv->asoc_list_lock);
 315                 }
 316
 317                 if (backup_oper_channel > 0) /* back to the original operation channel */
 318                         SelectChannel(padapter, backup_oper_channel);
 319         }
 320
 321         associated_clients_update(padapter, updated);
 322 }
 323
 324 void add_RATid(struct adapter *padapter, struct sta_info *psta, u8 rssi_level)
 325 {
 326         unsigned char sta_band = 0, shortGIrate = false;
 327         unsigned int tx_ra_bitmap = 0;
 328         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 329         struct wlan_bssid_ex
 330                 *pcur_network = (struct wlan_bssid_ex *)&pmlmepriv->cur_network.network;
 331
 332         if (!psta)
 333                 return;
 334
 335         if (!(psta->state & _FW_LINKED))
 336                 return;
 337
 338         rtw_hal_update_sta_rate_mask(padapter, psta);
 339         tx_ra_bitmap = psta->ra_mask;
 340
 341         shortGIrate = query_ra_short_GI(psta);
 342
 343         if (pcur_network->Configuration.DSConfig > 14) {
 344                 sta_band |= WIRELESS_INVALID;
 345         } else {
 346                 if (tx_ra_bitmap & 0xffff000)
 347                         sta_band |= WIRELESS_11_24N;
 348
 349                 if (tx_ra_bitmap & 0xff0)
 350                         sta_band |= WIRELESS_11G;
 351
 352                 if (tx_ra_bitmap & 0x0f)
 353                         sta_band |= WIRELESS_11B;
 354         }
 355
 356         psta->wireless_mode = sta_band;
 357         psta->raid = networktype_to_raid_ex(padapter, psta);
 358
 359         if (psta->aid < NUM_STA) {
 360                 u8 arg[4] = {0};
 361
 362                 arg[0] = psta->mac_id;
 363                 arg[1] = psta->raid;
 364                 arg[2] = shortGIrate;
 365                 arg[3] = psta->init_rate;
 366
 367                 rtw_hal_add_ra_tid(padapter, tx_ra_bitmap, arg, rssi_level);
 368         }
 369 }
 370
 371 void update_bmc_sta(struct adapter *padapter)
 372 {
 373         unsigned char network_type;
 374         int supportRateNum = 0;
 375         unsigned int tx_ra_bitmap = 0;
 376         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 377         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
 378         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
 379         struct wlan_bssid_ex
 380                 *pcur_network = (struct wlan_bssid_ex *)&pmlmepriv->cur_network.network;
 381         struct sta_info *psta = rtw_get_bcmc_stainfo(padapter);
 382
 383         if (psta) {
 384                 psta->aid = 0;/* default set to 0 */
 385                 /* psta->mac_id = psta->aid+4; */
 386                 psta->mac_id = psta->aid + 1;/* mac_id = 1 for bc/mc stainfo */
 387
 388                 pmlmeinfo->FW_sta_info[psta->mac_id].psta = psta;
 389
 390                 psta->qos_option = 0;
 391                 psta->htpriv.ht_option = false;
 392
 393                 psta->ieee8021x_blocked = 0;
 394
 395                 memset((void *)&psta->sta_stats, 0, sizeof(struct stainfo_stats));
 396
 397                 /* psta->dot118021XPrivacy = _NO_PRIVACY_;//!!! remove it, because it has been set before this. */
 398
 399                 /* prepare for add_RATid */
 400                 supportRateNum = rtw_get_rateset_len((u8 *)&pcur_network->SupportedRates);
 401                 network_type = rtw_check_network_type((u8 *)&pcur_network->SupportedRates,
 402                                                       supportRateNum,
 403                                                       pcur_network->Configuration.DSConfig
 404                 );
 405                 if (IsSupportedTxCCK(network_type)) {
 406                         network_type = WIRELESS_11B;
 407                 } else if (network_type == WIRELESS_INVALID) { /*  error handling */
 408
 409                         if (pcur_network->Configuration.DSConfig > 14)
 410                                 network_type = WIRELESS_INVALID;
 411                         else
 412                                 network_type = WIRELESS_11B;
 413                 }
 414                 update_sta_basic_rate(psta, network_type);
 415                 psta->wireless_mode = network_type;
 416
 417                 rtw_hal_update_sta_rate_mask(padapter, psta);
 418                 tx_ra_bitmap = psta->ra_mask;
 419
 420                 psta->raid = networktype_to_raid_ex(padapter, psta);
 421
 422                 /* ap mode */
 423                 rtw_hal_set_odm_var(padapter, HAL_ODM_STA_INFO, psta, true);
 424
 425                 /* if (pHalData->fw_ractrl == true) */
 426                 {
 427                         u8 arg[4] = {0};
 428
 429                         arg[0] = psta->mac_id;
 430                         arg[1] = psta->raid;
 431                         arg[2] = 0;
 432                         arg[3] = psta->init_rate;
 433
 434                         rtw_hal_add_ra_tid(padapter, tx_ra_bitmap, arg, 0);
 435                 }
 436
 437                 rtw_sta_media_status_rpt(padapter, psta, 1);
 438
 439                 spin_lock_bh(&psta->lock);
 440                 psta->state = _FW_LINKED;
 441                 spin_unlock_bh(&psta->lock);
 442
 443         }
 444 }
 445
 446 /* notes: */
 447 /* AID: 1~MAX for sta and 0 for bc/mc in ap/adhoc mode */
 448 /* MAC_ID = AID+1 for sta in ap/adhoc mode */
 449 /* MAC_ID = 1 for bc/mc for sta/ap/adhoc */
 450 /* MAC_ID = 0 for bssid for sta/ap/adhoc */
 451 /* CAM_ID = 0~3 for default key, cmd_id =macid + 3, macid =aid+1; */
 452
 453 void update_sta_info_apmode(struct adapter *padapter, struct sta_info *psta)
 454 {
 455         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 456         struct security_priv *psecuritypriv = &padapter->securitypriv;
 457         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
 458         struct ht_priv *phtpriv_ap = &pmlmepriv->htpriv;
 459         struct ht_priv *phtpriv_sta = &psta->htpriv;
 460         u8 cur_ldpc_cap = 0, cur_stbc_cap = 0, cur_beamform_cap = 0;
 461         /* set intf_tag to if1 */
 462         /* psta->intf_tag = 0; */
 463
 464         /* psta->mac_id = psta->aid+4; */
 465         /* psta->mac_id = psta->aid+1;//alloc macid when call rtw_alloc_stainfo(), */
 466         /* release macid when call rtw_free_stainfo() */
 467
 468         /* ap mode */
 469         rtw_hal_set_odm_var(padapter, HAL_ODM_STA_INFO, psta, true);
 470
 471         if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
 472                 psta->ieee8021x_blocked = true;
 473         else
 474                 psta->ieee8021x_blocked = false;
 475
 476         /* update sta's cap */
 477
 478         /* ERP */
 479         VCS_update(padapter, psta);
 480
 481         /* HT related cap */
 482         if (phtpriv_sta->ht_option) {
 483                 /* check if sta supports rx ampdu */
 484                 phtpriv_sta->ampdu_enable = phtpriv_ap->ampdu_enable;
 485
 486                 phtpriv_sta->rx_ampdu_min_spacing = (
 487                         phtpriv_sta->ht_cap.ampdu_params_info & IEEE80211_HT_CAP_AMPDU_DENSITY
 488                 ) >> 2;
 489
 490                 /*  bwmode */
 491                 if ((
 492                         phtpriv_sta->ht_cap.cap_info & phtpriv_ap->ht_cap.cap_info
 493                 ) & cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH))
 494                         psta->bw_mode = CHANNEL_WIDTH_40;
 495                 else
 496                         psta->bw_mode = CHANNEL_WIDTH_20;
 497
 498                 if (pmlmeext->cur_bwmode < psta->bw_mode)
 499                         psta->bw_mode = pmlmeext->cur_bwmode;
 500
 501                 phtpriv_sta->ch_offset = pmlmeext->cur_ch_offset;
 502
 503                 /* check if sta support s Short GI 20M */
 504                 if ((
 505                         phtpriv_sta->ht_cap.cap_info & phtpriv_ap->ht_cap.cap_info
 506                 ) & cpu_to_le16(IEEE80211_HT_CAP_SGI_20))
 507                         phtpriv_sta->sgi_20m = true;
 508
 509                 /* check if sta support s Short GI 40M */
 510                 if ((
 511                         phtpriv_sta->ht_cap.cap_info & phtpriv_ap->ht_cap.cap_info
 512                 ) & cpu_to_le16(IEEE80211_HT_CAP_SGI_40)) {
 513                         if (psta->bw_mode == CHANNEL_WIDTH_40) /* according to psta->bw_mode */
 514                                 phtpriv_sta->sgi_40m = true;
 515                         else
 516                                 phtpriv_sta->sgi_40m = false;
 517                 }
 518
 519                 psta->qos_option = true;
 520
 521                 /*  B0 Config LDPC Coding Capability */
 522                 if (TEST_FLAG(phtpriv_ap->ldpc_cap, LDPC_HT_ENABLE_TX) &&
 523                               GET_HT_CAPABILITY_ELE_LDPC_CAP((u8 *)(&phtpriv_sta->ht_cap)))
 524                         SET_FLAG(cur_ldpc_cap, (LDPC_HT_ENABLE_TX | LDPC_HT_CAP_TX));
 525
 526                 /*  B7 B8 B9 Config STBC setting */
 527                 if (TEST_FLAG(phtpriv_ap->stbc_cap, STBC_HT_ENABLE_TX) &&
 528                               GET_HT_CAPABILITY_ELE_RX_STBC((u8 *)(&phtpriv_sta->ht_cap)))
 529                         SET_FLAG(cur_stbc_cap, (STBC_HT_ENABLE_TX | STBC_HT_CAP_TX));
 530         } else {
 531                 phtpriv_sta->ampdu_enable = false;
 532
 533                 phtpriv_sta->sgi_20m = false;
 534                 phtpriv_sta->sgi_40m = false;
 535                 psta->bw_mode = CHANNEL_WIDTH_20;
 536                 phtpriv_sta->ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
 537         }
 538
 539         phtpriv_sta->ldpc_cap = cur_ldpc_cap;
 540         phtpriv_sta->stbc_cap = cur_stbc_cap;
 541         phtpriv_sta->beamform_cap = cur_beamform_cap;
 542
 543         /* Rx AMPDU */
 544         send_delba(padapter, 0, psta->hwaddr);/*  recipient */
 545
 546         /* TX AMPDU */
 547         send_delba(padapter, 1, psta->hwaddr);/* originator */
 548         phtpriv_sta->agg_enable_bitmap = 0x0;/* reset */
 549         phtpriv_sta->candidate_tid_bitmap = 0x0;/* reset */
 550
 551         update_ldpc_stbc_cap(psta);
 552
 553         /* todo: init other variables */
 554
 555         memset((void *)&psta->sta_stats, 0, sizeof(struct stainfo_stats));
 556
 557         /* add ratid */
 558         /* add_RATid(padapter, psta);//move to ap_sta_info_defer_update() */
 559
 560         spin_lock_bh(&psta->lock);
 561         psta->state |= _FW_LINKED;
 562         spin_unlock_bh(&psta->lock);
 563 }
 564
 565 static void update_ap_info(struct adapter *padapter, struct sta_info *psta)
 566 {
 567         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 568         struct wlan_bssid_ex
 569                 *pnetwork = (struct wlan_bssid_ex *)&pmlmepriv->cur_network.network;
 570         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
 571         struct ht_priv *phtpriv_ap = &pmlmepriv->htpriv;
 572
 573         psta->wireless_mode = pmlmeext->cur_wireless_mode;
 574
 575         psta->bssratelen = rtw_get_rateset_len(pnetwork->SupportedRates);
 576         memcpy(psta->bssrateset, pnetwork->SupportedRates, psta->bssratelen);
 577
 578         /* HT related cap */
 579         if (phtpriv_ap->ht_option) {
 580                 /* check if sta supports rx ampdu */
 581                 /* phtpriv_ap->ampdu_enable = phtpriv_ap->ampdu_enable; */
 582
 583                 /* check if sta support s Short GI 20M */
 584                 if ((phtpriv_ap->ht_cap.cap_info) & cpu_to_le16(IEEE80211_HT_CAP_SGI_20))
 585                         phtpriv_ap->sgi_20m = true;
 586
 587                 /* check if sta support s Short GI 40M */
 588                 if ((phtpriv_ap->ht_cap.cap_info) & cpu_to_le16(IEEE80211_HT_CAP_SGI_40))
 589                         phtpriv_ap->sgi_40m = true;
 590
 591                 psta->qos_option = true;
 592         } else {
 593                 phtpriv_ap->ampdu_enable = false;
 594
 595                 phtpriv_ap->sgi_20m = false;
 596                 phtpriv_ap->sgi_40m = false;
 597         }
 598
 599         psta->bw_mode = pmlmeext->cur_bwmode;
 600         phtpriv_ap->ch_offset = pmlmeext->cur_ch_offset;
 601
 602         phtpriv_ap->agg_enable_bitmap = 0x0;/* reset */
 603         phtpriv_ap->candidate_tid_bitmap = 0x0;/* reset */
 604
 605         memcpy(&psta->htpriv, &pmlmepriv->htpriv, sizeof(struct ht_priv));
 606 }
 607
 608 static void update_hw_ht_param(struct adapter *padapter)
 609 {
 610         unsigned char max_AMPDU_len;
 611         unsigned char min_MPDU_spacing;
 612         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 613         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
 614
 615         /* handle A-MPDU parameter field
 616          *
 617          *      AMPDU_para [1:0]:Max AMPDU Len => 0:8k , 1:16k, 2:32k, 3:64k
 618          *      AMPDU_para [4:2]:Min MPDU Start Spacing
 619          */
 620         max_AMPDU_len = pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x03;
 621
 622         min_MPDU_spacing = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c) >> 2;
 623
 624         rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_MIN_SPACE, (u8 *)(&min_MPDU_spacing));
 625
 626         rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_FACTOR, (u8 *)(&max_AMPDU_len));
 627
 628         /*  */
 629         /*  Config SM Power Save setting */
 630         /*  */
 631         pmlmeinfo->SM_PS = (le16_to_cpu(
 632                 pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info
 633         ) & 0x0C) >> 2;
 634
 635         /*  */
 636         /*  Config current HT Protection mode. */
 637         /*  */
 638         /* pmlmeinfo->HT_protection = pmlmeinfo->HT_info.infos[1] & 0x3; */
 639 }
 640
 641 void start_bss_network(struct adapter *padapter)
 642 {
 643         u8 *p;
 644         u8 val8, cur_channel, cur_bwmode, cur_ch_offset;
 645         u16 bcn_interval;
 646         u32 acparm;
 647         int     ie_len;
 648         struct registry_priv  *pregpriv = &padapter->registrypriv;
 649         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 650         struct security_priv *psecuritypriv = &(padapter->securitypriv);
 651         struct wlan_bssid_ex
 652                 *pnetwork = (struct wlan_bssid_ex *)&pmlmepriv->cur_network.network;
 653         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
 654         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
 655         struct wlan_bssid_ex *pnetwork_mlmeext = &(pmlmeinfo->network);
 656         struct HT_info_element *pht_info = NULL;
 657         u8 cbw40_enable = 0;
 658
 659         bcn_interval = (u16)pnetwork->Configuration.BeaconPeriod;
 660         cur_channel = pnetwork->Configuration.DSConfig;
 661         cur_bwmode = CHANNEL_WIDTH_20;
 662         cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
 663
 664         /* check if there is wps ie, */
 665         /* if there is wpsie in beacon, the hostapd will update beacon twice when stating hostapd, */
 666         /* and at first time the security ie (RSN/WPA IE) will not include in beacon. */
 667         if (!rtw_get_wps_ie(pnetwork->IEs + _FIXED_IE_LENGTH_,
 668                             pnetwork->IELength - _FIXED_IE_LENGTH_, NULL, NULL))
 669                 pmlmeext->bstart_bss = true;
 670
 671         /* todo: update wmm, ht cap */
 672         /* pmlmeinfo->WMM_enable; */
 673         /* pmlmeinfo->HT_enable; */
 674         if (pmlmepriv->qospriv.qos_option)
 675                 pmlmeinfo->WMM_enable = true;
 676         if (pmlmepriv->htpriv.ht_option) {
 677                 pmlmeinfo->WMM_enable = true;
 678                 pmlmeinfo->HT_enable = true;
 679                 /* pmlmeinfo->HT_info_enable = true; */
 680                 /* pmlmeinfo->HT_caps_enable = true; */
 681
 682                 update_hw_ht_param(padapter);
 683         }
 684
 685         if (!pmlmepriv->cur_network.join_res) { /* setting only at  first time */
 686
 687                 /* WEP Key will be set before this function, do not clear CAM. */
 688                 if ((psecuritypriv->dot11PrivacyAlgrthm != _WEP40_) &&
 689                     (psecuritypriv->dot11PrivacyAlgrthm != _WEP104_))
 690                         flush_all_cam_entry(padapter);  /* clear CAM */
 691         }
 692
 693         /* set MSR to AP_Mode */
 694         Set_MSR(padapter, _HW_STATE_AP_);
 695
 696         /* Set BSSID REG */
 697         rtw_hal_set_hwreg(padapter, HW_VAR_BSSID, pnetwork->MacAddress);
 698
 699         /* Set EDCA param reg */
 700         acparm = 0x002F3217; /*  VO */
 701         rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_VO, (u8 *)(&acparm));
 702         acparm = 0x005E4317; /*  VI */
 703         rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_VI, (u8 *)(&acparm));
 704         /* acparm = 0x00105320; // BE */
 705         acparm = 0x005ea42b;
 706         rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_BE, (u8 *)(&acparm));
 707         acparm = 0x0000A444; /*  BK */
 708         rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_BK, (u8 *)(&acparm));
 709
 710         /* Set Security */
 711         val8 = (
 712                 psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X
 713         ) ? 0xcc : 0xcf;
 714         rtw_hal_set_hwreg(padapter, HW_VAR_SEC_CFG, (u8 *)(&val8));
 715
 716         /* Beacon Control related register */
 717         rtw_hal_set_hwreg(padapter, HW_VAR_BEACON_INTERVAL, (u8 *)(&bcn_interval));
 718
 719         rtw_hal_set_hwreg(padapter, HW_VAR_DO_IQK, NULL);
 720
 721         if (!pmlmepriv->cur_network.join_res) { /* setting only at  first time */
 722                 /* u32 initialgain; */
 723
 724                 /* initialgain = 0x1e; */
 725
 726                 /* disable dynamic functions, such as high power, DIG */
 727                 /* Save_DM_Func_Flag(padapter); */
 728                 /* Switch_DM_Func(padapter, DYNAMIC_FUNC_DISABLE, false); */
 729
 730                 /* turn on all dynamic functions */
 731                 Switch_DM_Func(padapter, DYNAMIC_ALL_FUNC_ENABLE, true);
 732
 733                 /* rtw_hal_set_hwreg(padapter, HW_VAR_INITIAL_GAIN, (u8 *)(&initialgain)); */
 734         }
 735
 736         /* set channel, bwmode */
 737         p = rtw_get_ie((pnetwork->IEs + sizeof(struct ndis_802_11_fix_ie)),
 738                        WLAN_EID_HT_OPERATION,
 739                        &ie_len,
 740                        (pnetwork->IELength - sizeof(struct ndis_802_11_fix_ie))
 741         );
 742         if (p && ie_len) {
 743                 pht_info = (struct HT_info_element *)(p + 2);
 744
 745                 if (cur_channel > 14) {
 746                         if ((pregpriv->bw_mode & 0xf0) > 0)
 747                                 cbw40_enable = 1;
 748                 } else {
 749                         if ((pregpriv->bw_mode & 0x0f) > 0)
 750                                 cbw40_enable = 1;
 751                 }
 752
 753                 if ((cbw40_enable) &&    (pht_info->infos[0] & BIT(2))) {
 754                         /* switch to the 40M Hz mode */
 755                         /* pmlmeext->cur_bwmode = CHANNEL_WIDTH_40; */
 756                         cur_bwmode = CHANNEL_WIDTH_40;
 757                         switch (pht_info->infos[0] & 0x3) {
 758                         case 1:
 759                                 /* pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER; */
 760                                 cur_ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER;
 761                                 break;
 762
 763                         case 3:
 764                                 /* pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER; */
 765                                 cur_ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER;
 766                                 break;
 767
 768                         default:
 769                                 /* pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE; */
 770                                 cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
 771                                 break;
 772                         }
 773                 }
 774         }
 775
 776         set_channel_bwmode(padapter, cur_channel, cur_ch_offset, cur_bwmode);
 777         pmlmeext->cur_channel = cur_channel;
 778         pmlmeext->cur_bwmode = cur_bwmode;
 779         pmlmeext->cur_ch_offset = cur_ch_offset;
 780         pmlmeext->cur_wireless_mode = pmlmepriv->cur_network.network_type;
 781
 782         /* let pnetwork_mlmeext == pnetwork_mlme. */
 783         memcpy(pnetwork_mlmeext, pnetwork, pnetwork->Length);
 784
 785         /* update cur_wireless_mode */
 786         update_wireless_mode(padapter);
 787
 788         /* update RRSR after set channel and bandwidth */
 789         UpdateBrateTbl(padapter, pnetwork->SupportedRates);
 790         rtw_hal_set_hwreg(padapter, HW_VAR_BASIC_RATE, pnetwork->SupportedRates);
 791
 792         /* update capability after cur_wireless_mode updated */
 793         update_capinfo(
 794                 padapter,
 795                 rtw_get_capability((struct wlan_bssid_ex *)pnetwork)
 796         );
 797
 798         if (pmlmeext->bstart_bss) {
 799                 update_beacon(padapter, WLAN_EID_TIM, NULL, true);
 800
 801                 /* issue beacon frame */
 802                 send_beacon(padapter);
 803         }
 804
 805         /* update bc/mc sta_info */
 806         update_bmc_sta(padapter);
 807
 808         /* pmlmeext->bstart_bss = true; */
 809 }
 810
 811 int rtw_check_beacon_data(struct adapter *padapter, u8 *pbuf,  int len)
 812 {
 813         int ret = _SUCCESS;
 814         u8 *p;
 815         u8 *pHT_caps_ie = NULL;
 816         u8 *pHT_info_ie = NULL;
 817         struct sta_info *psta = NULL;
 818         u16 cap, ht_cap = false;
 819         uint ie_len = 0;
 820         int group_cipher, pairwise_cipher;
 821         u8 channel, network_type, supportRate[NDIS_802_11_LENGTH_RATES_EX];
 822         int supportRateNum = 0;
 823         u8 OUI1[] = {0x00, 0x50, 0xf2, 0x01};
 824         u8 WMM_PARA_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x01, 0x01};
 825         struct registry_priv *pregistrypriv = &padapter->registrypriv;
 826         struct security_priv *psecuritypriv = &padapter->securitypriv;
 827         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 828         struct wlan_bssid_ex
 829                 *pbss_network = (struct wlan_bssid_ex *)&pmlmepriv->cur_network.network;
 830         u8 *ie = pbss_network->IEs;
 831
 832         if (!check_fwstate(pmlmepriv, WIFI_AP_STATE))
 833                 return _FAIL;
 834
 835         if (len < 0 || len > MAX_IE_SZ)
 836                 return _FAIL;
 837
 838         pbss_network->IELength = len;
 839
 840         memset(ie, 0, MAX_IE_SZ);
 841
 842         memcpy(ie, pbuf, pbss_network->IELength);
 843
 844         if (pbss_network->InfrastructureMode != Ndis802_11APMode)
 845                 return _FAIL;
 846
 847         pbss_network->Rssi = 0;
 848
 849         memcpy(pbss_network->MacAddress, myid(&(padapter->eeprompriv)), ETH_ALEN);
 850
 851         /* beacon interval */
 852         p = rtw_get_beacon_interval_from_ie(ie);/* ie + 8;      8: TimeStamp, 2: Beacon Interval 2:Capability */
 853         /* pbss_network->Configuration.BeaconPeriod = le16_to_cpu(*(unsigned short*)p); */
 854         pbss_network->Configuration.BeaconPeriod = get_unaligned_le16(p);
 855
 856         /* capability */
 857         /* cap = *(unsigned short *)rtw_get_capability_from_ie(ie); */
 858         /* cap = le16_to_cpu(cap); */
 859         cap = get_unaligned_le16(ie);
 860
 861         /* SSID */
 862         p = rtw_get_ie(
 863                 ie + _BEACON_IE_OFFSET_,
 864                 WLAN_EID_SSID,
 865                 &ie_len,
 866                 (pbss_network->IELength - _BEACON_IE_OFFSET_)
 867         );
 868         if (p && ie_len > 0) {
 869                 memset(&pbss_network->Ssid, 0, sizeof(struct ndis_802_11_ssid));
 870                 memcpy(pbss_network->Ssid.Ssid, (p + 2), ie_len);
 871                 pbss_network->Ssid.SsidLength = ie_len;
 872         }
 873
 874         /* channel */
 875         channel = 0;
 876         pbss_network->Configuration.Length = 0;
 877         p = rtw_get_ie(
 878                 ie + _BEACON_IE_OFFSET_,
 879                 WLAN_EID_DS_PARAMS, &ie_len,
 880                 (pbss_network->IELength - _BEACON_IE_OFFSET_)
 881         );
 882         if (p && ie_len > 0)
 883                 channel = *(p + 2);
 884
 885         pbss_network->Configuration.DSConfig = channel;
 886
 887         memset(supportRate, 0, NDIS_802_11_LENGTH_RATES_EX);
 888         /*  get supported rates */
 889         p = rtw_get_ie(
 890                 ie + _BEACON_IE_OFFSET_,
 891                 WLAN_EID_SUPP_RATES,
 892                 &ie_len,
 893                 (pbss_network->IELength - _BEACON_IE_OFFSET_)
 894         );
 895         if (p !=  NULL) {
 896                 memcpy(supportRate, p + 2, ie_len);
 897                 supportRateNum = ie_len;
 898         }
 899
 900         /* get ext_supported rates */
 901         p = rtw_get_ie(
 902                 ie + _BEACON_IE_OFFSET_,
 903                 WLAN_EID_EXT_SUPP_RATES,
 904                 &ie_len,
 905                 pbss_network->IELength - _BEACON_IE_OFFSET_
 906         );
 907         if (p !=  NULL) {
 908                 memcpy(supportRate + supportRateNum, p + 2, ie_len);
 909                 supportRateNum += ie_len;
 910         }
 911
 912         network_type = rtw_check_network_type(supportRate, supportRateNum, channel);
 913
 914         rtw_set_supported_rate(pbss_network->SupportedRates, network_type);
 915
 916         /* parsing ERP_IE */
 917         p = rtw_get_ie(
 918                 ie + _BEACON_IE_OFFSET_,
 919                 WLAN_EID_ERP_INFO,
 920                 &ie_len,
 921                 (pbss_network->IELength - _BEACON_IE_OFFSET_)
 922         );
 923         if (p && ie_len > 0)
 924                 ERP_IE_handler(padapter, (struct ndis_80211_var_ie *)p);
 925
 926         /* update privacy/security */
 927         if (cap & BIT(4))
 928                 pbss_network->Privacy = 1;
 929         else
 930                 pbss_network->Privacy = 0;
 931
 932         psecuritypriv->wpa_psk = 0;
 933
 934         /* wpa2 */
 935         group_cipher = 0; pairwise_cipher = 0;
 936         psecuritypriv->wpa2_group_cipher = _NO_PRIVACY_;
 937         psecuritypriv->wpa2_pairwise_cipher = _NO_PRIVACY_;
 938         p = rtw_get_ie(
 939                 ie + _BEACON_IE_OFFSET_,
 940                 WLAN_EID_RSN,
 941                 &ie_len,
 942                 (pbss_network->IELength - _BEACON_IE_OFFSET_)
 943         );
 944         if (p && ie_len > 0) {
 945                 if (rtw_parse_wpa2_ie(
 946                         p,
 947                         ie_len + 2,
 948                         &group_cipher,
 949                         &pairwise_cipher,
 950                         NULL
 951                 ) == _SUCCESS) {
 952                         psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
 953
 954                         psecuritypriv->dot8021xalg = 1;/* psk,  todo:802.1x */
 955                         psecuritypriv->wpa_psk |= BIT(1);
 956
 957                         psecuritypriv->wpa2_group_cipher = group_cipher;
 958                         psecuritypriv->wpa2_pairwise_cipher = pairwise_cipher;
 959                 }
 960         }
 961
 962         /* wpa */
 963         ie_len = 0;
 964         group_cipher = 0; pairwise_cipher = 0;
 965         psecuritypriv->wpa_group_cipher = _NO_PRIVACY_;
 966         psecuritypriv->wpa_pairwise_cipher = _NO_PRIVACY_;
 967         for (p = ie + _BEACON_IE_OFFSET_; ; p += (ie_len + 2)) {
 968                 p = rtw_get_ie(
 969                         p,
 970                         WLAN_EID_VENDOR_SPECIFIC,
 971                         &ie_len,
 972                         (pbss_network->IELength - _BEACON_IE_OFFSET_ - (ie_len + 2))
 973                 );
 974                 if ((p) && (!memcmp(p + 2, OUI1, 4))) {
 975                         if (rtw_parse_wpa_ie(
 976                                 p,
 977                                 ie_len + 2,
 978                                 &group_cipher,
 979                                 &pairwise_cipher,
 980                                 NULL
 981                         ) == _SUCCESS) {
 982                                 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
 983
 984                                 psecuritypriv->dot8021xalg = 1;/* psk,  todo:802.1x */
 985
 986                                 psecuritypriv->wpa_psk |= BIT(0);
 987
 988                                 psecuritypriv->wpa_group_cipher = group_cipher;
 989                                 psecuritypriv->wpa_pairwise_cipher = pairwise_cipher;
 990                         }
 991
 992                         break;
 993                 }
 994
 995                 if ((p == NULL) || (ie_len == 0))
 996                         break;
 997         }
 998
 999         /* wmm */
1000         ie_len = 0;
1001         pmlmepriv->qospriv.qos_option = 0;
1002         if (pregistrypriv->wmm_enable) {
1003                 for (p = ie + _BEACON_IE_OFFSET_; ; p += (ie_len + 2)) {
1004                         p = rtw_get_ie(
1005                                 p,
1006                                 WLAN_EID_VENDOR_SPECIFIC,
1007                                 &ie_len,
1008                                 (pbss_network->IELength - _BEACON_IE_OFFSET_ - (ie_len + 2))
1009                         );
1010                         if ((p) && !memcmp(p + 2, WMM_PARA_IE, 6)) {
1011                                 pmlmepriv->qospriv.qos_option = 1;
1012
1013                                 *(p + 8) |= BIT(7);/* QoS Info, support U-APSD */
1014
1015                                 /* disable all ACM bits since the WMM admission */
1016                                 /* control is not supported */
1017                                 *(p + 10) &= ~BIT(4); /* BE */
1018                                 *(p + 14) &= ~BIT(4); /* BK */
1019                                 *(p + 18) &= ~BIT(4); /* VI */
1020                                 *(p + 22) &= ~BIT(4); /* VO */
1021
1022                                 break;
1023                         }
1024
1025                         if ((p == NULL) || (ie_len == 0))
1026                                 break;
1027                 }
1028         }
1029
1030         /* parsing HT_CAP_IE */
1031         p = rtw_get_ie(
1032                 ie + _BEACON_IE_OFFSET_,
1033                 WLAN_EID_HT_CAPABILITY,
1034                 &ie_len,
1035                 (pbss_network->IELength - _BEACON_IE_OFFSET_)
1036         );
1037         if (p && ie_len > 0) {
1038                 u8 rf_type = 0;
1039                 u8 max_rx_ampdu_factor = 0;
1040                 struct ieee80211_ht_cap *pht_cap = (struct ieee80211_ht_cap *)(p + 2);
1041
1042                 pHT_caps_ie = p;
1043
1044                 ht_cap = true;
1045                 network_type |= WIRELESS_11_24N;
1046
1047                 rtw_ht_use_default_setting(padapter);
1048
1049                 if (pmlmepriv->htpriv.sgi_20m == false)
1050                         pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_SGI_20));
1051
1052                 if (pmlmepriv->htpriv.sgi_40m == false)
1053                         pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_SGI_40));
1054
1055                 if (!TEST_FLAG(pmlmepriv->htpriv.ldpc_cap, LDPC_HT_ENABLE_RX))
1056                         pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_LDPC_CODING));
1057
1058                 if (!TEST_FLAG(pmlmepriv->htpriv.stbc_cap, STBC_HT_ENABLE_TX))
1059                         pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_TX_STBC));
1060
1061                 if (!TEST_FLAG(pmlmepriv->htpriv.stbc_cap, STBC_HT_ENABLE_RX))
1062                         pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_RX_STBC_3R));
1063
1064                 pht_cap->ampdu_params_info &= ~(
1065                         IEEE80211_HT_CAP_AMPDU_FACTOR | IEEE80211_HT_CAP_AMPDU_DENSITY
1066                 );
1067
1068                 if ((psecuritypriv->wpa_pairwise_cipher & WPA_CIPHER_CCMP) ||
1069                      (psecuritypriv->wpa2_pairwise_cipher & WPA_CIPHER_CCMP)) {
1070                         pht_cap->ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY & (0x07 << 2));
1071                 } else {
1072                         pht_cap->ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY & 0x00);
1073                 }
1074
1075                 rtw_hal_get_def_var(
1076                         padapter,
1077                         HW_VAR_MAX_RX_AMPDU_FACTOR,
1078                         &max_rx_ampdu_factor
1079                 );
1080                 pht_cap->ampdu_params_info |= (
1081                         IEEE80211_HT_CAP_AMPDU_FACTOR & max_rx_ampdu_factor
1082                 ); /* set  Max Rx AMPDU size  to 64K */
1083
1084                 rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
1085                 if (rf_type == RF_1T1R) {
1086                         pht_cap->mcs.rx_mask[0] = 0xff;
1087                         pht_cap->mcs.rx_mask[1] = 0x0;
1088                 }
1089
1090                 memcpy(&pmlmepriv->htpriv.ht_cap, p + 2, ie_len);
1091         }
1092
1093         /* parsing HT_INFO_IE */
1094         p = rtw_get_ie(
1095                 ie + _BEACON_IE_OFFSET_,
1096                 WLAN_EID_HT_OPERATION,
1097                 &ie_len,
1098                 (pbss_network->IELength - _BEACON_IE_OFFSET_)
1099         );
1100         if (p && ie_len > 0)
1101                 pHT_info_ie = p;
1102
1103         switch (network_type) {
1104         case WIRELESS_11B:
1105                 pbss_network->NetworkTypeInUse = Ndis802_11DS;
1106                 break;
1107         case WIRELESS_11G:
1108         case WIRELESS_11BG:
1109         case WIRELESS_11G_24N:
1110         case WIRELESS_11BG_24N:
1111                 pbss_network->NetworkTypeInUse = Ndis802_11OFDM24;
1112                 break;
1113         default:
1114                 pbss_network->NetworkTypeInUse = Ndis802_11OFDM24;
1115                 break;
1116         }
1117
1118         pmlmepriv->cur_network.network_type = network_type;
1119
1120         pmlmepriv->htpriv.ht_option = false;
1121
1122         if ((psecuritypriv->wpa2_pairwise_cipher & WPA_CIPHER_TKIP) ||
1123              (psecuritypriv->wpa_pairwise_cipher & WPA_CIPHER_TKIP)) {
1124                 /* todo: */
1125                 /* ht_cap = false; */
1126         }
1127
1128         /* ht_cap */
1129         if (pregistrypriv->ht_enable && ht_cap) {
1130                 pmlmepriv->htpriv.ht_option = true;
1131                 pmlmepriv->qospriv.qos_option = 1;
1132
1133                 if (pregistrypriv->ampdu_enable == 1)
1134                         pmlmepriv->htpriv.ampdu_enable = true;
1135
1136                 HT_caps_handler(padapter, (struct ndis_80211_var_ie *)pHT_caps_ie);
1137
1138                 HT_info_handler(padapter, (struct ndis_80211_var_ie *)pHT_info_ie);
1139         }
1140
1141         pbss_network->Length = get_wlan_bssid_ex_sz(
1142                 (struct wlan_bssid_ex  *)pbss_network
1143         );
1144
1145         /* issue beacon to start bss network */
1146         /* start_bss_network(padapter, (u8 *)pbss_network); */
1147         rtw_startbss_cmd(padapter, RTW_CMDF_WAIT_ACK);
1148
1149         /* alloc sta_info for ap itself */
1150         psta = rtw_get_stainfo(&padapter->stapriv, pbss_network->MacAddress);
1151         if (!psta) {
1152                 psta = rtw_alloc_stainfo(&padapter->stapriv, pbss_network->MacAddress);
1153                 if (psta == NULL)
1154                         return _FAIL;
1155         }
1156
1157         /*  update AP's sta info */
1158         update_ap_info(padapter, psta);
1159
1160         psta->state |= WIFI_AP_STATE;           /* Aries, add, fix bug of flush_cam_entry at STOP AP mode , 0724 */
1161         rtw_indicate_connect(padapter);
1162
1163         pmlmepriv->cur_network.join_res = true;/* for check if already set beacon */
1164
1165         /* update bc/mc sta_info */
1166         /* update_bmc_sta(padapter); */
1167
1168         return ret;
1169 }
1170
1171 void rtw_set_macaddr_acl(struct adapter *padapter, int mode)
1172 {
1173         struct sta_priv *pstapriv = &padapter->stapriv;
1174         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
1175
1176         pacl_list->mode = mode;
1177 }
1178
1179 int rtw_acl_add_sta(struct adapter *padapter, u8 *addr)
1180 {
1181         struct list_head        *plist, *phead;
1182         u8 added = false;
1183         int i, ret = 0;
1184         struct rtw_wlan_acl_node *paclnode;
1185         struct sta_priv *pstapriv = &padapter->stapriv;
1186         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
1187         struct __queue  *pacl_node_q = &pacl_list->acl_node_q;
1188
1189         if ((NUM_ACL - 1) < pacl_list->num)
1190                 return (-1);
1191
1192         spin_lock_bh(&(pacl_node_q->lock));
1193
1194         phead = get_list_head(pacl_node_q);
1195         list_for_each(plist, phead) {
1196                 paclnode = list_entry(plist, struct rtw_wlan_acl_node, list);
1197
1198                 if (!memcmp(paclnode->addr, addr, ETH_ALEN)) {
1199                         if (paclnode->valid == true) {
1200                                 added = true;
1201                                 break;
1202                         }
1203                 }
1204         }
1205
1206         spin_unlock_bh(&(pacl_node_q->lock));
1207
1208         if (added)
1209                 return ret;
1210
1211         spin_lock_bh(&(pacl_node_q->lock));
1212
1213         for (i = 0; i < NUM_ACL; i++) {
1214                 paclnode = &pacl_list->aclnode[i];
1215
1216                 if (!paclnode->valid) {
1217                         INIT_LIST_HEAD(&paclnode->list);
1218
1219                         memcpy(paclnode->addr, addr, ETH_ALEN);
1220
1221                         paclnode->valid = true;
1222
1223                         list_add_tail(&paclnode->list, get_list_head(pacl_node_q));
1224
1225                         pacl_list->num++;
1226
1227                         break;
1228                 }
1229         }
1230
1231         spin_unlock_bh(&(pacl_node_q->lock));
1232
1233         return ret;
1234 }
1235
1236 void rtw_acl_remove_sta(struct adapter *padapter, u8 *addr)
1237 {
1238         struct list_head *plist, *phead, *tmp;
1239         struct rtw_wlan_acl_node *paclnode;
1240         struct sta_priv *pstapriv = &padapter->stapriv;
1241         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
1242         struct __queue  *pacl_node_q = &pacl_list->acl_node_q;
1243         u8 baddr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };    /* Baddr is used for clearing acl_list */
1244
1245         spin_lock_bh(&(pacl_node_q->lock));
1246
1247         phead = get_list_head(pacl_node_q);
1248         list_for_each_safe(plist, tmp, phead) {
1249                 paclnode = list_entry(plist, struct rtw_wlan_acl_node, list);
1250
1251                 if (
1252                         !memcmp(paclnode->addr, addr, ETH_ALEN) ||
1253                         !memcmp(baddr, addr, ETH_ALEN)
1254                 ) {
1255                         if (paclnode->valid) {
1256                                 paclnode->valid = false;
1257
1258                                 list_del_init(&paclnode->list);
1259
1260                                 pacl_list->num--;
1261                         }
1262                 }
1263         }
1264
1265         spin_unlock_bh(&(pacl_node_q->lock));
1266
1267 }
1268
1269 u8 rtw_ap_set_pairwise_key(struct adapter *padapter, struct sta_info *psta)
1270 {
1271         struct cmd_obj *ph2c;
1272         struct set_stakey_parm  *psetstakey_para;
1273         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1274         u8 res = _SUCCESS;
1275
1276         ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
1277         if (!ph2c) {
1278                 res = _FAIL;
1279                 goto exit;
1280         }
1281
1282         psetstakey_para = rtw_zmalloc(sizeof(struct set_stakey_parm));
1283         if (psetstakey_para == NULL) {
1284                 kfree(ph2c);
1285                 res = _FAIL;
1286                 goto exit;
1287         }
1288
1289         init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
1290
1291         psetstakey_para->algorithm = (u8)psta->dot118021XPrivacy;
1292
1293         memcpy(psetstakey_para->addr, psta->hwaddr, ETH_ALEN);
1294
1295         memcpy(psetstakey_para->key, &psta->dot118021x_UncstKey, 16);
1296
1297         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1298
1299 exit:
1300
1301         return res;
1302 }
1303
1304 static int rtw_ap_set_key(
1305         struct adapter *padapter,
1306         u8 *key,
1307         u8 alg,
1308         int keyid,
1309         u8 set_tx
1310 )
1311 {
1312         u8 keylen;
1313         struct cmd_obj *pcmd;
1314         struct setkey_parm *psetkeyparm;
1315         struct cmd_priv *pcmdpriv = &(padapter->cmdpriv);
1316         int res = _SUCCESS;
1317
1318         pcmd = rtw_zmalloc(sizeof(struct cmd_obj));
1319         if (pcmd == NULL) {
1320                 res = _FAIL;
1321                 goto exit;
1322         }
1323         psetkeyparm = rtw_zmalloc(sizeof(struct setkey_parm));
1324         if (psetkeyparm == NULL) {
1325                 kfree(pcmd);
1326                 res = _FAIL;
1327                 goto exit;
1328         }
1329
1330         psetkeyparm->keyid = (u8)keyid;
1331         if (is_wep_enc(alg))
1332                 padapter->securitypriv.key_mask |= BIT(psetkeyparm->keyid);
1333
1334         psetkeyparm->algorithm = alg;
1335
1336         psetkeyparm->set_tx = set_tx;
1337
1338         switch (alg) {
1339         case _WEP40_:
1340                 keylen = 5;
1341                 break;
1342         case _WEP104_:
1343                 keylen = 13;
1344                 break;
1345         case _TKIP_:
1346         case _TKIP_WTMIC_:
1347         case _AES_:
1348         default:
1349                 keylen = 16;
1350         }
1351
1352         memcpy(&(psetkeyparm->key[0]), key, keylen);
1353
1354         pcmd->cmdcode = _SetKey_CMD_;
1355         pcmd->parmbuf = (u8 *)psetkeyparm;
1356         pcmd->cmdsz =  (sizeof(struct setkey_parm));
1357         pcmd->rsp = NULL;
1358         pcmd->rspsz = 0;
1359
1360         INIT_LIST_HEAD(&pcmd->list);
1361
1362         res = rtw_enqueue_cmd(pcmdpriv, pcmd);
1363
1364 exit:
1365
1366         return res;
1367 }
1368
1369 int rtw_ap_set_group_key(struct adapter *padapter, u8 *key, u8 alg, int keyid)
1370 {
1371         return rtw_ap_set_key(padapter, key, alg, keyid, 1);
1372 }
1373
1374 int rtw_ap_set_wep_key(
1375         struct adapter *padapter,
1376         u8 *key,
1377         u8 keylen,
1378         int keyid,
1379         u8 set_tx
1380 )
1381 {
1382         u8 alg;
1383
1384         switch (keylen) {
1385         case 5:
1386                 alg = _WEP40_;
1387                 break;
1388         case 13:
1389                 alg = _WEP104_;
1390                 break;
1391         default:
1392                 alg = _NO_PRIVACY_;
1393         }
1394
1395         return rtw_ap_set_key(padapter, key, alg, keyid, set_tx);
1396 }
1397
1398 static void update_bcn_fixed_ie(struct adapter *padapter)
1399 {
1400 }
1401
1402 static void update_bcn_erpinfo_ie(struct adapter *padapter)
1403 {
1404         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1405         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1406         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1407         struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
1408         unsigned char *p, *ie = pnetwork->IEs;
1409         u32 len = 0;
1410
1411         if (!pmlmeinfo->ERP_enable)
1412                 return;
1413
1414         /* parsing ERP_IE */
1415         p = rtw_get_ie(
1416                 ie + _BEACON_IE_OFFSET_,
1417                 WLAN_EID_ERP_INFO,
1418                 &len,
1419                 (pnetwork->IELength - _BEACON_IE_OFFSET_)
1420         );
1421         if (p && len > 0) {
1422                 struct ndis_80211_var_ie *pIE = (struct ndis_80211_var_ie *)p;
1423
1424                 if (pmlmepriv->num_sta_non_erp == 1)
1425                         pIE->data[0] |= RTW_ERP_INFO_NON_ERP_PRESENT | RTW_ERP_INFO_USE_PROTECTION;
1426                 else
1427                         pIE->data[0] &= ~(
1428                                 RTW_ERP_INFO_NON_ERP_PRESENT | RTW_ERP_INFO_USE_PROTECTION
1429                         );
1430
1431                 if (pmlmepriv->num_sta_no_short_preamble > 0)
1432                         pIE->data[0] |= RTW_ERP_INFO_BARKER_PREAMBLE_MODE;
1433                 else
1434                         pIE->data[0] &= ~(RTW_ERP_INFO_BARKER_PREAMBLE_MODE);
1435
1436                 ERP_IE_handler(padapter, pIE);
1437         }
1438 }
1439
1440 static void update_bcn_htcap_ie(struct adapter *padapter)
1441 {
1442 }
1443
1444 static void update_bcn_htinfo_ie(struct adapter *padapter)
1445 {
1446 }
1447
1448 static void update_bcn_rsn_ie(struct adapter *padapter)
1449 {
1450 }
1451
1452 static void update_bcn_wpa_ie(struct adapter *padapter)
1453 {
1454 }
1455
1456 static void update_bcn_wmm_ie(struct adapter *padapter)
1457 {
1458 }
1459
1460 static void update_bcn_wps_ie(struct adapter *padapter)
1461 {
1462         u8 *pwps_ie = NULL;
1463         u8 *pwps_ie_src;
1464         u8 *premainder_ie;
1465         u8 *pbackup_remainder_ie = NULL;
1466
1467         uint wps_ielen = 0, wps_offset, remainder_ielen;
1468         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1469         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1470         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1471         struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
1472         unsigned char *ie = pnetwork->IEs;
1473         u32 ielen = pnetwork->IELength;
1474
1475         pwps_ie = rtw_get_wps_ie(
1476                 ie + _FIXED_IE_LENGTH_,
1477                 ielen - _FIXED_IE_LENGTH_,
1478                 NULL,
1479                 &wps_ielen
1480         );
1481
1482         if (pwps_ie == NULL || wps_ielen == 0)
1483                 return;
1484
1485         pwps_ie_src = pmlmepriv->wps_beacon_ie;
1486         if (pwps_ie_src == NULL)
1487                 return;
1488
1489         wps_offset = (uint)(pwps_ie - ie);
1490
1491         premainder_ie = pwps_ie + wps_ielen;
1492
1493         remainder_ielen = ielen - wps_offset - wps_ielen;
1494
1495         if (remainder_ielen > 0) {
1496                 pbackup_remainder_ie = rtw_malloc(remainder_ielen);
1497                 if (pbackup_remainder_ie)
1498                         memcpy(pbackup_remainder_ie, premainder_ie, remainder_ielen);
1499         }
1500
1501         wps_ielen = (uint)pwps_ie_src[1];/* to get ie data len */
1502         if ((wps_offset + wps_ielen + 2 + remainder_ielen) <= MAX_IE_SZ) {
1503                 memcpy(pwps_ie, pwps_ie_src, wps_ielen + 2);
1504                 pwps_ie += (wps_ielen+2);
1505
1506                 if (pbackup_remainder_ie)
1507                         memcpy(pwps_ie, pbackup_remainder_ie, remainder_ielen);
1508
1509                 /* update IELength */
1510                 pnetwork->IELength = wps_offset + (wps_ielen + 2) + remainder_ielen;
1511         }
1512
1513         kfree(pbackup_remainder_ie);
1514 }
1515
1516 static void update_bcn_p2p_ie(struct adapter *padapter)
1517 {
1518 }
1519
1520 static void update_bcn_vendor_spec_ie(struct adapter *padapter, u8 *oui)
1521 {
1522         if (!memcmp(RTW_WPA_OUI, oui, 4))
1523                 update_bcn_wpa_ie(padapter);
1524
1525         else if (!memcmp(WMM_OUI, oui, 4))
1526                 update_bcn_wmm_ie(padapter);
1527
1528         else if (!memcmp(WPS_OUI, oui, 4))
1529                 update_bcn_wps_ie(padapter);
1530
1531         else if (!memcmp(P2P_OUI, oui, 4))
1532                 update_bcn_p2p_ie(padapter);
1533 }
1534
1535 void update_beacon(struct adapter *padapter, u8 ie_id, u8 *oui, u8 tx)
1536 {
1537         struct mlme_priv *pmlmepriv;
1538         struct mlme_ext_priv *pmlmeext;
1539         /* struct mlme_ext_info *pmlmeinfo; */
1540
1541         if (!padapter)
1542                 return;
1543
1544         pmlmepriv = &(padapter->mlmepriv);
1545         pmlmeext = &(padapter->mlmeextpriv);
1546         /* pmlmeinfo = &(pmlmeext->mlmext_info); */
1547
1548         if (!pmlmeext->bstart_bss)
1549                 return;
1550
1551         spin_lock_bh(&pmlmepriv->bcn_update_lock);
1552
1553         switch (ie_id) {
1554         case 0xFF:
1555
1556                 update_bcn_fixed_ie(padapter);/* 8: TimeStamp, 2: Beacon Interval 2:Capability */
1557
1558                 break;
1559
1560         case WLAN_EID_TIM:
1561
1562                 update_BCNTIM(padapter);
1563
1564                 break;
1565
1566         case WLAN_EID_ERP_INFO:
1567
1568                 update_bcn_erpinfo_ie(padapter);
1569
1570                 break;
1571
1572         case WLAN_EID_HT_CAPABILITY:
1573
1574                 update_bcn_htcap_ie(padapter);
1575
1576                 break;
1577
1578         case WLAN_EID_RSN:
1579
1580                 update_bcn_rsn_ie(padapter);
1581
1582                 break;
1583
1584         case WLAN_EID_HT_OPERATION:
1585
1586                 update_bcn_htinfo_ie(padapter);
1587
1588                 break;
1589
1590         case WLAN_EID_VENDOR_SPECIFIC:
1591
1592                 update_bcn_vendor_spec_ie(padapter, oui);
1593
1594                 break;
1595
1596         default:
1597                 break;
1598         }
1599
1600         pmlmepriv->update_bcn = true;
1601
1602         spin_unlock_bh(&pmlmepriv->bcn_update_lock);
1603
1604         if (tx) {
1605                 /* send_beacon(padapter);//send_beacon must execute on TSR level */
1606                 set_tx_beacon_cmd(padapter);
1607         }
1608 }
1609
1610 /*
1611  * op_mode
1612  * Set to 0 (HT pure) under the following conditions
1613  *        - all STAs in the BSS are 20/40 MHz HT in 20/40 MHz BSS or
1614  *        - all STAs in the BSS are 20 MHz HT in 20 MHz BSS
1615  * Set to 1 (HT non-member protection) if there may be non-HT STAs
1616  *        in both the primary and the secondary channel
1617  * Set to 2 if only HT STAs are associated in BSS,
1618  *        however and at least one 20 MHz HT STA is associated
1619  * Set to 3 (HT mixed mode) when one or more non-HT STAs are associated
1620  *        (currently non-GF HT station is considered as non-HT STA also)
1621  */
1622 static int rtw_ht_operation_update(struct adapter *padapter)
1623 {
1624         u16 cur_op_mode, new_op_mode;
1625         int op_mode_changes = 0;
1626         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1627         struct ht_priv *phtpriv_ap = &pmlmepriv->htpriv;
1628
1629         if (pmlmepriv->htpriv.ht_option)
1630                 return 0;
1631
1632         if (!(pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT)
1633             && pmlmepriv->num_sta_ht_no_gf) {
1634                 pmlmepriv->ht_op_mode |=
1635                         IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT;
1636                 op_mode_changes++;
1637         } else if ((pmlmepriv->ht_op_mode &
1638                     IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT) &&
1639                    pmlmepriv->num_sta_ht_no_gf == 0) {
1640                 pmlmepriv->ht_op_mode &=
1641                         ~IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT;
1642                 op_mode_changes++;
1643         }
1644
1645         if (!(pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT) &&
1646             (pmlmepriv->num_sta_no_ht || pmlmepriv->olbc_ht)) {
1647                 pmlmepriv->ht_op_mode |= IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT;
1648                 op_mode_changes++;
1649         } else if ((pmlmepriv->ht_op_mode &
1650                     IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT) &&
1651                    (pmlmepriv->num_sta_no_ht == 0 && !pmlmepriv->olbc_ht)) {
1652                 pmlmepriv->ht_op_mode &=
1653                         ~IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT;
1654                 op_mode_changes++;
1655         }
1656
1657         /* Note: currently we switch to the MIXED op mode if HT non-greenfield
1658          * station is associated. Probably it's a theoretical case, since
1659          * it looks like all known HT STAs support greenfield.
1660          */
1661         new_op_mode = 0;
1662         if (pmlmepriv->num_sta_no_ht ||
1663             (pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT))
1664                 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED;
1665         else if (
1666                 (le16_to_cpu(phtpriv_ap->ht_cap.cap_info) & IEEE80211_HT_CAP_SUP_WIDTH)
1667                 && pmlmepriv->num_sta_ht_20mhz)
1668                 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_20MHZ;
1669         else if (pmlmepriv->olbc_ht)
1670                 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER;
1671         else
1672                 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_NONE;
1673
1674         cur_op_mode = pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_PROTECTION;
1675         if (cur_op_mode != new_op_mode) {
1676                 pmlmepriv->ht_op_mode &= ~IEEE80211_HT_OP_MODE_PROTECTION;
1677                 pmlmepriv->ht_op_mode |= new_op_mode;
1678                 op_mode_changes++;
1679         }
1680
1681         return op_mode_changes;
1682 }
1683
1684 void associated_clients_update(struct adapter *padapter, u8 updated)
1685 {
1686         /* update associated stations cap. */
1687         if (updated) {
1688                 struct list_head        *phead, *plist;
1689                 struct sta_info *psta = NULL;
1690                 struct sta_priv *pstapriv = &padapter->stapriv;
1691
1692                 spin_lock_bh(&pstapriv->asoc_list_lock);
1693
1694                 phead = &pstapriv->asoc_list;
1695                 /* check asoc_queue */
1696                 list_for_each(plist, phead) {
1697                         psta = list_entry(plist, struct sta_info, asoc_list);
1698
1699                         VCS_update(padapter, psta);
1700                 }
1701
1702                 spin_unlock_bh(&pstapriv->asoc_list_lock);
1703         }
1704 }
1705
1706 /* called > TSR LEVEL for USB or SDIO Interface*/
1707 void bss_cap_update_on_sta_join(struct adapter *padapter, struct sta_info *psta)
1708 {
1709         u8 beacon_updated = false;
1710         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1711         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1712
1713         if (!(psta->flags & WLAN_STA_SHORT_PREAMBLE)) {
1714                 if (!psta->no_short_preamble_set) {
1715                         psta->no_short_preamble_set = 1;
1716
1717                         pmlmepriv->num_sta_no_short_preamble++;
1718
1719                         if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
1720                             (pmlmepriv->num_sta_no_short_preamble == 1)) {
1721                                 beacon_updated = true;
1722                                 update_beacon(padapter, 0xFF, NULL, true);
1723                         }
1724                 }
1725         } else {
1726                 if (psta->no_short_preamble_set) {
1727                         psta->no_short_preamble_set = 0;
1728
1729                         pmlmepriv->num_sta_no_short_preamble--;
1730
1731                         if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
1732                                 (pmlmepriv->num_sta_no_short_preamble == 0)) {
1733                                 beacon_updated = true;
1734                                 update_beacon(padapter, 0xFF, NULL, true);
1735                         }
1736                 }
1737         }
1738
1739         if (psta->flags & WLAN_STA_NONERP) {
1740                 if (!psta->nonerp_set) {
1741                         psta->nonerp_set = 1;
1742
1743                         pmlmepriv->num_sta_non_erp++;
1744
1745                         if (pmlmepriv->num_sta_non_erp == 1) {
1746                                 beacon_updated = true;
1747                                 update_beacon(padapter, WLAN_EID_ERP_INFO, NULL, true);
1748                         }
1749                 }
1750         } else {
1751                 if (psta->nonerp_set) {
1752                         psta->nonerp_set = 0;
1753
1754                         pmlmepriv->num_sta_non_erp--;
1755
1756                         if (pmlmepriv->num_sta_non_erp == 0) {
1757                                 beacon_updated = true;
1758                                 update_beacon(padapter, WLAN_EID_ERP_INFO, NULL, true);
1759                         }
1760                 }
1761         }
1762
1763         if (!(psta->capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)) {
1764                 if (!psta->no_short_slot_time_set) {
1765                         psta->no_short_slot_time_set = 1;
1766
1767                         pmlmepriv->num_sta_no_short_slot_time++;
1768
1769                         if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
1770                                  (pmlmepriv->num_sta_no_short_slot_time == 1)) {
1771                                 beacon_updated = true;
1772                                 update_beacon(padapter, 0xFF, NULL, true);
1773                         }
1774                 }
1775         } else {
1776                 if (psta->no_short_slot_time_set) {
1777                         psta->no_short_slot_time_set = 0;
1778
1779                         pmlmepriv->num_sta_no_short_slot_time--;
1780
1781                         if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
1782                                  (pmlmepriv->num_sta_no_short_slot_time == 0)) {
1783                                 beacon_updated = true;
1784                                 update_beacon(padapter, 0xFF, NULL, true);
1785                         }
1786                 }
1787         }
1788
1789         if (psta->flags & WLAN_STA_HT) {
1790                 u16 ht_capab = le16_to_cpu(psta->htpriv.ht_cap.cap_info);
1791
1792                 if (psta->no_ht_set) {
1793                         psta->no_ht_set = 0;
1794                         pmlmepriv->num_sta_no_ht--;
1795                 }
1796
1797                 if ((ht_capab & IEEE80211_HT_CAP_GRN_FLD) == 0) {
1798                         if (!psta->no_ht_gf_set) {
1799                                 psta->no_ht_gf_set = 1;
1800                                 pmlmepriv->num_sta_ht_no_gf++;
1801                         }
1802                 }
1803
1804                 if ((ht_capab & IEEE80211_HT_CAP_SUP_WIDTH) == 0) {
1805                         if (!psta->ht_20mhz_set) {
1806                                 psta->ht_20mhz_set = 1;
1807                                 pmlmepriv->num_sta_ht_20mhz++;
1808                         }
1809                 }
1810
1811         } else {
1812                 if (!psta->no_ht_set) {
1813                         psta->no_ht_set = 1;
1814                         pmlmepriv->num_sta_no_ht++;
1815                 }
1816         }
1817
1818         if (rtw_ht_operation_update(padapter) > 0) {
1819                 update_beacon(padapter, WLAN_EID_HT_CAPABILITY, NULL, false);
1820                 update_beacon(padapter, WLAN_EID_HT_OPERATION, NULL, true);
1821         }
1822
1823         /* update associated stations cap. */
1824         associated_clients_update(padapter,  beacon_updated);
1825 }
1826
1827 u8 bss_cap_update_on_sta_leave(struct adapter *padapter, struct sta_info *psta)
1828 {
1829         u8 beacon_updated = false;
1830         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1831         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1832
1833         if (!psta)
1834                 return beacon_updated;
1835
1836         if (psta->no_short_preamble_set) {
1837                 psta->no_short_preamble_set = 0;
1838                 pmlmepriv->num_sta_no_short_preamble--;
1839                 if (pmlmeext->cur_wireless_mode > WIRELESS_11B
1840                     && pmlmepriv->num_sta_no_short_preamble == 0){
1841                         beacon_updated = true;
1842                         update_beacon(padapter, 0xFF, NULL, true);
1843                 }
1844         }
1845
1846         if (psta->nonerp_set) {
1847                 psta->nonerp_set = 0;
1848                 pmlmepriv->num_sta_non_erp--;
1849                 if (pmlmepriv->num_sta_non_erp == 0) {
1850                         beacon_updated = true;
1851                         update_beacon(padapter, WLAN_EID_ERP_INFO, NULL, true);
1852                 }
1853         }
1854
1855         if (psta->no_short_slot_time_set) {
1856                 psta->no_short_slot_time_set = 0;
1857                 pmlmepriv->num_sta_no_short_slot_time--;
1858                 if (pmlmeext->cur_wireless_mode > WIRELESS_11B
1859                     && pmlmepriv->num_sta_no_short_slot_time == 0){
1860                         beacon_updated = true;
1861                         update_beacon(padapter, 0xFF, NULL, true);
1862                 }
1863         }
1864
1865         if (psta->no_ht_gf_set) {
1866                 psta->no_ht_gf_set = 0;
1867                 pmlmepriv->num_sta_ht_no_gf--;
1868         }
1869
1870         if (psta->no_ht_set) {
1871                 psta->no_ht_set = 0;
1872                 pmlmepriv->num_sta_no_ht--;
1873         }
1874
1875         if (psta->ht_20mhz_set) {
1876                 psta->ht_20mhz_set = 0;
1877                 pmlmepriv->num_sta_ht_20mhz--;
1878         }
1879
1880         if (rtw_ht_operation_update(padapter) > 0) {
1881                 update_beacon(padapter, WLAN_EID_HT_CAPABILITY, NULL, false);
1882                 update_beacon(padapter, WLAN_EID_HT_OPERATION, NULL, true);
1883         }
1884
1885         return beacon_updated;
1886 }
1887
1888 u8 ap_free_sta(
1889         struct adapter *padapter,
1890         struct sta_info *psta,
1891         bool active,
1892         u16 reason
1893 )
1894 {
1895         u8 beacon_updated = false;
1896
1897         if (!psta)
1898                 return beacon_updated;
1899
1900         if (active) {
1901                 /* tear down Rx AMPDU */
1902                 send_delba(padapter, 0, psta->hwaddr);/*  recipient */
1903
1904                 /* tear down TX AMPDU */
1905                 send_delba(padapter, 1, psta->hwaddr);/*  // originator */
1906
1907                 issue_deauth(padapter, psta->hwaddr, reason);
1908         }
1909
1910         psta->htpriv.agg_enable_bitmap = 0x0;/* reset */
1911         psta->htpriv.candidate_tid_bitmap = 0x0;/* reset */
1912
1913         /* report_del_sta_event(padapter, psta->hwaddr, reason); */
1914
1915         /* clear cam entry / key */
1916         rtw_clearstakey_cmd(padapter, psta, true);
1917
1918         spin_lock_bh(&psta->lock);
1919         psta->state &= ~_FW_LINKED;
1920         spin_unlock_bh(&psta->lock);
1921
1922         rtw_cfg80211_indicate_sta_disassoc(padapter, psta->hwaddr, reason);
1923
1924         report_del_sta_event(padapter, psta->hwaddr, reason);
1925
1926         beacon_updated = bss_cap_update_on_sta_leave(padapter, psta);
1927
1928         rtw_free_stainfo(padapter, psta);
1929
1930         return beacon_updated;
1931 }
1932
1933 void rtw_sta_flush(struct adapter *padapter)
1934 {
1935         struct list_head *phead, *plist, *tmp;
1936         struct sta_info *psta = NULL;
1937         struct sta_priv *pstapriv = &padapter->stapriv;
1938         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1939         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1940         u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1941
1942         if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)
1943                 return;
1944
1945         spin_lock_bh(&pstapriv->asoc_list_lock);
1946         phead = &pstapriv->asoc_list;
1947         /* free sta asoc_queue */
1948         list_for_each_safe(plist, tmp, phead) {
1949                 psta = list_entry(plist, struct sta_info, asoc_list);
1950
1951                 list_del_init(&psta->asoc_list);
1952                 pstapriv->asoc_list_cnt--;
1953
1954                 /* spin_unlock_bh(&pstapriv->asoc_list_lock); */
1955                 ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING);
1956                 /* spin_lock_bh(&pstapriv->asoc_list_lock); */
1957         }
1958         spin_unlock_bh(&pstapriv->asoc_list_lock);
1959
1960         issue_deauth(padapter, bc_addr, WLAN_REASON_DEAUTH_LEAVING);
1961
1962         associated_clients_update(padapter, true);
1963 }
1964
1965 /* called > TSR LEVEL for USB or SDIO Interface*/
1966 void sta_info_update(struct adapter *padapter, struct sta_info *psta)
1967 {
1968         int flags = psta->flags;
1969         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1970
1971         /* update wmm cap. */
1972         if (WLAN_STA_WME & flags)
1973                 psta->qos_option = 1;
1974         else
1975                 psta->qos_option = 0;
1976
1977         if (pmlmepriv->qospriv.qos_option == 0)
1978                 psta->qos_option = 0;
1979
1980         /* update 802.11n ht cap. */
1981         if (WLAN_STA_HT & flags) {
1982                 psta->htpriv.ht_option = true;
1983                 psta->qos_option = 1;
1984         } else {
1985                 psta->htpriv.ht_option = false;
1986         }
1987
1988         if (!pmlmepriv->htpriv.ht_option)
1989                 psta->htpriv.ht_option = false;
1990
1991         update_sta_info_apmode(padapter, psta);
1992 }
1993
1994 /* called >= TSR LEVEL for USB or SDIO Interface*/
1995 void ap_sta_info_defer_update(struct adapter *padapter, struct sta_info *psta)
1996 {
1997         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1998         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1999
2000         if (psta->state & _FW_LINKED) {
2001                 pmlmeinfo->FW_sta_info[psta->mac_id].psta = psta;
2002
2003                 /* add ratid */
2004                 add_RATid(padapter, psta, 0);/* DM_RATR_STA_INIT */
2005         }
2006 }
2007 /* restore hw setting from sw data structures */
2008 void rtw_ap_restore_network(struct adapter *padapter)
2009 {
2010         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2011         struct sta_priv *pstapriv = &padapter->stapriv;
2012         struct sta_info *psta;
2013         struct security_priv *psecuritypriv = &(padapter->securitypriv);
2014         struct list_head        *phead, *plist;
2015         u8 chk_alive_num = 0;
2016         char chk_alive_list[NUM_STA];
2017         int i;
2018
2019         rtw_setopmode_cmd(padapter, Ndis802_11APMode, false);
2020
2021         set_channel_bwmode(
2022                 padapter,
2023                 pmlmeext->cur_channel,
2024                 pmlmeext->cur_ch_offset,
2025                 pmlmeext->cur_bwmode
2026         );
2027
2028         start_bss_network(padapter);
2029
2030         if ((padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_) ||
2031                 (padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)) {
2032                 /* restore group key, WEP keys is restored in ips_leave() */
2033                 rtw_set_key(
2034                         padapter,
2035                         psecuritypriv,
2036                         psecuritypriv->dot118021XGrpKeyid,
2037                         0,
2038                         false
2039                 );
2040         }
2041
2042         spin_lock_bh(&pstapriv->asoc_list_lock);
2043
2044         phead = &pstapriv->asoc_list;
2045         list_for_each(plist, phead) {
2046                 int stainfo_offset;
2047
2048                 psta = list_entry(plist, struct sta_info, asoc_list);
2049
2050                 stainfo_offset = rtw_stainfo_offset(pstapriv, psta);
2051                 if (stainfo_offset_valid(stainfo_offset))
2052                         chk_alive_list[chk_alive_num++] = stainfo_offset;
2053         }
2054
2055         spin_unlock_bh(&pstapriv->asoc_list_lock);
2056
2057         for (i = 0; i < chk_alive_num; i++) {
2058                 psta = rtw_get_stainfo_by_offset(pstapriv, chk_alive_list[i]);
2059
2060                 if (!psta)
2061                         continue;
2062
2063                 if (psta->state & _FW_LINKED) {
2064                         rtw_sta_media_status_rpt(padapter, psta, 1);
2065                         Update_RA_Entry(padapter, psta);
2066                         /* pairwise key */
2067                         /* per sta pairwise key and settings */
2068                         if ((psecuritypriv->dot11PrivacyAlgrthm == _TKIP_) ||
2069                                 (psecuritypriv->dot11PrivacyAlgrthm == _AES_)) {
2070                                 rtw_setstakey_cmd(padapter, psta, true, false);
2071                         }
2072                 }
2073         }
2074 }
2075
2076 void start_ap_mode(struct adapter *padapter)
2077 {
2078         int i;
2079         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2080         struct sta_priv *pstapriv = &padapter->stapriv;
2081         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2082         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
2083
2084         pmlmepriv->update_bcn = false;
2085
2086         /* init_mlme_ap_info(padapter); */
2087         pmlmeext->bstart_bss = false;
2088
2089         pmlmepriv->num_sta_non_erp = 0;
2090
2091         pmlmepriv->num_sta_no_short_slot_time = 0;
2092
2093         pmlmepriv->num_sta_no_short_preamble = 0;
2094
2095         pmlmepriv->num_sta_ht_no_gf = 0;
2096         pmlmepriv->num_sta_no_ht = 0;
2097         pmlmepriv->num_sta_ht_20mhz = 0;
2098
2099         pmlmepriv->olbc = false;
2100
2101         pmlmepriv->olbc_ht = false;
2102
2103         pmlmepriv->ht_op_mode = 0;
2104
2105         for (i = 0; i < NUM_STA; i++)
2106                 pstapriv->sta_aid[i] = NULL;
2107
2108         pmlmepriv->wps_beacon_ie = NULL;
2109         pmlmepriv->wps_probe_resp_ie = NULL;
2110         pmlmepriv->wps_assoc_resp_ie = NULL;
2111
2112         pmlmepriv->p2p_beacon_ie = NULL;
2113         pmlmepriv->p2p_probe_resp_ie = NULL;
2114
2115         /* for ACL */
2116         INIT_LIST_HEAD(&(pacl_list->acl_node_q.queue));
2117         pacl_list->num = 0;
2118         pacl_list->mode = 0;
2119         for (i = 0; i < NUM_ACL; i++) {
2120                 INIT_LIST_HEAD(&pacl_list->aclnode[i].list);
2121                 pacl_list->aclnode[i].valid = false;
2122         }
2123 }
2124
2125 void stop_ap_mode(struct adapter *padapter)
2126 {
2127         struct list_head *phead, *plist, *tmp;
2128         struct rtw_wlan_acl_node *paclnode;
2129         struct sta_info *psta = NULL;
2130         struct sta_priv *pstapriv = &padapter->stapriv;
2131         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2132         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2133         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
2134         struct __queue  *pacl_node_q = &pacl_list->acl_node_q;
2135
2136         pmlmepriv->update_bcn = false;
2137         pmlmeext->bstart_bss = false;
2138
2139         /* reset and init security priv , this can refine with rtw_reset_securitypriv */
2140         memset(
2141                 (unsigned char *)&padapter->securitypriv,
2142                 0,
2143                 sizeof(struct security_priv)
2144         );
2145         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen;
2146         padapter->securitypriv.ndisencryptstatus = Ndis802_11WEPDisabled;
2147
2148         /* for ACL */
2149         spin_lock_bh(&(pacl_node_q->lock));
2150         phead = get_list_head(pacl_node_q);
2151         list_for_each_safe(plist, tmp, phead) {
2152                 paclnode = list_entry(plist, struct rtw_wlan_acl_node, list);
2153
2154                 if (paclnode->valid) {
2155                         paclnode->valid = false;
2156
2157                         list_del_init(&paclnode->list);
2158
2159                         pacl_list->num--;
2160                 }
2161         }
2162         spin_unlock_bh(&(pacl_node_q->lock));
2163
2164         rtw_sta_flush(padapter);
2165
2166         /* free_assoc_sta_resources */
2167         rtw_free_all_stainfo(padapter);
2168
2169         psta = rtw_get_bcmc_stainfo(padapter);
2170         rtw_free_stainfo(padapter, psta);
2171
2172         rtw_init_bcmc_stainfo(padapter);
2173
2174         rtw_free_mlme_priv_ie_data(pmlmepriv);
2175
2176         rtw_btcoex_MediaStatusNotify(padapter, 0); /* disconnect */
2177 }