1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#define _RTL871X_RECV_C_
18
19#include <linux/ip.h>
20#include <linux/slab.h>
21#include <linux/if_ether.h>
22#include <linux/kmemleak.h>
23#include <linux/etherdevice.h>
24#include <net/cfg80211.h>
25
26#include "osdep_service.h"
27#include "drv_types.h"
28#include "recv_osdep.h"
29#include "mlme_osdep.h"
30#include "ethernet.h"
31#include "usb_ops.h"
32#include "wifi.h"
33
34static const u8 SNAP_ETH_TYPE_IPX[2] = {0x81, 0x37};
35
36
37static const u8 SNAP_ETH_TYPE_APPLETALK_AARP[2] = {0x80, 0xf3};
38
39void _r8712_init_sta_recv_priv(struct sta_recv_priv *psta_recvpriv)
40{
41 memset((u8 *)psta_recvpriv, 0, sizeof(struct sta_recv_priv));
42 spin_lock_init(&psta_recvpriv->lock);
43 _init_queue(&psta_recvpriv->defrag_q);
44}
45
46void _r8712_init_recv_priv(struct recv_priv *precvpriv,
47 struct _adapter *padapter)
48{
49 sint i;
50 union recv_frame *precvframe;
51
52 memset((unsigned char *)precvpriv, 0, sizeof(struct recv_priv));
53 spin_lock_init(&precvpriv->lock);
54 _init_queue(&precvpriv->free_recv_queue);
55 _init_queue(&precvpriv->recv_pending_queue);
56 precvpriv->adapter = padapter;
57 precvpriv->free_recvframe_cnt = NR_RECVFRAME;
58 precvpriv->pallocated_frame_buf = kzalloc(NR_RECVFRAME *
59 sizeof(union recv_frame) + RXFRAME_ALIGN_SZ,
60 GFP_ATOMIC);
61 if (!precvpriv->pallocated_frame_buf)
62 return;
63 kmemleak_not_leak(precvpriv->pallocated_frame_buf);
64 precvpriv->precv_frame_buf = precvpriv->pallocated_frame_buf +
65 RXFRAME_ALIGN_SZ -
66 ((addr_t)(precvpriv->pallocated_frame_buf) &
67 (RXFRAME_ALIGN_SZ - 1));
68 precvframe = (union recv_frame *)precvpriv->precv_frame_buf;
69 for (i = 0; i < NR_RECVFRAME; i++) {
70 INIT_LIST_HEAD(&(precvframe->u.list));
71 list_add_tail(&(precvframe->u.list),
72 &(precvpriv->free_recv_queue.queue));
73 r8712_os_recv_resource_alloc(padapter, precvframe);
74 precvframe->u.hdr.adapter = padapter;
75 precvframe++;
76 }
77 precvpriv->rx_pending_cnt = 1;
78 r8712_init_recv_priv(precvpriv, padapter);
79}
80
81void _r8712_free_recv_priv(struct recv_priv *precvpriv)
82{
83 kfree(precvpriv->pallocated_frame_buf);
84 r8712_free_recv_priv(precvpriv);
85}
86
87union recv_frame *r8712_alloc_recvframe(struct __queue *pfree_recv_queue)
88{
89 unsigned long irqL;
90 union recv_frame *precvframe;
91 struct _adapter *padapter;
92 struct recv_priv *precvpriv;
93
94 spin_lock_irqsave(&pfree_recv_queue->lock, irqL);
95 precvframe = list_first_entry_or_null(&pfree_recv_queue->queue,
96 union recv_frame, u.hdr.list);
97 if (precvframe) {
98 list_del_init(&precvframe->u.hdr.list);
99 padapter = precvframe->u.hdr.adapter;
100 if (padapter) {
101 precvpriv = &padapter->recvpriv;
102 if (pfree_recv_queue == &precvpriv->free_recv_queue)
103 precvpriv->free_recvframe_cnt--;
104 }
105 }
106 spin_unlock_irqrestore(&pfree_recv_queue->lock, irqL);
107 return precvframe;
108}
109
110
111
112
113
114
115void r8712_free_recvframe_queue(struct __queue *pframequeue,
116 struct __queue *pfree_recv_queue)
117{
118 union recv_frame *precvframe;
119 struct list_head *plist, *phead;
120
121 spin_lock(&pframequeue->lock);
122 phead = &pframequeue->queue;
123 plist = phead->next;
124 while (!end_of_queue_search(phead, plist)) {
125 precvframe = container_of(plist, union recv_frame, u.list);
126 plist = plist->next;
127 r8712_free_recvframe(precvframe, pfree_recv_queue);
128 }
129 spin_unlock(&pframequeue->lock);
130}
131
132sint r8712_recvframe_chkmic(struct _adapter *adapter,
133 union recv_frame *precvframe)
134{
135 sint i, res = _SUCCESS;
136 u32 datalen;
137 u8 miccode[8];
138 u8 bmic_err = false;
139 u8 *pframe, *payload, *pframemic;
140 u8 *mickey, idx, *iv;
141 struct sta_info *stainfo;
142 struct rx_pkt_attrib *prxattrib = &precvframe->u.hdr.attrib;
143 struct security_priv *psecuritypriv = &adapter->securitypriv;
144
145 stainfo = r8712_get_stainfo(&adapter->stapriv, &prxattrib->ta[0]);
146 if (prxattrib->encrypt == _TKIP_) {
147
148 if (stainfo) {
149 if (is_multicast_ether_addr(prxattrib->ra)) {
150 iv = precvframe->u.hdr.rx_data +
151 prxattrib->hdrlen;
152 idx = iv[3];
153 mickey = &psecuritypriv->XGrprxmickey[(((idx >>
154 6) & 0x3)) - 1].skey[0];
155 if (!psecuritypriv->binstallGrpkey)
156 return _FAIL;
157 } else {
158 mickey = &stainfo->tkiprxmickey.skey[0];
159 }
160
161 datalen = precvframe->u.hdr.len - prxattrib->hdrlen -
162 prxattrib->iv_len - prxattrib->icv_len - 8;
163 pframe = precvframe->u.hdr.rx_data;
164 payload = pframe + prxattrib->hdrlen +
165 prxattrib->iv_len;
166 seccalctkipmic(mickey, pframe, payload, datalen,
167 &miccode[0],
168 (unsigned char)prxattrib->priority);
169 pframemic = payload + datalen;
170 bmic_err = false;
171 for (i = 0; i < 8; i++) {
172 if (miccode[i] != *(pframemic + i))
173 bmic_err = true;
174 }
175 if (bmic_err) {
176 if (prxattrib->bdecrypted)
177 r8712_handle_tkip_mic_err(adapter,
178 (u8)is_multicast_ether_addr(prxattrib->ra));
179 res = _FAIL;
180 } else {
181
182 if (!psecuritypriv->bcheck_grpkey &&
183 is_multicast_ether_addr(prxattrib->ra))
184 psecuritypriv->bcheck_grpkey = true;
185 }
186 recvframe_pull_tail(precvframe, 8);
187 }
188 }
189 return res;
190}
191
192
193union recv_frame *r8712_decryptor(struct _adapter *padapter,
194 union recv_frame *precv_frame)
195{
196 struct rx_pkt_attrib *prxattrib = &precv_frame->u.hdr.attrib;
197 struct security_priv *psecuritypriv = &padapter->securitypriv;
198 union recv_frame *return_packet = precv_frame;
199
200 if ((prxattrib->encrypt > 0) && ((prxattrib->bdecrypted == 0) ||
201 psecuritypriv->sw_decrypt)) {
202 psecuritypriv->hw_decrypted = false;
203 switch (prxattrib->encrypt) {
204 case _WEP40_:
205 case _WEP104_:
206 r8712_wep_decrypt(padapter, (u8 *)precv_frame);
207 break;
208 case _TKIP_:
209 r8712_tkip_decrypt(padapter, (u8 *)precv_frame);
210 break;
211 case _AES_:
212 r8712_aes_decrypt(padapter, (u8 *)precv_frame);
213 break;
214 default:
215 break;
216 }
217 } else if (prxattrib->bdecrypted == 1) {
218 psecuritypriv->hw_decrypted = true;
219 }
220 return return_packet;
221}
222
223union recv_frame *r8712_portctrl(struct _adapter *adapter,
224 union recv_frame *precv_frame)
225{
226 u8 *psta_addr, *ptr;
227 uint auth_alg;
228 struct recv_frame_hdr *pfhdr;
229 struct sta_info *psta;
230 struct sta_priv *pstapriv;
231 union recv_frame *prtnframe;
232 u16 ether_type;
233
234 pstapriv = &adapter->stapriv;
235 ptr = get_recvframe_data(precv_frame);
236 pfhdr = &precv_frame->u.hdr;
237 psta_addr = pfhdr->attrib.ta;
238 psta = r8712_get_stainfo(pstapriv, psta_addr);
239 auth_alg = adapter->securitypriv.AuthAlgrthm;
240 if (auth_alg == 2) {
241
242 ptr = ptr + pfhdr->attrib.hdrlen + LLC_HEADER_SIZE;
243 ether_type = get_unaligned_be16(ptr);
244
245 if (psta && psta->ieee8021x_blocked) {
246
247
248
249 if (ether_type == 0x888e) {
250 prtnframe = precv_frame;
251 } else {
252
253 r8712_free_recvframe(precv_frame,
254 &adapter->recvpriv.free_recv_queue);
255 prtnframe = NULL;
256 }
257 } else {
258
259
260
261
262 prtnframe = precv_frame;
263
264 if (ether_type == 0x888e) {
265
266 prtnframe = precv_frame;
267 }
268 }
269 } else {
270 prtnframe = precv_frame;
271 }
272 return prtnframe;
273}
274
275static sint recv_decache(union recv_frame *precv_frame, u8 bretry,
276 struct stainfo_rxcache *prxcache)
277{
278 sint tid = precv_frame->u.hdr.attrib.priority;
279 u16 seq_ctrl = ((precv_frame->u.hdr.attrib.seq_num & 0xffff) << 4) |
280 (precv_frame->u.hdr.attrib.frag_num & 0xf);
281
282 if (tid > 15)
283 return _FAIL;
284 if (seq_ctrl == prxcache->tid_rxseq[tid])
285 return _FAIL;
286 prxcache->tid_rxseq[tid] = seq_ctrl;
287 return _SUCCESS;
288}
289
290static sint sta2sta_data_frame(struct _adapter *adapter,
291 union recv_frame *precv_frame,
292 struct sta_info **psta)
293{
294 u8 *ptr = precv_frame->u.hdr.rx_data;
295 sint ret = _SUCCESS;
296 struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
297 struct sta_priv *pstapriv = &adapter->stapriv;
298 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
299 u8 *mybssid = get_bssid(pmlmepriv);
300 u8 *myhwaddr = myid(&adapter->eeprompriv);
301 u8 *sta_addr = NULL;
302 bool bmcast = is_multicast_ether_addr(pattrib->dst);
303
304 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) ||
305 check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) {
306
307 if (!memcmp(myhwaddr, pattrib->src, ETH_ALEN))
308 return _FAIL;
309 if ((memcmp(myhwaddr, pattrib->dst, ETH_ALEN)) && (!bmcast))
310 return _FAIL;
311 if (is_zero_ether_addr(pattrib->bssid) ||
312 is_zero_ether_addr(mybssid) ||
313 (memcmp(pattrib->bssid, mybssid, ETH_ALEN)))
314 return _FAIL;
315 sta_addr = pattrib->src;
316 } else if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
317
318
319
320 if (memcmp(pattrib->bssid, pattrib->src, ETH_ALEN))
321 return _FAIL;
322 sta_addr = pattrib->bssid;
323 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
324 if (bmcast) {
325
326
327
328 if (!is_multicast_ether_addr(pattrib->bssid))
329 return _FAIL;
330 } else {
331
332
333
334 if (memcmp(pattrib->bssid, pattrib->dst, ETH_ALEN))
335 return _FAIL;
336 sta_addr = pattrib->src;
337 }
338 } else if (check_fwstate(pmlmepriv, WIFI_MP_STATE)) {
339 memcpy(pattrib->dst, GetAddr1Ptr(ptr), ETH_ALEN);
340 memcpy(pattrib->src, GetAddr2Ptr(ptr), ETH_ALEN);
341 memcpy(pattrib->bssid, GetAddr3Ptr(ptr), ETH_ALEN);
342 memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
343 memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
344 sta_addr = mybssid;
345 } else {
346 ret = _FAIL;
347 }
348 if (bmcast)
349 *psta = r8712_get_bcmc_stainfo(adapter);
350 else
351 *psta = r8712_get_stainfo(pstapriv, sta_addr);
352 if (!*psta) {
353 if (check_fwstate(pmlmepriv, WIFI_MP_STATE))
354 adapter->mppriv.rx_pktloss++;
355 return _FAIL;
356 }
357 return ret;
358}
359
360static sint ap2sta_data_frame(struct _adapter *adapter,
361 union recv_frame *precv_frame,
362 struct sta_info **psta)
363{
364 u8 *ptr = precv_frame->u.hdr.rx_data;
365 struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
366 struct sta_priv *pstapriv = &adapter->stapriv;
367 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
368 u8 *mybssid = get_bssid(pmlmepriv);
369 u8 *myhwaddr = myid(&adapter->eeprompriv);
370 bool bmcast = is_multicast_ether_addr(pattrib->dst);
371
372 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) &&
373 check_fwstate(pmlmepriv, _FW_LINKED)) {
374
375 if ((GetFrameSubType(ptr)) == WIFI_DATA_NULL)
376 return _FAIL;
377
378
379
380 if ((GetFrameSubType(ptr) & WIFI_QOS_DATA_TYPE) ==
381 WIFI_QOS_DATA_TYPE) {
382 if (GetFrameSubType(ptr) & (BIT(4) | BIT(5) | BIT(6)))
383 return _FAIL;
384 }
385
386
387 if (!memcmp(myhwaddr, pattrib->src, ETH_ALEN))
388 return _FAIL;
389
390
391 if ((memcmp(myhwaddr, pattrib->dst, ETH_ALEN)) && (!bmcast))
392 return _FAIL;
393
394 if (is_zero_ether_addr(pattrib->bssid) ||
395 is_zero_ether_addr(mybssid) ||
396 (memcmp(pattrib->bssid, mybssid, ETH_ALEN)))
397 return _FAIL;
398 if (bmcast)
399 *psta = r8712_get_bcmc_stainfo(adapter);
400 else
401 *psta = r8712_get_stainfo(pstapriv, pattrib->bssid);
402 if (!*psta)
403 return _FAIL;
404 } else if (check_fwstate(pmlmepriv, WIFI_MP_STATE) &&
405 check_fwstate(pmlmepriv, _FW_LINKED)) {
406 memcpy(pattrib->dst, GetAddr1Ptr(ptr), ETH_ALEN);
407 memcpy(pattrib->src, GetAddr2Ptr(ptr), ETH_ALEN);
408 memcpy(pattrib->bssid, GetAddr3Ptr(ptr), ETH_ALEN);
409 memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
410 memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
411 memcpy(pattrib->bssid, mybssid, ETH_ALEN);
412 *psta = r8712_get_stainfo(pstapriv, pattrib->bssid);
413 if (!*psta)
414 return _FAIL;
415 } else {
416 return _FAIL;
417 }
418 return _SUCCESS;
419}
420
421static sint sta2ap_data_frame(struct _adapter *adapter,
422 union recv_frame *precv_frame,
423 struct sta_info **psta)
424{
425 struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
426 struct sta_priv *pstapriv = &adapter->stapriv;
427 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
428 unsigned char *mybssid = get_bssid(pmlmepriv);
429
430 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
431
432
433
434
435 if (memcmp(pattrib->bssid, mybssid, ETH_ALEN))
436 return _FAIL;
437 *psta = r8712_get_stainfo(pstapriv, pattrib->src);
438 if (!*psta)
439 return _FAIL;
440 }
441 return _SUCCESS;
442}
443
444static sint validate_recv_ctrl_frame(struct _adapter *adapter,
445 union recv_frame *precv_frame)
446{
447 return _FAIL;
448}
449
450static sint validate_recv_mgnt_frame(struct _adapter *adapter,
451 union recv_frame *precv_frame)
452{
453 return _FAIL;
454}
455
456
457static sint validate_recv_data_frame(struct _adapter *adapter,
458 union recv_frame *precv_frame)
459{
460 int res;
461 u8 bretry;
462 u8 *psa, *pda, *pbssid;
463 struct sta_info *psta = NULL;
464 u8 *ptr = precv_frame->u.hdr.rx_data;
465 struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
466 struct security_priv *psecuritypriv = &adapter->securitypriv;
467
468 bretry = GetRetry(ptr);
469 pda = get_da(ptr);
470 psa = get_sa(ptr);
471 pbssid = get_hdr_bssid(ptr);
472 if (!pbssid)
473 return _FAIL;
474 memcpy(pattrib->dst, pda, ETH_ALEN);
475 memcpy(pattrib->src, psa, ETH_ALEN);
476 memcpy(pattrib->bssid, pbssid, ETH_ALEN);
477 switch (pattrib->to_fr_ds) {
478 case 0:
479 memcpy(pattrib->ra, pda, ETH_ALEN);
480 memcpy(pattrib->ta, psa, ETH_ALEN);
481 res = sta2sta_data_frame(adapter, precv_frame, &psta);
482 break;
483 case 1:
484 memcpy(pattrib->ra, pda, ETH_ALEN);
485 memcpy(pattrib->ta, pbssid, ETH_ALEN);
486 res = ap2sta_data_frame(adapter, precv_frame, &psta);
487 break;
488 case 2:
489 memcpy(pattrib->ra, pbssid, ETH_ALEN);
490 memcpy(pattrib->ta, psa, ETH_ALEN);
491 res = sta2ap_data_frame(adapter, precv_frame, &psta);
492 break;
493 case 3:
494 memcpy(pattrib->ra, GetAddr1Ptr(ptr), ETH_ALEN);
495 memcpy(pattrib->ta, GetAddr2Ptr(ptr), ETH_ALEN);
496 return _FAIL;
497 default:
498 return _FAIL;
499 }
500 if (res == _FAIL)
501 return _FAIL;
502 if (!psta)
503 return _FAIL;
504 precv_frame->u.hdr.psta = psta;
505 pattrib->amsdu = 0;
506
507 if (pattrib->qos == 1) {
508 pattrib->priority = GetPriority((ptr + 24));
509 pattrib->ack_policy = GetAckpolicy((ptr + 24));
510 pattrib->amsdu = GetAMsdu((ptr + 24));
511 pattrib->hdrlen = pattrib->to_fr_ds == 3 ? 32 : 26;
512 } else {
513 pattrib->priority = 0;
514 pattrib->hdrlen = (pattrib->to_fr_ds == 3) ? 30 : 24;
515 }
516
517 if (pattrib->order)
518 pattrib->hdrlen += 4;
519 precv_frame->u.hdr.preorder_ctrl =
520 &psta->recvreorder_ctrl[pattrib->priority];
521
522
523 if (recv_decache(precv_frame, bretry, &psta->sta_recvpriv.rxcache) ==
524 _FAIL)
525 return _FAIL;
526
527 if (pattrib->privacy) {
528 GET_ENCRY_ALGO(psecuritypriv, psta, pattrib->encrypt,
529 is_multicast_ether_addr(pattrib->ra));
530 SET_ICE_IV_LEN(pattrib->iv_len, pattrib->icv_len,
531 pattrib->encrypt);
532 } else {
533 pattrib->encrypt = 0;
534 pattrib->iv_len = pattrib->icv_len = 0;
535 }
536 return _SUCCESS;
537}
538
539sint r8712_validate_recv_frame(struct _adapter *adapter,
540 union recv_frame *precv_frame)
541{
542
543
544
545 u8 type;
546 u8 subtype;
547 sint retval = _SUCCESS;
548 struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
549
550 u8 *ptr = precv_frame->u.hdr.rx_data;
551 u8 ver = (unsigned char)(*ptr) & 0x3;
552
553
554 if (ver != 0)
555 return _FAIL;
556 type = GetFrameType(ptr);
557 subtype = GetFrameSubType(ptr);
558 pattrib->to_fr_ds = get_tofr_ds(ptr);
559 pattrib->frag_num = GetFragNum(ptr);
560 pattrib->seq_num = GetSequence(ptr);
561 pattrib->pw_save = GetPwrMgt(ptr);
562 pattrib->mfrag = GetMFrag(ptr);
563 pattrib->mdata = GetMData(ptr);
564 pattrib->privacy = GetPrivacy(ptr);
565 pattrib->order = GetOrder(ptr);
566 switch (type) {
567 case WIFI_MGT_TYPE:
568 retval = validate_recv_mgnt_frame(adapter, precv_frame);
569 break;
570 case WIFI_CTRL_TYPE:
571 retval = validate_recv_ctrl_frame(adapter, precv_frame);
572 break;
573 case WIFI_DATA_TYPE:
574 pattrib->qos = (subtype & BIT(7)) ? 1 : 0;
575 retval = validate_recv_data_frame(adapter, precv_frame);
576 break;
577 default:
578 return _FAIL;
579 }
580 return retval;
581}
582
583int r8712_wlanhdr_to_ethhdr(union recv_frame *precvframe)
584{
585
586 sint rmv_len;
587 u16 len;
588 u8 bsnaphdr;
589 u8 *psnap_type;
590 struct ieee80211_snap_hdr *psnap;
591 struct _adapter *adapter = precvframe->u.hdr.adapter;
592 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
593
594 u8 *ptr = get_recvframe_data(precvframe);
595 struct rx_pkt_attrib *pattrib = &precvframe->u.hdr.attrib;
596
597 if (pattrib->encrypt)
598 recvframe_pull_tail(precvframe, pattrib->icv_len);
599 psnap = (struct ieee80211_snap_hdr *)(ptr + pattrib->hdrlen +
600 pattrib->iv_len);
601 psnap_type = ptr + pattrib->hdrlen + pattrib->iv_len + SNAP_SIZE;
602
603 if ((!memcmp(psnap, (void *)rfc1042_header, SNAP_SIZE) &&
604 (memcmp(psnap_type, (void *)SNAP_ETH_TYPE_IPX, 2)) &&
605 (memcmp(psnap_type, (void *)SNAP_ETH_TYPE_APPLETALK_AARP, 2))) ||
606 !memcmp(psnap, (void *)bridge_tunnel_header, SNAP_SIZE)) {
607
608
609
610 bsnaphdr = true;
611 } else {
612
613 bsnaphdr = false;
614 }
615 rmv_len = pattrib->hdrlen + pattrib->iv_len +
616 (bsnaphdr ? SNAP_SIZE : 0);
617 len = precvframe->u.hdr.len - rmv_len;
618 if (check_fwstate(pmlmepriv, WIFI_MP_STATE)) {
619 ptr += rmv_len;
620 *ptr = 0x87;
621 *(ptr + 1) = 0x12;
622
623 ptr = recvframe_pull(precvframe, (rmv_len -
624 sizeof(struct ethhdr) + 2) - 24);
625 if (!ptr)
626 return -ENOMEM;
627 memcpy(ptr, get_rxmem(precvframe), 24);
628 ptr += 24;
629 } else {
630 ptr = recvframe_pull(precvframe, (rmv_len -
631 sizeof(struct ethhdr) + (bsnaphdr ? 2 : 0)));
632 if (!ptr)
633 return -ENOMEM;
634 }
635
636 memcpy(ptr, pattrib->dst, ETH_ALEN);
637 memcpy(ptr + ETH_ALEN, pattrib->src, ETH_ALEN);
638 if (!bsnaphdr) {
639 __be16 be_tmp = htons(len);
640
641 memcpy(ptr + 12, &be_tmp, 2);
642 }
643 return 0;
644}
645
646void r8712_recv_entry(union recv_frame *precvframe)
647{
648 struct _adapter *padapter;
649 struct recv_priv *precvpriv;
650
651 s32 ret = _SUCCESS;
652
653 padapter = precvframe->u.hdr.adapter;
654 precvpriv = &(padapter->recvpriv);
655
656 padapter->ledpriv.LedControlHandler(padapter, LED_CTL_RX);
657
658 ret = recv_func(padapter, precvframe);
659 if (ret == _FAIL)
660 goto _recv_entry_drop;
661 precvpriv->rx_pkts++;
662 precvpriv->rx_bytes += (uint)(precvframe->u.hdr.rx_tail -
663 precvframe->u.hdr.rx_data);
664 return;
665_recv_entry_drop:
666 precvpriv->rx_drop++;
667 padapter->mppriv.rx_pktloss = precvpriv->rx_drop;
668}
669
