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_LIST_HEAD(&(precvframe
->u
.list
));
90 list_add_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 (list_empty(&pfree_recv_queue
->queue
))
118 phead
= &pfree_recv_queue
->queue
;
120 precvframe
= LIST_CONTAINOR(plist
, union recv_frame
, u
);
121 list_del_init(&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
= &pframequeue
->queue
;
150 while (end_of_queue_search(phead
, plist
) == false) {
151 precvframe
= LIST_CONTAINOR(plist
, union recv_frame
, u
);
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
);
520 precv_frame
->u
.hdr
.psta
= psta
;
522 /* parsing QC field */
523 if (pattrib
->qos
== 1) {
524 pattrib
->priority
= GetPriority((ptr
+ 24));
525 pattrib
->ack_policy
= GetAckpolicy((ptr
+ 24));
526 pattrib
->amsdu
= GetAMsdu((ptr
+ 24));
527 pattrib
->hdrlen
= pattrib
->to_fr_ds
== 3 ? 32 : 26;
529 pattrib
->priority
= 0;
530 pattrib
->hdrlen
= (pattrib
->to_fr_ds
== 3) ? 30 : 24;
533 if (pattrib
->order
)/*HT-CTRL 11n*/
534 pattrib
->hdrlen
+= 4;
535 precv_frame
->u
.hdr
.preorder_ctrl
=
536 &psta
->recvreorder_ctrl
[pattrib
->priority
];
538 /* decache, drop duplicate recv packets */
539 if (recv_decache(precv_frame
, bretry
, &psta
->sta_recvpriv
.rxcache
) ==
543 if (pattrib
->privacy
) {
544 GET_ENCRY_ALGO(psecuritypriv
, psta
, pattrib
->encrypt
,
545 IS_MCAST(pattrib
->ra
));
546 SET_ICE_IV_LEN(pattrib
->iv_len
, pattrib
->icv_len
,
549 pattrib
->encrypt
= 0;
550 pattrib
->iv_len
= pattrib
->icv_len
= 0;
555 sint
r8712_validate_recv_frame(struct _adapter
*adapter
,
556 union recv_frame
*precv_frame
)
558 /*shall check frame subtype, to / from ds, da, bssid */
559 /*then call check if rx seq/frag. duplicated.*/
563 sint retval
= _SUCCESS
;
564 struct rx_pkt_attrib
*pattrib
= &precv_frame
->u
.hdr
.attrib
;
566 u8
*ptr
= precv_frame
->u
.hdr
.rx_data
;
567 u8 ver
= (unsigned char)(*ptr
) & 0x3;
572 type
= GetFrameType(ptr
);
573 subtype
= GetFrameSubType(ptr
); /*bit(7)~bit(2)*/
574 pattrib
->to_fr_ds
= get_tofr_ds(ptr
);
575 pattrib
->frag_num
= GetFragNum(ptr
);
576 pattrib
->seq_num
= GetSequence(ptr
);
577 pattrib
->pw_save
= GetPwrMgt(ptr
);
578 pattrib
->mfrag
= GetMFrag(ptr
);
579 pattrib
->mdata
= GetMData(ptr
);
580 pattrib
->privacy
= GetPrivacy(ptr
);
581 pattrib
->order
= GetOrder(ptr
);
583 case WIFI_MGT_TYPE
: /*mgnt*/
584 retval
= validate_recv_mgnt_frame(adapter
, precv_frame
);
586 case WIFI_CTRL_TYPE
:/*ctrl*/
587 retval
= validate_recv_ctrl_frame(adapter
, precv_frame
);
589 case WIFI_DATA_TYPE
: /*data*/
590 pattrib
->qos
= (subtype
& BIT(7)) ? 1 : 0;
591 retval
= validate_recv_data_frame(adapter
, precv_frame
);
599 sint
r8712_wlanhdr_to_ethhdr(union recv_frame
*precvframe
)
601 /*remove the wlanhdr and add the eth_hdr*/
606 struct ieee80211_snap_hdr
*psnap
;
607 struct _adapter
*adapter
= precvframe
->u
.hdr
.adapter
;
608 struct mlme_priv
*pmlmepriv
= &adapter
->mlmepriv
;
610 u8
*ptr
= get_recvframe_data(precvframe
); /*point to frame_ctrl field*/
611 struct rx_pkt_attrib
*pattrib
= &precvframe
->u
.hdr
.attrib
;
613 if (pattrib
->encrypt
)
614 recvframe_pull_tail(precvframe
, pattrib
->icv_len
);
615 psnap
= (struct ieee80211_snap_hdr
*)(ptr
+ pattrib
->hdrlen
+
617 psnap_type
= ptr
+ pattrib
->hdrlen
+ pattrib
->iv_len
+ SNAP_SIZE
;
618 /* convert hdr + possible LLC headers into Ethernet header */
619 if ((!memcmp(psnap
, (void *)rfc1042_header
, SNAP_SIZE
) &&
620 (memcmp(psnap_type
, (void *)SNAP_ETH_TYPE_IPX
, 2)) &&
621 (memcmp(psnap_type
, (void *)SNAP_ETH_TYPE_APPLETALK_AARP
, 2))) ||
622 !memcmp(psnap
, (void *)bridge_tunnel_header
, SNAP_SIZE
)) {
623 /* remove RFC1042 or Bridge-Tunnel encapsulation and
624 * replace EtherType */
627 /* Leave Ethernet header part of hdr and full payload */
630 rmv_len
= pattrib
->hdrlen
+ pattrib
->iv_len
+
631 (bsnaphdr
? SNAP_SIZE
: 0);
632 len
= precvframe
->u
.hdr
.len
- rmv_len
;
633 if (check_fwstate(pmlmepriv
, WIFI_MP_STATE
) == true) {
637 /* append rx status for mp test packets */
638 ptr
= recvframe_pull(precvframe
, (rmv_len
-
639 sizeof(struct ethhdr
) + 2) - 24);
640 memcpy(ptr
, get_rxmem(precvframe
), 24);
643 ptr
= recvframe_pull(precvframe
, (rmv_len
-
644 sizeof(struct ethhdr
) + (bsnaphdr
? 2 : 0)));
646 memcpy(ptr
, pattrib
->dst
, ETH_ALEN
);
647 memcpy(ptr
+ETH_ALEN
, pattrib
->src
, ETH_ALEN
);
650 memcpy(ptr
+ 12, &len
, 2);
655 s32
r8712_recv_entry(union recv_frame
*precvframe
)
657 struct _adapter
*padapter
;
658 struct recv_priv
*precvpriv
;
662 padapter
= precvframe
->u
.hdr
.adapter
;
663 precvpriv
= &(padapter
->recvpriv
);
665 padapter
->ledpriv
.LedControlHandler(padapter
, LED_CTL_RX
);
667 ret
= recv_func(padapter
, precvframe
);
669 goto _recv_entry_drop
;
670 precvpriv
->rx_pkts
++;
671 precvpriv
->rx_bytes
+= (uint
)(precvframe
->u
.hdr
.rx_tail
-
672 precvframe
->u
.hdr
.rx_data
);
675 precvpriv
->rx_drop
++;
676 padapter
->mppriv
.rx_pktloss
= precvpriv
->rx_drop
;