drivers/staging/rtl8723au/core/rtw_recv.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_RECV_C_
  16 #include <osdep_service.h>
  17 #include <drv_types.h>
  18 #include <recv_osdep.h>
  19 #include <mlme_osdep.h>
  20 #include <linux/ip.h>
  21 #include <linux/if_ether.h>
  22 #include <usb_ops.h>
  23 #include <linux/ieee80211.h>
  24 #include <wifi.h>
  25 #include <rtl8723a_recv.h>
  26 #include <rtl8723a_xmit.h>
  27
  28 void rtw_signal_stat_timer_hdl23a(unsigned long data);
  29
  30 void _rtw_init_sta_recv_priv23a(struct sta_recv_priv *psta_recvpriv)
  31 {
  32
  33
  34
  35         spin_lock_init(&psta_recvpriv->lock);
  36
  37         /* for (i = 0; i<MAX_RX_NUMBLKS; i++) */
  38         /*      _rtw_init_queue23a(&psta_recvpriv->blk_strms[i]); */
  39
  40         _rtw_init_queue23a(&psta_recvpriv->defrag_q);
  41
  42
  43 }
  44
  45 int _rtw_init_recv_priv23a(struct recv_priv *precvpriv,
  46                         struct rtw_adapter *padapter)
  47 {
  48         struct recv_frame *precvframe;
  49         int i;
  50         int res = _SUCCESS;
  51
  52         spin_lock_init(&precvpriv->lock);
  53
  54         _rtw_init_queue23a(&precvpriv->free_recv_queue);
  55         _rtw_init_queue23a(&precvpriv->recv_pending_queue);
  56         _rtw_init_queue23a(&precvpriv->uc_swdec_pending_queue);
  57
  58         precvpriv->adapter = padapter;
  59
  60         for (i = 0; i < NR_RECVFRAME ; i++) {
  61                 precvframe = kzalloc(sizeof(struct recv_frame), GFP_KERNEL);
  62                 if (!precvframe)
  63                         break;
  64                 INIT_LIST_HEAD(&precvframe->list);
  65
  66                 list_add_tail(&precvframe->list,
  67                               &precvpriv->free_recv_queue.queue);
  68
  69                 precvframe->adapter = padapter;
  70                 precvframe++;
  71         }
  72
  73         precvpriv->free_recvframe_cnt = i;
  74         precvpriv->rx_pending_cnt = 1;
  75
  76         res = rtl8723au_init_recv_priv(padapter);
  77
  78         setup_timer(&precvpriv->signal_stat_timer, rtw_signal_stat_timer_hdl23a,
  79                     (unsigned long)padapter);
  80
  81         precvpriv->signal_stat_sampling_interval = 1000; /* ms */
  82
  83         rtw_set_signal_stat_timer(precvpriv);
  84
  85         return res;
  86 }
  87
  88 void _rtw_free_recv_priv23a(struct recv_priv *precvpriv)
  89 {
  90         struct rtw_adapter *padapter = precvpriv->adapter;
  91         struct recv_frame *precvframe, *ptmp;
  92
  93         rtw_free_uc_swdec_pending_queue23a(padapter);
  94
  95         list_for_each_entry_safe(precvframe, ptmp,
  96                                  &precvpriv->free_recv_queue.queue, list) {
  97                 list_del_init(&precvframe->list);
  98                 kfree(precvframe);
  99         }
 100
 101         rtl8723au_free_recv_priv(padapter);
 102 }
 103
 104 struct recv_frame *rtw_alloc_recvframe23a(struct rtw_queue *pfree_recv_queue)
 105 {
 106         struct recv_frame *pframe;
 107         struct list_head *plist, *phead;
 108         struct rtw_adapter *padapter;
 109         struct recv_priv *precvpriv;
 110
 111         spin_lock_bh(&pfree_recv_queue->lock);
 112
 113         if (list_empty(&pfree_recv_queue->queue))
 114                 pframe = NULL;
 115         else {
 116                 phead = get_list_head(pfree_recv_queue);
 117
 118                 plist = phead->next;
 119
 120                 pframe = container_of(plist, struct recv_frame, list);
 121
 122                 list_del_init(&pframe->list);
 123                 padapter = pframe->adapter;
 124                 if (padapter) {
 125                         precvpriv = &padapter->recvpriv;
 126                         if (pfree_recv_queue == &precvpriv->free_recv_queue)
 127                                 precvpriv->free_recvframe_cnt--;
 128                 }
 129         }
 130
 131         spin_unlock_bh(&pfree_recv_queue->lock);
 132
 133         return pframe;
 134 }
 135
 136 int rtw_free_recvframe23a(struct recv_frame *precvframe)
 137 {
 138         struct rtw_adapter *padapter = precvframe->adapter;
 139         struct recv_priv *precvpriv = &padapter->recvpriv;
 140         struct rtw_queue *pfree_recv_queue;
 141
 142         if (precvframe->pkt) {
 143                 dev_kfree_skb_any(precvframe->pkt);/* free skb by driver */
 144                 precvframe->pkt = NULL;
 145         }
 146
 147         pfree_recv_queue = &precvpriv->free_recv_queue;
 148         spin_lock_bh(&pfree_recv_queue->lock);
 149
 150         list_del_init(&precvframe->list);
 151
 152         list_add_tail(&precvframe->list, get_list_head(pfree_recv_queue));
 153
 154         if (padapter) {
 155                 if (pfree_recv_queue == &precvpriv->free_recv_queue)
 156                         precvpriv->free_recvframe_cnt++;
 157         }
 158
 159         spin_unlock_bh(&pfree_recv_queue->lock);
 160
 161
 162
 163         return _SUCCESS;
 164 }
 165
 166 int rtw_enqueue_recvframe23a(struct recv_frame *precvframe, struct rtw_queue *queue)
 167 {
 168         struct rtw_adapter *padapter = precvframe->adapter;
 169         struct recv_priv *precvpriv = &padapter->recvpriv;
 170
 171         spin_lock_bh(&queue->lock);
 172
 173         list_del_init(&precvframe->list);
 174
 175         list_add_tail(&precvframe->list, get_list_head(queue));
 176
 177         if (padapter) {
 178                 if (queue == &precvpriv->free_recv_queue)
 179                         precvpriv->free_recvframe_cnt++;
 180         }
 181
 182         spin_unlock_bh(&queue->lock);
 183
 184         return _SUCCESS;
 185 }
 186
 187 /*
 188 caller : defrag ; recvframe_chk_defrag23a in recv_thread  (passive)
 189 pframequeue: defrag_queue : will be accessed in recv_thread  (passive)
 190
 191 using spinlock to protect
 192
 193 */
 194
 195 static void rtw_free_recvframe23a_queue(struct rtw_queue *pframequeue)
 196 {
 197         struct recv_frame *hdr, *ptmp;
 198         struct list_head *phead;
 199
 200         spin_lock(&pframequeue->lock);
 201         phead = get_list_head(pframequeue);
 202         list_for_each_entry_safe(hdr, ptmp, phead, list)
 203                 rtw_free_recvframe23a(hdr);
 204         spin_unlock(&pframequeue->lock);
 205 }
 206
 207 u32 rtw_free_uc_swdec_pending_queue23a(struct rtw_adapter *adapter)
 208 {
 209         u32 cnt = 0;
 210         struct recv_frame *pending_frame;
 211
 212         while ((pending_frame = rtw_alloc_recvframe23a(&adapter->recvpriv.uc_swdec_pending_queue))) {
 213                 rtw_free_recvframe23a(pending_frame);
 214                 DBG_8723A("%s: dequeue uc_swdec_pending_queue\n", __func__);
 215                 cnt++;
 216         }
 217
 218         return cnt;
 219 }
 220
 221 int rtw_enqueue_recvbuf23a_to_head(struct recv_buf *precvbuf, struct rtw_queue *queue)
 222 {
 223         spin_lock_bh(&queue->lock);
 224
 225         list_del_init(&precvbuf->list);
 226         list_add(&precvbuf->list, get_list_head(queue));
 227
 228         spin_unlock_bh(&queue->lock);
 229
 230         return _SUCCESS;
 231 }
 232
 233 int rtw_enqueue_recvbuf23a(struct recv_buf *precvbuf, struct rtw_queue *queue)
 234 {
 235         unsigned long irqL;
 236
 237         spin_lock_irqsave(&queue->lock, irqL);
 238
 239         list_del_init(&precvbuf->list);
 240
 241         list_add_tail(&precvbuf->list, get_list_head(queue));
 242         spin_unlock_irqrestore(&queue->lock, irqL);
 243         return _SUCCESS;
 244 }
 245
 246 struct recv_buf *rtw_dequeue_recvbuf23a (struct rtw_queue *queue)
 247 {
 248         unsigned long irqL;
 249         struct recv_buf *precvbuf;
 250         struct list_head *plist, *phead;
 251
 252         spin_lock_irqsave(&queue->lock, irqL);
 253
 254         if (list_empty(&queue->queue)) {
 255                 precvbuf = NULL;
 256         } else {
 257                 phead = get_list_head(queue);
 258
 259                 plist = phead->next;
 260
 261                 precvbuf = container_of(plist, struct recv_buf, list);
 262
 263                 list_del_init(&precvbuf->list);
 264         }
 265
 266         spin_unlock_irqrestore(&queue->lock, irqL);
 267
 268         return precvbuf;
 269 }
 270
 271 int recvframe_chkmic(struct rtw_adapter *adapter,
 272                      struct recv_frame *precvframe);
 273 int recvframe_chkmic(struct rtw_adapter *adapter,
 274                      struct recv_frame *precvframe) {
 275
 276         int     i, res = _SUCCESS;
 277         u32     datalen;
 278         u8      miccode[8];
 279         u8      bmic_err = false, brpt_micerror = true;
 280         u8      *pframe, *payload, *pframemic;
 281         u8      *mickey;
 282         /* u8   *iv, rxdata_key_idx = 0; */
 283         struct  sta_info *stainfo;
 284         struct  rx_pkt_attrib *prxattrib = &precvframe->attrib;
 285         struct  security_priv *psecuritypriv = &adapter->securitypriv;
 286
 287         struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
 288         struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
 289
 290
 291         stainfo = rtw_get_stainfo23a(&adapter->stapriv, &prxattrib->ta[0]);
 292
 293         if (prxattrib->encrypt == WLAN_CIPHER_SUITE_TKIP) {
 294                 RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
 295                          "recvframe_chkmic:prxattrib->encrypt == WLAN_CIPHER_SUITE_TKIP\n");
 296                 RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
 297                          "recvframe_chkmic:da = %pM\n", prxattrib->ra);
 298
 299                 /* calculate mic code */
 300                 if (stainfo != NULL) {
 301                         if (is_multicast_ether_addr(prxattrib->ra)) {
 302                                 mickey = &psecuritypriv->dot118021XGrprxmickey[prxattrib->key_index].skey[0];
 303
 304                                 RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
 305                                          "recvframe_chkmic: bcmc key\n");
 306
 307                                 if (!psecuritypriv->binstallGrpkey) {
 308                                         res = _FAIL;
 309                                         RT_TRACE(_module_rtl871x_recv_c_,
 310                                                  _drv_err_,
 311                                                  "recvframe_chkmic:didn't install group key!\n");
 312                                         DBG_8723A("\n recvframe_chkmic:didn't "
 313                                                   "install group key!!!!!!\n");
 314                                         goto exit;
 315                                 }
 316                         } else {
 317                                 mickey = &stainfo->dot11tkiprxmickey.skey[0];
 318                                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 319                                          "recvframe_chkmic: unicast key\n");
 320                         }
 321
 322                         /* icv_len included the mic code */
 323                         datalen = precvframe->pkt->len-prxattrib->
 324                                 hdrlen-prxattrib->iv_len-prxattrib->icv_len - 8;
 325                         pframe = precvframe->pkt->data;
 326                         payload = pframe + prxattrib->hdrlen +
 327                                 prxattrib->iv_len;
 328
 329                         RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
 330                                  "prxattrib->iv_len =%d prxattrib->icv_len =%d\n",
 331                                  prxattrib->iv_len, prxattrib->icv_len);
 332
 333                         /* care the length of the data */
 334                         rtw_seccalctkipmic23a(mickey, pframe, payload,
 335                                            datalen, &miccode[0],
 336                                            (unsigned char)prxattrib->priority);
 337
 338                         pframemic = payload + datalen;
 339
 340                         bmic_err = false;
 341
 342                         for (i = 0; i < 8; i++) {
 343                                 if (miccode[i] != *(pframemic + i)) {
 344                                         RT_TRACE(_module_rtl871x_recv_c_,
 345                                                  _drv_err_,
 346                                                  "recvframe_chkmic:miccode[%d](%02x) != *(pframemic+%d)(%02x)\n",
 347                                                  i, miccode[i],
 348                                                  i, *(pframemic + i));
 349                                         bmic_err = true;
 350                                 }
 351                         }
 352
 353                         if (bmic_err == true) {
 354                                 int i;
 355
 356                                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 357                                          "*(pframemic-8)-*(pframemic-1) =%*phC\n",
 358                                          8, pframemic - 8);
 359                                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 360                                          "*(pframemic-16)-*(pframemic-9) =%*phC\n",
 361                                          8, pframemic - 16);
 362
 363                                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 364                                          "====== demp packet (len =%d) ======\n",
 365                                          precvframe->pkt->len);
 366                                 for (i = 0; i < precvframe->pkt->len; i = i + 8) {
 367                                         RT_TRACE(_module_rtl871x_recv_c_,
 368                                                  _drv_err_, "%*phC\n",
 369                                                  8, precvframe->pkt->data + i);
 370                                 }
 371                                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 372                                          "====== demp packet end [len =%d]======\n",
 373                                          precvframe->pkt->len);
 374                                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 375                                          "hrdlen =%d\n", prxattrib->hdrlen);
 376
 377                                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 378                                          "ra = %pM psecuritypriv->binstallGrpkey =%d\n",
 379                                          prxattrib->ra,
 380                                          psecuritypriv->binstallGrpkey);
 381
 382                                 /*  double check key_index for some timing
 383                                     issue, cannot compare with
 384                                     psecuritypriv->dot118021XGrpKeyid also
 385                                     cause timing issue */
 386                                 if ((is_multicast_ether_addr(prxattrib->ra)) &&
 387                                     (prxattrib->key_index !=
 388                                      pmlmeinfo->key_index))
 389                                         brpt_micerror = false;
 390
 391                                 if ((prxattrib->bdecrypted == true) &&
 392                                     (brpt_micerror == true)) {
 393                                         rtw_handle_tkip_mic_err23a(adapter, (u8)is_multicast_ether_addr(prxattrib->ra));
 394                                         RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 395                                                  "mic error :prxattrib->bdecrypted =%d\n",
 396                                                  prxattrib->bdecrypted);
 397                                         DBG_8723A(" mic error :prxattrib->"
 398                                                   "bdecrypted =%d\n",
 399                                                   prxattrib->bdecrypted);
 400                                 } else {
 401                                         RT_TRACE(_module_rtl871x_recv_c_,
 402                                                  _drv_err_,
 403                                                  "mic error :prxattrib->bdecrypted =%d\n",
 404                                                  prxattrib->bdecrypted);
 405                                         DBG_8723A(" mic error :prxattrib->"
 406                                                   "bdecrypted =%d\n",
 407                                                   prxattrib->bdecrypted);
 408                                 }
 409
 410                                 res = _FAIL;
 411                         } else {
 412                                 /* mic checked ok */
 413                                 if (!psecuritypriv->bcheck_grpkey &&
 414                                     is_multicast_ether_addr(prxattrib->ra)) {
 415                                         psecuritypriv->bcheck_grpkey = 1;
 416                                         RT_TRACE(_module_rtl871x_recv_c_,
 417                                                  _drv_err_,
 418                                                  "psecuritypriv->bcheck_grpkey = true\n");
 419                                 }
 420                         }
 421                 } else {
 422                         RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 423                                  "recvframe_chkmic: rtw_get_stainfo23a ==NULL!!!\n");
 424                 }
 425
 426                 skb_trim(precvframe->pkt, precvframe->pkt->len - 8);
 427         }
 428
 429 exit:
 430
 431
 432
 433         return res;
 434 }
 435
 436 /* decrypt and set the ivlen, icvlen of the recv_frame */
 437 struct recv_frame *decryptor(struct rtw_adapter *padapter,
 438                              struct recv_frame *precv_frame);
 439 struct recv_frame *decryptor(struct rtw_adapter *padapter,
 440                              struct recv_frame *precv_frame)
 441 {
 442         struct rx_pkt_attrib *prxattrib = &precv_frame->attrib;
 443         struct security_priv *psecuritypriv = &padapter->securitypriv;
 444         struct recv_frame *return_packet = precv_frame;
 445         int res = _SUCCESS;
 446
 447         RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
 448                  "prxstat->decrypted =%x prxattrib->encrypt = 0x%03x\n",
 449                  prxattrib->bdecrypted, prxattrib->encrypt);
 450
 451         if (prxattrib->encrypt > 0) {
 452                 u8 *iv = precv_frame->pkt->data + prxattrib->hdrlen;
 453
 454                 prxattrib->key_index = (((iv[3]) >> 6) & 0x3);
 455
 456                 if (prxattrib->key_index > WEP_KEYS) {
 457                         DBG_8723A("prxattrib->key_index(%d) > WEP_KEYS\n",
 458                                   prxattrib->key_index);
 459
 460                         switch (prxattrib->encrypt) {
 461                         case WLAN_CIPHER_SUITE_WEP40:
 462                         case WLAN_CIPHER_SUITE_WEP104:
 463                                 prxattrib->key_index =
 464                                         psecuritypriv->dot11PrivacyKeyIndex;
 465                                 break;
 466                         case WLAN_CIPHER_SUITE_TKIP:
 467                         case WLAN_CIPHER_SUITE_CCMP:
 468                         default:
 469                                 prxattrib->key_index =
 470                                         psecuritypriv->dot118021XGrpKeyid;
 471                                 break;
 472                         }
 473                 }
 474         }
 475
 476         if ((prxattrib->encrypt > 0) && ((prxattrib->bdecrypted == 0))) {
 477                 psecuritypriv->hw_decrypted = 0;
 478                 switch (prxattrib->encrypt) {
 479                 case WLAN_CIPHER_SUITE_WEP40:
 480                 case WLAN_CIPHER_SUITE_WEP104:
 481                         rtw_wep_decrypt23a(padapter, precv_frame);
 482                         break;
 483                 case WLAN_CIPHER_SUITE_TKIP:
 484                         res = rtw_tkip_decrypt23a(padapter, precv_frame);
 485                         break;
 486                 case WLAN_CIPHER_SUITE_CCMP:
 487                         res = rtw_aes_decrypt23a(padapter, precv_frame);
 488                         break;
 489                 default:
 490                         break;
 491                 }
 492         } else if (prxattrib->bdecrypted == 1 && prxattrib->encrypt > 0 &&
 493                    (psecuritypriv->busetkipkey == 1 ||
 494                     prxattrib->encrypt != WLAN_CIPHER_SUITE_TKIP)) {
 495                         psecuritypriv->hw_decrypted = 1;
 496         }
 497
 498         if (res == _FAIL) {
 499                 rtw_free_recvframe23a(return_packet);
 500                 return_packet = NULL;
 501         }
 502
 503
 504
 505         return return_packet;
 506 }
 507
 508 /* set the security information in the recv_frame */
 509 static struct recv_frame *portctrl(struct rtw_adapter *adapter,
 510                                    struct recv_frame *precv_frame)
 511 {
 512         u8 *psta_addr, *ptr;
 513         uint auth_alg;
 514         struct recv_frame *pfhdr;
 515         struct sta_info *psta;
 516         struct sta_priv *pstapriv ;
 517         struct recv_frame *prtnframe;
 518         u16 ether_type;
 519         u16 eapol_type = ETH_P_PAE;/* for Funia BD's WPA issue */
 520         struct rx_pkt_attrib *pattrib;
 521
 522         pstapriv = &adapter->stapriv;
 523
 524         auth_alg = adapter->securitypriv.dot11AuthAlgrthm;
 525
 526         pfhdr = precv_frame;
 527         pattrib = &pfhdr->attrib;
 528         psta_addr = pattrib->ta;
 529         psta = rtw_get_stainfo23a(pstapriv, psta_addr);
 530
 531         RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
 532                  "########portctrl:adapter->securitypriv.dot11AuthAlgrthm =%d\n",
 533                  adapter->securitypriv.dot11AuthAlgrthm);
 534
 535         prtnframe = precv_frame;
 536
 537         if (auth_alg == dot11AuthAlgrthm_8021X) {
 538                 /* get ether_type */
 539                 ptr = pfhdr->pkt->data + pfhdr->attrib.hdrlen;
 540
 541                 ether_type = (ptr[6] << 8) | ptr[7];
 542
 543                 if (psta && psta->ieee8021x_blocked) {
 544                         /* blocked */
 545                         /* only accept EAPOL frame */
 546                         RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
 547                                  "########portctrl:psta->ieee8021x_blocked ==1\n");
 548
 549                         if (ether_type != eapol_type) {
 550                                 /* free this frame */
 551                                 rtw_free_recvframe23a(precv_frame);
 552                                 prtnframe = NULL;
 553                         }
 554                 }
 555         }
 556
 557         return prtnframe;
 558 }
 559
 560 int recv_decache(struct recv_frame *precv_frame, u8 bretry,
 561                  struct stainfo_rxcache *prxcache);
 562 int recv_decache(struct recv_frame *precv_frame, u8 bretry,
 563                  struct stainfo_rxcache *prxcache)
 564 {
 565         int tid = precv_frame->attrib.priority;
 566
 567         u16 seq_ctrl = ((precv_frame->attrib.seq_num & 0xffff) << 4) |
 568                 (precv_frame->attrib.frag_num & 0xf);
 569
 570
 571
 572         if (tid > 15) {
 573                 RT_TRACE(_module_rtl871x_recv_c_, _drv_notice_,
 574                          "recv_decache, (tid>15)! seq_ctrl = 0x%x, tid = 0x%x\n",
 575                          seq_ctrl, tid);
 576
 577                 return _FAIL;
 578         }
 579
 580         if (1) { /* if (bretry) */
 581                 if (seq_ctrl == prxcache->tid_rxseq[tid]) {
 582                         RT_TRACE(_module_rtl871x_recv_c_, _drv_notice_,
 583                                  "recv_decache, seq_ctrl = 0x%x, tid = 0x%x, tid_rxseq = 0x%x\n",
 584                                  seq_ctrl, tid, prxcache->tid_rxseq[tid]);
 585
 586                         return _FAIL;
 587                 }
 588         }
 589
 590         prxcache->tid_rxseq[tid] = seq_ctrl;
 591
 592
 593
 594         return _SUCCESS;
 595 }
 596
 597 void process23a_pwrbit_data(struct rtw_adapter *padapter,
 598                          struct recv_frame *precv_frame);
 599 void process23a_pwrbit_data(struct rtw_adapter *padapter,
 600                          struct recv_frame *precv_frame)
 601 {
 602 #ifdef CONFIG_8723AU_AP_MODE
 603         unsigned char pwrbit;
 604         struct sk_buff *skb = precv_frame->pkt;
 605         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 606         struct rx_pkt_attrib *pattrib = &precv_frame->attrib;
 607         struct sta_priv *pstapriv = &padapter->stapriv;
 608         struct sta_info *psta;
 609
 610         psta = rtw_get_stainfo23a(pstapriv, pattrib->src);
 611
 612         if (psta) {
 613                 pwrbit = ieee80211_has_pm(hdr->frame_control);
 614
 615                 if (pwrbit) {
 616                         if (!(psta->state & WIFI_SLEEP_STATE))
 617                                 stop_sta_xmit23a(padapter, psta);
 618                 } else {
 619                         if (psta->state & WIFI_SLEEP_STATE)
 620                                 wakeup_sta_to_xmit23a(padapter, psta);
 621                 }
 622         }
 623
 624 #endif
 625 }
 626
 627 void process_wmmps_data(struct rtw_adapter *padapter,
 628                         struct recv_frame *precv_frame);
 629 void process_wmmps_data(struct rtw_adapter *padapter,
 630                         struct recv_frame *precv_frame)
 631 {
 632 #ifdef CONFIG_8723AU_AP_MODE
 633         struct rx_pkt_attrib *pattrib = &precv_frame->attrib;
 634         struct sta_priv *pstapriv = &padapter->stapriv;
 635         struct sta_info *psta;
 636
 637         psta = rtw_get_stainfo23a(pstapriv, pattrib->src);
 638
 639         if (!psta)
 640                 return;
 641
 642
 643         if (!psta->qos_option)
 644                 return;
 645
 646         if (!(psta->qos_info & 0xf))
 647                 return;
 648
 649         if (psta->state & WIFI_SLEEP_STATE) {
 650                 u8 wmmps_ac = 0;
 651
 652                 switch (pattrib->priority) {
 653                 case 1:
 654                 case 2:
 655                         wmmps_ac = psta->uapsd_bk & BIT(1);
 656                         break;
 657                 case 4:
 658                 case 5:
 659                         wmmps_ac = psta->uapsd_vi & BIT(1);
 660                         break;
 661                 case 6:
 662                 case 7:
 663                         wmmps_ac = psta->uapsd_vo & BIT(1);
 664                         break;
 665                 case 0:
 666                 case 3:
 667                 default:
 668                         wmmps_ac = psta->uapsd_be & BIT(1);
 669                         break;
 670                 }
 671
 672                 if (wmmps_ac) {
 673                         if (psta->sleepq_ac_len > 0) {
 674                                 /* process received triggered frame */
 675                                 xmit_delivery_enabled_frames23a(padapter, psta);
 676                         } else {
 677                                 /* issue one qos null frame with More data bit = 0 and the EOSP bit set (= 1) */
 678                                 issue_qos_nulldata23a(padapter, psta->hwaddr,
 679                                                    (u16)pattrib->priority,
 680                                                    0, 0);
 681                         }
 682                 }
 683         }
 684
 685 #endif
 686 }
 687
 688 static void count_rx_stats(struct rtw_adapter *padapter,
 689                            struct recv_frame *prframe, struct sta_info *sta)
 690 {
 691         int sz;
 692         struct sta_info *psta = NULL;
 693         struct stainfo_stats *pstats = NULL;
 694         struct rx_pkt_attrib *pattrib = & prframe->attrib;
 695         struct recv_priv *precvpriv = &padapter->recvpriv;
 696
 697         sz = prframe->pkt->len;
 698         precvpriv->rx_bytes += sz;
 699
 700         padapter->mlmepriv.LinkDetectInfo.NumRxOkInPeriod++;
 701
 702         if ((!is_broadcast_ether_addr(pattrib->dst)) &&
 703             (!is_multicast_ether_addr(pattrib->dst)))
 704                 padapter->mlmepriv.LinkDetectInfo.NumRxUnicastOkInPeriod++;
 705
 706         if (sta)
 707                 psta = sta;
 708         else
 709                 psta = prframe->psta;
 710
 711         if (psta) {
 712                 pstats = &psta->sta_stats;
 713
 714                 pstats->rx_data_pkts++;
 715                 pstats->rx_bytes += sz;
 716         }
 717 }
 718
 719 static int sta2sta_data_frame(struct rtw_adapter *adapter,
 720                               struct recv_frame *precv_frame,
 721                               struct sta_info**psta)
 722 {
 723         struct sk_buff *skb = precv_frame->pkt;
 724         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 725         int ret = _SUCCESS;
 726         struct rx_pkt_attrib *pattrib = & precv_frame->attrib;
 727         struct sta_priv *pstapriv = &adapter->stapriv;
 728         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
 729         u8 *mybssid  = get_bssid(pmlmepriv);
 730         u8 *myhwaddr = myid(&adapter->eeprompriv);
 731         u8 *sta_addr = NULL;
 732         int bmcast = is_multicast_ether_addr(pattrib->dst);
 733
 734
 735
 736         if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) ||
 737             check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) {
 738
 739                 /*  filter packets that SA is myself or multicast or broadcast */
 740                 if (ether_addr_equal(myhwaddr, pattrib->src)) {
 741                         RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 742                                  "SA == myself\n");
 743                         ret = _FAIL;
 744                         goto exit;
 745                 }
 746
 747                 if (!ether_addr_equal(myhwaddr, pattrib->dst) && !bmcast) {
 748                         ret = _FAIL;
 749                         goto exit;
 750                 }
 751
 752                 if (ether_addr_equal(pattrib->bssid, "\x0\x0\x0\x0\x0\x0") ||
 753                     ether_addr_equal(mybssid, "\x0\x0\x0\x0\x0\x0") ||
 754                     !ether_addr_equal(pattrib->bssid, mybssid)) {
 755                         ret = _FAIL;
 756                         goto exit;
 757                 }
 758
 759                 sta_addr = pattrib->src;
 760         } else if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
 761                 /*  For Station mode, sa and bssid should always be BSSID,
 762                     and DA is my mac-address */
 763                 if (!ether_addr_equal(pattrib->bssid, pattrib->src)) {
 764                         RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 765                                  "bssid != TA under STATION_MODE; drop pkt\n");
 766                         ret = _FAIL;
 767                         goto exit;
 768                 }
 769
 770                 sta_addr = pattrib->bssid;
 771
 772         } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
 773                 if (bmcast) {
 774                         /*  For AP mode, if DA == MCAST, then BSSID should be also MCAST */
 775                         if (!is_multicast_ether_addr(pattrib->bssid)) {
 776                                 ret = _FAIL;
 777                                 goto exit;
 778                         }
 779                 } else { /*  not mc-frame */
 780                         /*  For AP mode, if DA is non-MCAST, then it must
 781                             be BSSID, and bssid == BSSID */
 782                         if (!ether_addr_equal(pattrib->bssid, pattrib->dst)) {
 783                                 ret = _FAIL;
 784                                 goto exit;
 785                         }
 786
 787                         sta_addr = pattrib->src;
 788                 }
 789         } else if (check_fwstate(pmlmepriv, WIFI_MP_STATE)) {
 790                 ether_addr_copy(pattrib->dst, hdr->addr1);
 791                 ether_addr_copy(pattrib->src, hdr->addr2);
 792                 ether_addr_copy(pattrib->bssid, hdr->addr3);
 793                 ether_addr_copy(pattrib->ra, pattrib->dst);
 794                 ether_addr_copy(pattrib->ta, pattrib->src);
 795
 796                 sta_addr = mybssid;
 797         } else {
 798                 ret  = _FAIL;
 799         }
 800
 801         if (bmcast)
 802                 *psta = rtw_get_bcmc_stainfo23a(adapter);
 803         else
 804                 *psta = rtw_get_stainfo23a(pstapriv, sta_addr); /*  get ap_info */
 805
 806         if (*psta == NULL) {
 807                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 808                          "can't get psta under sta2sta_data_frame ; drop pkt\n");
 809                 ret = _FAIL;
 810                 goto exit;
 811         }
 812
 813 exit:
 814
 815         return ret;
 816 }
 817
 818 int ap2sta_data_frame(struct rtw_adapter *adapter,
 819                       struct recv_frame *precv_frame,
 820                       struct sta_info **psta);
 821 int ap2sta_data_frame(struct rtw_adapter *adapter,
 822                       struct recv_frame *precv_frame,
 823                       struct sta_info **psta)
 824 {
 825         struct sk_buff *skb = precv_frame->pkt;
 826         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 827         struct rx_pkt_attrib *pattrib = & precv_frame->attrib;
 828         int ret = _SUCCESS;
 829         struct sta_priv *pstapriv = &adapter->stapriv;
 830         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
 831         u8 *mybssid  = get_bssid(pmlmepriv);
 832         u8 *myhwaddr = myid(&adapter->eeprompriv);
 833         int bmcast = is_multicast_ether_addr(pattrib->dst);
 834
 835
 836
 837         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) &&
 838             (check_fwstate(pmlmepriv, _FW_LINKED) ||
 839              check_fwstate(pmlmepriv, _FW_UNDER_LINKING))) {
 840
 841                 /* filter packets that SA is myself or multicast or broadcast */
 842                 if (ether_addr_equal(myhwaddr, pattrib->src)) {
 843                         RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 844                                  "SA == myself\n");
 845                         ret = _FAIL;
 846                         goto exit;
 847                 }
 848
 849                 /*  da should be for me */
 850                 if (!ether_addr_equal(myhwaddr, pattrib->dst) && !bmcast) {
 851                         RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
 852                                  "ap2sta_data_frame:  compare DA failed; DA=%pM\n",
 853                                  pattrib->dst);
 854                         ret = _FAIL;
 855                         goto exit;
 856                 }
 857
 858                 /*  check BSSID */
 859                 if (ether_addr_equal(pattrib->bssid, "\x0\x0\x0\x0\x0\x0") ||
 860                     ether_addr_equal(mybssid, "\x0\x0\x0\x0\x0\x0") ||
 861                     !ether_addr_equal(pattrib->bssid, mybssid)) {
 862                         RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
 863                                  "ap2sta_data_frame:  compare BSSID failed; BSSID=%pM\n",
 864                                  pattrib->bssid);
 865                         RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
 866                                  "mybssid=%pM\n", mybssid);
 867
 868                         if (!bmcast) {
 869                                 DBG_8723A("issue_deauth23a to the nonassociated ap=%pM for the reason(7)\n",
 870                                           pattrib->bssid);
 871                                 issue_deauth23a(adapter, pattrib->bssid,
 872                                              WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA);
 873                         }
 874
 875                         ret = _FAIL;
 876                         goto exit;
 877                 }
 878
 879                 if (bmcast)
 880                         *psta = rtw_get_bcmc_stainfo23a(adapter);
 881                 else
 882                         /*  get ap_info */
 883                         *psta = rtw_get_stainfo23a(pstapriv, pattrib->bssid);
 884
 885                 if (*psta == NULL) {
 886                         RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 887                                  "ap2sta: can't get psta under STATION_MODE; drop pkt\n");
 888                         ret = _FAIL;
 889                         goto exit;
 890                 }
 891
 892                 if (ieee80211_is_nullfunc(hdr->frame_control)) {
 893                         /* No data, will not indicate to upper layer,
 894                            temporily count it here */
 895                         count_rx_stats(adapter, precv_frame, *psta);
 896                         ret = RTW_RX_HANDLED;
 897                         goto exit;
 898                 }
 899
 900         } else if (check_fwstate(pmlmepriv, WIFI_MP_STATE) &&
 901                    check_fwstate(pmlmepriv, _FW_LINKED)) {
 902                 ether_addr_copy(pattrib->dst, hdr->addr1);
 903                 ether_addr_copy(pattrib->src, hdr->addr2);
 904                 ether_addr_copy(pattrib->bssid, hdr->addr3);
 905                 ether_addr_copy(pattrib->ra, pattrib->dst);
 906                 ether_addr_copy(pattrib->ta, pattrib->src);
 907
 908                 /*  */
 909                 ether_addr_copy(pattrib->bssid,  mybssid);
 910
 911                 /*  get sta_info */
 912                 *psta = rtw_get_stainfo23a(pstapriv, pattrib->bssid);
 913                 if (*psta == NULL) {
 914                         RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 915                                  "can't get psta under MP_MODE ; drop pkt\n");
 916                         ret = _FAIL;
 917                         goto exit;
 918                 }
 919         } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
 920                 /* Special case */
 921                 ret = RTW_RX_HANDLED;
 922                 goto exit;
 923         } else {
 924                 if (ether_addr_equal(myhwaddr, pattrib->dst) && !bmcast) {
 925                         *psta = rtw_get_stainfo23a(pstapriv, pattrib->bssid);
 926                         if (*psta == NULL) {
 927                                 DBG_8723A("issue_deauth23a to the ap=%pM for the reason(7)\n",
 928                                           pattrib->bssid);
 929
 930                                 issue_deauth23a(adapter, pattrib->bssid,
 931                                              WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA);
 932                         }
 933                 }
 934
 935                 ret = _FAIL;
 936         }
 937
 938 exit:
 939
 940
 941
 942         return ret;
 943 }
 944
 945 int sta2ap_data_frame(struct rtw_adapter *adapter,
 946                       struct recv_frame *precv_frame,
 947                       struct sta_info **psta);
 948 int sta2ap_data_frame(struct rtw_adapter *adapter,
 949                       struct recv_frame *precv_frame,
 950                       struct sta_info **psta)
 951 {
 952         struct sk_buff *skb = precv_frame->pkt;
 953         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 954         struct rx_pkt_attrib *pattrib = & precv_frame->attrib;
 955         struct sta_priv *pstapriv = &adapter->stapriv;
 956         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
 957         unsigned char *mybssid = get_bssid(pmlmepriv);
 958         int ret = _SUCCESS;
 959
 960
 961
 962         if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
 963                 /* For AP mode, RA = BSSID, TX = STA(SRC_ADDR), A3 = DST_ADDR */
 964                 if (!ether_addr_equal(pattrib->bssid, mybssid)) {
 965                         ret = _FAIL;
 966                         goto exit;
 967                 }
 968
 969                 *psta = rtw_get_stainfo23a(pstapriv, pattrib->src);
 970                 if (*psta == NULL) {
 971                         RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
 972                                  "can't get psta under AP_MODE; drop pkt\n");
 973                         DBG_8723A("issue_deauth23a to sta=%pM for the reason(7)\n",
 974                                   pattrib->src);
 975
 976                         issue_deauth23a(adapter, pattrib->src,
 977                                      WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA);
 978
 979                         ret = RTW_RX_HANDLED;
 980                         goto exit;
 981                 }
 982
 983                 process23a_pwrbit_data(adapter, precv_frame);
 984
 985                 /* We only get here if it's a data frame, so no need to
 986                  * confirm data frame type first */
 987                 if (ieee80211_is_data_qos(hdr->frame_control))
 988                         process_wmmps_data(adapter, precv_frame);
 989
 990                 if (ieee80211_is_nullfunc(hdr->frame_control)) {
 991                         /* No data, will not indicate to upper layer,
 992                            temporily count it here */
 993                         count_rx_stats(adapter, precv_frame, *psta);
 994                         ret = RTW_RX_HANDLED;
 995                         goto exit;
 996                 }
 997         } else {
 998                 u8 *myhwaddr = myid(&adapter->eeprompriv);
 999
1000                 if (!ether_addr_equal(pattrib->ra, myhwaddr)) {
1001                         ret = RTW_RX_HANDLED;
1002                         goto exit;
1003                 }
1004                 DBG_8723A("issue_deauth23a to sta=%pM for the reason(7)\n",
1005                           pattrib->src);
1006                 issue_deauth23a(adapter, pattrib->src,
1007                              WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA);
1008                 ret = RTW_RX_HANDLED;
1009                 goto exit;
1010         }
1011
1012 exit:
1013
1014
1015
1016         return ret;
1017 }
1018
1019 static int validate_recv_ctrl_frame(struct rtw_adapter *padapter,
1020                                     struct recv_frame *precv_frame)
1021 {
1022 #ifdef CONFIG_8723AU_AP_MODE
1023         struct rx_pkt_attrib *pattrib = &precv_frame->attrib;
1024         struct sta_priv *pstapriv = &padapter->stapriv;
1025         struct sk_buff *skb = precv_frame->pkt;
1026         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1027
1028         if (!ieee80211_is_ctl(hdr->frame_control))
1029                 return _FAIL;
1030
1031         /* receive the frames that ra(a1) is my address */
1032         if (!ether_addr_equal(hdr->addr1, myid(&padapter->eeprompriv)))
1033                 return _FAIL;
1034
1035         /* only handle ps-poll */
1036         if (ieee80211_is_pspoll(hdr->frame_control)) {
1037                 struct ieee80211_pspoll *psp = (struct ieee80211_pspoll *)hdr;
1038                 u16 aid;
1039                 u8 wmmps_ac = 0;
1040                 struct sta_info *psta = NULL;
1041
1042                 aid = le16_to_cpu(psp->aid) & 0x3fff;
1043                 psta = rtw_get_stainfo23a(pstapriv, hdr->addr2);
1044
1045                 if (!psta || psta->aid != aid)
1046                         return _FAIL;
1047
1048                 /* for rx pkt statistics */
1049                 psta->sta_stats.rx_ctrl_pkts++;
1050
1051                 switch (pattrib->priority) {
1052                 case 1:
1053                 case 2:
1054                         wmmps_ac = psta->uapsd_bk & BIT(0);
1055                         break;
1056                 case 4:
1057                 case 5:
1058                         wmmps_ac = psta->uapsd_vi & BIT(0);
1059                         break;
1060                 case 6:
1061                 case 7:
1062                         wmmps_ac = psta->uapsd_vo & BIT(0);
1063                         break;
1064                 case 0:
1065                 case 3:
1066                 default:
1067                         wmmps_ac = psta->uapsd_be & BIT(0);
1068                         break;
1069                 }
1070
1071                 if (wmmps_ac)
1072                         return _FAIL;
1073
1074                 if (psta->state & WIFI_STA_ALIVE_CHK_STATE) {
1075                         DBG_8723A("%s alive check-rx ps-poll\n", __func__);
1076                         psta->expire_to = pstapriv->expire_to;
1077                         psta->state ^= WIFI_STA_ALIVE_CHK_STATE;
1078                 }
1079
1080                 if ((psta->state & WIFI_SLEEP_STATE) &&
1081                     (pstapriv->sta_dz_bitmap & CHKBIT(psta->aid))) {
1082                         struct list_head *xmitframe_plist, *xmitframe_phead;
1083                         struct xmit_frame *pxmitframe;
1084                         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1085
1086                         spin_lock_bh(&pxmitpriv->lock);
1087
1088                         xmitframe_phead = get_list_head(&psta->sleep_q);
1089                         xmitframe_plist = xmitframe_phead->next;
1090
1091                         if (!list_empty(xmitframe_phead)) {
1092                                 pxmitframe = container_of(xmitframe_plist,
1093                                                           struct xmit_frame,
1094                                                           list);
1095
1096                                 xmitframe_plist = xmitframe_plist->next;
1097
1098                                 list_del_init(&pxmitframe->list);
1099
1100                                 psta->sleepq_len--;
1101
1102                                 if (psta->sleepq_len>0)
1103                                         pxmitframe->attrib.mdata = 1;
1104                                 else
1105                                         pxmitframe->attrib.mdata = 0;
1106
1107                                 pxmitframe->attrib.triggered = 1;
1108
1109                                 /* DBG_8723A("handling ps-poll, q_len =%d, tim =%x\n", psta->sleepq_len, pstapriv->tim_bitmap); */
1110
1111                                 rtl8723au_hal_xmitframe_enqueue(padapter,
1112                                                                 pxmitframe);
1113
1114                                 if (psta->sleepq_len == 0) {
1115                                         pstapriv->tim_bitmap &= ~CHKBIT(psta->aid);
1116
1117                                         /* DBG_8723A("after handling ps-poll, tim =%x\n", pstapriv->tim_bitmap); */
1118
1119                                         /* update BCN for TIM IE */
1120                                         /* update_BCNTIM(padapter); */
1121                                         update_beacon23a(padapter, WLAN_EID_TIM,
1122                                                          NULL, false);
1123                                 }
1124
1125                                 /* spin_unlock_bh(&psta->sleep_q.lock); */
1126                                 spin_unlock_bh(&pxmitpriv->lock);
1127
1128                         } else {
1129                                 /* spin_unlock_bh(&psta->sleep_q.lock); */
1130                                 spin_unlock_bh(&pxmitpriv->lock);
1131
1132                                 /* DBG_8723A("no buffered packets to xmit\n"); */
1133                                 if (pstapriv->tim_bitmap & CHKBIT(psta->aid)) {
1134                                         if (psta->sleepq_len == 0) {
1135                                                 DBG_8723A("no buffered packets "
1136                                                           "to xmit\n");
1137
1138                                                 /* issue nulldata with More data bit = 0 to indicate we have no buffered packets */
1139                                                 issue_nulldata23a(padapter,
1140                                                                psta->hwaddr,
1141                                                                0, 0, 0);
1142                                         } else {
1143                                                 DBG_8723A("error!psta->sleepq"
1144                                                           "_len =%d\n",
1145                                                           psta->sleepq_len);
1146                                                 psta->sleepq_len = 0;
1147                                         }
1148
1149                                         pstapriv->tim_bitmap &= ~CHKBIT(psta->aid);
1150
1151                                         /* update BCN for TIM IE */
1152                                         /* update_BCNTIM(padapter); */
1153                                         update_beacon23a(padapter, WLAN_EID_TIM,
1154                                                          NULL, false);
1155                                 }
1156                         }
1157                 }
1158         }
1159
1160 #endif
1161         return _FAIL;
1162 }
1163
1164 struct recv_frame *recvframe_chk_defrag23a(struct rtw_adapter *padapter,
1165                                         struct recv_frame *precv_frame);
1166 static int validate_recv_mgnt_frame(struct rtw_adapter *padapter,
1167                                     struct recv_frame *precv_frame)
1168 {
1169         struct sta_info *psta;
1170         struct sk_buff *skb;
1171         struct ieee80211_hdr *hdr;
1172         /* struct mlme_priv *pmlmepriv = &adapter->mlmepriv; */
1173
1174         RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
1175                  "+validate_recv_mgnt_frame\n");
1176
1177         precv_frame = recvframe_chk_defrag23a(padapter, precv_frame);
1178         if (precv_frame == NULL) {
1179                 RT_TRACE(_module_rtl871x_recv_c_, _drv_notice_,
1180                          "%s: fragment packet\n", __func__);
1181                 return _SUCCESS;
1182         }
1183
1184         skb = precv_frame->pkt;
1185         hdr = (struct ieee80211_hdr *) skb->data;
1186
1187                 /* for rx pkt statistics */
1188         psta = rtw_get_stainfo23a(&padapter->stapriv, hdr->addr2);
1189         if (psta) {
1190                 psta->sta_stats.rx_mgnt_pkts++;
1191
1192                 if (ieee80211_is_beacon(hdr->frame_control))
1193                         psta->sta_stats.rx_beacon_pkts++;
1194                 else if (ieee80211_is_probe_req(hdr->frame_control))
1195                         psta->sta_stats.rx_probereq_pkts++;
1196                 else if (ieee80211_is_probe_resp(hdr->frame_control)) {
1197                         if (ether_addr_equal(padapter->eeprompriv.mac_addr,
1198                                     hdr->addr1))
1199                                 psta->sta_stats.rx_probersp_pkts++;
1200                         else if (is_broadcast_ether_addr(hdr->addr1) ||
1201                                  is_multicast_ether_addr(hdr->addr1))
1202                                 psta->sta_stats.rx_probersp_bm_pkts++;
1203                         else
1204                                 psta->sta_stats.rx_probersp_uo_pkts++;
1205                 }
1206         }
1207
1208         mgt_dispatcher23a(padapter, precv_frame);
1209
1210         return _SUCCESS;
1211 }
1212
1213 static int validate_recv_data_frame(struct rtw_adapter *adapter,
1214                                     struct recv_frame *precv_frame)
1215 {
1216         u8 bretry;
1217         u8 *psa, *pda;
1218         struct sta_info *psta = NULL;
1219         struct rx_pkt_attrib *pattrib = & precv_frame->attrib;
1220         struct security_priv *psecuritypriv = &adapter->securitypriv;
1221         int ret = _SUCCESS;
1222         struct sk_buff *skb = precv_frame->pkt;
1223         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1224
1225
1226
1227         bretry = ieee80211_has_retry(hdr->frame_control);
1228         pda = ieee80211_get_DA(hdr);
1229         psa = ieee80211_get_SA(hdr);
1230
1231         ether_addr_copy(pattrib->dst, pda);
1232         ether_addr_copy(pattrib->src, psa);
1233
1234         switch (hdr->frame_control &
1235                 cpu_to_le16(IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS)) {
1236         case cpu_to_le16(0):
1237                 ether_addr_copy(pattrib->bssid, hdr->addr3);
1238                 ether_addr_copy(pattrib->ra, pda);
1239                 ether_addr_copy(pattrib->ta, psa);
1240                 ret = sta2sta_data_frame(adapter, precv_frame, &psta);
1241                 break;
1242
1243         case cpu_to_le16(IEEE80211_FCTL_FROMDS):
1244                 ether_addr_copy(pattrib->bssid, hdr->addr2);
1245                 ether_addr_copy(pattrib->ra, pda);
1246                 ether_addr_copy(pattrib->ta, hdr->addr2);
1247                 ret = ap2sta_data_frame(adapter, precv_frame, &psta);
1248                 break;
1249
1250         case cpu_to_le16(IEEE80211_FCTL_TODS):
1251                 ether_addr_copy(pattrib->bssid, hdr->addr1);
1252                 ether_addr_copy(pattrib->ra, hdr->addr1);
1253                 ether_addr_copy(pattrib->ta, psa);
1254                 ret = sta2ap_data_frame(adapter, precv_frame, &psta);
1255                 break;
1256
1257         case cpu_to_le16(IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS):
1258                 /*
1259                  * There is no BSSID in this case, but the driver has been
1260                  * using addr1 so far, so keep it for now.
1261                  */
1262                 ether_addr_copy(pattrib->bssid, hdr->addr1);
1263                 ether_addr_copy(pattrib->ra, hdr->addr1);
1264                 ether_addr_copy(pattrib->ta, hdr->addr2);
1265                 ret = _FAIL;
1266                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_, "case 3\n");
1267                 break;
1268         }
1269
1270         if ((ret == _FAIL) || (ret == RTW_RX_HANDLED))
1271                 goto exit;
1272
1273         if (!psta) {
1274                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
1275                          "after to_fr_ds_chk; psta == NULL\n");
1276                 ret = _FAIL;
1277                 goto exit;
1278         }
1279
1280         /* psta->rssi = prxcmd->rssi; */
1281         /* psta->signal_quality = prxcmd->sq; */
1282         precv_frame->psta = psta;
1283
1284         pattrib->hdrlen = sizeof(struct ieee80211_hdr_3addr);
1285         if (ieee80211_has_a4(hdr->frame_control))
1286                 pattrib->hdrlen += ETH_ALEN;
1287
1288         /* parsing QC field */
1289         if (pattrib->qos == 1) {
1290                 __le16 *qptr = (__le16 *)ieee80211_get_qos_ctl(hdr);
1291                 u16 qos_ctrl = le16_to_cpu(*qptr);
1292
1293                 pattrib->priority = qos_ctrl & IEEE80211_QOS_CTL_TID_MASK;
1294                 pattrib->ack_policy = (qos_ctrl >> 5) & 3;
1295                 pattrib->amsdu =
1296                         (qos_ctrl & IEEE80211_QOS_CTL_A_MSDU_PRESENT) >> 7;
1297                 pattrib->hdrlen += IEEE80211_QOS_CTL_LEN;
1298
1299                 if (pattrib->priority != 0 && pattrib->priority != 3) {
1300                         adapter->recvpriv.bIsAnyNonBEPkts = true;
1301                 }
1302         } else {
1303                 pattrib->priority = 0;
1304                 pattrib->ack_policy = 0;
1305                 pattrib->amsdu = 0;
1306         }
1307
1308         if (pattrib->order) { /* HT-CTRL 11n */
1309                 pattrib->hdrlen += 4;
1310         }
1311
1312         precv_frame->preorder_ctrl = &psta->recvreorder_ctrl[pattrib->priority];
1313
1314         /*  decache, drop duplicate recv packets */
1315         if (recv_decache(precv_frame, bretry, &psta->sta_recvpriv.rxcache) ==
1316             _FAIL) {
1317                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
1318                          "decache : drop pkt\n");
1319                 ret = _FAIL;
1320                 goto exit;
1321         }
1322
1323         if (pattrib->privacy) {
1324                 RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
1325                          "validate_recv_data_frame:pattrib->privacy =%x\n",
1326                          pattrib->privacy);
1327                 RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
1328                          "^^^^^^^^^^^is_multicast_ether_addr(pattrib->ra(0x%02x)) =%d^^^^^^^^^^^^^^^6\n",
1329                          pattrib->ra[0],
1330                          is_multicast_ether_addr(pattrib->ra));
1331
1332                 GET_ENCRY_ALGO(psecuritypriv, psta, pattrib->encrypt,
1333                                is_multicast_ether_addr(pattrib->ra));
1334
1335                 RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
1336                          "pattrib->encrypt =%d\n", pattrib->encrypt);
1337
1338                 switch (pattrib->encrypt) {
1339                 case WLAN_CIPHER_SUITE_WEP40:
1340                 case WLAN_CIPHER_SUITE_WEP104:
1341                         pattrib->iv_len = IEEE80211_WEP_IV_LEN;
1342                         pattrib->icv_len = IEEE80211_WEP_ICV_LEN;
1343                         break;
1344                 case WLAN_CIPHER_SUITE_TKIP:
1345                         pattrib->iv_len = IEEE80211_TKIP_IV_LEN;
1346                         pattrib->icv_len = IEEE80211_TKIP_ICV_LEN;
1347                         break;
1348                 case WLAN_CIPHER_SUITE_CCMP:
1349                         pattrib->iv_len = IEEE80211_CCMP_HDR_LEN;
1350                         pattrib->icv_len = IEEE80211_CCMP_MIC_LEN;
1351                         break;
1352                 default:
1353                         pattrib->iv_len = 0;
1354                         pattrib->icv_len = 0;
1355                         break;
1356                 }
1357         } else {
1358                 pattrib->encrypt = 0;
1359                 pattrib->iv_len = 0;
1360                 pattrib->icv_len = 0;
1361         }
1362
1363 exit:
1364
1365
1366
1367         return ret;
1368 }
1369
1370 static void dump_rx_pkt(struct sk_buff *skb, u16 type, int level)
1371 {
1372         int i;
1373         u8 *ptr;
1374
1375         if ((level == 1) ||
1376             ((level == 2) && (type == IEEE80211_FTYPE_MGMT)) ||
1377             ((level == 3) && (type == IEEE80211_FTYPE_DATA))) {
1378
1379                 ptr = skb->data;
1380
1381                 DBG_8723A("#############################\n");
1382
1383                 for (i = 0; i < 64; i = i + 8)
1384                         DBG_8723A("%*phC:\n", 8, ptr + i);
1385                 DBG_8723A("#############################\n");
1386         }
1387 }
1388
1389 static int validate_recv_frame(struct rtw_adapter *adapter,
1390                                struct recv_frame *precv_frame)
1391 {
1392         /* shall check frame subtype, to / from ds, da, bssid */
1393
1394         /* then call check if rx seq/frag. duplicated. */
1395         u8 type;
1396         u8 subtype;
1397         int retval = _SUCCESS;
1398         struct rx_pkt_attrib *pattrib = & precv_frame->attrib;
1399         struct sk_buff *skb = precv_frame->pkt;
1400         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1401         u8 ver;
1402         u8 bDumpRxPkt;
1403         u16 seq_ctrl, fctl;
1404
1405         fctl = le16_to_cpu(hdr->frame_control);
1406         ver = fctl & IEEE80211_FCTL_VERS;
1407         type = fctl & IEEE80211_FCTL_FTYPE;
1408         subtype = fctl & IEEE80211_FCTL_STYPE;
1409
1410         /* add version chk */
1411         if (ver != 0) {
1412                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
1413                          "validate_recv_data_frame fail! (ver!= 0)\n");
1414                 retval = _FAIL;
1415                 goto exit;
1416         }
1417
1418         seq_ctrl = le16_to_cpu(hdr->seq_ctrl);
1419         pattrib->frag_num = seq_ctrl & IEEE80211_SCTL_FRAG;
1420         pattrib->seq_num = seq_ctrl >> 4;
1421
1422         pattrib->pw_save = ieee80211_has_pm(hdr->frame_control);
1423         pattrib->mfrag = ieee80211_has_morefrags(hdr->frame_control);
1424         pattrib->mdata = ieee80211_has_moredata(hdr->frame_control);
1425         pattrib->privacy = ieee80211_has_protected(hdr->frame_control);
1426         pattrib->order = ieee80211_has_order(hdr->frame_control);
1427
1428         GetHalDefVar8192CUsb(adapter, HAL_DEF_DBG_DUMP_RXPKT, &bDumpRxPkt);
1429
1430         if (unlikely(bDumpRxPkt == 1))
1431                 dump_rx_pkt(skb, type, bDumpRxPkt);
1432
1433         switch (type) {
1434         case IEEE80211_FTYPE_MGMT:
1435                 retval = validate_recv_mgnt_frame(adapter, precv_frame);
1436                 if (retval == _FAIL) {
1437                         RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
1438                                  "validate_recv_mgnt_frame fail\n");
1439                 }
1440                 retval = _FAIL; /*  only data frame return _SUCCESS */
1441                 break;
1442         case IEEE80211_FTYPE_CTL:
1443                 retval = validate_recv_ctrl_frame(adapter, precv_frame);
1444                 if (retval == _FAIL) {
1445                         RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
1446                                  "validate_recv_ctrl_frame fail\n");
1447                 }
1448                 retval = _FAIL; /*  only data frame return _SUCCESS */
1449                 break;
1450         case IEEE80211_FTYPE_DATA:
1451                 pattrib->qos = (subtype & IEEE80211_STYPE_QOS_DATA) ? 1 : 0;
1452                 retval = validate_recv_data_frame(adapter, precv_frame);
1453                 if (retval == _FAIL) {
1454                         struct recv_priv *precvpriv = &adapter->recvpriv;
1455
1456                         precvpriv->rx_drop++;
1457                 }
1458                 break;
1459         default:
1460                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
1461                          "validate_recv_data_frame fail! type = 0x%x\n", type);
1462                 retval = _FAIL;
1463                 break;
1464         }
1465
1466 exit:
1467         return retval;
1468 }
1469
1470 /* remove the wlanhdr and add the eth_hdr */
1471
1472 static int wlanhdr_to_ethhdr (struct recv_frame *precvframe)
1473 {
1474         u16     eth_type, len, hdrlen;
1475         u8      bsnaphdr;
1476         u8      *psnap;
1477         struct rtw_adapter *adapter = precvframe->adapter;
1478         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1479
1480         struct sk_buff *skb = precvframe->pkt;
1481         u8 *ptr;
1482         struct rx_pkt_attrib *pattrib = &precvframe->attrib;
1483
1484
1485
1486         ptr = skb->data;
1487         hdrlen = pattrib->hdrlen;
1488         psnap = ptr + hdrlen;
1489         eth_type = (psnap[6] << 8) | psnap[7];
1490         /* convert hdr + possible LLC headers into Ethernet header */
1491         /* eth_type = (psnap_type[0] << 8) | psnap_type[1]; */
1492         if ((ether_addr_equal(psnap, rfc1042_header) &&
1493              eth_type != ETH_P_AARP && eth_type != ETH_P_IPX) ||
1494             ether_addr_equal(psnap, bridge_tunnel_header)) {
1495                 /* remove RFC1042 or Bridge-Tunnel encapsulation
1496                    and replace EtherType */
1497                 bsnaphdr = true;
1498                 hdrlen += SNAP_SIZE;
1499         } else {
1500                 /* Leave Ethernet header part of hdr and full payload */
1501                 bsnaphdr = false;
1502                 eth_type = (psnap[0] << 8) | psnap[1];
1503         }
1504
1505         len = skb->len - hdrlen;
1506
1507         RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
1508                  "=== pattrib->hdrlen: %x,  pattrib->iv_len:%x ===\n",
1509                  pattrib->hdrlen,  pattrib->iv_len);
1510
1511         pattrib->eth_type = eth_type;
1512         if (check_fwstate(pmlmepriv, WIFI_MP_STATE)) {
1513                 ptr += hdrlen;
1514                 *ptr = 0x87;
1515                 *(ptr + 1) = 0x12;
1516
1517                 eth_type = 0x8712;
1518                 /*  append rx status for mp test packets */
1519
1520                 ptr = skb_pull(skb, (hdrlen - sizeof(struct ethhdr) + 2) - 24);
1521                 memcpy(ptr, skb->head, 24);
1522                 ptr += 24;
1523         } else {
1524                 ptr = skb_pull(skb, (hdrlen - sizeof(struct ethhdr) +
1525                                      (bsnaphdr ? 2:0)));
1526         }
1527
1528         ether_addr_copy(ptr, pattrib->dst);
1529         ether_addr_copy(ptr + ETH_ALEN, pattrib->src);
1530
1531         if (!bsnaphdr) {
1532                 put_unaligned_be16(len, ptr + 12);
1533         }
1534
1535
1536         return _SUCCESS;
1537 }
1538
1539 /* perform defrag */
1540 struct recv_frame *recvframe_defrag(struct rtw_adapter *adapter,
1541                                     struct rtw_queue *defrag_q);
1542 struct recv_frame *recvframe_defrag(struct rtw_adapter *adapter,
1543                                     struct rtw_queue *defrag_q)
1544 {
1545         struct list_head *plist, *phead;
1546         u8 wlanhdr_offset;
1547         u8 curfragnum;
1548         struct recv_frame *pnfhdr, *ptmp;
1549         struct recv_frame *prframe, *pnextrframe;
1550         struct rtw_queue *pfree_recv_queue;
1551         struct sk_buff *skb;
1552
1553         curfragnum = 0;
1554         pfree_recv_queue = &adapter->recvpriv.free_recv_queue;
1555
1556         phead = get_list_head(defrag_q);
1557         plist = phead->next;
1558         prframe = container_of(plist, struct recv_frame, list);
1559         list_del_init(&prframe->list);
1560         skb = prframe->pkt;
1561
1562         if (curfragnum != prframe->attrib.frag_num) {
1563                 /* the first fragment number must be 0 */
1564                 /* free the whole queue */
1565                 rtw_free_recvframe23a(prframe);
1566                 rtw_free_recvframe23a_queue(defrag_q);
1567
1568                 return NULL;
1569         }
1570
1571         curfragnum++;
1572
1573         list_for_each_entry_safe(pnfhdr, ptmp, phead, list) {
1574                 pnextrframe = (struct recv_frame *)pnfhdr;
1575                 /* check the fragment sequence  (2nd ~n fragment frame) */
1576
1577                 if (curfragnum != pnfhdr->attrib.frag_num) {
1578                         /* the fragment number must be increasing
1579                            (after decache) */
1580                         /* release the defrag_q & prframe */
1581                         rtw_free_recvframe23a(prframe);
1582                         rtw_free_recvframe23a_queue(defrag_q);
1583                         return NULL;
1584                 }
1585
1586                 curfragnum++;
1587
1588                 /* copy the 2nd~n fragment frame's payload to the
1589                    first fragment */
1590                 /* get the 2nd~last fragment frame's payload */
1591
1592                 wlanhdr_offset = pnfhdr->attrib.hdrlen + pnfhdr->attrib.iv_len;
1593
1594                 skb_pull(pnfhdr->pkt, wlanhdr_offset);
1595
1596                 /* append  to first fragment frame's tail
1597                    (if privacy frame, pull the ICV) */
1598
1599                 skb_trim(skb, skb->len - prframe->attrib.icv_len);
1600
1601                 memcpy(skb_tail_pointer(skb), pnfhdr->pkt->data,
1602                        pnfhdr->pkt->len);
1603
1604                 skb_put(skb, pnfhdr->pkt->len);
1605
1606                 prframe->attrib.icv_len = pnfhdr->attrib.icv_len;
1607         }
1608
1609         /* free the defrag_q queue and return the prframe */
1610         rtw_free_recvframe23a_queue(defrag_q);
1611
1612         RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
1613                  "Performance defrag!!!!!\n");
1614
1615         return prframe;
1616 }
1617
1618 /* check if need to defrag, if needed queue the frame to defrag_q */
1619 struct recv_frame *recvframe_chk_defrag23a(struct rtw_adapter *padapter,
1620                                         struct recv_frame *precv_frame)
1621 {
1622         u8      ismfrag;
1623         u8      fragnum;
1624         u8      *psta_addr;
1625         struct recv_frame *pfhdr;
1626         struct sta_info *psta;
1627         struct sta_priv *pstapriv;
1628         struct list_head *phead;
1629         struct recv_frame *prtnframe = NULL;
1630         struct rtw_queue *pfree_recv_queue, *pdefrag_q;
1631
1632
1633
1634         pstapriv = &padapter->stapriv;
1635
1636         pfhdr = precv_frame;
1637
1638         pfree_recv_queue = &padapter->recvpriv.free_recv_queue;
1639
1640         /* need to define struct of wlan header frame ctrl */
1641         ismfrag = pfhdr->attrib.mfrag;
1642         fragnum = pfhdr->attrib.frag_num;
1643
1644         psta_addr = pfhdr->attrib.ta;
1645         psta = rtw_get_stainfo23a(pstapriv, psta_addr);
1646         if (!psta) {
1647                 struct ieee80211_hdr *hdr =
1648                         (struct ieee80211_hdr *) pfhdr->pkt->data;
1649                 if (!ieee80211_is_data(hdr->frame_control)) {
1650                         psta = rtw_get_bcmc_stainfo23a(padapter);
1651                         pdefrag_q = &psta->sta_recvpriv.defrag_q;
1652                 } else
1653                         pdefrag_q = NULL;
1654         } else
1655                 pdefrag_q = &psta->sta_recvpriv.defrag_q;
1656
1657         if ((ismfrag == 0) && (fragnum == 0)) {
1658                 prtnframe = precv_frame;/* isn't a fragment frame */
1659         }
1660
1661         if (ismfrag == 1) {
1662                 /* 0~(n-1) fragment frame */
1663                 /* enqueue to defraf_g */
1664                 if (pdefrag_q != NULL) {
1665                         if (fragnum == 0) {
1666                                 /* the first fragment */
1667                                 if (!list_empty(&pdefrag_q->queue)) {
1668                                         /* free current defrag_q */
1669                                         rtw_free_recvframe23a_queue(pdefrag_q);
1670                                 }
1671                         }
1672
1673                         /* Then enqueue the 0~(n-1) fragment into the
1674                            defrag_q */
1675
1676                         /* spin_lock(&pdefrag_q->lock); */
1677                         phead = get_list_head(pdefrag_q);
1678                         list_add_tail(&pfhdr->list, phead);
1679                         /* spin_unlock(&pdefrag_q->lock); */
1680
1681                         RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
1682                                  "Enqueuq: ismfrag = %d, fragnum = %d\n",
1683                                  ismfrag, fragnum);
1684
1685                         prtnframe = NULL;
1686
1687                 } else {
1688                         /* can't find this ta's defrag_queue,
1689                            so free this recv_frame */
1690                         rtw_free_recvframe23a(precv_frame);
1691                         prtnframe = NULL;
1692                         RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
1693                                  "Free because pdefrag_q == NULL: ismfrag = %d, fragnum = %d\n",
1694                                  ismfrag, fragnum);
1695                 }
1696         }
1697
1698         if ((ismfrag == 0) && (fragnum != 0)) {
1699                 /* the last fragment frame */
1700                 /* enqueue the last fragment */
1701                 if (pdefrag_q != NULL) {
1702                         /* spin_lock(&pdefrag_q->lock); */
1703                         phead = get_list_head(pdefrag_q);
1704                         list_add_tail(&pfhdr->list, phead);
1705                         /* spin_unlock(&pdefrag_q->lock); */
1706
1707                         /* call recvframe_defrag to defrag */
1708                         RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
1709                                  "defrag: ismfrag = %d, fragnum = %d\n",
1710                                  ismfrag, fragnum);
1711                         precv_frame = recvframe_defrag(padapter, pdefrag_q);
1712                         prtnframe = precv_frame;
1713                 } else {
1714                         /* can't find this ta's defrag_queue,
1715                            so free this recv_frame */
1716                         rtw_free_recvframe23a(precv_frame);
1717                         prtnframe = NULL;
1718                         RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
1719                                  "Free because pdefrag_q == NULL: ismfrag = %d, fragnum = %d\n",
1720                                  ismfrag, fragnum);
1721                 }
1722
1723         }
1724
1725         if ((prtnframe != NULL) && (prtnframe->attrib.privacy)) {
1726                 /* after defrag we must check tkip mic code */
1727                 if (recvframe_chkmic(padapter,  prtnframe) == _FAIL) {
1728                         RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
1729                                  "recvframe_chkmic(padapter,  prtnframe) ==_FAIL\n");
1730                         rtw_free_recvframe23a(prtnframe);
1731                         prtnframe = NULL;
1732                 }
1733         }
1734
1735
1736
1737         return prtnframe;
1738 }
1739
1740 int amsdu_to_msdu(struct rtw_adapter *padapter, struct recv_frame *prframe);
1741 int amsdu_to_msdu(struct rtw_adapter *padapter, struct recv_frame *prframe)
1742 {
1743         struct rx_pkt_attrib *pattrib;
1744         struct sk_buff *skb, *sub_skb;
1745         struct sk_buff_head skb_list;
1746
1747         pattrib = &prframe->attrib;
1748
1749         skb = prframe->pkt;
1750         skb_pull(skb, prframe->attrib.hdrlen);
1751         __skb_queue_head_init(&skb_list);
1752
1753         ieee80211_amsdu_to_8023s(skb, &skb_list, NULL, 0, 0, false);
1754
1755         while (!skb_queue_empty(&skb_list)) {
1756                 sub_skb = __skb_dequeue(&skb_list);
1757
1758                 sub_skb->protocol = eth_type_trans(sub_skb, padapter->pnetdev);
1759                 sub_skb->dev = padapter->pnetdev;
1760
1761                 sub_skb->ip_summed = CHECKSUM_NONE;
1762
1763                 netif_rx(sub_skb);
1764         }
1765
1766         prframe->pkt = NULL;
1767         rtw_free_recvframe23a(prframe);
1768         return _SUCCESS;
1769 }
1770
1771 int check_indicate_seq(struct recv_reorder_ctrl *preorder_ctrl, u16 seq_num);
1772 int check_indicate_seq(struct recv_reorder_ctrl *preorder_ctrl, u16 seq_num)
1773 {
1774         u8      wsize = preorder_ctrl->wsize_b;
1775         u16     wend = (preorder_ctrl->indicate_seq + wsize -1) & 0xFFF;
1776
1777         /*  Rx Reorder initialize condition. */
1778         if (preorder_ctrl->indicate_seq == 0xFFFF)
1779                 preorder_ctrl->indicate_seq = seq_num;
1780
1781         /*  Drop out the packet which SeqNum is smaller than WinStart */
1782         if (SN_LESS(seq_num, preorder_ctrl->indicate_seq))
1783                 return false;
1784
1785         /*  */
1786         /*  Sliding window manipulation. Conditions includes: */
1787         /*  1. Incoming SeqNum is equal to WinStart =>Window shift 1 */
1788         /*  2. Incoming SeqNum is larger than the WinEnd => Window shift N */
1789         /*  */
1790         if (SN_EQUAL(seq_num, preorder_ctrl->indicate_seq)) {
1791                 preorder_ctrl->indicate_seq =
1792                         (preorder_ctrl->indicate_seq + 1) & 0xFFF;
1793         } else if (SN_LESS(wend, seq_num)) {
1794                 /*  boundary situation, when seq_num cross 0xFFF */
1795                 if (seq_num >= (wsize - 1))
1796                         preorder_ctrl->indicate_seq = seq_num + 1 -wsize;
1797                 else
1798                         preorder_ctrl->indicate_seq = 0xFFF - (wsize - (seq_num + 1)) + 1;
1799         }
1800         return true;
1801 }
1802
1803 static int enqueue_reorder_recvframe23a(struct recv_reorder_ctrl *preorder_ctrl,
1804                                         struct recv_frame *prframe)
1805 {
1806         struct rx_pkt_attrib *pattrib = &prframe->attrib;
1807         struct rtw_queue *ppending_recvframe_queue;
1808         struct list_head *phead, *plist, *ptmp;
1809         struct recv_frame *hdr;
1810         struct rx_pkt_attrib *pnextattrib;
1811
1812         ppending_recvframe_queue = &preorder_ctrl->pending_recvframe_queue;
1813         /* DbgPrint("+enqueue_reorder_recvframe23a()\n"); */
1814
1815         /* spin_lock_irqsave(&ppending_recvframe_queue->lock); */
1816         /* spin_lock_ex(&ppending_recvframe_queue->lock); */
1817
1818         phead = get_list_head(ppending_recvframe_queue);
1819
1820         list_for_each_safe(plist, ptmp, phead) {
1821                 hdr = container_of(plist, struct recv_frame, list);
1822                 pnextattrib = &hdr->attrib;
1823
1824                 if (SN_LESS(pnextattrib->seq_num, pattrib->seq_num)) {
1825                         continue;
1826                 } else if (SN_EQUAL(pnextattrib->seq_num, pattrib->seq_num)) {
1827                         /* Duplicate entry is found!! Do not insert current entry. */
1828
1829                         /* spin_unlock_irqrestore(&ppending_recvframe_queue->lock); */
1830                         return false;
1831                 } else {
1832                         break;
1833                 }
1834
1835                 /* DbgPrint("enqueue_reorder_recvframe23a():while\n"); */
1836         }
1837
1838         /* spin_lock_irqsave(&ppending_recvframe_queue->lock); */
1839         /* spin_lock_ex(&ppending_recvframe_queue->lock); */
1840
1841         list_del_init(&prframe->list);
1842
1843         list_add_tail(&prframe->list, plist);
1844
1845         /* spin_unlock_ex(&ppending_recvframe_queue->lock); */
1846         /* spin_unlock_irqrestore(&ppending_recvframe_queue->lock); */
1847
1848         return true;
1849 }
1850
1851 int recv_indicatepkts_in_order(struct rtw_adapter *padapter,
1852                                struct recv_reorder_ctrl *preorder_ctrl,
1853                                int bforced);
1854 int recv_indicatepkts_in_order(struct rtw_adapter *padapter,
1855                                struct recv_reorder_ctrl *preorder_ctrl,
1856                                int bforced)
1857 {
1858         /* u8 bcancelled; */
1859         struct list_head *phead, *plist;
1860         struct recv_frame *prframe;
1861         struct rx_pkt_attrib *pattrib;
1862         /* u8 index = 0; */
1863         int bPktInBuf = false;
1864         struct recv_priv *precvpriv;
1865         struct rtw_queue *ppending_recvframe_queue;
1866
1867         precvpriv = &padapter->recvpriv;
1868         ppending_recvframe_queue = &preorder_ctrl->pending_recvframe_queue;
1869         /* DbgPrint("+recv_indicatepkts_in_order\n"); */
1870
1871         /* spin_lock_irqsave(&ppending_recvframe_queue->lock); */
1872         /* spin_lock_ex(&ppending_recvframe_queue->lock); */
1873
1874         phead = get_list_head(ppending_recvframe_queue);
1875         plist = phead->next;
1876
1877         /*  Handling some condition for forced indicate case. */
1878         if (bforced) {
1879                 if (list_empty(phead)) {
1880                         /*  spin_unlock_irqrestore(&ppending_recvframe_queue->lock); */
1881                         /* spin_unlock_ex(&ppending_recvframe_queue->lock); */
1882                         return true;
1883                 }
1884
1885                 prframe = container_of(plist, struct recv_frame, list);
1886                 pattrib = &prframe->attrib;
1887                 preorder_ctrl->indicate_seq = pattrib->seq_num;
1888         }
1889
1890         /*  Prepare indication list and indication. */
1891         /*  Check if there is any packet need indicate. */
1892         while (!list_empty(phead)) {
1893
1894                 prframe = container_of(plist, struct recv_frame, list);
1895                 pattrib = &prframe->attrib;
1896
1897                 if (!SN_LESS(preorder_ctrl->indicate_seq, pattrib->seq_num)) {
1898                         RT_TRACE(_module_rtl871x_recv_c_, _drv_notice_,
1899                                  "recv_indicatepkts_in_order: indicate =%d seq =%d amsdu =%d\n",
1900                                  preorder_ctrl->indicate_seq,
1901                                  pattrib->seq_num, pattrib->amsdu);
1902
1903                         plist = plist->next;
1904                         list_del_init(&prframe->list);
1905
1906                         if (SN_EQUAL(preorder_ctrl->indicate_seq,
1907                                      pattrib->seq_num)) {
1908                                 preorder_ctrl->indicate_seq =
1909                                         (preorder_ctrl->indicate_seq + 1)&0xFFF;
1910                         }
1911
1912                         if (!pattrib->amsdu) {
1913                                 if ((padapter->bDriverStopped == false) &&
1914                                     (padapter->bSurpriseRemoved == false)) {
1915                                         rtw_recv_indicatepkt23a(padapter, prframe);
1916                                 }
1917                         } else {
1918                                 if (amsdu_to_msdu(padapter, prframe) !=
1919                                     _SUCCESS)
1920                                         rtw_free_recvframe23a(prframe);
1921                         }
1922
1923                         /* Update local variables. */
1924                         bPktInBuf = false;
1925
1926                 } else {
1927                         bPktInBuf = true;
1928                         break;
1929                 }
1930
1931                 /* DbgPrint("recv_indicatepkts_in_order():while\n"); */
1932         }
1933
1934         /* spin_unlock_ex(&ppending_recvframe_queue->lock); */
1935         /* spin_unlock_irqrestore(&ppending_recvframe_queue->lock); */
1936
1937         return bPktInBuf;
1938 }
1939
1940 int recv_indicatepkt_reorder(struct rtw_adapter *padapter,
1941                              struct recv_frame *prframe);
1942 int recv_indicatepkt_reorder(struct rtw_adapter *padapter,
1943                              struct recv_frame *prframe)
1944 {
1945         int retval = _SUCCESS;
1946         struct rx_pkt_attrib *pattrib;
1947         struct recv_reorder_ctrl *preorder_ctrl;
1948         struct rtw_queue *ppending_recvframe_queue;
1949
1950         pattrib = &prframe->attrib;
1951         preorder_ctrl = prframe->preorder_ctrl;
1952         ppending_recvframe_queue = &preorder_ctrl->pending_recvframe_queue;
1953
1954         if (!pattrib->amsdu) {
1955                 /* s1. */
1956                 wlanhdr_to_ethhdr(prframe);
1957
1958                 if ((pattrib->qos!= 1) || (pattrib->eth_type == ETH_P_ARP) ||
1959                     (pattrib->ack_policy != 0)) {
1960                         if ((padapter->bDriverStopped == false) &&
1961                             (padapter->bSurpriseRemoved == false)) {
1962                                 RT_TRACE(_module_rtl871x_recv_c_, _drv_notice_,
1963                                          "@@@@  recv_indicatepkt_reorder -recv_func recv_indicatepkt\n");
1964
1965                                 rtw_recv_indicatepkt23a(padapter, prframe);
1966                                 return _SUCCESS;
1967                         }
1968
1969                         return _FAIL;
1970                 }
1971
1972                 if (preorder_ctrl->enable == false) {
1973                         /* indicate this recv_frame */
1974                         preorder_ctrl->indicate_seq = pattrib->seq_num;
1975                         rtw_recv_indicatepkt23a(padapter, prframe);
1976
1977                         preorder_ctrl->indicate_seq =
1978                                 (preorder_ctrl->indicate_seq + 1) % 4096;
1979                         return _SUCCESS;
1980                 }
1981         } else {
1982                  /* temp filter -> means didn't support A-MSDUs in a A-MPDU */
1983                 if (preorder_ctrl->enable == false) {
1984                         preorder_ctrl->indicate_seq = pattrib->seq_num;
1985                         retval = amsdu_to_msdu(padapter, prframe);
1986
1987                         preorder_ctrl->indicate_seq =
1988                                 (preorder_ctrl->indicate_seq + 1) % 4096;
1989                         return retval;
1990                 }
1991         }
1992
1993         spin_lock_bh(&ppending_recvframe_queue->lock);
1994
1995         RT_TRACE(_module_rtl871x_recv_c_, _drv_notice_,
1996                  "recv_indicatepkt_reorder: indicate =%d seq =%d\n",
1997                  preorder_ctrl->indicate_seq, pattrib->seq_num);
1998
1999         /* s2. check if winstart_b(indicate_seq) needs to been updated */
2000         if (!check_indicate_seq(preorder_ctrl, pattrib->seq_num)) {
2001                 goto _err_exit;
2002         }
2003
2004         /* s3. Insert all packet into Reorder Queue to maintain its ordering. */
2005         if (!enqueue_reorder_recvframe23a(preorder_ctrl, prframe)) {
2006                 goto _err_exit;
2007         }
2008
2009         /* s4. */
2010         /*  Indication process. */
2011         /*  After Packet dropping and Sliding Window shifting as above,
2012             we can now just indicate the packets */
2013         /*  with the SeqNum smaller than latest WinStart and buffer
2014             other packets. */
2015         /*  */
2016         /*  For Rx Reorder condition: */
2017         /*  1. All packets with SeqNum smaller than WinStart => Indicate */
2018         /*  2. All packets with SeqNum larger than or equal to WinStart =>
2019             Buffer it. */
2020         /*  */
2021
2022         if (recv_indicatepkts_in_order(padapter, preorder_ctrl, false) == true) {
2023                 mod_timer(&preorder_ctrl->reordering_ctrl_timer,
2024                           jiffies + msecs_to_jiffies(REORDER_WAIT_TIME));
2025                 spin_unlock_bh(&ppending_recvframe_queue->lock);
2026         } else {
2027                 spin_unlock_bh(&ppending_recvframe_queue->lock);
2028                 del_timer_sync(&preorder_ctrl->reordering_ctrl_timer);
2029         }
2030         return _SUCCESS;
2031
2032 _err_exit:
2033
2034         spin_unlock_bh(&ppending_recvframe_queue->lock);
2035         return _FAIL;
2036 }
2037
2038 void rtw_reordering_ctrl_timeout_handler23a(unsigned long pcontext)
2039 {
2040         struct recv_reorder_ctrl *preorder_ctrl;
2041         struct rtw_adapter *padapter;
2042         struct rtw_queue *ppending_recvframe_queue;
2043
2044         preorder_ctrl = (struct recv_reorder_ctrl *)pcontext;
2045         padapter = preorder_ctrl->padapter;
2046         ppending_recvframe_queue = &preorder_ctrl->pending_recvframe_queue;
2047
2048         if (padapter->bDriverStopped || padapter->bSurpriseRemoved) {
2049                 return;
2050         }
2051
2052         /* DBG_8723A("+rtw_reordering_ctrl_timeout_handler23a() =>\n"); */
2053
2054         spin_lock_bh(&ppending_recvframe_queue->lock);
2055
2056         if (recv_indicatepkts_in_order(padapter, preorder_ctrl, true) == true) {
2057                 mod_timer(&preorder_ctrl->reordering_ctrl_timer,
2058                           jiffies + msecs_to_jiffies(REORDER_WAIT_TIME));
2059         }
2060
2061         spin_unlock_bh(&ppending_recvframe_queue->lock);
2062 }
2063
2064 int process_recv_indicatepkts(struct rtw_adapter *padapter,
2065                               struct recv_frame *prframe);
2066 int process_recv_indicatepkts(struct rtw_adapter *padapter,
2067                               struct recv_frame *prframe)
2068 {
2069         int retval = _SUCCESS;
2070         /* struct recv_priv *precvpriv = &padapter->recvpriv; */
2071         /* struct rx_pkt_attrib *pattrib = &prframe->attrib; */
2072         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2073         struct ht_priv *phtpriv = &pmlmepriv->htpriv;
2074
2075         if (phtpriv->ht_option == true) { /* B/G/N Mode */
2076                 /* prframe->preorder_ctrl = &precvpriv->recvreorder_ctrl[pattrib->priority]; */
2077
2078                 /*  including perform A-MPDU Rx Ordering Buffer Control */
2079                 if (recv_indicatepkt_reorder(padapter, prframe) != _SUCCESS) {
2080                         if ((padapter->bDriverStopped == false) &&
2081                             (padapter->bSurpriseRemoved == false)) {
2082                                 retval = _FAIL;
2083                                 return retval;
2084                         }
2085                 }
2086         } else { /* B/G mode */
2087                 retval = wlanhdr_to_ethhdr(prframe);
2088                 if (retval != _SUCCESS) {
2089                         RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
2090                                  "wlanhdr_to_ethhdr: drop pkt\n");
2091                         return retval;
2092                 }
2093
2094                 if ((padapter->bDriverStopped == false) &&
2095                     (padapter->bSurpriseRemoved == false)) {
2096                         /* indicate this recv_frame */
2097                         RT_TRACE(_module_rtl871x_recv_c_, _drv_notice_,
2098                                  "@@@@ process_recv_indicatepkts- recv_func recv_indicatepkt\n");
2099                         rtw_recv_indicatepkt23a(padapter, prframe);
2100                 } else {
2101                         RT_TRACE(_module_rtl871x_recv_c_, _drv_notice_,
2102                                  "@@@@ process_recv_indicatepkts- recv_func free_indicatepkt\n");
2103
2104                         RT_TRACE(_module_rtl871x_recv_c_, _drv_notice_,
2105                                  "recv_func:bDriverStopped(%d) OR bSurpriseRemoved(%d)\n",
2106                                  padapter->bDriverStopped,
2107                                  padapter->bSurpriseRemoved);
2108                         retval = _FAIL;
2109                         return retval;
2110                 }
2111
2112         }
2113
2114         return retval;
2115 }
2116
2117 static int recv_func_prehandle(struct rtw_adapter *padapter,
2118                                struct recv_frame *rframe)
2119 {
2120         int ret;
2121
2122         /* check the frame crtl field and decache */
2123         ret = validate_recv_frame(padapter, rframe);
2124         if (ret != _SUCCESS) {
2125                 RT_TRACE(_module_rtl871x_recv_c_, _drv_info_,
2126                          "recv_func: validate_recv_frame fail! drop pkt\n");
2127                 rtw_free_recvframe23a(rframe);
2128                 goto exit;
2129         }
2130
2131 exit:
2132         return ret;
2133 }
2134
2135 static int recv_func_posthandle(struct rtw_adapter *padapter,
2136                                 struct recv_frame *prframe)
2137 {
2138         int ret = _SUCCESS;
2139         struct recv_frame *orig_prframe = prframe;
2140         struct recv_priv *precvpriv = &padapter->recvpriv;
2141
2142         /*  DATA FRAME */
2143         prframe = decryptor(padapter, prframe);
2144         if (prframe == NULL) {
2145                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
2146                          "decryptor: drop pkt\n");
2147                 ret = _FAIL;
2148                 goto _recv_data_drop;
2149         }
2150
2151         prframe = recvframe_chk_defrag23a(padapter, prframe);
2152         if (!prframe) {
2153                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
2154                          "recvframe_chk_defrag23a: drop pkt\n");
2155                 goto _recv_data_drop;
2156         }
2157
2158         /*
2159          * Pull off crypto headers
2160          */
2161         if (prframe->attrib.iv_len > 0) {
2162                 skb_pull(prframe->pkt, prframe->attrib.iv_len);
2163         }
2164
2165         if (prframe->attrib.icv_len > 0) {
2166                 skb_trim(prframe->pkt,
2167                          prframe->pkt->len - prframe->attrib.icv_len);
2168         }
2169
2170         prframe = portctrl(padapter, prframe);
2171         if (!prframe) {
2172                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
2173                          "portctrl: drop pkt\n");
2174                 ret = _FAIL;
2175                 goto _recv_data_drop;
2176         }
2177
2178         count_rx_stats(padapter, prframe, NULL);
2179
2180         ret = process_recv_indicatepkts(padapter, prframe);
2181         if (ret != _SUCCESS) {
2182                 RT_TRACE(_module_rtl871x_recv_c_, _drv_err_,
2183                          "recv_func: process_recv_indicatepkts fail!\n");
2184                 rtw_free_recvframe23a(orig_prframe);/* free this recv_frame */
2185                 goto _recv_data_drop;
2186         }
2187         return ret;
2188
2189 _recv_data_drop:
2190         precvpriv->rx_drop++;
2191         return ret;
2192 }
2193
2194 int rtw_recv_entry23a(struct recv_frame *rframe)
2195 {
2196         int ret, r;
2197         struct rtw_adapter *padapter = rframe->adapter;
2198         struct rx_pkt_attrib *prxattrib = &rframe->attrib;
2199         struct recv_priv *recvpriv = &padapter->recvpriv;
2200         struct security_priv *psecuritypriv = &padapter->securitypriv;
2201         struct mlme_priv *mlmepriv = &padapter->mlmepriv;
2202
2203         /* check if need to handle uc_swdec_pending_queue*/
2204         if (check_fwstate(mlmepriv, WIFI_STATION_STATE) &&
2205             psecuritypriv->busetkipkey) {
2206                 struct recv_frame *pending_frame;
2207
2208                 while ((pending_frame = rtw_alloc_recvframe23a(&padapter->recvpriv.uc_swdec_pending_queue))) {
2209                         r = recv_func_posthandle(padapter, pending_frame);
2210                         if (r == _SUCCESS)
2211                                 DBG_8723A("%s: dequeue uc_swdec_pending_queue\n", __func__);
2212                 }
2213         }
2214
2215         ret = recv_func_prehandle(padapter, rframe);
2216
2217         if (ret == _SUCCESS) {
2218                 /* check if need to enqueue into uc_swdec_pending_queue*/
2219                 if (check_fwstate(mlmepriv, WIFI_STATION_STATE) &&
2220                     !is_multicast_ether_addr(prxattrib->ra) &&
2221                     prxattrib->encrypt > 0 &&
2222                     (prxattrib->bdecrypted == 0) &&
2223                     !is_wep_enc(psecuritypriv->dot11PrivacyAlgrthm) &&
2224                     !psecuritypriv->busetkipkey) {
2225                         rtw_enqueue_recvframe23a(rframe, &padapter->recvpriv.uc_swdec_pending_queue);
2226                         DBG_8723A("%s: no key, enqueue uc_swdec_pending_queue\n", __func__);
2227                         goto exit;
2228                 }
2229
2230                 ret = recv_func_posthandle(padapter, rframe);
2231
2232                 recvpriv->rx_pkts++;
2233         }
2234
2235 exit:
2236         return ret;
2237 }
2238
2239 void rtw_signal_stat_timer_hdl23a(unsigned long data)
2240 {
2241         struct rtw_adapter *adapter = (struct rtw_adapter *)data;
2242         struct recv_priv *recvpriv = &adapter->recvpriv;
2243
2244         u32 tmp_s, tmp_q;
2245         u8 avg_signal_strength = 0;
2246         u8 avg_signal_qual = 0;
2247         u32 num_signal_strength = 0;
2248         u32 num_signal_qual = 0;
2249         u8 _alpha = 3;  /* this value is based on converging_constant = 5000 */
2250                         /* and sampling_interval = 1000 */
2251
2252         if (recvpriv->signal_strength_data.update_req == 0) {
2253                 /*  update_req is clear, means we got rx */
2254                 avg_signal_strength = recvpriv->signal_strength_data.avg_val;
2255                 num_signal_strength = recvpriv->signal_strength_data.total_num;
2256                 /*  after avg_vals are acquired, we can re-stat */
2257                 /* the signal values */
2258                 recvpriv->signal_strength_data.update_req = 1;
2259         }
2260
2261         if (recvpriv->signal_qual_data.update_req == 0) {
2262                 /*  update_req is clear, means we got rx */
2263                 avg_signal_qual = recvpriv->signal_qual_data.avg_val;
2264                 num_signal_qual = recvpriv->signal_qual_data.total_num;
2265                 /*  after avg_vals are acquired, we can re-stat */
2266                 /*the signal values */
2267                 recvpriv->signal_qual_data.update_req = 1;
2268         }
2269
2270         /* update value of signal_strength, rssi, signal_qual */
2271         if (!check_fwstate(&adapter->mlmepriv, _FW_UNDER_SURVEY)) {
2272                 tmp_s = avg_signal_strength + (_alpha - 1) *
2273                          recvpriv->signal_strength;
2274                 if (tmp_s %_alpha)
2275                         tmp_s = tmp_s / _alpha + 1;
2276                 else
2277                         tmp_s = tmp_s / _alpha;
2278                 if (tmp_s > 100)
2279                         tmp_s = 100;
2280
2281                 tmp_q = avg_signal_qual + (_alpha - 1) * recvpriv->signal_qual;
2282                 if (tmp_q %_alpha)
2283                         tmp_q = tmp_q / _alpha + 1;
2284                 else
2285                         tmp_q = tmp_q / _alpha;
2286                 if (tmp_q > 100)
2287                         tmp_q = 100;
2288
2289                 recvpriv->signal_strength = tmp_s;
2290                 recvpriv->signal_qual = tmp_q;
2291
2292                 DBG_8723A("%s signal_strength:%3u, signal_qual:%3u, "
2293                           "num_signal_strength:%u, num_signal_qual:%u\n",
2294                           __func__, recvpriv->signal_strength,
2295                           recvpriv->signal_qual, num_signal_strength,
2296                           num_signal_qual);
2297         }
2298
2299         rtw_set_signal_stat_timer(recvpriv);
2300 }