projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:


53d2a45d55f9672deddb79aa25dc61cda1eef57d
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / otus / wwrap.c
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 #include <net/iw_handler.h>
30
31 extern void zfiRecv80211(zdev_t* dev, zbuf_t* buf, struct zsAdditionInfo* addInfo);
32 extern void zfCoreRecv(zdev_t* dev, zbuf_t* buf, struct zsAdditionInfo* addInfo);
33 extern void zfIdlChkRsp(zdev_t* dev, u32_t* rsp, u16_t rspLen);
34 extern void zfIdlRsp(zdev_t* dev, u32_t *rsp, u16_t rspLen);
35
36
37
38 //extern struct zsWdsStruct wds[ZM_WDS_PORT_NUMBER];
39 extern struct zsVapStruct vap[ZM_VAP_PORT_NUMBER];
40
41 u32_t zfLnxUsbSubmitTxData(zdev_t* dev);
42 u32_t zfLnxUsbIn(zdev_t* dev, urb_t *urb, zbuf_t *buf);
43 u32_t zfLnxSubmitRegInUrb(zdev_t *dev);
44 u32_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);
46 u32_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
50 u16_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 //idx = ((macp->TxUrbTail + 1) & (ZM_MAX_TX_URB_NUM - 1));
59
60 //if (idx != macp->TxUrbHead)
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 //printk(KERN_ERR "macp->TxUrbCnt: %d\n", macp->TxUrbCnt);
70 idx = 0xffff;
71 }
72
73 spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
74 return idx;
75 }
76
77 void 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 //if (idx != macp->TxUrbTail)
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
102 u16_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
116 UsbTxQ_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 //if (idx != macp->TxBufTail)
128 if (macp->TxBufCnt > 0)
129 {
130 //printk("CWY - zfwGetUsbTxBuffer ,macp->TxBufCnt = %d\n", macp->TxBufCnt);
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
151 u16_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 /* For Tx debug */
165 //zm_assert(macp->TxBufCnt >= 0); // deleted because of always true
166
167 //if (idx != macp->TxBufHead)
168 if (macp->TxBufCnt < ZM_MAX_TX_BUF_NUM)
169 {
170 //printk("CWY - zfwPutUsbTxBuffer ,macp->TxBufCnt = %d\n", macp->TxBufCnt);
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
196 zbuf_t *zfLnxGetUsbRxBuffer(zdev_t *dev)
197 {
198 struct usbdrv_private *macp = dev->ml_priv;
199 //u16_t idx;
200 zbuf_t *buf;
201 unsigned long irqFlag;
202
203 spin_lock_irqsave(&macp->cs_lock, irqFlag);
204
205 //idx = ((macp->RxBufHead+1) & (ZM_MAX_RX_URB_NUM - 1));
206
207 //if (idx != macp->RxBufTail)
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
226 u32_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 //if (idx != macp->RxBufHead)
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
255 void zfLnxUsbDataOut_callback(urb_t *urb)
256 {
257 zdev_t* dev = urb->context;
258 //UsbTxQ_t *TxData;
259
260 /* Give the urb back */
261 zfLnxPutTxUrb(dev);
262
263 /* Check whether there is any pending buffer needed */
264 /* to be sent */
265 if (zfLnxCheckTxBufferCnt(dev) != 0)
266 {
267 //TxData = zfwGetUsbTxBuffer(dev);
268
269 //if (TxData == NULL)
270 //{
271 // printk("Get a NULL buffer from zfwGetUsbTxBuffer\n");
272 // return;
273 //}
274 //else
275 //{
276 zfLnxUsbSubmitTxData(dev);
277 //}
278 }
279 }
280
281 void 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 /* Check status for URB */
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 //printk(KERN_ERR "nonzero read bulk status received: -EPIPE");
308 status = -1;
309 }
310
311 if (urb->status == -EPROTO){
312 //printk(KERN_ERR "nonzero read bulk status received: -EPROTO");
313 status = -1;
314 }
315 }
316
317 //printk(KERN_ERR "urb->status: 0x%08x\n", urb->status);
318
319 /* Dequeue skb buffer */
320 buf = zfLnxGetUsbRxBuffer(dev);
321 dev_kfree_skb_any(buf);
322 #if 0
323 /* Enqueue skb buffer */
324 zfLnxPutUsbRxBuffer(dev, buf);
325
326 /* Submit a Rx urb */
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 /* Dequeue skb buffer */
339 buf = zfLnxGetUsbRxBuffer(dev);
340
341 //zfwBufSetSize(dev, buf, urb->actual_length);
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 /* Copy data */
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 //printk("Get a packet, index: %d, pkt_len: 0x%04x\n", index, pkt_len);
380 #if 0
381 /* Dump data */
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; // - pad_len;
404 check_len = ZM_MAX_RX_BUFFER_SIZE - chk_idx - 4;
405 check_pad = pad_len;
406
407 /* Allocate a skb buffer */
408 //new_buf = zfwBufAllocate(dev, ZM_MAX_RX_BUFFER_SIZE);
409 new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
410
411 /* Set skb buffer length */
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 /* Copy the buffer */
423 memcpy(new_buf->data, &(buf->data[chk_idx+4]), check_len);
424
425 /* Record the buffer pointer */
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 /* Allocate a skb buffer */
442 new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
443
444 /* Set skb buffer length */
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 /* Copy the buffer */
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 /* Free buffer */
469 dev_kfree_skb_any(buf);
470
471 /* Allocate a skb buffer */
472 new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
473
474 /* Enqueue skb buffer */
475 zfLnxPutUsbRxBuffer(dev, new_buf);
476
477 /* Submit a Rx urb */
478 zfLnxUsbIn(dev, urb, new_buf);
479
480 return;
481 }
482 }
483
484 /* Free buffer */
485 dev_kfree_skb_any(buf);
486 #endif
487
488 /* Allocate a skb buffer */
489 new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
490
491 /* Enqueue skb buffer */
492 zfLnxPutUsbRxBuffer(dev, new_buf);
493
494 /* Submit a Rx urb */
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 /* pass data to upper layer */
504 macp->usbCbFunctions.zfcbUsbRecv(dev, buf);
505 #endif
506 }
507
508 void zfLnxUsbRegOut_callback(urb_t *urb)
509 {
510 //dev_t* dev = urb->context;
511
512 //printk(KERN_ERR "zfwUsbRegOut_callback\n");
513 }
514
515 void 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 /* Check status for URB */
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 //printk(KERN_ERR "nonzero read bulk status received: -EPIPE");
530 status = -1;
531 }
532
533 if (urb->status == -EPROTO){
534 //printk(KERN_ERR "nonzero read bulk status received: -EPROTO");
535 status = -1;
536 }
537 }
538
539 //printk(KERN_ERR "urb->status: 0x%08x\n", urb->status);
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 /* Copy data into respone buffer */
550 memcpy(rsp, macp->regUsbReadBuf, urb->actual_length);
551
552 /* Notify to upper layer */
553 //zfIdlChkRsp(dev, rsp, (u16_t)urb->actual_length);
554 //zfiUsbRegIn(dev, rsp, (u16_t)urb->actual_length);
555 macp->usbCbFunctions.zfcbUsbRegIn(dev, rsp, (u16_t)urb->actual_length);
556
557 /* Issue another USB IN URB */
558 zfLnxSubmitRegInUrb(dev);
559 }
560
561 u32_t zfLnxSubmitRegInUrb(zdev_t *dev)
562 {
563 u32_t ret;
564 struct usbdrv_private *macp = dev->ml_priv;
565
566 /* Submit a rx urb */
567 //ret = zfLnxUsbSubmitBulkUrb(macp->RegInUrb, macp->udev,
568 // USB_REG_IN_PIPE, USB_DIR_IN, macp->regUsbReadBuf,
569 // ZM_USB_REG_MAX_BUF_SIZE, zfLnxUsbRegIn_callback, dev);
570 //CWYang(-)
571 //if (ret != 0)
572 // printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);
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
581 u32_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 /* First check whether there is a free URB */
599 freeTxUrb = zfLnxGetFreeTxUrb(dev);
600
601 /* If there is no any free Tx Urb */
602 if (freeTxUrb == 0xffff)
603 {
604 //printk(KERN_ERR "Can't get free Tx Urb\n");
605 //printk("CWY - Can't get free Tx Urb\n");
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 //printk("usbTxAggCnt: %d\n", usbTxAggCnt);
622 #endif
623
624 #if ZM_USB_TX_STREAM_MODE == 1
625 for(ii = 0; ii < usbTxAggCnt; ii++)
626 {
627 #endif
628 /* Dequeue the packet from UsbTxBufQ */
629 TxData = zfLnxGetUsbTxBuffer(dev);
630 if (TxData == NULL)
631 {
632 /* Give the urb back */
633 zfLnxPutTxUrb(dev);
634 return 0xffff;
635 }
636
637 /* Point to the freeTxUrb buffer */
638 puTxBuf = macp->txUsbBuf[freeTxUrb];
639
640 #if ZM_USB_TX_STREAM_MODE == 1
641 puTxBuf += offset;
642 pUsbTxHdr = (u16_t *)puTxBuf;
643
644 /* Add the packet length and tag information */
645 *pUsbTxHdr++ = TxData->hdrlen + TxData->snapLen +
646 (TxData->buf->len - TxData->offset) + TxData->tailLen;
647
648 *pUsbTxHdr++ = 0x697e;
649
650 puTxBuf += 4;
651 #endif // #ifdef ZM_USB_TX_STREAM_MODE
652
653 /* Copy WLAN header and packet buffer into USB buffer */
654 for(i = 0; i < TxData->hdrlen; i++)
655 {
656 *puTxBuf++ = TxData->hdr[i];
657 }
658
659 /* Copy SNAP header */
660 for(i = 0; i < TxData->snapLen; i++)
661 {
662 *puTxBuf++ = TxData->snap[i];
663 }
664
665 /* Copy packet buffer */
666 for(i = 0; i < TxData->buf->len - TxData->offset; i++)
667 {
668 //*puTxBuf++ = zmw_rx_buf_readb(dev, TxData->buf, i);
669 *puTxBuf++ = *(u8_t*)((u8_t*)TxData->buf->data+i+TxData->offset);
670 }
671
672 /* Copy tail */
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 /* For debug purpose */
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 /* Dump control setting */
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 // Add the Length and Tag
717 len += 4;
718
719 //printk("%d packet, length: %d\n", ii+1, len);
720
721 if (ii < (ZM_MAX_TX_AGGREGATE_NUM-1))
722 {
723 /* Pad the buffer to firmware descriptor boundary */
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 //DbgPrint("%d packet, offset: %d\n", ii+1, pUsbTxTransfer->offset);
735
736 /* free packet */
737 //zfBufFree(dev, txData->buf);
738 }
739 #endif
740 //printk("CWY - call zfwUsbSubmitBulkUrb(), len = 0x%d\n", len);
741 /* Submit a tx urb */
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 //CWYang(-)
746 //if (ret != 0)
747 // printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);
748
749 /* free packet */
750 //dev_kfree_skb_any(TxData->buf);
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
763 u32_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 /* Submit a rx urb */
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 //CWYang(-)
773 //if (ret != 0)
774 // printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);
775
776 return ret;
777 }
778
779 u32_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 /* Issue an USB Out transfer */
794 /* Submit a tx urb */
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
803 u32_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 /* Check length of tail buffer */
810 //zm_assert((tailLen <= 16));
811
812 /* Enqueue the packet into UsbTxBufQ */
813 if (zfLnxPutUsbTxBuffer(dev, hdr, hdrlen, snap, snapLen, tail, tailLen, buf, offset) == 0xffff)
814 {
815 /* free packet */
816 //printk("CWY - zfwPutUsbTxBuffer Error, free packet\n");
817 //dev_kfree_skb_any(buf);
818 macp->usbCbFunctions.zfcbUsbOutComplete(dev, buf, 0, hdr);
819 return 0xffff;
820 }
821
822 //return 0;
823 //printk("CWY - call zfwUsbSubmitTxData()\n");
824 ret = zfLnxUsbSubmitTxData(dev);
825 return ret;
826 }
827
828 void zfLnxInitUsbTxQ(zdev_t* dev)
829 {
830 struct usbdrv_private *macp = dev->ml_priv;
831
832 printk(KERN_ERR "zfwInitUsbTxQ\n");
833
834 /* Zero memory for UsbTxBufQ */
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
844 void zfLnxInitUsbRxQ(zdev_t* dev)
845 {
846 u16_t i;
847 zbuf_t *buf;
848 struct usbdrv_private *macp = dev->ml_priv;
849
850 /* Zero memory for UsbRxBufQ */
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 //buf = zfwBufAllocate(dev, ZM_MAX_RX_BUFFER_SIZE);
858 buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
859 macp->UsbRxBufQ[i] = buf;
860 }
861
862 //macp->RxBufTail = ZM_MAX_RX_URB_NUM - 1;
863 macp->RxBufTail = 0;
864
865 /* Submit all Rx urbs */
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
875 u32_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 //printk("CWY - urb->hcpriv set by unknown reason, reset it\n");
898 //urb->hcpriv = 0;
899 }
900 }
901
902 ret = usb_submit_urb(urb, GFP_ATOMIC);
903 if ((epnum == 4) & (ret != 0))
904 {
905 //printk("CWY - ret = %x\n", ret);
906 }
907 return ret;
908 }
909
910 u32_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
933 int 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;
967 out:
968 return ret;
969 nlmsg_failure: /*NLMSG_PUT ʧ°Ü£¬Ôò³·ÏúÌ×½Ó×Ö»º´æ*/
970 kfree_skb(skb);
971 goto out;
972
973 #undef COMMTYPE_GROUP
974 #undef WAI_K_MSG
975 }
976 #endif //ZM_ENABLE_CENC
977
978 /* Simply return 0xffff if VAP function is not supported */
979 u16_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
993 u32_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
1010 u32_t smp_kevent_Lock = 0;
1011
1012 void 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 //schedule_work(&macp->kevent);
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 //zfiHwWatchDogReinit(dev);
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 /* FUNCTION DESCRIPTION zfLnxCreateThread */
1043 /* Create a Thread */
1044 /* */
1045 /* INPUTS */
1046 /* dev : device pointer */
1047 /* */
1048 /* OUTPUTS */
1049 /* always 0 */
1050 /* */
1051 /* AUTHOR */
1052 /* Yuan-Gu Wei Atheros Communications, INC. 2007.3 */
1053 /* */
1054 /************************************************************************/
1055 u8_t zfLnxCreateThread(zdev_t *dev)
1056 {
1057 struct usbdrv_private *macp = dev->ml_priv;
1058
1059 /* Create Mutex and keventd */
1060 INIT_WORK(&macp->kevent, kevent);
1061 init_MUTEX(&macp->ioctl_sem);
1062
1063 return 0;
1064 }
1065
1066 /************************************************************************/
1067 /* */
1068 /* FUNCTION DESCRIPTION zfLnxSignalThread */
1069 /* Signal Thread with Flag */
1070 /* */
1071 /* INPUTS */
1072 /* dev : device pointer */
1073 /* flag : signal thread flag */
1074 /* */
1075 /* OUTPUTS */
1076 /* none */
1077 /* */
1078 /* AUTHOR */
1079 /* Yuan-Gu Wei Atheros Communications, INC. 2007.3 */
1080 /* */
1081 /************************************************************************/
1082 void 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 //Fails is Normal
1103 //printk(KERN_ERR "schedule_task failed, flag = %x\n", flag);
1104 }
1105 }
1106
1107 /* Notify wrapper todo redownload firmware and reinit procedure when */
1108 /* hardware watchdog occur : zfiHwWatchDogReinit() */
1109 void zfLnxWatchDogNotify(zdev_t* dev)
1110 {
1111 zfLnxSignalThread(dev, KEVENT_WATCHDOG);
1112 }
1113
1114 /* Query Durantion of Active Scan */
1115 void zfwGetActiveScanDur(zdev_t* dev, u8_t* Dur)
1116 {
1117 *Dur = 30; // default 30 ms
1118 }
1119
1120 void zfwGetShowZeroLengthSSID(zdev_t* dev, u8_t* Dur)
1121 {
1122 *Dur = 0;
1123 }
1124
kernel source for telekom puls (alcatel/mediatek)