1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include "oal_dt.h"
26#include "usbdrv.h"
27
28#include <linux/netlink.h>
29#include <net/iw_handler.h>
30
31extern void zfiRecv80211(zdev_t* dev, zbuf_t* buf, struct zsAdditionInfo* addInfo);
32extern void zfCoreRecv(zdev_t* dev, zbuf_t* buf, struct zsAdditionInfo* addInfo);
33extern void zfIdlChkRsp(zdev_t* dev, u32_t* rsp, u16_t rspLen);
34extern void zfIdlRsp(zdev_t* dev, u32_t *rsp, u16_t rspLen);
35
36
37
38
39extern struct zsVapStruct vap[ZM_VAP_PORT_NUMBER];
40
41u32_t zfLnxUsbSubmitTxData(zdev_t* dev);
42u32_t zfLnxUsbIn(zdev_t* dev, urb_t *urb, zbuf_t *buf);
43u32_t zfLnxSubmitRegInUrb(zdev_t *dev);
44u32_t zfLnxUsbSubmitBulkUrb(urb_t *urb, struct usb_device *usb, u16_t epnum, u16_t direction,
45 void *transfer_buffer, int buffer_length, usb_complete_t complete, void *context);
46u32_t zfLnxUsbSubmitIntUrb(urb_t *urb, struct usb_device *usb, u16_t epnum, u16_t direction,
47 void *transfer_buffer, int buffer_length, usb_complete_t complete, void *context,
48 u32_t interval);
49
50u16_t zfLnxGetFreeTxUrb(zdev_t *dev)
51{
52 struct usbdrv_private *macp = dev->ml_priv;
53 u16_t idx;
54 unsigned long irqFlag;
55
56 spin_lock_irqsave(&macp->cs_lock, irqFlag);
57
58
59
60
61 if (macp->TxUrbCnt != 0)
62 {
63 idx = macp->TxUrbTail;
64 macp->TxUrbTail = ((macp->TxUrbTail + 1) & (ZM_MAX_TX_URB_NUM - 1));
65 macp->TxUrbCnt--;
66 }
67 else
68 {
69
70 idx = 0xffff;
71 }
72
73 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
74 return idx;
75}
76
77void zfLnxPutTxUrb(zdev_t *dev)
78{
79 struct usbdrv_private *macp = dev->ml_priv;
80 u16_t idx;
81 unsigned long irqFlag;
82
83 spin_lock_irqsave(&macp->cs_lock, irqFlag);
84
85 idx = ((macp->TxUrbHead + 1) & (ZM_MAX_TX_URB_NUM - 1));
86
87
88 if (macp->TxUrbCnt < ZM_MAX_TX_URB_NUM)
89 {
90 macp->TxUrbHead = idx;
91 macp->TxUrbCnt++;
92 }
93 else
94 {
95 printk("UsbTxUrbQ inconsistent: TxUrbHead: %d, TxUrbTail: %d\n",
96 macp->TxUrbHead, macp->TxUrbTail);
97 }
98
99 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
100}
101
102u16_t zfLnxCheckTxBufferCnt(zdev_t *dev)
103{
104 struct usbdrv_private *macp = dev->ml_priv;
105 u16_t TxBufCnt;
106 unsigned long irqFlag;
107
108 spin_lock_irqsave(&macp->cs_lock, irqFlag);
109
110 TxBufCnt = macp->TxBufCnt;
111
112 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
113 return TxBufCnt;
114}
115
116UsbTxQ_t *zfLnxGetUsbTxBuffer(zdev_t *dev)
117{
118 struct usbdrv_private *macp = dev->ml_priv;
119 u16_t idx;
120 UsbTxQ_t *TxQ;
121 unsigned long irqFlag;
122
123 spin_lock_irqsave(&macp->cs_lock, irqFlag);
124
125 idx = ((macp->TxBufHead+1) & (ZM_MAX_TX_BUF_NUM - 1));
126
127
128 if (macp->TxBufCnt > 0)
129 {
130
131 TxQ = (UsbTxQ_t *)&(macp->UsbTxBufQ[macp->TxBufHead]);
132 macp->TxBufHead = ((macp->TxBufHead+1) & (ZM_MAX_TX_BUF_NUM - 1));
133 macp->TxBufCnt--;
134 }
135 else
136 {
137 if (macp->TxBufHead != macp->TxBufTail)
138 {
139 printk(KERN_ERR "zfwGetUsbTxBuf UsbTxBufQ inconsistent: TxBufHead: %d, TxBufTail: %d\n",
140 macp->TxBufHead, macp->TxBufTail);
141 }
142
143 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
144 return NULL;
145 }
146
147 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
148 return TxQ;
149}
150
151u16_t zfLnxPutUsbTxBuffer(zdev_t *dev, u8_t *hdr, u16_t hdrlen,
152 u8_t *snap, u16_t snapLen, u8_t *tail, u16_t tailLen,
153 zbuf_t *buf, u16_t offset)
154{
155 struct usbdrv_private *macp = dev->ml_priv;
156 u16_t idx;
157 UsbTxQ_t *TxQ;
158 unsigned long irqFlag;
159
160 spin_lock_irqsave(&macp->cs_lock, irqFlag);
161
162 idx = ((macp->TxBufTail+1) & (ZM_MAX_TX_BUF_NUM - 1));
163
164
165
166
167
168 if (macp->TxBufCnt < ZM_MAX_TX_BUF_NUM)
169 {
170
171 TxQ = (UsbTxQ_t *)&(macp->UsbTxBufQ[macp->TxBufTail]);
172 memcpy(TxQ->hdr, hdr, hdrlen);
173 TxQ->hdrlen = hdrlen;
174 memcpy(TxQ->snap, snap, snapLen);
175 TxQ->snapLen = snapLen;
176 memcpy(TxQ->tail, tail, tailLen);
177 TxQ->tailLen = tailLen;
178 TxQ->buf = buf;
179 TxQ->offset = offset;
180
181 macp->TxBufTail = ((macp->TxBufTail+1) & (ZM_MAX_TX_BUF_NUM - 1));
182 macp->TxBufCnt++;
183 }
184 else
185 {
186 printk(KERN_ERR "zfLnxPutUsbTxBuffer UsbTxBufQ inconsistent: TxBufHead: %d, TxBufTail: %d, TxBufCnt: %d\n",
187 macp->TxBufHead, macp->TxBufTail, macp->TxBufCnt);
188 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
189 return 0xffff;
190 }
191
192 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
193 return 0;
194}
195
196zbuf_t *zfLnxGetUsbRxBuffer(zdev_t *dev)
197{
198 struct usbdrv_private *macp = dev->ml_priv;
199
200 zbuf_t *buf;
201 unsigned long irqFlag;
202
203 spin_lock_irqsave(&macp->cs_lock, irqFlag);
204
205
206
207
208 if (macp->RxBufCnt != 0)
209 {
210 buf = macp->UsbRxBufQ[macp->RxBufHead];
211 macp->RxBufHead = ((macp->RxBufHead+1) & (ZM_MAX_RX_URB_NUM - 1));
212 macp->RxBufCnt--;
213 }
214 else
215 {
216 printk("RxBufQ inconsistent: RxBufHead: %d, RxBufTail: %d\n",
217 macp->RxBufHead, macp->RxBufTail);
218 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
219 return NULL;
220 }
221
222 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
223 return buf;
224}
225
226u32_t zfLnxPutUsbRxBuffer(zdev_t *dev, zbuf_t *buf)
227{
228 struct usbdrv_private *macp = dev->ml_priv;
229 u16_t idx;
230 unsigned long irqFlag;
231
232 spin_lock_irqsave(&macp->cs_lock, irqFlag);
233
234 idx = ((macp->RxBufTail+1) & (ZM_MAX_RX_URB_NUM - 1));
235
236
237 if (macp->RxBufCnt != ZM_MAX_RX_URB_NUM)
238 {
239 macp->UsbRxBufQ[macp->RxBufTail] = buf;
240 macp->RxBufTail = idx;
241 macp->RxBufCnt++;
242 }
243 else
244 {
245 printk("RxBufQ inconsistent: RxBufHead: %d, RxBufTail: %d\n",
246 macp->RxBufHead, macp->RxBufTail);
247 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
248 return 0xffff;
249 }
250
251 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
252 return 0;
253}
254
255void zfLnxUsbDataOut_callback(urb_t *urb)
256{
257 zdev_t* dev = urb->context;
258
259
260
261 zfLnxPutTxUrb(dev);
262
263
264
265 if (zfLnxCheckTxBufferCnt(dev) != 0)
266 {
267
268
269
270
271
272
273
274
275
276 zfLnxUsbSubmitTxData(dev);
277
278 }
279}
280
281void zfLnxUsbDataIn_callback(urb_t *urb)
282{
283 zdev_t* dev = urb->context;
284 struct usbdrv_private *macp = dev->ml_priv;
285 zbuf_t *buf;
286 zbuf_t *new_buf;
287 int status;
288
289#if ZM_USB_STREAM_MODE == 1
290 static int remain_len = 0, check_pad = 0, check_len = 0;
291 int index = 0;
292 int chk_idx;
293 u16_t pkt_len;
294 u16_t pkt_tag;
295 u16_t ii;
296 zbuf_t *rxBufPool[8];
297 u16_t rxBufPoolIndex = 0;
298#endif
299
300
301 if (urb->status != 0){
302 printk("zfLnxUsbDataIn_callback() : status=0x%x\n", urb->status);
303 if ((urb->status != -ENOENT) && (urb->status != -ECONNRESET)
304 && (urb->status != -ESHUTDOWN))
305 {
306 if (urb->status == -EPIPE){
307
308 status = -1;
309 }
310
311 if (urb->status == -EPROTO){
312
313 status = -1;
314 }
315 }
316
317
318
319
320 buf = zfLnxGetUsbRxBuffer(dev);
321 dev_kfree_skb_any(buf);
322 #if 0
323
324 zfLnxPutUsbRxBuffer(dev, buf);
325
326
327 zfLnxUsbIn(dev, urb, buf);
328 #endif
329 return;
330 }
331
332 if (urb->actual_length == 0)
333 {
334 printk(KERN_ERR "Get an URB whose length is zero");
335 status = -1;
336 }
337
338
339 buf = zfLnxGetUsbRxBuffer(dev);
340
341
342#ifdef NET_SKBUFF_DATA_USES_OFFSET
343 buf->tail = 0;
344 buf->len = 0;
345#else
346 buf->tail = buf->data;
347 buf->len = 0;
348#endif
349
350 BUG_ON((buf->tail + urb->actual_length) > buf->end);
351
352 skb_put(buf, urb->actual_length);
353
354#if ZM_USB_STREAM_MODE == 1
355 if (remain_len != 0)
356 {
357 zbuf_t *remain_buf = macp->reamin_buf;
358
359 index = remain_len;
360 remain_len -= check_pad;
361
362
363 memcpy(&(remain_buf->data[check_len]), buf->data, remain_len);
364 check_len += remain_len;
365 remain_len = 0;
366
367 rxBufPool[rxBufPoolIndex++] = remain_buf;
368 }
369
370 while(index < urb->actual_length)
371 {
372 pkt_len = buf->data[index] + (buf->data[index+1] << 8);
373 pkt_tag = buf->data[index+2] + (buf->data[index+3] << 8);
374
375 if (pkt_tag == 0x4e00)
376 {
377 int pad_len;
378
379
380 #if 0
381
382 for (ii = index; ii < pkt_len+4;)
383 {
384 printk("%02x ", (buf->data[ii] & 0xff));
385
386 if ((++ii % 16) == 0)
387 printk("\n");
388 }
389
390 printk("\n");
391 #endif
392
393 pad_len = 4 - (pkt_len & 0x3);
394
395 if(pad_len == 4)
396 pad_len = 0;
397
398 chk_idx = index;
399 index = index + 4 + pkt_len + pad_len;
400
401 if (index > ZM_MAX_RX_BUFFER_SIZE)
402 {
403 remain_len = index - ZM_MAX_RX_BUFFER_SIZE;
404 check_len = ZM_MAX_RX_BUFFER_SIZE - chk_idx - 4;
405 check_pad = pad_len;
406
407
408
409 new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
410
411
412 #ifdef NET_SKBUFF_DATA_USES_OFFSET
413 new_buf->tail = 0;
414 new_buf->len = 0;
415 #else
416 new_buf->tail = new_buf->data;
417 new_buf->len = 0;
418 #endif
419
420 skb_put(new_buf, pkt_len);
421
422
423 memcpy(new_buf->data, &(buf->data[chk_idx+4]), check_len);
424
425
426 macp->reamin_buf = new_buf;
427 }
428 else
429 {
430 #ifdef ZM_DONT_COPY_RX_BUFFER
431 if (rxBufPoolIndex == 0)
432 {
433 new_buf = skb_clone(buf, GFP_ATOMIC);
434
435 new_buf->data = &(buf->data[chk_idx+4]);
436 new_buf->len = pkt_len;
437 }
438 else
439 {
440 #endif
441
442 new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
443
444
445 #ifdef NET_SKBUFF_DATA_USES_OFFSET
446 new_buf->tail = 0;
447 new_buf->len = 0;
448 #else
449 new_buf->tail = new_buf->data;
450 new_buf->len = 0;
451 #endif
452
453 skb_put(new_buf, pkt_len);
454
455
456 memcpy(new_buf->data, &(buf->data[chk_idx+4]), pkt_len);
457
458 #ifdef ZM_DONT_COPY_RX_BUFFER
459 }
460 #endif
461 rxBufPool[rxBufPoolIndex++] = new_buf;
462 }
463 }
464 else
465 {
466 printk(KERN_ERR "Can't find tag, pkt_len: 0x%04x, tag: 0x%04x\n", pkt_len, pkt_tag);
467
468
469 dev_kfree_skb_any(buf);
470
471
472 new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
473
474
475 zfLnxPutUsbRxBuffer(dev, new_buf);
476
477
478 zfLnxUsbIn(dev, urb, new_buf);
479
480 return;
481 }
482 }
483
484
485 dev_kfree_skb_any(buf);
486#endif
487
488
489 new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
490
491
492 zfLnxPutUsbRxBuffer(dev, new_buf);
493
494
495 zfLnxUsbIn(dev, urb, new_buf);
496
497#if ZM_USB_STREAM_MODE == 1
498 for(ii = 0; ii < rxBufPoolIndex; ii++)
499 {
500 macp->usbCbFunctions.zfcbUsbRecv(dev, rxBufPool[ii]);
501 }
502#else
503
504 macp->usbCbFunctions.zfcbUsbRecv(dev, buf);
505#endif
506}
507
508void zfLnxUsbRegOut_callback(urb_t *urb)
509{
510
511
512
513}
514
515void zfLnxUsbRegIn_callback(urb_t *urb)
516{
517 zdev_t* dev = urb->context;
518 u32_t rsp[64/4];
519 int status;
520 struct usbdrv_private *macp = dev->ml_priv;
521
522
523 if (urb->status != 0){
524 printk("zfLnxUsbRegIn_callback() : status=0x%x\n", urb->status);
525 if ((urb->status != -ENOENT) && (urb->status != -ECONNRESET)
526 && (urb->status != -ESHUTDOWN))
527 {
528 if (urb->status == -EPIPE){
529
530 status = -1;
531 }
532
533 if (urb->status == -EPROTO){
534
535 status = -1;
536 }
537 }
538
539
540 return;
541 }
542
543 if (urb->actual_length == 0)
544 {
545 printk(KERN_ERR "Get an URB whose length is zero");
546 status = -1;
547 }
548
549
550 memcpy(rsp, macp->regUsbReadBuf, urb->actual_length);
551
552
553
554
555 macp->usbCbFunctions.zfcbUsbRegIn(dev, rsp, (u16_t)urb->actual_length);
556
557
558 zfLnxSubmitRegInUrb(dev);
559}
560
561u32_t zfLnxSubmitRegInUrb(zdev_t *dev)
562{
563 u32_t ret;
564 struct usbdrv_private *macp = dev->ml_priv;
565
566
567
568
569
570
571
572
573
574 ret = zfLnxUsbSubmitIntUrb(macp->RegInUrb, macp->udev,
575 USB_REG_IN_PIPE, USB_DIR_IN, macp->regUsbReadBuf,
576 ZM_USB_REG_MAX_BUF_SIZE, zfLnxUsbRegIn_callback, dev, 1);
577
578 return ret;
579}
580
581u32_t zfLnxUsbSubmitTxData(zdev_t* dev)
582{
583 u32_t i;
584 u32_t ret;
585 u16_t freeTxUrb;
586 u8_t *puTxBuf = NULL;
587 UsbTxQ_t *TxData;
588 int len = 0;
589 struct usbdrv_private *macp = dev->ml_priv;
590#if ZM_USB_TX_STREAM_MODE == 1
591 u8_t ii;
592 u16_t offset = 0;
593 u16_t usbTxAggCnt;
594 u16_t *pUsbTxHdr;
595 UsbTxQ_t *TxQPool[ZM_MAX_TX_AGGREGATE_NUM];
596#endif
597
598
599 freeTxUrb = zfLnxGetFreeTxUrb(dev);
600
601
602 if (freeTxUrb == 0xffff)
603 {
604
605
606 return 0xffff;
607 }
608
609#if ZM_USB_TX_STREAM_MODE == 1
610 usbTxAggCnt = zfLnxCheckTxBufferCnt(dev);
611
612 if (usbTxAggCnt >= ZM_MAX_TX_AGGREGATE_NUM)
613 {
614 usbTxAggCnt = ZM_MAX_TX_AGGREGATE_NUM;
615 }
616 else
617 {
618 usbTxAggCnt = 1;
619 }
620
621
622#endif
623
624#if ZM_USB_TX_STREAM_MODE == 1
625 for(ii = 0; ii < usbTxAggCnt; ii++)
626 {
627#endif
628
629 TxData = zfLnxGetUsbTxBuffer(dev);
630 if (TxData == NULL)
631 {
632
633 zfLnxPutTxUrb(dev);
634 return 0xffff;
635 }
636
637
638 puTxBuf = macp->txUsbBuf[freeTxUrb];
639
640#if ZM_USB_TX_STREAM_MODE == 1
641 puTxBuf += offset;
642 pUsbTxHdr = (u16_t *)puTxBuf;
643
644
645 *pUsbTxHdr++ = TxData->hdrlen + TxData->snapLen +
646 (TxData->buf->len - TxData->offset) + TxData->tailLen;
647
648 *pUsbTxHdr++ = 0x697e;
649
650 puTxBuf += 4;
651#endif
652
653
654 for(i = 0; i < TxData->hdrlen; i++)
655 {
656 *puTxBuf++ = TxData->hdr[i];
657 }
658
659
660 for(i = 0; i < TxData->snapLen; i++)
661 {
662 *puTxBuf++ = TxData->snap[i];
663 }
664
665
666 for(i = 0; i < TxData->buf->len - TxData->offset; i++)
667 {
668
669 *puTxBuf++ = *(u8_t*)((u8_t*)TxData->buf->data+i+TxData->offset);
670 }
671
672
673 for(i = 0; i < TxData->tailLen; i++)
674 {
675 *puTxBuf++ = TxData->tail[i];
676 }
677
678 len = TxData->hdrlen+TxData->snapLen+TxData->buf->len+TxData->tailLen-TxData->offset;
679
680 #if 0
681 if (TxData->hdrlen != 0)
682 {
683 puTxBuf = macp->txUsbBuf[freeTxUrb];
684 for (i = 0; i < len; i++)
685 {
686 printk("%02x ", puTxBuf[i]);
687 if (i % 16 == 15)
688 printk("\n");
689 }
690 printk("\n");
691 }
692 #endif
693 #if 0
694
695 if(TxData->hdr[9] & 0x40)
696 {
697 int i;
698 u16_t ctrlLen = TxData->hdr[0] + (TxData->hdr[1] << 8);
699
700 if (ctrlLen != len + 4)
701 {
702
703 for(i = 0; i < 8; i++)
704 {
705 printk(KERN_ERR "0x%02x ", TxData->hdr[i]);
706 }
707 printk(KERN_ERR "\n");
708
709 printk(KERN_ERR "ctrLen: %d, hdrLen: %d, snapLen: %d\n", ctrlLen, TxData->hdrlen, TxData->snapLen);
710 printk(KERN_ERR "bufLen: %d, tailLen: %d, len: %d\n", TxData->buf->len, TxData->tailLen, len);
711 }
712 }
713 #endif
714
715#if ZM_USB_TX_STREAM_MODE == 1
716
717 len += 4;
718
719
720
721 if (ii < (ZM_MAX_TX_AGGREGATE_NUM-1))
722 {
723
724 offset += (((len-1) / 4) + 1) * 4;
725 }
726
727 if (ii == (ZM_MAX_TX_AGGREGATE_NUM-1))
728 {
729 len += offset;
730 }
731
732 TxQPool[ii] = TxData;
733
734
735
736
737
738 }
739#endif
740
741
742 ret = zfLnxUsbSubmitBulkUrb(macp->WlanTxDataUrb[freeTxUrb], macp->udev,
743 USB_WLAN_TX_PIPE, USB_DIR_OUT, macp->txUsbBuf[freeTxUrb],
744 len, zfLnxUsbDataOut_callback, dev);
745
746
747
748
749
750
751#if ZM_USB_TX_STREAM_MODE == 1
752 for(ii = 0; ii < usbTxAggCnt; ii++)
753 macp->usbCbFunctions.zfcbUsbOutComplete(dev, TxQPool[ii]->buf, 1, TxQPool[ii]->hdr);
754#else
755 macp->usbCbFunctions.zfcbUsbOutComplete(dev, TxData->buf, 1, TxData->hdr);
756#endif
757
758 return ret;
759}
760
761
762
763u32_t zfLnxUsbIn(zdev_t* dev, urb_t *urb, zbuf_t *buf)
764{
765 u32_t ret;
766 struct usbdrv_private *macp = dev->ml_priv;
767
768
769 ret = zfLnxUsbSubmitBulkUrb(urb, macp->udev, USB_WLAN_RX_PIPE,
770 USB_DIR_IN, buf->data, ZM_MAX_RX_BUFFER_SIZE,
771 zfLnxUsbDataIn_callback, dev);
772
773
774
775
776 return ret;
777}
778
779u32_t zfLnxUsbWriteReg(zdev_t* dev, u32_t* cmd, u16_t cmdLen)
780{
781 struct usbdrv_private *macp = dev->ml_priv;
782 u32_t ret;
783
784#ifdef ZM_CONFIG_BIG_ENDIAN
785 int ii = 0;
786
787 for(ii=0; ii<(cmdLen>>2); ii++)
788 cmd[ii] = cpu_to_le32(cmd[ii]);
789#endif
790
791 memcpy(macp->regUsbWriteBuf, cmd, cmdLen);
792
793
794
795 ret = zfLnxUsbSubmitIntUrb(macp->RegOutUrb, macp->udev,
796 USB_REG_OUT_PIPE, USB_DIR_OUT, macp->regUsbWriteBuf,
797 cmdLen, zfLnxUsbRegOut_callback, dev, 1);
798
799 return ret;
800}
801
802
803u32_t zfLnxUsbOut(zdev_t* dev, u8_t *hdr, u16_t hdrlen, u8_t *snap, u16_t snapLen,
804 u8_t *tail, u16_t tailLen, zbuf_t *buf, u16_t offset)
805{
806 u32_t ret;
807 struct usbdrv_private *macp = dev->ml_priv;
808
809
810
811
812
813 if (zfLnxPutUsbTxBuffer(dev, hdr, hdrlen, snap, snapLen, tail, tailLen, buf, offset) == 0xffff)
814 {
815
816
817
818 macp->usbCbFunctions.zfcbUsbOutComplete(dev, buf, 0, hdr);
819 return 0xffff;
820 }
821
822
823
824 ret = zfLnxUsbSubmitTxData(dev);
825 return ret;
826}
827
828void zfLnxInitUsbTxQ(zdev_t* dev)
829{
830 struct usbdrv_private *macp = dev->ml_priv;
831
832 printk(KERN_ERR "zfwInitUsbTxQ\n");
833
834
835 memset(macp->UsbTxBufQ, 0, sizeof(UsbTxQ_t) * ZM_MAX_TX_URB_NUM);
836
837 macp->TxBufHead = 0;
838 macp->TxBufTail = 0;
839 macp->TxUrbHead = 0;
840 macp->TxUrbTail = 0;
841 macp->TxUrbCnt = ZM_MAX_TX_URB_NUM;
842}
843
844void zfLnxInitUsbRxQ(zdev_t* dev)
845{
846 u16_t i;
847 zbuf_t *buf;
848 struct usbdrv_private *macp = dev->ml_priv;
849
850
851 memset(macp->UsbRxBufQ, 0, sizeof(zbuf_t *) * ZM_MAX_RX_URB_NUM);
852
853 macp->RxBufHead = 0;
854
855 for (i = 0; i < ZM_MAX_RX_URB_NUM; i++)
856 {
857
858 buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
859 macp->UsbRxBufQ[i] = buf;
860 }
861
862
863 macp->RxBufTail = 0;
864
865
866 for (i = 0; i < ZM_MAX_RX_URB_NUM; i++)
867 {
868 zfLnxPutUsbRxBuffer(dev, macp->UsbRxBufQ[i]);
869 zfLnxUsbIn(dev, macp->WlanRxDataUrb[i], macp->UsbRxBufQ[i]);
870 }
871}
872
873
874
875u32_t zfLnxUsbSubmitBulkUrb(urb_t *urb, struct usb_device *usb, u16_t epnum, u16_t direction,
876 void *transfer_buffer, int buffer_length, usb_complete_t complete, void *context)
877{
878 u32_t ret;
879
880 if(direction == USB_DIR_OUT)
881 {
882 usb_fill_bulk_urb(urb, usb, usb_sndbulkpipe(usb, epnum),
883 transfer_buffer, buffer_length, complete, context);
884
885 urb->transfer_flags |= URB_ZERO_PACKET;
886 }
887 else
888 {
889 usb_fill_bulk_urb(urb, usb, usb_rcvbulkpipe(usb, epnum),
890 transfer_buffer, buffer_length, complete, context);
891 }
892
893 if (epnum == 4)
894 {
895 if (urb->hcpriv)
896 {
897
898
899 }
900 }
901
902 ret = usb_submit_urb(urb, GFP_ATOMIC);
903 if ((epnum == 4) & (ret != 0))
904 {
905
906 }
907 return ret;
908}
909
910u32_t zfLnxUsbSubmitIntUrb(urb_t *urb, struct usb_device *usb, u16_t epnum, u16_t direction,
911 void *transfer_buffer, int buffer_length, usb_complete_t complete, void *context,
912 u32_t interval)
913{
914 u32_t ret;
915
916 if(direction == USB_DIR_OUT)
917 {
918 usb_fill_int_urb(urb, usb, usb_sndbulkpipe(usb, epnum),
919 transfer_buffer, buffer_length, complete, context, interval);
920 }
921 else
922 {
923 usb_fill_int_urb(urb, usb, usb_rcvbulkpipe(usb, epnum),
924 transfer_buffer, buffer_length, complete, context, interval);
925 }
926
927 ret = usb_submit_urb(urb, GFP_ATOMIC);
928
929 return ret;
930}
931
932#ifdef ZM_ENABLE_CENC
933int zfLnxCencSendMsg(struct sock *netlink_sk, u_int8_t *msg, int len)
934{
935#define COMMTYPE_GROUP 8
936#define WAI_K_MSG 0x11
937
938 int ret = -1;
939 int size;
940 unsigned char *old_tail;
941 struct sk_buff *skb;
942 struct nlmsghdr *nlh;
943 char *pos = NULL;
944
945 size = NLMSG_SPACE(len);
946 skb = alloc_skb(size, GFP_ATOMIC);
947
948 if(skb == NULL)
949 {
950 printk("dev_alloc_skb failure \n");
951 goto out;
952 }
953 old_tail = skb->tail;
954
955
956 nlh = NLMSG_PUT(skb, 0, 0, WAI_K_MSG, size-sizeof(*nlh));
957 pos = NLMSG_DATA(nlh);
958 memset(pos, 0, len);
959
960
961 memcpy(pos, msg, len);
962
963 nlh->nlmsg_len = skb->tail - old_tail;
964 NETLINK_CB(skb).dst_group = COMMTYPE_GROUP;
965 netlink_broadcast(netlink_sk, skb, 0, COMMTYPE_GROUP, GFP_ATOMIC);
966 ret = 0;
967out:
968 return ret;
969nlmsg_failure:
970 kfree_skb(skb);
971 goto out;
972
973#undef COMMTYPE_GROUP
974#undef WAI_K_MSG
975}
976#endif
977
978
979u16_t zfLnxGetVapId(zdev_t* dev)
980{
981 u16_t i;
982
983 for (i=0; i<ZM_VAP_PORT_NUMBER; i++)
984 {
985 if (vap[i].dev == dev)
986 {
987 return i;
988 }
989 }
990 return 0xffff;
991}
992
993u32_t zfwReadReg(zdev_t* dev, u32_t offset)
994{
995 return 0;
996}
997
998#ifndef INIT_WORK
999#define work_struct tq_struct
1000
1001#define schedule_work(a) schedule_task(a)
1002
1003#define flush_scheduled_work flush_scheduled_tasks
1004#define INIT_WORK(_wq, _routine, _data) INIT_TQUEUE(_wq, _routine, _data)
1005#define PREPARE_WORK(_wq, _routine, _data) PREPARE_TQUEUE(_wq, _routine, _data)
1006#endif
1007
1008#define KEVENT_WATCHDOG 0x00000001
1009
1010u32_t smp_kevent_Lock = 0;
1011
1012void kevent(struct work_struct *work)
1013{
1014 struct usbdrv_private *macp =
1015 container_of(work, struct usbdrv_private, kevent);
1016 zdev_t *dev = macp->device;
1017
1018 if (test_and_set_bit(0, (void *)&smp_kevent_Lock))
1019 {
1020
1021 return;
1022 }
1023
1024 down(&macp->ioctl_sem);
1025
1026 if (test_and_clear_bit(KEVENT_WATCHDOG, &macp->kevent_flags))
1027 {
1028 extern u16_t zfHpStartRecv(zdev_t *dev);
1029
1030 printk(("\n ************ Hw watchDog occur!! ************** \n"));
1031 zfiWlanSuspend(dev);
1032 zfiWlanResume(dev,0);
1033 zfHpStartRecv(dev);
1034 }
1035
1036 clear_bit(0, (void *)&smp_kevent_Lock);
1037 up(&macp->ioctl_sem);
1038}
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055u8_t zfLnxCreateThread(zdev_t *dev)
1056{
1057 struct usbdrv_private *macp = dev->ml_priv;
1058
1059
1060 INIT_WORK(&macp->kevent, kevent);
1061 init_MUTEX(&macp->ioctl_sem);
1062
1063 return 0;
1064}
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082void zfLnxSignalThread(zdev_t *dev, int flag)
1083{
1084 struct usbdrv_private *macp = dev->ml_priv;
1085
1086 if (macp == NULL)
1087 {
1088 printk("macp is NULL\n");
1089 return;
1090 }
1091
1092 if (0 && macp->kevent_ready != 1)
1093 {
1094 printk("Kevent not ready\n");
1095 return;
1096 }
1097
1098 set_bit(flag, &macp->kevent_flags);
1099
1100 if (!schedule_work(&macp->kevent))
1101 {
1102
1103
1104 }
1105}
1106
1107
1108
1109void zfLnxWatchDogNotify(zdev_t* dev)
1110{
1111 zfLnxSignalThread(dev, KEVENT_WATCHDOG);
1112}
1113
1114
1115void zfwGetActiveScanDur(zdev_t* dev, u8_t* Dur)
1116{
1117 *Dur = 30;
1118}
1119
1120void zfwGetShowZeroLengthSSID(zdev_t* dev, u8_t* Dur)
1121{
1122 *Dur = 0;
1123}
1124
1125