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 = dev->ml_priv;
61 unsigned long irqFlag;
63 spin_lock_irqsave(&macp->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(&macp->cs_lock, irqFlag);
84 void zfLnxPutTxUrb(zdev_t *dev)
86 struct usbdrv_private *macp = dev->ml_priv;
88 unsigned long irqFlag;
90 spin_lock_irqsave(&macp->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(&macp->cs_lock, irqFlag);
109 u16_t zfLnxCheckTxBufferCnt(zdev_t *dev)
111 struct usbdrv_private *macp = dev->ml_priv;
113 unsigned long irqFlag;
115 spin_lock_irqsave(&macp->cs_lock, irqFlag);
117 TxBufCnt = macp->TxBufCnt;
119 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
123 UsbTxQ_t *zfLnxGetUsbTxBuffer(zdev_t *dev)
125 struct usbdrv_private *macp = dev->ml_priv;
128 unsigned long irqFlag;
130 spin_lock_irqsave(&macp->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(&macp->cs_lock, irqFlag);
154 spin_unlock_irqrestore(&macp->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 = dev->ml_priv;
165 unsigned long irqFlag;
167 spin_lock_irqsave(&macp->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(&macp->cs_lock, irqFlag);
199 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
203 zbuf_t *zfLnxGetUsbRxBuffer(zdev_t *dev)
205 struct usbdrv_private *macp = dev->ml_priv;
208 unsigned long irqFlag;
210 spin_lock_irqsave(&macp->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(&macp->cs_lock, irqFlag);
229 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
233 u32_t zfLnxPutUsbRxBuffer(zdev_t *dev, zbuf_t *buf)
235 struct usbdrv_private *macp = dev->ml_priv;
237 unsigned long irqFlag;
239 spin_lock_irqsave(&macp->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(&macp->cs_lock, irqFlag);
258 spin_unlock_irqrestore(&macp->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 = dev->ml_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 = dev->ml_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 = dev->ml_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 = dev->ml_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 = dev->ml_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 = dev->ml_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 = dev->ml_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 = dev->ml_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 = dev->ml_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 = dev->ml_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 = dev->ml_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 = dev->ml_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)