git.oblomov.eu Git - linux-2.6/blob - 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
  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     if ((buf->tail + urb->actual_length) > buf->end)
 354         BUG();
 355
 356     skb_put(buf, urb->actual_length);
 357
 358 #if ZM_USB_STREAM_MODE == 1
 359     if (remain_len != 0)
 360     {
 361         zbuf_t *remain_buf = macp->reamin_buf;
 362
 363         index = remain_len;
 364         remain_len -= check_pad;
 365
 366         /*  Copy data */
 367         memcpy(&(remain_buf->data[check_len]), buf->data, remain_len);
 368         check_len += remain_len;
 369         remain_len = 0;
 370
 371         rxBufPool[rxBufPoolIndex++] = remain_buf;
 372     }
 373
 374     while(index < urb->actual_length)
 375     {
 376         pkt_len = buf->data[index] + (buf->data[index+1] << 8);
 377         pkt_tag = buf->data[index+2] + (buf->data[index+3] << 8);
 378
 379         if (pkt_tag == 0x4e00)
 380         {
 381             int pad_len;
 382
 383             //printk("Get a packet, index: %d, pkt_len: 0x%04x\n", index, pkt_len);
 384             #if 0
 385             /* Dump data */
 386             for (ii = index; ii < pkt_len+4;)
 387             {
 388                 printk("%02x ", (buf->data[ii] & 0xff));
 389
 390                 if ((++ii % 16) == 0)
 391                     printk("\n");
 392             }
 393
 394             printk("\n");
 395             #endif
 396
 397             pad_len = 4 - (pkt_len & 0x3);
 398
 399             if(pad_len == 4)
 400                 pad_len = 0;
 401
 402             chk_idx = index;
 403             index = index + 4 + pkt_len + pad_len;
 404
 405             if (index > ZM_MAX_RX_BUFFER_SIZE)
 406             {
 407                 remain_len = index - ZM_MAX_RX_BUFFER_SIZE; // - pad_len;
 408                 check_len = ZM_MAX_RX_BUFFER_SIZE - chk_idx - 4;
 409                 check_pad = pad_len;
 410
 411                 /* Allocate a skb buffer */
 412                 //new_buf = zfwBufAllocate(dev, ZM_MAX_RX_BUFFER_SIZE);
 413                 new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
 414
 415                 /* Set skb buffer length */
 416             #ifdef NET_SKBUFF_DATA_USES_OFFSET
 417                 new_buf->tail = 0;
 418                 new_buf->len = 0;
 419             #else
 420                 new_buf->tail = new_buf->data;
 421                 new_buf->len = 0;
 422             #endif
 423
 424                 skb_put(new_buf, pkt_len);
 425
 426                 /* Copy the buffer */
 427                 memcpy(new_buf->data, &(buf->data[chk_idx+4]), check_len);
 428
 429                 /* Record the buffer pointer */
 430                 macp->reamin_buf = new_buf;
 431             }
 432             else
 433             {
 434         #ifdef ZM_DONT_COPY_RX_BUFFER
 435                 if (rxBufPoolIndex == 0)
 436                 {
 437                     new_buf = skb_clone(buf, GFP_ATOMIC);
 438
 439                     new_buf->data = &(buf->data[chk_idx+4]);
 440                     new_buf->len = pkt_len;
 441                 }
 442                 else
 443                 {
 444         #endif
 445                 /* Allocate a skb buffer */
 446                 new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
 447
 448                 /* Set skb buffer length */
 449             #ifdef NET_SKBUFF_DATA_USES_OFFSET
 450                 new_buf->tail = 0;
 451                 new_buf->len = 0;
 452             #else
 453                 new_buf->tail = new_buf->data;
 454                 new_buf->len = 0;
 455             #endif
 456
 457                 skb_put(new_buf, pkt_len);
 458
 459                 /* Copy the buffer */
 460                 memcpy(new_buf->data, &(buf->data[chk_idx+4]), pkt_len);
 461
 462         #ifdef ZM_DONT_COPY_RX_BUFFER
 463                 }
 464         #endif
 465                 rxBufPool[rxBufPoolIndex++] = new_buf;
 466             }
 467         }
 468         else
 469         {
 470             printk(KERN_ERR "Can't find tag, pkt_len: 0x%04x, tag: 0x%04x\n", pkt_len, pkt_tag);
 471
 472             /* Free buffer */
 473             dev_kfree_skb_any(buf);
 474
 475             /* Allocate a skb buffer */
 476             new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
 477
 478             /* Enqueue skb buffer */
 479             zfLnxPutUsbRxBuffer(dev, new_buf);
 480
 481             /* Submit a Rx urb */
 482             zfLnxUsbIn(dev, urb, new_buf);
 483
 484             return;
 485         }
 486     }
 487
 488     /* Free buffer */
 489     dev_kfree_skb_any(buf);
 490 #endif
 491
 492     /* Allocate a skb buffer */
 493     new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
 494
 495     /* Enqueue skb buffer */
 496     zfLnxPutUsbRxBuffer(dev, new_buf);
 497
 498     /* Submit a Rx urb */
 499     zfLnxUsbIn(dev, urb, new_buf);
 500
 501 #if ZM_USB_STREAM_MODE == 1
 502     for(ii = 0; ii < rxBufPoolIndex; ii++)
 503     {
 504         macp->usbCbFunctions.zfcbUsbRecv(dev, rxBufPool[ii]);
 505     }
 506 #else
 507     /* pass data to upper layer */
 508     macp->usbCbFunctions.zfcbUsbRecv(dev, buf);
 509 #endif
 510 }
 511
 512 void zfLnxUsbRegOut_callback(urb_t *urb)
 513 {
 514     //dev_t* dev = urb->context;
 515
 516     //printk(KERN_ERR "zfwUsbRegOut_callback\n");
 517 }
 518
 519 void zfLnxUsbRegIn_callback(urb_t *urb)
 520 {
 521     zdev_t* dev = urb->context;
 522     u32_t rsp[64/4];
 523     int status;
 524     struct usbdrv_private *macp = dev->ml_priv;
 525
 526     /* Check status for URB */
 527     if (urb->status != 0){
 528         printk("zfLnxUsbRegIn_callback() : status=0x%x\n", urb->status);
 529         if ((urb->status != -ENOENT) && (urb->status != -ECONNRESET)
 530             && (urb->status != -ESHUTDOWN))
 531         {
 532                 if (urb->status == -EPIPE){
 533                     //printk(KERN_ERR "nonzero read bulk status received: -EPIPE");
 534                     status = -1;
 535                 }
 536
 537                 if (urb->status == -EPROTO){
 538                     //printk(KERN_ERR "nonzero read bulk status received: -EPROTO");
 539                     status = -1;
 540                 }
 541         }
 542
 543         //printk(KERN_ERR "urb->status: 0x%08x\n", urb->status);
 544         return;
 545     }
 546
 547     if (urb->actual_length == 0)
 548     {
 549         printk(KERN_ERR "Get an URB whose length is zero");
 550         status = -1;
 551     }
 552
 553     /* Copy data into respone buffer */
 554     memcpy(rsp, macp->regUsbReadBuf, urb->actual_length);
 555
 556     /* Notify to upper layer */
 557     //zfIdlChkRsp(dev, rsp, (u16_t)urb->actual_length);
 558     //zfiUsbRegIn(dev, rsp, (u16_t)urb->actual_length);
 559     macp->usbCbFunctions.zfcbUsbRegIn(dev, rsp, (u16_t)urb->actual_length);
 560
 561     /* Issue another USB IN URB */
 562     zfLnxSubmitRegInUrb(dev);
 563 }
 564
 565 u32_t zfLnxSubmitRegInUrb(zdev_t *dev)
 566 {
 567     u32_t ret;
 568     struct usbdrv_private *macp = dev->ml_priv;
 569
 570     /* Submit a rx urb */
 571     //ret = zfLnxUsbSubmitBulkUrb(macp->RegInUrb, macp->udev,
 572     //        USB_REG_IN_PIPE, USB_DIR_IN, macp->regUsbReadBuf,
 573     //        ZM_USB_REG_MAX_BUF_SIZE, zfLnxUsbRegIn_callback, dev);
 574     //CWYang(-)
 575     //if (ret != 0)
 576     //    printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);
 577
 578     ret = zfLnxUsbSubmitIntUrb(macp->RegInUrb, macp->udev,
 579             USB_REG_IN_PIPE, USB_DIR_IN, macp->regUsbReadBuf,
 580             ZM_USB_REG_MAX_BUF_SIZE, zfLnxUsbRegIn_callback, dev, 1);
 581
 582     return ret;
 583 }
 584
 585 u32_t zfLnxUsbSubmitTxData(zdev_t* dev)
 586 {
 587     u32_t i;
 588     u32_t ret;
 589     u16_t freeTxUrb;
 590     u8_t *puTxBuf = NULL;
 591     UsbTxQ_t *TxData;
 592     int len = 0;
 593     struct usbdrv_private *macp = dev->ml_priv;
 594 #if ZM_USB_TX_STREAM_MODE == 1
 595     u8_t               ii;
 596     u16_t              offset = 0;
 597     u16_t              usbTxAggCnt;
 598     u16_t              *pUsbTxHdr;
 599     UsbTxQ_t           *TxQPool[ZM_MAX_TX_AGGREGATE_NUM];
 600 #endif
 601
 602     /* First check whether there is a free URB */
 603     freeTxUrb = zfLnxGetFreeTxUrb(dev);
 604
 605     /* If there is no any free Tx Urb */
 606     if (freeTxUrb == 0xffff)
 607     {
 608         //printk(KERN_ERR "Can't get free Tx Urb\n");
 609         //printk("CWY - Can't get free Tx Urb\n");
 610         return 0xffff;
 611     }
 612
 613 #if ZM_USB_TX_STREAM_MODE == 1
 614     usbTxAggCnt = zfLnxCheckTxBufferCnt(dev);
 615
 616     if (usbTxAggCnt >= ZM_MAX_TX_AGGREGATE_NUM)
 617     {
 618        usbTxAggCnt = ZM_MAX_TX_AGGREGATE_NUM;
 619     }
 620     else
 621     {
 622        usbTxAggCnt = 1;
 623     }
 624
 625     //printk("usbTxAggCnt: %d\n", usbTxAggCnt);
 626 #endif
 627
 628 #if ZM_USB_TX_STREAM_MODE == 1
 629     for(ii = 0; ii < usbTxAggCnt; ii++)
 630     {
 631 #endif
 632     /* Dequeue the packet from UsbTxBufQ */
 633     TxData = zfLnxGetUsbTxBuffer(dev);
 634     if (TxData == NULL)
 635     {
 636         /* Give the urb back */
 637         zfLnxPutTxUrb(dev);
 638         return 0xffff;
 639     }
 640
 641     /* Point to the freeTxUrb buffer */
 642     puTxBuf = macp->txUsbBuf[freeTxUrb];
 643
 644 #if ZM_USB_TX_STREAM_MODE == 1
 645     puTxBuf += offset;
 646     pUsbTxHdr = (u16_t *)puTxBuf;
 647
 648     /* Add the packet length and tag information */
 649     *pUsbTxHdr++ = TxData->hdrlen + TxData->snapLen +
 650              (TxData->buf->len - TxData->offset) +  TxData->tailLen;
 651
 652     *pUsbTxHdr++ = 0x697e;
 653
 654     puTxBuf += 4;
 655 #endif // #ifdef ZM_USB_TX_STREAM_MODE
 656
 657     /* Copy WLAN header and packet buffer into USB buffer */
 658     for(i = 0; i < TxData->hdrlen; i++)
 659     {
 660         *puTxBuf++ = TxData->hdr[i];
 661     }
 662
 663     /* Copy SNAP header */
 664     for(i = 0; i < TxData->snapLen; i++)
 665     {
 666         *puTxBuf++ = TxData->snap[i];
 667     }
 668
 669     /* Copy packet buffer */
 670     for(i = 0; i < TxData->buf->len - TxData->offset; i++)
 671     {
 672         //*puTxBuf++ = zmw_rx_buf_readb(dev, TxData->buf, i);
 673         *puTxBuf++ = *(u8_t*)((u8_t*)TxData->buf->data+i+TxData->offset);
 674     }
 675
 676     /* Copy tail */
 677     for(i = 0; i < TxData->tailLen; i++)
 678     {
 679         *puTxBuf++ = TxData->tail[i];
 680     }
 681
 682     len = TxData->hdrlen+TxData->snapLen+TxData->buf->len+TxData->tailLen-TxData->offset;
 683
 684     #if 0
 685     if (TxData->hdrlen != 0)
 686     {
 687         puTxBuf = macp->txUsbBuf[freeTxUrb];
 688         for (i = 0; i < len; i++)
 689         {
 690             printk("%02x ", puTxBuf[i]);
 691             if (i % 16 == 15)
 692                 printk("\n");
 693         }
 694         printk("\n");
 695     }
 696     #endif
 697     #if 0
 698     /* For debug purpose */
 699     if(TxData->hdr[9] & 0x40)
 700     {
 701         int i;
 702         u16_t ctrlLen = TxData->hdr[0] + (TxData->hdr[1] << 8);
 703
 704         if (ctrlLen != len + 4)
 705         {
 706         /* Dump control setting */
 707         for(i = 0; i < 8; i++)
 708         {
 709             printk(KERN_ERR "0x%02x ", TxData->hdr[i]);
 710         }
 711         printk(KERN_ERR "\n");
 712
 713         printk(KERN_ERR "ctrLen: %d, hdrLen: %d, snapLen: %d\n", ctrlLen, TxData->hdrlen, TxData->snapLen);
 714         printk(KERN_ERR "bufLen: %d, tailLen: %d, len: %d\n", TxData->buf->len, TxData->tailLen, len);
 715         }
 716     }
 717     #endif
 718
 719 #if ZM_USB_TX_STREAM_MODE == 1
 720     // Add the Length and Tag
 721     len += 4;
 722
 723     //printk("%d packet, length: %d\n", ii+1, len);
 724
 725     if (ii < (ZM_MAX_TX_AGGREGATE_NUM-1))
 726     {
 727         /* Pad the buffer to firmware descriptor boundary */
 728         offset += (((len-1) / 4) + 1) * 4;
 729     }
 730
 731     if (ii == (ZM_MAX_TX_AGGREGATE_NUM-1))
 732     {
 733         len += offset;
 734     }
 735
 736     TxQPool[ii] = TxData;
 737
 738     //DbgPrint("%d packet, offset: %d\n", ii+1, pUsbTxTransfer->offset);
 739
 740     /* free packet */
 741     //zfBufFree(dev, txData->buf);
 742     }
 743 #endif
 744     //printk("CWY - call zfwUsbSubmitBulkUrb(), len = 0x%d\n", len);
 745     /* Submit a tx urb */
 746     ret = zfLnxUsbSubmitBulkUrb(macp->WlanTxDataUrb[freeTxUrb], macp->udev,
 747             USB_WLAN_TX_PIPE, USB_DIR_OUT, macp->txUsbBuf[freeTxUrb],
 748             len, zfLnxUsbDataOut_callback, dev);
 749     //CWYang(-)
 750     //if (ret != 0)
 751     //    printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);
 752
 753     /* free packet */
 754     //dev_kfree_skb_any(TxData->buf);
 755 #if ZM_USB_TX_STREAM_MODE == 1
 756     for(ii = 0; ii < usbTxAggCnt; ii++)
 757         macp->usbCbFunctions.zfcbUsbOutComplete(dev, TxQPool[ii]->buf, 1, TxQPool[ii]->hdr);
 758 #else
 759     macp->usbCbFunctions.zfcbUsbOutComplete(dev, TxData->buf, 1, TxData->hdr);
 760 #endif
 761
 762     return ret;
 763 }
 764
 765
 766
 767 u32_t zfLnxUsbIn(zdev_t* dev, urb_t *urb, zbuf_t *buf)
 768 {
 769     u32_t ret;
 770     struct usbdrv_private *macp = dev->ml_priv;
 771
 772     /* Submit a rx urb */
 773     ret = zfLnxUsbSubmitBulkUrb(urb, macp->udev, USB_WLAN_RX_PIPE,
 774             USB_DIR_IN, buf->data, ZM_MAX_RX_BUFFER_SIZE,
 775             zfLnxUsbDataIn_callback, dev);
 776     //CWYang(-)
 777     //if (ret != 0)
 778     //    printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);
 779
 780     return ret;
 781 }
 782
 783 u32_t zfLnxUsbWriteReg(zdev_t* dev, u32_t* cmd, u16_t cmdLen)
 784 {
 785     struct usbdrv_private *macp = dev->ml_priv;
 786     u32_t ret;
 787
 788 #ifdef ZM_CONFIG_BIG_ENDIAN
 789     int ii = 0;
 790
 791     for(ii=0; ii<(cmdLen>>2); ii++)
 792         cmd[ii] = cpu_to_le32(cmd[ii]);
 793 #endif
 794
 795     memcpy(macp->regUsbWriteBuf, cmd, cmdLen);
 796
 797     /* Issue an USB Out transfer */
 798     /* Submit a tx urb */
 799     ret = zfLnxUsbSubmitIntUrb(macp->RegOutUrb, macp->udev,
 800             USB_REG_OUT_PIPE, USB_DIR_OUT, macp->regUsbWriteBuf,
 801             cmdLen, zfLnxUsbRegOut_callback, dev, 1);
 802
 803     return ret;
 804 }
 805
 806
 807 u32_t zfLnxUsbOut(zdev_t* dev, u8_t *hdr, u16_t hdrlen, u8_t *snap, u16_t snapLen,
 808         u8_t *tail, u16_t tailLen, zbuf_t *buf, u16_t offset)
 809 {
 810     u32_t ret;
 811     struct usbdrv_private *macp = dev->ml_priv;
 812
 813     /* Check length of tail buffer */
 814     //zm_assert((tailLen <= 16));
 815
 816     /* Enqueue the packet into UsbTxBufQ */
 817     if (zfLnxPutUsbTxBuffer(dev, hdr, hdrlen, snap, snapLen, tail, tailLen, buf, offset) == 0xffff)
 818     {
 819         /* free packet */
 820         //printk("CWY - zfwPutUsbTxBuffer Error, free packet\n");
 821         //dev_kfree_skb_any(buf);
 822         macp->usbCbFunctions.zfcbUsbOutComplete(dev, buf, 0, hdr);
 823         return 0xffff;
 824     }
 825
 826     //return 0;
 827     //printk("CWY - call zfwUsbSubmitTxData()\n");
 828     ret = zfLnxUsbSubmitTxData(dev);
 829     return ret;
 830 }
 831
 832 void zfLnxInitUsbTxQ(zdev_t* dev)
 833 {
 834     struct usbdrv_private *macp = dev->ml_priv;
 835
 836     printk(KERN_ERR "zfwInitUsbTxQ\n");
 837
 838     /* Zero memory for UsbTxBufQ */
 839     memset(macp->UsbTxBufQ, 0, sizeof(UsbTxQ_t) * ZM_MAX_TX_URB_NUM);
 840
 841     macp->TxBufHead = 0;
 842     macp->TxBufTail = 0;
 843     macp->TxUrbHead = 0;
 844     macp->TxUrbTail = 0;
 845     macp->TxUrbCnt = ZM_MAX_TX_URB_NUM;
 846 }
 847
 848 void zfLnxInitUsbRxQ(zdev_t* dev)
 849 {
 850     u16_t i;
 851     zbuf_t *buf;
 852     struct usbdrv_private *macp = dev->ml_priv;
 853
 854     /* Zero memory for UsbRxBufQ */
 855     memset(macp->UsbRxBufQ, 0, sizeof(zbuf_t *) * ZM_MAX_RX_URB_NUM);
 856
 857     macp->RxBufHead = 0;
 858
 859     for (i = 0; i < ZM_MAX_RX_URB_NUM; i++)
 860     {
 861         //buf = zfwBufAllocate(dev, ZM_MAX_RX_BUFFER_SIZE);
 862         buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
 863         macp->UsbRxBufQ[i] = buf;
 864     }
 865
 866     //macp->RxBufTail = ZM_MAX_RX_URB_NUM - 1;
 867     macp->RxBufTail = 0;
 868
 869     /* Submit all Rx urbs */
 870     for (i = 0; i < ZM_MAX_RX_URB_NUM; i++)
 871     {
 872         zfLnxPutUsbRxBuffer(dev, macp->UsbRxBufQ[i]);
 873         zfLnxUsbIn(dev, macp->WlanRxDataUrb[i], macp->UsbRxBufQ[i]);
 874     }
 875 }
 876
 877
 878
 879 u32_t zfLnxUsbSubmitBulkUrb(urb_t *urb, struct usb_device *usb, u16_t epnum, u16_t direction,
 880         void *transfer_buffer, int buffer_length, usb_complete_t complete, void *context)
 881 {
 882     u32_t ret;
 883
 884     if(direction == USB_DIR_OUT)
 885     {
 886         usb_fill_bulk_urb(urb, usb, usb_sndbulkpipe(usb, epnum),
 887                 transfer_buffer, buffer_length, complete, context);
 888
 889         urb->transfer_flags |= URB_ZERO_PACKET;
 890     }
 891     else
 892     {
 893         usb_fill_bulk_urb(urb, usb, usb_rcvbulkpipe(usb, epnum),
 894                 transfer_buffer, buffer_length, complete, context);
 895     }
 896
 897     if (epnum == 4)
 898     {
 899         if (urb->hcpriv)
 900         {
 901             //printk("CWY - urb->hcpriv set by unknown reason, reset it\n");
 902             //urb->hcpriv = 0;
 903         }
 904     }
 905
 906     ret = usb_submit_urb(urb, GFP_ATOMIC);
 907     if ((epnum == 4) & (ret != 0))
 908     {
 909         //printk("CWY - ret = %x\n", ret);
 910     }
 911     return ret;
 912 }
 913
 914 u32_t zfLnxUsbSubmitIntUrb(urb_t *urb, struct usb_device *usb, u16_t epnum, u16_t direction,
 915         void *transfer_buffer, int buffer_length, usb_complete_t complete, void *context,
 916         u32_t interval)
 917 {
 918     u32_t ret;
 919
 920     if(direction == USB_DIR_OUT)
 921     {
 922         usb_fill_int_urb(urb, usb, usb_sndbulkpipe(usb, epnum),
 923                 transfer_buffer, buffer_length, complete, context, interval);
 924     }
 925     else
 926     {
 927         usb_fill_int_urb(urb, usb, usb_rcvbulkpipe(usb, epnum),
 928                 transfer_buffer, buffer_length, complete, context, interval);
 929     }
 930
 931     ret = usb_submit_urb(urb, GFP_ATOMIC);
 932
 933     return ret;
 934 }
 935
 936 #ifdef ZM_ENABLE_CENC
 937 int zfLnxCencSendMsg(struct sock *netlink_sk, u_int8_t *msg, int len)
 938 {
 939 #define COMMTYPE_GROUP   8
 940 #define WAI_K_MSG        0x11
 941
 942         int ret = -1;
 943         int size;
 944         unsigned char *old_tail;
 945         struct sk_buff *skb;
 946         struct nlmsghdr *nlh;
 947         char *pos = NULL;
 948
 949         size = NLMSG_SPACE(len);
 950         skb = alloc_skb(size, GFP_ATOMIC);
 951
 952         if(skb == NULL)
 953         {
 954                 printk("dev_alloc_skb failure \n");
 955                 goto out;
 956         }
 957         old_tail = skb->tail;
 958
 959         /*ÌîÐ´Êý¾Ý±¨Ïà¹ØÐÅÏ¢*/
 960         nlh = NLMSG_PUT(skb, 0, 0, WAI_K_MSG, size-sizeof(*nlh));
 961         pos = NLMSG_DATA(nlh);
 962         memset(pos, 0, len);
 963
 964         /*´«Êäµ½ÓÃ»§¿Õ¼äµÄÊý¾Ý*/
 965         memcpy(pos, msg,  len);
 966         /*¼ÆËã¾¹ý×Ö½Ú¶ÔÆäºóµÄÊý¾ÝÊµ¼Ê³¤¶È*/
 967         nlh->nlmsg_len = skb->tail - old_tail;
 968         NETLINK_CB(skb).dst_group = COMMTYPE_GROUP;
 969         netlink_broadcast(netlink_sk, skb, 0, COMMTYPE_GROUP, GFP_ATOMIC);
 970         ret = 0;
 971 out:
 972         return ret;
 973 nlmsg_failure: /*NLMSG_PUT Ê§°Ü£¬Ôò³·ÏúÌ×½Ó×Ö»º´æ*/
 974         if(skb)
 975                 kfree_skb(skb);
 976         goto out;
 977
 978 #undef COMMTYPE_GROUP
 979 #undef WAI_K_MSG
 980 }
 981 #endif //ZM_ENABLE_CENC
 982
 983 /* Simply return 0xffff if VAP function is not supported */
 984 u16_t zfLnxGetVapId(zdev_t* dev)
 985 {
 986     u16_t i;
 987
 988     for (i=0; i<ZM_VAP_PORT_NUMBER; i++)
 989     {
 990         if (vap[i].dev == dev)
 991         {
 992             return i;
 993         }
 994     }
 995     return 0xffff;
 996 }
 997
 998 u32_t zfwReadReg(zdev_t* dev, u32_t offset)
 999 {
1000     return 0;
1001 }
1002
1003 #ifndef INIT_WORK
1004 #define work_struct tq_struct
1005
1006 #define schedule_work(a)  schedule_task(a)
1007
1008 #define flush_scheduled_work  flush_scheduled_tasks
1009 #define INIT_WORK(_wq, _routine, _data)  INIT_TQUEUE(_wq, _routine, _data)
1010 #define PREPARE_WORK(_wq, _routine, _data)  PREPARE_TQUEUE(_wq, _routine, _data)
1011 #endif
1012
1013 #define KEVENT_WATCHDOG        0x00000001
1014
1015 u32_t smp_kevent_Lock = 0;
1016
1017 void kevent(struct work_struct *work)
1018 {
1019     struct usbdrv_private *macp =
1020                container_of(work, struct usbdrv_private, kevent);
1021     zdev_t *dev = macp->device;
1022
1023     if (macp == NULL)
1024     {
1025         return;
1026     }
1027
1028     if (test_and_set_bit(0, (void *)&smp_kevent_Lock))
1029     {
1030         //schedule_work(&macp->kevent);
1031         return;
1032     }
1033
1034     down(&macp->ioctl_sem);
1035
1036     if (test_and_clear_bit(KEVENT_WATCHDOG, &macp->kevent_flags))
1037     {
1038     extern u16_t zfHpStartRecv(zdev_t *dev);
1039         //zfiHwWatchDogReinit(dev);
1040         printk(("\n ************ Hw watchDog occur!! ************** \n"));
1041         zfiWlanSuspend(dev);
1042         zfiWlanResume(dev,0);
1043         zfHpStartRecv(dev);
1044     }
1045
1046     clear_bit(0, (void *)&smp_kevent_Lock);
1047     up(&macp->ioctl_sem);
1048 }
1049
1050 /************************************************************************/
1051 /*                                                                      */
1052 /*    FUNCTION DESCRIPTION                 zfLnxCreateThread            */
1053 /*      Create a Thread                                                 */
1054 /*                                                                      */
1055 /*    INPUTS                                                            */
1056 /*      dev : device pointer                                            */
1057 /*                                                                      */
1058 /*    OUTPUTS                                                           */
1059 /*      always 0                                                        */
1060 /*                                                                      */
1061 /*    AUTHOR                                                            */
1062 /*      Yuan-Gu Wei         Atheros Communications, INC.    2007.3      */
1063 /*                                                                      */
1064 /************************************************************************/
1065 u8_t zfLnxCreateThread(zdev_t *dev)
1066 {
1067     struct usbdrv_private *macp = dev->ml_priv;
1068
1069     /* Create Mutex and keventd */
1070     INIT_WORK(&macp->kevent, kevent);
1071     init_MUTEX(&macp->ioctl_sem);
1072
1073     return 0;
1074 }
1075
1076 /************************************************************************/
1077 /*                                                                      */
1078 /*    FUNCTION DESCRIPTION                 zfLnxSignalThread            */
1079 /*      Signal Thread with Flag                                         */
1080 /*                                                                      */
1081 /*    INPUTS                                                            */
1082 /*      dev : device pointer                                            */
1083 /*      flag : signal thread flag                                       */
1084 /*                                                                      */
1085 /*    OUTPUTS                                                           */
1086 /*      none                                                            */
1087 /*                                                                      */
1088 /*    AUTHOR                                                            */
1089 /*      Yuan-Gu Wei         Atheros Communications, INC.    2007.3      */
1090 /*                                                                      */
1091 /************************************************************************/
1092 void zfLnxSignalThread(zdev_t *dev, int flag)
1093 {
1094     struct usbdrv_private *macp = dev->ml_priv;
1095
1096     if (macp == NULL)
1097     {
1098         printk("macp is NULL\n");
1099         return;
1100     }
1101
1102     if (0 && macp->kevent_ready != 1)
1103     {
1104         printk("Kevent not ready\n");
1105         return;
1106     }
1107
1108     set_bit(flag, &macp->kevent_flags);
1109
1110     if (!schedule_work(&macp->kevent))
1111     {
1112         //Fails is Normal
1113         //printk(KERN_ERR "schedule_task failed, flag = %x\n", flag);
1114     }
1115 }
1116
1117 /* Notify wrapper todo redownload firmware and reinit procedure when */
1118 /* hardware watchdog occur : zfiHwWatchDogReinit() */
1119 void zfLnxWatchDogNotify(zdev_t* dev)
1120 {
1121     zfLnxSignalThread(dev, KEVENT_WATCHDOG);
1122 }
1123
1124 /* Query Durantion of Active Scan */
1125 void zfwGetActiveScanDur(zdev_t* dev, u8_t* Dur)
1126 {
1127     *Dur = 30; // default 30 ms
1128 }
1129
1130 void zfwGetShowZeroLengthSSID(zdev_t* dev, u8_t* Dur)
1131 {
1132     *Dur = 0;
1133 }
1134