/*
 * 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 : cmd.c                                                 */
/*                                                                      */
/*  Abstract                                                            */
/*      This module contains command interface functions.               */
/*                                                                      */
/*  NOTES                                                               */
/*      None                                                            */
/*                                                                      */
/************************************************************************/
#include "cprecomp.h"
#include "../hal/hpreg.h"


u16_t zfWlanReset(zdev_t* dev);
u32_t zfUpdateRxRate(zdev_t* dev);


extern void zfiUsbRecv(zdev_t *dev, zbuf_t *buf);
extern void zfiUsbRegIn(zdev_t* dev, u32_t* rsp, u16_t rspLen);
extern void zfiUsbOutComplete(zdev_t* dev, zbuf_t *buf, u8_t status, u8_t *hdr);
extern void zfiUsbRegOutComplete(zdev_t* dev);
extern u16_t zfHpReinit(zdev_t* dev, u32_t frequency);

/* Get size (byte) of driver core global data structure.    */
/* This size will be used by driver wrapper to allocate     */
/* a memory space for driver core to store global variables */
u16_t zfiGlobalDataSize(zdev_t* dev)
{
    u32_t ret;
    ret = (sizeof(struct zsWlanDev));
    zm_assert((ret>>16) == 0);
    return (u16_t)ret;
}


/* Initialize WLAN hardware and software, resource will be allocated */
/* for WLAN operation, must be called first before other function.   */
extern u16_t zfiWlanOpen(zdev_t* dev, struct zsCbFuncTbl* cbFuncTbl)
{
    //u16_t ret;
    //u32_t i;
    //u8_t* ch;
    //u8_t  bPassive;
    u32_t devSize;
    struct zfCbUsbFuncTbl cbUsbFuncTbl;
    zmw_get_wlan_dev(dev);

    zm_debug_msg0("start");

    devSize = sizeof(struct zsWlanDev);
    /* Zeroize zsWlanDev struct */
    zfZeroMemory((u8_t*)wd, (u16_t)devSize);

#ifdef ZM_ENABLE_AGGREGATION
    zfAggInit(dev);
#endif

    zfCwmInit(dev);

    wd->commTally.RateCtrlTxMPDU = 0;
    wd->commTally.RateCtrlBAFail = 0;
    wd->preambleTypeInUsed = ZM_PREAMBLE_TYPE_SHORT;

    if (cbFuncTbl == NULL)
    {
        /* zfcbRecvEth() is mandatory */
        zm_assert(0);
    }
    else
    {
        if (cbFuncTbl->zfcbRecvEth == NULL)
        {
            /* zfcbRecvEth() is mandatory */
            zm_assert(0);
        }
        wd->zfcbAuthNotify = cbFuncTbl->zfcbAuthNotify;
        wd->zfcbAuthNotify = cbFuncTbl->zfcbAuthNotify;
        wd->zfcbAsocNotify = cbFuncTbl->zfcbAsocNotify;
        wd->zfcbDisAsocNotify = cbFuncTbl->zfcbDisAsocNotify;
        wd->zfcbApConnectNotify = cbFuncTbl->zfcbApConnectNotify;
        wd->zfcbConnectNotify = cbFuncTbl->zfcbConnectNotify;
        wd->zfcbScanNotify = cbFuncTbl->zfcbScanNotify;
        wd->zfcbMicFailureNotify = cbFuncTbl->zfcbMicFailureNotify;
        wd->zfcbApMicFailureNotify = cbFuncTbl->zfcbApMicFailureNotify;
        wd->zfcbIbssPartnerNotify = cbFuncTbl->zfcbIbssPartnerNotify;
        wd->zfcbMacAddressNotify = cbFuncTbl->zfcbMacAddressNotify;
        wd->zfcbSendCompleteIndication = cbFuncTbl->zfcbSendCompleteIndication;
        wd->zfcbRecvEth = cbFuncTbl->zfcbRecvEth;
        wd->zfcbRestoreBufData = cbFuncTbl->zfcbRestoreBufData;
        wd->zfcbRecv80211 = cbFuncTbl->zfcbRecv80211;
#ifdef ZM_ENABLE_CENC
        wd->zfcbCencAsocNotify = cbFuncTbl->zfcbCencAsocNotify;
#endif //ZM_ENABLE_CENC
        wd->zfcbClassifyTxPacket = cbFuncTbl->zfcbClassifyTxPacket;
        wd->zfcbHwWatchDogNotify = cbFuncTbl->zfcbHwWatchDogNotify;
    }

    //add by honda 0330
    cbUsbFuncTbl.zfcbUsbRecv = zfiUsbRecv;
    cbUsbFuncTbl.zfcbUsbRegIn = zfiUsbRegIn;
    cbUsbFuncTbl.zfcbUsbOutComplete = zfiUsbOutComplete;
    cbUsbFuncTbl.zfcbUsbRegOutComplete = zfiUsbRegOutComplete;
    zfwUsbRegisterCallBack(dev, &cbUsbFuncTbl);
    /* Init OWN MAC address */
    wd->macAddr[0] = 0x8000;
    wd->macAddr[1] = 0x0000;
    wd->macAddr[2] = 0x0000;

    wd->regulationTable.regionCode = 0xffff;

    zfHpInit(dev, wd->frequency);

    /* init region code */
    //wd->regulationTable.regionCode = NULL1_WORLD; //Only 2.4g RegCode
    //zfHpGetRegulationTablefromRegionCode(dev, NULL1_WORLD);
    //zfiWlanSetDot11DMode(dev , 1); // Enable 802.11d
    /* Get the first channel */
    //wd->frequency = zfChGetFirstChannel(dev, &bPassive);
#ifdef ZM_AP_DEBUG
    //wd->frequency = 2437;
#endif

    //STA mode
    wd->sta.mTxRate = 0x0;
    wd->sta.uTxRate = 0x3;
    wd->sta.mmTxRate = 0x0;
    wd->sta.adapterState = ZM_STA_STATE_DISCONNECT;
    wd->sta.capability[0] = 0x01;
    wd->sta.capability[1] = 0x00;

    wd->sta.preambleTypeHT = 0;
    wd->sta.htCtrlBandwidth = 0;
    wd->sta.htCtrlSTBC = 0;
    wd->sta.htCtrlSG = 0;
    wd->sta.defaultTA = 0;
    //wd->sta.activescanTickPerChannel = ZM_TIME_ACTIVE_SCAN/ZM_MS_PER_TICK;
	{
		u8_t Dur = ZM_TIME_ACTIVE_SCAN;
		zfwGetActiveScanDur(dev, &Dur);
		wd->sta.activescanTickPerChannel = Dur/ZM_MS_PER_TICK;

	}
    wd->sta.passiveScanTickPerChannel = ZM_TIME_PASSIVE_SCAN/ZM_MS_PER_TICK;
    wd->sta.bAutoReconnect = TRUE;
    wd->sta.dropUnencryptedPkts = FALSE;

    /* set default to bypass all multicast packet for linux, window XP would set 0 by wrapper initialization */
	wd->sta.bAllMulticast = 1;

    /* Initial the RIFS Status / RIFS-like frame count / RIFS count */
    wd->sta.rifsState = ZM_RIFS_STATE_DETECTING;
    wd->sta.rifsLikeFrameCnt = 0;
    wd->sta.rifsCount = 0;

    wd->sta.osRxFilter = 0;
    wd->sta.bSafeMode = 0;

    //Common
    zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_DISCONNECT);
    wd->beaconInterval = 100;
    wd->rtsThreshold = 2346;
    wd->fragThreshold = 32767;
    wd->wlanMode = ZM_MODE_INFRASTRUCTURE;
    wd->txMCS = 0xff;    //AUTO
    wd->dtim = 1;
    //wd->txMT = 1;       //OFDM
    wd->tick = 1;
    wd->maxTxPower2 = 0xff;
    wd->maxTxPower5 = 0xff;
    wd->supportMode = 0xffffffff;
    wd->ws.adhocMode = ZM_ADHOCBAND_G;
    wd->ws.autoSetFrequency = 0xff;

    //AP mode
    //wd->bgMode = wd->ws.bgMode;
    wd->ap.ssidLen[0] = 6;
    wd->ap.ssid[0][0] = 'Z';
    wd->ap.ssid[0][1] = 'D';
    wd->ap.ssid[0][2] = '1';
    wd->ap.ssid[0][3] = '2';
    wd->ap.ssid[0][4] = '2';
    wd->ap.ssid[0][5] = '1';

    // Init the country iso name as NA
    wd->ws.countryIsoName[0] = 0;
    wd->ws.countryIsoName[1] = 0;
    wd->ws.countryIsoName[2] = '\0';

	/* init fragmentation is disabled */
	//zfiWlanSetFragThreshold(dev, 0);

	/* airopeek : swSniffer 1=>on  0=>off */
	wd->swSniffer = 0;
    wd->XLinkMode = 0;

