Staging: otus: 80211core/ccmd.c: Fix Coding Style

Signed-off-by: Dragoslav Zaric <dragoslav.zaric.kd@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

drivers/staging/otus/80211core/ccmd.c

@@ -27,1019 +27,941 @@
 #include "../hal/hpreg.h"
 
 
-u16_t zfWlanReset(zdev_t* dev);
-u32_t zfUpdateRxRate(zdev_t* dev);
+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);
+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)
+u16_t zfiGlobalDataSize(zdev_t *dev)
 {
-    u32_t ret;
-    ret = (sizeof(struct zsWlanDev));
-    zm_assert((ret>>16) == 0);
-    return (u16_t)ret;
+	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)
+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);
+	/* 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");
+	zm_debug_msg0("start");
 
-    devSize = sizeof(struct zsWlanDev);
-    /* Zeroize zsWlanDev struct */
-    zfZeroMemory((u8_t*)wd, (u16_t)devSize);
+	devSize = sizeof(struct zsWlanDev);
+	/* Zeroize zsWlanDev struct */
+	zfZeroMemory((u8_t *)wd, (u16_t)devSize);
 
 #ifdef ZM_ENABLE_AGGREGATION
-    zfAggInit(dev);
+	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;
+	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);
+		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;
+	/* 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;
+	/* 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.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;
+	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 */
+	/* 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';
+	/* 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);
+	/* zfiWlanSetFragThreshold(dev, 0); */
 
 	/* airopeek : swSniffer 1=>on  0=>off */
 	wd->swSniffer = 0;
-    wd->XLinkMode = 0;
+	wd->XLinkMode = 0;
 
-// jhlee HT 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;
+	/* 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;
+	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;
+	/*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;
+	/* WME test code */
+	wd->ap.qosMode[0] = 1;
 #endif
 
-    wd->ledStruct.ledMode[0] = 0x2221;
-    wd->ledStruct.ledMode[1] = 0x2221;
+	wd->ledStruct.ledMode[0] = 0x2221;
+	wd->ledStruct.ledMode[1] = 0x2221;
 
-    zfTimerInit(dev);
+	zfTimerInit(dev);
 
-    ZM_PERFORMANCE_INIT(dev);
+	ZM_PERFORMANCE_INIT(dev);
 
-    zfBssInfoCreate(dev);
-    zfScanMgrInit(dev);
-    zfPowerSavingMgrInit(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);
-    }
+	/* 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);
+	/* 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);
+	/* zfHpInit(dev, wd->frequency); */
 
-    /* MAC address */
-    //zfHpSetMacAddress(dev, wd->macAddr, 0);
-    zfHpGetMacAddress(dev);
+	/* MAC address */
+	/* zfHpSetMacAddress(dev, wd->macAddr, 0); */
+	zfHpGetMacAddress(dev);
 
-    zfCoreSetFrequency(dev, wd->frequency);
+	zfCoreSetFrequency(dev, wd->frequency);
 
 #if ZM_PCI_LOOP_BACK == 1
-    zfwWriteReg(dev, ZM_REG_PCI_CONTROL, 6);
+	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;
+	/* 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
+	/* zfiWlanSetFrequency(dev, 5260000, TRUE); */
+	/* zfiWlanSetAniMode(dev , 1); // Enable ANI */
 
-    /* Trgger Rx DMA */
-    zfHpStartRecv(dev);
+	/* Trgger Rx DMA */
+	zfHpStartRecv(dev);
 
-    zm_debug_msg0("end");
+	zm_debug_msg0("end");
 
-    return 0;
+	return 0;
 }
 
 /* WLAN hardware will be shutdown and all resource will be release */
