/*
 * Copyright (c) 2000-2005 ZyDAS Technology Corporation
 * Copyright (c) 2007-2008 Atheros Communications Inc.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
/*                                                                      */
/*  Module Name : ud.c                                                  */
/*                                                                      */
/*  Abstract                                                            */
/*      This module contains USB descriptor functions.                  */
/*                                                                      */
/*  NOTES                                                               */
/*      None                                                            */
/*                                                                      */
/************************************************************************/
#include "../80211core/cprecomp.h"
#include "hpani.h"
#include "hpusb.h"

extern void zfwUsbCmd(zdev_t* dev, u8_t endpt, u32_t* cmd, u16_t cmdLen);

extern void zfIdlRsp(zdev_t* dev, u32_t* rsp, u16_t rspLen);
extern u16_t zfDelayWriteInternalReg(zdev_t* dev, u32_t addr, u32_t val);
extern u16_t zfFlushDelayWrite(zdev_t* dev);


#define USB_ENDPOINT_TX_INDEX   1
#define USB_ENDPOINT_RX_INDEX   2
#define USB_ENDPOINT_INT_INDEX  3
#define USB_ENDPOINT_CMD_INDEX  4

void zfIdlCmd(zdev_t* dev, u32_t* cmd, u16_t cmdLen)
{
#if ZM_SW_LOOP_BACK != 1
    zfwUsbCmd(dev, USB_ENDPOINT_CMD_INDEX, cmd, cmdLen);
#endif

    return;
}