// jhlee HT 0
#if 1
    /* AP Mode*/
    /* Init HT Capability Info */
    wd->ap.HTCap.Data.ElementID = ZM_WLAN_EID_HT_CAPABILITY;
    wd->ap.HTCap.Data.Length = 26;
    //wd->ap.HTCap.Data.SupChannelWidthSet = 0;
    //wd->ap.HTCap.Data.MIMOPowerSave = 3;
    //wd->ap.HTCap.Data.ShortGIfor40MHz = 0;
    //wd->ap.HTCap.Data.ShortGIfor20MHz = 0;
    //wd->ap.HTCap.Data.DSSSandCCKin40MHz = 0;
    wd->ap.HTCap.Data.AMPDUParam |= HTCAP_MaxRxAMPDU3;
    wd->ap.HTCap.Data.MCSSet[0] = 0xFF; // MCS 0 ~  7
    wd->ap.HTCap.Data.MCSSet[1] = 0xFF; // MCS 8 ~ 15

    /* Init Extended HT Capability Info */
    wd->ap.ExtHTCap.Data.ElementID = ZM_WLAN_EID_EXTENDED_HT_CAPABILITY;
    wd->ap.ExtHTCap.Data.Length = 22;
    wd->ap.ExtHTCap.Data.ControlChannel = 6;
    //wd->ap.ExtHTCap.Data.ExtChannelOffset = 3;
    wd->ap.ExtHTCap.Data.ChannelInfo |= ExtHtCap_RecomTxWidthSet;
    //wd->ap.ExtHTCap.Data.RIFSMode = 1;
    wd->ap.ExtHTCap.Data.OperatingInfo |= 1;

    /* STA Mode*/
    /* Init HT Capability Info */
    wd->sta.HTCap.Data.ElementID = ZM_WLAN_EID_HT_CAPABILITY;
    wd->sta.HTCap.Data.Length = 26;

    /* Test with 5G-AP : 7603 */
    //wd->sta.HTCap.Data.SupChannelWidthSet = 1;
    wd->sta.HTCap.Data.HtCapInfo |= HTCAP_SMEnabled;
    wd->sta.HTCap.Data.HtCapInfo |= HTCAP_SupChannelWidthSet;
    wd->sta.HTCap.Data.HtCapInfo |= HTCAP_ShortGIfor40MHz;
    wd->sta.HTCap.Data.HtCapInfo |= HTCAP_DSSSandCCKin40MHz;
#ifndef ZM_DISABLE_AMSDU8K_SUPPORT
    wd->sta.HTCap.Data.HtCapInfo |= HTCAP_MaxAMSDULength;
#endif
    //wd->sta.HTCap.Data.MIMOPowerSave = 0;
    //wd->sta.HTCap.Data.ShortGIfor40MHz = 0;
    //wd->sta.HTCap.Data.ShortGIfor20MHz = 0;
    //wd->sta.HTCap.Data.DSSSandCCKin40MHz = 0;
    wd->sta.HTCap.Data.AMPDUParam |= HTCAP_MaxRxAMPDU3;
    wd->sta.HTCap.Data.MCSSet[0] = 0xFF; // MCS 0 ~  7
    wd->sta.HTCap.Data.MCSSet[1] = 0xFF; // MCS 8 ~ 15
    wd->sta.HTCap.Data.PCO |= HTCAP_TransmissionTime3;
    //wd->sta.HTCap.Data.TransmissionTime = 0;
    /* Init Extended HT Capability Info */
    wd->sta.ExtHTCap.Data.ElementID = ZM_WLAN_EID_EXTENDED_HT_CAPABILITY;
    wd->sta.ExtHTCap.Data.Length = 22;
    wd->sta.ExtHTCap.Data.ControlChannel = 6;

    //wd->sta.ExtHTCap.Data.ExtChannelOffset |= 3;
    wd->sta.ExtHTCap.Data.ChannelInfo |= ExtHtCap_ExtChannelOffsetBelow;

    //wd->sta.ExtHTCap.Data.RecomTxWidthSet = 1;
    //wd->sta.ExtHTCap.Data.RIFSMode = 1;
    wd->sta.ExtHTCap.Data.OperatingInfo |= 1;
#endif

#if 0
    /* WME test code */
    wd->ap.qosMode[0] = 1;
#endif

    wd->ledStruct.ledMode[0] = 0x2221;
    wd->ledStruct.ledMode[1] = 0x2221;

    zfTimerInit(dev);

    ZM_PERFORMANCE_INIT(dev);

    zfBssInfoCreate(dev);
    zfScanMgrInit(dev);
    zfPowerSavingMgrInit(dev);

#if 0
    /* Test code */
    {
        u32_t key[4] = {0xffffffff, 0xff, 0, 0};
        u16_t addr[3] = {0x8000, 0x01ab, 0x0000};
        //zfSetKey(dev, 0, 0, ZM_WEP64, addr, key);
        //zfSetKey(dev, 0, 0, ZM_AES, addr, key);
        //zfSetKey(dev, 64, 0, 1, wd->macAddr, key);
    }
#endif

    // WME settings
    wd->ws.staWmeEnabled = 1;           // Enable WME by default
    #define ZM_UAPSD_Q_SIZE 32 //2^N
    wd->ap.uapsdQ = zfQueueCreate(dev, ZM_UAPSD_Q_SIZE);
    zm_assert(wd->ap.uapsdQ != NULL);
    wd->sta.uapsdQ = zfQueueCreate(dev, ZM_UAPSD_Q_SIZE);
    zm_assert(wd->sta.uapsdQ != NULL);

    //zfHpInit(dev, wd->frequency);

    /* MAC address */
    //zfHpSetMacAddress(dev, wd->macAddr, 0);
    zfHpGetMacAddress(dev);

    zfCoreSetFrequency(dev, wd->frequency);

#if ZM_PCI_LOOP_BACK == 1
    zfwWriteReg(dev, ZM_REG_PCI_CONTROL, 6);
#endif /* #if ZM_PCI_LOOP_BACK == 1 */

    //zfiWlanSetDot11DMode(dev , 1); // Enable 802.11d
    //zfiWlanSetDot11HDFSMode(dev , 1); // Enable 802.11h DFS
    wd->sta.DFSEnable = 1;
    wd->sta.capability[1] |= ZM_BIT_0;

    //zfiWlanSetFrequency(dev, 5260000, TRUE);
    //zfiWlanSetAniMode(dev , 1); // Enable ANI

    /* Trgger Rx DMA */
    zfHpStartRecv(dev);

    zm_debug_msg0("end");

    return 0;
}

/* WLAN hardware will be shutdown and all resource will be release */
u16_t zfiWlanClose(zdev_t* dev)
{
    zmw_get_wlan_dev(dev);

    zm_msg0_init(ZM_LV_0, "enter");

    wd->state = ZM_WLAN_STATE_CLOSEDED;

    //zfiWlanDisable(dev, 1);
    zfWlanReset(dev);

    zfHpStopRecv(dev);

    /* Disable MAC */
    /* Disable PHY */
    /* Disable RF */

    zfHpRelease(dev);

    zfQueueDestroy(dev, wd->ap.uapsdQ);
    zfQueueDestroy(dev, wd->sta.uapsdQ);

    zfBssInfoDestroy(dev);

#ifdef ZM_ENABLE_AGGREGATION
    /* add by honda */
    zfAggRxFreeBuf(dev, 1);  //1 for release structure memory
    /* end of add by honda */
#endif

    zm_msg0_init(ZM_LV_0, "exit");

    return 0;
}

