/*
 * 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);
	} else { /*if (wd->wlanMode == ZM_MODE_AP) */

		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) {
		/* CCK mode */
		case 0x0:
			wd->rateField = addInfo->PlcpHeader[0] & 0xff;
			wd->rxInfo = 0;
			break;
		/* Legacy-OFDM mode */
		case 0x1:
			wd->rateField = addInfo->PlcpHeader[0] & 0x0f;
			wd->rxInfo = 0;
			break;
		/* HT-OFDM mode */
		case 0x2:
			wd->rateField = addInfo->PlcpHeader[3];
			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) {
	/* CCK mode */
	case 0x0:
		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;
	/* Legacy-OFDM mode */
	case 0x1:
		if (wd->rateField <= 15)
			rxRateKbps = zcIndextoRateBG[wd->rateField];
		break;
	/* HT-OFDM mode */
	case 0x2:
		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 framebyte 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;
}