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
   8 #include <drv_types.h>
   9 #include <rtw_debug.h>
  10 #include <asm/unaligned.h>
  11
  12 void init_mlme_ap_info(struct adapter *padapter)
  13 {
  14         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
  15         struct sta_priv *pstapriv = &padapter->stapriv;
  16         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
  17
  18         spin_lock_init(&pmlmepriv->bcn_update_lock);
  19
  20         /* for ACL */
  21         INIT_LIST_HEAD(&pacl_list->acl_node_q.queue);
  22         spin_lock_init(&pacl_list->acl_node_q.lock);
  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->ie_length - _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->ie_length - 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->ie_length - _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->ie_length - _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->ie_length - 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->ie_length = 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.ds_config > 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->supported_rates);
 401                 network_type = rtw_check_network_type((u8 *)&pcur_network->supported_rates,
 402                                                       supportRateNum,
 403                                                       pcur_network->configuration.ds_config
 404                 );
 405                 if (is_supported_tx_cck(network_type)) {
 406                         network_type = WIRELESS_11B;
 407                 } else if (network_type == WIRELESS_INVALID) { /*  error handling */
 408
 409                         if (pcur_network->configuration.ds_config > 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->supported_rates);
 576         memcpy(psta->bssrateset, pnetwork->supported_rates, 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.beacon_period;
 660         cur_channel = pnetwork->configuration.ds_config;
 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->ie_length - _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->mac_address);
 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->ie_length - 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->supported_rates);
 790         rtw_hal_set_hwreg(padapter, HW_VAR_BASIC_RATE, pnetwork->supported_rates);
 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->ie_length = len;
 839
 840         memset(ie, 0, MAX_IE_SZ);
 841
 842         memcpy(ie, pbuf, pbss_network->ie_length);
 843
 844         if (pbss_network->infrastructure_mode != Ndis802_11APMode)
 845                 return _FAIL;
 846
 847         pbss_network->rssi = 0;
 848
 849         memcpy(pbss_network->mac_address, 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.beacon_period = le16_to_cpu(*(unsigned short*)p); */
 854         pbss_network->configuration.beacon_period = 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->ie_length - _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.ssid_length = 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->ie_length - _BEACON_IE_OFFSET_)
 881         );
 882         if (p && ie_len > 0)
 883                 channel = *(p + 2);
 884
 885         pbss_network->configuration.ds_config = 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->ie_length - _BEACON_IE_OFFSET_)
 894         );
 895         if (p) {
 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->ie_length - _BEACON_IE_OFFSET_
 906         );
 907         if (p) {
 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->supported_rates, 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->ie_length - _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->ie_length - _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->ie_length - _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 || 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->ie_length - _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 || 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->ie_length - _BEACON_IE_OFFSET_)