-u16_t zfiWlanClose(zdev_t* dev)
+u16_t zfiWlanClose(zdev_t *dev)
 {
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    zm_msg0_init(ZM_LV_0, "enter");
+	zm_msg0_init(ZM_LV_0, "enter");
 
-    wd->state = ZM_WLAN_STATE_CLOSEDED;
+	wd->state = ZM_WLAN_STATE_CLOSEDED;
 
-    //zfiWlanDisable(dev, 1);
-    zfWlanReset(dev);
+	/* zfiWlanDisable(dev, 1); */
+	zfWlanReset(dev);
 
-    zfHpStopRecv(dev);
+	zfHpStopRecv(dev);
 
-    /* Disable MAC */
-    /* Disable PHY */
-    /* Disable RF */
+	/* Disable MAC */
+	/* Disable PHY */
+	/* Disable RF */
 
-    zfHpRelease(dev);
+	zfHpRelease(dev);
 
-    zfQueueDestroy(dev, wd->ap.uapsdQ);
-    zfQueueDestroy(dev, wd->sta.uapsdQ);
+	zfQueueDestroy(dev, wd->ap.uapsdQ);
+	zfQueueDestroy(dev, wd->sta.uapsdQ);
 
-    zfBssInfoDestroy(dev);
+	zfBssInfoDestroy(dev);
 
 #ifdef ZM_ENABLE_AGGREGATION
-    /* add by honda */
-    zfAggRxFreeBuf(dev, 1);  //1 for release structure memory
-    /* end of add by honda */
+	/* add by honda */
+	zfAggRxFreeBuf(dev, 1);  /* 1 for release structure memory */
+	/* end of add by honda */
 #endif
 
-    zm_msg0_init(ZM_LV_0, "exit");
+	zm_msg0_init(ZM_LV_0, "exit");
 
-    return 0;
+	return 0;
 }
 
-void zfGetWrapperSetting(zdev_t* dev)
+void zfGetWrapperSetting(zdev_t *dev)
 {
-    u8_t   bPassive;
-    u16_t vapId = 0;
+	u8_t bPassive;
+	u16_t vapId = 0;
 
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    zmw_declare_for_critical_section();
+	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) );
-    }
+	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;
-            }
-        }
-    }
+	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 */
+	/* 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);
+	/* 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)
+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
-        {
+	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;
+			/* 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;
+			/* 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 )
-    {
+		}
+
+		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)
+		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->CurrentRxRateKbps = 270000;
+	} else {
+		wd->CurrentTxRateKbps = 54000;
+		wd->CurrentRxRateKbps = 54000;
+	}
 
-    wd->state = ZM_WLAN_STATE_ENABLED;
+	wd->state = ZM_WLAN_STATE_ENABLED;
 
-    return 0;
+	return 0;
 }
 
 /* Enable/disable Wlan operation */
-u16_t zfiWlanEnable(zdev_t* dev)
+u16_t zfiWlanEnable(zdev_t *dev)
 {
-    u16_t ret;
+	u16_t ret;
 
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    zm_msg0_mm(ZM_LV_1, "Enable Wlan");
+	zm_msg0_mm(ZM_LV_1, "Enable Wlan");
 
-    zfGetWrapperSetting(dev);
+	zfGetWrapperSetting(dev);
 
-    zfZeroMemory((u8_t*) &wd->trafTally, sizeof(struct zsTrafTally));
+	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;
+	}
 
-    // 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);
 
-    zfFlushVtxq(dev);
-    if ((wd->queueFlushed & 0x10) != 0)
-    {
-        zfHpUsbReset(dev);
-    }
-    ret = zfWlanEnable(dev);
+	ret = zfWlanEnable(dev);
 
-    return ret;
+	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)
+   after setting group key, it shouldn't clear KeyCache.
+*/
+u16_t zfiWlanDisable(zdev_t *dev, u8_t ResetKeyCache)
 {
-    u16_t  i;
-    u8_t isConnected;
+	u16_t  i;
+	u8_t isConnected;
 
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
 #ifdef ZM_ENABLE_IBSS_WPA2PSK
-    zmw_declare_for_critical_section();
+	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);
-        }
+	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);
+		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;
-}
+		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--;
+	}
 
-u16_t zfiWlanSuspend(zdev_t* dev)
-{
-    zmw_get_wlan_dev(dev);
-    zmw_declare_for_critical_section();
+	/* 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);
 
-    // 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);
+	/* 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;
+}
 
-    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 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;
+	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;
 }
 
 /************************************************************************/
@@ -1057,235 +979,227 @@ u16_t zfiWlanResume(zdev_t* dev, u8_t doReconn)
 /*      Stephen Chen        Atheros Communications, INC.    2007.1      */
 /*                                                                      */
 /************************************************************************/
-void zfiWlanFlushAllQueuedBuffers(zdev_t* dev)
+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);
+	/* 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 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;
+	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);
+	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;
+	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);
+	ret = zfScanMgrScanStart(dev, ZM_SCAN_MGR_SCAN_EXTERNAL);
 
-    zm_debug_msg1("ret = ", ret);
+	zm_debug_msg1("ret = ", ret);
 
-    return 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 */
+/* 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;
+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*/
-    };
+{
+	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;
-    }
+	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)
+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;
-        }
-    }
+	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};
+			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};
+			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};
+			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];
@@ -1294,568 +1208,558 @@ extern u32_t zcIndextoRateN20S[16];
 extern u32_t zcIndextoRateN40L[16];
 extern u32_t zcIndextoRateN40S[16];
 
