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