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