-u32_t zfiWlanQueryRxRate(zdev_t* dev)
+u32_t zfiWlanQueryRxRate(zdev_t *dev)
 {
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    wd->CurrentRxRateUpdated = 0;
-    return wd->CurrentRxRateKbps;
+	wd->CurrentRxRateUpdated = 0;
+	return wd->CurrentRxRateKbps;
 }
 
-u32_t zfUpdateRxRate(zdev_t* dev)
+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;
+	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)
+u16_t zfiWlanGetStatistics(zdev_t *dev)
 {
-    /* Return link statistics */
-    return 0;
+	/* Return link statistics */
+	return 0;
 }
 
-u16_t zfiWlanReset(zdev_t* dev)
+u16_t zfiWlanReset(zdev_t *dev)
 {
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    wd->state = ZM_WLAN_STATE_DISABLED;
+	wd->state = ZM_WLAN_STATE_DISABLED;
 
-    return zfWlanReset(dev);
+	return zfWlanReset(dev);
 }
 
 /* Reset WLAN */
-u16_t zfWlanReset(zdev_t* dev)
+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;
+	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;
+	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;
+	/* 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)
+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;
+	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. */
+/* 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)
+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;
+	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)
+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;
+	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)
+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;
+	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)
+void zfiWlanDbg(zdev_t *dev, u8_t setting)
 {
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    wd->enableHALDbgInfo = setting;
+	wd->enableHALDbgInfo = setting;
 }
 
 /* FB50 in OS XP, RD private test code */
-void zfiWlanSetRxPacketDump(zdev_t* dev, u32_t setting)
+void zfiWlanSetRxPacketDump(zdev_t *dev, u32_t setting)
 {
-    zmw_get_wlan_dev(dev);
-    if (setting)
-    {
-        wd->rxPacketDump = 1;   /* enable */
-    }
-    else
-    {
-        wd->rxPacketDump = 0;   /* disable */
-    }
+	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)
+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;
+	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);
+	zmw_leave_critical_section(dev);
 }
 
 /* FB50 in OS XP, RD private test code */
-void zfiWlanQueryTally(zdev_t* dev, struct zsCommTally *tally)
+void zfiWlanQueryTally(zdev_t *dev, struct zsCommTally *tally)
 {
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    zmw_declare_for_critical_section();
+	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);
+	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)
+
+void zfiWlanQueryTrafTally(zdev_t *dev, struct zsTrafTally *tally)
 {
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    zmw_declare_for_critical_section();
+	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);
+	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)
+void zfiWlanQueryMonHalRxInfo(zdev_t *dev, struct zsMonHalRxInfo *monHalRxInfo)
 {
-    zfHpQueryMonHalRxInfo(dev, (u8_t *)monHalRxInfo);
+	zfHpQueryMonHalRxInfo(dev, (u8_t *)monHalRxInfo);
 }
 
 /* parse the modeMDKEnable to DrvCore */
-void zfiDKEnable(zdev_t* dev, u32_t enable)
+void zfiDKEnable(zdev_t *dev, u32_t enable)
 {
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    wd->modeMDKEnable = enable;
-    zm_debug_msg1("modeMDKEnable = ", wd->modeMDKEnable);
+	wd->modeMDKEnable = enable;
+	zm_debug_msg1("modeMDKEnable = ", wd->modeMDKEnable);
 }
 
 /* airoPeek */
-u32_t zfiWlanQueryPacketTypePromiscuous(zdev_t* dev)
+u32_t zfiWlanQueryPacketTypePromiscuous(zdev_t *dev)
 {
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    return wd->swSniffer;
+	return wd->swSniffer;
 }
 
 /* airoPeek */
-void zfiWlanSetPacketTypePromiscuous(zdev_t* dev, u32_t setValue)
+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");
-	   }
+	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)
+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);
-    }
+	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)
+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);
+	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)
+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;
-    }
+	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)
+void zfiCheckRifs(zdev_t *dev)
 {
-    zmw_get_wlan_dev(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);
-    }
+	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)
+void zfiSetReorder(zdev_t *dev, u16_t value)
 {
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    wd->reorder = value;
+	wd->reorder = value;
 }
 
-void zfiSetSeqDebug(zdev_t* dev, u16_t value)
+void zfiSetSeqDebug(zdev_t *dev, u16_t value)
 {
-    zmw_get_wlan_dev(dev);
+	zmw_get_wlan_dev(dev);
 
-    wd->seq_debug = value;
+	wd->seq_debug = value;
 }