void zfGetWrapperSetting(zdev_t* dev)
{
    u8_t   bPassive;
    u16_t vapId = 0;

    zmw_get_wlan_dev(dev);

    zmw_declare_for_critical_section();
#if 0
    if ( (wd->ws.countryIsoName[0] != 0)
         || (wd->ws.countryIsoName[1] != 0)
         || (wd->ws.countryIsoName[2] != '\0') )
    {
        zfHpGetRegulationTablefromRegionCode(
            dev,
            zfHpGetRegionCodeFromIsoName(dev, wd->ws.countryIsoName) );
    }
#endif
    zmw_enter_critical_section(dev);

    wd->wlanMode = wd->ws.wlanMode;

    /* set channel */
    if ( wd->ws.frequency )
    {
        wd->frequency = wd->ws.frequency;
        wd->ws.frequency = 0;
    }
    else
    {
        wd->frequency = zfChGetFirstChannel(dev, &bPassive);

        if ( wd->wlanMode == ZM_MODE_IBSS )
        {
            if (wd->ws.adhocMode == ZM_ADHOCBAND_A)
            {
                wd->frequency = ZM_CH_A_36;
            }
            else
            {
            wd->frequency = ZM_CH_G_6;
            }
        }
    }
#ifdef ZM_AP_DEBUG
    /* honda add for debug, 2437 channel 6, 2452 channel 9 */
    wd->frequency = 2437;
    /* end of add by honda */
#endif

    /* set preamble type */
    switch (wd->ws.preambleType)
    {
    case ZM_PREAMBLE_TYPE_AUTO:
    case ZM_PREAMBLE_TYPE_SHORT:
    case ZM_PREAMBLE_TYPE_LONG:
        wd->preambleType = wd->ws.preambleType;
        break;
    default:
        wd->preambleType = ZM_PREAMBLE_TYPE_SHORT;
        break;
    }
    wd->ws.preambleType = 0;

    if ( wd->wlanMode == ZM_MODE_AP )
    {
        vapId = zfwGetVapId(dev);

        if (vapId == 0xffff)
        {
            wd->ap.authAlgo[0] = wd->ws.authMode;
            wd->ap.encryMode[0] = wd->ws.encryMode;
        }
        else
        {
            wd->ap.authAlgo[vapId + 1] = wd->ws.authMode;
            wd->ap.encryMode[vapId + 1] = wd->ws.encryMode;
        }
        wd->ws.authMode = 0;
        wd->ws.encryMode = ZM_NO_WEP;

        /* Get beaconInterval from WrapperSetting */
        if ((wd->ws.beaconInterval >= 20) && (wd->ws.beaconInterval <= 1000))
        {
            wd->beaconInterval = wd->ws.beaconInterval;
        }
        else
        {
            wd->beaconInterval = 100; //100ms
        }

        if (wd->ws.dtim > 0)
        {
            wd->dtim = wd->ws.dtim;
        }
        else
        {
            wd->dtim = 1;
        }

        wd->ap.qosMode = wd->ws.apWmeEnabled & 0x1;
        wd->ap.uapsdEnabled = (wd->ws.apWmeEnabled & 0x2) >> 1;
    }
    else
    {
        wd->sta.authMode = wd->ws.authMode;
        wd->sta.currentAuthMode = wd->ws.authMode;
        wd->sta.wepStatus = wd->ws.wepStatus;

        if ( wd->ws.beaconInterval )
        {
            wd->beaconInterval = wd->ws.beaconInterval;
        }
        else
        {
            wd->beaconInterval = 0x64;
        }

        if ( wd->wlanMode == ZM_MODE_IBSS )
        {
            /* 1. Set default channel 6 (2437MHz) */
//            wd->frequency = 2437;

            /* 2. Otus support 802.11g Mode */
            if ((wd->ws.adhocMode == ZM_ADHOCBAND_G) ||
                (wd->ws.adhocMode == ZM_ADHOCBAND_BG) ||
                (wd->ws.adhocMode == ZM_ADHOCBAND_ABG) ) {
                wd->wfc.bIbssGMode = 1;
            } else {
                wd->wfc.bIbssGMode = 0;
            }

            /* 3. set short preamble  */
            //wd->sta.preambleType = ZM_PREAMBLE_TYPE_SHORT ;
        }

        /* set ATIM window */
        if ( wd->ws.atimWindow )
        {
            wd->sta.atimWindow = wd->ws.atimWindow;
        }
        else
        {
            //wd->sta.atimWindow = 0x0a;
            wd->sta.atimWindow = 0;
        }

        //wd->sta.connectingHiddenAP = 1;//wd->ws.connectingHiddenAP;
        wd->sta.dropUnencryptedPkts = wd->ws.dropUnencryptedPkts;
        wd->sta.ibssJoinOnly = wd->ws.ibssJoinOnly;

        if ( wd->ws.bDesiredBssid )
        {
            zfMemoryCopy(wd->sta.desiredBssid, wd->ws.desiredBssid, 6);
            wd->sta.bDesiredBssid = TRUE;
            wd->ws.bDesiredBssid = FALSE;
        }
        else
        {
            wd->sta.bDesiredBssid = FALSE;
        }

        /* check ssid */
        if ( wd->ws.ssidLen != 0 )
        {
            if ( (!zfMemoryIsEqual(wd->ws.ssid, wd->sta.ssid,
                                   wd->sta.ssidLen))||
                 (wd->ws.ssidLen != wd->sta.ssidLen)||
                 (wd->sta.authMode == ZM_AUTH_MODE_WPA)||
                 (wd->sta.authMode == ZM_AUTH_MODE_WPAPSK) ||
                 (wd->ws.staWmeQosInfo!= 0) )
            {
                /*if u-APSD test(set QosInfo), clear connectByReasso to do association (not reassociation)*/
                wd->sta.connectByReasso = FALSE;
                wd->sta.failCntOfReasso = 0;
                wd->sta.pmkidInfo.bssidCount = 0;

                wd->sta.ssidLen = wd->ws.ssidLen;
                zfMemoryCopy(wd->sta.ssid, wd->ws.ssid, wd->sta.ssidLen);

                if ( wd->sta.ssidLen < 32 )
                {
                    wd->sta.ssid[wd->sta.ssidLen] = 0;
                }
            }
        }
        else
        {   /* ANY BSS */
            wd->sta.ssid[0] = 0;
            wd->sta.ssidLen = 0;
        }

        wd->sta.wmeEnabled = wd->ws.staWmeEnabled;
        wd->sta.wmeQosInfo = wd->ws.staWmeQosInfo;

    }

    zmw_leave_critical_section(dev);
}