/* zfAdjustCtrlSetting: fit OUTS format */
/*     convert MIMO2 to OUTS             */
void zfAdjustCtrlSetting(zdev_t* dev, u16_t* header, zbuf_t* buf)
{
    /* MIMO2 => OUTS FB-50 */
    /* length not change, only modify format */

    u32_t oldMT;
        u32_t oldMCS;

    u32_t phyCtrl;
    u32_t oldPhyCtrl;

    u16_t tpc = 0;
    struct zsHpPriv* hpPriv;

    zmw_get_wlan_dev(dev);
    hpPriv=wd->hpPrivate;

   /* mm */
    if (header == NULL)
    {
        oldPhyCtrl = zmw_buf_readh(dev, buf, 4) | ((u32_t)zmw_buf_readh(dev, buf, 6) << 16);
    }
    else
    {
        oldPhyCtrl = header[2] | ((u32_t)header[3] <<16);
    }

        phyCtrl = 0;


        /* MT : Bit[1~0] */
        oldMT = oldPhyCtrl&0x3;
        phyCtrl |= oldMT;
    if ( oldMT == 0x3 )   /* DL-OFDM (Duplicate Legacy OFDM) */
                phyCtrl |= 0x1;


        /* PT : Bit[2]    HT PT: 0 Mixed mode    1 Green field */
        phyCtrl |= (oldPhyCtrl&0x4);

        /* Bandwidth control : Bit[4~3] */
        if ( oldPhyCtrl&0x800000 )    /* Bit23 : 40M */
        {
                #if 0
                if (oldMT == 0x3)             /* DL-OFDM */
            phyCtrl |= (0x3<<3);   /* 40M duplicate */
                else
                        phyCtrl |= (0x2<<3);   /* 40M shared */
                #else
                if (oldMT == 0x2 && ((struct zsHpPriv*)wd->hpPrivate)->hwBw40)
                {
                        phyCtrl |= (0x2<<3);   /* 40M shared */
                }
                #endif
        }
        else {
        oldPhyCtrl &= ~0x80000000;
    }

        /* MCS : Bit[24~18] */
        oldMCS = (oldPhyCtrl&0x7f0000)>>16;  /* Bit[22~16] */
        phyCtrl |= (oldMCS<<18);

        /* Short GI : Bit[31]*/
    phyCtrl |= (oldPhyCtrl&0x80000000);

        /* AM : Antenna mask */
        //if ((oldMT == 2) && (oldMCS > 7))
        if (hpPriv->halCapability & ZM_HP_CAP_11N_ONE_TX_STREAM)
        {
            phyCtrl |= (0x1<<15);
        }
        else
        {
            /* HT                     Tx 2 chain */
            /* OFDM 6M/9M/12M/18M/24M Tx 2 chain */
            /* OFDM 36M/48M/54M/      Tx 1 chain */
            /* CCK                    Tx 2 chain */
            if ((oldMT == 2) || (oldMT == 3))
            {
                phyCtrl |= (0x5<<15);
            }
            else if (oldMT == 1)
            {
                if ((oldMCS == 0xb) || (oldMCS == 0xf) ||
                    (oldMCS == 0xa) || (oldMCS == 0xe) ||
                    (oldMCS == 0x9))                       //6M/9M/12M/18M/24M
                {
                    phyCtrl |= (0x5<<15);
                }
                else
                {
                    phyCtrl |= (0x1<<15);
                }
            }
            else //(oldMT==0)
            {
                phyCtrl |= (0x5<<15);
            }
        }
        //else
        //    phyCtrl |= (0x1<<15);

        /* TPC */
        /* TODO : accelerating these code */
        if (hpPriv->hwFrequency < 3000)
        {
        if (oldMT == 0)
        {
            /* CCK */
            tpc = (hpPriv->tPow2xCck[oldMCS]&0x3f);
        }
        else if (oldMT == 1)
        {
            /* OFDM */
            if (oldMCS == 0xc)
            {
                tpc = (hpPriv->tPow2x2g[3]&0x3f);
            }
            else if (oldMCS == 0x8)
            {
                tpc = (hpPriv->tPow2x2g[2]&0x3f);
            }
            else if (oldMCS == 0xd)
            {
                tpc = (hpPriv->tPow2x2g[1]&0x3f);
            }
            else if (oldMCS == 0x9)
            {
                tpc = ((hpPriv->tPow2x2g[0]-hpPriv->tPow2x2g24HeavyClipOffset)&0x3f);
            }
            else
            {
                tpc = (hpPriv->tPow2x2g[0]&0x3f);
            }
        }
        else if (oldMT == 2)
        {
            if ( oldPhyCtrl&0x800000 )    /* Bit23 : 40M */
            {
                /* HT 40 */
                tpc = (hpPriv->tPow2x2gHt40[oldMCS&0x7]&0x3f);
            }
            else
            {
                /* HT 20 */
                tpc = (hpPriv->tPow2x2gHt20[oldMCS&0x7]&0x3f);
            }
        }
    }
    else  //5GHz
    {
        if (oldMT == 1)
        {
            /* OFDM */
            if (oldMCS == 0xc)
            {
                tpc = (hpPriv->tPow2x5g[3]&0x3f);
            }
            else if (oldMCS == 0x8)
            {
                tpc = (hpPriv->tPow2x5g[2]&0x3f);
            }
            else if (oldMCS == 0xd)
            {
                tpc = (hpPriv->tPow2x5g[1]&0x3f);
            }
            else
            {
                tpc = (hpPriv->tPow2x5g[0]&0x3f);
            }
        }
        else if (oldMT == 2)
        {
            if ( oldPhyCtrl&0x800000 )    /* Bit23 : 40M */
            {
                /* HT 40 */
                tpc = (hpPriv->tPow2x5gHt40[oldMCS&0x7]&0x3f);
            }
            else
            {
                /* HT 20 */
                tpc = (hpPriv->tPow2x5gHt20[oldMCS&0x7]&0x3f);
            }
        }
    }

    /* Tx power adjust for HT40 */
        /* HT40   +1dBm */
        if ((oldMT==2) && (oldPhyCtrl&0x800000) )
        {
            tpc += 2;
        }
        tpc &= 0x3f;

    /* Evl force tx TPC */
    if(wd->forceTxTPC)
    {
        tpc = (u16_t)(wd->forceTxTPC & 0x3f);
    }

    if (hpPriv->hwFrequency < 3000) {
        wd->maxTxPower2 &= 0x3f;
        tpc = (tpc > wd->maxTxPower2)? wd->maxTxPower2 : tpc;
    } else {
        wd->maxTxPower5 &= 0x3f;
        tpc = (tpc > wd->maxTxPower5)? wd->maxTxPower5 : tpc;
    }


#define ZM_MIN_TPC     5
#define ZM_TPC_OFFSET  5
#define ZM_SIGNAL_THRESHOLD  56
    if ((wd->sta.bScheduleScan == FALSE) && (wd->sta.bChannelScan == FALSE))
    {
        if (( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
                && (zfStaIsConnected(dev))
                && (wd->SignalStrength > ZM_SIGNAL_THRESHOLD))
        {
            if (tpc > ((ZM_MIN_TPC+ZM_TPC_OFFSET)*2))
            {
                tpc -= (ZM_TPC_OFFSET*2);
            }
            else if (tpc > (ZM_MIN_TPC*2))
            {
                tpc = (ZM_MIN_TPC*2);
            }
        }
    }
#undef ZM_MIN_TPC
#undef ZM_TPC_OFFSET
#undef ZM_SIGNAL_THRESHOLD

    #ifndef ZM_OTUS_LINUX_PHASE_2
    phyCtrl |= (tpc & 0x3f) << 9;
    #endif

    /* Set bits[8:6]BF-MCS for heavy clip */
    if ((phyCtrl&0x3) == 2)
        {
            phyCtrl |= ((phyCtrl >> 12) & 0x1c0);
    }

        /* PHY control */
    if (header == NULL)
    {
        zmw_buf_writeh(dev, buf, 4, (u16_t) (phyCtrl&0xffff));
        zmw_buf_writeh(dev, buf, 6, (u16_t) (phyCtrl>>16));
    }
    else
    {
        //PHY control L
        header[2] = (u16_t) (phyCtrl&0xffff);
        //PHY control H
        header[3] = (u16_t) (phyCtrl>>16);
    }

        zm_msg2_tx(ZM_LV_2, "old phy ctrl = ", oldPhyCtrl);
    zm_msg2_tx(ZM_LV_2, "new phy ctrl = ", phyCtrl);
        //DbgPrint("old phy ctrl =%08x \n", oldPhyCtrl);
    //DbgPrint("new phy ctrl =%08x \n", phyCtrl);
}


#define EXTRA_INFO_LEN      24    //RSSI(7) + EVM(12) + PHY(1) + MACStatus(4)
u16_t zfHpSend(zdev_t* dev, u16_t* header, u16_t headerLen,
                u16_t* snap, u16_t snapLen,
                u16_t* tail, u16_t tailLen, zbuf_t* buf, u16_t offset,
                u16_t bufType, u8_t ac, u8_t keyIdx)
{
#if ZM_SW_LOOP_BACK == 1
    zbuf_t *rxbuf;
    u8_t *puRxBuf;
    u8_t *pHdr;
           u8_t *psnap;
           u16_t plcplen = 12;
    u16_t i;
        u16_t swlpOffset;
#endif /* #if ZM_SW_LOOP_BACK == 1 */
    struct zsHpPriv* hpPriv;

    zmw_get_wlan_dev(dev);
    hpPriv=wd->hpPrivate;

    zm_msg1_tx(ZM_LV_1, "zfHpSend(), len = ", 12 + headerLen-8 + snapLen + zfwBufGetSize(dev, buf) + 4 + 8);

        /* Adjust ctrl setting : 6N14 yjsung */
    zfAdjustCtrlSetting(dev, header, buf);

#if ZM_SW_LOOP_BACK != 1
    hpPriv->usbSendBytes += zfwBufGetSize(dev, buf);
    hpPriv->usbAcSendBytes[ac&0x3] += zfwBufGetSize(dev, buf);

    /* Submit USB Out Urb */
    zfwUsbSend(dev, USB_ENDPOINT_TX_INDEX, (u8_t *)header, headerLen,
                  (u8_t *)snap, snapLen, (u8_t *)tail, tailLen, buf, offset);
#endif

#if ZM_SW_LOOP_BACK == 1

    rxbuf = zfwBufAllocate(dev, plcplen + headerLen-8 + snapLen + (zfwBufGetSize(dev, buf)-offset) + 4 + EXTRA_INFO_LEN);
    pHdr = (u8_t *) header+8;
        psnap = (u8_t *) snap;

    zmw_enter_critical_section(dev);
    /* software loop back */
    /* Copy WLAN header and packet buffer */
        swlpOffset = plcplen;

    for(i = 0; i < headerLen-8; i++)
    {
        zmw_rx_buf_writeb(dev, rxbuf, swlpOffset+i, pHdr[i]);
    }

        swlpOffset += headerLen-8;

    /* Copy SNAP header */
    for(i = 0; i < snapLen; i++)
    {
                      zmw_rx_buf_writeb(dev, rxbuf, swlpOffset+i, psnap[i]);
    }

           swlpOffset += snapLen;

    /* Copy body from tx buf to rxbuf */
    for(i = 0; i < (zfwBufGetSize(dev, buf)-offset); i++)
    {
        u8_t value = zmw_rx_buf_readb(dev, buf, i+offset);
        zmw_rx_buf_writeb(dev, rxbuf, swlpOffset+i, value);
    }

           /* total length = PLCP +         MacHeader       + Payload   + FCS + RXstatus */
           /*                 12  +  headerLen-8  + snapLen + buf length + 4  + 8        */
        zfwSetBufSetSize(dev, rxbuf, swlpOffset + (zfwBufGetSize(dev, buf)-offset) + 4 + EXTRA_INFO_LEN );

    zmw_leave_critical_section(dev);

    zfwBufFree(dev, buf, 0);

           //zfwDumpBuf(dev, rxbuf);
           //-------------------------------------------------

    //zfCoreRecv(dev, rxbuf);

#endif /* #if ZM_SW_LOOP_BACK */

    return ZM_SUCCESS;
}

/* Report moniter Hal rx information about rssi, evm, bandwidth, SG etc */
void zfHpQueryMonHalRxInfo(zdev_t* dev, u8_t *monHalRxInfo)
{
    zmw_get_wlan_dev(dev);
    zfMemoryCopy(monHalRxInfo,
                (u8_t*)&(((struct zsHpPriv*)wd->hpPrivate)->halRxInfo),
                sizeof(struct zsHalRxInfo));
}


u8_t zfIsDataFrame(zdev_t* dev, zbuf_t* buf)
{
    u8_t frameType;
    u8_t mpduInd;

    mpduInd = zmw_rx_buf_readb(dev, buf, zfwBufGetSize(dev, buf)-1);

    /* sinlge or First */
    if ((mpduInd & 0x30) == 0x00 || (mpduInd & 0x30) == 0x20)
    {
        frameType = zmw_rx_buf_readb(dev, buf, 12);
    }
    else
    {
        frameType = zmw_rx_buf_readb(dev, buf, 0);
    }

    if((frameType & 0xf) == ZM_WLAN_DATA_FRAME)
        return 1;
    else
        return 0;
}

u32_t zfcConvertRateOFDM(zdev_t* dev, zbuf_t* buf)
{
    // What's the default value??
    u32_t MCS = 0;

    switch(zmw_rx_buf_readb(dev, buf, 0)& 0xf)
    {
        case 0xb:
            MCS = 0x4;
            break;
        case 0xf:
            MCS = 0x5;
            break;
        case 0xa:
            MCS = 0x6;
            break;
        case 0xe:
            MCS = 0x7;
            break;
        case 0x9:
            MCS = 0x8;
            break;
        case 0xd:
            MCS = 0x9;
            break;
        case 0x8:
            MCS = 0xa;
            break;
        case 0xc:
            MCS = 0xb;
            break;
    }
    return MCS;
}

u16_t zfHpGetPayloadLen(zdev_t* dev,
                        zbuf_t* buf,
                        u16_t len,
                        u16_t plcpHdrLen,
                        u32_t *rxMT,
                        u32_t *rxMCS,
                        u32_t *rxBW,
                        u32_t *rxSG
                        )
{
    u8_t modulation,mpduInd;
    u16_t low, high, msb;
    s16_t payloadLen = 0;

    zmw_get_wlan_dev(dev);

    mpduInd = zmw_rx_buf_readb(dev, buf, len-1);
    modulation = zmw_rx_buf_readb(dev, buf, (len-1)) & 0x3;
    *rxMT = modulation;

    //zm_debug_msg1(" modulation= ", modulation);
    switch (modulation) {
    case 0: /* CCK Mode */
        low = zmw_rx_buf_readb(dev, buf, 2);
        high = zmw_rx_buf_readb(dev, buf, 3);
        payloadLen = (low | high << 8) - 4;
        if (wd->enableHALDbgInfo)
        {
            *rxMCS = zmw_rx_buf_readb(dev, buf, 0);
            *rxBW  = 0;
            *rxSG  = 0;
        }
        break;
    case 1: /* Legacy-OFDM mode */
        low = zmw_rx_buf_readb(dev, buf, 0) >> 5;
        high = zmw_rx_buf_readb(dev, buf, 1);
        msb = zmw_rx_buf_readb(dev, buf, 2) & 0x1;
        payloadLen = (low | (high << 3) | (msb << 11)) - 4;
        if (wd->enableHALDbgInfo)
        {
            *rxMCS = zfcConvertRateOFDM(dev, buf);
            *rxBW  = 0;
            *rxSG  = 0;
        }
        break;
    case 2: /* HT OFDM mode */
        //zm_debug_msg1("aggregation= ", (zmw_rx_buf_readb(dev, buf, 6) >> 3) &0x1 );
        if ((mpduInd & 0x30) == 0x00 || (mpduInd & 0x30) == 0x10)    //single or last mpdu
            payloadLen = len - 24 - 4 - plcpHdrLen;  // - rxStatus - fcs
        else {
            payloadLen = len - 4 - 4 - plcpHdrLen;  // - rxStatus - fcs
            //zm_debug_msg1("first or middle mpdu, plcpHdrLen= ", plcpHdrLen);
        }
        if (wd->enableHALDbgInfo)
        {
            *rxMCS = zmw_rx_buf_readb(dev, buf, 3) & 0x7f;
            *rxBW  = (zmw_rx_buf_readb(dev, buf, 3) >> 7) & 0x1;
            *rxSG  = (zmw_rx_buf_readb(dev, buf, 6) >> 7) & 0x1;
        }
        break;
    default:
        break;

    }
    /* return the payload length - FCS */
    if (payloadLen < 0) payloadLen = 0;
    return payloadLen;
}

/************************************************************************/
/*                                                                      */
/*    FUNCTION DESCRIPTION                  zfiUsbRecv                  */
/*      Callback function for USB IN Transfer.                          */
/*                                                                      */
/*    INPUTS                                                            */
/*      dev: device pointer                                             */
/*                                                                      */
/*    OUTPUTS                                                           */
/*      None                                                            */
/*                                                                      */
/*    AUTHOR                                                            */
/*      Yuan-Gu Wei        ZyDAS Technology Corporation    2005.10      */
/*                                                                      */
/************************************************************************/
#define ZM_INT_USE_EP2                1
#define ZM_INT_USE_EP2_HEADER_SIZE   12

#if ZM_INT_USE_EP2 == 1
void zfiUsbRegIn(zdev_t* dev, u32_t* rsp, u16_t rspLen);
#endif

#ifdef ZM_OTUS_RX_STREAM_MODE
void zfiUsbRecvPerPkt(zdev_t *dev, zbuf_t *buf)
#else
void zfiUsbRecv(zdev_t *dev, zbuf_t *buf)
#endif
{


#if ZM_FW_LOOP_BACK != 1
    u8_t mpduInd;
    u16_t plcpHdrLen;
    u16_t crcPlusRxStatusLen;
    u16_t len, payloadLen=0;
    u16_t i; //CWYang(+)
    struct zsAdditionInfo addInfo;
    u32_t               rxMT;
    u32_t               rxMCS;
    u32_t               rxBW;
    u32_t               rxSG;
    struct zsHpPriv* hpPriv;

    zmw_get_wlan_dev(dev);
    hpPriv=wd->hpPrivate;

    //zm_msg0_rx(ZM_LV_0, "zfiUsbRecv()");

#if ZM_INT_USE_EP2 == 1

    for (i=0; i<(ZM_INT_USE_EP2_HEADER_SIZE>>1); i++)
    {
        if (zmw_rx_buf_readh(dev, buf, i*2) != 0xffff)
                break;
    }

    if (i==(ZM_INT_USE_EP2_HEADER_SIZE>>1))
    {
        u32_t               rsp[ZM_USB_MAX_EPINT_BUFFER/4];
        u16_t               rspLen;
        u32_t               rspi;
        u8_t*               pdst = (u8_t*)rsp;

        /* Interrupt Rsp */
        rspLen = (u16_t) zfwBufGetSize(dev, buf)-ZM_INT_USE_EP2_HEADER_SIZE;

        if (rspLen > 60)
        {
            zm_debug_msg1("Get error len by EP2 = \n", rspLen);
            /* free USB buf */
                  zfwBufFree(dev, buf, 0);
                  return;
        }

        for (rspi=0; rspi<rspLen; rspi++)
        {
                *pdst = zmw_rx_buf_readb(dev, buf, rspi+ZM_INT_USE_EP2_HEADER_SIZE);
                pdst++;
        }

        //if (adapter->zfcbUsbRegIn)
        //    adapter->zfcbUsbRegIn(adapter, rsp, rspLen);
        zfiUsbRegIn(dev, rsp, rspLen);

              /* free USB buf */
              zfwBufFree(dev, buf, 0);
              return;
    }
#endif /* end of #if ZM_INT_USE_EP2 == 1 */

    ZM_PERFORMANCE_RX_MPDU(dev, buf);

    if (wd->swSniffer)
    {
        /* airopeek: Report everything up */
        if (wd->zfcbRecv80211 != NULL)
        {
            wd->zfcbRecv80211(dev, buf, NULL);
        }
    }

    /* Read the last byte */
    len = zfwBufGetSize(dev, buf);
    mpduInd = zmw_rx_buf_readb(dev, buf, len-1);

    /* First MPDU */
    if((mpduInd & 0x30) == 0x20)
    {
        u16_t duration;
        if (zmw_rx_buf_readb(dev, buf, 36) == 0) //AC = BE
        {
            duration = zmw_rx_buf_readh(dev, buf, 14);
            if (duration > hpPriv->aggMaxDurationBE)
            {
                hpPriv->aggMaxDurationBE = duration;
            }
            else
            {
                if (hpPriv->aggMaxDurationBE > 10)
                {
                    hpPriv->aggMaxDurationBE--;
                }
            }
            //DbgPrint("aggMaxDurationBE=%d", hpPriv->aggMaxDurationBE);
        }
    }

#if 1
    /* First MPDU or Single MPDU */
    if(((mpduInd & 0x30) == 0x00) || ((mpduInd & 0x30) == 0x20))
    //if ((mpduInd & 0x10) == 0x00)
    {
        plcpHdrLen = 12;        // PLCP header length
    }
    else
    {
        if (zmw_rx_buf_readh(dev, buf, 4) == wd->macAddr[0] &&
            zmw_rx_buf_readh(dev, buf, 6) == wd->macAddr[1] &&
            zmw_rx_buf_readh(dev, buf, 8) == wd->macAddr[2]) {
            plcpHdrLen = 0;
        }
        else if (zmw_rx_buf_readh(dev, buf, 16) == wd->macAddr[0] &&
                 zmw_rx_buf_readh(dev, buf, 18) == wd->macAddr[1] &&
                 zmw_rx_buf_readh(dev, buf, 20) == wd->macAddr[2]){
            plcpHdrLen = 12;
        }
        else {
            plcpHdrLen = 0;
        }
    }

    /* Last MPDU or Single MPDU */
    if ((mpduInd & 0x30) == 0x00 || (mpduInd & 0x30) == 0x10)
    {
        crcPlusRxStatusLen = EXTRA_INFO_LEN + 4;     // Extra bytes + FCS
    }
    else
    {
        crcPlusRxStatusLen = 4 + 4;     // Extra 4 bytes + FCS
    }
#else
    plcpHdrLen = 12;
    crcPlusRxStatusLen = EXTRA_INFO_LEN + 4;     // Extra bytes + FCS
#endif

    if (len < (plcpHdrLen+10+crcPlusRxStatusLen))
    {
        zm_msg1_rx(ZM_LV_0, "Invalid Rx length=", len);
        //zfwDumpBuf(dev, buf);

        zfwBufFree(dev, buf, 0);
        return;
    }

    /* display RSSI combined */
    /*
     * ¢z¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢s¢w¢w¢w¢w¢w¢w¢w¢w¢s¢w¢w¢w¢w¢w¢w¢s¢w¢w¢w¢w¢w¢w¢s¢w¢w¢w¢w¢w¢w¢w¢w¢w¢s¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢{
     * ¢x PLCP Header ¢x  MPDU  ¢x RSSI ¢x  EVM ¢x PHY Err ¢x  MAC Status ¢x
     * ¢u¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢q¢w¢w¢w¢w¢w¢w¢w¢w¢q¢w¢w¢w¢w¢w¢w¢q¢w¢w¢w¢w¢w¢w¢q¢w¢w¢w¢w¢w¢w¢w¢w¢w¢q¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢t
     * ¢x     12      ¢x    n   ¢x  7   ¢x  12  ¢x    1    ¢x      4      ¢x
     * ¢|¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢r¢w¢w¢w¢w¢w¢w¢w¢w¢r¢w¢w¢w¢w¢w¢w¢r¢w¢w¢w¢w¢w¢w¢r¢w¢w¢w¢w¢w¢w¢w¢w¢w¢r¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢}
     *  RSSI filed (From BB and MAC just pass them to host)
     *   Byte1: RSSI for antenna 0.
     *   Byte2: RSSI for antenna 1.
     *   Byte3: RSSI for antenna 2.
     *   Byte4: RSSI for antenna 0 extension.
     *   Byte5: RSSI for antenna 1 extension.
     *   Byte6: RSSI for antenna 2 extension.
     *   Byte7: RSSI for antenna combined.
     */

    //zm_debug_msg1(" recv RSSI = ", zmw_rx_buf_readb(dev, buf, (len-1)-17));

    payloadLen = zfHpGetPayloadLen(dev, buf, len, plcpHdrLen, &rxMT, &rxMCS, &rxBW, &rxSG);

    /* Hal Rx info */
    /* First MPDU or Single MPDU */
    if(((mpduInd & 0x30) == 0x00) || ((mpduInd & 0x30) == 0x20))
    {
        if (wd->enableHALDbgInfo && zfIsDataFrame(dev, buf))
        {
            ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxDataMT   = rxMT;
            ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxDataMCS  = rxMCS;
            ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxDataBW   = rxBW;
            ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxDataSG   = rxSG;
        }
    }

    if ((plcpHdrLen + payloadLen) > len) {
        zm_msg1_rx(ZM_LV_0, "Invalid payload length=", payloadLen);
        zfwBufFree(dev, buf, 0);
        return;
    }

    //Store Rx Tail Infomation before Remove--CWYang(+)

#if 0
    for (i = 0; i < crcPlusRxStatusLen-4; i++)
    {
       addInfo.Tail.Byte[i] =
               zmw_rx_buf_readb(dev, buf, len - crcPlusRxStatusLen + 4 + i);
    }
#else
/*
* Brief format of OUTS chip
* ¢z¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢s¢w¢w¢w¢w¢w¢w¢w¢w¢s¢w¢w¢w¢w¢w¢w¢s¢w¢w¢w¢w¢w¢w¢s¢w¢w¢w¢w¢w¢w¢w¢w¢w¢s¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢{
* ¢x PLCP Header ¢x  MPDU  ¢x RSSI ¢x  EVM ¢x PHY Err ¢x  MAC Status ¢x
* ¢u¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢q¢w¢w¢w¢w¢w¢w¢w¢w¢q¢w¢w¢w¢w¢w¢w¢q¢w¢w¢w¢w¢w¢w¢q¢w¢w¢w¢w¢w¢w¢w¢w¢w¢q¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢t
* ¢x     12      ¢x    n   ¢x  7   ¢x  12  ¢x    1    ¢x      4      ¢x
* ¢|¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢r¢w¢w¢w¢w¢w¢w¢w¢w¢r¢w¢w¢w¢w¢w¢w¢r¢w¢w¢w¢w¢w¢w¢r¢w¢w¢w¢w¢w¢w¢w¢w¢w¢r¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢w¢}
* RSSI:
*       Byte 1  antenna 0
*       Byte 2  antenna 1
*       Byte 3  antenna 2
*       Byte 4  antenna 0 extension
*       Byte 5  antenna 1 extension
*       Byte 6  antenna 2 extension
*       Byte 7  antenna combined
* EVM:
*       Byte 1  Stream 0 pilot 0
*       Byte 2  Stream 0 pilot 1
*       Byte 3  Stream 0 pilot 2
*       Byte 4  Stream 0 pilot 3
*       Byte 5  Stream 0 pilot 4
*       Byte 6  Stream 0 pilot 5
*       Byte 7  Stream 1 pilot 0
*       Byte 8  Stream 1 pilot 1
*       Byte 9  Stream 1 pilot 2
*       Byte 10 Stream 1 pilot 3
*       Byte 11 Stream 1 pilot 4
*       Byte 12 Stream 1 pilot 5
*/

    /* Fill the Tail information */
    /* Last MPDU or Single MPDU */
    if ((mpduInd & 0x30) == 0x00 || (mpduInd & 0x30) == 0x10)
    {
#define ZM_RX_RSSI_COMPENSATION     27
        u8_t zm_rx_rssi_compensation = ZM_RX_RSSI_COMPENSATION;

        /* RSSI information */
        addInfo.Tail.Data.SignalStrength1 = zmw_rx_buf_readb(dev, buf,
                (len-1) - 17) + ((hpPriv->rxStrongRSSI == 1)?zm_rx_rssi_compensation:0);
#undef ZM_RX_RSSI_COMPENSATION

      /* EVM */

      /* TODO: for RD/BB debug message */
      /* save current rx hw infomration, report to DrvCore/Application */
      if (wd->enableHALDbgInfo && zfIsDataFrame(dev, buf))
      {
            u8_t trssi;
            for (i=0; i<7; i++)
            {
                trssi = zmw_rx_buf_readb(dev, buf, (len-1) - 23 + i);
                    if (trssi&0x80)
                    {
                    trssi = ((~((u8_t)trssi) & 0x7f) + 1) & 0x7f;
                }
                ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRSSI[i] = trssi;

            }
          if (rxMT==2)
          {
            //if (rxBW)
            //{
                  for (i=0; i<12; i++)
                    ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxEVM[i] =
                                       zmw_rx_buf_readb(dev, buf, (len-1) - 16 + i);
            //}
            //else
            //{
            //    for (i=0; i<4; i++)
            //        ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxEVM[i] =
            //                           zmw_rx_buf_readb(dev, buf, (len-1) - 16 + i);
            //}
          }

          #if 0
          /* print */
            zm_dbg(("MT(%d) MCS(%d) BW(%d) SG(%d) RSSI:%d,%d,%d,%d,%d,%d,%d EVM:(%d,%d,%d,%d,%d,%d)(%d,%d,%d,%d,%d,%d)\n",
                       rxMT,
                       rxMCS,
                       rxBW,
                       rxSG,
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRSSI[0],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRSSI[1],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRSSI[2],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRSSI[3],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRSSI[4],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRSSI[5],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRSSI[6],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxEVM[0],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxEVM[1],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxEVM[2],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxEVM[3],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxEVM[4],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxEVM[5],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxEVM[6],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxEVM[7],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxEVM[8],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxEVM[9],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxEVM[10],
                       ((struct zsHpPriv*)wd->hpPrivate)->halRxInfo.currentRxEVM[11]
                       ));
          #endif
      } /* if (wd->enableHALDbgInfo && zfIsDataFrame(dev, buf)) */

    }
    else
    {
        /* Mid or First aggregate frame without phy rx information */
        addInfo.Tail.Data.SignalStrength1 = 0;
    }

    addInfo.Tail.Data.SignalStrength2 = 0;
    addInfo.Tail.Data.SignalStrength3 = 0;
    addInfo.Tail.Data.SignalQuality   = 0;

    addInfo.Tail.Data.SAIndex           = zmw_rx_buf_readb(dev, buf, len - 4);
    addInfo.Tail.Data.DAIndex           = zmw_rx_buf_readb(dev, buf, len - 3);
    addInfo.Tail.Data.ErrorIndication   = zmw_rx_buf_readb(dev, buf, len - 2);
    addInfo.Tail.Data.RxMacStatus       = zmw_rx_buf_readb(dev, buf, len - 1);

#endif
    /* Remove CRC and Rx Status */
    zfwBufSetSize(dev, buf, (len-crcPlusRxStatusLen));
    //zfwBufSetSize(dev, buf, payloadLen + plcpHdrLen);    /* payloadLen + PLCP 12 - FCS 4*/

    //Store PLCP Header Infomation before Remove--CWYang(+)
    if (plcpHdrLen != 0)
    {
        for (i = 0; i < plcpHdrLen; i++)
        {
            addInfo.PlcpHeader[i] = zmw_rx_buf_readb(dev, buf, i);
        }
    }
    else
    {
        addInfo.PlcpHeader[0] = 0;
    }
    /* Remove PLCP header */
    zfwBufRemoveHead(dev, buf, plcpHdrLen);

    /* handle 802.11 frame */
    zfCoreRecv(dev, buf, &addInfo);

#else
    /* Firmware loopback: Rx frame = Tx frame       */
    /* convert Rx frame to fit receive frame format */
    zbuf_t *new_buf;
    u8_t    ctrl_offset = 8;
    u8_t    PLCP_Len = 12;
    u8_t    data;
    u8_t    i;


    /* Tx:  | ctrl_setting | Mac hdr | data | */
    /*            8            24       x     */

    /* Rx:          | PLCP | Mac hdr | data | FCS | Rxstatus | */
    /*                 12      24        x     4       8       */

    /* new allocate a rx format size buf */
    new_buf = zfwBufAllocate(dev, zfwBufGetSize(dev, buf)-8+12+4+EXTRA_INFO_LEN);

    for (i=0; i<zfwBufGetSize(dev, buf)-ctrl_offset; i++)
    {
        data = zmw_rx_buf_readb(dev, buf, ctrl_offset+i);
        zmw_rx_buf_writeb(dev, new_buf, PLCP_Len+i, data);
    }

    zfwBufSetSize(dev, new_buf, zfwBufGetSize(dev, buf)-8+12+4+EXTRA_INFO_LEN);

    zfwBufFree(dev, buf, 0);

    /* receive the new_buf */
    //zfCoreRecv(dev, new_buf);

#endif

}

#ifdef ZM_OTUS_RX_STREAM_MODE
void zfiUsbRecv(zdev_t *dev, zbuf_t *buf)
{
    u16_t index = 0;
    u16_t chkIdx;
    u32_t status = 0;
    u16_t ii;
    zbuf_t *newBuf;
    zbuf_t *rxBufPool[8];
    u16_t rxBufPoolIndex = 0;
    struct zsHpPriv *halPriv;
    u8_t *srcBufPtr;
    u32_t bufferLength;
    u16_t usbRxRemainLen;
    u16_t usbRxPktLen;

    zmw_get_wlan_dev(dev);

    halPriv = (struct zsHpPriv*)wd->hpPrivate;
    srcBufPtr = zmw_buf_get_buffer(dev, buf);

    bufferLength = zfwBufGetSize(dev, buf);

    /* Zero Length Transfer */
    if (!bufferLength)
    {
        zfwBufFree(dev, buf, 0);
        return;
    }

    usbRxRemainLen = halPriv->usbRxRemainLen;
    usbRxPktLen = halPriv->usbRxTransferLen;

    /* Check whether there is any data in the last transfer */
    if (usbRxRemainLen != 0 )
    {
        zbuf_t *remainBufPtr = halPriv->remainBuf;
        u8_t* BufPtr = NULL;

        if ( remainBufPtr != NULL )
        {
            BufPtr = zmw_buf_get_buffer(dev, remainBufPtr);
        }

        index = usbRxRemainLen;
        usbRxRemainLen -= halPriv->usbRxPadLen;

        /*  Copy data */
        if ( BufPtr != NULL )
        {
            zfwMemoryCopy(&(BufPtr[usbRxPktLen]), srcBufPtr, usbRxRemainLen);
        }

        usbRxPktLen += usbRxRemainLen;
        halPriv->usbRxRemainLen = 0;

        if ( remainBufPtr != NULL )

        {
            zfwBufSetSize(dev, remainBufPtr, usbRxPktLen);
            rxBufPool[rxBufPoolIndex++] = remainBufPtr;
        }
        halPriv->remainBuf = NULL;
    }

    //zm_debug_msg1("length: %d\n", (int)pUsbRxTransfer->pRxUrb->UrbBulkOrInterruptTransfer.TransferBufferLength);

    bufferLength = zfwBufGetSize(dev, buf);
//printk("bufferLength %d\n", bufferLength);
    while(index < bufferLength)
    {
        u16_t pktLen;
        u16_t pktTag;
        //u8_t *ptr = (u8_t*)((struct zsBuffer*)pUsbRxTransfer->buf)->data;
        u8_t *ptr = srcBufPtr;

        /* Retrieve packet length and tag */
        pktLen = ptr[index] + (ptr[index+1] << 8);
        pktTag = ptr[index+2] + (ptr[index+3] << 8);

        if (pktTag == ZM_USB_STREAM_MODE_TAG)
        {
            u16_t padLen;

            zm_assert(pktLen < ZM_WLAN_MAX_RX_SIZE);

            //printk("Get a packet, pktLen: 0x%04x\n", pktLen);
            #if 0
            /* Dump data */
            for (ii = index; ii < pkt_len+4;)
            {
                DbgPrint("0x%02x ",
                        (zmw_rx_buf_readb(adapter, pUsbRxTransfer->buf, ii) & 0xff));

                if ((++ii % 16) == 0)
                    DbgPrint("\n");
            }

            DbgPrint("\n");
            #endif

            /* Calcuate the padding length, in the current design,
               the length should be padded to 4 byte boundray. */
            padLen = ZM_USB_STREAM_MODE_TAG_LEN - (pktLen & 0x3);

            if(padLen == ZM_USB_STREAM_MODE_TAG_LEN)
                padLen = 0;

            chkIdx = index;
            index = index + ZM_USB_STREAM_MODE_TAG_LEN + pktLen + padLen;

            if (chkIdx > ZM_MAX_USB_IN_TRANSFER_SIZE)
            {
                zm_debug_msg1("chkIdx is too large, chkIdx: %d\n", chkIdx);
                zm_assert(0);
                status = 1;
                break;
            }

            if (index > ZM_MAX_USB_IN_TRANSFER_SIZE)
            {
                //struct zsBuffer* BufPtr;
                //struct zsBuffer* UsbBufPtr;
                u8_t *BufPtr;
                u8_t *UsbBufPtr;

                halPriv->usbRxRemainLen = index - ZM_MAX_USB_IN_TRANSFER_SIZE; // - padLen;
                halPriv->usbRxTransferLen = ZM_MAX_USB_IN_TRANSFER_SIZE -
                        chkIdx - ZM_USB_STREAM_MODE_TAG_LEN;
                halPriv->usbRxPadLen = padLen;
                //check_index = index;

                if (halPriv->usbRxTransferLen > ZM_WLAN_MAX_RX_SIZE)
                {
                    zm_debug_msg1("check_len is too large, chk_len: %d\n",
                            halPriv->usbRxTransferLen);
                    status = 1;
                    break;
                }

                /* Allocate a skb buffer */
                newBuf = zfwBufAllocate(dev, ZM_WLAN_MAX_RX_SIZE);

                if ( newBuf != NULL )
                {
                    BufPtr = zmw_buf_get_buffer(dev, newBuf);
                    UsbBufPtr = srcBufPtr;

                    /* Copy the buffer */
                    zfwMemoryCopy(BufPtr, &(UsbBufPtr[chkIdx+ZM_USB_STREAM_MODE_TAG_LEN]), halPriv->usbRxTransferLen);

                    /* Record the buffer pointer */
                    halPriv->remainBuf = newBuf;
                }
            }
            else
            {
                u8_t* BufPtr;
                u8_t* UsbBufPtr;

                /* Allocate a skb buffer */
                newBuf = zfwBufAllocate(dev, ZM_WLAN_MAX_RX_SIZE);
                if ( newBuf != NULL )
                {
                    BufPtr = zmw_buf_get_buffer(dev, newBuf);
                    UsbBufPtr = srcBufPtr;

                    /* Copy the buffer */
                    zfwMemoryCopy(BufPtr, &(UsbBufPtr[chkIdx+ZM_USB_STREAM_MODE_TAG_LEN]), pktLen);

                    zfwBufSetSize(dev, newBuf, pktLen);
                    rxBufPool[rxBufPoolIndex++] = newBuf;
                }
            }
        }
        else
        {
                u16_t i;

                DbgPrint("Can't find tag, pkt_len: 0x%04x, tag: 0x%04x\n",
                        pktLen, pktTag);

                #if 0
                for(i = 0; i < 32; i++)
                {
                    DbgPrint("%02x ", buf->data[index-16+i]);

                    if ((i & 0xf) == 0xf)
                        DbgPrint("\n");
                }
                #endif

                break;
        }
    }

    /* Free buffer */
    //zfwBufFree(adapter, pUsbRxTransfer->buf, 0);
    zfwBufFree(dev, buf, 0);

    for(ii = 0; ii < rxBufPoolIndex; ii++)
    {
        zfiUsbRecvPerPkt(dev, rxBufPool[ii]);
    }
}
#endif

/************************************************************************/
/*                                                                      */
/*    FUNCTION DESCRIPTION                  zfUsbInit                   */
/*      Initialize USB resource.                                        */
/*                                                                      */
/*    INPUTS                                                            */
/*      dev : device pointer                                            */
/*                                                                      */
/*    OUTPUTS                                                           */
/*      None                                                            */
/*                                                                      */
/*    AUTHOR                                                            */
/*      Stephen Chen        ZyDAS Technology Corporation    2005.12     */
/*                                                                      */
/************************************************************************/
void zfUsbInit(zdev_t* dev)
{
    /* Initialize Rx & INT endpoint for receiving data & interrupt */
    zfwUsbEnableRxEpt(dev, USB_ENDPOINT_RX_INDEX);
    zfwUsbEnableIntEpt(dev, USB_ENDPOINT_INT_INDEX);

    return;
}


/************************************************************************/
/*                                                                      */
/*    FUNCTION DESCRIPTION                  zfUsbFree                   */
/*      Free PCI resource.                                              */
/*                                                                      */
/*    INPUTS                                                            */
/*      dev : device pointer                                            */
/*                                                                      */
/*    OUTPUTS                                                           */
/*      None                                                            */
/*                                                                      */
/*    AUTHOR                                                            */
/*      Stephen Chen        ZyDAS Technology Corporation    2005.12     */
/*                                                                      */
/************************************************************************/
void zfUsbFree(zdev_t* dev)
{
    struct zsHpPriv *halPriv;

    zmw_get_wlan_dev(dev);

    halPriv = (struct zsHpPriv*)wd->hpPrivate;

#ifdef ZM_OTUS_RX_STREAM_MODE
    if ( halPriv->remainBuf != NULL )
    {
        zfwBufFree(dev, halPriv->remainBuf, 0);
    }
#endif

    return;
}

void zfHpSendBeacon(zdev_t* dev, zbuf_t* buf, u16_t len)
{
    u32_t hw, lw;
    u16_t i;
    zmw_get_wlan_dev(dev);

    /* Write to beacon buffer (ZM_BEACON_BUFFER_ADDRESS) */
    for (i = 0; i<len; i+=4)
    {
        lw = zmw_tx_buf_readh(dev, buf, i);
        hw = zmw_tx_buf_readh(dev, buf, i+2);

        zfDelayWriteInternalReg(dev, ZM_BEACON_BUFFER_ADDRESS+i, (hw<<16)+lw);
    }

    /* Beacon PCLP header */
    if (((struct zsHpPriv*)wd->hpPrivate)->hwFrequency < 3000)
    {
    zfDelayWriteInternalReg(dev, ZM_MAC_REG_BCN_PLCP, ((len+4)<<(3+16))+0x0400);
    }
    else
    {
        zfDelayWriteInternalReg(dev, ZM_MAC_REG_BCN_PLCP, ((len+4)<<(16))+0x001b);
    }

    /* Beacon length (include CRC32) */
    zfDelayWriteInternalReg(dev, ZM_MAC_REG_BCN_LENGTH, len+4);

    /* Beacon Ready */
    zfDelayWriteInternalReg(dev, ZM_MAC_REG_BCN_CTRL, 1);
    zfFlushDelayWrite(dev);

    /* Free beacon buf */
    zfwBufFree(dev, buf, 0);

    return;
}


#define ZM_STATUS_TX_COMP       0x00
#define ZM_STATUS_RETRY_COMP    0x01
#define ZM_STATUS_TX_FAILED     0x02
void zfiUsbRegIn(zdev_t* dev, u32_t* rsp, u16_t rspLen)
{
    //u8_t len, type, i;
    u8_t type;
    u8_t *u8rsp;
    u16_t status;
    u32_t bitmap;
    zmw_get_wlan_dev(dev);

    zm_msg0_mm(ZM_LV_3, "zfiUsbRegIn()");

    u8rsp = (u8_t *)rsp;

    //len = *u8rsp;
    type = *(u8rsp+1);
    u8rsp = u8rsp+4;


    /* Interrupt event */
    if ((type & 0xC0) == 0xC0)
    {
        if (type == 0xC0)
        {
            zfCoreEvent(dev, 0, u8rsp);

        }
        else if (type == 0xC1)
        {
#if 0
            {
                u16_t i;
                DbgPrint("rspLen=%d\n", rspLen);
                for (i=0; i<(rspLen/4); i++)
                {
                    DbgPrint("rsp[%d]=0x%lx\n", i, rsp[i]);
                }
            }
#endif
            status = (u16_t)(rsp[3] >> 16);

            ////6789
            rsp[8] = rsp[8] >> 2 | (rsp[9] & 0x1) << 6;
            switch (status)
            {
            case ZM_STATUS_RETRY_COMP :
                zfCoreEvent(dev, 1, u8rsp);
                break;
            case ZM_STATUS_TX_FAILED :
                zfCoreEvent(dev, 2, u8rsp);
                break;
            case ZM_STATUS_TX_COMP :
                zfCoreEvent(dev, 3, u8rsp);
                break;
            }
        }
        else if (type == 0xC2)
        {
            zfBeaconCfgInterrupt(dev, u8rsp);
        }
        else if (type == 0xC3)
        {
            zfEndOfAtimWindowInterrupt(dev);
        }
        else if (type == 0xC4)
        {
#if 0
            {
                u16_t i;
                DbgPrint("0xC2:rspLen=%d\n", rspLen);
                for (i=0; i<(rspLen/4); i++)
                {
                    DbgPrint("0xC2:rsp[%d]=0x%lx\n", i, rsp[i]);
                }
            }
#endif
            bitmap = (rsp[1] >> 16) + ((rsp[2] & 0xFFFF) << 16 );
            //zfBawCore(dev, (u16_t)rsp[1] & 0xFFFF, bitmap, (u16_t)(rsp[2] >> 16) & 0xFF);
        }
        else if (type == 0xC5)
        {
            u16_t i;
#if 0

            for (i=0; i<(rspLen/4); i++) {
                DbgPrint("0xC5:rsp[%d]=0x%lx\n", i, rsp[i]);
            }
#endif
            for (i=1; i<(rspLen/4); i++) {
                u8rsp = (u8_t *)(rsp+i);
                //DbgPrint("0xC5:rsp[%d]=0x%lx\n", i, ((u32_t*)u8rsp)[0]);
                zfCoreEvent(dev, 4, u8rsp);
            }
        }
        else if (type == 0xC6)
        {
            zm_debug_msg0("\n\n WatchDog interrupt!!! : 0xC6 \n\n");
            if (wd->zfcbHwWatchDogNotify != NULL)
            {
                wd->zfcbHwWatchDogNotify(dev);
            }
        }
        else if (type == 0xC8)
        {
            //PZSW_ADAPTER adapter;

            // for SPI flash program chk Flag
            zfwDbgProgrameFlashChkDone(dev);
        }
        else if (type == 0xC9)
        {
            struct zsHpPriv* hpPriv=wd->hpPrivate;

            zm_debug_msg0("##### Tx retransmission 5 times event #####");

            /* correct tx retransmission issue */
            hpPriv->retransmissionEvent = 1;
        }
    }
    else
    {
        zfIdlRsp(dev, rsp, rspLen);
    }
}


#define ZM_PROGRAM_RAM_ADDR     0x200000 //0x1000 //0x700000
#define FIRMWARE_DOWNLOAD       0x30
#define FIRMWARE_DOWNLOAD_COMP  0x31
#define FIRMWARE_CONFIRM        0x32

u16_t zfFirmwareDownload(zdev_t* dev, u32_t* fw, u32_t len, u32_t offset)
{
    u16_t ret = ZM_SUCCESS;
    u32_t uCodeOfst = offset;
    u8_t *image, *ptr;
    u32_t result;

    image = (u8_t*) fw;
    ptr = image;

    while (len > 0)
    {
        u32_t translen = (len > 4096) ? 4096 : len;

        result = zfwUsbSubmitControl(dev, FIRMWARE_DOWNLOAD,
                                     (u16_t) (uCodeOfst >> 8),
                                     0, image, translen);

        if (result != ZM_SUCCESS)
        {
            zm_msg0_init(ZM_LV_0, "FIRMWARE_DOWNLOAD failed");
            ret = 1;
            goto exit;
        }

        len -= translen;
        image += translen;
        uCodeOfst += translen; // in Word (16 bit)

        result = 0;
    }

    /* If download firmware success, issue a command to firmware */
    if (ret == 0)
    {
        result = zfwUsbSubmitControl(dev, FIRMWARE_DOWNLOAD_COMP,
                                     0, 0, NULL, 0);

        if (result != ZM_SUCCESS)
        {
            zm_msg0_init(ZM_LV_0, "FIRMWARE_DOWNLOAD_COMP failed");
            ret = 1;
            goto exit;
        }
    }

#if 0
    /* PCI code */
    /* Wait for firmware ready */
    result = zfwUsbSubmitControl(dev, FIRMWARE_CONFIRM, USB_DIR_IN | 0x40,
                     0, 0, &ret_value, sizeof(ret_value), HZ);

    if (result != 0)
    {
        zm_msg0_init(ZM_LV_0, "Can't receive firmware ready: ", result);
        ret = 1;
    }
#endif

exit:

    return ret;

}

u16_t zfFirmwareDownloadNotJump(zdev_t* dev, u32_t* fw, u32_t len, u32_t offset)
{
    u16_t ret = ZM_SUCCESS;
    u32_t uCodeOfst = offset;
    u8_t *image, *ptr;
    u32_t result;

    image = (u8_t*) fw;
    ptr = image;

    while (len > 0)
    {
        u32_t translen = (len > 4096) ? 4096 : len;

        result = zfwUsbSubmitControl(dev, FIRMWARE_DOWNLOAD,
                                     (u16_t) (uCodeOfst >> 8),
                                     0, image, translen);

        if (result != ZM_SUCCESS)
        {
            zm_msg0_init(ZM_LV_0, "FIRMWARE_DOWNLOAD failed");
            ret = 1;
            goto exit;
        }

        len -= translen;
        image += translen;
        uCodeOfst += translen; // in Word (16 bit)

        result = 0;
    }

exit:

    return ret;

}

/************************************************************************/
/*                                                                      */
/*    FUNCTION DESCRIPTION                  zfIdlGetFreeTxdCount        */
/*      Get free PCI PCI TxD count.                                     */
/*                                                                      */
/*    INPUTS                                                            */
/*      dev : device pointer                                            */
/*                                                                      */
/*    OUTPUTS                                                           */
/*      None                                                            */
/*                                                                      */
/*    AUTHOR                                                            */
/*      Stephen             ZyDAS Technology Corporation    2006.6      */
/*                                                                      */
/************************************************************************/
u32_t zfHpGetFreeTxdCount(zdev_t* dev)
{
    return zfwUsbGetFreeTxQSize(dev);
}

u32_t zfHpGetMaxTxdCount(zdev_t* dev)
{
    //return 8;
    return zfwUsbGetMaxTxQSize(dev);
}

void zfiUsbRegOutComplete(zdev_t* dev)
{
    return;
}

extern void zfPushVtxq(zdev_t* dev);

void zfiUsbOutComplete(zdev_t* dev, zbuf_t *buf, u8_t status, u8_t *hdr) {
#ifndef ZM_ENABLE_AGGREGATION
    if (buf) {
        zfwBufFree(dev, buf, 0);
    }
#else
    #ifdef ZM_BYPASS_AGGR_SCHEDULING
    //Simply free the buf since BA retransmission is done in the firmware
    if (buf)
    {
        zfwBufFree(dev, buf, 0);
    }
    zfPushVtxq(dev);
    #else
    zmw_get_wlan_dev(dev);

    #ifdef ZM_ENABLE_FW_BA_RETRANSMISSION
    //Simply free the buf since BA retransmission is done in the firmware
    if (buf)
    {
        zfwBufFree(dev, buf, 0);
    }
    #else
    u8_t agg;
    u16_t frameType;

    if(!hdr && buf) {
        zfwBufFree(dev, buf, 0);
        //zm_debug_msg0("buf Free due to hdr == NULL");
        return;
    }

    if(hdr && buf) {
        frameType = hdr[8] & 0xf;
        agg = (u8_t)(hdr[2] >> 5 ) & 0x1;
        //zm_debug_msg1("AGG=", agg);

        if (!status) {
            if (agg) {
                //delete buf in ba fail queue??
                //not ganna happen?
            }
            else {
                zfwBufFree(dev, buf, 0);
            }
        }
        else {
            if (agg) {
                //don't do anything
                //zfwBufFree(dev, buf, 0);
            }
            else {
                zfwBufFree(dev, buf, 0);
            }
        }
    }
    #endif

    if (wd->state != ZM_WLAN_STATE_ENABLED) {
        return;
    }

    if( (wd->wlanMode == ZM_MODE_AP) ||
        (wd->wlanMode == ZM_MODE_INFRASTRUCTURE && wd->sta.EnableHT) ||
        (wd->wlanMode == ZM_MODE_PSEUDO) ) {
        zfAggTxScheduler(dev, 0);
    }
    #endif
#endif

    return;

}