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>
29 #include <linux/slab.h>
30 #include <net/iw_handler.h>
32 extern void zfiRecv80211(zdev_t
*dev
, zbuf_t
*buf
, struct zsAdditionInfo
*addInfo
);
33 extern void zfCoreRecv(zdev_t
*dev
, zbuf_t
*buf
, struct zsAdditionInfo
*addInfo
);
34 extern void zfIdlChkRsp(zdev_t
*dev
, u32_t
*rsp
, u16_t rspLen
);
35 extern void zfIdlRsp(zdev_t
*dev
, u32_t
*rsp
, u16_t rspLen
);
39 /*extern struct zsWdsStruct wds[ZM_WDS_PORT_NUMBER];*/
40 extern struct zsVapStruct vap
[ZM_VAP_PORT_NUMBER
];
42 u32_t
zfLnxUsbSubmitTxData(zdev_t
*dev
);
43 u32_t
zfLnxUsbIn(zdev_t
*dev
, urb_t
*urb
, zbuf_t
*buf
);
44 u32_t
zfLnxSubmitRegInUrb(zdev_t
*dev
);
45 u32_t
zfLnxUsbSubmitBulkUrb(urb_t
*urb
, struct usb_device
*usb
, u16_t epnum
, u16_t direction
,
46 void *transfer_buffer
, int buffer_length
, usb_complete_t complete
, void *context
);
47 u32_t
zfLnxUsbSubmitIntUrb(urb_t
*urb
, struct usb_device
*usb
, u16_t epnum
, u16_t direction
,
48 void *transfer_buffer
, int buffer_length
, usb_complete_t complete
, void *context
,
51 u16_t
zfLnxGetFreeTxUrb(zdev_t
*dev
)
53 struct usbdrv_private
*macp
= dev
->ml_priv
;
55 unsigned long irqFlag
;
57 spin_lock_irqsave(&macp
->cs_lock
, irqFlag
);
59 /*idx = ((macp->TxUrbTail + 1) & (ZM_MAX_TX_URB_NUM - 1));*/
61 /*if (idx != macp->TxUrbHead)*/
62 if (macp
->TxUrbCnt
!= 0) {
63 idx
= macp
->TxUrbTail
;
64 macp
->TxUrbTail
= ((macp
->TxUrbTail
+ 1) & (ZM_MAX_TX_URB_NUM
- 1));
67 /*printk(KERN_ERR "macp->TxUrbCnt: %d\n", macp->TxUrbCnt);*/
71 spin_unlock_irqrestore(&macp
->cs_lock
, irqFlag
);
75 void zfLnxPutTxUrb(zdev_t
*dev
)
77 struct usbdrv_private
*macp
= dev
->ml_priv
;
79 unsigned long irqFlag
;
81 spin_lock_irqsave(&macp
->cs_lock
, irqFlag
);
83 idx
= ((macp
->TxUrbHead
+ 1) & (ZM_MAX_TX_URB_NUM
- 1));
85 /*if (idx != macp->TxUrbTail)*/
86 if (macp
->TxUrbCnt
< ZM_MAX_TX_URB_NUM
) {
87 macp
->TxUrbHead
= idx
;
90 printk("UsbTxUrbQ inconsistent: TxUrbHead: %d, TxUrbTail: %d\n",
91 macp
->TxUrbHead
, macp
->TxUrbTail
);
94 spin_unlock_irqrestore(&macp
->cs_lock
, irqFlag
);
97 u16_t
zfLnxCheckTxBufferCnt(zdev_t
*dev
)
99 struct usbdrv_private
*macp
= dev
->ml_priv
;
101 unsigned long irqFlag
;
103 spin_lock_irqsave(&macp
->cs_lock
, irqFlag
);
105 TxBufCnt
= macp
->TxBufCnt
;
107 spin_unlock_irqrestore(&macp
->cs_lock
, irqFlag
);
111 UsbTxQ_t
*zfLnxGetUsbTxBuffer(zdev_t
*dev
)
113 struct usbdrv_private
*macp
= dev
->ml_priv
;
116 unsigned long irqFlag
;
118 spin_lock_irqsave(&macp
->cs_lock
, irqFlag
);
120 idx
= ((macp
->TxBufHead
+1) & (ZM_MAX_TX_BUF_NUM
- 1));
122 /*if (idx != macp->TxBufTail)*/
123 if (macp
->TxBufCnt
> 0) {
124 /*printk("CWY - zfwGetUsbTxBuffer ,macp->TxBufCnt = %d\n", macp->TxBufCnt);*/
125 TxQ
= (UsbTxQ_t
*)&(macp
->UsbTxBufQ
[macp
->TxBufHead
]);
126 macp
->TxBufHead
= ((macp
->TxBufHead
+1) & (ZM_MAX_TX_BUF_NUM
- 1));
129 if (macp
->TxBufHead
!= macp
->TxBufTail
) {
130 printk(KERN_ERR
"zfwGetUsbTxBuf UsbTxBufQ inconsistent: TxBufHead: %d, TxBufTail: %d\n",
131 macp
->TxBufHead
, macp
->TxBufTail
);
134 spin_unlock_irqrestore(&macp
->cs_lock
, irqFlag
);
138 spin_unlock_irqrestore(&macp
->cs_lock
, irqFlag
);
142 u16_t
zfLnxPutUsbTxBuffer(zdev_t
*dev
, u8_t
*hdr
, u16_t hdrlen
,
143 u8_t
*snap
, u16_t snapLen
, u8_t
*tail
, u16_t tailLen
,
144 zbuf_t
*buf
, u16_t offset
)
146 struct usbdrv_private
*macp
= dev
->ml_priv
;
149 unsigned long irqFlag
;
151 spin_lock_irqsave(&macp
->cs_lock
, irqFlag
);
153 idx
= ((macp
->TxBufTail
+1) & (ZM_MAX_TX_BUF_NUM
- 1));
156 /*zm_assert(macp->TxBufCnt >= 0); // deleted because of always true*/
158 /*if (idx != macp->TxBufHead)*/
159 if (macp
->TxBufCnt
< ZM_MAX_TX_BUF_NUM
) {
160 /*printk("CWY - zfwPutUsbTxBuffer ,macp->TxBufCnt = %d\n", macp->TxBufCnt);*/
161 TxQ
= (UsbTxQ_t
*)&(macp
->UsbTxBufQ
[macp
->TxBufTail
]);
162 memcpy(TxQ
->hdr
, hdr
, hdrlen
);
163 TxQ
->hdrlen
= hdrlen
;
164 memcpy(TxQ
->snap
, snap
, snapLen
);
165 TxQ
->snapLen
= snapLen
;
166 memcpy(TxQ
->tail
, tail
, tailLen
);
167 TxQ
->tailLen
= tailLen
;
169 TxQ
->offset
= offset
;
171 macp
->TxBufTail
= ((macp
->TxBufTail
+1) & (ZM_MAX_TX_BUF_NUM
- 1));
174 printk(KERN_ERR
"zfLnxPutUsbTxBuffer UsbTxBufQ inconsistent: TxBufHead: %d, TxBufTail: %d, TxBufCnt: %d\n",
175 macp
->TxBufHead
, macp
->TxBufTail
, macp
->TxBufCnt
);
176 spin_unlock_irqrestore(&macp
->cs_lock
, irqFlag
);
180 spin_unlock_irqrestore(&macp
->cs_lock
, irqFlag
);
184 zbuf_t
*zfLnxGetUsbRxBuffer(zdev_t
*dev
)
186 struct usbdrv_private
*macp
= dev
->ml_priv
;
189 unsigned long irqFlag
;
191 spin_lock_irqsave(&macp
->cs_lock
, irqFlag
);
193 /*idx = ((macp->RxBufHead+1) & (ZM_MAX_RX_URB_NUM - 1));*/
195 /*if (idx != macp->RxBufTail)*/
196 if (macp
->RxBufCnt
!= 0) {
197 buf
= macp
->UsbRxBufQ
[macp
->RxBufHead
];
198 macp
->RxBufHead
= ((macp
->RxBufHead
+1) & (ZM_MAX_RX_URB_NUM
- 1));
201 printk("RxBufQ inconsistent: RxBufHead: %d, RxBufTail: %d\n",
202 macp
->RxBufHead
, macp
->RxBufTail
);
203 spin_unlock_irqrestore(&macp
->cs_lock
, irqFlag
);
207 spin_unlock_irqrestore(&macp
->cs_lock
, irqFlag
);
211 u32_t
zfLnxPutUsbRxBuffer(zdev_t
*dev
, zbuf_t
*buf
)
213 struct usbdrv_private
*macp
= dev
->ml_priv
;
215 unsigned long irqFlag
;
217 spin_lock_irqsave(&macp
->cs_lock
, irqFlag
);
219 idx
= ((macp
->RxBufTail
+1) & (ZM_MAX_RX_URB_NUM
- 1));
221 /*if (idx != macp->RxBufHead)*/
222 if (macp
->RxBufCnt
!= ZM_MAX_RX_URB_NUM
) {
223 macp
->UsbRxBufQ
[macp
->RxBufTail
] = buf
;
224 macp
->RxBufTail
= idx
;
227 printk("RxBufQ inconsistent: RxBufHead: %d, RxBufTail: %d\n",
228 macp
->RxBufHead
, macp
->RxBufTail
);
229 spin_unlock_irqrestore(&macp
->cs_lock
, irqFlag
);
233 spin_unlock_irqrestore(&macp
->cs_lock
, irqFlag
);
237 void zfLnxUsbDataOut_callback(urb_t
*urb
)
239 zdev_t
*dev
= urb
->context
;
240 /*UsbTxQ_t *TxData;*/
242 /* Give the urb back */
245 /* Check whether there is any pending buffer needed */
247 if (zfLnxCheckTxBufferCnt(dev
) != 0) {
248 /*TxData = zfwGetUsbTxBuffer(dev);
249 //if (TxData == NULL)
251 // printk("Get a NULL buffer from zfwGetUsbTxBuffer\n");
256 zfLnxUsbSubmitTxData(dev);
261 void zfLnxUsbDataIn_callback(urb_t
*urb
)
263 zdev_t
*dev
= urb
->context
;
264 struct usbdrv_private
*macp
= dev
->ml_priv
;
269 #if ZM_USB_STREAM_MODE == 1
270 static int remain_len
, check_pad
, check_len
;
276 zbuf_t
*rxBufPool
[8];
277 u16_t rxBufPoolIndex
= 0;
280 /* Check status for URB */
281 if (urb
->status
!= 0) {
282 printk("zfLnxUsbDataIn_callback() : status=0x%x\n", urb
->status
);
283 if ((urb
->status
!= -ENOENT
) && (urb
->status
!= -ECONNRESET
)
284 && (urb
->status
!= -ESHUTDOWN
)) {
285 if (urb
->status
== -EPIPE
) {
286 /*printk(KERN_ERR "nonzero read bulk status received: -EPIPE");*/
290 if (urb
->status
== -EPROTO
) {
291 /*printk(KERN_ERR "nonzero read bulk status received: -EPROTO");*/
296 /*printk(KERN_ERR "urb->status: 0x%08x\n", urb->status);*/
298 /* Dequeue skb buffer */
299 buf
= zfLnxGetUsbRxBuffer(dev
);
300 dev_kfree_skb_any(buf
);
304 if (urb
->actual_length
== 0) {
305 printk(KERN_ERR
"Get an URB whose length is zero");
309 /* Dequeue skb buffer */
310 buf
= zfLnxGetUsbRxBuffer(dev
);
312 /*zfwBufSetSize(dev, buf, urb->actual_length);*/
313 #ifdef NET_SKBUFF_DATA_USES_OFFSET
317 buf
->tail
= buf
->data
;
321 BUG_ON((buf
->tail
+ urb
->actual_length
) > buf
->end
);
323 skb_put(buf
, urb
->actual_length
);
325 #if ZM_USB_STREAM_MODE == 1
326 if (remain_len
!= 0) {
327 zbuf_t
*remain_buf
= macp
->reamin_buf
;
330 remain_len
-= check_pad
;
333 memcpy(&(remain_buf
->data
[check_len
]), buf
->data
, remain_len
);
334 check_len
+= remain_len
;
337 rxBufPool
[rxBufPoolIndex
++] = remain_buf
;
340 while (index
< urb
->actual_length
) {
341 pkt_len
= buf
->data
[index
] + (buf
->data
[index
+1] << 8);
342 pkt_tag
= buf
->data
[index
+2] + (buf
->data
[index
+3] << 8);
344 if (pkt_tag
== 0x4e00) {
347 /*printk("Get a packet, index: %d, pkt_len: 0x%04x\n", index, pkt_len);*/
349 pad_len
= 4 - (pkt_len
& 0x3);
355 index
= index
+ 4 + pkt_len
+ pad_len
;
357 if (index
> ZM_MAX_RX_BUFFER_SIZE
) {
358 remain_len
= index
- ZM_MAX_RX_BUFFER_SIZE
; /* - pad_len;*/
359 check_len
= ZM_MAX_RX_BUFFER_SIZE
- chk_idx
- 4;
362 /* Allocate a skb buffer */
363 /*new_buf = zfwBufAllocate(dev, ZM_MAX_RX_BUFFER_SIZE);*/
364 new_buf
= dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE
);
366 /* Set skb buffer length */
367 #ifdef NET_SKBUFF_DATA_USES_OFFSET
371 new_buf
->tail
= new_buf
->data
;
375 skb_put(new_buf
, pkt_len
);
377 /* Copy the buffer */
378 memcpy(new_buf
->data
, &(buf
->data
[chk_idx
+4]), check_len
);
380 /* Record the buffer pointer */
381 macp
->reamin_buf
= new_buf
;
383 #ifdef ZM_DONT_COPY_RX_BUFFER
384 if (rxBufPoolIndex
== 0) {
385 new_buf
= skb_clone(buf
, GFP_ATOMIC
);
387 new_buf
->data
= &(buf
->data
[chk_idx
+4]);
388 new_buf
->len
= pkt_len
;
391 /* Allocate a skb buffer */
392 new_buf
= dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE
);
394 /* Set skb buffer length */
395 #ifdef NET_SKBUFF_DATA_USES_OFFSET
399 new_buf
->tail
= new_buf
->data
;
403 skb_put(new_buf
, pkt_len
);
405 /* Copy the buffer */
406 memcpy(new_buf
->data
, &(buf
->data
[chk_idx
+4]), pkt_len
);
408 #ifdef ZM_DONT_COPY_RX_BUFFER
411 rxBufPool
[rxBufPoolIndex
++] = new_buf
;
414 printk(KERN_ERR
"Can't find tag, pkt_len: 0x%04x, tag: 0x%04x\n", pkt_len
, pkt_tag
);
417 dev_kfree_skb_any(buf
);
419 /* Allocate a skb buffer */
420 new_buf
= dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE
);
422 /* Enqueue skb buffer */
423 zfLnxPutUsbRxBuffer(dev
, new_buf
);
425 /* Submit a Rx urb */
426 zfLnxUsbIn(dev
, urb
, new_buf
);
433 dev_kfree_skb_any(buf
);
436 /* Allocate a skb buffer */
437 new_buf
= dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE
);
439 /* Enqueue skb buffer */
440 zfLnxPutUsbRxBuffer(dev
, new_buf
);
442 /* Submit a Rx urb */
443 zfLnxUsbIn(dev
, urb
, new_buf
);
445 #if ZM_USB_STREAM_MODE == 1
446 for (ii
= 0; ii
< rxBufPoolIndex
; ii
++) {
447 macp
->usbCbFunctions
.zfcbUsbRecv(dev
, rxBufPool
[ii
]);
450 /* pass data to upper layer */
451 macp
->usbCbFunctions
.zfcbUsbRecv(dev
, buf
);
455 void zfLnxUsbRegOut_callback(urb_t
*urb
)
457 /*dev_t* dev = urb->context;*/
459 /*printk(KERN_ERR "zfwUsbRegOut_callback\n");*/
462 void zfLnxUsbRegIn_callback(urb_t
*urb
)
464 zdev_t
*dev
= urb
->context
;
467 struct usbdrv_private
*macp
= dev
->ml_priv
;
469 /* Check status for URB */
470 if (urb
->status
!= 0) {
471 printk("zfLnxUsbRegIn_callback() : status=0x%x\n", urb
->status
);
472 if ((urb
->status
!= -ENOENT
) && (urb
->status
!= -ECONNRESET
) && (urb
->status
!= -ESHUTDOWN
)) {
473 if (urb
->status
== -EPIPE
) {
474 /*printk(KERN_ERR "nonzero read bulk status received: -EPIPE");*/
478 if (urb
->status
== -EPROTO
) {
479 /*printk(KERN_ERR "nonzero read bulk status received: -EPROTO");*/
484 /*printk(KERN_ERR "urb->status: 0x%08x\n", urb->status);*/
488 if (urb
->actual_length
== 0) {
489 printk(KERN_ERR
"Get an URB whose length is zero");
493 /* Copy data into respone buffer */
494 memcpy(rsp
, macp
->regUsbReadBuf
, urb
->actual_length
);
496 /* Notify to upper layer */
497 /*zfIdlChkRsp(dev, rsp, (u16_t)urb->actual_length);*/
498 /*zfiUsbRegIn(dev, rsp, (u16_t)urb->actual_length);*/
499 macp
->usbCbFunctions
.zfcbUsbRegIn(dev
, rsp
, (u16_t
)urb
->actual_length
);
501 /* Issue another USB IN URB */
502 zfLnxSubmitRegInUrb(dev
);
505 u32_t
zfLnxSubmitRegInUrb(zdev_t
*dev
)
508 struct usbdrv_private
*macp
= dev
->ml_priv
;
511 //ret = zfLnxUsbSubmitBulkUrb(macp->RegInUrb, macp->udev,
512 // USB_REG_IN_PIPE, USB_DIR_IN, macp->regUsbReadBuf,
513 // ZM_USB_REG_MAX_BUF_SIZE, zfLnxUsbRegIn_callback, dev);
516 // printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);*/
518 ret
= zfLnxUsbSubmitIntUrb(macp
->RegInUrb
, macp
->udev
,
519 USB_REG_IN_PIPE
, USB_DIR_IN
, macp
->regUsbReadBuf
,
520 ZM_USB_REG_MAX_BUF_SIZE
, zfLnxUsbRegIn_callback
, dev
, 1);
525 u32_t
zfLnxUsbSubmitTxData(zdev_t
*dev
)
530 u8_t
*puTxBuf
= NULL
;
533 struct usbdrv_private
*macp
= dev
->ml_priv
;
534 #if ZM_USB_TX_STREAM_MODE == 1
539 UsbTxQ_t
*TxQPool
[ZM_MAX_TX_AGGREGATE_NUM
];
542 /* First check whether there is a free URB */
543 freeTxUrb
= zfLnxGetFreeTxUrb(dev
);
545 /* If there is no any free Tx Urb */
546 if (freeTxUrb
== 0xffff) {
547 /*printk(KERN_ERR "Can't get free Tx Urb\n");
548 //printk("CWY - Can't get free Tx Urb\n");*/
552 #if ZM_USB_TX_STREAM_MODE == 1
553 usbTxAggCnt
= zfLnxCheckTxBufferCnt(dev
);
555 if (usbTxAggCnt
>= ZM_MAX_TX_AGGREGATE_NUM
) {
556 usbTxAggCnt
= ZM_MAX_TX_AGGREGATE_NUM
;
561 /*printk("usbTxAggCnt: %d\n", usbTxAggCnt);*/
564 #if ZM_USB_TX_STREAM_MODE == 1
565 for (ii
= 0; ii
< usbTxAggCnt
; ii
++) {
567 /* Dequeue the packet from UsbTxBufQ */
568 TxData
= zfLnxGetUsbTxBuffer(dev
);
569 if (TxData
== NULL
) {
570 /* Give the urb back */
575 /* Point to the freeTxUrb buffer */
576 puTxBuf
= macp
->txUsbBuf
[freeTxUrb
];
578 #if ZM_USB_TX_STREAM_MODE == 1
580 pUsbTxHdr
= (u16_t
*)puTxBuf
;
582 /* Add the packet length and tag information */
583 *pUsbTxHdr
++ = TxData
->hdrlen
+ TxData
->snapLen
+
584 (TxData
->buf
->len
- TxData
->offset
) + TxData
->tailLen
;
586 *pUsbTxHdr
++ = 0x697e;
589 #endif /* #ifdef ZM_USB_TX_STREAM_MODE*/
591 /* Copy WLAN header and packet buffer into USB buffer */
592 for (i
= 0; i
< TxData
->hdrlen
; i
++) {
593 *puTxBuf
++ = TxData
->hdr
[i
];
596 /* Copy SNAP header */
597 for (i
= 0; i
< TxData
->snapLen
; i
++) {
598 *puTxBuf
++ = TxData
->snap
[i
];
601 /* Copy packet buffer */
602 for (i
= 0; i
< TxData
->buf
->len
- TxData
->offset
; i
++) {
603 /*puTxBuf++ = zmw_rx_buf_readb(dev, TxData->buf, i);*/
604 *puTxBuf
++ = *(u8_t
*)((u8_t
*)TxData
->buf
->data
+i
+TxData
->offset
);
608 for (i
= 0; i
< TxData
->tailLen
; i
++) {
609 *puTxBuf
++ = TxData
->tail
[i
];
612 len
= TxData
->hdrlen
+TxData
->snapLen
+TxData
->buf
->len
+TxData
->tailLen
-TxData
->offset
;
615 #if ZM_USB_TX_STREAM_MODE == 1
616 /* Add the Length and Tag*/
619 /*printk("%d packet, length: %d\n", ii+1, len);*/
621 if (ii
< (ZM_MAX_TX_AGGREGATE_NUM
-1)) {
622 /* Pad the buffer to firmware descriptor boundary */
623 offset
+= (((len
-1) / 4) + 1) * 4;
626 if (ii
== (ZM_MAX_TX_AGGREGATE_NUM
-1)) {
630 TxQPool
[ii
] = TxData
;
632 /*DbgPrint("%d packet, offset: %d\n", ii+1, pUsbTxTransfer->offset);*/
635 /*zfBufFree(dev, txData->buf);*/
638 /*printk("CWY - call zfwUsbSubmitBulkUrb(), len = 0x%d\n", len);*/
639 /* Submit a tx urb */
640 ret
= zfLnxUsbSubmitBulkUrb(macp
->WlanTxDataUrb
[freeTxUrb
], macp
->udev
,
641 USB_WLAN_TX_PIPE
, USB_DIR_OUT
, macp
->txUsbBuf
[freeTxUrb
],
642 len
, zfLnxUsbDataOut_callback
, dev
);
645 // printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);*/
648 /*dev_kfree_skb_any(TxData->buf);*/
649 #if ZM_USB_TX_STREAM_MODE == 1
650 for (ii
= 0; ii
< usbTxAggCnt
; ii
++)
651 macp
->usbCbFunctions
.zfcbUsbOutComplete(dev
, TxQPool
[ii
]->buf
, 1, TxQPool
[ii
]->hdr
);
653 macp
->usbCbFunctions
.zfcbUsbOutComplete(dev
, TxData
->buf
, 1, TxData
->hdr
);
661 u32_t
zfLnxUsbIn(zdev_t
*dev
, urb_t
*urb
, zbuf_t
*buf
)
664 struct usbdrv_private
*macp
= dev
->ml_priv
;
666 /* Submit a rx urb */
667 ret
= zfLnxUsbSubmitBulkUrb(urb
, macp
->udev
, USB_WLAN_RX_PIPE
,
668 USB_DIR_IN
, buf
->data
, ZM_MAX_RX_BUFFER_SIZE
,
669 zfLnxUsbDataIn_callback
, dev
);
672 // printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);*/
677 u32_t
zfLnxUsbWriteReg(zdev_t
*dev
, u32_t
*cmd
, u16_t cmdLen
)
679 struct usbdrv_private
*macp
= dev
->ml_priv
;
682 #ifdef ZM_CONFIG_BIG_ENDIAN
685 for (ii
= 0; ii
< (cmdLen
>>2); ii
++)
686 cmd
[ii
] = cpu_to_le32(cmd
[ii
]);
689 memcpy(macp
->regUsbWriteBuf
, cmd
, cmdLen
);
691 /* Issue an USB Out transfer */
692 /* Submit a tx urb */
693 ret
= zfLnxUsbSubmitIntUrb(macp
->RegOutUrb
, macp
->udev
,
694 USB_REG_OUT_PIPE
, USB_DIR_OUT
, macp
->regUsbWriteBuf
,
695 cmdLen
, zfLnxUsbRegOut_callback
, dev
, 1);
701 u32_t
zfLnxUsbOut(zdev_t
*dev
, u8_t
*hdr
, u16_t hdrlen
, u8_t
*snap
, u16_t snapLen
,
702 u8_t
*tail
, u16_t tailLen
, zbuf_t
*buf
, u16_t offset
)
705 struct usbdrv_private
*macp
= dev
->ml_priv
;
707 /* Check length of tail buffer */
708 /*zm_assert((tailLen <= 16));*/
710 /* Enqueue the packet into UsbTxBufQ */
711 if (zfLnxPutUsbTxBuffer(dev
, hdr
, hdrlen
, snap
, snapLen
, tail
, tailLen
, buf
, offset
) == 0xffff) {
713 /*printk("CWY - zfwPutUsbTxBuffer Error, free packet\n");
714 //dev_kfree_skb_any(buf);*/
715 macp
->usbCbFunctions
.zfcbUsbOutComplete(dev
, buf
, 0, hdr
);
720 //printk("CWY - call zfwUsbSubmitTxData()\n");*/
721 ret
= zfLnxUsbSubmitTxData(dev
);
725 void zfLnxInitUsbTxQ(zdev_t
*dev
)
727 struct usbdrv_private
*macp
= dev
->ml_priv
;
729 printk(KERN_ERR
"zfwInitUsbTxQ\n");
731 /* Zero memory for UsbTxBufQ */
732 memset(macp
->UsbTxBufQ
, 0, sizeof(UsbTxQ_t
) * ZM_MAX_TX_URB_NUM
);
738 macp
->TxUrbCnt
= ZM_MAX_TX_URB_NUM
;
741 void zfLnxInitUsbRxQ(zdev_t
*dev
)
745 struct usbdrv_private
*macp
= dev
->ml_priv
;
747 /* Zero memory for UsbRxBufQ */
748 memset(macp
->UsbRxBufQ
, 0, sizeof(zbuf_t
*) * ZM_MAX_RX_URB_NUM
);
752 for (i
= 0; i
< ZM_MAX_RX_URB_NUM
; i
++) {
753 /*buf = zfwBufAllocate(dev, ZM_MAX_RX_BUFFER_SIZE);*/
754 buf
= dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE
);
755 macp
->UsbRxBufQ
[i
] = buf
;
758 /*macp->RxBufTail = ZM_MAX_RX_URB_NUM - 1;*/
761 /* Submit all Rx urbs */
762 for (i
= 0; i
< ZM_MAX_RX_URB_NUM
; i
++) {
763 zfLnxPutUsbRxBuffer(dev
, macp
->UsbRxBufQ
[i
]);
764 zfLnxUsbIn(dev
, macp
->WlanRxDataUrb
[i
], macp
->UsbRxBufQ
[i
]);
770 u32_t
zfLnxUsbSubmitBulkUrb(urb_t
*urb
, struct usb_device
*usb
, u16_t epnum
, u16_t direction
,
771 void *transfer_buffer
, int buffer_length
, usb_complete_t complete
, void *context
)
775 if (direction
== USB_DIR_OUT
) {
776 usb_fill_bulk_urb(urb
, usb
, usb_sndbulkpipe(usb
, epnum
),
777 transfer_buffer
, buffer_length
, complete
, context
);
779 urb
->transfer_flags
|= URB_ZERO_PACKET
;
781 usb_fill_bulk_urb(urb
, usb
, usb_rcvbulkpipe(usb
, epnum
),
782 transfer_buffer
, buffer_length
, complete
, context
);
787 /*printk("CWY - urb->hcpriv set by unknown reason, reset it\n");
792 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
793 if ((epnum
== 4) & (ret
!= 0)) {
794 /*printk("CWY - ret = %x\n", ret);*/
799 u32_t
zfLnxUsbSubmitIntUrb(urb_t
*urb
, struct usb_device
*usb
, u16_t epnum
, u16_t direction
,
800 void *transfer_buffer
, int buffer_length
, usb_complete_t complete
, void *context
,
805 if (direction
== USB_DIR_OUT
) {
806 usb_fill_int_urb(urb
, usb
, usb_sndbulkpipe(usb
, epnum
),
807 transfer_buffer
, buffer_length
, complete
, context
, interval
);
809 usb_fill_int_urb(urb
, usb
, usb_rcvbulkpipe(usb
, epnum
),
810 transfer_buffer
, buffer_length
, complete
, context
, interval
);
813 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
818 #ifdef ZM_ENABLE_CENC
819 int zfLnxCencSendMsg(struct sock
*netlink_sk
, u_int8_t
*msg
, int len
)
821 #define COMMTYPE_GROUP 8
822 #define WAI_K_MSG 0x11
826 unsigned char *old_tail
;
828 struct nlmsghdr
*nlh
;
831 size
= NLMSG_SPACE(len
);
832 skb
= alloc_skb(size
, GFP_ATOMIC
);
835 printk("dev_alloc_skb failure \n");
838 old_tail
= skb
->tail
;
841 nlh
= NLMSG_PUT(skb
, 0, 0, WAI_K_MSG
, size
-sizeof(*nlh
));
842 pos
= NLMSG_DATA(nlh
);
845 memcpy(pos
, msg
, len
);
847 nlh
->nlmsg_len
= skb
->tail
- old_tail
;
848 NETLINK_CB(skb
).dst_group
= COMMTYPE_GROUP
;
849 netlink_broadcast(netlink_sk
, skb
, 0, COMMTYPE_GROUP
, GFP_ATOMIC
);
857 #undef COMMTYPE_GROUP
860 #endif /*ZM_ENABLE_CENC*/
862 /* Simply return 0xffff if VAP function is not supported */
863 u16_t
zfLnxGetVapId(zdev_t
*dev
)
867 for (i
= 0; i
< ZM_VAP_PORT_NUMBER
; i
++) {
868 if (vap
[i
].dev
== dev
) {
875 u32_t
zfwReadReg(zdev_t
*dev
, u32_t offset
)
881 #define work_struct tq_struct
883 #define schedule_work(a) schedule_task(a)
885 #define flush_scheduled_work flush_scheduled_tasks
886 #define INIT_WORK(_wq, _routine, _data) INIT_TQUEUE(_wq, _routine, _data)
887 #define PREPARE_WORK(_wq, _routine, _data) PREPARE_TQUEUE(_wq, _routine, _data)
890 #define KEVENT_WATCHDOG 0x00000001
892 u32_t smp_kevent_Lock
= 0;
894 void kevent(struct work_struct
*work
)
896 struct usbdrv_private
*macp
=
897 container_of(work
, struct usbdrv_private
, kevent
);
898 zdev_t
*dev
= macp
->device
;
900 if (test_and_set_bit(0, (void *)&smp_kevent_Lock
)) {
901 /*schedule_work(&macp->kevent);*/
905 down(&macp
->ioctl_sem
);
907 if (test_and_clear_bit(KEVENT_WATCHDOG
, &macp
->kevent_flags
)) {
908 extern u16_t
zfHpStartRecv(zdev_t
*dev
);
909 /*zfiHwWatchDogReinit(dev);*/
910 printk(("\n ************ Hw watchDog occur!! ************** \n"));
912 zfiWlanResume(dev
, 0);
916 clear_bit(0, (void *)&smp_kevent_Lock
);
917 up(&macp
->ioctl_sem
);
920 /************************************************************************/
922 /* FUNCTION DESCRIPTION zfLnxCreateThread */
923 /* Create a Thread */
926 /* dev : device pointer */
932 /* Yuan-Gu Wei Atheros Communications, INC. 2007.3 */
934 /************************************************************************/
935 u8_t
zfLnxCreateThread(zdev_t
*dev
)
937 struct usbdrv_private
*macp
= dev
->ml_priv
;
939 /* Create Mutex and keventd */
940 INIT_WORK(&macp
->kevent
, kevent
);
941 init_MUTEX(&macp
->ioctl_sem
);
946 /************************************************************************/
948 /* FUNCTION DESCRIPTION zfLnxSignalThread */
949 /* Signal Thread with Flag */
952 /* dev : device pointer */
953 /* flag : signal thread flag */
959 /* Yuan-Gu Wei Atheros Communications, INC. 2007.3 */
961 /************************************************************************/
962 void zfLnxSignalThread(zdev_t
*dev
, int flag
)
964 struct usbdrv_private
*macp
= dev
->ml_priv
;
967 printk("macp is NULL\n");
971 if (0 && macp
->kevent_ready
!= 1) {
972 printk("Kevent not ready\n");
976 set_bit(flag
, &macp
->kevent_flags
);
978 if (!schedule_work(&macp
->kevent
)) {
980 //printk(KERN_ERR "schedule_task failed, flag = %x\n", flag);*/
984 /* Notify wrapper todo redownload firmware and reinit procedure when */
985 /* hardware watchdog occur : zfiHwWatchDogReinit() */
986 void zfLnxWatchDogNotify(zdev_t
*dev
)
988 zfLnxSignalThread(dev
, KEVENT_WATCHDOG
);
991 /* Query Durantion of Active Scan */
992 void zfwGetActiveScanDur(zdev_t
*dev
, u8_t
*Dur
)
994 *Dur
= 30; /* default 30 ms*/
997 void zfwGetShowZeroLengthSSID(zdev_t
*dev
, u8_t
*Dur
)