drivers/staging/rtl8188eu/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 <linux/ieee80211.h>
  10
  11 #include <osdep_service.h>
  12 #include <drv_types.h>
  13 #include <wifi.h>
  14 #include <ieee80211.h>
  15 #include <asm/unaligned.h>
  16
  17 #ifdef CONFIG_88EU_AP_MODE
  18
  19 void init_mlme_ap_info(struct adapter *padapter)
  20 {
  21         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
  22         struct sta_priv *pstapriv = &padapter->stapriv;
  23         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
  24
  25         spin_lock_init(&pmlmepriv->bcn_update_lock);
  26
  27         /* for ACL */
  28         _rtw_init_queue(&pacl_list->acl_node_q);
  29
  30         start_ap_mode(padapter);
  31 }
  32
  33 void free_mlme_ap_info(struct adapter *padapter)
  34 {
  35         struct sta_info *psta = NULL;
  36         struct sta_priv *pstapriv = &padapter->stapriv;
  37         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
  38         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
  39         struct mlme_ext_info    *pmlmeinfo = &pmlmeext->mlmext_info;
  40
  41         pmlmepriv->update_bcn = false;
  42         pmlmeext->bstart_bss = false;
  43
  44         rtw_sta_flush(padapter);
  45
  46         pmlmeinfo->state = _HW_STATE_NOLINK_;
  47
  48         /* free_assoc_sta_resources */
  49         rtw_free_all_stainfo(padapter);
  50
  51         /* free bc/mc sta_info */
  52         psta = rtw_get_bcmc_stainfo(padapter);
  53         spin_lock_bh(&pstapriv->sta_hash_lock);
  54         rtw_free_stainfo(padapter, psta);
  55         spin_unlock_bh(&pstapriv->sta_hash_lock);
  56 }
  57
  58 static void update_BCNTIM(struct adapter *padapter)
  59 {
  60         struct sta_priv *pstapriv = &padapter->stapriv;
  61         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
  62         struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
  63         struct wlan_bssid_ex *pnetwork_mlmeext = &pmlmeinfo->network;
  64         unsigned char *pie = pnetwork_mlmeext->ies;
  65         u8 *p, *dst_ie, *premainder_ie = NULL;
  66         u8 *pbackup_remainder_ie = NULL;
  67         uint offset, tmp_len, tim_ielen, tim_ie_offset, remainder_ielen;
  68
  69         /* update TIM IE */
  70         p = rtw_get_ie(pie + _FIXED_IE_LENGTH_, _TIM_IE_, &tim_ielen,
  71                        pnetwork_mlmeext->ie_length - _FIXED_IE_LENGTH_);
  72         if (p && tim_ielen > 0) {
  73                 tim_ielen += 2;
  74                 premainder_ie = p + tim_ielen;
  75                 tim_ie_offset = (int)(p - pie);
  76                 remainder_ielen = pnetwork_mlmeext->ie_length -
  77                                         tim_ie_offset - tim_ielen;
  78                 /* append TIM IE from dst_ie offset */
  79                 dst_ie = p;
  80         } else {
  81                 tim_ielen = 0;
  82
  83                 /* calculate head_len */
  84                 offset = _FIXED_IE_LENGTH_;
  85                 offset += pnetwork_mlmeext->ssid.ssid_length + 2;
  86
  87                 /*  get supported rates len */
  88                 p = rtw_get_ie(pie + _BEACON_IE_OFFSET_, _SUPPORTEDRATES_IE_,
  89                                &tmp_len, (pnetwork_mlmeext->ie_length -
  90                                           _BEACON_IE_OFFSET_));
  91                 if (p)
  92                         offset += tmp_len + 2;
  93
  94                 /* DS Parameter Set IE, len = 3 */
  95                 offset += 3;
  96
  97                 premainder_ie = pie + offset;
  98
  99                 remainder_ielen = pnetwork_mlmeext->ie_length -
 100                                         offset - tim_ielen;
 101
 102                 /* append TIM IE from offset */
 103                 dst_ie = pie + offset;
 104         }
 105
 106         if (remainder_ielen > 0) {
 107                 pbackup_remainder_ie = rtw_malloc(remainder_ielen);
 108                 if (pbackup_remainder_ie && premainder_ie)
 109                         memcpy(pbackup_remainder_ie, premainder_ie,
 110                                remainder_ielen);
 111         }
 112         *dst_ie++ = _TIM_IE_;
 113
 114         if ((pstapriv->tim_bitmap & 0xff00) && (pstapriv->tim_bitmap & 0x00fc))
 115                 tim_ielen = 5;
 116         else
 117                 tim_ielen = 4;
 118
 119         *dst_ie++ = tim_ielen;
 120
 121         *dst_ie++ = 0;/* DTIM count */
 122         *dst_ie++ = 1;/* DTIM period */
 123
 124         if (pstapriv->tim_bitmap & BIT(0))/* for bc/mc frames */
 125                 *dst_ie++ = BIT(0);/* bitmap ctrl */
 126         else
 127                 *dst_ie++ = 0;
 128
 129         if (tim_ielen == 4) {
 130                 *dst_ie++ = pstapriv->tim_bitmap & 0xff;
 131         } else if (tim_ielen == 5) {
 132                 put_unaligned_le16(pstapriv->tim_bitmap, dst_ie);
 133                 dst_ie += 2;
 134         }
 135
 136         /* copy remainder IE */
 137         if (pbackup_remainder_ie) {
 138                 memcpy(dst_ie, pbackup_remainder_ie, remainder_ielen);
 139
 140                 kfree(pbackup_remainder_ie);
 141         }
 142         offset =  (uint)(dst_ie - pie);
 143         pnetwork_mlmeext->ie_length = offset + remainder_ielen;
 144
 145         set_tx_beacon_cmd(padapter);
 146 }
 147
 148 static u8 chk_sta_is_alive(struct sta_info *psta)
 149 {
 150         u8 ret = false;
 151
 152         if ((psta->sta_stats.last_rx_data_pkts +
 153                         psta->sta_stats.last_rx_ctrl_pkts) ==
 154                         (psta->sta_stats.rx_data_pkts +
 155                         psta->sta_stats.rx_ctrl_pkts))
 156                 ;
 157         else
 158                 ret = true;
 159
 160         sta_update_last_rx_pkts(psta);
 161
 162         return ret;
 163 }
 164
 165 void expire_timeout_chk(struct adapter *padapter)
 166 {
 167         struct list_head *phead, *plist;
 168         u8 updated = 0;
 169         struct sta_info *psta = NULL;
 170         struct sta_priv *pstapriv = &padapter->stapriv;
 171         u8 chk_alive_num = 0;
 172         char chk_alive_list[NUM_STA];
 173         int i;
 174
 175         spin_lock_bh(&pstapriv->auth_list_lock);
 176
 177         phead = &pstapriv->auth_list;
 178         plist = phead->next;
 179
 180         /* check auth_queue */
 181         while (phead != plist) {
 182                 psta = container_of(plist, struct sta_info, auth_list);
 183                 plist = plist->next;
 184
 185                 if (psta->expire_to > 0) {
 186                         psta->expire_to--;
 187                         if (psta->expire_to == 0) {
 188                                 list_del_init(&psta->auth_list);
 189                                 pstapriv->auth_list_cnt--;
 190
 191                                 DBG_88E("auth expire %6ph\n",
 192                                         psta->hwaddr);
 193
 194                                 spin_unlock_bh(&pstapriv->auth_list_lock);
 195
 196                                 spin_lock_bh(&pstapriv->sta_hash_lock);
 197                                 rtw_free_stainfo(padapter, psta);
 198                                 spin_unlock_bh(&pstapriv->sta_hash_lock);
 199
 200                                 spin_lock_bh(&pstapriv->auth_list_lock);
 201                         }
 202                 }
 203         }
 204         spin_unlock_bh(&pstapriv->auth_list_lock);
 205
 206         psta = NULL;
 207
 208         spin_lock_bh(&pstapriv->asoc_list_lock);
 209
 210         phead = &pstapriv->asoc_list;
 211         plist = phead->next;
 212
 213         /* check asoc_queue */
 214         while (phead != plist) {
 215                 psta = container_of(plist, struct sta_info, asoc_list);
 216                 plist = plist->next;
 217
 218                 if (chk_sta_is_alive(psta) || !psta->expire_to) {
 219                         psta->expire_to = pstapriv->expire_to;
 220                         psta->keep_alive_trycnt = 0;
 221                         psta->under_exist_checking = 0;
 222                 } else {
 223                         psta->expire_to--;
 224                 }
 225
 226                 if (psta->expire_to <= 0) {
 227                         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 228
 229                         if (padapter->registrypriv.wifi_spec == 1) {
 230                                 psta->expire_to = pstapriv->expire_to;
 231                                 continue;
 232                         }
 233
 234                         if (psta->state & WIFI_SLEEP_STATE) {
 235                                 if (!(psta->state & WIFI_STA_ALIVE_CHK_STATE)) {
 236                                         /* to check if alive by another methods
 237                                          * if station is at ps mode.
 238                                          */
 239                                         psta->expire_to = pstapriv->expire_to;
 240                                         psta->state |= WIFI_STA_ALIVE_CHK_STATE;
 241
 242                                         /* to update bcn with tim_bitmap
 243                                          * for this station
 244                                          */
 245                                         pstapriv->tim_bitmap |= BIT(psta->aid);
 246                                         update_beacon(padapter, _TIM_IE_, NULL,
 247                                                       false);
 248
 249                                         if (!pmlmeext->active_keep_alive_check)
 250                                                 continue;
 251                                 }
 252                         }
 253                         if (pmlmeext->active_keep_alive_check) {
 254                                 int stainfo_offset;
 255
 256                                 stainfo_offset =
 257                                         rtw_stainfo_offset(pstapriv, psta);
 258                                 if (stainfo_offset_valid(stainfo_offset))
 259                                         chk_alive_list[chk_alive_num++] =
 260                                                 stainfo_offset;
 261                                 continue;
 262                         }
 263
 264                         list_del_init(&psta->asoc_list);
 265                         pstapriv->asoc_list_cnt--;
 266
 267                         DBG_88E("asoc expire %pM, state = 0x%x\n",
 268                                 (psta->hwaddr), psta->state);
 269                         updated = ap_free_sta(padapter, psta, true,
 270                                               WLAN_REASON_DEAUTH_LEAVING);
 271                 } else {
 272                         /* TODO: Aging mechanism to digest frames in sleep_q to avoid running out of xmitframe */
 273                         if (psta->sleepq_len > (NR_XMITFRAME / pstapriv->asoc_list_cnt) &&
 274                             padapter->xmitpriv.free_xmitframe_cnt < (NR_XMITFRAME / pstapriv->asoc_list_cnt / 2)) {
 275                                 DBG_88E("%s sta:%pM, sleepq_len:%u, free_xmitframe_cnt:%u, asoc_list_cnt:%u, clear sleep_q\n", __func__,
 276                                         (psta->hwaddr), psta->sleepq_len,
 277                                         padapter->xmitpriv.free_xmitframe_cnt,
 278                                         pstapriv->asoc_list_cnt);
 279                                 wakeup_sta_to_xmit(padapter, psta);
 280                         }
 281                 }
 282         }
 283
 284         spin_unlock_bh(&pstapriv->asoc_list_lock);
 285
 286         if (chk_alive_num) {
 287                 u8 backup_oper_channel = 0;
 288                 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 289                 /* switch to correct channel of current network  before issue keep-alive frames */
 290                 if (rtw_get_oper_ch(padapter) != pmlmeext->cur_channel) {
 291                         backup_oper_channel = rtw_get_oper_ch(padapter);
 292                         SelectChannel(padapter, pmlmeext->cur_channel);
 293                 }
 294
 295                 /* issue null data to check sta alive*/
 296                 for (i = 0; i < chk_alive_num; i++) {
 297                         int ret = _FAIL;
 298
 299                         psta = rtw_get_stainfo_by_offset(pstapriv,
 300                                                          chk_alive_list[i]);
 301
 302                         if (psta->state & WIFI_SLEEP_STATE) {
 303                                 ret = issue_nulldata(padapter, psta->hwaddr,
 304                                                      0, 1, 50);
 305                         } else {
 306                                 ret = issue_nulldata(padapter, psta->hwaddr,
 307                                                      0, 3, 50);
 308                         }
 309
 310                         psta->keep_alive_trycnt++;
 311                         if (ret == _SUCCESS) {
 312                                 DBG_88E("asoc check, sta(%pM) is alive\n",
 313                                         (psta->hwaddr));
 314                                 psta->expire_to = pstapriv->expire_to;
 315                                 psta->keep_alive_trycnt = 0;
 316                                 continue;
 317                         } else if (psta->keep_alive_trycnt <= 3) {
 318                                 DBG_88E("ack check for asoc expire, keep_alive_trycnt =%d\n", psta->keep_alive_trycnt);
 319                                 psta->expire_to = 1;
 320                                 continue;
 321                         }
 322
 323                         psta->keep_alive_trycnt = 0;
 324
 325                         DBG_88E("asoc expire %pM, state = 0x%x\n",
 326                                 psta->hwaddr, psta->state);
 327                         spin_lock_bh(&pstapriv->asoc_list_lock);
 328                         list_del_init(&psta->asoc_list);
 329                         pstapriv->asoc_list_cnt--;
 330                         updated = ap_free_sta(padapter, psta, true,
 331                                               WLAN_REASON_DEAUTH_LEAVING);
 332                         spin_unlock_bh(&pstapriv->asoc_list_lock);
 333                 }
 334
 335                 if (backup_oper_channel > 0) /* back to the original operation channel */
 336                         SelectChannel(padapter, backup_oper_channel);
 337         }
 338
 339         associated_clients_update(padapter, updated);
 340 }
 341
 342 void add_RATid(struct adapter *padapter, struct sta_info *psta, u8 rssi_level)
 343 {
 344         int i;
 345         u32 init_rate = 0;
 346         unsigned char sta_band = 0, raid, shortGIrate = false;
 347         unsigned int tx_ra_bitmap = 0;
 348         struct ht_priv  *psta_ht = NULL;
 349
 350         if (psta)
 351                 psta_ht = &psta->htpriv;
 352         else
 353                 return;
 354
 355         if (!(psta->state & _FW_LINKED))
 356                 return;
 357
 358         /* b/g mode ra_bitmap */
 359         for (i = 0; i < sizeof(psta->bssrateset); i++) {
 360                 if (psta->bssrateset[i])
 361                         tx_ra_bitmap |= rtw_get_bit_value_from_ieee_value(psta->bssrateset[i] & 0x7f);
 362         }
 363         /* n mode ra_bitmap */
 364         if (psta_ht->ht_option) {
 365                 for (i = 0; i < 8; i++)
 366                         if (psta_ht->ht_cap.mcs.rx_mask[0] & BIT(i))
 367                                 tx_ra_bitmap |= BIT(i + 12);
 368
 369                 /* max short GI rate */
 370                 shortGIrate = psta_ht->sgi;
 371         }
 372
 373         if (tx_ra_bitmap & 0xffff000)
 374                 sta_band |= WIRELESS_11_24N | WIRELESS_11G | WIRELESS_11B;
 375         else if (tx_ra_bitmap & 0xff0)
 376                 sta_band |= WIRELESS_11G | WIRELESS_11B;
 377         else
 378                 sta_band |= WIRELESS_11B;
 379
 380         psta->wireless_mode = sta_band;
 381
 382         raid = networktype_to_raid(sta_band);
 383         init_rate = get_highest_rate_idx(tx_ra_bitmap & 0x0fffffff) & 0x3f;
 384
 385         if (psta->aid < NUM_STA) {
 386                 u8 arg = 0;
 387
 388                 arg = psta->mac_id & 0x1f;
 389
 390                 arg |= BIT(7);/* support entry 2~31 */
 391
 392                 if (shortGIrate)
 393                         arg |= BIT(5);
 394
 395                 tx_ra_bitmap |= ((raid << 28) & 0xf0000000);
 396
 397                 DBG_88E("%s => mac_id:%d , raid:%d , bitmap = 0x%x, arg = 0x%x\n",
 398                         __func__, psta->mac_id, raid, tx_ra_bitmap, arg);
 399
 400                 /* bitmap[0:27] = tx_rate_bitmap */
 401                 /* bitmap[28:31]= Rate Adaptive id */
 402                 /* arg[0:4] = macid */
 403                 /* arg[5] = Short GI */
 404                 rtw_hal_add_ra_tid(padapter, tx_ra_bitmap, arg, rssi_level);
 405
 406                 if (shortGIrate)
 407                         init_rate |= BIT(6);
 408
 409                 /* set ra_id, init_rate */
 410                 psta->raid = raid;
 411                 psta->init_rate = init_rate;
 412
 413         } else {
 414                 DBG_88E("station aid %d exceed the max number\n", psta->aid);
 415         }
 416 }
 417
 418 static void update_bmc_sta(struct adapter *padapter)
 419 {
 420         u32 init_rate = 0;
 421         unsigned char   network_type, raid;
 422         int i, supportRateNum = 0;
 423         unsigned int tx_ra_bitmap = 0;
 424         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 425         struct wlan_bssid_ex *pcur_network = &pmlmepriv->cur_network.network;
 426         struct sta_info *psta = rtw_get_bcmc_stainfo(padapter);
 427
 428         if (psta) {
 429                 psta->aid = 0;/* default set to 0 */
 430                 psta->mac_id = psta->aid + 1;
 431
 432                 psta->qos_option = 0;
 433                 psta->htpriv.ht_option = false;
 434
 435                 psta->ieee8021x_blocked = 0;
 436
 437                 memset(&psta->sta_stats, 0, sizeof(struct stainfo_stats));
 438
 439                 /* prepare for add_RATid */
 440                 supportRateNum = rtw_get_rateset_len((u8 *)&pcur_network->SupportedRates);
 441                 network_type = rtw_check_network_type((u8 *)&pcur_network->SupportedRates);
 442
 443                 memcpy(psta->bssrateset, &pcur_network->SupportedRates,
 444                        supportRateNum);
 445                 psta->bssratelen = supportRateNum;
 446
 447                 /* b/g mode ra_bitmap */
 448                 for (i = 0; i < supportRateNum; i++) {
 449                         if (psta->bssrateset[i])
 450                                 tx_ra_bitmap |= rtw_get_bit_value_from_ieee_value(psta->bssrateset[i] & 0x7f);
 451                 }
 452
 453                 /* force to b mode */
 454                 network_type = WIRELESS_11B;
 455                 tx_ra_bitmap = 0xf;
 456
 457                 raid = networktype_to_raid(network_type);
 458                 init_rate = get_highest_rate_idx(tx_ra_bitmap & 0x0fffffff) &
 459                             0x3f;
 460
 461                 /* ap mode */
 462                 rtw_hal_set_odm_var(padapter, HAL_ODM_STA_INFO, psta, true);
 463
 464                 {
 465                         u8 arg = 0;
 466
 467                         arg = psta->mac_id & 0x1f;
 468                         arg |= BIT(7);
 469                         tx_ra_bitmap |= ((raid << 28) & 0xf0000000);
 470                         DBG_88E("%s, mask = 0x%x, arg = 0x%x\n", __func__,
 471                                 tx_ra_bitmap, arg);
 472
 473                         /* bitmap[0:27] = tx_rate_bitmap */
 474                         /* bitmap[28:31]= Rate Adaptive id */
 475                         /* arg[0:4] = macid */
 476                         /* arg[5] = Short GI */
 477                         rtw_hal_add_ra_tid(padapter, tx_ra_bitmap, arg, 0);
 478                 }
 479                 /* set ra_id, init_rate */
 480                 psta->raid = raid;
 481                 psta->init_rate = init_rate;
 482
 483                 rtw_stassoc_hw_rpt(padapter, psta);
 484
 485                 spin_lock_bh(&psta->lock);
 486                 psta->state = _FW_LINKED;
 487                 spin_unlock_bh(&psta->lock);
 488
 489         } else {
 490                 DBG_88E("add_RATid_bmc_sta error!\n");
 491         }
 492 }
 493
 494 /* notes: */
 495 /* AID: 1~MAX for sta and 0 for bc/mc in ap/adhoc mode */
 496 /* MAC_ID = AID+1 for sta in ap/adhoc mode */
 497 /* MAC_ID = 1 for bc/mc for sta/ap/adhoc */
 498 /* MAC_ID = 0 for bssid for sta/ap/adhoc */
 499 /* CAM_ID = 0~3 for default key, cmd_id = macid + 3, macid = aid+1; */
 500
 501 void update_sta_info_apmode(struct adapter *padapter, struct sta_info *psta)
 502 {
 503         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 504         struct security_priv *psecuritypriv = &padapter->securitypriv;
 505         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 506         struct ht_priv  *phtpriv_ap = &pmlmepriv->htpriv;
 507         struct ht_priv  *phtpriv_sta = &psta->htpriv;
 508
 509         psta->mac_id = psta->aid + 1;
 510         DBG_88E("%s\n", __func__);
 511
 512         /* ap mode */
 513         rtw_hal_set_odm_var(padapter, HAL_ODM_STA_INFO, psta, true);
 514
 515         if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
 516                 psta->ieee8021x_blocked = true;
 517         else
 518                 psta->ieee8021x_blocked = false;
 519
 520         /* update sta's cap */
 521
 522         /* ERP */
 523         VCS_update(padapter, psta);
 524         /* HT related cap */
 525         if (phtpriv_sta->ht_option) {
 526                 /* check if sta supports rx ampdu */
 527                 phtpriv_sta->ampdu_enable = phtpriv_ap->ampdu_enable;
 528
 529                 /* check if sta support s Short GI */
 530                 if (le16_to_cpu(phtpriv_sta->ht_cap.cap_info &
 531                                 phtpriv_ap->ht_cap.cap_info) &
 532                     (IEEE80211_HT_CAP_SGI_20 | IEEE80211_HT_CAP_SGI_40))
 533                         phtpriv_sta->sgi = true;
 534
 535                 /*  bwmode */
 536                 if (le16_to_cpu(phtpriv_sta->ht_cap.cap_info &
 537                                 phtpriv_ap->ht_cap.cap_info) &
 538                     IEEE80211_HT_CAP_SUP_WIDTH_20_40) {
 539                         phtpriv_sta->bwmode = pmlmeext->cur_bwmode;
 540                         phtpriv_sta->ch_offset = pmlmeext->cur_ch_offset;
 541                 }
 542                 psta->qos_option = true;
 543         } else {
 544                 phtpriv_sta->ampdu_enable = false;
 545                 phtpriv_sta->sgi = false;
 546                 phtpriv_sta->bwmode = HT_CHANNEL_WIDTH_20;
 547                 phtpriv_sta->ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
 548         }
 549
 550         /* Rx AMPDU */
 551         send_delba(padapter, 0, psta->hwaddr);/*  recipient */
 552
 553         /* TX AMPDU */
 554         send_delba(padapter, 1, psta->hwaddr);/* originator */
 555         phtpriv_sta->agg_enable_bitmap = 0x0;/* reset */
 556         phtpriv_sta->candidate_tid_bitmap = 0x0;/* reset */
 557
 558         /* todo: init other variables */
 559
 560         memset(&psta->sta_stats, 0, sizeof(struct stainfo_stats));
 561
 562         spin_lock_bh(&psta->lock);
 563         psta->state |= _FW_LINKED;
 564         spin_unlock_bh(&psta->lock);
 565 }
 566
 567 static void update_hw_ht_param(struct adapter *padapter)
 568 {
 569         u8 max_ampdu_len;
 570         u8 min_mpdu_spacing;
 571         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 572         struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
 573
 574         DBG_88E("%s\n", __func__);
 575
 576         /* handle A-MPDU parameter field
 577          * ampdu_params_info [1:0]:Max AMPDU Len => 0:8k , 1:16k, 2:32k, 3:64k
 578          * ampdu_params_info [4:2]:Min MPDU Start Spacing
 579          */
 580         max_ampdu_len = pmlmeinfo->HT_caps.ampdu_params_info & 0x03;
 581         min_mpdu_spacing = (pmlmeinfo->HT_caps.ampdu_params_info & 0x1c) >> 2;
 582
 583         rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_MIN_SPACE, &min_mpdu_spacing);
 584         rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_FACTOR, &max_ampdu_len);
 585
 586         /* Config SM Power Save setting */
 587         pmlmeinfo->SM_PS = (le16_to_cpu(pmlmeinfo->HT_caps.cap_info) & 0x0C) >> 2;
 588         if (pmlmeinfo->SM_PS == WLAN_HT_CAP_SM_PS_STATIC)
 589                 DBG_88E("%s(): WLAN_HT_CAP_SM_PS_STATIC\n", __func__);
 590 }
 591
 592 static void start_bss_network(struct adapter *padapter, u8 *pbuf)
 593 {
 594         u8 *p;
 595         u8 val8, cur_channel, cur_bwmode, cur_ch_offset;
 596         u16 bcn_interval;
 597         u32     acparm;
 598         uint    ie_len;
 599         struct registry_priv     *pregpriv = &padapter->registrypriv;
 600         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 601         struct security_priv *psecuritypriv = &padapter->securitypriv;
 602         struct wlan_bssid_ex *pnetwork = &pmlmepriv->cur_network.network;
 603         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 604         struct mlme_ext_info    *pmlmeinfo = &pmlmeext->mlmext_info;
 605         struct wlan_bssid_ex *pnetwork_mlmeext = &pmlmeinfo->network;
 606         struct HT_info_element *pht_info = NULL;
 607
 608         bcn_interval = (u16)pnetwork->Configuration.BeaconPeriod;
 609         cur_channel = pnetwork->Configuration.DSConfig;
 610         cur_bwmode = HT_CHANNEL_WIDTH_20;
 611         cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
 612
 613         /* check if there is wps ie,
 614          * if there is wpsie in beacon, the hostapd will update
 615          * beacon twice when stating hostapd, and at first time the
 616          * security ie (RSN/WPA IE) will not include in beacon.
 617          */
 618         if (!rtw_get_wps_ie(pnetwork->ies + _FIXED_IE_LENGTH_, pnetwork->ie_length - _FIXED_IE_LENGTH_, NULL, NULL))
 619                 pmlmeext->bstart_bss = true;
 620
 621         /* todo: update wmm, ht cap */
 622         if (pmlmepriv->qospriv.qos_option)
 623                 pmlmeinfo->WMM_enable = true;
 624         if (pmlmepriv->htpriv.ht_option) {
 625                 pmlmeinfo->WMM_enable = true;
 626                 pmlmeinfo->HT_enable = true;
 627
 628                 update_hw_ht_param(padapter);
 629         }
 630
 631         /* setting only at  first time */
 632         if (!pmlmepriv->cur_network.join_res) {
 633                 /* WEP Key will be set before this function, do not
 634                  * clear CAM.
 635                  */
 636                 if ((psecuritypriv->dot11PrivacyAlgrthm != _WEP40_) &&
 637                     (psecuritypriv->dot11PrivacyAlgrthm != _WEP104_))
 638                         flush_all_cam_entry(padapter);  /* clear CAM */
 639         }
 640
 641         /* set MSR to AP_Mode */
 642         Set_MSR(padapter, _HW_STATE_AP_);
 643
 644         /* Set BSSID REG */
 645         rtw_hal_set_hwreg(padapter, HW_VAR_BSSID, pnetwork->MacAddress);
 646
 647         /* Set EDCA param reg */
 648         acparm = 0x002F3217; /*  VO */
 649         rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_VO, (u8 *)(&acparm));
 650         acparm = 0x005E4317; /*  VI */
 651         rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_VI, (u8 *)(&acparm));
 652         acparm = 0x005ea42b;
 653         rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_BE, (u8 *)(&acparm));
 654         acparm = 0x0000A444; /*  BK */
 655         rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_BK, (u8 *)(&acparm));
 656
 657         /* Set Security */
 658         val8 = (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) ? 0xcc : 0xcf;
 659         rtw_hal_set_hwreg(padapter, HW_VAR_SEC_CFG, (u8 *)(&val8));
 660
 661         /* Beacon Control related register */
 662         rtw_hal_set_hwreg(padapter, HW_VAR_BEACON_INTERVAL,
 663                           (u8 *)(&bcn_interval));
 664
 665         UpdateBrateTbl(padapter, pnetwork->SupportedRates);
 666         rtw_hal_set_hwreg(padapter, HW_VAR_BASIC_RATE, pnetwork->SupportedRates);
 667
 668         if (!pmlmepriv->cur_network.join_res) { /* setting only at  first time */
 669                 /* turn on all dynamic functions */
 670                 Switch_DM_Func(padapter, DYNAMIC_ALL_FUNC_ENABLE, true);
 671         }
 672         /* set channel, bwmode */
 673         p = rtw_get_ie(pnetwork->ies + sizeof(struct ndis_802_11_fixed_ie),
 674                        _HT_ADD_INFO_IE_, &ie_len,
 675                        pnetwork->ie_length -
 676                        sizeof(struct ndis_802_11_fixed_ie));
 677         if (p && ie_len) {
 678                 pht_info = (struct HT_info_element *)(p + 2);
 679
 680                 if ((pregpriv->cbw40_enable) &&  (pht_info->infos[0] & BIT(2))) {
 681                         /* switch to the 40M Hz mode */
 682                         cur_bwmode = HT_CHANNEL_WIDTH_40;
 683                         switch (pht_info->infos[0] & 0x3) {
 684                         case 1:
 685                                 cur_ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER;
 686                                 break;
 687                         case 3:
 688                                 cur_ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER;
 689                                 break;
 690                         default:
 691                                 cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
 692                                 break;
 693                         }
 694                 }
 695         }
 696         /* TODO: need to judge the phy parameters on concurrent
 697          * mode for single phy
 698          */
 699         set_channel_bwmode(padapter, cur_channel, cur_ch_offset, cur_bwmode);
 700
 701         DBG_88E("CH =%d, BW =%d, offset =%d\n", cur_channel, cur_bwmode,
 702                 cur_ch_offset);
 703
 704         /*  */
 705         pmlmeext->cur_channel = cur_channel;
 706         pmlmeext->cur_bwmode = cur_bwmode;
 707         pmlmeext->cur_ch_offset = cur_ch_offset;
 708         pmlmeext->cur_wireless_mode = pmlmepriv->cur_network.network_type;
 709
 710         /* update cur_wireless_mode */
 711         update_wireless_mode(padapter);
 712
 713         /* update capability after cur_wireless_mode updated */
 714         update_capinfo(padapter, rtw_get_capability(pnetwork));
 715
 716         /* let pnetwork_mlmeext == pnetwork_mlme. */
 717         memcpy(pnetwork_mlmeext, pnetwork, pnetwork->Length);
 718
 719         if (pmlmeext->bstart_bss) {
 720                 update_beacon(padapter, _TIM_IE_, NULL, false);
 721
 722                 /* issue beacon frame */
 723                 if (send_beacon(padapter) == _FAIL)
 724                         DBG_88E("send_beacon, fail!\n");
 725         }
 726
 727         /* update bc/mc sta_info */
 728         update_bmc_sta(padapter);
 729 }
 730
 731 int rtw_check_beacon_data(struct adapter *padapter, u8 *pbuf,  int len)
 732 {
 733         int ret = _SUCCESS;
 734         u8 *p;
 735         u8 *pHT_caps_ie = NULL;
 736         u8 *pHT_info_ie = NULL;
 737         struct sta_info *psta = NULL;
 738         u16 cap, ht_cap = false;
 739         uint ie_len = 0;
 740         int group_cipher, pairwise_cipher;
 741         u8      channel, network_type, supportRate[NDIS_802_11_LENGTH_RATES_EX];
 742         int supportRateNum = 0;
 743         u8 OUI1[] = {0x00, 0x50, 0xf2, 0x01};
 744         u8 WMM_PARA_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x01, 0x01};
 745         struct registry_priv *pregistrypriv = &padapter->registrypriv;
 746         struct security_priv *psecuritypriv = &padapter->securitypriv;
 747         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 748         struct wlan_bssid_ex *pbss_network = &pmlmepriv->cur_network.network;
 749         u8 *ie = pbss_network->ies;
 750
 751         /* SSID */
 752         /* Supported rates */
 753         /* DS Params */
 754         /* WLAN_EID_COUNTRY */
 755         /* ERP Information element */
 756         /* Extended supported rates */
 757         /* WPA/WPA2 */
 758         /* Wi-Fi Wireless Multimedia Extensions */
 759         /* ht_capab, ht_oper */
 760         /* WPS IE */
 761
 762         DBG_88E("%s, len =%d\n", __func__, len);
 763
 764         if (!check_fwstate(pmlmepriv, WIFI_AP_STATE))
 765                 return _FAIL;
 766
 767         if (len < 0 || len > MAX_IE_SZ)
 768                 return _FAIL;
 769
 770         pbss_network->ie_length = len;
 771
 772         memset(ie, 0, MAX_IE_SZ);
 773
 774         memcpy(ie, pbuf, pbss_network->ie_length);
 775
 776         if (pbss_network->InfrastructureMode != Ndis802_11APMode)
 777                 return _FAIL;
 778
 779         pbss_network->Rssi = 0;
 780
 781         ether_addr_copy(pbss_network->MacAddress, myid(&padapter->eeprompriv));
 782
 783         /* beacon interval */
 784         p = rtw_get_beacon_interval_from_ie(ie);/* 8: TimeStamp, 2: Beacon Interval 2:Capability */
 785         pbss_network->Configuration.BeaconPeriod = get_unaligned_le16(p);
 786
 787         /* capability */
 788         cap = get_unaligned_le16(ie);
 789
 790         /* SSID */
 791         p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _SSID_IE_, &ie_len,
 792                        pbss_network->ie_length - _BEACON_IE_OFFSET_);
 793         if (p && ie_len > 0) {
 794                 ie_len = min_t(int, ie_len, sizeof(pbss_network->ssid.ssid));
 795                 memset(&pbss_network->ssid, 0, sizeof(struct ndis_802_11_ssid));
 796                 memcpy(pbss_network->ssid.ssid, p + 2, ie_len);
 797                 pbss_network->ssid.ssid_length = ie_len;
 798         }
 799
 800         /* channel */
 801         channel = 0;
 802         pbss_network->Configuration.Length = 0;
 803         p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _DSSET_IE_, &ie_len,
 804                        (pbss_network->ie_length - _BEACON_IE_OFFSET_));
 805         if (p && ie_len > 0)
 806                 channel = *(p + 2);
 807
 808         pbss_network->Configuration.DSConfig = channel;
 809
 810         memset(supportRate, 0, NDIS_802_11_LENGTH_RATES_EX);
 811         /*  get supported rates */
 812         p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _SUPPORTEDRATES_IE_, &ie_len,
 813                        pbss_network->ie_length - _BEACON_IE_OFFSET_);
 814         if (p) {
 815                 ie_len = min_t(int, ie_len, NDIS_802_11_LENGTH_RATES_EX);
 816                 memcpy(supportRate, p + 2, ie_len);
 817                 supportRateNum = ie_len;
 818         }
 819
 820         /* get ext_supported rates */
 821         p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _EXT_SUPPORTEDRATES_IE_,
 822                        &ie_len, pbss_network->ie_length - _BEACON_IE_OFFSET_);
 823         if (p) {
 824                 ie_len = min_t(int, ie_len,
 825                                NDIS_802_11_LENGTH_RATES_EX - supportRateNum);
 826                 memcpy(supportRate + supportRateNum, p + 2, ie_len);
 827                 supportRateNum += ie_len;
 828         }
 829
 830         network_type = rtw_check_network_type(supportRate);
 831
 832         rtw_set_supported_rate(pbss_network->SupportedRates, network_type);
 833
 834         /* parsing ERP_IE */
 835         p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _ERPINFO_IE_, &ie_len,
 836                        pbss_network->ie_length - _BEACON_IE_OFFSET_);
 837         if (p && ie_len > 0)
 838                 ERP_IE_handler(padapter, (struct ndis_802_11_var_ie *)p);
 839
 840         /* update privacy/security */
 841         if (cap & BIT(4))
 842                 pbss_network->Privacy = 1;
 843         else
 844                 pbss_network->Privacy = 0;
 845
 846         psecuritypriv->wpa_psk = 0;
 847
 848         /* wpa2 */
 849         group_cipher = 0;
 850         pairwise_cipher = 0;
 851         psecuritypriv->wpa2_group_cipher = _NO_PRIVACY_;
 852         psecuritypriv->wpa2_pairwise_cipher = _NO_PRIVACY_;
 853         p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _RSN_IE_2_, &ie_len,
 854                        pbss_network->ie_length - _BEACON_IE_OFFSET_);
 855         if (p && ie_len > 0) {
 856                 if (rtw_parse_wpa2_ie(p, ie_len + 2, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) {
 857                         psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
 858
 859                         psecuritypriv->dot8021xalg = 1;/* psk,  todo:802.1x */
 860                         psecuritypriv->wpa_psk |= BIT(1);
 861
 862                         psecuritypriv->wpa2_group_cipher = group_cipher;
 863                         psecuritypriv->wpa2_pairwise_cipher = pairwise_cipher;
 864                 }
 865         }
 866         /* wpa */
 867         ie_len = 0;
 868         group_cipher = 0;
 869         pairwise_cipher = 0;
 870         psecuritypriv->wpa_group_cipher = _NO_PRIVACY_;
 871         psecuritypriv->wpa_pairwise_cipher = _NO_PRIVACY_;
 872         for (p = ie + _BEACON_IE_OFFSET_;; p += (ie_len + 2)) {
 873                 p = rtw_get_ie(p, _SSN_IE_1_, &ie_len,
 874                                pbss_network->ie_length - _BEACON_IE_OFFSET_ - (ie_len + 2));
 875                 if ((p) && (!memcmp(p + 2, OUI1, 4))) {
 876                         if (rtw_parse_wpa_ie(p, ie_len + 2, &group_cipher,
 877                                              &pairwise_cipher, NULL) == _SUCCESS) {
 878                                 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
 879
 880                                 psecuritypriv->dot8021xalg = 1;/* psk,  todo:802.1x */
 881
 882                                 psecuritypriv->wpa_psk |= BIT(0);
 883
 884                                 psecuritypriv->wpa_group_cipher = group_cipher;
 885                                 psecuritypriv->wpa_pairwise_cipher = pairwise_cipher;
 886                         }
 887                         break;
 888                 }
 889                 if ((!p) || (ie_len == 0))
 890                         break;
 891         }
 892
 893         /* wmm */
 894         ie_len = 0;
 895         pmlmepriv->qospriv.qos_option = 0;
 896         if (pregistrypriv->wmm_enable) {
 897                 for (p = ie + _BEACON_IE_OFFSET_;; p += (ie_len + 2)) {
 898                         p = rtw_get_ie(p, _VENDOR_SPECIFIC_IE_, &ie_len,
 899                                        pbss_network->ie_length - _BEACON_IE_OFFSET_ - (ie_len + 2));
 900                         if ((p) && !memcmp(p + 2, WMM_PARA_IE, 6)) {
 901                                 pmlmepriv->qospriv.qos_option = 1;
 902
 903                                 /* QoS Info, support U-APSD */
 904                                 *(p + 8) |= BIT(7);
 905
 906                                 /* disable all ACM bits since the WMM
 907                                  * admission control is not supported
 908                                  */
 909                                 *(p + 10) &= ~BIT(4); /* BE */
 910                                 *(p + 14) &= ~BIT(4); /* BK */
 911                                 *(p + 18) &= ~BIT(4); /* VI */
 912                                 *(p + 22) &= ~BIT(4); /* VO */
 913                                 break;
 914                         }
 915
 916                         if ((!p) || (ie_len == 0))
 917                                 break;
 918                 }
 919         }
 920         /* parsing HT_CAP_IE */
 921         p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _HT_CAPABILITY_IE_, &ie_len,
 922                        pbss_network->ie_length - _BEACON_IE_OFFSET_);
 923         if (p && ie_len > 0) {
 924                 struct ieee80211_ht_cap *pht_cap = (struct ieee80211_ht_cap *)(p + 2);
 925
 926                 pHT_caps_ie = p;
 927                 ht_cap = true;
 928                 network_type |= WIRELESS_11_24N;
 929
 930                 if ((psecuritypriv->wpa_pairwise_cipher & WPA_CIPHER_CCMP) ||
 931                     (psecuritypriv->wpa2_pairwise_cipher & WPA_CIPHER_CCMP))
 932                         pht_cap->ampdu_params_info |= (IEEE80211_HT_AMPDU_PARM_DENSITY & (0x07 << 2));
 933                 else
 934                         pht_cap->ampdu_params_info |= (IEEE80211_HT_AMPDU_PARM_DENSITY & 0x00);
 935
 936                 /* set  Max Rx AMPDU size  to 64K */
 937                 pht_cap->ampdu_params_info |= (IEEE80211_HT_AMPDU_PARM_FACTOR & 0x03);
 938
 939                 pht_cap->mcs.rx_mask[0] = 0xff;
 940                 pht_cap->mcs.rx_mask[1] = 0x0;
 941                 ie_len = min_t(int, ie_len, sizeof(pmlmepriv->htpriv.ht_cap));
 942                 memcpy(&pmlmepriv->htpriv.ht_cap, p + 2, ie_len);
 943         }
 944
 945         /* parsing HT_INFO_IE */
 946         p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _HT_ADD_INFO_IE_, &ie_len,
 947                        pbss_network->ie_length - _BEACON_IE_OFFSET_);
 948         if (p && ie_len > 0)
 949                 pHT_info_ie = p;
 950         switch (network_type) {
 951         case WIRELESS_11B:
 952                 pbss_network->NetworkTypeInUse = Ndis802_11DS;
 953                 break;
 954         case WIRELESS_11G:
 955         case WIRELESS_11BG:
 956         case WIRELESS_11G_24N:
 957         case WIRELESS_11BG_24N:
 958                 pbss_network->NetworkTypeInUse = Ndis802_11OFDM24;
 959                 break;
 960         case WIRELESS_11A:
 961                 pbss_network->NetworkTypeInUse = Ndis802_11OFDM5;
 962                 break;
 963         default:
 964                 pbss_network->NetworkTypeInUse = Ndis802_11OFDM24;
 965                 break;
 966         }
 967
 968         pmlmepriv->cur_network.network_type = network_type;
 969
 970         pmlmepriv->htpriv.ht_option = false;
 971
 972         if ((psecuritypriv->wpa2_pairwise_cipher & WPA_CIPHER_TKIP) ||
 973             (psecuritypriv->wpa_pairwise_cipher & WPA_CIPHER_TKIP)) {
 974                 /* todo: */
 975                 /* ht_cap = false; */
 976         }
 977
 978         /* ht_cap */
 979         if (pregistrypriv->ht_enable && ht_cap) {
 980                 pmlmepriv->htpriv.ht_option = true;
 981                 pmlmepriv->qospriv.qos_option = 1;
 982
 983                 if (pregistrypriv->ampdu_enable == 1)
 984                         pmlmepriv->htpriv.ampdu_enable = true;
 985                 HT_caps_handler(padapter, (struct ndis_802_11_var_ie *)pHT_caps_ie);
 986
 987                 HT_info_handler(padapter, (struct ndis_802_11_var_ie *)pHT_info_ie);
 988         }
 989
 990         pbss_network->Length = get_wlan_bssid_ex_sz(pbss_network);
 991
 992         /* issue beacon to start bss network */
 993         start_bss_network(padapter, (u8 *)pbss_network);
 994
 995         /* alloc sta_info for ap itself */
 996         psta = rtw_get_stainfo(&padapter->stapriv, pbss_network->MacAddress);
 997         if (!psta) {
 998                 psta = rtw_alloc_stainfo(&padapter->stapriv, pbss_network->MacAddress);
 999                 if (!psta)
1000                         return _FAIL;
1001         }
1002
1003         /* fix bug of flush_cam_entry at STOP AP mode */
1004         psta->state |= WIFI_AP_STATE;
1005         rtw_indicate_connect(padapter);
1006         pmlmepriv->cur_network.join_res = true;/* for check if already set beacon */
1007         return ret;
1008 }
1009
1010 void rtw_set_macaddr_acl(struct adapter *padapter, int mode)
1011 {
1012         struct sta_priv *pstapriv = &padapter->stapriv;
1013         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
1014
1015         DBG_88E("%s, mode =%d\n", __func__, mode);
1016
1017         pacl_list->mode = mode;
1018 }
1019
1020 int rtw_acl_add_sta(struct adapter *padapter, u8 *addr)
1021 {
1022         struct list_head *plist, *phead;
1023         u8 added = false;
1024         int i, ret = 0;
1025         struct rtw_wlan_acl_node *paclnode;
1026         struct sta_priv *pstapriv = &padapter->stapriv;
1027         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
1028         struct __queue *pacl_node_q = &pacl_list->acl_node_q;
1029
1030         DBG_88E("%s(acl_num =%d) =%pM\n", __func__, pacl_list->num, (addr));
1031
1032         if ((NUM_ACL - 1) < pacl_list->num)
1033                 return -1;
1034
1035         spin_lock_bh(&pacl_node_q->lock);
1036
1037         phead = get_list_head(pacl_node_q);
1038         plist = phead->next;
1039
1040         while (phead != plist) {
1041                 paclnode = container_of(plist, struct rtw_wlan_acl_node, list);
1042                 plist = plist->next;
1043
1044                 if (!memcmp(paclnode->addr, addr, ETH_ALEN)) {
1045                         if (paclnode->valid) {
1046                                 added = true;
1047                                 DBG_88E("%s, sta has been added\n", __func__);
1048                                 break;
1049                         }
1050                 }
1051         }
1052
1053         spin_unlock_bh(&pacl_node_q->lock);
1054
1055         if (added)
1056                 return ret;
1057
1058         spin_lock_bh(&pacl_node_q->lock);
1059
1060         for (i = 0; i < NUM_ACL; i++) {
1061                 paclnode = &pacl_list->aclnode[i];
1062
1063                 if (!paclnode->valid) {
1064                         INIT_LIST_HEAD(&paclnode->list);
1065
1066                         ether_addr_copy(paclnode->addr, addr);
1067
1068                         paclnode->valid = true;
1069
1070                         list_add_tail(&paclnode->list, get_list_head(pacl_node_q));
1071
1072                         pacl_list->num++;
1073
1074                         break;
1075                 }
1076         }
1077
1078         DBG_88E("%s, acl_num =%d\n", __func__, pacl_list->num);
1079
1080         spin_unlock_bh(&pacl_node_q->lock);
1081
1082         return ret;
1083 }
1084
1085 int rtw_acl_remove_sta(struct adapter *padapter, u8 *addr)
1086 {
1087         struct list_head *plist, *phead;
1088         struct rtw_wlan_acl_node *paclnode;
1089         struct sta_priv *pstapriv = &padapter->stapriv;
1090         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
1091         struct __queue *pacl_node_q = &pacl_list->acl_node_q;
1092
1093         DBG_88E("%s(acl_num =%d) =%pM\n", __func__, pacl_list->num, (addr));
1094
1095         spin_lock_bh(&pacl_node_q->lock);
1096
1097         phead = get_list_head(pacl_node_q);
1098         plist = phead->next;
1099
1100         while (phead != plist) {
1101                 paclnode = container_of(plist, struct rtw_wlan_acl_node, list);
1102                 plist = plist->next;
1103
1104                 if (!memcmp(paclnode->addr, addr, ETH_ALEN)) {
1105                         if (paclnode->valid) {
1106                                 paclnode->valid = false;
1107
1108                                 list_del_init(&paclnode->list);
1109
1110                                 pacl_list->num--;
1111                         }
1112                 }
1113         }
1114
1115         spin_unlock_bh(&pacl_node_q->lock);
1116
1117         DBG_88E("%s, acl_num =%d\n", __func__, pacl_list->num);
1118         return 0;
1119 }
1120
1121 static void update_bcn_erpinfo_ie(struct adapter *padapter)
1122 {
1123         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1124         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
1125         struct mlme_ext_info    *pmlmeinfo = &pmlmeext->mlmext_info;
1126         struct wlan_bssid_ex *pnetwork = &pmlmeinfo->network;
1127         unsigned char *p, *ie = pnetwork->ies;
1128         u32 len = 0;
1129
1130         DBG_88E("%s, ERP_enable =%d\n", __func__, pmlmeinfo->ERP_enable);
1131
1132         if (!pmlmeinfo->ERP_enable)
1133                 return;
1134
1135         /* parsing ERP_IE */
1136         p = rtw_get_ie(ie + _BEACON_IE_OFFSET_, _ERPINFO_IE_, &len,
1137                        (pnetwork->ie_length - _BEACON_IE_OFFSET_));
1138         if (p && len > 0) {
1139                 struct ndis_802_11_var_ie *pIE = (struct ndis_802_11_var_ie *)p;
1140
1141                 if (pmlmepriv->num_sta_non_erp == 1)
1142                         pIE->data[0] |= RTW_ERP_INFO_NON_ERP_PRESENT |
1143                                         RTW_ERP_INFO_USE_PROTECTION;
1144                 else
1145                         pIE->data[0] &= ~(RTW_ERP_INFO_NON_ERP_PRESENT |
1146                                           RTW_ERP_INFO_USE_PROTECTION);
1147
1148                 if (pmlmepriv->num_sta_no_short_preamble > 0)
1149                         pIE->data[0] |= RTW_ERP_INFO_BARKER_PREAMBLE_MODE;
1150                 else
1151                         pIE->data[0] &= ~(RTW_ERP_INFO_BARKER_PREAMBLE_MODE);
1152
1153                 ERP_IE_handler(padapter, pIE);
1154         }
1155 }
1156
1157 static void update_bcn_wps_ie(struct adapter *padapter)
1158 {
1159         u8 *pwps_ie = NULL, *pwps_ie_src;
1160         u8 *premainder_ie, *pbackup_remainder_ie = NULL;
1161         uint wps_ielen = 0, wps_offset, remainder_ielen;
1162         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1163         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
1164         struct mlme_ext_info    *pmlmeinfo = &pmlmeext->mlmext_info;
1165         struct wlan_bssid_ex *pnetwork = &pmlmeinfo->network;
1166         unsigned char *ie = pnetwork->ies;
1167         u32 ielen = pnetwork->ie_length;
1168
1169         DBG_88E("%s\n", __func__);
1170
1171         pwps_ie_src = pmlmepriv->wps_beacon_ie;
1172         if (!pwps_ie_src)
1173                 return;
1174
1175         pwps_ie = rtw_get_wps_ie(ie + _FIXED_IE_LENGTH_,
1176                                  ielen - _FIXED_IE_LENGTH_, NULL, &wps_ielen);
1177
1178         if (!pwps_ie || wps_ielen == 0)
1179                 return;
1180
1181         wps_offset = (uint)(pwps_ie - ie);
1182
1183         premainder_ie = pwps_ie + wps_ielen;
1184
1185         remainder_ielen = ielen - wps_offset - wps_ielen;
1186
1187         if (remainder_ielen > 0) {
1188                 pbackup_remainder_ie = rtw_malloc(remainder_ielen);
1189                 if (pbackup_remainder_ie)
1190                         memcpy(pbackup_remainder_ie, premainder_ie, remainder_ielen);
1191         }
1192
1193         wps_ielen = (uint)pwps_ie_src[1];/* to get ie data len */
1194         if (wps_offset + wps_ielen + 2 + remainder_ielen <= MAX_IE_SZ) {
1195                 memcpy(pwps_ie, pwps_ie_src, wps_ielen + 2);
1196                 pwps_ie += wps_ielen + 2;
1197
1198                 if (pbackup_remainder_ie)
1199                         memcpy(pwps_ie, pbackup_remainder_ie, remainder_ielen);
1200
1201                 /* update ie_length */
1202                 pnetwork->ie_length = wps_offset + wps_ielen + 2 + remainder_ielen;
1203         }
1204
1205         kfree(pbackup_remainder_ie);
1206 }
1207
1208 static void update_bcn_vendor_spec_ie(struct adapter *padapter, u8 *oui)
1209 {
1210         DBG_88E("%s\n", __func__);
1211
1212         if (!memcmp(WPS_OUI, oui, 4))
1213                 update_bcn_wps_ie(padapter);
1214         else
1215                 DBG_88E("unknown OUI type!\n");
1216 }
1217
1218 void update_beacon(struct adapter *padapter, u8 ie_id, u8 *oui, u8 tx)
1219 {
1220         struct mlme_priv *pmlmepriv;
1221         struct mlme_ext_priv    *pmlmeext;
1222
1223         if (!padapter)
1224                 return;
1225
1226         pmlmepriv = &padapter->mlmepriv;
1227         pmlmeext = &padapter->mlmeextpriv;
1228
1229         if (!pmlmeext->bstart_bss)
1230                 return;
1231
1232         spin_lock_bh(&pmlmepriv->bcn_update_lock);
1233
1234         switch (ie_id) {
1235         case _TIM_IE_:
1236                 update_BCNTIM(padapter);
1237                 break;
1238         case _ERPINFO_IE_:
1239                 update_bcn_erpinfo_ie(padapter);
1240                 break;
1241         case _VENDOR_SPECIFIC_IE_:
1242                 update_bcn_vendor_spec_ie(padapter, oui);
1243                 break;
1244         default:
1245                 break;
1246         }
1247
1248         pmlmepriv->update_bcn = true;
1249
1250         spin_unlock_bh(&pmlmepriv->bcn_update_lock);
1251
1252         if (tx)
1253                 set_tx_beacon_cmd(padapter);
1254 }
1255
1256 /*
1257  * op_mode
1258  * Set to 0 (HT pure) under the following conditions
1259  *      - all STAs in the BSS are 20/40 MHz HT in 20/40 MHz BSS or
1260  *      - all STAs in the BSS are 20 MHz HT in 20 MHz BSS
1261  * Set to 1 (HT non-member protection) if there may be non-HT STAs
1262  *        in both the primary and the secondary channel
1263  * Set to 2 if only HT STAs are associated in BSS,
1264  *        however and at least one 20 MHz HT STA is associated
1265  * Set to 3 (HT mixed mode) when one or more non-HT STAs are associated
1266  *        (currently non-GF HT station is considered as non-HT STA also)
1267  */
1268 static int rtw_ht_operation_update(struct adapter *padapter)
1269 {
1270         u16 cur_op_mode, new_op_mode;
1271         int op_mode_changes = 0;
1272         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1273         struct ht_priv  *phtpriv_ap = &pmlmepriv->htpriv;
1274
1275         if (pmlmepriv->htpriv.ht_option)
1276                 return 0;
1277
1278         DBG_88E("%s current operation mode = 0x%X\n",
1279                 __func__, pmlmepriv->ht_op_mode);
1280
1281         if (!(pmlmepriv->ht_op_mode & HT_INFO_OPERATION_MODE_NON_GF_DEVS_PRESENT) &&
1282             pmlmepriv->num_sta_ht_no_gf) {
1283                 pmlmepriv->ht_op_mode |=
1284                         HT_INFO_OPERATION_MODE_NON_GF_DEVS_PRESENT;
1285                 op_mode_changes++;
1286         } else if ((pmlmepriv->ht_op_mode &
1287                    HT_INFO_OPERATION_MODE_NON_GF_DEVS_PRESENT) &&
1288                    pmlmepriv->num_sta_ht_no_gf == 0) {
1289                 pmlmepriv->ht_op_mode &=
1290                         ~HT_INFO_OPERATION_MODE_NON_GF_DEVS_PRESENT;
1291                 op_mode_changes++;
1292         }
1293
1294         if (!(pmlmepriv->ht_op_mode & HT_INFO_OPERATION_MODE_NON_HT_STA_PRESENT) &&
1295             (pmlmepriv->num_sta_no_ht || pmlmepriv->olbc_ht)) {
1296                 pmlmepriv->ht_op_mode |= HT_INFO_OPERATION_MODE_NON_HT_STA_PRESENT;
1297                 op_mode_changes++;
1298         } else if ((pmlmepriv->ht_op_mode &
1299                     HT_INFO_OPERATION_MODE_NON_HT_STA_PRESENT) &&
1300                    (pmlmepriv->num_sta_no_ht == 0 && !pmlmepriv->olbc_ht)) {
1301                 pmlmepriv->ht_op_mode &=
1302                         ~HT_INFO_OPERATION_MODE_NON_HT_STA_PRESENT;
1303                 op_mode_changes++;
1304         }
1305
1306         /* Note: currently we switch to the MIXED op mode if HT non-greenfield
1307          * station is associated. Probably it's a theoretical case, since
1308          * it looks like all known HT STAs support greenfield.
1309          */
1310         new_op_mode = 0;
1311         if (pmlmepriv->num_sta_no_ht ||
1312             (pmlmepriv->ht_op_mode & HT_INFO_OPERATION_MODE_NON_GF_DEVS_PRESENT))
1313                 new_op_mode = OP_MODE_MIXED;
1314         else if ((le16_to_cpu(phtpriv_ap->ht_cap.cap_info) &
1315                   IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&
1316                  pmlmepriv->num_sta_ht_20mhz)
1317                 new_op_mode = OP_MODE_20MHZ_HT_STA_ASSOCED;
1318         else if (pmlmepriv->olbc_ht)
1319                 new_op_mode = OP_MODE_MAY_BE_LEGACY_STAS;
1320         else
1321                 new_op_mode = OP_MODE_PURE;
1322
1323         cur_op_mode = pmlmepriv->ht_op_mode & HT_INFO_OPERATION_MODE_OP_MODE_MASK;
1324         if (cur_op_mode != new_op_mode) {
1325                 pmlmepriv->ht_op_mode &= ~HT_INFO_OPERATION_MODE_OP_MODE_MASK;
1326                 pmlmepriv->ht_op_mode |= new_op_mode;
1327                 op_mode_changes++;
1328         }
1329
1330         DBG_88E("%s new operation mode = 0x%X changes =%d\n",
1331                 __func__, pmlmepriv->ht_op_mode, op_mode_changes);
1332
1333         return op_mode_changes;
1334 }
1335
1336 void associated_clients_update(struct adapter *padapter, u8 updated)
1337 {
1338         /* update associated stations cap. */
1339         if (updated) {
1340                 struct list_head *phead, *plist;
1341                 struct sta_info *psta = NULL;
1342                 struct sta_priv *pstapriv = &padapter->stapriv;
1343
1344                 spin_lock_bh(&pstapriv->asoc_list_lock);
1345
1346                 phead = &pstapriv->asoc_list;
1347                 plist = phead->next;
1348
1349                 /* check asoc_queue */
1350                 while (phead != plist) {
1351                         psta = container_of(plist, struct sta_info, asoc_list);
1352
1353                         plist = plist->next;
1354
1355                         VCS_update(padapter, psta);
1356                 }
1357                 spin_unlock_bh(&pstapriv->asoc_list_lock);
1358         }
1359 }
1360
1361 /* called > TSR LEVEL for USB or SDIO Interface*/
1362 void bss_cap_update_on_sta_join(struct adapter *padapter, struct sta_info *psta)
1363 {
1364         u8 beacon_updated = false;
1365         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1366         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1367
1368         if (!(psta->flags & WLAN_STA_SHORT_PREAMBLE)) {
1369                 if (!psta->no_short_preamble_set) {
1370                         psta->no_short_preamble_set = 1;
1371
1372                         pmlmepriv->num_sta_no_short_preamble++;
1373
1374                         if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
1375                             (pmlmepriv->num_sta_no_short_preamble == 1)) {
1376                                 beacon_updated = true;
1377                                 update_beacon(padapter, 0xFF, NULL, true);
1378                         }
1379                 }
1380         } else {
1381                 if (psta->no_short_preamble_set) {
1382                         psta->no_short_preamble_set = 0;
1383
1384                         pmlmepriv->num_sta_no_short_preamble--;
1385
1386                         if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
1387                             (pmlmepriv->num_sta_no_short_preamble == 0)) {
1388                                 beacon_updated = true;
1389                                 update_beacon(padapter, 0xFF, NULL, true);
1390                         }
1391                 }
1392         }
1393
1394         if (psta->flags & WLAN_STA_NONERP) {
1395                 if (!psta->nonerp_set) {
1396                         psta->nonerp_set = 1;
1397
1398                         pmlmepriv->num_sta_non_erp++;
1399
1400                         if (pmlmepriv->num_sta_non_erp == 1) {
1401                                 beacon_updated = true;
1402                                 update_beacon(padapter, _ERPINFO_IE_, NULL, true);
1403                         }
1404                 }
1405         } else {
1406                 if (psta->nonerp_set) {
1407                         psta->nonerp_set = 0;
1408
1409                         pmlmepriv->num_sta_non_erp--;
1410
1411                         if (pmlmepriv->num_sta_non_erp == 0) {
1412                                 beacon_updated = true;
1413                                 update_beacon(padapter, _ERPINFO_IE_, NULL, true);
1414                         }
1415                 }
1416         }
1417
1418         if (!(psta->capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)) {
1419                 if (!psta->no_short_slot_time_set) {
1420                         psta->no_short_slot_time_set = 1;
1421
1422                         pmlmepriv->num_sta_no_short_slot_time++;
1423
1424                         if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
1425                             (pmlmepriv->num_sta_no_short_slot_time == 1)) {
1426                                 beacon_updated = true;
1427                                 update_beacon(padapter, 0xFF, NULL, true);
1428                         }
1429                 }
1430         } else {
1431                 if (psta->no_short_slot_time_set) {
1432                         psta->no_short_slot_time_set = 0;
1433
1434                         pmlmepriv->num_sta_no_short_slot_time--;
1435
1436                         if ((pmlmeext->cur_wireless_mode > WIRELESS_11B) &&
1437                             (pmlmepriv->num_sta_no_short_slot_time == 0)) {
1438                                 beacon_updated = true;
1439                                 update_beacon(padapter, 0xFF, NULL, true);
1440                         }
1441                 }
1442         }
1443
1444         if (psta->flags & WLAN_STA_HT) {
1445                 u16 ht_capab = le16_to_cpu(psta->htpriv.ht_cap.cap_info);
1446
1447                 DBG_88E("HT: STA %pM HT Capabilities Info: 0x%04x\n",
1448                         (psta->hwaddr), ht_capab);
1449
1450                 if (psta->no_ht_set) {
1451                         psta->no_ht_set = 0;
1452                         pmlmepriv->num_sta_no_ht--;
1453                 }
1454
1455                 if ((ht_capab & IEEE80211_HT_CAP_GRN_FLD) == 0) {
1456                         if (!psta->no_ht_gf_set) {
1457                                 psta->no_ht_gf_set = 1;
1458                                 pmlmepriv->num_sta_ht_no_gf++;
1459                         }
1460                         DBG_88E("%s STA %pM - no greenfield, num of non-gf stations %d\n",
1461                                 __func__, (psta->hwaddr),
1462                                 pmlmepriv->num_sta_ht_no_gf);
1463                 }
1464
1465                 if ((ht_capab & IEEE80211_HT_CAP_SUP_WIDTH_20_40) == 0) {
1466                         if (!psta->ht_20mhz_set) {
1467                                 psta->ht_20mhz_set = 1;
1468                                 pmlmepriv->num_sta_ht_20mhz++;
1469                         }
1470                         DBG_88E("%s STA %pM - 20 MHz HT, num of 20MHz HT STAs %d\n",
1471                                 __func__, (psta->hwaddr),
1472                                 pmlmepriv->num_sta_ht_20mhz);
1473                 }
1474         } else {
1475                 if (!psta->no_ht_set) {
1476                         psta->no_ht_set = 1;
1477                         pmlmepriv->num_sta_no_ht++;
1478                 }
1479                 if (pmlmepriv->htpriv.ht_option) {
1480                         DBG_88E("%s STA %pM - no HT, num of non-HT stations %d\n",
1481                                 __func__, (psta->hwaddr),
1482                                 pmlmepriv->num_sta_no_ht);
1483                 }
1484         }
1485
1486         if (rtw_ht_operation_update(padapter) > 0) {
1487                 update_beacon(padapter, _HT_CAPABILITY_IE_, NULL, false);
1488                 update_beacon(padapter, _HT_ADD_INFO_IE_, NULL, true);
1489         }
1490
1491         /* update associated stations cap. */
1492         associated_clients_update(padapter,  beacon_updated);
1493
1494         DBG_88E("%s, updated =%d\n", __func__, beacon_updated);
1495 }
1496
1497 u8 bss_cap_update_on_sta_leave(struct adapter *padapter, struct sta_info *psta)
1498 {
1499         u8 beacon_updated = false;
1500         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1501         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1502
1503         if (!psta)
1504                 return beacon_updated;
1505
1506         if (psta->no_short_preamble_set) {
1507                 psta->no_short_preamble_set = 0;
1508                 pmlmepriv->num_sta_no_short_preamble--;
1509                 if (pmlmeext->cur_wireless_mode > WIRELESS_11B &&
1510                     pmlmepriv->num_sta_no_short_preamble == 0) {
1511                         beacon_updated = true;
1512                         update_beacon(padapter, 0xFF, NULL, true);
1513                 }
1514         }
1515
1516         if (psta->nonerp_set) {
1517                 psta->nonerp_set = 0;
1518                 pmlmepriv->num_sta_non_erp--;
1519                 if (pmlmepriv->num_sta_non_erp == 0) {
1520                         beacon_updated = true;
1521                         update_beacon(padapter, _ERPINFO_IE_, NULL, true);
1522                 }
1523         }
1524
1525         if (psta->no_short_slot_time_set) {
1526                 psta->no_short_slot_time_set = 0;
1527                 pmlmepriv->num_sta_no_short_slot_time--;
1528                 if (pmlmeext->cur_wireless_mode > WIRELESS_11B &&
1529                     pmlmepriv->num_sta_no_short_slot_time == 0) {
1530                         beacon_updated = true;
1531                         update_beacon(padapter, 0xFF, NULL, true);
1532                 }
1533         }
1534
1535         if (psta->no_ht_gf_set) {
1536                 psta->no_ht_gf_set = 0;
1537                 pmlmepriv->num_sta_ht_no_gf--;
1538         }
1539
1540         if (psta->no_ht_set) {
1541                 psta->no_ht_set = 0;
1542                 pmlmepriv->num_sta_no_ht--;
1543         }
1544
1545         if (psta->ht_20mhz_set) {
1546                 psta->ht_20mhz_set = 0;
1547                 pmlmepriv->num_sta_ht_20mhz--;
1548         }
1549
1550         if (rtw_ht_operation_update(padapter) > 0) {
1551                 update_beacon(padapter, _HT_CAPABILITY_IE_, NULL, false);
1552                 update_beacon(padapter, _HT_ADD_INFO_IE_, NULL, true);
1553         }
1554
1555         /* update associated stations cap. */
1556
1557         DBG_88E("%s, updated =%d\n", __func__, beacon_updated);
1558
1559         return beacon_updated;
1560 }
1561
1562 u8 ap_free_sta(struct adapter *padapter, struct sta_info *psta,
1563                bool active, u16 reason)
1564 {
1565         u8 beacon_updated = false;
1566         struct sta_priv *pstapriv = &padapter->stapriv;
1567
1568         if (!psta)
1569                 return beacon_updated;
1570
1571         /* tear down Rx AMPDU */
1572         send_delba(padapter, 0, psta->hwaddr);/*  recipient */
1573
1574         /* tear down TX AMPDU */
1575         send_delba(padapter, 1, psta->hwaddr);/*  originator */
1576         psta->htpriv.agg_enable_bitmap = 0x0;/* reset */
1577         psta->htpriv.candidate_tid_bitmap = 0x0;/* reset */
1578
1579         if (active)
1580                 issue_deauth(padapter, psta->hwaddr, reason);
1581
1582         /* clear cam entry / key */
1583         rtw_clearstakey_cmd(padapter, (u8 *)psta, (u8)(psta->mac_id + 3), true);
1584
1585         spin_lock_bh(&psta->lock);
1586         psta->state &= ~_FW_LINKED;
1587         spin_unlock_bh(&psta->lock);
1588
1589         rtw_indicate_sta_disassoc_event(padapter, psta);
1590
1591         report_del_sta_event(padapter, psta->hwaddr, reason);
1592
1593         beacon_updated = bss_cap_update_on_sta_leave(padapter, psta);
1594
1595         spin_lock_bh(&pstapriv->sta_hash_lock);
1596         rtw_free_stainfo(padapter, psta);
1597         spin_unlock_bh(&pstapriv->sta_hash_lock);
1598
1599         return beacon_updated;
1600 }
1601
1602 int rtw_sta_flush(struct adapter *padapter)
1603 {
1604         struct list_head *phead, *plist;
1605         struct sta_info *psta = NULL;
1606         struct sta_priv *pstapriv = &padapter->stapriv;
1607         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1608         struct mlme_ext_info    *pmlmeinfo = &pmlmeext->mlmext_info;
1609         u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1610
1611         DBG_88E(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(padapter->pnetdev));
1612
1613         if ((pmlmeinfo->state & 0x03) != WIFI_FW_AP_STATE)
1614                 return 0;
1615
1616         spin_lock_bh(&pstapriv->asoc_list_lock);
1617         phead = &pstapriv->asoc_list;
1618         plist = phead->next;
1619
1620         /* free sta asoc_queue */
1621         while (phead != plist) {
1622                 psta = container_of(plist, struct sta_info, asoc_list);
1623
1624                 plist = plist->next;
1625
1626                 list_del_init(&psta->asoc_list);
1627                 pstapriv->asoc_list_cnt--;
1628
1629                 ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING);
1630         }
1631         spin_unlock_bh(&pstapriv->asoc_list_lock);
1632
1633         issue_deauth(padapter, bc_addr, WLAN_REASON_DEAUTH_LEAVING);
1634
1635         associated_clients_update(padapter, true);
1636
1637         return 0;
1638 }
1639
1640 /* called > TSR LEVEL for USB or SDIO Interface*/
1641 void sta_info_update(struct adapter *padapter, struct sta_info *psta)
1642 {
1643         int flags = psta->flags;
1644         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1645
1646         /* update wmm cap. */
1647         if (WLAN_STA_WME & flags)
1648                 psta->qos_option = 1;
1649         else
1650                 psta->qos_option = 0;
1651
1652         if (pmlmepriv->qospriv.qos_option == 0)
1653                 psta->qos_option = 0;
1654
1655         /* update 802.11n ht cap. */
1656         if (WLAN_STA_HT & flags) {
1657                 psta->htpriv.ht_option = true;
1658                 psta->qos_option = 1;
1659         } else {
1660                 psta->htpriv.ht_option = false;
1661         }
1662
1663         if (!pmlmepriv->htpriv.ht_option)
1664                 psta->htpriv.ht_option = false;
1665
1666         update_sta_info_apmode(padapter, psta);
1667 }
1668
1669 /* called >= TSR LEVEL for USB or SDIO Interface*/
1670 void ap_sta_info_defer_update(struct adapter *padapter, struct sta_info *psta)
1671 {
1672         if (psta->state & _FW_LINKED) {
1673                 /* add ratid */
1674                 add_RATid(padapter, psta, 0);/* DM_RATR_STA_INIT */
1675         }
1676 }
1677
1678 void start_ap_mode(struct adapter *padapter)
1679 {
1680         int i;
1681         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1682         struct sta_priv *pstapriv = &padapter->stapriv;
1683         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1684         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
1685
1686         pmlmepriv->update_bcn = false;
1687
1688         pmlmeext->bstart_bss = false;
1689
1690         pmlmepriv->num_sta_non_erp = 0;
1691
1692         pmlmepriv->num_sta_no_short_slot_time = 0;
1693
1694         pmlmepriv->num_sta_no_short_preamble = 0;
1695
1696         pmlmepriv->num_sta_ht_no_gf = 0;
1697         pmlmepriv->num_sta_no_ht = 0;
1698         pmlmepriv->num_sta_ht_20mhz = 0;
1699
1700         pmlmepriv->olbc = false;
1701
1702         pmlmepriv->olbc_ht = false;
1703
1704         pmlmepriv->ht_op_mode = 0;
1705
1706         for (i = 0; i < NUM_STA; i++)
1707                 pstapriv->sta_aid[i] = NULL;
1708
1709         pmlmepriv->wps_beacon_ie = NULL;
1710         pmlmepriv->wps_probe_resp_ie = NULL;
1711         pmlmepriv->wps_assoc_resp_ie = NULL;
1712
1713         /* for ACL */
1714         INIT_LIST_HEAD(&pacl_list->acl_node_q.queue);
1715         pacl_list->num = 0;
1716         pacl_list->mode = 0;
1717         for (i = 0; i < NUM_ACL; i++) {
1718                 INIT_LIST_HEAD(&pacl_list->aclnode[i].list);
1719                 pacl_list->aclnode[i].valid = false;
1720         }
1721 }
1722
1723 void stop_ap_mode(struct adapter *padapter)
1724 {
1725         struct list_head *phead, *plist;
1726         struct rtw_wlan_acl_node *paclnode;
1727         struct sta_info *psta = NULL;
1728         struct sta_priv *pstapriv = &padapter->stapriv;
1729         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1730         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1731         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
1732         struct __queue *pacl_node_q = &pacl_list->acl_node_q;
1733
1734         pmlmepriv->update_bcn = false;
1735         pmlmeext->bstart_bss = false;
1736
1737         /* reset and init security priv , this can refine with
1738          * rtw_reset_securitypriv
1739          */
1740         memset((unsigned char *)&padapter->securitypriv, 0, sizeof(struct security_priv));
1741         padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen;
1742         padapter->securitypriv.ndisencryptstatus = Ndis802_11WEPDisabled;
1743
1744         /* for ACL */
1745         spin_lock_bh(&pacl_node_q->lock);
1746         phead = get_list_head(pacl_node_q);
1747         plist = phead->next;
1748         while (phead != plist) {
1749                 paclnode = container_of(plist, struct rtw_wlan_acl_node, list);
1750                 plist = plist->next;
1751
1752                 if (paclnode->valid) {
1753                         paclnode->valid = false;
1754
1755                         list_del_init(&paclnode->list);
1756
1757                         pacl_list->num--;
1758                 }
1759         }
1760         spin_unlock_bh(&pacl_node_q->lock);
1761
1762         DBG_88E("%s, free acl_node_queue, num =%d\n", __func__, pacl_list->num);
1763
1764         rtw_sta_flush(padapter);
1765
1766         /* free_assoc_sta_resources */
1767         rtw_free_all_stainfo(padapter);
1768
1769         psta = rtw_get_bcmc_stainfo(padapter);
1770         spin_lock_bh(&pstapriv->sta_hash_lock);
1771         rtw_free_stainfo(padapter, psta);
1772         spin_unlock_bh(&pstapriv->sta_hash_lock);
1773
1774         rtw_init_bcmc_stainfo(padapter);
1775
1776         rtw_free_mlme_priv_ie_data(pmlmepriv);
1777 }
1778
1779 #endif /* CONFIG_88EU_AP_MODE */