kernel/drivers/staging/rtl8723au/core/rtw_ap.c

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