u16_t zfWlanEnable(zdev_t* dev)
{
    u8_t     bssid[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
    u16_t i;

    zmw_get_wlan_dev(dev);

    zmw_declare_for_critical_section();

    if ( wd->wlanMode == ZM_MODE_UNKNOWN )
    {
        zm_debug_msg0("Unknown Mode...Skip...");
        return 0;
    }

    if (wd->wlanMode == ZM_MODE_AP)
    {
        u16_t vapId;

        vapId = zfwGetVapId(dev);

        if (vapId == 0xffff)
        {
            /* AP mode */
            zfApInitStaTbl(dev);

            /* AP default parameters */
            wd->bRate = 0xf;
            wd->gRate = 0xff;
            wd->bRateBasic = 0xf;
            wd->gRateBasic = 0x0;
            //wd->beaconInterval = 100;
            wd->ap.apBitmap = 1;
            wd->ap.beaconCounter = 0;
            //wd->ap.vapNumber = 1;    //mark by ygwei for Vap

            wd->ap.hideSsid[0] = 0;
            wd->ap.staAgingTimeSec = 10*60;
            wd->ap.staProbingTimeSec = 60;

            for (i=0; i<ZM_MAX_AP_SUPPORT; i++)
            {
                wd->ap.bcmcHead[i] = wd->ap.bcmcTail[i] = 0;
            }

            //wd->ap.uniHead = wd->ap.uniTail = 0;

            /* load AP parameters */
            wd->bRateBasic = wd->ws.bRateBasic;
            wd->gRateBasic = wd->ws.gRateBasic;
            wd->bgMode = wd->ws.bgMode;
            if ((wd->ws.ssidLen <= 32) && (wd->ws.ssidLen != 0))
            {
                wd->ap.ssidLen[0] = wd->ws.ssidLen;
                for(i=0; i<wd->ws.ssidLen; i++)
                {
                    wd->ap.ssid[0][i] = wd->ws.ssid[i];
                }
                wd->ws.ssidLen = 0; // Reset Wrapper Variable
            }

            if (wd->ap.encryMode[0] == 0)
            {
                wd->ap.capab[0] = 0x001;
            }
            else
            {
                wd->ap.capab[0] = 0x011;
            }
            /* set Short Slot Time bit if not 11b */
            if (wd->ap.wlanType[0] != ZM_WLAN_TYPE_PURE_B)
            {
              wd->ap.capab[0] |= 0x400;
            }

            // wd->ap.vapNumber = 1;    // mark by ygwei for Vap Test
        }
        else
        {
#if 0
            /* VAP Test Code */
            wd->ap.apBitmap = 0x3;
            wd->ap.capab[1] = 0x401;
            wd->ap.ssidLen[1] = 4;
            wd->ap.ssid[1][0] = 'v';
            wd->ap.ssid[1][1] = 'a';
            wd->ap.ssid[1][2] = 'p';
            wd->ap.ssid[1][3] = '1';
            wd->ap.authAlgo[1] = wd->ws.authMode;
            wd->ap.encryMode[1] = wd->ws.encryMode;
            wd->ap.vapNumber = 2;
#else
            /* VAP Test Code */
            wd->ap.apBitmap = 0x1 | (0x01 << (vapId+1));

            if ((wd->ws.ssidLen <= 32) && (wd->ws.ssidLen != 0))
            {
                wd->ap.ssidLen[vapId+1] = wd->ws.ssidLen;
                for(i=0; i<wd->ws.ssidLen; i++)
                {
                    wd->ap.ssid[vapId+1][i] = wd->ws.ssid[i];
                }
                wd->ws.ssidLen = 0; // Reset Wrapper Variable
            }

            if (wd->ap.encryMode[vapId+1] == 0)
            {
                wd->ap.capab[vapId+1] = 0x401;
            }
            else
            {
                wd->ap.capab[vapId+1] = 0x411;
            }

            wd->ap.authAlgo[vapId+1] = wd->ws.authMode;
            wd->ap.encryMode[vapId+1] = wd->ws.encryMode;

            /* Need to be modified when VAP is used */
            //wd->ap.vapNumber = 2;
#endif
        }

        wd->ap.vapNumber++;

        zfCoreSetFrequency(dev, wd->frequency);

        zfInitMacApMode(dev);

        /* Disable protection mode */
        zfApSetProtectionMode(dev, 0);

        zfApSendBeacon(dev);
    } /*if (wd->wlanMode == ZM_MODE_AP) */
    else
    {
        zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_INTERNAL);
        zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_EXTERNAL);

        zmw_enter_critical_section(dev);
        wd->sta.oppositeCount = 0;    /* reset opposite count */
        //wd->sta.bAutoReconnect = wd->sta.bAutoReconnectEnabled;
        //wd->sta.scanWithSSID = 0;
        zfStaInitOppositeInfo(dev);
        zmw_leave_critical_section(dev);

        zfStaResetStatus(dev, 0);

        if ( (wd->sta.cmDisallowSsidLength != 0)&&
             (wd->sta.ssidLen == wd->sta.cmDisallowSsidLength)&&
             (zfMemoryIsEqual(wd->sta.ssid, wd->sta.cmDisallowSsid,
                              wd->sta.ssidLen)) &&
             (wd->sta.wepStatus == ZM_ENCRYPTION_TKIP))
        {   /* countermeasures */
            zm_debug_msg0("countermeasures disallow association");

        }
        else
        {
            switch( wd->wlanMode )
            {
                case ZM_MODE_IBSS:
                    /* some registers may be set here */
                    if ( wd->sta.authMode == ZM_AUTH_MODE_WPA2PSK )
                    {
                        zfHpSetApStaMode(dev, ZM_HAL_80211_MODE_IBSS_WPA2PSK);
                    }
                    else
                    {
                        zfHpSetApStaMode(dev, ZM_HAL_80211_MODE_IBSS_GENERAL);
                    }

                    zm_msg0_mm(ZM_LV_0, "ZM_MODE_IBSS");
                    zfIbssConnectNetwork(dev);
                    break;

                case ZM_MODE_INFRASTRUCTURE:
                    /* some registers may be set here */
                    zfHpSetApStaMode(dev, ZM_HAL_80211_MODE_STA);

                    zfInfraConnectNetwork(dev);
                    break;

                case ZM_MODE_PSEUDO:
                    /* some registers may be set here */
                    zfHpSetApStaMode(dev, ZM_HAL_80211_MODE_STA);

                    zfUpdateBssid(dev, bssid);
                    zfCoreSetFrequency(dev, wd->frequency);
                    break;

                default:
                    break;
            }
        }

    }


    //if ( (wd->wlanMode != ZM_MODE_INFRASTRUCTURE)&&
    //     (wd->wlanMode != ZM_MODE_AP) )
    if ( wd->wlanMode == ZM_MODE_PSEUDO )
    {
        /* Reset Wlan status */
        zfWlanReset(dev);

        if (wd->zfcbConnectNotify != NULL)
        {
            wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECT, wd->sta.bssid);
        }
        zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTED);
    }


    if(wd->wlanMode == ZM_MODE_AP)
    {
        if (wd->zfcbConnectNotify != NULL)
        {
            wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECT, wd->sta.bssid);
        }
        //zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTED);
    }

    // Assign default Tx Rate
    if ( wd->sta.EnableHT )
    {
		u32_t oneTxStreamCap;
		oneTxStreamCap = (zfHpCapability(dev) & ZM_HP_CAP_11N_ONE_TX_STREAM);
		if(oneTxStreamCap)
			wd->CurrentTxRateKbps = 135000;
		else
			wd->CurrentTxRateKbps = 270000;
        wd->CurrentRxRateKbps = 270000;
    }
    else
    {
        wd->CurrentTxRateKbps = 54000;
        wd->CurrentRxRateKbps = 54000;
    }

    wd->state = ZM_WLAN_STATE_ENABLED;

    return 0;
}

/* Enable/disable Wlan operation */
u16_t zfiWlanEnable(zdev_t* dev)
{
    u16_t ret;

    zmw_get_wlan_dev(dev);

    zm_msg0_mm(ZM_LV_1, "Enable Wlan");

    zfGetWrapperSetting(dev);

    zfZeroMemory((u8_t*) &wd->trafTally, sizeof(struct zsTrafTally));

    // Reset cmMicFailureCount to 0 for new association request
    if ( wd->sta.cmMicFailureCount == 1 )
    {
        zfTimerCancel(dev, ZM_EVENT_CM_TIMER);
        wd->sta.cmMicFailureCount = 0;
    }

    zfFlushVtxq(dev);
    if ((wd->queueFlushed & 0x10) != 0)
    {
        zfHpUsbReset(dev);
    }
    ret = zfWlanEnable(dev);

    return ret;
}
/* Add a flag named ResetKeyCache to show if KeyCache should be cleared.
   for hostapd in AP mode, if driver receives iwconfig ioctl
   after setting group key, it shouldn't clear KeyCache.                 */
u16_t zfiWlanDisable(zdev_t* dev, u8_t ResetKeyCache)
{
    u16_t  i;
    u8_t isConnected;

    zmw_get_wlan_dev(dev);

#ifdef ZM_ENABLE_IBSS_WPA2PSK
    zmw_declare_for_critical_section();
#endif
    wd->state = ZM_WLAN_STATE_DISABLED;

    zm_msg0_mm(ZM_LV_1, "Disable Wlan");

    if ( wd->wlanMode != ZM_MODE_AP )
    {
        isConnected = zfStaIsConnected(dev);

        if ( (wd->wlanMode == ZM_MODE_INFRASTRUCTURE)&&
             (wd->sta.currentAuthMode != ZM_AUTH_MODE_WPA2) )
        {
            /* send deauthentication frame */
            if (isConnected)
            {
                //zfiWlanDeauth(dev, NULL, 0);
                zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, wd->sta.bssid, 3, 0, 0);
                //zmw_debug_msg0("send a Deauth frame!");
            }
        }

        // Remove all the connected peer stations
        if ( wd->wlanMode == ZM_MODE_IBSS )
        {
            wd->sta.ibssBssIsCreator = 0;
            zfTimerCancel(dev, ZM_EVENT_IBSS_MONITOR);
            zfStaIbssMonitoring(dev, 1);
        }

#ifdef ZM_ENABLE_IBSS_WPA2PSK
        zmw_enter_critical_section(dev);
        wd->sta.ibssWpa2Psk = 0;
        zmw_leave_critical_section(dev);
#endif

        wd->sta.wpaState = ZM_STA_WPA_STATE_INIT;

        /* reset connect timeout counter */
        wd->sta.connectTimeoutCount = 0;

        /* reset connectState to None */
        wd->sta.connectState = ZM_STA_CONN_STATE_NONE;

        /* reset leap enable variable */
        wd->sta.leapEnabled = 0;

        /* Disable the RIFS Status / RIFS-like frame count / RIFS count */
        if( wd->sta.rifsState == ZM_RIFS_STATE_DETECTED )
            zfHpDisableRifs(dev);
        wd->sta.rifsState = ZM_RIFS_STATE_DETECTING;
        wd->sta.rifsLikeFrameCnt = 0;
        wd->sta.rifsCount = 0;

        wd->sta.osRxFilter = 0;
        wd->sta.bSafeMode = 0;

        zfChangeAdapterState(dev, ZM_STA_STATE_DISCONNECT);
        if (ResetKeyCache)
            zfHpResetKeyCache(dev);

        if (isConnected)
        {
            if (wd->zfcbConnectNotify != NULL)
            {
                wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECTION_DISABLED, wd->sta.bssid);
            }
        }
        else
        {
            if (wd->zfcbConnectNotify != NULL)
            {
                wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_DISABLED, wd->sta.bssid);
            }
        }
    }
    else //if (wd->wlanMode == ZM_MODE_AP)
    {
        for (i=0; i<ZM_MAX_STA_SUPPORT; i++)
        {
            /* send deauthentication frame */
            if (wd->ap.staTable[i].valid == 1)
            {
                /* Reason : Sending station is leaving */
                zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH,
                        wd->ap.staTable[i].addr, 3, 0, 0);
            }
        }

        if (ResetKeyCache)
            zfHpResetKeyCache(dev);

        wd->ap.vapNumber--;
    }

    /* stop beacon */
    zfHpDisableBeacon(dev);

    /* Flush VTxQ and MmQ */
    zfFlushVtxq(dev);
    /* Flush AP PS queues */
    zfApFlushBufferedPsFrame(dev);
    /* Free buffer in defragment list*/
    zfAgingDefragList(dev, 1);

    #ifdef ZM_ENABLE_AGGREGATION
    /* add by honda */
    zfAggRxFreeBuf(dev, 0);  //1 for release structure memory
    /* end of add by honda */
    #endif

    // Clear the information for the peer stations of IBSS or AP of Station mode
    zfZeroMemory((u8_t*)wd->sta.oppositeInfo, sizeof(struct zsOppositeInfo) * ZM_MAX_OPPOSITE_COUNT);

    /* Turn off Software WEP/TKIP */
    if (wd->sta.SWEncryptEnable != 0)
    {
        zm_debug_msg0("Disable software encryption");
        zfStaDisableSWEncryption(dev);
    }

    /* Improve WEP/TKIP performace with HT AP, detail information please look bug#32495 */
    //zfHpSetTTSIFSTime(dev, 0x8);

    return 0;
}

