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);
302 /* Enqueue skb buffer */
303 zfLnxPutUsbRxBuffer(dev, buf);
305 /* Submit a Rx urb */
306 zfLnxUsbIn(dev, urb, buf);
311 if (urb->actual_length == 0) {
312 printk(KERN_ERR "Get an URB whose length is zero");
316 /* Dequeue skb buffer */
317 buf = zfLnxGetUsbRxBuffer(dev);
319 /*zfwBufSetSize(dev, buf, urb->actual_length);*/
320 #ifdef NET_SKBUFF_DATA_USES_OFFSET
324 buf->tail = buf->data;
328 BUG_ON((buf->tail + urb->actual_length) > buf->end);
330 skb_put(buf, urb->actual_length);
332 #if ZM_USB_STREAM_MODE == 1
333 if (remain_len != 0) {
334 zbuf_t *remain_buf = macp->reamin_buf;
337 remain_len -= check_pad;
340 memcpy(&(remain_buf->data[check_len]), buf->data, remain_len);
341 check_len += remain_len;
344 rxBufPool[rxBufPoolIndex++] = remain_buf;
347 while (index < urb->actual_length) {
348 pkt_len = buf->data[index] + (buf->data[index+1] << 8);
349 pkt_tag = buf->data[index+2] + (buf->data[index+3] << 8);
351 if (pkt_tag == 0x4e00) {
354 /*printk("Get a packet, index: %d, pkt_len: 0x%04x\n", index, pkt_len);*/
357 for (ii = index; ii < pkt_len+4;) {
358 printk("%02x ", (buf->data[ii] & 0xff));
360 if ((++ii % 16) == 0)
367 pad_len = 4 - (pkt_len & 0x3);
373 index = index + 4 + pkt_len + pad_len;
375 if (index > ZM_MAX_RX_BUFFER_SIZE) {
376 remain_len = index - ZM_MAX_RX_BUFFER_SIZE; /* - pad_len;*/
377 check_len = ZM_MAX_RX_BUFFER_SIZE - chk_idx - 4;
380 /* Allocate a skb buffer */
381 /*new_buf = zfwBufAllocate(dev, ZM_MAX_RX_BUFFER_SIZE);*/
382 new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
384 /* Set skb buffer length */
385 #ifdef NET_SKBUFF_DATA_USES_OFFSET
389 new_buf->tail = new_buf->data;
393 skb_put(new_buf, pkt_len);
395 /* Copy the buffer */
396 memcpy(new_buf->data, &(buf->data[chk_idx+4]), check_len);
398 /* Record the buffer pointer */
399 macp->reamin_buf = new_buf;
401 #ifdef ZM_DONT_COPY_RX_BUFFER
402 if (rxBufPoolIndex == 0) {
403 new_buf = skb_clone(buf, GFP_ATOMIC);
405 new_buf->data = &(buf->data[chk_idx+4]);
406 new_buf->len = pkt_len;
409 /* Allocate a skb buffer */
410 new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
412 /* Set skb buffer length */
413 #ifdef NET_SKBUFF_DATA_USES_OFFSET
417 new_buf->tail = new_buf->data;
421 skb_put(new_buf, pkt_len);
423 /* Copy the buffer */
424 memcpy(new_buf->data, &(buf->data[chk_idx+4]), pkt_len);
426 #ifdef ZM_DONT_COPY_RX_BUFFER
429 rxBufPool[rxBufPoolIndex++] = new_buf;
432 printk(KERN_ERR "Can't find tag, pkt_len: 0x%04x, tag: 0x%04x\n", pkt_len, pkt_tag);
435 dev_kfree_skb_any(buf);
437 /* Allocate a skb buffer */
438 new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
440 /* Enqueue skb buffer */
441 zfLnxPutUsbRxBuffer(dev, new_buf);
443 /* Submit a Rx urb */
444 zfLnxUsbIn(dev, urb, new_buf);
451 dev_kfree_skb_any(buf);
454 /* Allocate a skb buffer */
455 new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
457 /* Enqueue skb buffer */
458 zfLnxPutUsbRxBuffer(dev, new_buf);
460 /* Submit a Rx urb */
461 zfLnxUsbIn(dev, urb, new_buf);
463 #if ZM_USB_STREAM_MODE == 1
464 for (ii = 0; ii < rxBufPoolIndex; ii++) {
465 macp->usbCbFunctions.zfcbUsbRecv(dev, rxBufPool[ii]);
468 /* pass data to upper layer */
469 macp->usbCbFunctions.zfcbUsbRecv(dev, buf);
473 void zfLnxUsbRegOut_callback(urb_t *urb)
475 /*dev_t* dev = urb->context;*/
477 /*printk(KERN_ERR "zfwUsbRegOut_callback\n");*/
480 void zfLnxUsbRegIn_callback(urb_t *urb)
482 zdev_t *dev = urb->context;
485 struct usbdrv_private *macp = dev->ml_priv;
487 /* Check status for URB */
488 if (urb->status != 0) {
489 printk("zfLnxUsbRegIn_callback() : status=0x%x\n", urb->status);
490 if ((urb->status != -ENOENT) && (urb->status != -ECONNRESET) && (urb->status != -ESHUTDOWN)) {
491 if (urb->status == -EPIPE) {
492 /*printk(KERN_ERR "nonzero read bulk status received: -EPIPE");*/
496 if (urb->status == -EPROTO) {
497 /*printk(KERN_ERR "nonzero read bulk status received: -EPROTO");*/
502 /*printk(KERN_ERR "urb->status: 0x%08x\n", urb->status);*/
506 if (urb->actual_length == 0) {
507 printk(KERN_ERR "Get an URB whose length is zero");
511 /* Copy data into respone buffer */
512 memcpy(rsp, macp->regUsbReadBuf, urb->actual_length);
514 /* Notify to upper layer */
515 /*zfIdlChkRsp(dev, rsp, (u16_t)urb->actual_length);*/
516 /*zfiUsbRegIn(dev, rsp, (u16_t)urb->actual_length);*/
517 macp->usbCbFunctions.zfcbUsbRegIn(dev, rsp, (u16_t)urb->actual_length);
519 /* Issue another USB IN URB */
520 zfLnxSubmitRegInUrb(dev);
523 u32_t zfLnxSubmitRegInUrb(zdev_t *dev)
526 struct usbdrv_private *macp = dev->ml_priv;
529 //ret = zfLnxUsbSubmitBulkUrb(macp->RegInUrb, macp->udev,
530 // USB_REG_IN_PIPE, USB_DIR_IN, macp->regUsbReadBuf,
531 // ZM_USB_REG_MAX_BUF_SIZE, zfLnxUsbRegIn_callback, dev);
534 // printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);*/
536 ret = zfLnxUsbSubmitIntUrb(macp->RegInUrb, macp->udev,
537 USB_REG_IN_PIPE, USB_DIR_IN, macp->regUsbReadBuf,
538 ZM_USB_REG_MAX_BUF_SIZE, zfLnxUsbRegIn_callback, dev, 1);
543 u32_t zfLnxUsbSubmitTxData(zdev_t *dev)
548 u8_t *puTxBuf = NULL;
551 struct usbdrv_private *macp = dev->ml_priv;
552 #if ZM_USB_TX_STREAM_MODE == 1
557 UsbTxQ_t *TxQPool[ZM_MAX_TX_AGGREGATE_NUM];
560 /* First check whether there is a free URB */
561 freeTxUrb = zfLnxGetFreeTxUrb(dev);
563 /* If there is no any free Tx Urb */
564 if (freeTxUrb == 0xffff) {
565 /*printk(KERN_ERR "Can't get free Tx Urb\n");
566 //printk("CWY - Can't get free Tx Urb\n");*/
570 #if ZM_USB_TX_STREAM_MODE == 1
571 usbTxAggCnt = zfLnxCheckTxBufferCnt(dev);
573 if (usbTxAggCnt >= ZM_MAX_TX_AGGREGATE_NUM) {
574 usbTxAggCnt = ZM_MAX_TX_AGGREGATE_NUM;
579 /*printk("usbTxAggCnt: %d\n", usbTxAggCnt);*/
582 #if ZM_USB_TX_STREAM_MODE == 1
583 for (ii = 0; ii < usbTxAggCnt; ii++) {
585 /* Dequeue the packet from UsbTxBufQ */
586 TxData = zfLnxGetUsbTxBuffer(dev);
587 if (TxData == NULL) {
588 /* Give the urb back */
593 /* Point to the freeTxUrb buffer */
594 puTxBuf = macp->txUsbBuf[freeTxUrb];
596 #if ZM_USB_TX_STREAM_MODE == 1
598 pUsbTxHdr = (u16_t *)puTxBuf;
600 /* Add the packet length and tag information */
601 *pUsbTxHdr++ = TxData->hdrlen + TxData->snapLen +
602 (TxData->buf->len - TxData->offset) + TxData->tailLen;
604 *pUsbTxHdr++ = 0x697e;
607 #endif /* #ifdef ZM_USB_TX_STREAM_MODE*/
609 /* Copy WLAN header and packet buffer into USB buffer */
610 for (i = 0; i < TxData->hdrlen; i++) {
611 *puTxBuf++ = TxData->hdr[i];
614 /* Copy SNAP header */
615 for (i = 0; i < TxData->snapLen; i++) {
616 *puTxBuf++ = TxData->snap[i];
619 /* Copy packet buffer */
620 for (i = 0; i < TxData->buf->len - TxData->offset; i++) {
621 /*puTxBuf++ = zmw_rx_buf_readb(dev, TxData->buf, i);*/
622 *puTxBuf++ = *(u8_t *)((u8_t *)TxData->buf->data+i+TxData->offset);
626 for (i = 0; i < TxData->tailLen; i++) {
627 *puTxBuf++ = TxData->tail[i];
630 len = TxData->hdrlen+TxData->snapLen+TxData->buf->len+TxData->tailLen-TxData->offset;
633 if (TxData->hdrlen != 0) {
634 puTxBuf = macp->txUsbBuf[freeTxUrb];
635 for (i = 0; i < len; i++) {
636 printk("%02x ", puTxBuf[i]);
644 /* For debug purpose */
645 if (TxData->hdr[9] & 0x40) {
647 u16_t ctrlLen = TxData->hdr[0] + (TxData->hdr[1] << 8);
649 if (ctrlLen != len + 4) {
650 /* Dump control setting */
651 for (i = 0; i < 8; i++) {
652 printk(KERN_ERR "0x%02x ", TxData->hdr[i]);
654 printk(KERN_ERR "\n");
656 printk(KERN_ERR "ctrLen: %d, hdrLen: %d, snapLen: %d\n", ctrlLen, TxData->hdrlen, TxData->snapLen);
657 printk(KERN_ERR "bufLen: %d, tailLen: %d, len: %d\n", TxData->buf->len, TxData->tailLen, len);
662 #if ZM_USB_TX_STREAM_MODE == 1
663 /* Add the Length and Tag*/
666 /*printk("%d packet, length: %d\n", ii+1, len);*/
668 if (ii < (ZM_MAX_TX_AGGREGATE_NUM-1)) {
669 /* Pad the buffer to firmware descriptor boundary */
670 offset += (((len-1) / 4) + 1) * 4;
673 if (ii == (ZM_MAX_TX_AGGREGATE_NUM-1)) {
677 TxQPool[ii] = TxData;
679 /*DbgPrint("%d packet, offset: %d\n", ii+1, pUsbTxTransfer->offset);*/
682 /*zfBufFree(dev, txData->buf);*/
685 /*printk("CWY - call zfwUsbSubmitBulkUrb(), len = 0x%d\n", len);*/
686 /* Submit a tx urb */
687 ret = zfLnxUsbSubmitBulkUrb(macp->WlanTxDataUrb[freeTxUrb], macp->udev,
688 USB_WLAN_TX_PIPE, USB_DIR_OUT, macp->txUsbBuf[freeTxUrb],
689 len, zfLnxUsbDataOut_callback, dev);
692 // printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);*/
695 /*dev_kfree_skb_any(TxData->buf);*/
696 #if ZM_USB_TX_STREAM_MODE == 1
697 for (ii = 0; ii < usbTxAggCnt; ii++)
698 macp->usbCbFunctions.zfcbUsbOutComplete(dev, TxQPool[ii]->buf, 1, TxQPool[ii]->hdr);
700 macp->usbCbFunctions.zfcbUsbOutComplete(dev, TxData->buf, 1, TxData->hdr);
708 u32_t zfLnxUsbIn(zdev_t *dev, urb_t *urb, zbuf_t *buf)
711 struct usbdrv_private *macp = dev->ml_priv;
713 /* Submit a rx urb */
714 ret = zfLnxUsbSubmitBulkUrb(urb, macp->udev, USB_WLAN_RX_PIPE,
715 USB_DIR_IN, buf->data, ZM_MAX_RX_BUFFER_SIZE,
716 zfLnxUsbDataIn_callback, dev);
719 // printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);*/
724 u32_t zfLnxUsbWriteReg(zdev_t *dev, u32_t *cmd, u16_t cmdLen)
726 struct usbdrv_private *macp = dev->ml_priv;
729 #ifdef ZM_CONFIG_BIG_ENDIAN
732 for (ii = 0; ii < (cmdLen>>2); ii++)
733 cmd[ii] = cpu_to_le32(cmd[ii]);
736 memcpy(macp->regUsbWriteBuf, cmd, cmdLen);
738 /* Issue an USB Out transfer */
739 /* Submit a tx urb */
740 ret = zfLnxUsbSubmitIntUrb(macp->RegOutUrb, macp->udev,
741 USB_REG_OUT_PIPE, USB_DIR_OUT, macp->regUsbWriteBuf,
742 cmdLen, zfLnxUsbRegOut_callback, dev, 1);
748 u32_t zfLnxUsbOut(zdev_t *dev, u8_t *hdr, u16_t hdrlen, u8_t *snap, u16_t snapLen,
749 u8_t *tail, u16_t tailLen, zbuf_t *buf, u16_t offset)
752 struct usbdrv_private *macp = dev->ml_priv;
754 /* Check length of tail buffer */
755 /*zm_assert((tailLen <= 16));*/
757 /* Enqueue the packet into UsbTxBufQ */
758 if (zfLnxPutUsbTxBuffer(dev, hdr, hdrlen, snap, snapLen, tail, tailLen, buf, offset) == 0xffff) {
760 /*printk("CWY - zfwPutUsbTxBuffer Error, free packet\n");
761 //dev_kfree_skb_any(buf);*/
762 macp->usbCbFunctions.zfcbUsbOutComplete(dev, buf, 0, hdr);
767 //printk("CWY - call zfwUsbSubmitTxData()\n");*/
768 ret = zfLnxUsbSubmitTxData(dev);
772 void zfLnxInitUsbTxQ(zdev_t *dev)
774 struct usbdrv_private *macp = dev->ml_priv;
776 printk(KERN_ERR "zfwInitUsbTxQ\n");
778 /* Zero memory for UsbTxBufQ */
779 memset(macp->UsbTxBufQ, 0, sizeof(UsbTxQ_t) * ZM_MAX_TX_URB_NUM);
785 macp->TxUrbCnt = ZM_MAX_TX_URB_NUM;
788 void zfLnxInitUsbRxQ(zdev_t *dev)
792 struct usbdrv_private *macp = dev->ml_priv;
794 /* Zero memory for UsbRxBufQ */
795 memset(macp->UsbRxBufQ, 0, sizeof(zbuf_t *) * ZM_MAX_RX_URB_NUM);
799 for (i = 0; i < ZM_MAX_RX_URB_NUM; i++) {
800 /*buf = zfwBufAllocate(dev, ZM_MAX_RX_BUFFER_SIZE);*/
801 buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
802 macp->UsbRxBufQ[i] = buf;
805 /*macp->RxBufTail = ZM_MAX_RX_URB_NUM - 1;*/
808 /* Submit all Rx urbs */
809 for (i = 0; i < ZM_MAX_RX_URB_NUM; i++) {
810 zfLnxPutUsbRxBuffer(dev, macp->UsbRxBufQ[i]);
811 zfLnxUsbIn(dev, macp->WlanRxDataUrb[i], macp->UsbRxBufQ[i]);
817 u32_t zfLnxUsbSubmitBulkUrb(urb_t *urb, struct usb_device *usb, u16_t epnum, u16_t direction,
818 void *transfer_buffer, int buffer_length, usb_complete_t complete, void *context)
822 if (direction == USB_DIR_OUT) {
823 usb_fill_bulk_urb(urb, usb, usb_sndbulkpipe(usb, epnum),
824 transfer_buffer, buffer_length, complete, context);
826 urb->transfer_flags |= URB_ZERO_PACKET;
828 usb_fill_bulk_urb(urb, usb, usb_rcvbulkpipe(usb, epnum),
829 transfer_buffer, buffer_length, complete, context);
834 /*printk("CWY - urb->hcpriv set by unknown reason, reset it\n");
839 ret = usb_submit_urb(urb, GFP_ATOMIC);
840 if ((epnum == 4) & (ret != 0)) {
841 /*printk("CWY - ret = %x\n", ret);*/
846 u32_t zfLnxUsbSubmitIntUrb(urb_t *urb, struct usb_device *usb, u16_t epnum, u16_t direction,
847 void *transfer_buffer, int buffer_length, usb_complete_t complete, void *context,
852 if (direction == USB_DIR_OUT) {
853 usb_fill_int_urb(urb, usb, usb_sndbulkpipe(usb, epnum),
854 transfer_buffer, buffer_length, complete, context, interval);
856 usb_fill_int_urb(urb, usb, usb_rcvbulkpipe(usb, epnum),
857 transfer_buffer, buffer_length, complete, context, interval);
860 ret = usb_submit_urb(urb, GFP_ATOMIC);
865 #ifdef ZM_ENABLE_CENC
866 int zfLnxCencSendMsg(struct sock *netlink_sk, u_int8_t *msg, int len)
868 #define COMMTYPE_GROUP 8
869 #define WAI_K_MSG 0x11
873 unsigned char *old_tail;
875 struct nlmsghdr *nlh;
878 size = NLMSG_SPACE(len);
879 skb = alloc_skb(size, GFP_ATOMIC);
882 printk("dev_alloc_skb failure \n");
885 old_tail = skb->tail;
888 nlh = NLMSG_PUT(skb, 0, 0, WAI_K_MSG, size-sizeof(*nlh));
889 pos = NLMSG_DATA(nlh);
892 memcpy(pos, msg, len);
894 nlh->nlmsg_len = skb->tail - old_tail;
895 NETLINK_CB(skb).dst_group = COMMTYPE_GROUP;
896 netlink_broadcast(netlink_sk, skb, 0, COMMTYPE_GROUP, GFP_ATOMIC);
904 #undef COMMTYPE_GROUP
907 #endif /*ZM_ENABLE_CENC*/
909 /* Simply return 0xffff if VAP function is not supported */
910 u16_t zfLnxGetVapId(zdev_t *dev)
914 for (i = 0; i < ZM_VAP_PORT_NUMBER; i++) {
915 if (vap[i].dev == dev) {
922 u32_t zfwReadReg(zdev_t *dev, u32_t offset)
928 #define work_struct tq_struct
930 #define schedule_work(a) schedule_task(a)
932 #define flush_scheduled_work flush_scheduled_tasks
933 #define INIT_WORK(_wq, _routine, _data) INIT_TQUEUE(_wq, _routine, _data)
934 #define PREPARE_WORK(_wq, _routine, _data) PREPARE_TQUEUE(_wq, _routine, _data)
937 #define KEVENT_WATCHDOG 0x00000001
939 u32_t smp_kevent_Lock = 0;
941 void kevent(struct work_struct *work)
943 struct usbdrv_private *macp =
944 container_of(work, struct usbdrv_private, kevent);
945 zdev_t *dev = macp->device;
947 if (test_and_set_bit(0, (void *)&smp_kevent_Lock)) {
948 /*schedule_work(&macp->kevent);*/
952 down(&macp->ioctl_sem);
954 if (test_and_clear_bit(KEVENT_WATCHDOG, &macp->kevent_flags)) {
955 extern u16_t zfHpStartRecv(zdev_t *dev);
956 /*zfiHwWatchDogReinit(dev);*/
957 printk(("\n ************ Hw watchDog occur!! ************** \n"));
959 zfiWlanResume(dev , 0);
963 clear_bit(0, (void *)&smp_kevent_Lock);
964 up(&macp->ioctl_sem);
967 /************************************************************************/
969 /* FUNCTION DESCRIPTION zfLnxCreateThread */
970 /* Create a Thread */
973 /* dev : device pointer */
979 /* Yuan-Gu Wei Atheros Communications, INC. 2007.3 */
981 /************************************************************************/
982 u8_t zfLnxCreateThread(zdev_t *dev)
984 struct usbdrv_private *macp = dev->ml_priv;
986 /* Create Mutex and keventd */
987 INIT_WORK(&macp->kevent, kevent);
988 init_MUTEX(&macp->ioctl_sem);
993 /************************************************************************/
995 /* FUNCTION DESCRIPTION zfLnxSignalThread */
996 /* Signal Thread with Flag */
999 /* dev : device pointer */
1000 /* flag : signal thread flag */
1006 /* Yuan-Gu Wei Atheros Communications, INC. 2007.3 */
1008 /************************************************************************/
1009 void zfLnxSignalThread(zdev_t *dev, int flag)
1011 struct usbdrv_private *macp = dev->ml_priv;
1014 printk("macp is NULL\n");
1018 if (0 && macp->kevent_ready != 1) {
1019 printk("Kevent not ready\n");
1023 set_bit(flag, &macp->kevent_flags);
1025 if (!schedule_work(&macp->kevent)) {
1027 //printk(KERN_ERR "schedule_task failed, flag = %x\n", flag);*/
1031 /* Notify wrapper todo redownload firmware and reinit procedure when */
1032 /* hardware watchdog occur : zfiHwWatchDogReinit() */
1033 void zfLnxWatchDogNotify(zdev_t *dev)
1035 zfLnxSignalThread(dev, KEVENT_WATCHDOG);
1038 /* Query Durantion of Active Scan */
1039 void zfwGetActiveScanDur(zdev_t *dev, u8_t *Dur)
1041 *Dur = 30; /* default 30 ms*/
1044 void zfwGetShowZeroLengthSSID(zdev_t *dev, u8_t *Dur)