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