u16_t zfiWlanSuspend(zdev_t* dev)
{
    zmw_get_wlan_dev(dev);
    zmw_declare_for_critical_section();

    // Change the HAL state to init so that any packet can't be transmitted between
    // resume & HAL reinit. This would cause the chip hang issue in OTUS.
    zmw_enter_critical_section(dev);
    wd->halState = ZM_HAL_STATE_INIT;
    zmw_leave_critical_section(dev);

    return 0;
}

u16_t zfiWlanResume(zdev_t* dev, u8_t doReconn)
{
    u16_t ret;
    zmw_get_wlan_dev(dev);
    zmw_declare_for_critical_section();

    /* Redownload firmware, Reinit MAC,PHY,RF */
    zfHpReinit(dev, wd->frequency);

    //Set channel according to AP's configuration
    zfCoreSetFrequencyExV2(dev, wd->frequency, wd->BandWidth40,
            wd->ExtOffset, NULL, 1);

    zfHpSetMacAddress(dev, wd->macAddr, 0);

    /* Start Rx */
    zfHpStartRecv(dev);

    zfFlushVtxq(dev);

    if ( wd->wlanMode != ZM_MODE_INFRASTRUCTURE &&
         wd->wlanMode != ZM_MODE_IBSS )
    {
        return 1;
    }

    zm_msg0_mm(ZM_LV_1, "Resume Wlan");
    if ( (zfStaIsConnected(dev)) || (zfStaIsConnecting(dev)) )
    {
        if (doReconn == 1)
        {
            zm_msg0_mm(ZM_LV_1, "Re-connect...");
            zmw_enter_critical_section(dev);
            wd->sta.connectByReasso = FALSE;
            zmw_leave_critical_section(dev);

            zfWlanEnable(dev);
        }
        else if (doReconn == 0)
        {
            zfHpSetRollCallTable(dev);
        }
    }

    ret = 0;

    return ret;
}

/************************************************************************/
/*                                                                      */
/*    FUNCTION DESCRIPTION                 zfiWlanFlushAllQueuedBuffers */
/*      Flush Virtual TxQ, MmQ, PS frames and defragment list           */
/*                                                                      */
/*    INPUTS                                                            */
/*      dev : device pointer                                            */
/*                                                                      */
/*    OUTPUTS                                                           */
/*      None                                                            */
/*                                                                      */
/*    AUTHOR                                                            */
/*      Stephen Chen        Atheros Communications, INC.    2007.1      */
/*                                                                      */
/************************************************************************/
void zfiWlanFlushAllQueuedBuffers(zdev_t* dev)
{
    /* Flush VTxQ and MmQ */
    zfFlushVtxq(dev);
    /* Flush AP PS queues */
    zfApFlushBufferedPsFrame(dev);
    /* Free buffer in defragment list*/
    zfAgingDefragList(dev, 1);
}

/* Do WLAN site survey */
u16_t zfiWlanScan(zdev_t* dev)
{
    u16_t ret = 1;
    zmw_get_wlan_dev(dev);

    zm_debug_msg0("");

    zmw_declare_for_critical_section();

    zmw_enter_critical_section(dev);

    if (wd->wlanMode == ZM_MODE_AP)
    {
        wd->heartBeatNotification |= ZM_BSSID_LIST_SCAN;
        wd->sta.scanFrequency = 0;
        //wd->sta.pUpdateBssList->bssCount = 0;
        ret = 0;
    }
    else
    {
        #if 0
        if ( !zfStaBlockWlanScan(dev) )
        {
            zm_debug_msg0("scan request");
            //zfTimerSchedule(dev, ZM_EVENT_SCAN, ZM_TICK_ZERO);
            ret = 0;
            goto start_scan;
        }
        #else
            goto start_scan;
        #endif
    }

    zmw_leave_critical_section(dev);

    return ret;

start_scan:
    zmw_leave_critical_section(dev);

    if(wd->ledStruct.LEDCtrlFlagFromReg & ZM_LED_CTRL_FLAG_ALPHA)   // flag for Alpha
        wd->ledStruct.LEDCtrlFlag |= ZM_LED_CTRL_FLAG_ALPHA;

    ret = zfScanMgrScanStart(dev, ZM_SCAN_MGR_SCAN_EXTERNAL);

    zm_debug_msg1("ret = ", ret);

    return ret;
}


/* rate         */
/*    0 : AUTO  */
/*    1 : CCK 1M */
/*    2 : CCK 2M */
/*    3 : CCK 5.5M */
/*    4 : CCK 11M */
/*    5 : OFDM 6M */
/*    6 : OFDM 9M */
/*    7 : OFDM 12M */
/*    8 : OFDM 18M */
/*    9 : OFDM 24M */
/*    10 : OFDM 36M */
/*    11 : OFDM 48M */
/*    12 : OFDM 54M */
/*    13 : MCS 0 */
/*    28 : MCS 15 */
u16_t zcRateToMCS[] =
    {0xff, 0, 1, 2, 3, 0xb, 0xf, 0xa, 0xe, 0x9, 0xd, 0x8, 0xc};
u16_t zcRateToMT[] = {0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1};

u16_t zfiWlanSetTxRate(zdev_t* dev, u16_t rate)
{   // jhlee HT 0
    zmw_get_wlan_dev(dev);

    if (rate <=12)
    {
        wd->txMCS = zcRateToMCS[rate];
        wd->txMT = zcRateToMT[rate];
        return ZM_SUCCESS;
    }
    else if ((rate<=28)||(rate==13+32))
    {
        wd->txMCS = rate - 12 - 1;
        wd->txMT = 2;
        return ZM_SUCCESS;
    }

    return ZM_ERR_INVALID_TX_RATE;
}

const u32_t zcRateIdToKbps40M[] =
    {
        1000, 2000, 5500, 11000,                  /* 1M, 2M, 5M, 11M          ,  0  1  2  3*/
        6000, 9000, 12000, 18000,                 /* 6M  9M  12M  18M         ,  4  5  6  7*/
        24000, 36000, 48000, 54000,               /* 24M  36M  48M  54M       ,  8  9 10 11*/
        13500, 27000, 40500, 54000,               /* MCS0 MCS1 MCS2 MCS3      , 12 13 14 15*/
        81000, 108000, 121500, 135000,            /* MCS4 MCS5 MCS6 MCS7      , 16 17 18 19*/
        27000, 54000, 81000, 108000,              /* MCS8 MCS9 MCS10 MCS11    , 20 21 22 23*/
        162000, 216000, 243000, 270000,           /* MCS12 MCS13 MCS14 MCS15  , 24 25 26 27*/
        270000, 300000, 150000                    /* MCS14SG, MCS15SG, MCS7SG , 28 29 30*/
    };

