drivers/staging/rtl8723bs/core/rtw_sta

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

DEFINITIONS
