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