2 * Copyright (c) 2007-2008 Atheros Communications Inc.
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 /* Module Name : wwrap.c */
18 /* This module contains wrapper functions. */
21 /* Platform dependent. */
24 /* Please include your header files here */
28 #include <linux/netlink.h>
31 #include <net/iw_handler.h>
34 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
35 #define URB_ZERO_PACKET USB_ZERO_PACKET
38 extern void zfiRecv80211(zdev_t
* dev
, zbuf_t
* buf
, struct zsAdditionInfo
* addInfo
);
39 extern void zfCoreRecv(zdev_t
* dev
, zbuf_t
* buf
, struct zsAdditionInfo
* addInfo
);
40 extern void zfIdlChkRsp(zdev_t
* dev
, u32_t
* rsp
, u16_t rspLen
);
41 extern void zfIdlRsp(zdev_t
* dev
, u32_t
*rsp
, u16_t rspLen
);
45 //extern struct zsWdsStruct wds[ZM_WDS_PORT_NUMBER];
46 extern struct zsVapStruct vap
[ZM_VAP_PORT_NUMBER
];
48 u32_t
zfLnxUsbSubmitTxData(zdev_t
* dev
);
49 u32_t
zfLnxUsbIn(zdev_t
* dev
, urb_t
*urb
, zbuf_t
*buf
);
50 u32_t
zfLnxSubmitRegInUrb(zdev_t
*dev
);
51 u32_t
zfLnxUsbSubmitBulkUrb(urb_t
*urb
, struct usb_device
*usb
, u16_t epnum
, u16_t direction
,
52 void *transfer_buffer
, int buffer_length
, usb_complete_t complete
, void *context
);
53 u32_t
zfLnxUsbSubmitIntUrb(urb_t
*urb
, struct usb_device
*usb
, u16_t epnum
, u16_t direction
,
54 void *transfer_buffer
, int buffer_length
, usb_complete_t complete
, void *context
,
57 u16_t
zfLnxGetFreeTxUrb(zdev_t
*dev
)
59 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
61 unsigned long irqFlag
;
63 spin_lock_irqsave(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
65 //idx = ((macp->TxUrbTail + 1) & (ZM_MAX_TX_URB_NUM - 1));
67 //if (idx != macp->TxUrbHead)
68 if (macp
->TxUrbCnt
!= 0)
70 idx
= macp
->TxUrbTail
;
71 macp
->TxUrbTail
= ((macp
->TxUrbTail
+ 1) & (ZM_MAX_TX_URB_NUM
- 1));
76 //printk(KERN_ERR "macp->TxUrbCnt: %d\n", macp->TxUrbCnt);
80 spin_unlock_irqrestore(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
84 void zfLnxPutTxUrb(zdev_t
*dev
)
86 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
88 unsigned long irqFlag
;
90 spin_lock_irqsave(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
92 idx
= ((macp
->TxUrbHead
+ 1) & (ZM_MAX_TX_URB_NUM
- 1));
94 //if (idx != macp->TxUrbTail)
95 if (macp
->TxUrbCnt
< ZM_MAX_TX_URB_NUM
)
97 macp
->TxUrbHead
= idx
;
102 printk("UsbTxUrbQ inconsistent: TxUrbHead: %d, TxUrbTail: %d\n",
103 macp
->TxUrbHead
, macp
->TxUrbTail
);
106 spin_unlock_irqrestore(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
109 u16_t
zfLnxCheckTxBufferCnt(zdev_t
*dev
)
111 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
113 unsigned long irqFlag
;
115 spin_lock_irqsave(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
117 TxBufCnt
= macp
->TxBufCnt
;
119 spin_unlock_irqrestore(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
123 UsbTxQ_t
*zfLnxGetUsbTxBuffer(zdev_t
*dev
)
125 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
128 unsigned long irqFlag
;
130 spin_lock_irqsave(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
132 idx
= ((macp
->TxBufHead
+1) & (ZM_MAX_TX_BUF_NUM
- 1));
134 //if (idx != macp->TxBufTail)
135 if (macp
->TxBufCnt
> 0)
137 //printk("CWY - zfwGetUsbTxBuffer ,macp->TxBufCnt = %d\n", macp->TxBufCnt);
138 TxQ
= (UsbTxQ_t
*)&(macp
->UsbTxBufQ
[macp
->TxBufHead
]);
139 macp
->TxBufHead
= ((macp
->TxBufHead
+1) & (ZM_MAX_TX_BUF_NUM
- 1));
144 if (macp
->TxBufHead
!= macp
->TxBufTail
)
146 printk(KERN_ERR
"zfwGetUsbTxBuf UsbTxBufQ inconsistent: TxBufHead: %d, TxBufTail: %d\n",
147 macp
->TxBufHead
, macp
->TxBufTail
);
150 spin_unlock_irqrestore(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
154 spin_unlock_irqrestore(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
158 u16_t
zfLnxPutUsbTxBuffer(zdev_t
*dev
, u8_t
*hdr
, u16_t hdrlen
,
159 u8_t
*snap
, u16_t snapLen
, u8_t
*tail
, u16_t tailLen
,
160 zbuf_t
*buf
, u16_t offset
)
162 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
165 unsigned long irqFlag
;
167 spin_lock_irqsave(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
169 idx
= ((macp
->TxBufTail
+1) & (ZM_MAX_TX_BUF_NUM
- 1));
172 //zm_assert(macp->TxBufCnt >= 0); // deleted because of always true
174 //if (idx != macp->TxBufHead)
175 if (macp
->TxBufCnt
< ZM_MAX_TX_BUF_NUM
)
177 //printk("CWY - zfwPutUsbTxBuffer ,macp->TxBufCnt = %d\n", macp->TxBufCnt);
178 TxQ
= (UsbTxQ_t
*)&(macp
->UsbTxBufQ
[macp
->TxBufTail
]);
179 memcpy(TxQ
->hdr
, hdr
, hdrlen
);
180 TxQ
->hdrlen
= hdrlen
;
181 memcpy(TxQ
->snap
, snap
, snapLen
);
182 TxQ
->snapLen
= snapLen
;
183 memcpy(TxQ
->tail
, tail
, tailLen
);
184 TxQ
->tailLen
= tailLen
;
186 TxQ
->offset
= offset
;
188 macp
->TxBufTail
= ((macp
->TxBufTail
+1) & (ZM_MAX_TX_BUF_NUM
- 1));
193 printk(KERN_ERR
"zfLnxPutUsbTxBuffer UsbTxBufQ inconsistent: TxBufHead: %d, TxBufTail: %d, TxBufCnt: %d\n",
194 macp
->TxBufHead
, macp
->TxBufTail
, macp
->TxBufCnt
);
195 spin_unlock_irqrestore(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
199 spin_unlock_irqrestore(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
203 zbuf_t
*zfLnxGetUsbRxBuffer(zdev_t
*dev
)
205 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
208 unsigned long irqFlag
;
210 spin_lock_irqsave(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
212 //idx = ((macp->RxBufHead+1) & (ZM_MAX_RX_URB_NUM - 1));
214 //if (idx != macp->RxBufTail)
215 if (macp
->RxBufCnt
!= 0)
217 buf
= macp
->UsbRxBufQ
[macp
->RxBufHead
];
218 macp
->RxBufHead
= ((macp
->RxBufHead
+1) & (ZM_MAX_RX_URB_NUM
- 1));
223 printk("RxBufQ inconsistent: RxBufHead: %d, RxBufTail: %d\n",
224 macp
->RxBufHead
, macp
->RxBufTail
);
225 spin_unlock_irqrestore(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
229 spin_unlock_irqrestore(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
233 u32_t
zfLnxPutUsbRxBuffer(zdev_t
*dev
, zbuf_t
*buf
)
235 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
237 unsigned long irqFlag
;
239 spin_lock_irqsave(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
241 idx
= ((macp
->RxBufTail
+1) & (ZM_MAX_RX_URB_NUM
- 1));
243 //if (idx != macp->RxBufHead)
244 if (macp
->RxBufCnt
!= ZM_MAX_RX_URB_NUM
)
246 macp
->UsbRxBufQ
[macp
->RxBufTail
] = buf
;
247 macp
->RxBufTail
= idx
;
252 printk("RxBufQ inconsistent: RxBufHead: %d, RxBufTail: %d\n",
253 macp
->RxBufHead
, macp
->RxBufTail
);
254 spin_unlock_irqrestore(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
258 spin_unlock_irqrestore(&(((struct usbdrv_private
*)(dev
->priv
))->cs_lock
), irqFlag
);
262 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
263 void zfLnxUsbDataOut_callback(urb_t
*urb
)
265 void zfLnxUsbDataOut_callback(urb_t
*urb
, struct pt_regs
*regs
)
268 zdev_t
* dev
= urb
->context
;
271 /* Give the urb back */
274 /* Check whether there is any pending buffer needed */
276 if (zfLnxCheckTxBufferCnt(dev
) != 0)
278 //TxData = zfwGetUsbTxBuffer(dev);
280 //if (TxData == NULL)
282 // printk("Get a NULL buffer from zfwGetUsbTxBuffer\n");
287 zfLnxUsbSubmitTxData(dev
);
292 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
293 void zfLnxUsbDataIn_callback(urb_t
*urb
)
295 void zfLnxUsbDataIn_callback(urb_t
*urb
, struct pt_regs
*regs
)
298 zdev_t
* dev
= urb
->context
;
299 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
304 #if ZM_USB_STREAM_MODE == 1
305 static int remain_len
= 0, check_pad
= 0, check_len
= 0;
311 zbuf_t
*rxBufPool
[8];
312 u16_t rxBufPoolIndex
= 0;
315 /* Check status for URB */
316 if (urb
->status
!= 0){
317 printk("zfLnxUsbDataIn_callback() : status=0x%x\n", urb
->status
);
318 if ((urb
->status
!= -ENOENT
) && (urb
->status
!= -ECONNRESET
)
319 && (urb
->status
!= -ESHUTDOWN
))
321 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
322 if (urb
->status
== USB_ST_INTERNALERROR
)
325 if (urb
->status
== -EPIPE
){
326 //printk(KERN_ERR "nonzero read bulk status received: -EPIPE");
330 if (urb
->status
== -EPROTO
){
331 //printk(KERN_ERR "nonzero read bulk status received: -EPROTO");
337 //printk(KERN_ERR "urb->status: 0x%08x\n", urb->status);
339 /* Dequeue skb buffer */
340 buf
= zfLnxGetUsbRxBuffer(dev
);
341 dev_kfree_skb_any(buf
);
343 /* Enqueue skb buffer */
344 zfLnxPutUsbRxBuffer(dev
, buf
);
346 /* Submit a Rx urb */
347 zfLnxUsbIn(dev
, urb
, buf
);
352 if (urb
->actual_length
== 0)
354 printk(KERN_ERR
"Get an URB whose length is zero");
358 /* Dequeue skb buffer */
359 buf
= zfLnxGetUsbRxBuffer(dev
);
361 //zfwBufSetSize(dev, buf, urb->actual_length);
362 #ifdef NET_SKBUFF_DATA_USES_OFFSET
366 buf
->tail
= buf
->data
;
370 if ((buf
->tail
+ urb
->actual_length
) > buf
->end
)
373 skb_put(buf
, urb
->actual_length
);
375 #if ZM_USB_STREAM_MODE == 1
378 zbuf_t
*remain_buf
= macp
->reamin_buf
;
381 remain_len
-= check_pad
;
384 memcpy(&(remain_buf
->data
[check_len
]), buf
->data
, remain_len
);
385 check_len
+= remain_len
;
388 rxBufPool
[rxBufPoolIndex
++] = remain_buf
;
391 while(index
< urb
->actual_length
)
393 pkt_len
= buf
->data
[index
] + (buf
->data
[index
+1] << 8);
394 pkt_tag
= buf
->data
[index
+2] + (buf
->data
[index
+3] << 8);
396 if (pkt_tag
== 0x4e00)
400 //printk("Get a packet, index: %d, pkt_len: 0x%04x\n", index, pkt_len);
403 for (ii
= index
; ii
< pkt_len
+4;)
405 printk("%02x ", (buf
->data
[ii
] & 0xff));
407 if ((++ii
% 16) == 0)
414 pad_len
= 4 - (pkt_len
& 0x3);
420 index
= index
+ 4 + pkt_len
+ pad_len
;
422 if (index
> ZM_MAX_RX_BUFFER_SIZE
)
424 remain_len
= index
- ZM_MAX_RX_BUFFER_SIZE
; // - pad_len;
425 check_len
= ZM_MAX_RX_BUFFER_SIZE
- chk_idx
- 4;
428 /* Allocate a skb buffer */
429 //new_buf = zfwBufAllocate(dev, ZM_MAX_RX_BUFFER_SIZE);
430 new_buf
= dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE
);
432 /* Set skb buffer length */
433 #ifdef NET_SKBUFF_DATA_USES_OFFSET
437 new_buf
->tail
= new_buf
->data
;
441 skb_put(new_buf
, pkt_len
);
443 /* Copy the buffer */
444 memcpy(new_buf
->data
, &(buf
->data
[chk_idx
+4]), check_len
);
446 /* Record the buffer pointer */
447 macp
->reamin_buf
= new_buf
;
451 #ifdef ZM_DONT_COPY_RX_BUFFER
452 if (rxBufPoolIndex
== 0)
454 new_buf
= skb_clone(buf
, GFP_ATOMIC
);
456 new_buf
->data
= &(buf
->data
[chk_idx
+4]);
457 new_buf
->len
= pkt_len
;
462 /* Allocate a skb buffer */
463 new_buf
= dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE
);
465 /* Set skb buffer length */
466 #ifdef NET_SKBUFF_DATA_USES_OFFSET
470 new_buf
->tail
= new_buf
->data
;
474 skb_put(new_buf
, pkt_len
);
476 /* Copy the buffer */
477 memcpy(new_buf
->data
, &(buf
->data
[chk_idx
+4]), pkt_len
);
479 #ifdef ZM_DONT_COPY_RX_BUFFER
482 rxBufPool
[rxBufPoolIndex
++] = new_buf
;
487 printk(KERN_ERR
"Can't find tag, pkt_len: 0x%04x, tag: 0x%04x\n", pkt_len
, pkt_tag
);
490 dev_kfree_skb_any(buf
);
492 /* Allocate a skb buffer */
493 new_buf
= dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE
);
495 /* Enqueue skb buffer */
496 zfLnxPutUsbRxBuffer(dev
, new_buf
);
498 /* Submit a Rx urb */
499 zfLnxUsbIn(dev
, urb
, new_buf
);
506 dev_kfree_skb_any(buf
);
509 /* Allocate a skb buffer */
510 new_buf
= dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE
);
512 /* Enqueue skb buffer */
513 zfLnxPutUsbRxBuffer(dev
, new_buf
);
515 /* Submit a Rx urb */
516 zfLnxUsbIn(dev
, urb
, new_buf
);
518 #if ZM_USB_STREAM_MODE == 1
519 for(ii
= 0; ii
< rxBufPoolIndex
; ii
++)
521 macp
->usbCbFunctions
.zfcbUsbRecv(dev
, rxBufPool
[ii
]);
524 /* pass data to upper layer */
525 macp
->usbCbFunctions
.zfcbUsbRecv(dev
, buf
);
529 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
530 void zfLnxUsbRegOut_callback(urb_t
*urb
)
532 void zfLnxUsbRegOut_callback(urb_t
*urb
, struct pt_regs
*regs
)
535 //dev_t* dev = urb->context;
537 //printk(KERN_ERR "zfwUsbRegOut_callback\n");
540 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
541 void zfLnxUsbRegIn_callback(urb_t
*urb
)
543 void zfLnxUsbRegIn_callback(urb_t
*urb
, struct pt_regs
*regs
)
546 zdev_t
* dev
= urb
->context
;
549 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
551 /* Check status for URB */
552 if (urb
->status
!= 0){
553 printk("zfLnxUsbRegIn_callback() : status=0x%x\n", urb
->status
);
554 if ((urb
->status
!= -ENOENT
) && (urb
->status
!= -ECONNRESET
)
555 && (urb
->status
!= -ESHUTDOWN
))
557 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
558 if (urb
->status
== USB_ST_INTERNALERROR
)
561 if (urb
->status
== -EPIPE
){
562 //printk(KERN_ERR "nonzero read bulk status received: -EPIPE");
566 if (urb
->status
== -EPROTO
){
567 //printk(KERN_ERR "nonzero read bulk status received: -EPROTO");
573 //printk(KERN_ERR "urb->status: 0x%08x\n", urb->status);
577 if (urb
->actual_length
== 0)
579 printk(KERN_ERR
"Get an URB whose length is zero");
583 /* Copy data into respone buffer */
584 memcpy(rsp
, macp
->regUsbReadBuf
, urb
->actual_length
);
586 /* Notify to upper layer */
587 //zfIdlChkRsp(dev, rsp, (u16_t)urb->actual_length);
588 //zfiUsbRegIn(dev, rsp, (u16_t)urb->actual_length);
589 macp
->usbCbFunctions
.zfcbUsbRegIn(dev
, rsp
, (u16_t
)urb
->actual_length
);
591 /* Issue another USB IN URB */
592 zfLnxSubmitRegInUrb(dev
);
595 u32_t
zfLnxSubmitRegInUrb(zdev_t
*dev
)
598 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
600 /* Submit a rx urb */
601 //ret = zfLnxUsbSubmitBulkUrb(macp->RegInUrb, macp->udev,
602 // USB_REG_IN_PIPE, USB_DIR_IN, macp->regUsbReadBuf,
603 // ZM_USB_REG_MAX_BUF_SIZE, zfLnxUsbRegIn_callback, dev);
606 // printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);
608 ret
= zfLnxUsbSubmitIntUrb(macp
->RegInUrb
, macp
->udev
,
609 USB_REG_IN_PIPE
, USB_DIR_IN
, macp
->regUsbReadBuf
,
610 ZM_USB_REG_MAX_BUF_SIZE
, zfLnxUsbRegIn_callback
, dev
, 1);
615 u32_t
zfLnxUsbSubmitTxData(zdev_t
* dev
)
620 u8_t
*puTxBuf
= NULL
;
623 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
624 #if ZM_USB_TX_STREAM_MODE == 1
629 UsbTxQ_t
*TxQPool
[ZM_MAX_TX_AGGREGATE_NUM
];
632 /* First check whether there is a free URB */
633 freeTxUrb
= zfLnxGetFreeTxUrb(dev
);
635 /* If there is no any free Tx Urb */
636 if (freeTxUrb
== 0xffff)
638 //printk(KERN_ERR "Can't get free Tx Urb\n");
639 //printk("CWY - Can't get free Tx Urb\n");
643 #if ZM_USB_TX_STREAM_MODE == 1
644 usbTxAggCnt
= zfLnxCheckTxBufferCnt(dev
);
646 if (usbTxAggCnt
>= ZM_MAX_TX_AGGREGATE_NUM
)
648 usbTxAggCnt
= ZM_MAX_TX_AGGREGATE_NUM
;
655 //printk("usbTxAggCnt: %d\n", usbTxAggCnt);
658 #if ZM_USB_TX_STREAM_MODE == 1
659 for(ii
= 0; ii
< usbTxAggCnt
; ii
++)
662 /* Dequeue the packet from UsbTxBufQ */
663 TxData
= zfLnxGetUsbTxBuffer(dev
);
666 /* Give the urb back */
671 /* Point to the freeTxUrb buffer */
672 puTxBuf
= macp
->txUsbBuf
[freeTxUrb
];
674 #if ZM_USB_TX_STREAM_MODE == 1
676 pUsbTxHdr
= (u16_t
*)puTxBuf
;
678 /* Add the packet length and tag information */
679 *pUsbTxHdr
++ = TxData
->hdrlen
+ TxData
->snapLen
+
680 (TxData
->buf
->len
- TxData
->offset
) + TxData
->tailLen
;
682 *pUsbTxHdr
++ = 0x697e;
685 #endif // #ifdef ZM_USB_TX_STREAM_MODE
687 /* Copy WLAN header and packet buffer into USB buffer */
688 for(i
= 0; i
< TxData
->hdrlen
; i
++)
690 *puTxBuf
++ = TxData
->hdr
[i
];
693 /* Copy SNAP header */
694 for(i
= 0; i
< TxData
->snapLen
; i
++)
696 *puTxBuf
++ = TxData
->snap
[i
];
699 /* Copy packet buffer */
700 for(i
= 0; i
< TxData
->buf
->len
- TxData
->offset
; i
++)
702 //*puTxBuf++ = zmw_rx_buf_readb(dev, TxData->buf, i);
703 *puTxBuf
++ = *(u8_t
*)((u8_t
*)TxData
->buf
->data
+i
+TxData
->offset
);
707 for(i
= 0; i
< TxData
->tailLen
; i
++)
709 *puTxBuf
++ = TxData
->tail
[i
];
712 len
= TxData
->hdrlen
+TxData
->snapLen
+TxData
->buf
->len
+TxData
->tailLen
-TxData
->offset
;
715 if (TxData
->hdrlen
!= 0)
717 puTxBuf
= macp
->txUsbBuf
[freeTxUrb
];
718 for (i
= 0; i
< len
; i
++)
720 printk("%02x ", puTxBuf
[i
]);
728 /* For debug purpose */
729 if(TxData
->hdr
[9] & 0x40)
732 u16_t ctrlLen
= TxData
->hdr
[0] + (TxData
->hdr
[1] << 8);
734 if (ctrlLen
!= len
+ 4)
736 /* Dump control setting */
737 for(i
= 0; i
< 8; i
++)
739 printk(KERN_ERR
"0x%02x ", TxData
->hdr
[i
]);
741 printk(KERN_ERR
"\n");
743 printk(KERN_ERR
"ctrLen: %d, hdrLen: %d, snapLen: %d\n", ctrlLen
, TxData
->hdrlen
, TxData
->snapLen
);
744 printk(KERN_ERR
"bufLen: %d, tailLen: %d, len: %d\n", TxData
->buf
->len
, TxData
->tailLen
, len
);
749 #if ZM_USB_TX_STREAM_MODE == 1
750 // Add the Length and Tag
753 //printk("%d packet, length: %d\n", ii+1, len);
755 if (ii
< (ZM_MAX_TX_AGGREGATE_NUM
-1))
757 /* Pad the buffer to firmware descriptor boundary */
758 offset
+= (((len
-1) / 4) + 1) * 4;
761 if (ii
== (ZM_MAX_TX_AGGREGATE_NUM
-1))
766 TxQPool
[ii
] = TxData
;
768 //DbgPrint("%d packet, offset: %d\n", ii+1, pUsbTxTransfer->offset);
771 //zfBufFree(dev, txData->buf);
774 //printk("CWY - call zfwUsbSubmitBulkUrb(), len = 0x%d\n", len);
775 /* Submit a tx urb */
776 ret
= zfLnxUsbSubmitBulkUrb(macp
->WlanTxDataUrb
[freeTxUrb
], macp
->udev
,
777 USB_WLAN_TX_PIPE
, USB_DIR_OUT
, macp
->txUsbBuf
[freeTxUrb
],
778 len
, zfLnxUsbDataOut_callback
, dev
);
781 // printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);
784 //dev_kfree_skb_any(TxData->buf);
785 #if ZM_USB_TX_STREAM_MODE == 1
786 for(ii
= 0; ii
< usbTxAggCnt
; ii
++)
787 macp
->usbCbFunctions
.zfcbUsbOutComplete(dev
, TxQPool
[ii
]->buf
, 1, TxQPool
[ii
]->hdr
);
789 macp
->usbCbFunctions
.zfcbUsbOutComplete(dev
, TxData
->buf
, 1, TxData
->hdr
);
797 u32_t
zfLnxUsbIn(zdev_t
* dev
, urb_t
*urb
, zbuf_t
*buf
)
800 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
802 /* Submit a rx urb */
803 ret
= zfLnxUsbSubmitBulkUrb(urb
, macp
->udev
, USB_WLAN_RX_PIPE
,
804 USB_DIR_IN
, buf
->data
, ZM_MAX_RX_BUFFER_SIZE
,
805 zfLnxUsbDataIn_callback
, dev
);
808 // printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);
813 u32_t
zfLnxUsbWriteReg(zdev_t
* dev
, u32_t
* cmd
, u16_t cmdLen
)
815 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
818 #ifdef ZM_CONFIG_BIG_ENDIAN
821 for(ii
=0; ii
<(cmdLen
>>2); ii
++)
822 cmd
[ii
] = cpu_to_le32(cmd
[ii
]);
825 memcpy(macp
->regUsbWriteBuf
, cmd
, cmdLen
);
827 /* Issue an USB Out transfer */
828 /* Submit a tx urb */
829 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
830 ret
= zfLnxUsbSubmitBulkUrb(macp
->RegOutUrb
, macp
->udev
,
831 USB_REG_OUT_PIPE
, USB_DIR_OUT
, macp
->regUsbWriteBuf
,
832 cmdLen
, zfLnxUsbRegOut_callback
, dev
);
834 ret
= zfLnxUsbSubmitIntUrb(macp
->RegOutUrb
, macp
->udev
,
835 USB_REG_OUT_PIPE
, USB_DIR_OUT
, macp
->regUsbWriteBuf
,
836 cmdLen
, zfLnxUsbRegOut_callback
, dev
, 1);
843 u32_t
zfLnxUsbOut(zdev_t
* dev
, u8_t
*hdr
, u16_t hdrlen
, u8_t
*snap
, u16_t snapLen
,
844 u8_t
*tail
, u16_t tailLen
, zbuf_t
*buf
, u16_t offset
)
847 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
849 /* Check length of tail buffer */
850 //zm_assert((tailLen <= 16));
852 /* Enqueue the packet into UsbTxBufQ */
853 if (zfLnxPutUsbTxBuffer(dev
, hdr
, hdrlen
, snap
, snapLen
, tail
, tailLen
, buf
, offset
) == 0xffff)
856 //printk("CWY - zfwPutUsbTxBuffer Error, free packet\n");
857 //dev_kfree_skb_any(buf);
858 macp
->usbCbFunctions
.zfcbUsbOutComplete(dev
, buf
, 0, hdr
);
863 //printk("CWY - call zfwUsbSubmitTxData()\n");
864 ret
= zfLnxUsbSubmitTxData(dev
);
868 void zfLnxInitUsbTxQ(zdev_t
* dev
)
870 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
872 printk(KERN_ERR
"zfwInitUsbTxQ\n");
874 /* Zero memory for UsbTxBufQ */
875 memset(macp
->UsbTxBufQ
, 0, sizeof(UsbTxQ_t
) * ZM_MAX_TX_URB_NUM
);
881 macp
->TxUrbCnt
= ZM_MAX_TX_URB_NUM
;
884 void zfLnxInitUsbRxQ(zdev_t
* dev
)
888 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
890 /* Zero memory for UsbRxBufQ */
891 memset(macp
->UsbRxBufQ
, 0, sizeof(zbuf_t
*) * ZM_MAX_RX_URB_NUM
);
895 for (i
= 0; i
< ZM_MAX_RX_URB_NUM
; i
++)
897 //buf = zfwBufAllocate(dev, ZM_MAX_RX_BUFFER_SIZE);
898 buf
= dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE
);
899 macp
->UsbRxBufQ
[i
] = buf
;
902 //macp->RxBufTail = ZM_MAX_RX_URB_NUM - 1;
905 /* Submit all Rx urbs */
906 for (i
= 0; i
< ZM_MAX_RX_URB_NUM
; i
++)
908 zfLnxPutUsbRxBuffer(dev
, macp
->UsbRxBufQ
[i
]);
909 zfLnxUsbIn(dev
, macp
->WlanRxDataUrb
[i
], macp
->UsbRxBufQ
[i
]);
915 u32_t
zfLnxUsbSubmitBulkUrb(urb_t
*urb
, struct usb_device
*usb
, u16_t epnum
, u16_t direction
,
916 void *transfer_buffer
, int buffer_length
, usb_complete_t complete
, void *context
)
920 if(direction
== USB_DIR_OUT
)
922 usb_fill_bulk_urb(urb
, usb
, usb_sndbulkpipe(usb
, epnum
),
923 transfer_buffer
, buffer_length
, complete
, context
);
925 urb
->transfer_flags
|= URB_ZERO_PACKET
;
929 usb_fill_bulk_urb(urb
, usb
, usb_rcvbulkpipe(usb
, epnum
),
930 transfer_buffer
, buffer_length
, complete
, context
);
933 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15)
934 urb
->transfer_flags
|= URB_ASYNC_UNLINK
;
941 //printk("CWY - urb->hcpriv set by unknown reason, reset it\n");
946 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
947 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
949 ret
= usb_submit_urb(urb
);
951 if ((epnum
== 4) & (ret
!= 0))
953 //printk("CWY - ret = %x\n", ret);
958 u32_t
zfLnxUsbSubmitIntUrb(urb_t
*urb
, struct usb_device
*usb
, u16_t epnum
, u16_t direction
,
959 void *transfer_buffer
, int buffer_length
, usb_complete_t complete
, void *context
,
964 if(direction
== USB_DIR_OUT
)
966 usb_fill_int_urb(urb
, usb
, usb_sndbulkpipe(usb
, epnum
),
967 transfer_buffer
, buffer_length
, complete
, context
, interval
);
971 usb_fill_int_urb(urb
, usb
, usb_rcvbulkpipe(usb
, epnum
),
972 transfer_buffer
, buffer_length
, complete
, context
, interval
);
975 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15)
976 urb
->transfer_flags
|= URB_ASYNC_UNLINK
;
979 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
980 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
982 ret
= usb_submit_urb(urb
);
988 #ifdef ZM_ENABLE_CENC
989 int zfLnxCencSendMsg(struct sock
*netlink_sk
, u_int8_t
*msg
, int len
)
991 #define COMMTYPE_GROUP 8
992 #define WAI_K_MSG 0x11
996 unsigned char *old_tail
;
998 struct nlmsghdr
*nlh
;
1001 size
= NLMSG_SPACE(len
);
1002 skb
= alloc_skb(size
, GFP_ATOMIC
);
1006 printk("dev_alloc_skb failure \n");
1009 old_tail
= skb
->tail
;
1011 /*ÌîдÊý¾Ý±¨Ïà¹ØÐÅÏ¢*/
1012 nlh
= NLMSG_PUT(skb
, 0, 0, WAI_K_MSG
, size
-sizeof(*nlh
));
1013 pos
= NLMSG_DATA(nlh
);
1014 memset(pos
, 0, len
);
1016 /*´«Êäµ½Óû§¿Õ¼äµÄÊý¾Ý*/
1017 memcpy(pos
, msg
, len
);
1018 /*¼ÆËã¾¹ý×Ö½Ú¶ÔÆäºóµÄÊý¾Ýʵ¼Ê³¤¶È*/
1019 nlh
->nlmsg_len
= skb
->tail
- old_tail
;
1020 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14)
1021 NETLINK_CB(skb
).dst_groups
= COMMTYPE_GROUP
;
1023 NETLINK_CB(skb
).dst_group
= COMMTYPE_GROUP
;
1025 netlink_broadcast(netlink_sk
, skb
, 0, COMMTYPE_GROUP
, GFP_ATOMIC
);
1029 nlmsg_failure
: /*NLMSG_PUT ʧ°Ü£¬Ôò³·ÏúÌ×½Ó×Ö»º´æ*/
1034 #undef COMMTYPE_GROUP
1037 #endif //ZM_ENABLE_CENC
1039 /* Simply return 0xffff if VAP function is not supported */
1040 u16_t
zfLnxGetVapId(zdev_t
* dev
)
1044 for (i
=0; i
<ZM_VAP_PORT_NUMBER
; i
++)
1046 if (vap
[i
].dev
== dev
)
1054 u32_t
zfwReadReg(zdev_t
* dev
, u32_t offset
)
1060 #define work_struct tq_struct
1062 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0))
1063 #define schedule_work(a) queue_task(a, &tq_scheduler)
1065 #define schedule_work(a) schedule_task(a)
1068 #define flush_scheduled_work flush_scheduled_tasks
1069 #define INIT_WORK(_wq, _routine, _data) INIT_TQUEUE(_wq, _routine, _data)
1070 #define PREPARE_WORK(_wq, _routine, _data) PREPARE_TQUEUE(_wq, _routine, _data)
1073 #define KEVENT_WATCHDOG 0x00000001
1075 u32_t smp_kevent_Lock
= 0;
1077 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,20))
1078 void kevent(struct work_struct
*work
)
1080 void kevent(void *data
)
1083 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,20))
1084 struct usbdrv_private
*macp
=
1085 container_of(work
, struct usbdrv_private
, kevent
);
1086 zdev_t
*dev
= macp
->device
;
1088 zdev_t
*dev
= (zdev_t
*) data
;
1089 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
1097 if (test_and_set_bit(0, (void *)&smp_kevent_Lock
))
1099 //schedule_work(&macp->kevent);
1103 down(&macp
->ioctl_sem
);
1105 if (test_and_clear_bit(KEVENT_WATCHDOG
, &macp
->kevent_flags
))
1107 extern u16_t
zfHpStartRecv(zdev_t
*dev
);
1108 //zfiHwWatchDogReinit(dev);
1109 printk(("\n ************ Hw watchDog occur!! ************** \n"));
1110 zfiWlanSuspend(dev
);
1111 zfiWlanResume(dev
,0);
1115 clear_bit(0, (void *)&smp_kevent_Lock
);
1116 up(&macp
->ioctl_sem
);
1119 /************************************************************************/
1121 /* FUNCTION DESCRIPTION zfLnxCreateThread */
1122 /* Create a Thread */
1125 /* dev : device pointer */
1131 /* Yuan-Gu Wei Atheros Communications, INC. 2007.3 */
1133 /************************************************************************/
1134 u8_t
zfLnxCreateThread(zdev_t
*dev
)
1136 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
1138 /* Create Mutex and keventd */
1139 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
1140 INIT_WORK(&macp
->kevent
, kevent
, dev
);
1142 INIT_WORK(&macp
->kevent
, kevent
);
1144 init_MUTEX(&macp
->ioctl_sem
);
1149 /************************************************************************/
1151 /* FUNCTION DESCRIPTION zfLnxSignalThread */
1152 /* Signal Thread with Flag */
1155 /* dev : device pointer */
1156 /* flag : signal thread flag */
1162 /* Yuan-Gu Wei Atheros Communications, INC. 2007.3 */
1164 /************************************************************************/
1165 void zfLnxSignalThread(zdev_t
*dev
, int flag
)
1167 struct usbdrv_private
*macp
= (struct usbdrv_private
*)dev
->priv
;
1171 printk("macp is NULL\n");
1175 if (0 && macp
->kevent_ready
!= 1)
1177 printk("Kevent not ready\n");
1181 set_bit(flag
, &macp
->kevent_flags
);
1183 if (!schedule_work(&macp
->kevent
))
1186 //printk(KERN_ERR "schedule_task failed, flag = %x\n", flag);
1190 /* Notify wrapper todo redownload firmware and reinit procedure when */
1191 /* hardware watchdog occur : zfiHwWatchDogReinit() */
1192 void zfLnxWatchDogNotify(zdev_t
* dev
)
1194 zfLnxSignalThread(dev
, KEVENT_WATCHDOG
);
1197 /* Query Durantion of Active Scan */
1198 void zfwGetActiveScanDur(zdev_t
* dev
, u8_t
* Dur
)
1200 *Dur
= 30; // default 30 ms
1203 void zfwGetShowZeroLengthSSID(zdev_t
* dev
, u8_t
* Dur
)