const u32_t zcRateIdToKbps20M[] =
    {
        1000, 2000, 5500, 11000,                  /* 1M, 2M, 5M, 11M          ,  0  1  2  3*/
        6000, 9000, 12000, 18000,                 /* 6M  9M  12M  18M         ,  4  5  6  7*/
        24000, 36000, 48000, 54000,               /* 24M  36M  48M  54M       ,  8  9 10 11*/
        6500, 13000, 19500, 26000,                /* MCS0 MCS1 MCS2 MCS3      , 12 13 14 15*/
        39000, 52000, 58500, 65000,               /* MCS4 MCS5 MCS6 MCS7      , 16 17 18 19*/
        13000, 26000, 39000, 52000,               /* MCS8 MCS9 MCS10 MCS11    , 20 21 22 23*/
        78000, 104000, 117000, 130000,            /* MCS12 MCS13 MCS14 MCS15  , 24 25 26 27*/
        130000, 144400, 72200                     /* MCS14SG, MCS15SG, MSG7SG , 28 29 30*/
    };

u32_t zfiWlanQueryTxRate(zdev_t* dev)
{
    u8_t rateId = 0xff;
    zmw_get_wlan_dev(dev);
    zmw_declare_for_critical_section();

    /* If Tx rate had not been trained, return maximum Tx rate instead */
    if ((wd->wlanMode == ZM_MODE_INFRASTRUCTURE) && (zfStaIsConnected(dev)))
    {
        zmw_enter_critical_section(dev);
        //Not in fixed rate mode
        if (wd->txMCS == 0xff)
        {
            if ((wd->sta.oppositeInfo[0].rcCell.flag & ZM_RC_TRAINED_BIT) == 0)
            {
                rateId = wd->sta.oppositeInfo[0].rcCell.operationRateSet[wd->sta.oppositeInfo[0].rcCell.operationRateCount-1];
            }
            else
            {
                rateId = wd->sta.oppositeInfo[0].rcCell.operationRateSet[wd->sta.oppositeInfo[0].rcCell.currentRateIndex];
            }
        }
        zmw_leave_critical_section(dev);
    }
    if (rateId != 0xff)
    {
        if (wd->sta.htCtrlBandwidth)
        {
            return zcRateIdToKbps40M[rateId];
        }
        else
        {
            return zcRateIdToKbps20M[rateId];
        }
    }
    else
    {
        return wd->CurrentTxRateKbps;
    }
}

void zfWlanUpdateRxRate(zdev_t* dev, struct zsAdditionInfo* addInfo)
{
    u32_t rxRateKbps;
    zmw_get_wlan_dev(dev);
    //zm_msg1_mm(ZM_LV_0, "addInfo->Tail.Data.RxMacStatus =", addInfo->Tail.Data.RxMacStatus & 0x03);

    /* b5~b4: MPDU indication.                */
    /*        00: Single MPDU.                */
    /*        10: First MPDU of A-MPDU.       */
    /*        11: Middle MPDU of A-MPDU.      */
    /*        01: Last MPDU of A-MPDU.        */
    /* Only First MPDU and Single MPDU have PLCP header */
    /* First MPDU  : (mpduInd & 0x30) == 0x00 */
    /* Single MPDU : (mpduInd & 0x30) == 0x20 */
    if ((addInfo->Tail.Data.RxMacStatus & 0x10) == 0)
    {
        /* Modulation type */
        wd->modulationType = addInfo->Tail.Data.RxMacStatus & 0x03;
        switch(wd->modulationType)
        {
    		case 0x0: wd->rateField = addInfo->PlcpHeader[0] & 0xff; //CCK mode
                      wd->rxInfo = 0;
                      break;
    		case 0x1: wd->rateField = addInfo->PlcpHeader[0] & 0x0f; //Legacy-OFDM mode
                      wd->rxInfo = 0;
                      break;
    		case 0x2: wd->rateField = addInfo->PlcpHeader[3]; //HT-OFDM mode
    		          wd->rxInfo = addInfo->PlcpHeader[6];
                      break;
            default: break;
         }

        rxRateKbps = zfUpdateRxRate(dev);
        if (wd->CurrentRxRateUpdated == 1)
        {
            if (rxRateKbps > wd->CurrentRxRateKbps)
            {
                wd->CurrentRxRateKbps = rxRateKbps;
            }
        }
        else
        {
            wd->CurrentRxRateKbps = rxRateKbps;
            wd->CurrentRxRateUpdated = 1;
        }
    }
}
#if 0
u16_t zcIndextoRateBG[16] = {1000, 2000, 5500, 11000, 0, 0, 0, 0, 48000,
                               24000, 12000, 6000, 54000, 36000, 18000, 9000};
u32_t zcIndextoRateN20L[16] = {6500, 13000, 19500, 26000, 39000, 52000, 58500,
                              65000, 13000, 26000, 39000, 52000, 78000, 104000,
                              117000, 130000};
u32_t zcIndextoRateN20S[16] = {7200, 14400, 21700, 28900, 43300, 57800, 65000,
                              72200, 14400, 28900, 43300, 57800, 86700, 115600,
                              130000, 144400};
u32_t zcIndextoRateN40L[16] = {13500, 27000, 40500, 54000, 81000, 108000, 121500,
                              135000, 27000, 54000, 81000, 108000, 162000, 216000,
                              243000, 270000};
u32_t zcIndextoRateN40S[16] = {15000, 30000, 45000, 60000, 90000, 120000, 135000,
                              150000, 30000, 60000, 90000, 120000, 180000, 240000,
                              270000, 300000};
#endif

extern u16_t zcIndextoRateBG[16];
extern u32_t zcIndextoRateN20L[16];
extern u32_t zcIndextoRateN20S[16];
extern u32_t zcIndextoRateN40L[16];
extern u32_t zcIndextoRateN40S[16];

u32_t zfiWlanQueryRxRate(zdev_t* dev)
{
    zmw_get_wlan_dev(dev);

    wd->CurrentRxRateUpdated = 0;
    return wd->CurrentRxRateKbps;
}

u32_t zfUpdateRxRate(zdev_t* dev)
{
    u8_t mcs, bandwidth;
    u32_t rxRateKbps = 130000;
    zmw_get_wlan_dev(dev);

    switch (wd->modulationType)
    {
		case 0x0: //CCK mode
                  switch (wd->rateField)
                  {
                      case 0x0a: rxRateKbps = 1000;
                            break;
                      case 0x14: rxRateKbps = 2000;

                      case 0x37: rxRateKbps = 5500;
                            break;
                      case 0x6e: rxRateKbps = 11000;
                            break;
                      default:
                            break;
                  }
                  break;
		case 0x1: //Legacy-OFDM mode
                  if (wd->rateField <= 15)
                  {
                      rxRateKbps = zcIndextoRateBG[wd->rateField];
                  }
                  break;
		case 0x2: //HT-OFDM mode
		          mcs = wd->rateField & 0x7F;
		          bandwidth = wd->rateField & 0x80;
                  if (mcs <= 15)
                  {
                      if (bandwidth != 0)
                      {
                          if((wd->rxInfo & 0x80) != 0)
                          {
                              /* Short GI 40 MHz MIMO Rate */
                              rxRateKbps = zcIndextoRateN40S[mcs];
                          }
                          else
                          {
                              /* Long GI 40 MHz MIMO Rate */
                              rxRateKbps = zcIndextoRateN40L[mcs];
                          }
                      }
                      else
                      {
                          if((wd->rxInfo & 0x80) != 0)
                          {
                              /* Short GI 20 MHz MIMO Rate */
                              rxRateKbps = zcIndextoRateN20S[mcs];
                          }
                          else
                          {
                              /* Long GI 20 MHz MIMO Rate */
                              rxRateKbps = zcIndextoRateN20L[mcs];
                          }
                      }
                  }
                  break;
        default:
                  break;
    }
    //zm_msg1_mm(ZM_LV_0, "wd->CurrentRxRateKbps=", wd->CurrentRxRateKbps);

     // ToDo: use bandwith field to define 40MB
    return rxRateKbps;
}

/* Get WLAN stastics */
u16_t zfiWlanGetStatistics(zdev_t* dev)
{
    /* Return link statistics */
    return 0;
}

u16_t zfiWlanReset(zdev_t* dev)
{
    zmw_get_wlan_dev(dev);

    wd->state = ZM_WLAN_STATE_DISABLED;

    return zfWlanReset(dev);
}

