1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include <linux/sched.h>
29#include "rt_config.h"
30
31ULONG RTDebugLevel = RT_DEBUG_ERROR;
32
33BUILD_TIMER_FUNCTION(MlmePeriodicExec);
34BUILD_TIMER_FUNCTION(AsicRxAntEvalTimeout);
35BUILD_TIMER_FUNCTION(APSDPeriodicExec);
36BUILD_TIMER_FUNCTION(AsicRfTuningExec);
37#ifdef RT2870
38BUILD_TIMER_FUNCTION(BeaconUpdateExec);
39#endif
40
41BUILD_TIMER_FUNCTION(BeaconTimeout);
42BUILD_TIMER_FUNCTION(ScanTimeout);
43BUILD_TIMER_FUNCTION(AuthTimeout);
44BUILD_TIMER_FUNCTION(AssocTimeout);
45BUILD_TIMER_FUNCTION(ReassocTimeout);
46BUILD_TIMER_FUNCTION(DisassocTimeout);
47BUILD_TIMER_FUNCTION(LinkDownExec);
48BUILD_TIMER_FUNCTION(StaQuickResponeForRateUpExec);
49BUILD_TIMER_FUNCTION(WpaDisassocApAndBlockAssoc);
50#ifdef RT2860
51BUILD_TIMER_FUNCTION(PsPollWakeExec);
52BUILD_TIMER_FUNCTION(RadioOnExec);
53#endif
54
55
56char const *pWirelessSysEventText[IW_SYS_EVENT_TYPE_NUM] = {
57
58 "had associated successfully",
59 "had disassociated",
60 "had deauthenticated",
61 "had been aged-out and disassociated",
62 "occurred CounterMeasures attack",
63 "occurred replay counter different in Key Handshaking",
64 "occurred RSNIE different in Key Handshaking",
65 "occurred MIC different in Key Handshaking",
66 "occurred ICV error in RX",
67 "occurred MIC error in RX",
68 "Group Key Handshaking timeout",
69 "Pairwise Key Handshaking timeout",
70 "RSN IE sanity check failure",
71 "set key done in WPA/WPAPSK",
72 "set key done in WPA2/WPA2PSK",
73 "connects with our wireless client",
74 "disconnects with our wireless client",
75 "scan completed"
76 "scan terminate!! Busy!! Enqueue fail!!"
77 };
78
79
80char const *pWirelessSpoofEventText[IW_SPOOF_EVENT_TYPE_NUM] = {
81 "detected conflict SSID",
82 "detected spoofed association response",
83 "detected spoofed reassociation responses",
84 "detected spoofed probe response",
85 "detected spoofed beacon",
86 "detected spoofed disassociation",
87 "detected spoofed authentication",
88 "detected spoofed deauthentication",
89 "detected spoofed unknown management frame",
90 "detected replay attack"
91 };
92
93
94char const *pWirelessFloodEventText[IW_FLOOD_EVENT_TYPE_NUM] = {
95 "detected authentication flooding",
96 "detected association request flooding",
97 "detected reassociation request flooding",
98 "detected probe request flooding",
99 "detected disassociation flooding",
100 "detected deauthentication flooding",
101 "detected 802.1x eap-request flooding"
102 };
103
104
105VOID RTMP_SetPeriodicTimer(
106 IN NDIS_MINIPORT_TIMER *pTimer,
107 IN unsigned long timeout)
108{
109 timeout = ((timeout*HZ) / 1000);
110 pTimer->expires = jiffies + timeout;
111 add_timer(pTimer);
112}
113
114
115VOID RTMP_OS_Init_Timer(
116 IN PRTMP_ADAPTER pAd,
117 IN NDIS_MINIPORT_TIMER *pTimer,
118 IN TIMER_FUNCTION function,
119 IN PVOID data)
120{
121 init_timer(pTimer);
122 pTimer->data = (unsigned long)data;
123 pTimer->function = function;
124}
125
126
127VOID RTMP_OS_Add_Timer(
128 IN NDIS_MINIPORT_TIMER *pTimer,
129 IN unsigned long timeout)
130{
131 if (timer_pending(pTimer))
132 return;
133
134 timeout = ((timeout*HZ) / 1000);
135 pTimer->expires = jiffies + timeout;
136 add_timer(pTimer);
137}
138
139VOID RTMP_OS_Mod_Timer(
140 IN NDIS_MINIPORT_TIMER *pTimer,
141 IN unsigned long timeout)
142{
143 timeout = ((timeout*HZ) / 1000);
144 mod_timer(pTimer, jiffies + timeout);
145}
146
147VOID RTMP_OS_Del_Timer(
148 IN NDIS_MINIPORT_TIMER *pTimer,
149 OUT BOOLEAN *pCancelled)
150{
151 if (timer_pending(pTimer))
152 {
153 *pCancelled = del_timer_sync(pTimer);
154 }
155 else
156 {
157 *pCancelled = TRUE;
158 }
159
160}
161
162VOID RTMP_OS_Release_Packet(
163 IN PRTMP_ADAPTER pAd,
164 IN PQUEUE_ENTRY pEntry)
165{
166
167}
168
169
170VOID RTMPusecDelay(
171 IN ULONG usec)
172{
173 ULONG i;
174
175 for (i = 0; i < (usec / 50); i++)
176 udelay(50);
177
178 if (usec % 50)
179 udelay(usec % 50);
180}
181
182void RTMP_GetCurrentSystemTime(LARGE_INTEGER *time)
183{
184 time->u.LowPart = jiffies;
185}
186
187
188NDIS_STATUS os_alloc_mem(
189 IN PRTMP_ADAPTER pAd,
190 OUT PUCHAR *mem,
191 IN ULONG size)
192{
193 *mem = (PUCHAR) kmalloc(size, GFP_ATOMIC);
194 if (*mem)
195 return (NDIS_STATUS_SUCCESS);
196 else
197 return (NDIS_STATUS_FAILURE);
198}
199
200
201NDIS_STATUS os_free_mem(
202 IN PRTMP_ADAPTER pAd,
203 IN PUCHAR mem)
204{
205
206 ASSERT(mem);
207 kfree(mem);
208 return (NDIS_STATUS_SUCCESS);
209}
210
211
212PNDIS_PACKET RTMP_AllocateFragPacketBuffer(
213 IN PRTMP_ADAPTER pAd,
214 IN ULONG Length)
215{
216 struct sk_buff *pkt;
217
218 pkt = dev_alloc_skb(Length);
219
220 if (pkt == NULL)
221 {
222 DBGPRINT(RT_DEBUG_ERROR, ("can't allocate frag rx %ld size packet\n",Length));
223 }
224
225 if (pkt)
226 {
227 RTMP_SET_PACKET_SOURCE(OSPKT_TO_RTPKT(pkt), PKTSRC_NDIS);
228 }
229
230 return (PNDIS_PACKET) pkt;
231}
232
233
234PNDIS_PACKET RTMP_AllocateTxPacketBuffer(
235 IN PRTMP_ADAPTER pAd,
236 IN ULONG Length,
237 IN BOOLEAN Cached,
238 OUT PVOID *VirtualAddress)
239{
240 struct sk_buff *pkt;
241
242 pkt = dev_alloc_skb(Length);
243
244 if (pkt == NULL)
245 {
246 DBGPRINT(RT_DEBUG_ERROR, ("can't allocate tx %ld size packet\n",Length));
247 }
248
249 if (pkt)
250 {
251 RTMP_SET_PACKET_SOURCE(OSPKT_TO_RTPKT(pkt), PKTSRC_NDIS);
252 *VirtualAddress = (PVOID) pkt->data;
253 }
254 else
255 {
256 *VirtualAddress = (PVOID) NULL;
257 }
258
259 return (PNDIS_PACKET) pkt;
260}
261
262
263VOID build_tx_packet(
264 IN PRTMP_ADAPTER pAd,
265 IN PNDIS_PACKET pPacket,
266 IN PUCHAR pFrame,
267 IN ULONG FrameLen)
268{
269
270 struct sk_buff *pTxPkt;
271
272 ASSERT(pPacket);
273 pTxPkt = RTPKT_TO_OSPKT(pPacket);
274
275 NdisMoveMemory(skb_put(pTxPkt, FrameLen), pFrame, FrameLen);
276}
277
278VOID RTMPFreeAdapter(
279 IN PRTMP_ADAPTER pAd)
280{
281 POS_COOKIE os_cookie;
282 int index;
283
284 os_cookie=(POS_COOKIE)pAd->OS_Cookie;
285
286 kfree(pAd->BeaconBuf);
287
288
289 NdisFreeSpinLock(&pAd->MgmtRingLock);
290#ifdef RT2860
291 NdisFreeSpinLock(&pAd->RxRingLock);
292#endif
293 for (index =0 ; index < NUM_OF_TX_RING; index++)
294 {
295 NdisFreeSpinLock(&pAd->TxSwQueueLock[index]);
296 NdisFreeSpinLock(&pAd->DeQueueLock[index]);
297 pAd->DeQueueRunning[index] = FALSE;
298 }
299
300 NdisFreeSpinLock(&pAd->irq_lock);
301
302 vfree(pAd);
303 kfree(os_cookie);
304}
305
306BOOLEAN OS_Need_Clone_Packet(void)
307{
308 return (FALSE);
309}
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335NDIS_STATUS RTMPCloneNdisPacket(
336 IN PRTMP_ADAPTER pAd,
337 IN BOOLEAN pInsAMSDUHdr,
338 IN PNDIS_PACKET pInPacket,
339 OUT PNDIS_PACKET *ppOutPacket)
340{
341
342 struct sk_buff *pkt;
343
344 ASSERT(pInPacket);
345 ASSERT(ppOutPacket);
346
347
348 pkt = dev_alloc_skb(2048);
349
350 if (pkt == NULL)
351 {
352 return NDIS_STATUS_FAILURE;
353 }
354
355 skb_put(pkt, GET_OS_PKT_LEN(pInPacket));
356 NdisMoveMemory(pkt->data, GET_OS_PKT_DATAPTR(pInPacket), GET_OS_PKT_LEN(pInPacket));
357 *ppOutPacket = OSPKT_TO_RTPKT(pkt);
358
359
360 RTMP_SET_PACKET_SOURCE(OSPKT_TO_RTPKT(pkt), PKTSRC_NDIS);
361
362 printk("###Clone###\n");
363
364 return NDIS_STATUS_SUCCESS;
365}
366
367
368
369NDIS_STATUS RTMPAllocateNdisPacket(
370 IN PRTMP_ADAPTER pAd,
371 OUT PNDIS_PACKET *ppPacket,
372 IN PUCHAR pHeader,
373 IN UINT HeaderLen,
374 IN PUCHAR pData,
375 IN UINT DataLen)
376{
377 PNDIS_PACKET pPacket;
378 ASSERT(pData);
379 ASSERT(DataLen);
380
381
382 pPacket = (PNDIS_PACKET *) dev_alloc_skb(HeaderLen + DataLen + TXPADDING_SIZE);
383 if (pPacket == NULL)
384 {
385 *ppPacket = NULL;
386#ifdef DEBUG
387 printk("RTMPAllocateNdisPacket Fail\n\n");
388#endif
389 return NDIS_STATUS_FAILURE;
390 }
391
392
393 if (HeaderLen > 0)
394 NdisMoveMemory(GET_OS_PKT_DATAPTR(pPacket), pHeader, HeaderLen);
395 if (DataLen > 0)
396 NdisMoveMemory(GET_OS_PKT_DATAPTR(pPacket) + HeaderLen, pData, DataLen);
397
398
399 skb_put(GET_OS_PKT_TYPE(pPacket), HeaderLen+DataLen);
400
401 RTMP_SET_PACKET_SOURCE(pPacket, PKTSRC_NDIS);
402
403 *ppPacket = pPacket;
404 return NDIS_STATUS_SUCCESS;
405}
406
407
408
409
410
411
412
413
414VOID RTMPFreeNdisPacket(
415 IN PRTMP_ADAPTER pAd,
416 IN PNDIS_PACKET pPacket)
417{
418 dev_kfree_skb_any(RTPKT_TO_OSPKT(pPacket));
419}
420
421
422
423
424
425NDIS_STATUS Sniff2BytesFromNdisBuffer(
426 IN PNDIS_BUFFER pFirstBuffer,
427 IN UCHAR DesiredOffset,
428 OUT PUCHAR pByte0,
429 OUT PUCHAR pByte1)
430{
431 *pByte0 = *(PUCHAR)(pFirstBuffer + DesiredOffset);
432 *pByte1 = *(PUCHAR)(pFirstBuffer + DesiredOffset + 1);
433
434 return NDIS_STATUS_SUCCESS;
435}
436
437
438void RTMP_QueryPacketInfo(
439 IN PNDIS_PACKET pPacket,
440 OUT PACKET_INFO *pPacketInfo,
441 OUT PUCHAR *pSrcBufVA,
442 OUT UINT *pSrcBufLen)
443{
444 pPacketInfo->BufferCount = 1;
445 pPacketInfo->pFirstBuffer = GET_OS_PKT_DATAPTR(pPacket);
446 pPacketInfo->PhysicalBufferCount = 1;
447 pPacketInfo->TotalPacketLength = GET_OS_PKT_LEN(pPacket);
448
449 *pSrcBufVA = GET_OS_PKT_DATAPTR(pPacket);
450 *pSrcBufLen = GET_OS_PKT_LEN(pPacket);
451}
452
453void RTMP_QueryNextPacketInfo(
454 IN PNDIS_PACKET *ppPacket,
455 OUT PACKET_INFO *pPacketInfo,
456 OUT PUCHAR *pSrcBufVA,
457 OUT UINT *pSrcBufLen)
458{
459 PNDIS_PACKET pPacket = NULL;
460
461 if (*ppPacket)
462 pPacket = GET_OS_PKT_NEXT(*ppPacket);
463
464 if (pPacket)
465 {
466 pPacketInfo->BufferCount = 1;
467 pPacketInfo->pFirstBuffer = GET_OS_PKT_DATAPTR(pPacket);
468 pPacketInfo->PhysicalBufferCount = 1;
469 pPacketInfo->TotalPacketLength = GET_OS_PKT_LEN(pPacket);
470
471 *pSrcBufVA = GET_OS_PKT_DATAPTR(pPacket);
472 *pSrcBufLen = GET_OS_PKT_LEN(pPacket);
473 *ppPacket = GET_OS_PKT_NEXT(pPacket);
474 }
475 else
476 {
477 pPacketInfo->BufferCount = 0;
478 pPacketInfo->pFirstBuffer = NULL;
479 pPacketInfo->PhysicalBufferCount = 0;
480 pPacketInfo->TotalPacketLength = 0;
481
482 *pSrcBufVA = NULL;
483 *pSrcBufLen = 0;
484 *ppPacket = NULL;
485 }
486}
487
488
489PNET_DEV get_netdev_from_bssid(
490 IN PRTMP_ADAPTER pAd,
491 IN UCHAR FromWhichBSSID)
492{
493 PNET_DEV dev_p = NULL;
494
495 dev_p = pAd->net_dev;
496
497 ASSERT(dev_p);
498 return dev_p;
499}
500
501PNDIS_PACKET DuplicatePacket(
502 IN PRTMP_ADAPTER pAd,
503 IN PNDIS_PACKET pPacket,
504 IN UCHAR FromWhichBSSID)
505{
506 struct sk_buff *skb;
507 PNDIS_PACKET pRetPacket = NULL;
508 USHORT DataSize;
509 UCHAR *pData;
510
511 DataSize = (USHORT) GET_OS_PKT_LEN(pPacket);
512 pData = (PUCHAR) GET_OS_PKT_DATAPTR(pPacket);
513
514
515 skb = skb_clone(RTPKT_TO_OSPKT(pPacket), MEM_ALLOC_FLAG);
516 if (skb)
517 {
518 skb->dev = get_netdev_from_bssid(pAd, FromWhichBSSID);
519 pRetPacket = OSPKT_TO_RTPKT(skb);
520 }
521
522 return pRetPacket;
523
524}
525
526PNDIS_PACKET duplicate_pkt(
527 IN PRTMP_ADAPTER pAd,
528 IN PUCHAR pHeader802_3,
529 IN UINT HdrLen,
530 IN PUCHAR pData,
531 IN ULONG DataSize,
532 IN UCHAR FromWhichBSSID)
533{
534 struct sk_buff *skb;
535 PNDIS_PACKET pPacket = NULL;
536
537
538 if ((skb = __dev_alloc_skb(HdrLen + DataSize + 2, MEM_ALLOC_FLAG)) != NULL)
539 {
540 skb_reserve(skb, 2);
541 NdisMoveMemory(skb_tail_pointer(skb), pHeader802_3, HdrLen);
542 skb_put(skb, HdrLen);
543 NdisMoveMemory(skb_tail_pointer(skb), pData, DataSize);
544 skb_put(skb, DataSize);
545 skb->dev = get_netdev_from_bssid(pAd, FromWhichBSSID);
546 pPacket = OSPKT_TO_RTPKT(skb);
547 }
548
549 return pPacket;
550}
551
552
553#define TKIP_TX_MIC_SIZE 8
554PNDIS_PACKET duplicate_pkt_with_TKIP_MIC(
555 IN PRTMP_ADAPTER pAd,
556 IN PNDIS_PACKET pPacket)
557{
558 struct sk_buff *skb, *newskb;
559
560
561 skb = RTPKT_TO_OSPKT(pPacket);
562 if (skb_tailroom(skb) < TKIP_TX_MIC_SIZE)
563 {
564
565 newskb = skb_copy_expand(skb, skb_headroom(skb), TKIP_TX_MIC_SIZE, GFP_ATOMIC);
566 dev_kfree_skb_any(skb);
567 if (newskb == NULL)
568 {
569 DBGPRINT(RT_DEBUG_ERROR, ("Extend Tx.MIC for packet failed!, dropping packet!\n"));
570 return NULL;
571 }
572 skb = newskb;
573 }
574
575 return OSPKT_TO_RTPKT(skb);
576}
577
578
579
580
581PNDIS_PACKET ClonePacket(
582 IN PRTMP_ADAPTER pAd,
583 IN PNDIS_PACKET pPacket,
584 IN PUCHAR pData,
585 IN ULONG DataSize)
586{
587 struct sk_buff *pRxPkt;
588 struct sk_buff *pClonedPkt;
589
590 ASSERT(pPacket);
591 pRxPkt = RTPKT_TO_OSPKT(pPacket);
592
593
594 pClonedPkt = skb_clone(pRxPkt, MEM_ALLOC_FLAG);
595
596 if (pClonedPkt)
597 {
598
599 pClonedPkt->dev = pRxPkt->dev;
600 pClonedPkt->data = pData;
601 pClonedPkt->len = DataSize;
602 pClonedPkt->tail = pClonedPkt->data + pClonedPkt->len;
603 ASSERT(DataSize < 1530);
604 }
605 return pClonedPkt;
606}
607
608
609
610
611void update_os_packet_info(
612 IN PRTMP_ADAPTER pAd,
613 IN RX_BLK *pRxBlk,
614 IN UCHAR FromWhichBSSID)
615{
616 struct sk_buff *pOSPkt;
617
618 ASSERT(pRxBlk->pRxPacket);
619 pOSPkt = RTPKT_TO_OSPKT(pRxBlk->pRxPacket);
620
621 pOSPkt->dev = get_netdev_from_bssid(pAd, FromWhichBSSID);
622 pOSPkt->data = pRxBlk->pData;
623 pOSPkt->len = pRxBlk->DataSize;
624 pOSPkt->tail = pOSPkt->data + pOSPkt->len;
625}
626
627
628void wlan_802_11_to_802_3_packet(
629 IN PRTMP_ADAPTER pAd,
630 IN RX_BLK *pRxBlk,
631 IN PUCHAR pHeader802_3,
632 IN UCHAR FromWhichBSSID)
633{
634 struct sk_buff *pOSPkt;
635
636 ASSERT(pRxBlk->pRxPacket);
637 ASSERT(pHeader802_3);
638
639 pOSPkt = RTPKT_TO_OSPKT(pRxBlk->pRxPacket);
640
641 pOSPkt->dev = get_netdev_from_bssid(pAd, FromWhichBSSID);
642 pOSPkt->data = pRxBlk->pData;
643 pOSPkt->len = pRxBlk->DataSize;
644 pOSPkt->tail = pOSPkt->data + pOSPkt->len;
645
646
647
648
649
650
651 NdisMoveMemory(skb_push(pOSPkt, LENGTH_802_3), pHeader802_3, LENGTH_802_3);
652}
653
654void announce_802_3_packet(
655 IN PRTMP_ADAPTER pAd,
656 IN PNDIS_PACKET pPacket)
657{
658
659 struct sk_buff *pRxPkt;
660
661 ASSERT(pPacket);
662
663 pRxPkt = RTPKT_TO_OSPKT(pPacket);
664
665
666 pRxPkt->protocol = eth_type_trans(pRxPkt, pRxPkt->dev);
667
668 netif_rx(pRxPkt);
669}
670
671
672PRTMP_SCATTER_GATHER_LIST
673rt_get_sg_list_from_packet(PNDIS_PACKET pPacket, RTMP_SCATTER_GATHER_LIST *sg)
674{
675 sg->NumberOfElements = 1;
676 sg->Elements[0].Address = GET_OS_PKT_DATAPTR(pPacket);
677 sg->Elements[0].Length = GET_OS_PKT_LEN(pPacket);
678 return (sg);
679}
680
681void hex_dump(char *str, unsigned char *pSrcBufVA, unsigned int SrcBufLen)
682{
683 unsigned char *pt;
684 int x;
685
686 if (RTDebugLevel < RT_DEBUG_TRACE)
687 return;
688
689 pt = pSrcBufVA;
690 printk("%s: %p, len = %d\n",str, pSrcBufVA, SrcBufLen);
691 for (x=0; x<SrcBufLen; x++)
692 {
693 if (x % 16 == 0)
694 printk("0x%04x : ", x);
695 printk("%02x ", ((unsigned char)pt[x]));
696 if (x%16 == 15) printk("\n");
697 }
698 printk("\n");
699}
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721VOID RTMPSendWirelessEvent(
722 IN PRTMP_ADAPTER pAd,
723 IN USHORT Event_flag,
724 IN PUCHAR pAddr,
725 IN UCHAR BssIdx,
726 IN CHAR Rssi)
727{
728
729 union iwreq_data wrqu;
730 PUCHAR pBuf = NULL, pBufPtr = NULL;
731 USHORT event, type, BufLen;
732 UCHAR event_table_len = 0;
733
734 type = Event_flag & 0xFF00;
735 event = Event_flag & 0x00FF;
736
737 switch (type)
738 {
739 case IW_SYS_EVENT_FLAG_START:
740 event_table_len = IW_SYS_EVENT_TYPE_NUM;
741 break;
742
743 case IW_SPOOF_EVENT_FLAG_START:
744 event_table_len = IW_SPOOF_EVENT_TYPE_NUM;
745 break;
746
747 case IW_FLOOD_EVENT_FLAG_START:
748 event_table_len = IW_FLOOD_EVENT_TYPE_NUM;
749 break;
750 }
751
752 if (event_table_len == 0)
753 {
754 DBGPRINT(RT_DEBUG_ERROR, ("%s : The type(%0x02x) is not valid.\n", __func__, type));
755 return;
756 }
757
758 if (event >= event_table_len)
759 {
760 DBGPRINT(RT_DEBUG_ERROR, ("%s : The event(%0x02x) is not valid.\n", __func__, event));
761 return;
762 }
763
764
765 if((pBuf = kmalloc(IW_CUSTOM_MAX_LEN, GFP_ATOMIC)) != NULL)
766 {
767
768 memset(pBuf, 0, IW_CUSTOM_MAX_LEN);
769
770 pBufPtr = pBuf;
771
772 if (pAddr)
773 pBufPtr += sprintf(pBufPtr, "(RT2860) STA(%02x:%02x:%02x:%02x:%02x:%02x) ", PRINT_MAC(pAddr));
774 else if (BssIdx < MAX_MBSSID_NUM)
775 pBufPtr += sprintf(pBufPtr, "(RT2860) BSS(wlan%d) ", BssIdx);
776 else
777 pBufPtr += sprintf(pBufPtr, "(RT2860) ");
778
779 if (type == IW_SYS_EVENT_FLAG_START)
780 pBufPtr += sprintf(pBufPtr, "%s", pWirelessSysEventText[event]);
781 else if (type == IW_SPOOF_EVENT_FLAG_START)
782 pBufPtr += sprintf(pBufPtr, "%s (RSSI=%d)", pWirelessSpoofEventText[event], Rssi);
783 else if (type == IW_FLOOD_EVENT_FLAG_START)
784 pBufPtr += sprintf(pBufPtr, "%s", pWirelessFloodEventText[event]);
785 else
786 pBufPtr += sprintf(pBufPtr, "%s", "unknown event");
787
788 pBufPtr[pBufPtr - pBuf] = '\0';
789 BufLen = pBufPtr - pBuf;
790
791 memset(&wrqu, 0, sizeof(wrqu));
792 wrqu.data.flags = Event_flag;
793 wrqu.data.length = BufLen;
794
795
796 wireless_send_event(pAd->net_dev, IWEVCUSTOM, &wrqu, pBuf);
797
798
799
800 kfree(pBuf);
801 }
802 else
803 DBGPRINT(RT_DEBUG_ERROR, ("%s : Can't allocate memory for wireless event.\n", __func__));
804}
805
806void send_monitor_packets(
807 IN PRTMP_ADAPTER pAd,
808 IN RX_BLK *pRxBlk)
809{
810 struct sk_buff *pOSPkt;
811 wlan_ng_prism2_header *ph;
812 int rate_index = 0;
813 USHORT header_len = 0;
814 UCHAR temp_header[40] = {0};
815
816 u_int32_t ralinkrate[256] = {2,4,11,22, 12,18,24,36,48,72,96, 108, 109, 110, 111, 112, 13, 26, 39, 52,78,104, 117, 130, 26, 52, 78,104, 156, 208, 234, 260, 27, 54,81,108,162, 216, 243, 270,
817 54, 108, 162, 216, 324, 432, 486, 540, 14, 29, 43, 57, 87, 115, 130, 144, 29, 59,87,115, 173, 230,260, 288, 30, 60,90,120,180,240,270,300,60,120,180,240,360,480,540,600, 0,1,2,3,4,5,6,7,8,9,10,
818 11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80};
819
820
821 ASSERT(pRxBlk->pRxPacket);
822 if (pRxBlk->DataSize < 10)
823 {
824 DBGPRINT(RT_DEBUG_ERROR, ("%s : Size is too small! (%d)\n", __func__, pRxBlk->DataSize));
825 goto err_free_sk_buff;
826 }
827
828 if (pRxBlk->DataSize + sizeof(wlan_ng_prism2_header) > RX_BUFFER_AGGRESIZE)
829 {
830 DBGPRINT(RT_DEBUG_ERROR, ("%s : Size is too large! (%zu)\n", __func__, pRxBlk->DataSize + sizeof(wlan_ng_prism2_header)));
831 goto err_free_sk_buff;
832 }
833
834 pOSPkt = RTPKT_TO_OSPKT(pRxBlk->pRxPacket);
835 pOSPkt->dev = get_netdev_from_bssid(pAd, BSS0);
836 if (pRxBlk->pHeader->FC.Type == BTYPE_DATA)
837 {
838 pRxBlk->DataSize -= LENGTH_802_11;
839 if ((pRxBlk->pHeader->FC.ToDs == 1) &&
840 (pRxBlk->pHeader->FC.FrDs == 1))
841 header_len = LENGTH_802_11_WITH_ADDR4;
842 else
843 header_len = LENGTH_802_11;
844
845
846 if (pRxBlk->pHeader->FC.SubType & 0x08)
847 {
848 header_len += 2;
849
850 pRxBlk->DataSize -=2;
851 }
852
853
854 if (pRxBlk->pHeader->FC.Order)
855 {
856 header_len += 4;
857
858 pRxBlk->DataSize -= 4;
859 }
860
861
862 if (header_len <= 40)
863 NdisMoveMemory(temp_header, pRxBlk->pData, header_len);
864
865
866 if (pRxBlk->RxD.L2PAD)
867 pRxBlk->pData += (header_len + 2);
868 else
869 pRxBlk->pData += header_len;
870 }
871
872
873 if (pRxBlk->DataSize < pOSPkt->len) {
874 skb_trim(pOSPkt,pRxBlk->DataSize);
875 } else {
876 skb_put(pOSPkt,(pRxBlk->DataSize - pOSPkt->len));
877 }
878
879 if ((pRxBlk->pData - pOSPkt->data) > 0) {
880 skb_put(pOSPkt,(pRxBlk->pData - pOSPkt->data));
881 skb_pull(pOSPkt,(pRxBlk->pData - pOSPkt->data));
882 }
883
884 if (skb_headroom(pOSPkt) < (sizeof(wlan_ng_prism2_header)+ header_len)) {
885 if (pskb_expand_head(pOSPkt, (sizeof(wlan_ng_prism2_header) + header_len), 0, GFP_ATOMIC)) {
886 DBGPRINT(RT_DEBUG_ERROR, ("%s : Reallocate header size of sk_buff fail!\n", __func__));
887 goto err_free_sk_buff;
888 }
889 }
890
891 if (header_len > 0)
892 NdisMoveMemory(skb_push(pOSPkt, header_len), temp_header, header_len);
893
894 ph = (wlan_ng_prism2_header *) skb_push(pOSPkt, sizeof(wlan_ng_prism2_header));
895 NdisZeroMemory(ph, sizeof(wlan_ng_prism2_header));
896
897 ph->msgcode = DIDmsg_lnxind_wlansniffrm;
898 ph->msglen = sizeof(wlan_ng_prism2_header);
899 strcpy(ph->devname, pAd->net_dev->name);
900
901 ph->hosttime.did = DIDmsg_lnxind_wlansniffrm_hosttime;
902 ph->hosttime.status = 0;
903 ph->hosttime.len = 4;
904 ph->hosttime.data = jiffies;
905
906 ph->mactime.did = DIDmsg_lnxind_wlansniffrm_mactime;
907 ph->mactime.status = 0;
908 ph->mactime.len = 0;
909 ph->mactime.data = 0;
910
911 ph->istx.did = DIDmsg_lnxind_wlansniffrm_istx;
912 ph->istx.status = 0;
913 ph->istx.len = 0;
914 ph->istx.data = 0;
915
916 ph->channel.did = DIDmsg_lnxind_wlansniffrm_channel;
917 ph->channel.status = 0;
918 ph->channel.len = 4;
919
920 ph->channel.data = (u_int32_t)pAd->CommonCfg.Channel;
921
922 ph->rssi.did = DIDmsg_lnxind_wlansniffrm_rssi;
923 ph->rssi.status = 0;
924 ph->rssi.len = 4;
925 ph->rssi.data = (u_int32_t)RTMPMaxRssi(pAd, ConvertToRssi(pAd, pRxBlk->pRxWI->RSSI0, RSSI_0), ConvertToRssi(pAd, pRxBlk->pRxWI->RSSI1, RSSI_1), ConvertToRssi(pAd, pRxBlk->pRxWI->RSSI2, RSSI_2));;
926
927 ph->signal.did = DIDmsg_lnxind_wlansniffrm_signal;
928 ph->signal.status = 0;
929 ph->signal.len = 4;
930 ph->signal.data = 0;
931
932 ph->noise.did = DIDmsg_lnxind_wlansniffrm_noise;
933 ph->noise.status = 0;
934 ph->noise.len = 4;
935 ph->noise.data = 0;
936
937 if (pRxBlk->pRxWI->PHYMODE >= MODE_HTMIX)
938 {
939 rate_index = 16 + ((UCHAR)pRxBlk->pRxWI->BW *16) + ((UCHAR)pRxBlk->pRxWI->ShortGI *32) + ((UCHAR)pRxBlk->pRxWI->MCS);
940 }
941 else
942 if (pRxBlk->pRxWI->PHYMODE == MODE_OFDM)
943 rate_index = (UCHAR)(pRxBlk->pRxWI->MCS) + 4;
944 else
945 rate_index = (UCHAR)(pRxBlk->pRxWI->MCS);
946 if (rate_index < 0)
947 rate_index = 0;
948 if (rate_index > 255)
949 rate_index = 255;
950
951 ph->rate.did = DIDmsg_lnxind_wlansniffrm_rate;
952 ph->rate.status = 0;
953 ph->rate.len = 4;
954 ph->rate.data = ralinkrate[rate_index];
955
956 ph->frmlen.did = DIDmsg_lnxind_wlansniffrm_frmlen;
957 ph->frmlen.status = 0;
958 ph->frmlen.len = 4;
959 ph->frmlen.data = (u_int32_t)pRxBlk->DataSize;
960
961
962 pOSPkt->pkt_type = PACKET_OTHERHOST;
963 pOSPkt->protocol = eth_type_trans(pOSPkt, pOSPkt->dev);
964 pOSPkt->ip_summed = CHECKSUM_NONE;
965 netif_rx(pOSPkt);
966
967 return;
968
969err_free_sk_buff:
970 RELEASE_NDIS_PACKET(pAd, pRxBlk->pRxPacket, NDIS_STATUS_FAILURE);
971 return;
972
973}
974
975void rtmp_os_thread_init(PUCHAR pThreadName, PVOID pNotify)
976{
977 daemonize(pThreadName );
978
979 allow_signal(SIGTERM);
980 allow_signal(SIGKILL);
981 current->flags |= PF_NOFREEZE;
982
983
984 complete(pNotify);
985}
986
987void RTMP_IndicateMediaState(
988 IN PRTMP_ADAPTER pAd)
989{
990 if (pAd->CommonCfg.bWirelessEvent)
991 {
992 if (pAd->IndicateMediaState == NdisMediaStateConnected)
993 {
994 RTMPSendWirelessEvent(pAd, IW_STA_LINKUP_EVENT_FLAG, pAd->MacTab.Content[BSSID_WCID].Addr, BSS0, 0);
995 }
996 else
997 {
998 RTMPSendWirelessEvent(pAd, IW_STA_LINKDOWN_EVENT_FLAG, pAd->MacTab.Content[BSSID_WCID].Addr, BSS0, 0);
999 }
1000 }
1001}
1002
1003