1 /******************************************************************************
4 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
5 * Linux device driver for RTL8192SU
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
20 * Modifications for inclusion into the Linux staging tree are
21 * Copyright(c) 2010 Larry Finger. All rights reserved.
23 * Contact information:
24 * WLAN FAE <wlanfae@realtek.com>
25 * Larry Finger <Larry.Finger@lwfinger.net>
27 ******************************************************************************/
29 #define _RTL871X_RECV_C_
32 #include <linux/slab.h>
33 #include <linux/if_ether.h>
34 #include <linux/kmemleak.h>
35 #include <linux/etherdevice.h>
37 #include "osdep_service.h"
38 #include "drv_types.h"
39 #include "recv_osdep.h"
40 #include "mlme_osdep.h"
45 static const u8 SNAP_ETH_TYPE_IPX
[2] = {0x81, 0x37};
47 /* Datagram Delivery Protocol */
48 static const u8 SNAP_ETH_TYPE_APPLETALK_AARP
[2] = {0x80, 0xf3};
50 /* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */
51 static const u8 bridge_tunnel_header
[] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8};
53 /* Ethernet-II snap header (RFC1042 for most EtherTypes) */
54 static const u8 rfc1042_header
[] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00};
56 void _r8712_init_sta_recv_priv(struct sta_recv_priv
*psta_recvpriv
)
58 memset((u8
*)psta_recvpriv
, 0, sizeof(struct sta_recv_priv
));
59 spin_lock_init(&psta_recvpriv
->lock
);
60 _init_queue(&psta_recvpriv
->defrag_q
);
63 sint
_r8712_init_recv_priv(struct recv_priv
*precvpriv
,
64 struct _adapter
*padapter
)
67 union recv_frame
*precvframe
;
69 memset((unsigned char *)precvpriv
, 0, sizeof(struct recv_priv
));
70 spin_lock_init(&precvpriv
->lock
);
71 _init_queue(&precvpriv
->free_recv_queue
);
72 _init_queue(&precvpriv
->recv_pending_queue
);
73 precvpriv
->adapter
= padapter
;
74 precvpriv
->free_recvframe_cnt
= NR_RECVFRAME
;
75 precvpriv
->pallocated_frame_buf
= kmalloc(NR_RECVFRAME
*
76 sizeof(union recv_frame
) + RXFRAME_ALIGN_SZ
,
78 if (precvpriv
->pallocated_frame_buf
== NULL
)
80 kmemleak_not_leak(precvpriv
->pallocated_frame_buf
);
81 memset(precvpriv
->pallocated_frame_buf
, 0, NR_RECVFRAME
*
82 sizeof(union recv_frame
) + RXFRAME_ALIGN_SZ
);
83 precvpriv
->precv_frame_buf
= precvpriv
->pallocated_frame_buf
+
85 ((addr_t
)(precvpriv
->pallocated_frame_buf
) &
86 (RXFRAME_ALIGN_SZ
-1));
87 precvframe
= (union recv_frame
*)precvpriv
->precv_frame_buf
;
88 for (i
= 0; i
< NR_RECVFRAME
; i
++) {
89 _init_listhead(&(precvframe
->u
.list
));
90 list_insert_tail(&(precvframe
->u
.list
),
91 &(precvpriv
->free_recv_queue
.queue
));
92 r8712_os_recv_resource_alloc(padapter
, precvframe
);
93 precvframe
->u
.hdr
.adapter
= padapter
;
96 precvpriv
->rx_pending_cnt
= 1;
97 return r8712_init_recv_priv(precvpriv
, padapter
);
100 void _r8712_free_recv_priv(struct recv_priv
*precvpriv
)
102 kfree(precvpriv
->pallocated_frame_buf
);
103 r8712_free_recv_priv(precvpriv
);
106 union recv_frame
*r8712_alloc_recvframe(struct __queue
*pfree_recv_queue
)
109 union recv_frame
*precvframe
;
110 struct list_head
*plist
, *phead
;
111 struct _adapter
*padapter
;
112 struct recv_priv
*precvpriv
;
114 spin_lock_irqsave(&pfree_recv_queue
->lock
, irqL
);
115 if (_queue_empty(pfree_recv_queue
) == true)
118 phead
= get_list_head(pfree_recv_queue
);
119 plist
= get_next(phead
);
120 precvframe
= LIST_CONTAINOR(plist
, union recv_frame
, u
);
121 list_delete(&precvframe
->u
.hdr
.list
);
122 padapter
= precvframe
->u
.hdr
.adapter
;
123 if (padapter
!= NULL
) {
124 precvpriv
= &padapter
->recvpriv
;
125 if (pfree_recv_queue
== &precvpriv
->free_recv_queue
)
126 precvpriv
->free_recvframe_cnt
--;
129 spin_unlock_irqrestore(&pfree_recv_queue
->lock
, irqL
);
134 caller : defrag; recvframe_chk_defrag in recv_thread (passive)
135 pframequeue: defrag_queue : will be accessed in recv_thread (passive)
137 using spin_lock to protect
141 void r8712_free_recvframe_queue(struct __queue
*pframequeue
,
142 struct __queue
*pfree_recv_queue
)
144 union recv_frame
*precvframe
;
145 struct list_head
*plist
, *phead
;
147 spin_lock(&pframequeue
->lock
);
148 phead
= get_list_head(pframequeue
);
149 plist
= get_next(phead
);
150 while (end_of_queue_search(phead
, plist
) == false) {
151 precvframe
= LIST_CONTAINOR(plist
, union recv_frame
, u
);
152 plist
= get_next(plist
);
153 r8712_free_recvframe(precvframe
, pfree_recv_queue
);
155 spin_unlock(&pframequeue
->lock
);
158 sint
r8712_recvframe_chkmic(struct _adapter
*adapter
,
159 union recv_frame
*precvframe
)
161 sint i
, res
= _SUCCESS
;
165 u8
*pframe
, *payload
, *pframemic
;
166 u8
*mickey
, idx
, *iv
;
167 struct sta_info
*stainfo
;
168 struct rx_pkt_attrib
*prxattrib
= &precvframe
->u
.hdr
.attrib
;
169 struct security_priv
*psecuritypriv
= &adapter
->securitypriv
;
171 stainfo
= r8712_get_stainfo(&adapter
->stapriv
, &prxattrib
->ta
[0]);
172 if (prxattrib
->encrypt
== _TKIP_
) {
173 /* calculate mic code */
174 if (stainfo
!= NULL
) {
175 if (IS_MCAST(prxattrib
->ra
)) {
176 iv
= precvframe
->u
.hdr
.rx_data
+
179 mickey
= &psecuritypriv
->XGrprxmickey
[(((idx
>>
180 6) & 0x3)) - 1].skey
[0];
181 if (psecuritypriv
->binstallGrpkey
== false)
184 mickey
= &stainfo
->tkiprxmickey
.skey
[0];
185 /*icv_len included the mic code*/
186 datalen
= precvframe
->u
.hdr
.len
- prxattrib
->hdrlen
-
187 prxattrib
->iv_len
- prxattrib
->icv_len
- 8;
188 pframe
= precvframe
->u
.hdr
.rx_data
;
189 payload
= pframe
+ prxattrib
->hdrlen
+
191 seccalctkipmic(mickey
, pframe
, payload
, datalen
,
193 (unsigned char)prxattrib
->priority
);
194 pframemic
= payload
+ datalen
;
196 for (i
= 0; i
< 8; i
++) {
197 if (miccode
[i
] != *(pframemic
+ i
))
200 if (bmic_err
== true) {
201 if (prxattrib
->bdecrypted
== true)
202 r8712_handle_tkip_mic_err(adapter
,
203 (u8
)IS_MCAST(prxattrib
->ra
));
207 if ((psecuritypriv
->bcheck_grpkey
==
208 false) && (IS_MCAST(prxattrib
->ra
) ==
210 psecuritypriv
->bcheck_grpkey
= true;
212 recvframe_pull_tail(precvframe
, 8);
218 /* decrypt and set the ivlen,icvlen of the recv_frame */
219 union recv_frame
*r8712_decryptor(struct _adapter
*padapter
,
220 union recv_frame
*precv_frame
)
222 struct rx_pkt_attrib
*prxattrib
= &precv_frame
->u
.hdr
.attrib
;
223 struct security_priv
*psecuritypriv
= &padapter
->securitypriv
;
224 union recv_frame
*return_packet
= precv_frame
;
226 if ((prxattrib
->encrypt
> 0) && ((prxattrib
->bdecrypted
== 0) ||
227 (psecuritypriv
->sw_decrypt
== true))) {
228 psecuritypriv
->hw_decrypted
= false;
229 switch (prxattrib
->encrypt
) {
232 r8712_wep_decrypt(padapter
, (u8
*)precv_frame
);
235 r8712_tkip_decrypt(padapter
, (u8
*)precv_frame
);
238 r8712_aes_decrypt(padapter
, (u8
*)precv_frame
);
243 } else if (prxattrib
->bdecrypted
== 1)
244 psecuritypriv
->hw_decrypted
= true;
245 return return_packet
;
247 /*###set the security information in the recv_frame */
248 union recv_frame
*r8712_portctrl(struct _adapter
*adapter
,
249 union recv_frame
*precv_frame
)
253 struct recv_frame_hdr
*pfhdr
;
254 struct sta_info
*psta
;
255 struct sta_priv
*pstapriv
;
256 union recv_frame
*prtnframe
;
259 pstapriv
= &adapter
->stapriv
;
260 ptr
= get_recvframe_data(precv_frame
);
261 pfhdr
= &precv_frame
->u
.hdr
;
262 psta_addr
= pfhdr
->attrib
.ta
;
263 psta
= r8712_get_stainfo(pstapriv
, psta_addr
);
264 auth_alg
= adapter
->securitypriv
.AuthAlgrthm
;
267 ptr
= ptr
+ pfhdr
->attrib
.hdrlen
+ LLC_HEADER_SIZE
;
268 memcpy(ðer_type
, ptr
, 2);
269 ether_type
= ntohs((unsigned short)ether_type
);
271 if ((psta
!= NULL
) && (psta
->ieee8021x_blocked
)) {
273 * only accept EAPOL frame */
274 if (ether_type
== 0x888e)
275 prtnframe
= precv_frame
;
278 r8712_free_recvframe(precv_frame
,
279 &adapter
->recvpriv
.free_recv_queue
);
284 * check decryption status, and decrypt the
286 prtnframe
= precv_frame
;
287 /* check is the EAPOL frame or not (Rekey) */
288 if (ether_type
== 0x888e) {
290 prtnframe
= precv_frame
;
294 prtnframe
= precv_frame
;
298 static sint
recv_decache(union recv_frame
*precv_frame
, u8 bretry
,
299 struct stainfo_rxcache
*prxcache
)
301 sint tid
= precv_frame
->u
.hdr
.attrib
.priority
;
302 u16 seq_ctrl
= ((precv_frame
->u
.hdr
.attrib
.seq_num
&0xffff) << 4) |
303 (precv_frame
->u
.hdr
.attrib
.frag_num
& 0xf);
307 if (seq_ctrl
== prxcache
->tid_rxseq
[tid
])
309 prxcache
->tid_rxseq
[tid
] = seq_ctrl
;
313 static sint
sta2sta_data_frame(struct _adapter
*adapter
,
314 union recv_frame
*precv_frame
,
315 struct sta_info
**psta
)
317 u8
*ptr
= precv_frame
->u
.hdr
.rx_data
;
319 struct rx_pkt_attrib
*pattrib
= &precv_frame
->u
.hdr
.attrib
;
320 struct sta_priv
*pstapriv
= &adapter
->stapriv
;
321 struct mlme_priv
*pmlmepriv
= &adapter
->mlmepriv
;
322 u8
*mybssid
= get_bssid(pmlmepriv
);
323 u8
*myhwaddr
= myid(&adapter
->eeprompriv
);
325 sint bmcast
= IS_MCAST(pattrib
->dst
);
327 if ((check_fwstate(pmlmepriv
, WIFI_ADHOC_STATE
) == true) ||
328 (check_fwstate(pmlmepriv
, WIFI_ADHOC_MASTER_STATE
) == true)) {
329 /* filter packets that SA is myself or multicast or broadcast */
330 if (!memcmp(myhwaddr
, pattrib
->src
, ETH_ALEN
))
332 if ((memcmp(myhwaddr
, pattrib
->dst
, ETH_ALEN
)) && (!bmcast
))
334 if (is_zero_ether_addr(pattrib
->bssid
) ||
335 is_zero_ether_addr(mybssid
) ||
336 (memcmp(pattrib
->bssid
, mybssid
, ETH_ALEN
)))
338 sta_addr
= pattrib
->src
;
339 } else if (check_fwstate(pmlmepriv
, WIFI_STATION_STATE
) == true) {
340 /* For Station mode, sa and bssid should always be BSSID,
341 * and DA is my mac-address */
342 if (memcmp(pattrib
->bssid
, pattrib
->src
, ETH_ALEN
))
344 sta_addr
= pattrib
->bssid
;
345 } else if (check_fwstate(pmlmepriv
, WIFI_AP_STATE
) == true) {
347 /* For AP mode, if DA == MCAST, then BSSID should
349 if (!IS_MCAST(pattrib
->bssid
))
351 } else { /* not mc-frame */
352 /* For AP mode, if DA is non-MCAST, then it must be
353 * BSSID, and bssid == BSSID */
354 if (memcmp(pattrib
->bssid
, pattrib
->dst
, ETH_ALEN
))
356 sta_addr
= pattrib
->src
;
358 } else if (check_fwstate(pmlmepriv
, WIFI_MP_STATE
) == true) {
359 memcpy(pattrib
->dst
, GetAddr1Ptr(ptr
), ETH_ALEN
);
360 memcpy(pattrib
->src
, GetAddr2Ptr(ptr
), ETH_ALEN
);
361 memcpy(pattrib
->bssid
, GetAddr3Ptr(ptr
), ETH_ALEN
);
362 memcpy(pattrib
->ra
, pattrib
->dst
, ETH_ALEN
);
363 memcpy(pattrib
->ta
, pattrib
->src
, ETH_ALEN
);
368 *psta
= r8712_get_bcmc_stainfo(adapter
);
370 *psta
= r8712_get_stainfo(pstapriv
, sta_addr
); /* get ap_info */
372 if (check_fwstate(pmlmepriv
, WIFI_MP_STATE
) == true)
373 adapter
->mppriv
.rx_pktloss
++;
379 static sint
ap2sta_data_frame(struct _adapter
*adapter
,
380 union recv_frame
*precv_frame
,
381 struct sta_info
**psta
)
383 u8
*ptr
= precv_frame
->u
.hdr
.rx_data
;
384 struct rx_pkt_attrib
*pattrib
= &precv_frame
->u
.hdr
.attrib
;
385 struct sta_priv
*pstapriv
= &adapter
->stapriv
;
386 struct mlme_priv
*pmlmepriv
= &adapter
->mlmepriv
;
387 u8
*mybssid
= get_bssid(pmlmepriv
);
388 u8
*myhwaddr
= myid(&adapter
->eeprompriv
);
389 sint bmcast
= IS_MCAST(pattrib
->dst
);
391 if ((check_fwstate(pmlmepriv
, WIFI_STATION_STATE
) == true)
392 && (check_fwstate(pmlmepriv
, _FW_LINKED
) == true)) {
393 /* if NULL-frame, drop packet */
394 if ((GetFrameSubType(ptr
)) == WIFI_DATA_NULL
)
396 /* drop QoS-SubType Data, including QoS NULL,
397 * excluding QoS-Data */
398 if ((GetFrameSubType(ptr
) & WIFI_QOS_DATA_TYPE
) ==
399 WIFI_QOS_DATA_TYPE
) {
400 if (GetFrameSubType(ptr
) & (BIT(4) | BIT(5) | BIT(6)))
404 /* filter packets that SA is myself or multicast or broadcast */
405 if (!memcmp(myhwaddr
, pattrib
->src
, ETH_ALEN
))
408 /* da should be for me */
409 if ((memcmp(myhwaddr
, pattrib
->dst
, ETH_ALEN
)) && (!bmcast
))
412 if (is_zero_ether_addr(pattrib
->bssid
) ||
413 is_zero_ether_addr(mybssid
) ||
414 (memcmp(pattrib
->bssid
, mybssid
, ETH_ALEN
)))
417 *psta
= r8712_get_bcmc_stainfo(adapter
);
419 *psta
= r8712_get_stainfo(pstapriv
, pattrib
->bssid
);
422 } else if ((check_fwstate(pmlmepriv
, WIFI_MP_STATE
) == true) &&
423 (check_fwstate(pmlmepriv
, _FW_LINKED
) == true)) {
424 memcpy(pattrib
->dst
, GetAddr1Ptr(ptr
), ETH_ALEN
);
425 memcpy(pattrib
->src
, GetAddr2Ptr(ptr
), ETH_ALEN
);
426 memcpy(pattrib
->bssid
, GetAddr3Ptr(ptr
), ETH_ALEN
);
427 memcpy(pattrib
->ra
, pattrib
->dst
, ETH_ALEN
);
428 memcpy(pattrib
->ta
, pattrib
->src
, ETH_ALEN
);
429 memcpy(pattrib
->bssid
, mybssid
, ETH_ALEN
);
430 *psta
= r8712_get_stainfo(pstapriv
, pattrib
->bssid
);
438 static sint
sta2ap_data_frame(struct _adapter
*adapter
,
439 union recv_frame
*precv_frame
,
440 struct sta_info
**psta
)
442 struct rx_pkt_attrib
*pattrib
= &precv_frame
->u
.hdr
.attrib
;
443 struct sta_priv
*pstapriv
= &adapter
->stapriv
;
444 struct mlme_priv
*pmlmepriv
= &adapter
->mlmepriv
;
445 unsigned char *mybssid
= get_bssid(pmlmepriv
);
447 if (check_fwstate(pmlmepriv
, WIFI_AP_STATE
) == true) {
448 /* For AP mode, if DA is non-MCAST, then it must be BSSID,
450 * For AP mode, RA=BSSID, TX=STA(SRC_ADDR), A3=DST_ADDR */
451 if (memcmp(pattrib
->bssid
, mybssid
, ETH_ALEN
))
453 *psta
= r8712_get_stainfo(pstapriv
, pattrib
->src
);
460 static sint
validate_recv_ctrl_frame(struct _adapter
*adapter
,
461 union recv_frame
*precv_frame
)
466 static sint
validate_recv_mgnt_frame(struct _adapter
*adapter
,
467 union recv_frame
*precv_frame
)
473 static sint
validate_recv_data_frame(struct _adapter
*adapter
,
474 union recv_frame
*precv_frame
)
478 u8
*psa
, *pda
, *pbssid
;
479 struct sta_info
*psta
= NULL
;
480 u8
*ptr
= precv_frame
->u
.hdr
.rx_data
;
481 struct rx_pkt_attrib
*pattrib
= &precv_frame
->u
.hdr
.attrib
;
482 struct security_priv
*psecuritypriv
= &adapter
->securitypriv
;
484 bretry
= GetRetry(ptr
);
487 pbssid
= get_hdr_bssid(ptr
);
490 memcpy(pattrib
->dst
, pda
, ETH_ALEN
);
491 memcpy(pattrib
->src
, psa
, ETH_ALEN
);
492 memcpy(pattrib
->bssid
, pbssid
, ETH_ALEN
);
493 switch (pattrib
->to_fr_ds
) {
495 memcpy(pattrib
->ra
, pda
, ETH_ALEN
);
496 memcpy(pattrib
->ta
, psa
, ETH_ALEN
);
497 res
= sta2sta_data_frame(adapter
, precv_frame
, &psta
);
500 memcpy(pattrib
->ra
, pda
, ETH_ALEN
);
501 memcpy(pattrib
->ta
, pbssid
, ETH_ALEN
);
502 res
= ap2sta_data_frame(adapter
, precv_frame
, &psta
);
505 memcpy(pattrib
->ra
, pbssid
, ETH_ALEN
);
506 memcpy(pattrib
->ta
, psa
, ETH_ALEN
);
507 res
= sta2ap_data_frame(adapter
, precv_frame
, &psta
);
510 memcpy(pattrib
->ra
, GetAddr1Ptr(ptr
), ETH_ALEN
);
511 memcpy(pattrib
->ta
, GetAddr2Ptr(ptr
), ETH_ALEN
);
521 precv_frame
->u
.hdr
.psta
= psta
;
523 /* parsing QC field */
524 if (pattrib
->qos
== 1) {
525 pattrib
->priority
= GetPriority((ptr
+ 24));
526 pattrib
->ack_policy
= GetAckpolicy((ptr
+ 24));
527 pattrib
->amsdu
= GetAMsdu((ptr
+ 24));
528 pattrib
->hdrlen
= pattrib
->to_fr_ds
== 3 ? 32 : 26;
530 pattrib
->priority
= 0;
531 pattrib
->hdrlen
= (pattrib
->to_fr_ds
== 3) ? 30 : 24;
534 if (pattrib
->order
)/*HT-CTRL 11n*/
535 pattrib
->hdrlen
+= 4;
536 precv_frame
->u
.hdr
.preorder_ctrl
=
537 &psta
->recvreorder_ctrl
[pattrib
->priority
];
539 /* decache, drop duplicate recv packets */
540 if (recv_decache(precv_frame
, bretry
, &psta
->sta_recvpriv
.rxcache
) ==
544 if (pattrib
->privacy
) {
545 GET_ENCRY_ALGO(psecuritypriv
, psta
, pattrib
->encrypt
,
546 IS_MCAST(pattrib
->ra
));
547 SET_ICE_IV_LEN(pattrib
->iv_len
, pattrib
->icv_len
,
550 pattrib
->encrypt
= 0;
551 pattrib
->iv_len
= pattrib
->icv_len
= 0;
556 sint
r8712_validate_recv_frame(struct _adapter
*adapter
,
557 union recv_frame
*precv_frame
)
559 /*shall check frame subtype, to / from ds, da, bssid */
560 /*then call check if rx seq/frag. duplicated.*/
564 sint retval
= _SUCCESS
;
565 struct rx_pkt_attrib
*pattrib
= &precv_frame
->u
.hdr
.attrib
;
567 u8
*ptr
= precv_frame
->u
.hdr
.rx_data
;
568 u8 ver
= (unsigned char)(*ptr
) & 0x3;
573 type
= GetFrameType(ptr
);
574 subtype
= GetFrameSubType(ptr
); /*bit(7)~bit(2)*/
575 pattrib
->to_fr_ds
= get_tofr_ds(ptr
);
576 pattrib
->frag_num
= GetFragNum(ptr
);
577 pattrib
->seq_num
= GetSequence(ptr
);
578 pattrib
->pw_save
= GetPwrMgt(ptr
);
579 pattrib
->mfrag
= GetMFrag(ptr
);
580 pattrib
->mdata
= GetMData(ptr
);
581 pattrib
->privacy
= GetPrivacy(ptr
);
582 pattrib
->order
= GetOrder(ptr
);
584 case WIFI_MGT_TYPE
: /*mgnt*/
585 retval
= validate_recv_mgnt_frame(adapter
, precv_frame
);
587 case WIFI_CTRL_TYPE
:/*ctrl*/
588 retval
= validate_recv_ctrl_frame(adapter
, precv_frame
);
590 case WIFI_DATA_TYPE
: /*data*/
591 pattrib
->qos
= (subtype
& BIT(7)) ? 1 : 0;
592 retval
= validate_recv_data_frame(adapter
, precv_frame
);
600 sint
r8712_wlanhdr_to_ethhdr(union recv_frame
*precvframe
)
602 /*remove the wlanhdr and add the eth_hdr*/
607 struct ieee80211_snap_hdr
*psnap
;
608 struct _adapter
*adapter
= precvframe
->u
.hdr
.adapter
;
609 struct mlme_priv
*pmlmepriv
= &adapter
->mlmepriv
;
611 u8
*ptr
= get_recvframe_data(precvframe
); /*point to frame_ctrl field*/
612 struct rx_pkt_attrib
*pattrib
= &precvframe
->u
.hdr
.attrib
;
614 if (pattrib
->encrypt
)
615 recvframe_pull_tail(precvframe
, pattrib
->icv_len
);
616 psnap
= (struct ieee80211_snap_hdr
*)(ptr
+ pattrib
->hdrlen
+
618 psnap_type
= ptr
+ pattrib
->hdrlen
+ pattrib
->iv_len
+ SNAP_SIZE
;
619 /* convert hdr + possible LLC headers into Ethernet header */
620 if ((!memcmp(psnap
, (void *)rfc1042_header
, SNAP_SIZE
) &&
621 (memcmp(psnap_type
, (void *)SNAP_ETH_TYPE_IPX
, 2)) &&
622 (memcmp(psnap_type
, (void *)SNAP_ETH_TYPE_APPLETALK_AARP
, 2))) ||
623 !memcmp(psnap
, (void *)bridge_tunnel_header
, SNAP_SIZE
)) {
624 /* remove RFC1042 or Bridge-Tunnel encapsulation and
625 * replace EtherType */
628 /* Leave Ethernet header part of hdr and full payload */
631 rmv_len
= pattrib
->hdrlen
+ pattrib
->iv_len
+
632 (bsnaphdr
? SNAP_SIZE
: 0);
633 len
= precvframe
->u
.hdr
.len
- rmv_len
;
634 if ((check_fwstate(pmlmepriv
, WIFI_MP_STATE
) == true)) {
639 /* append rx status for mp test packets */
640 ptr
= recvframe_pull(precvframe
, (rmv_len
-
641 sizeof(struct ethhdr
) + 2) - 24);
642 memcpy(ptr
, get_rxmem(precvframe
), 24);
645 ptr
= recvframe_pull(precvframe
, (rmv_len
-
646 sizeof(struct ethhdr
) + (bsnaphdr
? 2 : 0)));
648 memcpy(ptr
, pattrib
->dst
, ETH_ALEN
);
649 memcpy(ptr
+ETH_ALEN
, pattrib
->src
, ETH_ALEN
);
652 memcpy(ptr
+ 12, &len
, 2);
657 s32
r8712_recv_entry(union recv_frame
*precvframe
)
659 struct _adapter
*padapter
;
660 struct recv_priv
*precvpriv
;
661 struct mlme_priv
*pmlmepriv
;
662 struct recv_stat
*prxstat
;
663 struct dvobj_priv
*pdev
;
664 u8
*phead
, *pdata
, *ptail
, *pend
;
666 struct __queue
*pfree_recv_queue
, *ppending_recv_queue
;
668 struct intf_hdl
*pintfhdl
;
670 padapter
= precvframe
->u
.hdr
.adapter
;
671 pintfhdl
= &padapter
->pio_queue
->intf
;
672 pmlmepriv
= &padapter
->mlmepriv
;
673 precvpriv
= &(padapter
->recvpriv
);
674 pdev
= &padapter
->dvobjpriv
;
675 pfree_recv_queue
= &(precvpriv
->free_recv_queue
);
676 ppending_recv_queue
= &(precvpriv
->recv_pending_queue
);
677 phead
= precvframe
->u
.hdr
.rx_head
;
678 pdata
= precvframe
->u
.hdr
.rx_data
;
679 ptail
= precvframe
->u
.hdr
.rx_tail
;
680 pend
= precvframe
->u
.hdr
.rx_end
;
681 prxstat
= (struct recv_stat
*)phead
;
683 padapter
->ledpriv
.LedControlHandler(padapter
, LED_CTL_RX
);
685 ret
= recv_func(padapter
, precvframe
);
687 goto _recv_entry_drop
;
688 precvpriv
->rx_pkts
++;
689 precvpriv
->rx_bytes
+= (uint
)(precvframe
->u
.hdr
.rx_tail
-
690 precvframe
->u
.hdr
.rx_data
);
693 precvpriv
->rx_drop
++;
694 padapter
->mppriv
.rx_pktloss
= precvpriv
->rx_drop
;