/* Reset WLAN */
u16_t zfWlanReset(zdev_t* dev)
{
    u8_t isConnected;
    zmw_get_wlan_dev(dev);

    zmw_declare_for_critical_section();

    zm_debug_msg0("zfWlanReset");

    isConnected = zfStaIsConnected(dev);

    //if ( wd->wlanMode != ZM_MODE_AP )
    {
        if ( (wd->wlanMode == ZM_MODE_INFRASTRUCTURE)&&
             (wd->sta.currentAuthMode != ZM_AUTH_MODE_WPA2) )
        {
            /* send deauthentication frame */
            if (isConnected)
            {
                //zfiWlanDeauth(dev, NULL, 0);
                zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, wd->sta.bssid, 3, 0, 0);
                //zmw_debug_msg0("send a Deauth frame!");
            }
        }
    }

    zfChangeAdapterState(dev, ZM_STA_STATE_DISCONNECT);
    zfHpResetKeyCache(dev);

    if (isConnected)
    {
        //zfiWlanDisable(dev);
        if (wd->zfcbConnectNotify != NULL)
        {
            wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECTION_RESET, wd->sta.bssid);
        }
    }
    else
    {
        if (wd->zfcbConnectNotify != NULL)
        {
            wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_RESET, wd->sta.bssid);
        }
    }

    /* stop beacon */
    zfHpDisableBeacon(dev);

    /* Free buffer in defragment list*/
    zfAgingDefragList(dev, 1);

    /* Flush VTxQ and MmQ */
    zfFlushVtxq(dev);

    #ifdef ZM_ENABLE_AGGREGATION
    /* add by honda */
    zfAggRxFreeBuf(dev, 0);  //1 for release structure memory
    /* end of add by honda */
    #endif

    zfStaRefreshBlockList(dev, 1);

    zmw_enter_critical_section(dev);

    zfTimerCancel(dev, ZM_EVENT_IBSS_MONITOR);
    zfTimerCancel(dev, ZM_EVENT_CM_BLOCK_TIMER);
    zfTimerCancel(dev, ZM_EVENT_CM_DISCONNECT);

    wd->sta.connectState = ZM_STA_CONN_STATE_NONE;
    wd->sta.connectByReasso = FALSE;
    wd->sta.cmDisallowSsidLength = 0;
    wd->sta.bAutoReconnect = 0;
    wd->sta.InternalScanReq = 0;
    wd->sta.encryMode = ZM_NO_WEP;
    wd->sta.wepStatus = ZM_ENCRYPTION_WEP_DISABLED;
    wd->sta.wpaState = ZM_STA_WPA_STATE_INIT;
    wd->sta.cmMicFailureCount = 0;
    wd->sta.ibssBssIsCreator = 0;
#ifdef ZM_ENABLE_IBSS_WPA2PSK
    wd->sta.ibssWpa2Psk = 0;
#endif
    /* reset connect timeout counter */
    wd->sta.connectTimeoutCount = 0;

    /* reset leap enable variable */
    wd->sta.leapEnabled = 0;

    /* Reset the RIFS Status / RIFS-like frame count / RIFS count */
    if( wd->sta.rifsState == ZM_RIFS_STATE_DETECTED )
        zfHpDisableRifs(dev);
    wd->sta.rifsState = ZM_RIFS_STATE_DETECTING;
    wd->sta.rifsLikeFrameCnt = 0;
    wd->sta.rifsCount = 0;

    wd->sta.osRxFilter = 0;
    wd->sta.bSafeMode = 0;

    // Clear the information for the peer stations of IBSS or AP of Station mode
    zfZeroMemory((u8_t*)wd->sta.oppositeInfo, sizeof(struct zsOppositeInfo) * ZM_MAX_OPPOSITE_COUNT);

    zmw_leave_critical_section(dev);

    zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_INTERNAL);
    zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_EXTERNAL);

    /* Turn off Software WEP/TKIP */
    if (wd->sta.SWEncryptEnable != 0)
    {
        zm_debug_msg0("Disable software encryption");
        zfStaDisableSWEncryption(dev);
    }

    /* Improve WEP/TKIP performace with HT AP, detail information please look bug#32495 */
    //zfHpSetTTSIFSTime(dev, 0x8);

    /* Keep Pseudo mode */
    if ( wd->wlanMode != ZM_MODE_PSEUDO )
    {
        wd->wlanMode = ZM_MODE_INFRASTRUCTURE;
    }
    return 0;
}

/* Deauthenticate a STA */
u16_t zfiWlanDeauth(zdev_t* dev, u16_t* macAddr, u16_t reason)
{
    zmw_get_wlan_dev(dev);

    if ( wd->wlanMode == ZM_MODE_AP )
    {
        //u16_t id;

        /*
         * we will reset all key in zfHpResetKeyCache() when call
         * zfiWlanDisable(), if we want to reset PairwiseKey for each sta,
         * need to use a nullAddr to let keyindex not match.
         * otherwise hardware will still find PairwiseKey when AP change
         * encryption mode from WPA to WEP
         */

        /*
        if ((id = zfApFindSta(dev, macAddr)) != 0xffff)
        {
            u32_t key[8];
            u16_t nullAddr[3] = { 0x0, 0x0, 0x0 };

            if (wd->ap.staTable[i].encryMode != ZM_NO_WEP)
            {
                zfHpSetApPairwiseKey(dev, nullAddr,
                        ZM_NO_WEP, &key[0], &key[4], i+1);
            }
            //zfHpSetApPairwiseKey(dev, (u16_t *)macAddr,
            //        ZM_NO_WEP, &key[0], &key[4], id+1);
            wd->ap.staTable[id].encryMode = ZM_NO_WEP;
            wd->ap.staTable[id].keyIdx = 0xff;
        }
        */

        zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, macAddr, reason, 0, 0);
    }
    else
    {
        zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, wd->sta.bssid, 3, 0, 0);
    }

    /* Issue DEAUTH command to FW */
    return 0;
}


/* XP packet filter feature : */
/* 1=>enable: All multicast address packets, not just the ones enumerated in the multicast address list. */
/* 0=>disable */
void zfiWlanSetAllMulticast(zdev_t* dev, u32_t setting)
{
    zmw_get_wlan_dev(dev);
    zm_msg1_mm(ZM_LV_0, "sta.bAllMulticast = ", setting);
    wd->sta.bAllMulticast = (u8_t)setting;
}


/* HT configure API */
void zfiWlanSetHTCtrl(zdev_t* dev, u32_t *setting, u32_t forceTxTPC)
{
    zmw_get_wlan_dev(dev);

    wd->preambleType        = (u8_t)setting[0];
    wd->sta.preambleTypeHT  = (u8_t)setting[1];
    wd->sta.htCtrlBandwidth = (u8_t)setting[2];
    wd->sta.htCtrlSTBC      = (u8_t)setting[3];
    wd->sta.htCtrlSG        = (u8_t)setting[4];
    wd->sta.defaultTA       = (u8_t)setting[5];
    wd->enableAggregation   = (u8_t)setting[6];
    wd->enableWDS           = (u8_t)setting[7];

    wd->forceTxTPC          = forceTxTPC;
}

/* FB50 in OS XP, RD private test code */
void zfiWlanQueryHTCtrl(zdev_t* dev, u32_t *setting, u32_t *forceTxTPC)
{
    zmw_get_wlan_dev(dev);

    setting[0] = wd->preambleType;
    setting[1] = wd->sta.preambleTypeHT;
    setting[2] = wd->sta.htCtrlBandwidth;
    setting[3] = wd->sta.htCtrlSTBC;
    setting[4] = wd->sta.htCtrlSG;
    setting[5] = wd->sta.defaultTA;
    setting[6] = wd->enableAggregation;
    setting[7] = wd->enableWDS;

    *forceTxTPC = wd->forceTxTPC;
}

void zfiWlanDbg(zdev_t* dev, u8_t setting)
{
    zmw_get_wlan_dev(dev);

    wd->enableHALDbgInfo = setting;
}

/* FB50 in OS XP, RD private test code */
void zfiWlanSetRxPacketDump(zdev_t* dev, u32_t setting)
{
    zmw_get_wlan_dev(dev);
    if (setting)
    {
        wd->rxPacketDump = 1;   /* enable */
    }
    else
    {
        wd->rxPacketDump = 0;   /* disable */
    }
}


