?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drivers/staging: Remove unnecessary semicolons
[linux-2.6.git] / drivers / staging / rt2860 / rt_linux.c
blob0bbd04a71a6a84a82a318940e31b0ceb0055d17b
1 /*
2 *************************************************************************
3 * Ralink Tech Inc.
4 * 5F., No.36, Taiyuan St., Jhubei City,
5 * Hsinchu County 302,
6 * Taiwan, R.O.C.
7 *
8 * (c) Copyright 2002-2007, Ralink Technology, Inc.
9 *
10 * This program is free software; you can redistribute it and/or modify *
11 * it under the terms of the GNU General Public License as published by *
12 * the Free Software Foundation; either version 2 of the License, or *
13 * (at your option) any later version. *
14 * *
15 * This program is distributed in the hope that it will be useful, *
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
18 * GNU General Public License for more details. *
19 * *
20 * You should have received a copy of the GNU General Public License *
21 * along with this program; if not, write to the *
22 * Free Software Foundation, Inc., *
23 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
24 * *
25 *************************************************************************
26 */
27
28 #include <linux/firmware.h>
29 #include <linux/sched.h>
30 #include <linux/slab.h>
31 #include "rt_config.h"
32
33 unsigned long RTDebugLevel = RT_DEBUG_ERROR;
34
35 /* for wireless system event message */
36 char const *pWirelessSysEventText[IW_SYS_EVENT_TYPE_NUM] = {
37 /* system status event */
38 "had associated successfully", /* IW_ASSOC_EVENT_FLAG */
39 "had disassociated", /* IW_DISASSOC_EVENT_FLAG */
40 "had deauthenticated", /* IW_DEAUTH_EVENT_FLAG */
41 "had been aged-out and disassociated", /* IW_AGEOUT_EVENT_FLAG */
42 "occurred CounterMeasures attack", /* IW_COUNTER_MEASURES_EVENT_FLAG */
43 "occurred replay counter different in Key Handshaking", /* IW_REPLAY_COUNTER_DIFF_EVENT_FLAG */
44 "occurred RSNIE different in Key Handshaking", /* IW_RSNIE_DIFF_EVENT_FLAG */
45 "occurred MIC different in Key Handshaking", /* IW_MIC_DIFF_EVENT_FLAG */
46 "occurred ICV error in RX", /* IW_ICV_ERROR_EVENT_FLAG */
47 "occurred MIC error in RX", /* IW_MIC_ERROR_EVENT_FLAG */
48 "Group Key Handshaking timeout", /* IW_GROUP_HS_TIMEOUT_EVENT_FLAG */
49 "Pairwise Key Handshaking timeout", /* IW_PAIRWISE_HS_TIMEOUT_EVENT_FLAG */
50 "RSN IE sanity check failure", /* IW_RSNIE_SANITY_FAIL_EVENT_FLAG */
51 "set key done in WPA/WPAPSK", /* IW_SET_KEY_DONE_WPA1_EVENT_FLAG */
52 "set key done in WPA2/WPA2PSK", /* IW_SET_KEY_DONE_WPA2_EVENT_FLAG */
53 "connects with our wireless client", /* IW_STA_LINKUP_EVENT_FLAG */
54 "disconnects with our wireless client", /* IW_STA_LINKDOWN_EVENT_FLAG */
55 "scan completed" /* IW_SCAN_COMPLETED_EVENT_FLAG */
56 "scan terminate! Busy! Enqueue fail!" /* IW_SCAN_ENQUEUE_FAIL_EVENT_FLAG */
57 };
58
59 /* for wireless IDS_spoof_attack event message */
60 char const *pWirelessSpoofEventText[IW_SPOOF_EVENT_TYPE_NUM] = {
61 "detected conflict SSID", /* IW_CONFLICT_SSID_EVENT_FLAG */
62 "detected spoofed association response", /* IW_SPOOF_ASSOC_RESP_EVENT_FLAG */
63 "detected spoofed reassociation responses", /* IW_SPOOF_REASSOC_RESP_EVENT_FLAG */
64 "detected spoofed probe response", /* IW_SPOOF_PROBE_RESP_EVENT_FLAG */
65 "detected spoofed beacon", /* IW_SPOOF_BEACON_EVENT_FLAG */
66 "detected spoofed disassociation", /* IW_SPOOF_DISASSOC_EVENT_FLAG */
67 "detected spoofed authentication", /* IW_SPOOF_AUTH_EVENT_FLAG */
68 "detected spoofed deauthentication", /* IW_SPOOF_DEAUTH_EVENT_FLAG */
69 "detected spoofed unknown management frame", /* IW_SPOOF_UNKNOWN_MGMT_EVENT_FLAG */
70 "detected replay attack" /* IW_REPLAY_ATTACK_EVENT_FLAG */
71 };
72
73 /* for wireless IDS_flooding_attack event message */
74 char const *pWirelessFloodEventText[IW_FLOOD_EVENT_TYPE_NUM] = {
75 "detected authentication flooding", /* IW_FLOOD_AUTH_EVENT_FLAG */
76 "detected association request flooding", /* IW_FLOOD_ASSOC_REQ_EVENT_FLAG */
77 "detected reassociation request flooding", /* IW_FLOOD_REASSOC_REQ_EVENT_FLAG */
78 "detected probe request flooding", /* IW_FLOOD_PROBE_REQ_EVENT_FLAG */
79 "detected disassociation flooding", /* IW_FLOOD_DISASSOC_EVENT_FLAG */
80 "detected deauthentication flooding", /* IW_FLOOD_DEAUTH_EVENT_FLAG */
81 "detected 802.1x eap-request flooding" /* IW_FLOOD_EAP_REQ_EVENT_FLAG */
82 };
83
84 /* timeout -- ms */
85 void RTMP_SetPeriodicTimer(struct timer_list *pTimer,
86 IN unsigned long timeout)
87 {
88 timeout = ((timeout * OS_HZ) / 1000);
89 pTimer->expires = jiffies + timeout;
90 add_timer(pTimer);
91 }
92
93 /* convert NdisMInitializeTimer --> RTMP_OS_Init_Timer */
94 void RTMP_OS_Init_Timer(struct rt_rtmp_adapter *pAd,
95 struct timer_list *pTimer,
96 IN TIMER_FUNCTION function, void *data)
97 {
98 init_timer(pTimer);
99 pTimer->data = (unsigned long)data;
100 pTimer->function = function;
101 }
102
103 void RTMP_OS_Add_Timer(struct timer_list *pTimer,
104 IN unsigned long timeout)
105 {
106 if (timer_pending(pTimer))
107 return;
108
109 timeout = ((timeout * OS_HZ) / 1000);
110 pTimer->expires = jiffies + timeout;
111 add_timer(pTimer);
112 }
113
114 void RTMP_OS_Mod_Timer(struct timer_list *pTimer,
115 IN unsigned long timeout)
116 {
117 timeout = ((timeout * OS_HZ) / 1000);
118 mod_timer(pTimer, jiffies + timeout);
119 }
120
121 void RTMP_OS_Del_Timer(struct timer_list *pTimer,
122 OUT BOOLEAN * pCancelled)
123 {
124 if (timer_pending(pTimer)) {
125 *pCancelled = del_timer_sync(pTimer);
126 } else {
127 *pCancelled = TRUE;
128 }
129
130 }
131
132 void RTMP_OS_Release_Packet(struct rt_rtmp_adapter *pAd, struct rt_queue_entry *pEntry)
133 {
134 /*RTMPFreeNdisPacket(pAd, (struct sk_buff *)pEntry); */
135 }
136
137 /* Unify all delay routine by using udelay */
138 void RTMPusecDelay(unsigned long usec)
139 {
140 unsigned long i;
141
142 for (i = 0; i < (usec / 50); i++)
143 udelay(50);
144
145 if (usec % 50)
146 udelay(usec % 50);
147 }
148
149 void RTMP_GetCurrentSystemTime(LARGE_INTEGER *time)
150 {
151 time->u.LowPart = jiffies;
152 }
153
154 /* pAd MUST allow to be NULL */
155 int os_alloc_mem(struct rt_rtmp_adapter *pAd, u8 ** mem, unsigned long size)
156 {
157 *mem = kmalloc(size, GFP_ATOMIC);
158 if (*mem)
159 return NDIS_STATUS_SUCCESS;
160 else
161 return NDIS_STATUS_FAILURE;
162 }
163
164 /* pAd MUST allow to be NULL */
165 int os_free_mem(struct rt_rtmp_adapter *pAd, void *mem)
166 {
167
168 ASSERT(mem);
169 kfree(mem);
170 return NDIS_STATUS_SUCCESS;
171 }
172
173 void *RtmpOSNetPktAlloc(struct rt_rtmp_adapter *pAd, IN int size)
174 {
175 struct sk_buff *skb;
176 /* Add 2 more bytes for ip header alignment */
177 skb = dev_alloc_skb(size + 2);
178
179 return (void *)skb;
180 }
181
182 void *RTMP_AllocateFragPacketBuffer(struct rt_rtmp_adapter *pAd,
183 unsigned long Length)
184 {
185 struct sk_buff *pkt;
186
187 pkt = dev_alloc_skb(Length);
188
189 if (pkt == NULL) {
190 DBGPRINT(RT_DEBUG_ERROR,
191 ("can't allocate frag rx %ld size packet\n", Length));
192 }
193
194 if (pkt) {
195 RTMP_SET_PACKET_SOURCE(OSPKT_TO_RTPKT(pkt), PKTSRC_NDIS);
196 }
197
198 return (void *)pkt;
199 }
200
201 void *RTMP_AllocateTxPacketBuffer(struct rt_rtmp_adapter *pAd,
202 unsigned long Length,
203 IN BOOLEAN Cached,
204 void **VirtualAddress)
205 {
206 struct sk_buff *pkt;
207
208 pkt = dev_alloc_skb(Length);
209
210 if (pkt == NULL) {
211 DBGPRINT(RT_DEBUG_ERROR,
212 ("can't allocate tx %ld size packet\n", Length));
213 }
214
215 if (pkt) {
216 RTMP_SET_PACKET_SOURCE(OSPKT_TO_RTPKT(pkt), PKTSRC_NDIS);
217 *VirtualAddress = (void *)pkt->data;
218 } else {
219 *VirtualAddress = (void *)NULL;
220 }
221
222 return (void *)pkt;
223 }
224
225 void build_tx_packet(struct rt_rtmp_adapter *pAd,
226 void *pPacket,
227 u8 *pFrame, unsigned long FrameLen)
228 {
229
230 struct sk_buff *pTxPkt;
231
232 ASSERT(pPacket);
233 pTxPkt = RTPKT_TO_OSPKT(pPacket);
234
235 NdisMoveMemory(skb_put(pTxPkt, FrameLen), pFrame, FrameLen);
236 }
237
238 void RTMPFreeAdapter(struct rt_rtmp_adapter *pAd)
239 {
240 struct os_cookie *os_cookie;
241 int index;
242
243 os_cookie = (struct os_cookie *)pAd->OS_Cookie;
244
245 if (pAd->BeaconBuf)
246 kfree(pAd->BeaconBuf);
247
248 NdisFreeSpinLock(&pAd->MgmtRingLock);
249
250 #ifdef RTMP_MAC_PCI
251 NdisFreeSpinLock(&pAd->RxRingLock);
252 #ifdef RT3090
253 NdisFreeSpinLock(&pAd->McuCmdLock);
254 #endif /* RT3090 // */
255 #endif /* RTMP_MAC_PCI // */
256
257 for (index = 0; index < NUM_OF_TX_RING; index++) {
258 NdisFreeSpinLock(&pAd->TxSwQueueLock[index]);
259 NdisFreeSpinLock(&pAd->DeQueueLock[index]);
260 pAd->DeQueueRunning[index] = FALSE;
261 }
262
263 NdisFreeSpinLock(&pAd->irq_lock);
264
265 release_firmware(pAd->firmware);
266
267 vfree(pAd); /* pci_free_consistent(os_cookie->pci_dev,sizeof(struct rt_rtmp_adapter),pAd,os_cookie->pAd_pa); */
268 if (os_cookie)
269 kfree(os_cookie);
270 }
271
272 BOOLEAN OS_Need_Clone_Packet(void)
273 {
274 return FALSE;
275 }
276
277 /*
278 ========================================================================
279
280 Routine Description:
281 clone an input NDIS PACKET to another one. The new internally created NDIS PACKET
282 must have only one NDIS BUFFER
283 return - byte copied. 0 means can't create NDIS PACKET
284 NOTE: internally created char should be destroyed by RTMPFreeNdisPacket
285
286 Arguments:
287 pAd Pointer to our adapter
288 pInsAMSDUHdr EWC A-MSDU format has extra 14-bytes header. if TRUE, insert this 14-byte hdr in front of MSDU.
289 *pSrcTotalLen return total packet length. This lenght is calculated with 802.3 format packet.
290
291 Return Value:
292 NDIS_STATUS_SUCCESS
293 NDIS_STATUS_FAILURE
294
295 Note:
296
297 ========================================================================
298 */
299 int RTMPCloneNdisPacket(struct rt_rtmp_adapter *pAd,
300 IN BOOLEAN pInsAMSDUHdr,
301 void *pInPacket,
302 void **ppOutPacket)
303 {
304
305 struct sk_buff *pkt;
306
307 ASSERT(pInPacket);
308 ASSERT(ppOutPacket);
309
310 /* 1. Allocate a packet */
311 pkt = dev_alloc_skb(2048);
312
313 if (pkt == NULL) {
314 return NDIS_STATUS_FAILURE;
315 }
316
317 skb_put(pkt, GET_OS_PKT_LEN(pInPacket));
318 NdisMoveMemory(pkt->data, GET_OS_PKT_DATAPTR(pInPacket),
319 GET_OS_PKT_LEN(pInPacket));
320 *ppOutPacket = OSPKT_TO_RTPKT(pkt);
321
322 RTMP_SET_PACKET_SOURCE(OSPKT_TO_RTPKT(pkt), PKTSRC_NDIS);
323
324 printk("###Clone###\n");
325
326 return NDIS_STATUS_SUCCESS;
327 }
328
329 /* the allocated NDIS PACKET must be freed via RTMPFreeNdisPacket() */
330 int RTMPAllocateNdisPacket(struct rt_rtmp_adapter *pAd,
331 void **ppPacket,
332 u8 *pHeader,
333 u32 HeaderLen,
334 u8 *pData, u32 DataLen)
335 {
336 void *pPacket;
337 ASSERT(pData);
338 ASSERT(DataLen);
339
340 /* 1. Allocate a packet */
341 pPacket =
342 (void **) dev_alloc_skb(HeaderLen + DataLen +
343 RTMP_PKT_TAIL_PADDING);
344 if (pPacket == NULL) {
345 *ppPacket = NULL;
346 #ifdef DEBUG
347 printk("RTMPAllocateNdisPacket Fail\n");
348 #endif
349 return NDIS_STATUS_FAILURE;
350 }
351 /* 2. clone the frame content */
352 if (HeaderLen > 0)
353 NdisMoveMemory(GET_OS_PKT_DATAPTR(pPacket), pHeader, HeaderLen);
354 if (DataLen > 0)
355 NdisMoveMemory(GET_OS_PKT_DATAPTR(pPacket) + HeaderLen, pData,
356 DataLen);
357
358 /* 3. update length of packet */
359 skb_put(GET_OS_PKT_TYPE(pPacket), HeaderLen + DataLen);
360
361 RTMP_SET_PACKET_SOURCE(pPacket, PKTSRC_NDIS);
362 /* printk("%s : pPacket = %p, len = %d\n", __func__, pPacket, GET_OS_PKT_LEN(pPacket)); */
363 *ppPacket = pPacket;
364 return NDIS_STATUS_SUCCESS;
365 }
366
367 /*
368 ========================================================================
369 Description:
370 This routine frees a miniport internally allocated char and its
371 corresponding NDIS_BUFFER and allocated memory.
372 ========================================================================
373 */
374 void RTMPFreeNdisPacket(struct rt_rtmp_adapter *pAd, void *pPacket)
375 {
376 dev_kfree_skb_any(RTPKT_TO_OSPKT(pPacket));
377 }
378
379 /* IRQL = DISPATCH_LEVEL */
380 /* NOTE: we do have an assumption here, that Byte0 and Byte1 always reasid at the same */
381 /* scatter gather buffer */
382 int Sniff2BytesFromNdisBuffer(char *pFirstBuffer,
383 u8 DesiredOffset,
384 u8 *pByte0, u8 *pByte1)
385 {
386 *pByte0 = *(u8 *)(pFirstBuffer + DesiredOffset);
387 *pByte1 = *(u8 *)(pFirstBuffer + DesiredOffset + 1);
388
389 return NDIS_STATUS_SUCCESS;
390 }
391
392 void RTMP_QueryPacketInfo(void *pPacket,
393 struct rt_packet_info *pPacketInfo,
394 u8 **pSrcBufVA, u32 * pSrcBufLen)
395 {
396 pPacketInfo->BufferCount = 1;
397 pPacketInfo->pFirstBuffer = (char *)GET_OS_PKT_DATAPTR(pPacket);
398 pPacketInfo->PhysicalBufferCount = 1;
399 pPacketInfo->TotalPacketLength = GET_OS_PKT_LEN(pPacket);
400
401 *pSrcBufVA = GET_OS_PKT_DATAPTR(pPacket);
402 *pSrcBufLen = GET_OS_PKT_LEN(pPacket);
403 }
404
405 void RTMP_QueryNextPacketInfo(void **ppPacket,
406 struct rt_packet_info *pPacketInfo,
407 u8 **pSrcBufVA, u32 * pSrcBufLen)
408 {
409 void *pPacket = NULL;
410
411 if (*ppPacket)
412 pPacket = GET_OS_PKT_NEXT(*ppPacket);
413
414 if (pPacket) {
415 pPacketInfo->BufferCount = 1;
416 pPacketInfo->pFirstBuffer =
417 (char *)GET_OS_PKT_DATAPTR(pPacket);
418 pPacketInfo->PhysicalBufferCount = 1;
419 pPacketInfo->TotalPacketLength = GET_OS_PKT_LEN(pPacket);
420
421 *pSrcBufVA = GET_OS_PKT_DATAPTR(pPacket);
422 *pSrcBufLen = GET_OS_PKT_LEN(pPacket);
423 *ppPacket = GET_OS_PKT_NEXT(pPacket);
424 } else {
425 pPacketInfo->BufferCount = 0;
426 pPacketInfo->pFirstBuffer = NULL;
427 pPacketInfo->PhysicalBufferCount = 0;
428 pPacketInfo->TotalPacketLength = 0;
429
430 *pSrcBufVA = NULL;
431 *pSrcBufLen = 0;
432 *ppPacket = NULL;
433 }
434 }
435
436 void *DuplicatePacket(struct rt_rtmp_adapter *pAd,
437 void *pPacket, u8 FromWhichBSSID)
438 {
439 struct sk_buff *skb;
440 void *pRetPacket = NULL;
441 u16 DataSize;
442 u8 *pData;
443
444 DataSize = (u16)GET_OS_PKT_LEN(pPacket);
445 pData = (u8 *)GET_OS_PKT_DATAPTR(pPacket);
446
447 skb = skb_clone(RTPKT_TO_OSPKT(pPacket), MEM_ALLOC_FLAG);
448 if (skb) {
449 skb->dev = get_netdev_from_bssid(pAd, FromWhichBSSID);
450 pRetPacket = OSPKT_TO_RTPKT(skb);
451 }
452
453 return pRetPacket;
454
455 }
456
457 void *duplicate_pkt(struct rt_rtmp_adapter *pAd,
458 u8 *pHeader802_3,
459 u32 HdrLen,
460 u8 *pData,
461 unsigned long DataSize, u8 FromWhichBSSID)
462 {
463 struct sk_buff *skb;
464 void *pPacket = NULL;
465
466 skb = __dev_alloc_skb(HdrLen + DataSize + 2, MEM_ALLOC_FLAG);
467 if (skb != NULL) {
468 skb_reserve(skb, 2);
469 NdisMoveMemory(skb_tail_pointer(skb), pHeader802_3, HdrLen);
470 skb_put(skb, HdrLen);
471 NdisMoveMemory(skb_tail_pointer(skb), pData, DataSize);
472 skb_put(skb, DataSize);
473 skb->dev = get_netdev_from_bssid(pAd, FromWhichBSSID);
474 pPacket = OSPKT_TO_RTPKT(skb);
475 }
476
477 return pPacket;
478 }
479
480 #define TKIP_TX_MIC_SIZE 8
481 void *duplicate_pkt_with_TKIP_MIC(struct rt_rtmp_adapter *pAd,
482 void *pPacket)
483 {
484 struct sk_buff *skb, *newskb;
485
486 skb = RTPKT_TO_OSPKT(pPacket);
487 if (skb_tailroom(skb) < TKIP_TX_MIC_SIZE) {
488 /* alloc a new skb and copy the packet */
489 newskb =
490 skb_copy_expand(skb, skb_headroom(skb), TKIP_TX_MIC_SIZE,
491 GFP_ATOMIC);
492 dev_kfree_skb_any(skb);
493 if (newskb == NULL) {
494 DBGPRINT(RT_DEBUG_ERROR,
495 ("Extend Tx.MIC for packet failed!, dropping packet!\n"));
496 return NULL;
497 }
498 skb = newskb;
499 }
500
501 return OSPKT_TO_RTPKT(skb);
502 }
503
504 void *ClonePacket(struct rt_rtmp_adapter *pAd,
505 void *pPacket,
506 u8 *pData, unsigned long DataSize)
507 {
508 struct sk_buff *pRxPkt;
509 struct sk_buff *pClonedPkt;
510
511 ASSERT(pPacket);
512 pRxPkt = RTPKT_TO_OSPKT(pPacket);
513
514 /* clone the packet */
515 pClonedPkt = skb_clone(pRxPkt, MEM_ALLOC_FLAG);
516
517 if (pClonedPkt) {
518 /* set the correct dataptr and data len */
519 pClonedPkt->dev = pRxPkt->dev;
520 pClonedPkt->data = pData;
521 pClonedPkt->len = DataSize;
522 skb_set_tail_pointer(pClonedPkt, DataSize)
523 ASSERT(DataSize < 1530);
524 }
525 return pClonedPkt;
526 }
527
528 /* */
529 /* change OS packet DataPtr and DataLen */
530 /* */
531 void update_os_packet_info(struct rt_rtmp_adapter *pAd,
532 struct rt_rx_blk *pRxBlk, u8 FromWhichBSSID)
533 {
534 struct sk_buff *pOSPkt;
535
536 ASSERT(pRxBlk->pRxPacket);
537 pOSPkt = RTPKT_TO_OSPKT(pRxBlk->pRxPacket);
538
539 pOSPkt->dev = get_netdev_from_bssid(pAd, FromWhichBSSID);
540 pOSPkt->data = pRxBlk->pData;
541 pOSPkt->len = pRxBlk->DataSize;
542 skb_set_tail_pointer(pOSPkt, pOSPkt->len);
543 }
544
545 void wlan_802_11_to_802_3_packet(struct rt_rtmp_adapter *pAd,
546 struct rt_rx_blk *pRxBlk,
547 u8 *pHeader802_3,
548 u8 FromWhichBSSID)
549 {
550 struct sk_buff *pOSPkt;
551
552 ASSERT(pRxBlk->pRxPacket);
553 ASSERT(pHeader802_3);
554
555 pOSPkt = RTPKT_TO_OSPKT(pRxBlk->pRxPacket);
556
557 pOSPkt->dev = get_netdev_from_bssid(pAd, FromWhichBSSID);
558 pOSPkt->data = pRxBlk->pData;
559 pOSPkt->len = pRxBlk->DataSize;
560 skb_set_tail_pointer(pOSPkt, pOSPkt->len);
561
562 /* */
563 /* copy 802.3 header */
564 /* */
565 /* */
566
567 NdisMoveMemory(skb_push(pOSPkt, LENGTH_802_3), pHeader802_3,
568 LENGTH_802_3);
569 }
570
571 void announce_802_3_packet(struct rt_rtmp_adapter *pAd, void *pPacket)
572 {
573
574 struct sk_buff *pRxPkt;
575
576 ASSERT(pPacket);
577
578 pRxPkt = RTPKT_TO_OSPKT(pPacket);
579
580 /* Push up the protocol stack */
581 pRxPkt->protocol = eth_type_trans(pRxPkt, pRxPkt->dev);
582
583 netif_rx(pRxPkt);
584 }
585
586 struct rt_rtmp_sg_list *
587 rt_get_sg_list_from_packet(void *pPacket, struct rt_rtmp_sg_list *sg)
588 {
589 sg->NumberOfElements = 1;
590 sg->Elements[0].Address = GET_OS_PKT_DATAPTR(pPacket);
591 sg->Elements[0].Length = GET_OS_PKT_LEN(pPacket);
592 return sg;
593 }
594
595 void hex_dump(char *str, unsigned char *pSrcBufVA, unsigned int SrcBufLen)
596 {
597 unsigned char *pt;
598 int x;
599
600 if (RTDebugLevel < RT_DEBUG_TRACE)
601 return;
602
603 pt = pSrcBufVA;
604 printk("%s: %p, len = %d\n", str, pSrcBufVA, SrcBufLen);
605 for (x = 0; x < SrcBufLen; x++) {
606 if (x % 16 == 0)
607 printk("0x%04x : ", x);
608 printk("%02x ", ((unsigned char)pt[x]));
609 if (x % 16 == 15)
610 printk("\n");
611 }
612 printk("\n");
613 }
614
615 /*
616 ========================================================================
617
618 Routine Description:
619 Send log message through wireless event
620
621 Support standard iw_event with IWEVCUSTOM. It is used below.
622
623 iwreq_data.data.flags is used to store event_flag that is defined by user.
624 iwreq_data.data.length is the length of the event log.
625
626 The format of the event log is composed of the entry's MAC address and
627 the desired log message (refer to pWirelessEventText).
628
629 ex: 11:22:33:44:55:66 has associated successfully
630
631 p.s. The requirement of Wireless Extension is v15 or newer.
632
633 ========================================================================
634 */
635 void RTMPSendWirelessEvent(struct rt_rtmp_adapter *pAd,
636 u16 Event_flag,
637 u8 *pAddr, u8 BssIdx, char Rssi)
638 {
639
640 /*union iwreq_data wrqu; */
641 char *pBuf = NULL, *pBufPtr = NULL;
642 u16 event, type, BufLen;
643 u8 event_table_len = 0;
644
645 type = Event_flag & 0xFF00;
646 event = Event_flag & 0x00FF;
647
648 switch (type) {
649 case IW_SYS_EVENT_FLAG_START:
650 event_table_len = IW_SYS_EVENT_TYPE_NUM;
651 break;
652
653 case IW_SPOOF_EVENT_FLAG_START:
654 event_table_len = IW_SPOOF_EVENT_TYPE_NUM;
655 break;
656
657 case IW_FLOOD_EVENT_FLAG_START:
658 event_table_len = IW_FLOOD_EVENT_TYPE_NUM;
659 break;
660 }
661
662 if (event_table_len == 0) {
663 DBGPRINT(RT_DEBUG_ERROR,
664 ("%s : The type(%0x02x) is not valid.\n", __func__,
665 type));
666 return;
667 }
668
669 if (event >= event_table_len) {
670 DBGPRINT(RT_DEBUG_ERROR,
671 ("%s : The event(%0x02x) is not valid.\n", __func__,
672 event));
673 return;
674 }
675 /*Allocate memory and copy the msg. */
676 pBuf = kmalloc(IW_CUSTOM_MAX_LEN, GFP_ATOMIC);
677 if (pBuf != NULL) {
678 /*Prepare the payload */
679 memset(pBuf, 0, IW_CUSTOM_MAX_LEN);
680
681 pBufPtr = pBuf;
682
683 if (pAddr)
684 pBufPtr +=
685 sprintf(pBufPtr, "(RT2860) STA(%pM) ", pAddr);
686 else if (BssIdx < MAX_MBSSID_NUM)
687 pBufPtr +=
688 sprintf(pBufPtr, "(RT2860) BSS(wlan%d) ", BssIdx);
689 else
690 pBufPtr += sprintf(pBufPtr, "(RT2860) ");
691
692 if (type == IW_SYS_EVENT_FLAG_START)
693 pBufPtr +=
694 sprintf(pBufPtr, "%s",
695 pWirelessSysEventText[event]);
696 else if (type == IW_SPOOF_EVENT_FLAG_START)
697 pBufPtr +=
698 sprintf(pBufPtr, "%s (RSSI=%d)",
699 pWirelessSpoofEventText[event], Rssi);
700 else if (type == IW_FLOOD_EVENT_FLAG_START)
701 pBufPtr +=
702 sprintf(pBufPtr, "%s",
703 pWirelessFloodEventText[event]);
704 else
705 pBufPtr += sprintf(pBufPtr, "%s", "unknown event");
706
707 pBufPtr[pBufPtr - pBuf] = '\0';
708 BufLen = pBufPtr - pBuf;
709
710 RtmpOSWrielessEventSend(pAd, IWEVCUSTOM, Event_flag, NULL,
711 (u8 *)pBuf, BufLen);
712 /*DBGPRINT(RT_DEBUG_TRACE, ("%s : %s\n", __func__, pBuf)); */
713
714 kfree(pBuf);
715 } else
716 DBGPRINT(RT_DEBUG_ERROR,
717 ("%s : Can't allocate memory for wireless event.\n",
718 __func__));
719 }
720
721 void send_monitor_packets(struct rt_rtmp_adapter *pAd, struct rt_rx_blk *pRxBlk)
722 {
723 struct sk_buff *pOSPkt;
724 struct rt_wlan_ng_prism2_header *ph;
725 int rate_index = 0;
726 u16 header_len = 0;
727 u8 temp_header[40] = { 0 };
728
729 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, /* Last 38 */
730 54, 108, 162, 216, 324, 432, 486, 540, 14, 29, 43, 57, 87, 115,
731 130, 144, 29, 59, 87, 115, 173, 230, 260, 288, 30, 60, 90,
732 120, 180, 240, 270, 300, 60, 120, 180, 240, 360, 480, 540,
733 600, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
734 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
735 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
736 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
737 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
738 72, 73, 74, 75, 76, 77, 78, 79, 80
739 };
740
741 ASSERT(pRxBlk->pRxPacket);
742 if (pRxBlk->DataSize < 10) {
743 DBGPRINT(RT_DEBUG_ERROR,
744 ("%s : Size is too small! (%d)\n", __func__,
745 pRxBlk->DataSize));
746 goto err_free_sk_buff;
747 }
748
749 if (pRxBlk->DataSize + sizeof(struct rt_wlan_ng_prism2_header) >
750 RX_BUFFER_AGGRESIZE) {
751 DBGPRINT(RT_DEBUG_ERROR,
752 ("%s : Size is too large! (%zu)\n", __func__,
753 pRxBlk->DataSize + sizeof(struct rt_wlan_ng_prism2_header)));
754 goto err_free_sk_buff;
755 }
756
757 pOSPkt = RTPKT_TO_OSPKT(pRxBlk->pRxPacket);
758 pOSPkt->dev = get_netdev_from_bssid(pAd, BSS0);
759 if (pRxBlk->pHeader->FC.Type == BTYPE_DATA) {
760 pRxBlk->DataSize -= LENGTH_802_11;
761 if ((pRxBlk->pHeader->FC.ToDs == 1) &&
762 (pRxBlk->pHeader->FC.FrDs == 1))
763 header_len = LENGTH_802_11_WITH_ADDR4;
764 else
765 header_len = LENGTH_802_11;
766
767 /* QOS */
768 if (pRxBlk->pHeader->FC.SubType & 0x08) {
769 header_len += 2;
770 /* Data skip QOS control field */
771 pRxBlk->DataSize -= 2;
772 }
773 /* Order bit: A-Ralink or HTC+ */
774 if (pRxBlk->pHeader->FC.Order) {
775 header_len += 4;
776 /* Data skip HTC control field */
777 pRxBlk->DataSize -= 4;
778 }
779 /* Copy Header */
780 if (header_len <= 40)
781 NdisMoveMemory(temp_header, pRxBlk->pData, header_len);
782
783 /* skip HW padding */
784 if (pRxBlk->RxD.L2PAD)
785 pRxBlk->pData += (header_len + 2);
786 else
787 pRxBlk->pData += header_len;
788 } /*end if */
789
790 if (pRxBlk->DataSize < pOSPkt->len) {
791 skb_trim(pOSPkt, pRxBlk->DataSize);
792 } else {
793 skb_put(pOSPkt, (pRxBlk->DataSize - pOSPkt->len));
794 } /*end if */
795
796 if ((pRxBlk->pData - pOSPkt->data) > 0) {
797 skb_put(pOSPkt, (pRxBlk->pData - pOSPkt->data));
798 skb_pull(pOSPkt, (pRxBlk->pData - pOSPkt->data));
799 } /*end if */
800
801 if (skb_headroom(pOSPkt) < (sizeof(struct rt_wlan_ng_prism2_header) + header_len)) {
802 if (pskb_expand_head
803 (pOSPkt, (sizeof(struct rt_wlan_ng_prism2_header) + header_len), 0,
804 GFP_ATOMIC)) {
805 DBGPRINT(RT_DEBUG_ERROR,
806 ("%s : Reallocate header size of sk_buff fail!\n",
807 __func__));
808 goto err_free_sk_buff;
809 } /*end if */
810 } /*end if */
811
812 if (header_len > 0)
813 NdisMoveMemory(skb_push(pOSPkt, header_len), temp_header,
814 header_len);
815
816 ph = (struct rt_wlan_ng_prism2_header *)skb_push(pOSPkt,
817 sizeof(struct rt_wlan_ng_prism2_header));
818 NdisZeroMemory(ph, sizeof(struct rt_wlan_ng_prism2_header));
819
820 ph->msgcode = DIDmsg_lnxind_wlansniffrm;
821 ph->msglen = sizeof(struct rt_wlan_ng_prism2_header);
822 strcpy((char *)ph->devname, (char *)pAd->net_dev->name);
823
824 ph->hosttime.did = DIDmsg_lnxind_wlansniffrm_hosttime;
825 ph->hosttime.status = 0;
826 ph->hosttime.len = 4;
827 ph->hosttime.data = jiffies;
828
829 ph->mactime.did = DIDmsg_lnxind_wlansniffrm_mactime;
830 ph->mactime.status = 0;
831 ph->mactime.len = 0;
832 ph->mactime.data = 0;
833
834 ph->istx.did = DIDmsg_lnxind_wlansniffrm_istx;
835 ph->istx.status = 0;
836 ph->istx.len = 0;
837 ph->istx.data = 0;
838
839 ph->channel.did = DIDmsg_lnxind_wlansniffrm_channel;
840 ph->channel.status = 0;
841 ph->channel.len = 4;
842
843 ph->channel.data = (u_int32_t) pAd->CommonCfg.Channel;
844
845 ph->rssi.did = DIDmsg_lnxind_wlansniffrm_rssi;
846 ph->rssi.status = 0;
847 ph->rssi.len = 4;
848 ph->rssi.data =
849 (u_int32_t) RTMPMaxRssi(pAd,
850 ConvertToRssi(pAd, pRxBlk->pRxWI->RSSI0,
851 RSSI_0), ConvertToRssi(pAd,
852 pRxBlk->
853 pRxWI->
854 RSSI1,
855 RSSI_1),
856 ConvertToRssi(pAd, pRxBlk->pRxWI->RSSI2,
857 RSSI_2));
858
859 ph->signal.did = DIDmsg_lnxind_wlansniffrm_signal;
860 ph->signal.status = 0;
861 ph->signal.len = 4;
862 ph->signal.data = 0; /*rssi + noise; */
863
864 ph->noise.did = DIDmsg_lnxind_wlansniffrm_noise;
865 ph->noise.status = 0;
866 ph->noise.len = 4;
867 ph->noise.data = 0;
868
869 if (pRxBlk->pRxWI->PHYMODE >= MODE_HTMIX) {
870 rate_index =
871 16 + ((u8)pRxBlk->pRxWI->BW * 16) +
872 ((u8)pRxBlk->pRxWI->ShortGI * 32) +
873 ((u8)pRxBlk->pRxWI->MCS);
874 } else if (pRxBlk->pRxWI->PHYMODE == MODE_OFDM)
875 rate_index = (u8)(pRxBlk->pRxWI->MCS) + 4;
876 else
877 rate_index = (u8)(pRxBlk->pRxWI->MCS);
878 if (rate_index < 0)
879 rate_index = 0;
880 if (rate_index > 255)
881 rate_index = 255;
882
883 ph->rate.did = DIDmsg_lnxind_wlansniffrm_rate;
884 ph->rate.status = 0;
885 ph->rate.len = 4;
886 ph->rate.data = ralinkrate[rate_index];
887
888 ph->frmlen.did = DIDmsg_lnxind_wlansniffrm_frmlen;
889 ph->frmlen.status = 0;
890 ph->frmlen.len = 4;
891 ph->frmlen.data = (u_int32_t) pRxBlk->DataSize;
892
893 pOSPkt->pkt_type = PACKET_OTHERHOST;
894 pOSPkt->protocol = eth_type_trans(pOSPkt, pOSPkt->dev);
895 pOSPkt->ip_summed = CHECKSUM_NONE;
896 netif_rx(pOSPkt);
897
898 return;
899
900 err_free_sk_buff:
901 RELEASE_NDIS_PACKET(pAd, pRxBlk->pRxPacket, NDIS_STATUS_FAILURE);
902 return;
903
904 }
905
906 /*******************************************************************************
907
908 Device IRQ related functions.
909
910 *******************************************************************************/
911 int RtmpOSIRQRequest(struct net_device *pNetDev)
912 {
913 #ifdef RTMP_PCI_SUPPORT
914 struct net_device *net_dev = pNetDev;
915 struct rt_rtmp_adapter *pAd = NULL;
916 int retval = 0;
917
918 GET_PAD_FROM_NET_DEV(pAd, pNetDev);
919
920 ASSERT(pAd);
921
922 if (pAd->infType == RTMP_DEV_INF_PCI) {
923 struct os_cookie *_pObj = (struct os_cookie *)(pAd->OS_Cookie);
924 RTMP_MSI_ENABLE(pAd);
925 retval =
926 request_irq(_pObj->pci_dev->irq, rt2860_interrupt, SA_SHIRQ,
927 (net_dev)->name, (net_dev));
928 if (retval != 0)
929 printk("RT2860: request_irq ERROR(%d)\n", retval);
930 }
931
932 return retval;
933 #else
934 return 0;
935 #endif
936 }
937
938 int RtmpOSIRQRelease(struct net_device *pNetDev)
939 {
940 struct net_device *net_dev = pNetDev;
941 struct rt_rtmp_adapter *pAd = NULL;
942
943 GET_PAD_FROM_NET_DEV(pAd, net_dev);
944
945 ASSERT(pAd);
946
947 #ifdef RTMP_PCI_SUPPORT
948 if (pAd->infType == RTMP_DEV_INF_PCI) {
949 struct os_cookie *pObj = (struct os_cookie *)(pAd->OS_Cookie);
950 synchronize_irq(pObj->pci_dev->irq);
951 free_irq(pObj->pci_dev->irq, (net_dev));
952 RTMP_MSI_DISABLE(pAd);
953 }
954 #endif /* RTMP_PCI_SUPPORT // */
955
956 return 0;
957 }
958
959 /*******************************************************************************
960
961 File open/close related functions.
962
963 *******************************************************************************/
964 struct file *RtmpOSFileOpen(char *pPath, int flag, int mode)
965 {
966 struct file *filePtr;
967
968 filePtr = filp_open(pPath, flag, 0);
969 if (IS_ERR(filePtr)) {
970 DBGPRINT(RT_DEBUG_ERROR,
971 ("%s(): Error %ld opening %s\n", __func__,
972 -PTR_ERR(filePtr), pPath));
973 }
974
975 return (struct file *)filePtr;
976 }
977
978 int RtmpOSFileClose(struct file *osfd)
979 {
980 filp_close(osfd, NULL);
981 return 0;
982 }
983
984 void RtmpOSFileSeek(struct file *osfd, int offset)
985 {
986 osfd->f_pos = offset;
987 }
988
989 int RtmpOSFileRead(struct file *osfd, char *pDataPtr, int readLen)
990 {
991 /* The object must have a read method */
992 if (osfd->f_op && osfd->f_op->read) {
993 return osfd->f_op->read(osfd, pDataPtr, readLen, &osfd->f_pos);
994 } else {
995 DBGPRINT(RT_DEBUG_ERROR, ("no file read method\n"));
996 return -1;
997 }
998 }
999
1000 int RtmpOSFileWrite(struct file *osfd, char *pDataPtr, int writeLen)
1001 {
1002 return osfd->f_op->write(osfd, pDataPtr, (size_t) writeLen,
1003 &osfd->f_pos);
1004 }
1005
1006 /*******************************************************************************
1007
1008 Task create/management/kill related functions.
1009
1010 *******************************************************************************/
1011 int RtmpOSTaskKill(struct rt_rtmp_os_task *pTask)
1012 {
1013 struct rt_rtmp_adapter *pAd;
1014 int ret = NDIS_STATUS_FAILURE;
1015
1016 pAd = pTask->priv;
1017
1018 #ifdef KTHREAD_SUPPORT
1019 if (pTask->kthread_task) {
1020 kthread_stop(pTask->kthread_task);
1021 ret = NDIS_STATUS_SUCCESS;
1022 }
1023 #else
1024 CHECK_PID_LEGALITY(pTask->taskPID) {
1025 printk("Terminate the task(%s) with pid(%d)!\n",
1026 pTask->taskName, GET_PID_NUMBER(pTask->taskPID));
1027 mb();
1028 pTask->task_killed = 1;
1029 mb();
1030 ret = KILL_THREAD_PID(pTask->taskPID, SIGTERM, 1);
1031 if (ret) {
1032 printk(KERN_WARNING
1033 "kill task(%s) with pid(%d) failed(retVal=%d)!\n",
1034 pTask->taskName, GET_PID_NUMBER(pTask->taskPID),
1035 ret);
1036 } else {
1037 wait_for_completion(&pTask->taskComplete);
1038 pTask->taskPID = THREAD_PID_INIT_VALUE;
1039 pTask->task_killed = 0;
1040 ret = NDIS_STATUS_SUCCESS;
1041 }
1042 }
1043 #endif
1044
1045 return ret;
1046
1047 }
1048
1049 int RtmpOSTaskNotifyToExit(struct rt_rtmp_os_task *pTask)
1050 {
1051
1052 #ifndef KTHREAD_SUPPORT
1053 complete_and_exit(&pTask->taskComplete, 0);
1054 #endif
1055
1056 return 0;
1057 }
1058
1059 void RtmpOSTaskCustomize(struct rt_rtmp_os_task *pTask)
1060 {
1061
1062 #ifndef KTHREAD_SUPPORT
1063
1064 daemonize((char *)&pTask->taskName[0] /*"%s",pAd->net_dev->name */);
1065
1066 allow_signal(SIGTERM);
1067 allow_signal(SIGKILL);
1068 current->flags |= PF_NOFREEZE;
1069
1070 /* signal that we've started the thread */
1071 complete(&pTask->taskComplete);
1072
1073 #endif
1074 }
1075
1076 int RtmpOSTaskAttach(struct rt_rtmp_os_task *pTask,
1077 IN int (*fn) (void *), IN void *arg)
1078 {
1079 int status = NDIS_STATUS_SUCCESS;
1080
1081 #ifdef KTHREAD_SUPPORT
1082 pTask->task_killed = 0;
1083 pTask->kthread_task = NULL;
1084 pTask->kthread_task = kthread_run(fn, arg, pTask->taskName);
1085 if (IS_ERR(pTask->kthread_task))
1086 status = NDIS_STATUS_FAILURE;
1087 #else
1088 pid_number = kernel_thread(fn, arg, RTMP_OS_MGMT_TASK_FLAGS);
1089 if (pid_number < 0) {
1090 DBGPRINT(RT_DEBUG_ERROR,
1091 ("Attach task(%s) failed!\n", pTask->taskName));
1092 status = NDIS_STATUS_FAILURE;
1093 } else {
1094 pTask->taskPID = GET_PID(pid_number);
1095
1096 /* Wait for the thread to start */
1097 wait_for_completion(&pTask->taskComplete);
1098 status = NDIS_STATUS_SUCCESS;
1099 }
1100 #endif
1101 return status;
1102 }
1103
1104 int RtmpOSTaskInit(struct rt_rtmp_os_task *pTask,
1105 char *pTaskName, void * pPriv)
1106 {
1107 int len;
1108
1109 ASSERT(pTask);
1110
1111 #ifndef KTHREAD_SUPPORT
1112 NdisZeroMemory((u8 *)(pTask), sizeof(struct rt_rtmp_os_task));
1113 #endif
1114
1115 len = strlen(pTaskName);
1116 len =
1117 len >
1118 (RTMP_OS_TASK_NAME_LEN - 1) ? (RTMP_OS_TASK_NAME_LEN - 1) : len;
1119 NdisMoveMemory(&pTask->taskName[0], pTaskName, len);
1120 pTask->priv = pPriv;
1121
1122 #ifndef KTHREAD_SUPPORT
1123 RTMP_SEM_EVENT_INIT_LOCKED(&(pTask->taskSema));
1124 pTask->taskPID = THREAD_PID_INIT_VALUE;
1125
1126 init_completion(&pTask->taskComplete);
1127 #endif
1128
1129 return NDIS_STATUS_SUCCESS;
1130 }
1131
1132 void RTMP_IndicateMediaState(struct rt_rtmp_adapter *pAd)
1133 {
1134 if (pAd->CommonCfg.bWirelessEvent) {
1135 if (pAd->IndicateMediaState == NdisMediaStateConnected) {
1136 RTMPSendWirelessEvent(pAd, IW_STA_LINKUP_EVENT_FLAG,
1137 pAd->MacTab.Content[BSSID_WCID].
1138 Addr, BSS0, 0);
1139 } else {
1140 RTMPSendWirelessEvent(pAd, IW_STA_LINKDOWN_EVENT_FLAG,
1141 pAd->MacTab.Content[BSSID_WCID].
1142 Addr, BSS0, 0);
1143 }
1144 }
1145 }
1146
1147 int RtmpOSWrielessEventSend(struct rt_rtmp_adapter *pAd,
1148 u32 eventType,
1149 int flags,
1150 u8 *pSrcMac,
1151 u8 *pData, u32 dataLen)
1152 {
1153 union iwreq_data wrqu;
1154
1155 memset(&wrqu, 0, sizeof(wrqu));
1156
1157 if (flags > -1)
1158 wrqu.data.flags = flags;
1159
1160 if (pSrcMac)
1161 memcpy(wrqu.ap_addr.sa_data, pSrcMac, MAC_ADDR_LEN);
1162
1163 if ((pData != NULL) && (dataLen > 0))
1164 wrqu.data.length = dataLen;
1165
1166 wireless_send_event(pAd->net_dev, eventType, &wrqu, (char *)pData);
1167 return 0;
1168 }
1169
1170 int RtmpOSNetDevAddrSet(struct net_device *pNetDev, u8 *pMacAddr)
1171 {
1172 struct net_device *net_dev;
1173 struct rt_rtmp_adapter *pAd;
1174
1175 net_dev = pNetDev;
1176 GET_PAD_FROM_NET_DEV(pAd, net_dev);
1177
1178 /* work-around for SuSE, due to them having their own interface name management system. */
1179 {
1180 NdisZeroMemory(pAd->StaCfg.dev_name, 16);
1181 NdisMoveMemory(pAd->StaCfg.dev_name, net_dev->name,
1182 strlen(net_dev->name));
1183 }
1184
1185 NdisMoveMemory(net_dev->dev_addr, pMacAddr, 6);
1186
1187 return 0;
1188 }
1189
1190 /*
1191 * Assign the network dev name for created Ralink WiFi interface.
1192 */
1193 static int RtmpOSNetDevRequestName(struct rt_rtmp_adapter *pAd,
1194 struct net_device *dev,
1195 char *pPrefixStr, int devIdx)
1196 {
1197 struct net_device *existNetDev;
1198 char suffixName[IFNAMSIZ];
1199 char desiredName[IFNAMSIZ];
1200 int ifNameIdx, prefixLen, slotNameLen;
1201 int Status;
1202
1203 prefixLen = strlen(pPrefixStr);
1204 ASSERT((prefixLen < IFNAMSIZ));
1205
1206 for (ifNameIdx = devIdx; ifNameIdx < 32; ifNameIdx++) {
1207 memset(suffixName, 0, IFNAMSIZ);
1208 memset(desiredName, 0, IFNAMSIZ);
1209 strncpy(&desiredName[0], pPrefixStr, prefixLen);
1210
1211 sprintf(suffixName, "%d", ifNameIdx);
1212
1213 slotNameLen = strlen(suffixName);
1214 ASSERT(((slotNameLen + prefixLen) < IFNAMSIZ));
1215 strcat(desiredName, suffixName);
1216
1217 existNetDev = RtmpOSNetDevGetByName(dev, &desiredName[0]);
1218 if (existNetDev == NULL)
1219 break;
1220 else
1221 RtmpOSNetDeviceRefPut(existNetDev);
1222 }
1223
1224 if (ifNameIdx < 32) {
1225 strcpy(&dev->name[0], &desiredName[0]);
1226 Status = NDIS_STATUS_SUCCESS;
1227 } else {
1228 DBGPRINT(RT_DEBUG_ERROR,
1229 ("Cannot request DevName with preifx(%s) and in range(0~32) as suffix from OS!\n",
1230 pPrefixStr));
1231 Status = NDIS_STATUS_FAILURE;
1232 }
1233
1234 return Status;
1235 }
1236
1237 void RtmpOSNetDevClose(struct net_device *pNetDev)
1238 {
1239 dev_close(pNetDev);
1240 }
1241
1242 void RtmpOSNetDevFree(struct net_device *pNetDev)
1243 {
1244 ASSERT(pNetDev);
1245
1246 free_netdev(pNetDev);
1247 }
1248
1249 int RtmpOSNetDevAlloc(struct net_device **new_dev_p, u32 privDataSize)
1250 {
1251 /* assign it as null first. */
1252 *new_dev_p = NULL;
1253
1254 DBGPRINT(RT_DEBUG_TRACE,
1255 ("Allocate a net device with private data size=%d!\n",
1256 privDataSize));
1257 *new_dev_p = alloc_etherdev(privDataSize);
1258 if (*new_dev_p)
1259 return NDIS_STATUS_SUCCESS;
1260 else
1261 return NDIS_STATUS_FAILURE;
1262 }
1263
1264 struct net_device *RtmpOSNetDevGetByName(struct net_device *pNetDev, char *pDevName)
1265 {
1266 struct net_device *pTargetNetDev = NULL;
1267
1268 pTargetNetDev = dev_get_by_name(dev_net(pNetDev), pDevName);
1269
1270 return pTargetNetDev;
1271 }
1272
1273 void RtmpOSNetDeviceRefPut(struct net_device *pNetDev)
1274 {
1275 /*
1276 every time dev_get_by_name is called, and it has returned a valid struct
1277 net_device*, dev_put should be called afterwards, because otherwise the
1278 machine hangs when the device is unregistered (since dev->refcnt > 1).
1279 */
1280 if (pNetDev)
1281 dev_put(pNetDev);
1282 }
1283
1284 int RtmpOSNetDevDestory(struct rt_rtmp_adapter *pAd, struct net_device *pNetDev)
1285 {
1286
1287 /* TODO: Need to fix this */
1288 printk("WARNING: This function(%s) not implement yet!\n", __func__);
1289 return 0;
1290 }
1291
1292 void RtmpOSNetDevDetach(struct net_device *pNetDev)
1293 {
1294 unregister_netdev(pNetDev);
1295 }
1296
1297 int RtmpOSNetDevAttach(struct net_device *pNetDev,
1298 struct rt_rtmp_os_netdev_op_hook *pDevOpHook)
1299 {
1300 int ret, rtnl_locked = FALSE;
1301
1302 DBGPRINT(RT_DEBUG_TRACE, ("RtmpOSNetDevAttach()--->\n"));
1303 /* If we need hook some callback function to the net device structure, now do it. */
1304 if (pDevOpHook) {
1305 struct rt_rtmp_adapter *pAd = NULL;
1306
1307 GET_PAD_FROM_NET_DEV(pAd, pNetDev);
1308
1309 pNetDev->netdev_ops = pDevOpHook->netdev_ops;
1310
1311 /* OS specific flags, here we used to indicate if we are virtual interface */
1312 pNetDev->priv_flags = pDevOpHook->priv_flags;
1313
1314 if (pAd->OpMode == OPMODE_STA)
1315 pNetDev->wireless_handlers = &rt28xx_iw_handler_def;
1316
1317 /* copy the net device mac address to the net_device structure. */
1318 NdisMoveMemory(pNetDev->dev_addr, &pDevOpHook->devAddr[0],
1319 MAC_ADDR_LEN);
1320
1321 rtnl_locked = pDevOpHook->needProtcted;
1322 }
1323
1324 if (rtnl_locked)
1325 ret = register_netdevice(pNetDev);
1326 else
1327 ret = register_netdev(pNetDev);
1328
1329 DBGPRINT(RT_DEBUG_TRACE, ("<---RtmpOSNetDevAttach(), ret=%d\n", ret));
1330 if (ret == 0)
1331 return NDIS_STATUS_SUCCESS;
1332 else
1333 return NDIS_STATUS_FAILURE;
1334 }
1335
1336 struct net_device *RtmpOSNetDevCreate(struct rt_rtmp_adapter *pAd,
1337 int devType,
1338 int devNum,
1339 int privMemSize, char *pNamePrefix)
1340 {
1341 struct net_device *pNetDev = NULL;
1342 int status;
1343
1344 /* allocate a new network device */
1345 status = RtmpOSNetDevAlloc(&pNetDev, 0 /*privMemSize */);
1346 if (status != NDIS_STATUS_SUCCESS) {
1347 /* allocation fail, exit */
1348 DBGPRINT(RT_DEBUG_ERROR,
1349 ("Allocate network device fail (%s)...\n",
1350 pNamePrefix));
1351 return NULL;
1352 }
1353
1354 /* find an available interface name, max 32 interfaces */
1355 status = RtmpOSNetDevRequestName(pAd, pNetDev, pNamePrefix, devNum);
1356 if (status != NDIS_STATUS_SUCCESS) {
1357 /* error! no available ra name can be used! */
1358 DBGPRINT(RT_DEBUG_ERROR,
1359 ("Assign interface name (%s with suffix 0~32) failed...\n",
1360 pNamePrefix));
1361 RtmpOSNetDevFree(pNetDev);
1362
1363 return NULL;
1364 } else {
1365 DBGPRINT(RT_DEBUG_TRACE,
1366 ("The name of the new %s interface is %s...\n",
1367 pNamePrefix, pNetDev->name));
1368 }
1369
1370 return pNetDev;
1371 }
Linus' kernel tree