drivers/staging/rtl8723bs/core/rtw_sta_mgt.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
   5  *
   6  ******************************************************************************/
   7 #define _RTW_STA_MGT_C_
   8
   9 #include <drv_types.h>
  10 #include <rtw_debug.h>
  11
  12 void _rtw_init_stainfo(struct sta_info *psta);
  13 void _rtw_init_stainfo(struct sta_info *psta)
  14 {
  15         memset((u8 *)psta, 0, sizeof(struct sta_info));
  16
  17         spin_lock_init(&psta->lock);
  18         INIT_LIST_HEAD(&psta->list);
  19         INIT_LIST_HEAD(&psta->hash_list);
  20         /* INIT_LIST_HEAD(&psta->asoc_list); */
  21         /* INIT_LIST_HEAD(&psta->sleep_list); */
  22         /* INIT_LIST_HEAD(&psta->wakeup_list); */
  23
  24         _rtw_init_queue(&psta->sleep_q);
  25         psta->sleepq_len = 0;
  26
  27         _rtw_init_sta_xmit_priv(&psta->sta_xmitpriv);
  28         _rtw_init_sta_recv_priv(&psta->sta_recvpriv);
  29
  30         INIT_LIST_HEAD(&psta->asoc_list);
  31
  32         INIT_LIST_HEAD(&psta->auth_list);
  33
  34         psta->expire_to = 0;
  35
  36         psta->flags = 0;
  37
  38         psta->capability = 0;
  39
  40         psta->bpairwise_key_installed = false;
  41
  42         psta->nonerp_set = 0;
  43         psta->no_short_slot_time_set = 0;
  44         psta->no_short_preamble_set = 0;
  45         psta->no_ht_gf_set = 0;
  46         psta->no_ht_set = 0;
  47         psta->ht_20mhz_set = 0;
  48
  49         psta->under_exist_checking = 0;
  50
  51         psta->keep_alive_trycnt = 0;
  52 }
  53
  54 u32 _rtw_init_sta_priv(struct   sta_priv *pstapriv)
  55 {
  56         struct sta_info *psta;
  57         s32 i;
  58
  59         pstapriv->pallocated_stainfo_buf = vzalloc(sizeof(struct sta_info) * NUM_STA+4);
  60
  61         if (!pstapriv->pallocated_stainfo_buf)
  62                 return _FAIL;
  63
  64         pstapriv->pstainfo_buf = pstapriv->pallocated_stainfo_buf + 4 -
  65                 ((SIZE_PTR)(pstapriv->pallocated_stainfo_buf) & 3);
  66
  67         _rtw_init_queue(&pstapriv->free_sta_queue);
  68
  69         spin_lock_init(&pstapriv->sta_hash_lock);
  70
  71         /* _rtw_init_queue(&pstapriv->asoc_q); */
  72         pstapriv->asoc_sta_count = 0;
  73         _rtw_init_queue(&pstapriv->sleep_q);
  74         _rtw_init_queue(&pstapriv->wakeup_q);
  75
  76         psta = (struct sta_info *)(pstapriv->pstainfo_buf);
  77
  78
  79         for (i = 0; i < NUM_STA; i++) {
  80                 _rtw_init_stainfo(psta);
  81
  82                 INIT_LIST_HEAD(&(pstapriv->sta_hash[i]));
  83
  84                 list_add_tail(&psta->list, get_list_head(&pstapriv->free_sta_queue));
  85
  86                 psta++;
  87         }
  88
  89         pstapriv->sta_dz_bitmap = 0;
  90         pstapriv->tim_bitmap = 0;
  91
  92         INIT_LIST_HEAD(&pstapriv->asoc_list);
  93         INIT_LIST_HEAD(&pstapriv->auth_list);
  94         spin_lock_init(&pstapriv->asoc_list_lock);
  95         spin_lock_init(&pstapriv->auth_list_lock);
  96         pstapriv->asoc_list_cnt = 0;
  97         pstapriv->auth_list_cnt = 0;
  98
  99         pstapriv->auth_to = 3; /*  3*2 = 6 sec */
 100         pstapriv->assoc_to = 3;
 101         pstapriv->expire_to = 3; /*  3*2 = 6 sec */
 102         pstapriv->max_num_sta = NUM_STA;
 103         return _SUCCESS;
 104 }
 105
 106 inline int rtw_stainfo_offset(struct sta_priv *stapriv, struct sta_info *sta)
 107 {
 108         int offset = (((u8 *)sta) - stapriv->pstainfo_buf)/sizeof(struct sta_info);
 109
 110         if (!stainfo_offset_valid(offset))
 111                 DBG_871X("%s invalid offset(%d), out of range!!!", __func__, offset);
 112
 113         return offset;
 114 }
 115
 116 inline struct sta_info *rtw_get_stainfo_by_offset(struct sta_priv *stapriv, int offset)
 117 {
 118         if (!stainfo_offset_valid(offset))
 119                 DBG_871X("%s invalid offset(%d), out of range!!!", __func__, offset);
 120
 121         return (struct sta_info *)(stapriv->pstainfo_buf + offset * sizeof(struct sta_info));
 122 }
 123
 124 /*  this function is used to free the memory of lock || sema for all stainfos */
 125 void kfree_all_stainfo(struct sta_priv *pstapriv);
 126 void kfree_all_stainfo(struct sta_priv *pstapriv)
 127 {
 128         struct list_head        *plist, *phead;
 129         struct sta_info *psta = NULL;
 130
 131         spin_lock_bh(&pstapriv->sta_hash_lock);
 132
 133         phead = get_list_head(&pstapriv->free_sta_queue);
 134         plist = get_next(phead);
 135
 136         while (phead != plist) {
 137                 psta = LIST_CONTAINOR(plist, struct sta_info, list);
 138                 plist = get_next(plist);
 139         }
 140
 141         spin_unlock_bh(&pstapriv->sta_hash_lock);
 142 }
 143
 144 void kfree_sta_priv_lock(struct sta_priv *pstapriv);
 145 void kfree_sta_priv_lock(struct sta_priv *pstapriv)
 146 {
 147          kfree_all_stainfo(pstapriv); /* be done before free sta_hash_lock */
 148 }
 149
 150 u32 _rtw_free_sta_priv(struct   sta_priv *pstapriv)
 151 {
 152         struct list_head        *phead, *plist;
 153         struct sta_info *psta = NULL;
 154         struct recv_reorder_ctrl *preorder_ctrl;
 155         int     index;
 156
 157         if (pstapriv) {
 158
 159                 /*delete all reordering_ctrl_timer              */
 160                 spin_lock_bh(&pstapriv->sta_hash_lock);
 161                 for (index = 0; index < NUM_STA; index++) {
 162                         phead = &(pstapriv->sta_hash[index]);
 163                         plist = get_next(phead);
 164
 165                         while (phead != plist) {
 166                                 int i;
 167                                 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
 168                                 plist = get_next(plist);
 169
 170                                 for (i = 0; i < 16 ; i++) {
 171                                         preorder_ctrl = &psta->recvreorder_ctrl[i];
 172                                         del_timer_sync(&preorder_ctrl->reordering_ctrl_timer);
 173                                 }
 174                         }
 175                 }
 176                 spin_unlock_bh(&pstapriv->sta_hash_lock);
 177                 /*===============================*/
 178
 179                 kfree_sta_priv_lock(pstapriv);
 180
 181                 if (pstapriv->pallocated_stainfo_buf)
 182                         vfree(pstapriv->pallocated_stainfo_buf);
 183
 184         }
 185         return _SUCCESS;
 186 }
 187
 188 /* struct       sta_info *rtw_alloc_stainfo(_queue *pfree_sta_queue, unsigned char *hwaddr) */
 189 struct  sta_info *rtw_alloc_stainfo(struct      sta_priv *pstapriv, u8 *hwaddr)
 190 {
 191         uint tmp_aid;
 192         s32     index;
 193         struct list_head        *phash_list;
 194         struct sta_info *psta;
 195         struct __queue *pfree_sta_queue;
 196         struct recv_reorder_ctrl *preorder_ctrl;
 197         int i = 0;
 198         u16  wRxSeqInitialValue = 0xffff;
 199
 200         pfree_sta_queue = &pstapriv->free_sta_queue;
 201
 202         /* spin_lock_bh(&(pfree_sta_queue->lock)); */
 203         spin_lock_bh(&(pstapriv->sta_hash_lock));
 204         if (list_empty(&pfree_sta_queue->queue)) {
 205                 /* spin_unlock_bh(&(pfree_sta_queue->lock)); */
 206                 spin_unlock_bh(&(pstapriv->sta_hash_lock));
 207                 psta = NULL;
 208                 return psta;
 209         } else{
 210                 psta = LIST_CONTAINOR(get_next(&pfree_sta_queue->queue), struct sta_info, list);
 211
 212                 list_del_init(&(psta->list));
 213
 214                 /* spin_unlock_bh(&(pfree_sta_queue->lock)); */
 215
 216                 tmp_aid = psta->aid;
 217
 218                 _rtw_init_stainfo(psta);
 219
 220                 psta->padapter = pstapriv->padapter;
 221
 222                 memcpy(psta->hwaddr, hwaddr, ETH_ALEN);
 223
 224                 index = wifi_mac_hash(hwaddr);
 225
 226                 RT_TRACE(_module_rtl871x_sta_mgt_c_, _drv_info_, ("rtw_alloc_stainfo: index  = %x", index));
 227
 228                 if (index >= NUM_STA) {
 229                         RT_TRACE(_module_rtl871x_sta_mgt_c_, _drv_err_, ("ERROR => rtw_alloc_stainfo: index >= NUM_STA"));
 230                         spin_unlock_bh(&(pstapriv->sta_hash_lock));
 231                         psta = NULL;
 232                         goto exit;
 233                 }
 234                 phash_list = &(pstapriv->sta_hash[index]);
 235
 236                 /* spin_lock_bh(&(pstapriv->sta_hash_lock)); */
 237
 238                 list_add_tail(&psta->hash_list, phash_list);
 239
 240                 pstapriv->asoc_sta_count++;
 241
 242                 /* spin_unlock_bh(&(pstapriv->sta_hash_lock)); */
 243
 244 /*  Commented by Albert 2009/08/13 */
 245 /*  For the SMC router, the sequence number of first packet of WPS handshake will be 0. */
 246 /*  In this case, this packet will be dropped by recv_decache function if we use the 0x00 as the default value for tid_rxseq variable. */
 247 /*  So, we initialize the tid_rxseq variable as the 0xffff. */
 248
 249                 for (i = 0; i < 16; i++) {
 250                         memcpy(&psta->sta_recvpriv.rxcache.tid_rxseq[i], &wRxSeqInitialValue, 2);
 251                 }
 252
 253                 RT_TRACE(
 254                         _module_rtl871x_sta_mgt_c_,
 255                         _drv_info_, (
 256                                 "alloc number_%d stainfo  with hwaddr = %x %x %x %x %x %x \n",
 257                                 pstapriv->asoc_sta_count,
 258                                 hwaddr[0],
 259                                 hwaddr[1],
 260                                 hwaddr[2],
 261                                 hwaddr[3],
 262                                 hwaddr[4],
 263                                 hwaddr[5]
 264                         )
 265                 );
 266
 267                 init_addba_retry_timer(pstapriv->padapter, psta);
 268
 269                 /* for A-MPDU Rx reordering buffer control */
 270                 for (i = 0; i < 16 ; i++) {
 271                         preorder_ctrl = &psta->recvreorder_ctrl[i];
 272
 273                         preorder_ctrl->padapter = pstapriv->padapter;
 274
 275                         preorder_ctrl->enable = false;
 276
 277                         preorder_ctrl->indicate_seq = 0xffff;
 278                         #ifdef DBG_RX_SEQ
 279                         DBG_871X("DBG_RX_SEQ %s:%d IndicateSeq: %d\n", __func__, __LINE__,
 280                                 preorder_ctrl->indicate_seq);
 281                         #endif
 282                         preorder_ctrl->wend_b = 0xffff;
 283                         /* preorder_ctrl->wsize_b = (NR_RECVBUFF-2); */
 284                         preorder_ctrl->wsize_b = 64;/* 64; */
 285
 286                         _rtw_init_queue(&preorder_ctrl->pending_recvframe_queue);
 287
 288                         rtw_init_recv_timer(preorder_ctrl);
 289                 }
 290
 291
 292                 /* init for DM */
 293                 psta->rssi_stat.UndecoratedSmoothedPWDB = (-1);
 294                 psta->rssi_stat.UndecoratedSmoothedCCK = (-1);
 295
 296                 /* init for the sequence number of received management frame */
 297                 psta->RxMgmtFrameSeqNum = 0xffff;
 298                 spin_unlock_bh(&(pstapriv->sta_hash_lock));
 299                 /* alloc mac id for non-bc/mc station, */
 300                 rtw_alloc_macid(pstapriv->padapter, psta);
 301
 302         }
 303
 304 exit:
 305
 306
 307         return psta;
 308 }
 309
 310 /*  using pstapriv->sta_hash_lock to protect */
 311 u32 rtw_free_stainfo(struct adapter *padapter, struct sta_info *psta)
 312 {
 313         int i;
 314         struct __queue *pfree_sta_queue;
 315         struct recv_reorder_ctrl *preorder_ctrl;
 316         struct  sta_xmit_priv *pstaxmitpriv;
 317         struct  xmit_priv *pxmitpriv = &padapter->xmitpriv;
 318         struct  sta_priv *pstapriv = &padapter->stapriv;
 319         struct hw_xmit *phwxmit;
 320
 321         if (psta == NULL)
 322                 goto exit;
 323
 324
 325         spin_lock_bh(&psta->lock);
 326         psta->state &= ~_FW_LINKED;
 327         spin_unlock_bh(&psta->lock);
 328
 329         pfree_sta_queue = &pstapriv->free_sta_queue;
 330
 331
 332         pstaxmitpriv = &psta->sta_xmitpriv;
 333
 334         /* list_del_init(&psta->sleep_list); */
 335
 336         /* list_del_init(&psta->wakeup_list); */
 337
 338         spin_lock_bh(&pxmitpriv->lock);
 339
 340         rtw_free_xmitframe_queue(pxmitpriv, &psta->sleep_q);
 341         psta->sleepq_len = 0;
 342
 343         /* vo */
 344         /* spin_lock_bh(&(pxmitpriv->vo_pending.lock)); */
 345         rtw_free_xmitframe_queue(pxmitpriv, &pstaxmitpriv->vo_q.sta_pending);
 346         list_del_init(&(pstaxmitpriv->vo_q.tx_pending));
 347         phwxmit = pxmitpriv->hwxmits;
 348         phwxmit->accnt -= pstaxmitpriv->vo_q.qcnt;
 349         pstaxmitpriv->vo_q.qcnt = 0;
 350         /* spin_unlock_bh(&(pxmitpriv->vo_pending.lock)); */
 351
 352         /* vi */
 353         /* spin_lock_bh(&(pxmitpriv->vi_pending.lock)); */
 354         rtw_free_xmitframe_queue(pxmitpriv, &pstaxmitpriv->vi_q.sta_pending);
 355         list_del_init(&(pstaxmitpriv->vi_q.tx_pending));
 356         phwxmit = pxmitpriv->hwxmits+1;
 357         phwxmit->accnt -= pstaxmitpriv->vi_q.qcnt;
 358         pstaxmitpriv->vi_q.qcnt = 0;
 359         /* spin_unlock_bh(&(pxmitpriv->vi_pending.lock)); */
 360
 361         /* be */
 362         /* spin_lock_bh(&(pxmitpriv->be_pending.lock)); */
 363         rtw_free_xmitframe_queue(pxmitpriv, &pstaxmitpriv->be_q.sta_pending);
 364         list_del_init(&(pstaxmitpriv->be_q.tx_pending));
 365         phwxmit = pxmitpriv->hwxmits+2;
 366         phwxmit->accnt -= pstaxmitpriv->be_q.qcnt;
 367         pstaxmitpriv->be_q.qcnt = 0;
 368         /* spin_unlock_bh(&(pxmitpriv->be_pending.lock)); */
 369
 370         /* bk */
 371         /* spin_lock_bh(&(pxmitpriv->bk_pending.lock)); */
 372         rtw_free_xmitframe_queue(pxmitpriv, &pstaxmitpriv->bk_q.sta_pending);
 373         list_del_init(&(pstaxmitpriv->bk_q.tx_pending));
 374         phwxmit = pxmitpriv->hwxmits+3;
 375         phwxmit->accnt -= pstaxmitpriv->bk_q.qcnt;
 376         pstaxmitpriv->bk_q.qcnt = 0;
 377         /* spin_unlock_bh(&(pxmitpriv->bk_pending.lock)); */
 378
 379         spin_unlock_bh(&pxmitpriv->lock);
 380
 381         list_del_init(&psta->hash_list);
 382         RT_TRACE(
 383                 _module_rtl871x_sta_mgt_c_,
 384                 _drv_err_, (
 385                         "\n free number_%d stainfo  with hwaddr = 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x \n",
 386                         pstapriv->asoc_sta_count,
 387                         psta->hwaddr[0],
 388                         psta->hwaddr[1],
 389                         psta->hwaddr[2],
 390                         psta->hwaddr[3],
 391                         psta->hwaddr[4],
 392                         psta->hwaddr[5]
 393                 )
 394         );
 395         pstapriv->asoc_sta_count--;
 396
 397
 398         /*  re-init sta_info; 20061114 will be init in alloc_stainfo */
 399         /* _rtw_init_sta_xmit_priv(&psta->sta_xmitpriv); */
 400         /* _rtw_init_sta_recv_priv(&psta->sta_recvpriv); */
 401
 402         del_timer_sync(&psta->addba_retry_timer);
 403
 404         /* for A-MPDU Rx reordering buffer control, cancel reordering_ctrl_timer */
 405         for (i = 0; i < 16 ; i++) {
 406                 struct list_head        *phead, *plist;
 407                 union recv_frame *prframe;
 408                 struct __queue *ppending_recvframe_queue;
 409                 struct __queue *pfree_recv_queue = &padapter->recvpriv.free_recv_queue;
 410
 411                 preorder_ctrl = &psta->recvreorder_ctrl[i];
 412
 413                 del_timer_sync(&preorder_ctrl->reordering_ctrl_timer);
 414
 415
 416                 ppending_recvframe_queue = &preorder_ctrl->pending_recvframe_queue;
 417
 418                 spin_lock_bh(&ppending_recvframe_queue->lock);
 419
 420                 phead =         get_list_head(ppending_recvframe_queue);
 421                 plist = get_next(phead);
 422
 423                 while (!list_empty(phead)) {
 424                         prframe = (union recv_frame *)plist;
 425
 426                         plist = get_next(plist);
 427
 428                         list_del_init(&(prframe->u.hdr.list));
 429
 430                         rtw_free_recvframe(prframe, pfree_recv_queue);
 431                 }
 432
 433                 spin_unlock_bh(&ppending_recvframe_queue->lock);
 434
 435         }
 436
 437         if (!(psta->state & WIFI_AP_STATE))
 438                 rtw_hal_set_odm_var(padapter, HAL_ODM_STA_INFO, psta, false);
 439
 440
 441         /* release mac id for non-bc/mc station, */
 442         rtw_release_macid(pstapriv->padapter, psta);
 443
 444 /*
 445         spin_lock_bh(&pstapriv->asoc_list_lock);
 446         list_del_init(&psta->asoc_list);
 447         spin_unlock_bh(&pstapriv->asoc_list_lock);
 448 */
 449         spin_lock_bh(&pstapriv->auth_list_lock);
 450         if (!list_empty(&psta->auth_list)) {
 451                 list_del_init(&psta->auth_list);
 452                 pstapriv->auth_list_cnt--;
 453         }
 454         spin_unlock_bh(&pstapriv->auth_list_lock);
 455
 456         psta->expire_to = 0;
 457         psta->sleepq_ac_len = 0;
 458         psta->qos_info = 0;
 459
 460         psta->max_sp_len = 0;
 461         psta->uapsd_bk = 0;
 462         psta->uapsd_be = 0;
 463         psta->uapsd_vi = 0;
 464         psta->uapsd_vo = 0;
 465
 466         psta->has_legacy_ac = 0;
 467
 468         pstapriv->sta_dz_bitmap &= ~BIT(psta->aid);
 469         pstapriv->tim_bitmap &= ~BIT(psta->aid);
 470
 471         if ((psta->aid > 0) && (pstapriv->sta_aid[psta->aid - 1] == psta)) {
 472                 pstapriv->sta_aid[psta->aid - 1] = NULL;
 473                 psta->aid = 0;
 474         }
 475
 476         psta->under_exist_checking = 0;
 477
 478         /* spin_lock_bh(&(pfree_sta_queue->lock)); */
 479         list_add_tail(&psta->list, get_list_head(pfree_sta_queue));
 480         /* spin_unlock_bh(&(pfree_sta_queue->lock)); */
 481
 482 exit:
 483         return _SUCCESS;
 484 }
 485
 486 /*  free all stainfo which in sta_hash[all] */
 487 void rtw_free_all_stainfo(struct adapter *padapter)
 488 {
 489         struct list_head        *plist, *phead;
 490         s32     index;
 491         struct sta_info *psta = NULL;
 492         struct  sta_priv *pstapriv = &padapter->stapriv;
 493         struct sta_info *pbcmc_stainfo = rtw_get_bcmc_stainfo(padapter);
 494
 495         if (pstapriv->asoc_sta_count == 1)
 496                 return;
 497
 498         spin_lock_bh(&pstapriv->sta_hash_lock);
 499
 500         for (index = 0; index < NUM_STA; index++) {
 501                 phead = &(pstapriv->sta_hash[index]);
 502                 plist = get_next(phead);
 503
 504                 while (phead != plist) {
 505                         psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
 506
 507                         plist = get_next(plist);
 508
 509                         if (pbcmc_stainfo != psta)
 510                                 rtw_free_stainfo(padapter, psta);
 511
 512                 }
 513         }
 514
 515         spin_unlock_bh(&pstapriv->sta_hash_lock);
 516 }
 517
 518 /* any station allocated can be searched by hash list */
 519 struct sta_info *rtw_get_stainfo(struct sta_priv *pstapriv, u8 *hwaddr)
 520 {
 521         struct list_head        *plist, *phead;
 522         struct sta_info *psta = NULL;
 523         u32 index;
 524         u8 *addr;
 525         u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 526
 527         if (hwaddr == NULL)
 528                 return NULL;
 529
 530         if (IS_MCAST(hwaddr))
 531                 addr = bc_addr;
 532         else
 533                 addr = hwaddr;
 534
 535         index = wifi_mac_hash(addr);
 536
 537         spin_lock_bh(&pstapriv->sta_hash_lock);
 538
 539         phead = &(pstapriv->sta_hash[index]);
 540         plist = get_next(phead);
 541
 542
 543         while (phead != plist) {
 544
 545                 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
 546
 547                 if ((!memcmp(psta->hwaddr, addr, ETH_ALEN)))
 548                  /*  if found the matched address */
 549                         break;
 550
 551                 psta = NULL;
 552                 plist = get_next(plist);
 553         }
 554
 555         spin_unlock_bh(&pstapriv->sta_hash_lock);
 556         return psta;
 557 }
 558
 559 u32 rtw_init_bcmc_stainfo(struct adapter *padapter)
 560 {
 561
 562         struct sta_info *psta;
 563         struct tx_servq *ptxservq;
 564         u32 res = _SUCCESS;
 565         NDIS_802_11_MAC_ADDRESS bcast_addr = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 566
 567         struct  sta_priv *pstapriv = &padapter->stapriv;
 568         /* struct __queue       *pstapending = &padapter->xmitpriv.bm_pending; */
 569
 570         psta = rtw_alloc_stainfo(pstapriv, bcast_addr);
 571
 572         if (psta == NULL) {
 573                 res = _FAIL;
 574                 RT_TRACE(_module_rtl871x_sta_mgt_c_, _drv_err_, ("rtw_alloc_stainfo fail"));
 575                 goto exit;
 576         }
 577
 578         /*  default broadcast & multicast use macid 1 */
 579         psta->mac_id = 1;
 580
 581         ptxservq = &(psta->sta_xmitpriv.be_q);
 582 exit:
 583         return _SUCCESS;
 584 }
 585
 586
 587 struct sta_info *rtw_get_bcmc_stainfo(struct adapter *padapter)
 588 {
 589         struct sta_info *psta;
 590         struct sta_priv *pstapriv = &padapter->stapriv;
 591         u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 592
 593         psta = rtw_get_stainfo(pstapriv, bc_addr);
 594         return psta;
 595 }
 596
 597 u8 rtw_access_ctrl(struct adapter *padapter, u8 *mac_addr)
 598 {
 599         bool res = true;
 600         struct list_head        *plist, *phead;
 601         struct rtw_wlan_acl_node *paclnode;
 602         bool match = false;
 603         struct sta_priv *pstapriv = &padapter->stapriv;
 604         struct wlan_acl_pool *pacl_list = &pstapriv->acl_list;
 605         struct __queue  *pacl_node_q = &pacl_list->acl_node_q;
 606
 607         spin_lock_bh(&(pacl_node_q->lock));
 608         phead = get_list_head(pacl_node_q);
 609         plist = get_next(phead);
 610         while (phead != plist) {
 611                 paclnode = LIST_CONTAINOR(plist, struct rtw_wlan_acl_node, list);
 612                 plist = get_next(plist);
 613
 614                 if (!memcmp(paclnode->addr, mac_addr, ETH_ALEN))
 615                         if (paclnode->valid == true) {
 616                                 match = true;
 617                                 break;
 618                         }
 619
 620         }
 621         spin_unlock_bh(&(pacl_node_q->lock));
 622
 623
 624         if (pacl_list->mode == 1) /* accept unless in deny list */
 625                 res = !match;
 626
 627         else if (pacl_list->mode == 2)/* deny unless in accept list */
 628                 res = match;
 629         else
 630                  res = true;
 631
 632         return res;
 633 }