/* FB50 in OS XP, RD private test code */
/* Tally */
void zfiWlanResetTally(zdev_t* dev)
{
    zmw_get_wlan_dev(dev);

    zmw_declare_for_critical_section();

    zmw_enter_critical_section(dev);

	   wd->commTally.txUnicastFrm = 0;		//txUnicastFrames
	   wd->commTally.txMulticastFrm = 0;		//txMulticastFrames
	   wd->commTally.txUnicastOctets = 0;	//txUniOctets  byte size
	   wd->commTally.txMulticastOctets = 0;	//txMultiOctets  byte size
	   wd->commTally.txFrmUpperNDIS = 0;
	   wd->commTally.txFrmDrvMgt = 0;
	   wd->commTally.RetryFailCnt = 0;
	   wd->commTally.Hw_TotalTxFrm = 0;		//Hardware total Tx Frame
	   wd->commTally.Hw_RetryCnt = 0;		//txMultipleRetriesFrames
	   wd->commTally.Hw_UnderrunCnt = 0;//
	   wd->commTally.DriverRxFrmCnt = 0;//
	   wd->commTally.rxUnicastFrm = 0;		//rxUnicastFrames
	   wd->commTally.rxMulticastFrm = 0;	//rxMulticastFrames
	   wd->commTally.NotifyNDISRxFrmCnt = 0;//
	   wd->commTally.rxUnicastOctets = 0;	//rxUniOctets  byte size
	   wd->commTally.rxMulticastOctets = 0;	//rxMultiOctets  byte size
	   wd->commTally.DriverDiscardedFrm = 0;// Discard by ValidateFrame
	   wd->commTally.LessThanDataMinLen = 0;//
	   wd->commTally.GreaterThanMaxLen = 0;//
	   wd->commTally.DriverDiscardedFrmCauseByMulticastList = 0;
	   wd->commTally.DriverDiscardedFrmCauseByFrmCtrl = 0;
	   wd->commTally.rxNeedFrgFrm = 0;		// need more frg frm
	   wd->commTally.DriverRxMgtFrmCnt = 0;
	   wd->commTally.rxBroadcastFrm = 0;	//Receive broadcast frame count
	   wd->commTally.rxBroadcastOctets = 0;	//Receive broadcast frame byte size
	   wd->commTally.Hw_TotalRxFrm = 0;//
	   wd->commTally.Hw_CRC16Cnt = 0;		//rxPLCPCRCErrCnt
	   wd->commTally.Hw_CRC32Cnt = 0;		//rxCRC32ErrCnt
	   wd->commTally.Hw_DecrypErr_UNI = 0;//
	   wd->commTally.Hw_DecrypErr_Mul = 0;//
	   wd->commTally.Hw_RxFIFOOverrun = 0;//
	   wd->commTally.Hw_RxTimeOut = 0;
	   wd->commTally.LossAP = 0;//

	   wd->commTally.Tx_MPDU = 0;
	   wd->commTally.BA_Fail = 0;
	   wd->commTally.Hw_Tx_AMPDU = 0;
	   wd->commTally.Hw_Tx_MPDU = 0;

    wd->commTally.txQosDropCount[0] = 0;
    wd->commTally.txQosDropCount[1] = 0;
    wd->commTally.txQosDropCount[2] = 0;
    wd->commTally.txQosDropCount[3] = 0;
    wd->commTally.txQosDropCount[4] = 0;

    wd->commTally.Hw_RxMPDU = 0;
    wd->commTally.Hw_RxDropMPDU = 0;
    wd->commTally.Hw_RxDelMPDU = 0;

    wd->commTally.Hw_RxPhyMiscError = 0;
    wd->commTally.Hw_RxPhyXRError = 0;
    wd->commTally.Hw_RxPhyOFDMError = 0;
    wd->commTally.Hw_RxPhyCCKError = 0;
    wd->commTally.Hw_RxPhyHTError = 0;
    wd->commTally.Hw_RxPhyTotalCount = 0;

#if	(defined(GCCK) && defined(OFDM))
	   wd->commTally.rx11bDataFrame = 0;
	   wd->commTally.rxOFDMDataFrame = 0;
#endif

    zmw_leave_critical_section(dev);
}

/* FB50 in OS XP, RD private test code */
void zfiWlanQueryTally(zdev_t* dev, struct zsCommTally *tally)
{
    zmw_get_wlan_dev(dev);

    zmw_declare_for_critical_section();

    zmw_enter_critical_section(dev);
    zfMemoryCopy((u8_t*)tally, (u8_t*)&wd->commTally, sizeof(struct zsCommTally));
    zmw_leave_critical_section(dev);
}
void zfiWlanQueryTrafTally(zdev_t* dev, struct zsTrafTally *tally)
{
    zmw_get_wlan_dev(dev);

    zmw_declare_for_critical_section();

    zmw_enter_critical_section(dev);
    zfMemoryCopy((u8_t*)tally, (u8_t*)&wd->trafTally, sizeof(struct zsTrafTally));
    zmw_leave_critical_section(dev);
}

void zfiWlanQueryMonHalRxInfo(zdev_t* dev, struct zsMonHalRxInfo *monHalRxInfo)
{
    zfHpQueryMonHalRxInfo(dev, (u8_t *)monHalRxInfo);
}

/* parse the modeMDKEnable to DrvCore */
void zfiDKEnable(zdev_t* dev, u32_t enable)
{
    zmw_get_wlan_dev(dev);

    wd->modeMDKEnable = enable;
    zm_debug_msg1("modeMDKEnable = ", wd->modeMDKEnable);
}

/* airoPeek */
u32_t zfiWlanQueryPacketTypePromiscuous(zdev_t* dev)
{
    zmw_get_wlan_dev(dev);

    return wd->swSniffer;
}

/* airoPeek */
void zfiWlanSetPacketTypePromiscuous(zdev_t* dev, u32_t setValue)
{
    zmw_get_wlan_dev(dev);

	   wd->swSniffer = setValue;
	   zm_msg1_mm(ZM_LV_0, "wd->swSniffer ", wd->swSniffer);
	   if (setValue)
	   {
	       	/* write register for sniffer mode */
            zfHpSetSnifferMode(dev, 1);
            zm_msg0_mm(ZM_LV_1, "enalbe sniffer mode");
	   }
	   else
	   {
            zfHpSetSnifferMode(dev, 0);
            zm_msg0_mm(ZM_LV_0, "disalbe sniffer mode");
	   }
}

void zfiWlanSetXLinkMode(zdev_t* dev, u32_t setValue)
{
    zmw_get_wlan_dev(dev);

    wd->XLinkMode = setValue;
    if (setValue)
    {
        /* write register for sniffer mode */
        zfHpSetSnifferMode(dev, 1);
    }
    else
    {
        zfHpSetSnifferMode(dev, 0);
    }
}

extern void zfStaChannelManagement(zdev_t* dev, u8_t scan);
void zfiSetChannelManagement(zdev_t* dev, u32_t setting)
{
    zmw_get_wlan_dev(dev);

    switch (setting)
    {
        case 1:
            wd->sta.EnableHT = 1;
            wd->BandWidth40 = 1;
            wd->ExtOffset   = 1;
            break;
        case 3:
            wd->sta.EnableHT = 1;
            wd->BandWidth40 = 1;
            wd->ExtOffset   = 3;
            break;
        case 0:
            wd->sta.EnableHT = 1;
            wd->BandWidth40 = 0;
            wd->ExtOffset   = 0;
            break;
        default:
            wd->BandWidth40 = 0;
            wd->ExtOffset   = 0;
            break;

    }
    zfCoreSetFrequencyEx(dev, wd->frequency, wd->BandWidth40,
                    wd->ExtOffset, NULL);
}

void zfiSetRifs(zdev_t* dev, u16_t setting)
{
    zmw_get_wlan_dev(dev);

    wd->sta.ie.HtInfo.ChannelInfo |= ExtHtCap_RIFSMode;
    wd->sta.EnableHT = 1;
    switch (setting)
    {
        case 0:
            wd->sta.HT2040 = 0;
//            zfHpSetRifs(dev, 1, 0, (wd->sta.currentFrequency < 3000)? 1:0);
            break;
        case 1:
            wd->sta.HT2040 = 1;
//            zfHpSetRifs(dev, 1, 1, (wd->sta.currentFrequency < 3000)? 1:0);
            break;
        default:
            wd->sta.HT2040 = 0;
//            zfHpSetRifs(dev, 1, 0, (wd->sta.currentFrequency < 3000)? 1:0);
            break;
    }
}

void zfiCheckRifs(zdev_t* dev)
{
    zmw_get_wlan_dev(dev);

    if(wd->sta.ie.HtInfo.ChannelInfo & ExtHtCap_RIFSMode)
    {
//        zfHpSetRifs(dev, wd->sta.EnableHT, wd->sta.HT2040, (wd->sta.currentFrequency < 3000)? 1:0);
    }
}

void zfiSetReorder(zdev_t* dev, u16_t value)
{
    zmw_get_wlan_dev(dev);

    wd->reorder = value;
}

void zfiSetSeqDebug(zdev_t* dev, u16_t value)
{
    zmw_get_wlan_dev(dev);

    wd->seq_debug = value;
}