1036         );
1037         if (p && ie_len > 0) {
1038                 u8 max_rx_ampdu_factor = 0;
1039                 struct ieee80211_ht_cap *pht_cap = (struct ieee80211_ht_cap *)(p + 2);
1040
1041                 pHT_caps_ie = p;
1042
1043                 ht_cap = true;
1044                 network_type |= WIRELESS_11_24N;
1045
1046                 rtw_ht_use_default_setting(padapter);
1047
1048                 if (pmlmepriv->htpriv.sgi_20m == false)
1049                         pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_SGI_20));
1050
1051                 if (pmlmepriv->htpriv.sgi_40m == false)
1052                         pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_SGI_40));
1053
1054                 if (!TEST_FLAG(pmlmepriv->htpriv.ldpc_cap, LDPC_HT_ENABLE_RX))
1055                         pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_LDPC_CODING));
1056
1057                 if (!TEST_FLAG(pmlmepriv->htpriv.stbc_cap, STBC_HT_ENABLE_TX))
1058                         pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_TX_STBC));
1059
1060                 if (!TEST_FLAG(pmlmepriv->htpriv.stbc_cap, STBC_HT_ENABLE_RX))
1061                         pht_cap->cap_info &= cpu_to_le16(~(IEEE80211_HT_CAP_RX_STBC_3R));
1062
1063                 pht_cap->ampdu_params_info &= ~(
1064                         IEEE80211_HT_CAP_AMPDU_FACTOR | IEEE80211_HT_CAP_AMPDU_DENSITY
1065                 );
1066
1067                 if ((psecuritypriv->wpa_pairwise_cipher & WPA_CIPHER_CCMP) ||
1068                     (psecuritypriv->wpa2_pairwise_cipher & WPA_CIPHER_CCMP)) {
1069                         pht_cap->ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY &
1070                                                        (0x07 << 2));
1071                 } else {
1072                         pht_cap->ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY &
1073                                                        0x00);
1074                 }
1075
1076                 rtw_hal_get_def_var(
1077                         padapter,
1078                         HW_VAR_MAX_RX_AMPDU_FACTOR,
1079                         &max_rx_ampdu_factor
1080                 );
1081                 pht_cap->ampdu_params_info |= (
1082                         IEEE80211_HT_CAP_AMPDU_FACTOR & max_rx_ampdu_factor
1083                 ); /* set  Max Rx AMPDU size  to 64K */
1084
1085                 pht_cap->mcs.rx_mask[0] = 0xff;
1086                 pht_cap->mcs.rx_mask[1] = 0x0;
1087
1088                 memcpy(&pmlmepriv->htpriv.ht_cap, p + 2, ie_len);
1089         }
1090
1091         /* parsing HT_INFO_IE */
1092         p = rtw_get_ie(
1093                 ie + _BEACON_IE_OFFSET_,
1094                 WLAN_EID_HT_OPERATION,
1095                 &ie_len,
1096                 (pbss_network->ie_length - _BEACON_IE_OFFSET_)
1097         );
1098         if (p && ie_len > 0)
1099                 pHT_info_ie = p;
1100
1101         switch (network_type) {
1102         case WIRELESS_11B:
1103                 pbss_network->network_type_in_use = Ndis802_11DS;
1104                 break;
1105         case WIRELESS_11G:
1106         case WIRELESS_11BG:
1107         case WIRELESS_11G_24N:
1108         case WIRELESS_11BG_24N:
1109                 pbss_network->network_type_in_use = Ndis802_11OFDM24;
1110                 break;
1111         default:
1112                 pbss_network->network_type_in_use = Ndis802_11OFDM24;
1113                 break;
1114         }
1115
1116         pmlmepriv->cur_network.network_type = network_type;
1117
1118         pmlmepriv->htpriv.ht_option = false;
1119
1120         if ((psecuritypriv->wpa2_pairwise_cipher & WPA_CIPHER_TKIP) ||
1121             (psecuritypriv->wpa_pairwise_cipher & WPA_CIPHER_TKIP)) {
1122                 /* todo: */
1123                 /* ht_cap = false; */
1124         }
1125
1126         /* ht_cap */
1127         if (pregistrypriv->ht_enable && ht_cap) {
1128                 pmlmepriv->htpriv.ht_option = true;
1129                 pmlmepriv->qospriv.qos_option = 1;
1130
1131                 if (pregistrypriv->ampdu_enable == 1)
1132                         pmlmepriv->htpriv.ampdu_enable = true;
1133
1134                 HT_caps_handler(padapter, (struct ndis_80211_var_ie *)pHT_caps_ie);
1135
1136                 HT_info_handler(padapter, (struct ndis_80211_var_ie *)pHT_info_ie);
1137         }
1138
1139         pbss_network->length = get_wlan_bssid_ex_sz(
1140                 (struct wlan_bssid_ex  *)pbss_network
1141         );
1142
1143         /* issue beacon to start bss network */
1144         /* start_bss_network(padapter, (u8 *)pbss_network); */
1145         rtw_startbss_cmd(padapter, RTW_CMDF_WAIT_ACK);
1146
1147         /* alloc sta_info for ap itself */
1148         psta = rtw_get_stainfo(&padapter->stapriv, pbss_network->mac_address);
1149         if (!psta) {
1150                 psta = rtw_alloc_stainfo(&padapter->stapriv, pbss_network->mac_address);
1151                 if (!psta)
1152                         return _FAIL;
1153         }
1154
1155         /*  update AP's sta info */
1156         update_ap_info(padapter, psta);
1157
1158         psta->state |= WIFI_AP_STATE;           /* Aries, add, fix bug of flush_cam_entry at STOP AP mode , 0724 */
1159         rtw_indicate_connect(padapter);
1160
1161         pmlmepriv->cur_network.join_res = true;/* for check if already set beacon */
1162
1163         /* update bc/mc sta_info */
1164         /* update_bmc_sta(padapter); */
1165
1166         return ret;
1167 }
1168
1169 void rtw_set_macaddr_acl(struct adapter *padapter, int mode)
1170 {
1171         struct sta_priv *pstapriv = &padapter->stapriv;
1172         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
1173
1174         pacl_list->mode = mode;
1175 }
1176
1177 int rtw_acl_add_sta(struct adapter *padapter, u8 *addr)
1178 {
1179         struct list_head        *plist, *phead;
1180         u8 added = false;
1181         int i, ret = 0;
1182         struct rtw_wlan_acl_node *paclnode;
1183         struct sta_priv *pstapriv = &padapter->stapriv;
1184         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
1185         struct __queue  *pacl_node_q = &pacl_list->acl_node_q;
1186
1187         if ((NUM_ACL - 1) < pacl_list->num)
1188                 return (-1);
1189
1190         spin_lock_bh(&(pacl_node_q->lock));
1191
1192         phead = get_list_head(pacl_node_q);
1193         list_for_each(plist, phead) {
1194                 paclnode = list_entry(plist, struct rtw_wlan_acl_node, list);
1195
1196                 if (!memcmp(paclnode->addr, addr, ETH_ALEN)) {
1197                         if (paclnode->valid == true) {
1198                                 added = true;
1199                                 break;
1200                         }
1201                 }
1202         }
1203
1204         spin_unlock_bh(&(pacl_node_q->lock));
1205
1206         if (added)
1207                 return ret;
1208
1209         spin_lock_bh(&(pacl_node_q->lock));
1210
1211         for (i = 0; i < NUM_ACL; i++) {
1212                 paclnode = &pacl_list->aclnode[i];
1213
1214                 if (!paclnode->valid) {
1215                         INIT_LIST_HEAD(&paclnode->list);
1216
1217                         memcpy(paclnode->addr, addr, ETH_ALEN);
1218
1219                         paclnode->valid = true;
1220
1221                         list_add_tail(&paclnode->list, get_list_head(pacl_node_q));
1222
1223                         pacl_list->num++;
1224
1225                         break;
1226                 }
1227         }
1228
1229         spin_unlock_bh(&(pacl_node_q->lock));
1230
1231         return ret;
1232 }
1233
1234 void rtw_acl_remove_sta(struct adapter *padapter, u8 *addr)
1235 {
1236         struct list_head *plist, *phead, *tmp;
1237         struct rtw_wlan_acl_node *paclnode;
1238         struct sta_priv *pstapriv = &padapter->stapriv;
1239         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
1240         struct __queue  *pacl_node_q = &pacl_list->acl_node_q;
1241         u8 baddr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };    /* Baddr is used for clearing acl_list */
1242
1243         spin_lock_bh(&(pacl_node_q->lock));
1244
1245         phead = get_list_head(pacl_node_q);
1246         list_for_each_safe(plist, tmp, phead) {
1247                 paclnode = list_entry(plist, struct rtw_wlan_acl_node, list);
1248
1249                 if (
1250                         !memcmp(paclnode->addr, addr, ETH_ALEN) ||
1251                         !memcmp(baddr, addr, ETH_ALEN)
1252                 ) {
1253                         if (paclnode->valid) {
1254                                 paclnode->valid = false;
1255
1256                                 list_del_init(&paclnode->list);
1257
1258                                 pacl_list->num--;
1259                         }
1260                 }
1261         }
1262
1263         spin_unlock_bh(&(pacl_node_q->lock));
1264
1265 }
1266
1267 u8 rtw_ap_set_pairwise_key(struct adapter *padapter, struct sta_info *psta)
1268 {
1269         struct cmd_obj *ph2c;
1270         struct set_stakey_parm  *psetstakey_para;
1271         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1272         u8 res = _SUCCESS;
1273
1274         ph2c = rtw_zmalloc(sizeof(struct cmd_obj));
1275         if (!ph2c) {
1276                 res = _FAIL;
1277                 goto exit;
1278         }
1279
1280         psetstakey_para = rtw_zmalloc(sizeof(struct set_stakey_parm));
1281         if (!psetstakey_para) {
1282                 kfree(ph2c);
1283                 res = _FAIL;
1284                 goto exit;
1285         }
1286
1287         init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
1288
1289         psetstakey_para->algorithm = (u8)psta->dot118021XPrivacy;
1290
1291         memcpy(psetstakey_para->addr, psta->hwaddr, ETH_ALEN);
1292
1293         memcpy(psetstakey_para->key, &psta->dot118021x_UncstKey, 16);
1294
1295         res = rtw_enqueue_cmd(pcmdpriv, ph2c);
1296
1297 exit:
1298
1299         return res;
1300 }
1301
1302 static int rtw_ap_set_key(
1303         struct adapter *padapter,
1304         u8 *key,
1305         u8 alg,
1306         int keyid,
1307         u8 set_tx
1308 )
1309 {
1310         u8 keylen;
1311         struct cmd_obj *pcmd;
1312         struct setkey_parm *psetkeyparm;
1313         struct cmd_priv *pcmdpriv = &(padapter->cmdpriv);
1314         int res = _SUCCESS;
1315
1316         pcmd = rtw_zmalloc(sizeof(struct cmd_obj));
1317         if (!pcmd) {
1318                 res = _FAIL;
1319                 goto exit;
1320         }
1321         psetkeyparm = rtw_zmalloc(sizeof(struct setkey_parm));
1322         if (!psetkeyparm) {
1323                 kfree(pcmd);
1324                 res = _FAIL;
1325                 goto exit;
1326         }
1327
1328         psetkeyparm->keyid = (u8)keyid;
1329         if (is_wep_enc(alg))
1330                 padapter->securitypriv.key_mask |= BIT(psetkeyparm->keyid);
1331
1332         psetkeyparm->algorithm = alg;
1333
1334         psetkeyparm->set_tx = set_tx;
1335
1336         switch (alg) {
1337         case _WEP40_:
1338                 keylen = 5;
1339                 break;
1340         case _WEP104_:
1341                 keylen = 13;
1342                 break;
1343         case _TKIP_:
1344         case _TKIP_WTMIC_:
1345         case _AES_:
1346         default:
1347                 keylen = 16;
1348         }
1349
1350         memcpy(&(psetkeyparm->key[0]), key, keylen);
1351
1352         pcmd->cmdcode = _SetKey_CMD_;
1353         pcmd->parmbuf = (u8 *)psetkeyparm;
1354         pcmd->cmdsz =  (sizeof(struct setkey_parm));
1355         pcmd->rsp = NULL;
1356         pcmd->rspsz = 0;
1357
1358         INIT_LIST_HEAD(&pcmd->list);
1359
1360         res = rtw_enqueue_cmd(pcmdpriv, pcmd);
1361
1362 exit:
1363
1364         return res;
1365 }
1366
1367 int rtw_ap_set_group_key(struct adapter *padapter, u8 *key, u8 alg, int keyid)
1368 {
1369         return rtw_ap_set_key(padapter, key, alg, keyid, 1);
1370 }
1371
1372 int rtw_ap_set_wep_key(
1373         struct adapter *padapter,
1374         u8 *key,
1375         u8 keylen,
1376         int keyid,
1377         u8 set_tx
1378 )
1379 {
1380         u8 alg;
1381
1382         switch (keylen) {
1383         case 5:
1384                 alg = _WEP40_;
1385                 break;
1386         case 13:
1387                 alg = _WEP104_;
1388                 break;
1389         default:
1390                 alg = _NO_PRIVACY_;
1391         }
1392
1393         return rtw_ap_set_key(padapter, key, alg, keyid, set_tx);
1394 }
1395
1396 static void update_bcn_fixed_ie(struct adapter *padapter)
1397 {
1398 }
1399
1400 static void update_bcn_erpinfo_ie(struct adapter *padapter)
1401 {
1402         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1403         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1404         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1405         struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
1406         unsigned char *p, *ie = pnetwork->ies;
1407         u32 len = 0;
1408
1409         if (!pmlmeinfo->ERP_enable)
1410                 return;
1411
1412         /* parsing ERP_IE */
1413         p = rtw_get_ie(
1414                 ie + _BEACON_IE_OFFSET_,
1415                 WLAN_EID_ERP_INFO,
1416                 &len,
1417                 (pnetwork->ie_length - _BEACON_IE_OFFSET_)
1418         );
1419         if (p && len > 0) {
1420                 struct ndis_80211_var_ie *pIE = (struct ndis_80211_var_ie *)p;
1421
1422                 if (pmlmepriv->num_sta_non_erp == 1)
1423                         pIE->data[0] |= RTW_ERP_INFO_NON_ERP_PRESENT | RTW_ERP_INFO_USE_PROTECTION;
1424                 else
1425                         pIE->data[0] &= ~(
1426                                 RTW_ERP_INFO_NON_ERP_PRESENT | RTW_ERP_INFO_USE_PROTECTION
1427                         );
1428
1429                 if (pmlmepriv->num_sta_no_short_preamble > 0)
1430                         pIE->data[0] |= RTW_ERP_INFO_BARKER_PREAMBLE_MODE;
1431                 else
1432                         pIE->data[0] &= ~(RTW_ERP_INFO_BARKER_PREAMBLE_MODE);
1433
1434                 ERP_IE_handler(padapter, pIE);
1435         }
1436 }
1437
1438 static void update_bcn_htcap_ie(struct adapter *padapter)
1439 {
1440 }
1441
1442 static void update_bcn_htinfo_ie(struct adapter *padapter)
1443 {
1444 }
1445
1446 static void update_bcn_rsn_ie(struct adapter *padapter)
1447 {
1448 }
1449
1450 static void update_bcn_wpa_ie(struct adapter *padapter)
1451 {
1452 }
1453
1454 static void update_bcn_wmm_ie(struct adapter *padapter)
1455 {
1456 }
1457
1458 static void update_bcn_wps_ie(struct adapter *padapter)
1459 {
1460         u8 *pwps_ie = NULL;
1461         u8 *pwps_ie_src;
1462         u8 *premainder_ie;
1463         u8 *pbackup_remainder_ie = NULL;
1464
1465         uint wps_ielen = 0, wps_offset, remainder_ielen;
1466         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1467         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1468         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1469         struct wlan_bssid_ex *pnetwork = &(pmlmeinfo->network);
1470         unsigned char *ie = pnetwork->ies;
1471         u32 ielen = pnetwork->ie_length;
1472
1473         pwps_ie = rtw_get_wps_ie(
1474                 ie + _FIXED_IE_LENGTH_,
1475                 ielen - _FIXED_IE_LENGTH_,
1476                 NULL,
1477                 &wps_ielen
1478         );
1479
1480         if (!pwps_ie || wps_ielen == 0)
1481                 return;
1482
1483         pwps_ie_src = pmlmepriv->wps_beacon_ie;
1484         if (!pwps_ie_src)
1485                 return;
1486
1487         wps_offset = (uint)(pwps_ie - ie);
1488
1489         premainder_ie = pwps_ie + wps_ielen;
1490
1491         remainder_ielen = ielen - wps_offset - wps_ielen;
1492
1493         if (remainder_ielen > 0) {
1494                 pbackup_remainder_ie = rtw_malloc(remainder_ielen);
1495                 if (pbackup_remainder_ie)
1496                         memcpy(pbackup_remainder_ie, premainder_ie, remainder_ielen);
1497         }
1498
1499         wps_ielen = (uint)pwps_ie_src[1];/* to get ie data len */
1500         if ((wps_offset + wps_ielen + 2 + remainder_ielen) <= MAX_IE_SZ) {
1501                 memcpy(pwps_ie, pwps_ie_src, wps_ielen + 2);
1502                 pwps_ie += (wps_ielen+2);
1503
1504                 if (pbackup_remainder_ie)
1505                         memcpy(pwps_ie, pbackup_remainder_ie, remainder_ielen);
1506
1507                 /* update ie_length */
1508                 pnetwork->ie_length = wps_offset + (wps_ielen + 2) + remainder_ielen;
1509         }
1510
1511         kfree(pbackup_remainder_ie);
1512 }
1513
1514 static void update_bcn_p2p_ie(struct adapter *padapter)
1515 {
1516 }
1517
1518 static void update_bcn_vendor_spec_ie(struct adapter *padapter, u8 *oui)
1519 {
1520         if (!memcmp(RTW_WPA_OUI, oui, 4))
1521                 update_bcn_wpa_ie(padapter);
1522
1523         else if (!memcmp(WMM_OUI, oui, 4))
1524                 update_bcn_wmm_ie(padapter);
1525
1526         else if (!memcmp(WPS_OUI, oui, 4))
1527                 update_bcn_wps_ie(padapter);
1528
1529         else if (!memcmp(P2P_OUI, oui, 4))
1530                 update_bcn_p2p_ie(padapter);
1531 }
1532
1533 void update_beacon(struct adapter *padapter, u8 ie_id, u8 *oui, u8 tx)
1534 {
1535         struct mlme_priv *pmlmepriv;
1536         struct mlme_ext_priv *pmlmeext;
1537         /* struct mlme_ext_info *pmlmeinfo; */
1538
1539         if (!padapter)
1540                 return;
1541
1542         pmlmepriv = &(padapter->mlmepriv);
1543         pmlmeext = &(padapter->mlmeextpriv);
1544         /* pmlmeinfo = &(pmlmeext->mlmext_info); */
1545
1546         if (!pmlmeext->bstart_bss)
1547                 return;
1548
1549         spin_lock_bh(&pmlmepriv->bcn_update_lock);
1550
1551         switch (ie_id) {
1552         case 0xFF:
1553
1554                 update_bcn_fixed_ie(padapter);/* 8: TimeStamp, 2: Beacon Interval 2:Capability */
1555
1556                 break;
1557
1558         case WLAN_EID_TIM:
1559
1560                 update_BCNTIM(padapter);
1561
1562                 break;
1563
1564         case WLAN_EID_ERP_INFO:
1565
1566                 update_bcn_erpinfo_ie(padapter);
1567
1568                 break;
1569
1570         case WLAN_EID_HT_CAPABILITY:
1571
1572                 update_bcn_htcap_ie(padapter);
1573
1574                 break;
1575
1576         case WLAN_EID_RSN:
1577
1578                 update_bcn_rsn_ie(padapter);
1579
1580                 break;
1581
1582         case WLAN_EID_HT_OPERATION:
1583
1584                 update_bcn_htinfo_ie(padapter);
1585
1586                 break;
1587
1588         case WLAN_EID_VENDOR_SPECIFIC:
1589
1590                 update_bcn_vendor_spec_ie(padapter, oui);
1591
1592                 break;
1593
1594         default:
1595                 break;
1596         }
1597
1598         pmlmepriv->update_bcn = true;
1599
1600         spin_unlock_bh(&pmlmepriv->bcn_update_lock);
1601
1602         if (tx) {
1603                 /* send_beacon(padapter);//send_beacon must execute on TSR level */
1604                 set_tx_beacon_cmd(padapter);
1605         }
1606 }
1607
1608 /*
1609  * op_mode
1610  * Set to 0 (HT pure) under the following conditions
1611  *        - all STAs in the BSS are 20/40 MHz HT in 20/40 MHz BSS or
1612  *        - all STAs in the BSS are 20 MHz HT in 20 MHz BSS
1613  * Set to 1 (HT non-member protection) if there may be non-HT STAs
1614  *        in both the primary and the secondary channel
1615  * Set to 2 if only HT STAs are associated in BSS,
1616  *        however and at least one 20 MHz HT STA is associated
1617  * Set to 3 (HT mixed mode) when one or more non-HT STAs are associated
1618  *        (currently non-GF HT station is considered as non-HT STA also)
1619  */
1620 static int rtw_ht_operation_update(struct adapter *padapter)
1621 {
1622         u16 cur_op_mode, new_op_mode;
1623         int op_mode_changes = 0;
1624         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1625         struct ht_priv *phtpriv_ap = &pmlmepriv->htpriv;
1626
1627         if (pmlmepriv->htpriv.ht_option)
1628                 return 0;
1629
1630         if (!(pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT)
1631             && pmlmepriv->num_sta_ht_no_gf) {
1632                 pmlmepriv->ht_op_mode |=
1633                         IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT;
1634                 op_mode_changes++;
1635         } else if ((pmlmepriv->ht_op_mode &
1636                     IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT) &&
1637                    pmlmepriv->num_sta_ht_no_gf == 0) {
1638                 pmlmepriv->ht_op_mode &=
1639                         ~IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT;
1640                 op_mode_changes++;
1641         }
1642
1643         if (!(pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT) &&
1644             (pmlmepriv->num_sta_no_ht || pmlmepriv->olbc_ht)) {
1645                 pmlmepriv->ht_op_mode |= IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT;
1646                 op_mode_changes++;
1647         } else if ((pmlmepriv->ht_op_mode &
1648                     IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT) &&
1649                    (pmlmepriv->num_sta_no_ht == 0 && !pmlmepriv->olbc_ht)) {
1650                 pmlmepriv->ht_op_mode &=
1651                         ~IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT;
1652                 op_mode_changes++;
1653         }
1654
1655         /* Note: currently we switch to the MIXED op mode if HT non-greenfield
1656          * station is associated. Probably it's a theoretical case, since
1657          * it looks like all known HT STAs support greenfield.
1658          */
1659         new_op_mode = 0;
1660         if (pmlmepriv->num_sta_no_ht ||
1661             (pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT))
1662                 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED;
1663         else if (
1664                 (le16_to_cpu(phtpriv_ap->ht_cap.cap_info) & IEEE80211_HT_CAP_SUP_WIDTH)
1665                 && pmlmepriv->num_sta_ht_20mhz)
1666                 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_20MHZ;
1667         else if (pmlmepriv->olbc_ht)
1668                 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_NONMEMBER;
1669         else
1670                 new_op_mode = IEEE80211_HT_OP_MODE_PROTECTION_NONE;
1671
1672         cur_op_mode = pmlmepriv->ht_op_mode & IEEE80211_HT_OP_MODE_PROTECTION;
1673         if (cur_op_mode != new_op_mode) {
1674                 pmlmepriv->ht_op_mode &= ~IEEE80211_HT_OP_MODE_PROTECTION;
1675                 pmlmepriv->ht_op_mode |= new_op_mode;
1676                 op_mode_changes++;
1677         }
1678
1679         return op_mode_changes;
1680 }
1681
1682 void associated_clients_update(struct adapter *padapter, u8 updated)
1683 {
1684         /* update associated stations cap. */
1685         if (updated) {
1686                 struct list_head        *phead, *plist;
1687                 struct sta_info *psta = NULL;
1688                 struct sta_priv *pstapriv = &padapter->stapriv;
1689
1690                 spin_lock_bh(&pstapriv->asoc_list_lock);
1691
1692                 phead = &pstapriv->asoc_list;
1693                 /* check asoc_queue */
1694                 list_for_each(plist, phead) {
1695                         psta = list_entry(plist, struct sta_info, asoc_list);
1696
1697                         VCS_update(padapter, psta);
1698                 }
1699
1700                 spin_unlock_bh(&pstapriv->asoc_list_lock);
1701         }
1702 }
1703
1704 /* called > TSR LEVEL for USB or SDIO Interface*/
1705 void bss_cap_update_on_sta_join(struct adapter *padapter, struct sta_info *psta)
1706 {
1707         u8 beacon_updated = false;
1708         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1709         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1710
1711         if (!(psta->flags & WLAN_STA_SHORT_PREAMBLE)) {
1712                 if (!psta->no_short_preamble_set) {
1713                         psta->no_short_preamble_set = 1;
1714
1715                         pmlmepriv->num_sta_no_short_preamble++;
1716
1717                         if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
1718                             (pmlmepriv->num_sta_no_short_preamble == 1)) {
1719                                 beacon_updated = true;
1720                                 update_beacon(padapter, 0xFF, NULL, true);
1721                         }
1722                 }
1723         } else {
1724                 if (psta->no_short_preamble_set) {
1725                         psta->no_short_preamble_set = 0;
1726
1727                         pmlmepriv->num_sta_no_short_preamble--;
1728
1729                         if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
1730                             (pmlmepriv->num_sta_no_short_preamble == 0)) {
1731                                 beacon_updated = true;
1732                                 update_beacon(padapter, 0xFF, NULL, true);
1733                         }
1734                 }
1735         }
1736
1737         if (psta->flags & WLAN_STA_NONERP) {
1738                 if (!psta->nonerp_set) {
1739                         psta->nonerp_set = 1;
1740
1741                         pmlmepriv->num_sta_non_erp++;
1742
1743                         if (pmlmepriv->num_sta_non_erp == 1) {
1744                                 beacon_updated = true;
1745                                 update_beacon(padapter, WLAN_EID_ERP_INFO, NULL, true);
1746                         }
1747                 }
1748         } else {
1749                 if (psta->nonerp_set) {
1750                         psta->nonerp_set = 0;
1751
1752                         pmlmepriv->num_sta_non_erp--;
1753
1754                         if (pmlmepriv->num_sta_non_erp == 0) {
1755                                 beacon_updated = true;
1756                                 update_beacon(padapter, WLAN_EID_ERP_INFO, NULL, true);
1757                         }
1758                 }
1759         }
1760
1761         if (!(psta->capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)) {
1762                 if (!psta->no_short_slot_time_set) {
1763                         psta->no_short_slot_time_set = 1;
1764
1765                         pmlmepriv->num_sta_no_short_slot_time++;
1766
1767                         if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
1768                             (pmlmepriv->num_sta_no_short_slot_time == 1)) {
1769                                 beacon_updated = true;
1770                                 update_beacon(padapter, 0xFF, NULL, true);
1771                         }
1772                 }
1773         } else {
1774                 if (psta->no_short_slot_time_set) {
1775                         psta->no_short_slot_time_set = 0;
1776
1777                         pmlmepriv->num_sta_no_short_slot_time--;
1778
1779                         if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
1780                             (pmlmepriv->num_sta_no_short_slot_time == 0)) {
1781                                 beacon_updated = true;
1782                                 update_beacon(padapter, 0xFF, NULL, true);
1783                         }
1784                 }
1785         }
1786
1787         if (psta->flags & WLAN_STA_HT) {
1788                 u16 ht_capab = le16_to_cpu(psta->htpriv.ht_cap.cap_info);
1789
1790                 if (psta->no_ht_set) {
1791                         psta->no_ht_set = 0;
1792                         pmlmepriv->num_sta_no_ht--;
1793                 }
1794
1795                 if ((ht_capab & IEEE80211_HT_CAP_GRN_FLD) == 0) {
1796                         if (!psta->no_ht_gf_set) {
1797                                 psta->no_ht_gf_set = 1;
1798                                 pmlmepriv->num_sta_ht_no_gf++;
1799                         }
1800                 }
1801
1802                 if ((ht_capab & IEEE80211_HT_CAP_SUP_WIDTH) == 0) {
1803                         if (!psta->ht_20mhz_set) {
1804                                 psta->ht_20mhz_set = 1;
1805                                 pmlmepriv->num_sta_ht_20mhz++;
1806                         }
1807                 }
1808
1809         } else {
1810                 if (!psta->no_ht_set) {
1811                         psta->no_ht_set = 1;
1812                         pmlmepriv->num_sta_no_ht++;
1813                 }
1814         }
1815
1816         if (rtw_ht_operation_update(padapter) > 0) {
1817                 update_beacon(padapter, WLAN_EID_HT_CAPABILITY, NULL, false);
1818                 update_beacon(padapter, WLAN_EID_HT_OPERATION, NULL, true);
1819         }
1820
1821         /* update associated stations cap. */
1822         associated_clients_update(padapter,  beacon_updated);
1823 }
1824
1825 u8 bss_cap_update_on_sta_leave(struct adapter *padapter, struct sta_info *psta)
1826 {
1827         u8 beacon_updated = false;
1828         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1829         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1830
1831         if (!psta)
1832                 return beacon_updated;
1833
1834         if (psta->no_short_preamble_set) {
1835                 psta->no_short_preamble_set = 0;
1836                 pmlmepriv->num_sta_no_short_preamble--;
1837                 if (pmlmeext->cur_wireless_mode > WIRELESS_11B
1838                     && pmlmepriv->num_sta_no_short_preamble == 0){
1839                         beacon_updated = true;
1840                         update_beacon(padapter, 0xFF, NULL, true);
1841                 }
1842         }
1843
1844         if (psta->nonerp_set) {
1845                 psta->nonerp_set = 0;
1846                 pmlmepriv->num_sta_non_erp--;
1847                 if (pmlmepriv->num_sta_non_erp == 0) {
1848                         beacon_updated = true;
1849                         update_beacon(padapter, WLAN_EID_ERP_INFO, NULL, true);
1850                 }
1851         }
1852
1853         if (psta->no_short_slot_time_set) {
1854                 psta->no_short_slot_time_set = 0;
1855                 pmlmepriv->num_sta_no_short_slot_time--;
1856                 if (pmlmeext->cur_wireless_mode > WIRELESS_11B
1857                     && pmlmepriv->num_sta_no_short_slot_time == 0){
1858                         beacon_updated = true;
1859                         update_beacon(padapter, 0xFF, NULL, true);
1860                 }
1861         }
1862
1863         if (psta->no_ht_gf_set) {
1864                 psta->no_ht_gf_set = 0;
1865                 pmlmepriv->num_sta_ht_no_gf--;
1866         }
1867
1868         if (psta->no_ht_set) {
1869                 psta->no_ht_set = 0;
1870                 pmlmepriv->num_sta_no_ht--;
1871         }
1872
1873         if (psta->ht_20mhz_set) {
1874                 psta->ht_20mhz_set = 0;
1875                 pmlmepriv->num_sta_ht_20mhz--;
1876         }
1877
1878         if (rtw_ht_operation_update(padapter) > 0) {
1879                 update_beacon(padapter, WLAN_EID_HT_CAPABILITY, NULL, false);
1880                 update_beacon(padapter, WLAN_EID_HT_OPERATION, NULL, true);
1881         }
1882
1883         return beacon_updated;
1884 }
1885
1886 u8 ap_free_sta(
1887         struct adapter *padapter,
1888         struct sta_info *psta,
1889         bool active,
1890         u16 reason
1891 )
1892 {
1893         u8 beacon_updated = false;
1894
1895         if (!psta)
1896                 return beacon_updated;
1897
1898         if (active) {
1899                 /* tear down Rx AMPDU */
1900                 send_delba(padapter, 0, psta->hwaddr);/*  recipient */
1901
1902                 /* tear down TX AMPDU */
1903                 send_delba(padapter, 1, psta->hwaddr);/*  // originator */
1904
1905                 issue_deauth(padapter, psta->hwaddr, reason);
1906         }
1907
1908         psta->htpriv.agg_enable_bitmap = 0x0;/* reset */
1909         psta->htpriv.candidate_tid_bitmap = 0x0;/* reset */
1910
1911         /* report_del_sta_event(padapter, psta->hwaddr, reason); */
1912
1913         /* clear cam entry / key */
1914         rtw_clearstakey_cmd(padapter, psta, true);
1915
1916         spin_lock_bh(&psta->lock);
1917         psta->state &= ~_FW_LINKED;
1918         spin_unlock_bh(&psta->lock);
1919
1920         rtw_cfg80211_indicate_sta_disassoc(padapter, psta->hwaddr, reason);
1921
1922         report_del_sta_event(padapter, psta->hwaddr, reason);
1923
1924         beacon_updated = bss_cap_update_on_sta_leave(padapter, psta);
1925
1926         rtw_free_stainfo(padapter, psta);
1927
1928         return beacon_updated;
1929 }
1930
1931 void rtw_sta_flush(struct adapter *padapter)
1932 {
1933         struct list_head *phead, *plist, *tmp;
1934         struct sta_info *psta = NULL;
1935         struct sta_priv *pstapriv = &padapter->stapriv;
1936         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1937         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1938         u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1939
1940         if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)
1941                 return;
1942
1943         spin_lock_bh(&pstapriv->asoc_list_lock);
1944         phead = &pstapriv->asoc_list;
1945         /* free sta asoc_queue */
1946         list_for_each_safe(plist, tmp, phead) {
1947                 psta = list_entry(plist, struct sta_info, asoc_list);
1948
1949                 list_del_init(&psta->asoc_list);
1950                 pstapriv->asoc_list_cnt--;
1951
1952                 /* spin_unlock_bh(&pstapriv->asoc_list_lock); */
1953                 ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING);
1954                 /* spin_lock_bh(&pstapriv->asoc_list_lock); */
1955         }
1956         spin_unlock_bh(&pstapriv->asoc_list_lock);
1957
1958         issue_deauth(padapter, bc_addr, WLAN_REASON_DEAUTH_LEAVING);
1959
1960         associated_clients_update(padapter, true);
1961 }
1962
1963 /* called > TSR LEVEL for USB or SDIO Interface*/
1964 void sta_info_update(struct adapter *padapter, struct sta_info *psta)
1965 {
1966         int flags = psta->flags;
1967         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1968
1969         /* update wmm cap. */
1970         if (WLAN_STA_WME & flags)
1971                 psta->qos_option = 1;
1972         else
1973                 psta->qos_option = 0;
1974
1975         if (pmlmepriv->qospriv.qos_option == 0)
1976                 psta->qos_option = 0;
1977
1978         /* update 802.11n ht cap. */
1979         if (WLAN_STA_HT & flags) {
1980                 psta->htpriv.ht_option = true;
1981                 psta->qos_option = 1;
1982         } else {
1983                 psta->htpriv.ht_option = false;
1984         }
1985
1986         if (!pmlmepriv->htpriv.ht_option)
1987                 psta->htpriv.ht_option = false;
1988
1989         update_sta_info_apmode(padapter, psta);
1990 }
1991
1992 /* called >= TSR LEVEL for USB or SDIO Interface*/
1993 void ap_sta_info_defer_update(struct adapter *padapter, struct sta_info *psta)
1994 {
1995         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1996         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1997
1998         if (psta->state & _FW_LINKED) {
1999                 pmlmeinfo->FW_sta_info[psta->mac_id].psta = psta;
2000
2001                 /* add ratid */
2002                 add_RATid(padapter, psta, 0);/* DM_RATR_STA_INIT */
2003         }
2004 }
2005 /* restore hw setting from sw data structures */
2006 void rtw_ap_restore_network(struct adapter *padapter)
2007 {
2008         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2009         struct sta_priv *pstapriv = &padapter->stapriv;
2010         struct sta_info *psta;
2011         struct security_priv *psecuritypriv = &(padapter->securitypriv);
2012         struct list_head        *phead, *plist;
2013         u8 chk_alive_num = 0;
2014         char chk_alive_list[NUM_STA];
2015         int i;
2016
2017         rtw_setopmode_cmd(padapter, Ndis802_11APMode, false);
2018
2019         set_channel_bwmode(
2020                 padapter,
2021                 pmlmeext->cur_channel,
2022                 pmlmeext->cur_ch_offset,
2023                 pmlmeext->cur_bwmode
2024         );
2025
2026         start_bss_network(padapter);
2027
2028         if ((padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_) ||
2029             (padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)) {
2030                 /* restore group key, WEP keys is restored in ips_leave() */
2031                 rtw_set_key(
2032                         padapter,
2033                         psecuritypriv,
2034                         psecuritypriv->dot118021XGrpKeyid,
2035                         0,
2036                         false
2037                 );
2038         }
2039
2040         spin_lock_bh(&pstapriv->asoc_list_lock);
2041
2042         phead = &pstapriv->asoc_list;
2043         list_for_each(plist, phead) {
2044                 int stainfo_offset;
2045
2046                 psta = list_entry(plist, struct sta_info, asoc_list);
2047
2048                 stainfo_offset = rtw_stainfo_offset(pstapriv, psta);
2049                 if (stainfo_offset_valid(stainfo_offset))
2050                         chk_alive_list[chk_alive_num++] = stainfo_offset;
2051         }
2052
2053         spin_unlock_bh(&pstapriv->asoc_list_lock);
2054
2055         for (i = 0; i < chk_alive_num; i++) {
2056                 psta = rtw_get_stainfo_by_offset(pstapriv, chk_alive_list[i]);
2057
2058                 if (!psta)
2059                         continue;
2060
2061                 if (psta->state & _FW_LINKED) {
2062                         rtw_sta_media_status_rpt(padapter, psta, 1);
2063                         Update_RA_Entry(padapter, psta);
2064                         /* pairwise key */
2065                         /* per sta pairwise key and settings */
2066                         if ((psecuritypriv->dot11PrivacyAlgrthm == _TKIP_) ||
2067                             (psecuritypriv->dot11PrivacyAlgrthm == _AES_)) {
2068                                 rtw_setstakey_cmd(padapter, psta, true, false);
2069                         }
2070                 }
2071         }
2072 }
2073
2074 void start_ap_mode(struct adapter *padapter)
2075 {
2076         int i;
2077         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2078         struct sta_priv *pstapriv = &padapter->stapriv;
2079         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2080         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
2081
2082         pmlmepriv->update_bcn = false;
2083
2084         /* init_mlme_ap_info(padapter); */
2085         pmlmeext->bstart_bss = false;
2086
2087         pmlmepriv->num_sta_non_erp = 0;
2088
2089         pmlmepriv->num_sta_no_short_slot_time = 0;
2090
2091         pmlmepriv->num_sta_no_short_preamble = 0;
2092
2093         pmlmepriv->num_sta_ht_no_gf = 0;
2094         pmlmepriv->num_sta_no_ht = 0;
2095         pmlmepriv->num_sta_ht_20mhz = 0;
2096
2097         pmlmepriv->olbc = false;
2098
2099         pmlmepriv->olbc_ht = false;
2100
2101         pmlmepriv->ht_op_mode = 0;
2102
2103         for (i = 0; i < NUM_STA; i++)
2104                 pstapriv->sta_aid[i] = NULL;
2105
2106         pmlmepriv->wps_beacon_ie = NULL;
2107         pmlmepriv->wps_probe_resp_ie = NULL;
2108         pmlmepriv->wps_assoc_resp_ie = NULL;
2109
2110         pmlmepriv->p2p_beacon_ie = NULL;
2111         pmlmepriv->p2p_probe_resp_ie = NULL;
2112
2113         /* for ACL */
2114         INIT_LIST_HEAD(&(pacl_list->acl_node_q.queue));
2115         pacl_list->num = 0;
2116         pacl_list->mode = 0;
2117         for (i = 0; i < NUM_ACL; i++) {
2118                 INIT_LIST_HEAD(&pacl_list->aclnode[i].list);
2119                 pacl_list->aclnode[i].valid = false;
2120         }
2121 }
2122
2123 void stop_ap_mode(struct adapter *padapter)
2124 {
2125         struct list_head *phead, *plist, *tmp;
2126         struct rtw_wlan_acl_node *paclnode;
2127         struct sta_info *psta = NULL;
2128         struct sta_priv *pstapriv = &padapter->stapriv;
2129         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2130         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2131         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
2132         struct __queue  *pacl_node_q = &pacl_list->acl_node_q;
2133
2134         pmlmepriv->update_bcn = false;
2135         pmlmeext->bstart_bss = false;
2136
2137         /* reset and init security priv , this can refine with rtw_reset_securitypriv */
2138         memset(
2139                 (unsigned char *)&padapter->securitypriv,
2140                 0,
2141                 sizeof(struct security_priv)
2142         );
2143         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen;
2144         padapter->securitypriv.ndisencryptstatus = Ndis802_11WEPDisabled;
2145
2146         /* for ACL */
2147         spin_lock_bh(&(pacl_node_q->lock));
2148         phead = get_list_head(pacl_node_q);
2149         list_for_each_safe(plist, tmp, phead) {
2150                 paclnode = list_entry(plist, struct rtw_wlan_acl_node, list);
2151
2152                 if (paclnode->valid) {
2153                         paclnode->valid = false;
2154
2155                         list_del_init(&paclnode->list);
2156
2157                         pacl_list->num--;
2158                 }
2159         }
2160         spin_unlock_bh(&(pacl_node_q->lock));
2161
2162         rtw_sta_flush(padapter);
2163
2164         /* free_assoc_sta_resources */
2165         rtw_free_all_stainfo(padapter);
2166
2167         psta = rtw_get_bcmc_stainfo(padapter);
2168         rtw_free_stainfo(padapter, psta);
2169
2170         rtw_init_bcmc_stainfo(padapter);
2171
2172         rtw_free_mlme_priv_ie_data(pmlmepriv);
2173
2174         rtw_btcoex_MediaStatusNotify(padapter, 0); /* disconnect */
2175 }