2009-03-21 18:59:47

by Dragoslav Zaric

Subject: [PATCH 2.6.29-rc8] drivers/staging/otus/80211core/ccmd.c: Fix Coding Style

--- drivers/staging/otus/80211core/ccmd.c 2009-03-10 01:01:36.000000000 +0100
+++ drivers/staging/otus/80211core/ccmd_cs_fix.c 2009-03-21 19:47:17.000000000 +0100
@@ -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);
-
- zm_debug_msg0("start");
-
- devSize = sizeof(struct zsWlanDev);
- /* Zeroize zsWlanDev struct */
- zfZeroMemory((u8_t*)wd, (u16_t)devSize);
+ /* u16_t ret;
+ u32_t i;
+ u8_t* ch;
+ u8_t bPassive;
+ */
+ u32_t devSize;
+ struct zfCbUsbFuncTbl cbUsbFuncTbl;
+ zmw_get_wlan_dev(dev);
+
+ zm_debug_msg0("start");
+
+ devSize = sizeof(struct zsWlanDev);
+ /* Zeroize zsWlanDev struct */
+ zfZeroMemory((u8_t *)wd, (u16_t)devSize);

#ifdef ZM_ENABLE_AGGREGATION
- zfAggInit(dev);
+ zfAggInit(dev);
#endif

- zfCwmInit(dev);
+ 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;
+ 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;
-
- /* set default to bypass all multicast packet for linux, window XP would set 0 by wrapper initialization */
+ wd->sta.passiveScanTickPerChannel = ZM_TIME_PASSIVE_SCAN/ZM_MS_PER_TICK;
+ wd->sta.bAutoReconnect = TRUE;
+ wd->sta.dropUnencryptedPkts = FALSE;
+
+ /* set default to bypass all multicast packet for linux,
+ * window XP would set 0 by wrapper initialization
+ */
wd->sta.bAllMulticast = 1;

- /* Initial the RIFS Status / RIFS-like frame count / RIFS count */
- wd->sta.rifsState = ZM_RIFS_STATE_DETECTING;
- wd->sta.rifsLikeFrameCnt = 0;
- wd->sta.rifsCount = 0;
-
- wd->sta.osRxFilter = 0;
- wd->sta.bSafeMode = 0;
-
- //Common
- zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_DISCONNECT);
- wd->beaconInterval = 100;
- wd->rtsThreshold = 2346;
- wd->fragThreshold = 32767;
- wd->wlanMode = ZM_MODE_INFRASTRUCTURE;
- wd->txMCS = 0xff; //AUTO
- wd->dtim = 1;
- //wd->txMT = 1; //OFDM
- wd->tick = 1;
- wd->maxTxPower2 = 0xff;
- wd->maxTxPower5 = 0xff;
- wd->supportMode = 0xffffffff;
- wd->ws.adhocMode = ZM_ADHOCBAND_G;
- wd->ws.autoSetFrequency = 0xff;
-
- //AP mode
- //wd->bgMode = wd->ws.bgMode;
- wd->ap.ssidLen[0] = 6;
- wd->ap.ssid[0][0] = 'Z';
- wd->ap.ssid[0][1] = 'D';
- wd->ap.ssid[0][2] = '1';
- wd->ap.ssid[0][3] = '2';
- wd->ap.ssid[0][4] = '2';
- wd->ap.ssid[0][5] = '1';
-
- // Init the country iso name as NA
- wd->ws.countryIsoName[0] = 0;
- wd->ws.countryIsoName[1] = 0;
- wd->ws.countryIsoName[2] = '\0';
+ /* 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);
-
- //zfHpInit(dev, wd->frequency);
-
- /* MAC address */
- //zfHpSetMacAddress(dev, wd->macAddr, 0);
- zfHpGetMacAddress(dev);
+ /* WME settings */
+ wd->ws.staWmeEnabled = 1; /* Enable WME by default */
+#define ZM_UAPSD_Q_SIZE 32 /* 2^N */
+ wd->ap.uapsdQ = zfQueueCreate(dev, ZM_UAPSD_Q_SIZE);
+ zm_assert(wd->ap.uapsdQ != NULL);
+ wd->sta.uapsdQ = zfQueueCreate(dev, ZM_UAPSD_Q_SIZE);
+ zm_assert(wd->sta.uapsdQ != NULL);
+
+ /* zfHpInit(dev, wd->frequency); */
+
+ /* MAC address */
+ /* zfHpSetMacAddress(dev, wd->macAddr, 0); */
+ zfHpGetMacAddress(dev);

- zfCoreSetFrequency(dev, wd->frequency);
+ 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);
+ zmw_enter_critical_section(dev);

- wd->wlanMode = wd->ws.wlanMode;
+ 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;
- }
- }
- }
+ /* 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);
-}
-
-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
- {
+ /* set preamble type */
+ switch (wd->ws.preambleType) {
+ case ZM_PREAMBLE_TYPE_AUTO:
+ case ZM_PREAMBLE_TYPE_SHORT:
+ case ZM_PREAMBLE_TYPE_LONG:
+ wd->preambleType = wd->ws.preambleType;
+ break;
+ default:
+ wd->preambleType = ZM_PREAMBLE_TYPE_SHORT;
+ break;
+ }
+ wd->ws.preambleType = 0;
+
+ if (wd->wlanMode == ZM_MODE_AP) {
+ vapId = zfwGetVapId(dev);
+
+ if (vapId == 0xffff) {
+ wd->ap.authAlgo[0] = wd->ws.authMode;
+ wd->ap.encryMode[0] = wd->ws.encryMode;
+ } else {
+ wd->ap.authAlgo[vapId + 1] = wd->ws.authMode;
+ wd->ap.encryMode[vapId + 1] = wd->ws.encryMode;
+ }
+ wd->ws.authMode = 0;
+ wd->ws.encryMode = ZM_NO_WEP;
+
+ /* Get beaconInterval from WrapperSetting */
+ if ((wd->ws.beaconInterval >= 20) &&
+ (wd->ws.beaconInterval <= 1000))
+ wd->beaconInterval = wd->ws.beaconInterval;
+ else
+ wd->beaconInterval = 100; /* 100ms */
+
+ if (wd->ws.dtim > 0)
+ wd->dtim = wd->ws.dtim;
+ else
+ wd->dtim = 1;
+
+
+ wd->ap.qosMode = wd->ws.apWmeEnabled & 0x1;
+ wd->ap.uapsdEnabled = (wd->ws.apWmeEnabled & 0x2) >> 1;
+ } else {
+ wd->sta.authMode = wd->ws.authMode;
+ wd->sta.currentAuthMode = wd->ws.authMode;
+ wd->sta.wepStatus = wd->ws.wepStatus;
+
+ if (wd->ws.beaconInterval)
+ wd->beaconInterval = wd->ws.beaconInterval;
+ else
+ wd->beaconInterval = 0x64;
+
+ if (wd->wlanMode == ZM_MODE_IBSS) {
+ /* 1. Set default channel 6 (2437MHz) */
+ /* wd->frequency = 2437; */
+
+ /* 2. Otus support 802.11g Mode */
+ if ((wd->ws.adhocMode == ZM_ADHOCBAND_G) ||
+ (wd->ws.adhocMode == ZM_ADHOCBAND_BG) ||
+ (wd->ws.adhocMode == ZM_ADHOCBAND_ABG))
+ wd->wfc.bIbssGMode = 1;
+ else
+ wd->wfc.bIbssGMode = 0;
+
+ /* 3. set short preamble */
+ /* wd->sta.preambleType = ZM_PREAMBLE_TYPE_SHORT; */
+ }
+
+ /* set ATIM window */
+ if (wd->ws.atimWindow)
+ wd->sta.atimWindow = wd->ws.atimWindow;
+ else {
+ /* wd->sta.atimWindow = 0x0a; */
+ wd->sta.atimWindow = 0;
+ }
+
+ /* wd->sta.connectingHiddenAP = 1;
+ wd->ws.connectingHiddenAP;
+ */
+ wd->sta.dropUnencryptedPkts = wd->ws.dropUnencryptedPkts;
+ wd->sta.ibssJoinOnly = wd->ws.ibssJoinOnly;
+
+ if (wd->ws.bDesiredBssid) {
+ zfMemoryCopy(wd->sta.desiredBssid,
+ wd->ws.desiredBssid, 6);
+ wd->sta.bDesiredBssid = TRUE;
+ wd->ws.bDesiredBssid = FALSE;
+ } else
+ wd->sta.bDesiredBssid = FALSE;
+
+ /* check ssid */
+ if (wd->ws.ssidLen != 0) {
+ if ((!zfMemoryIsEqual(wd->ws.ssid, wd->sta.ssid,
+ wd->sta.ssidLen)) ||
+ (wd->ws.ssidLen != wd->sta.ssidLen) ||
+ (wd->sta.authMode == ZM_AUTH_MODE_WPA) ||
+ (wd->sta.authMode == ZM_AUTH_MODE_WPAPSK) ||
+ (wd->ws.staWmeQosInfo != 0)) {
+ /* if u-APSD test(set QosInfo), clear
+ connectByReasso to do association
+ (not reassociation)
+ */
+ wd->sta.connectByReasso = FALSE;
+ wd->sta.failCntOfReasso = 0;
+ wd->sta.pmkidInfo.bssidCount = 0;
+
+ wd->sta.ssidLen = wd->ws.ssidLen;
+ zfMemoryCopy(wd->sta.ssid, wd->ws.ssid,
+ wd->sta.ssidLen);
+
+ if (wd->sta.ssidLen < 32)
+ wd->sta.ssid[wd->sta.ssidLen] = 0;
+ }
+ } else {
+ /* ANY BSS */
+ wd->sta.ssid[0] = 0;
+ wd->sta.ssidLen = 0;
+ }
+
+ wd->sta.wmeEnabled = wd->ws.staWmeEnabled;
+ wd->sta.wmeQosInfo = wd->ws.staWmeQosInfo;
+
+ }
+
+ zmw_leave_critical_section(dev);
+}
+
+u16_t zfWlanEnable(zdev_t *dev)
+{
+ u8_t bssid[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+ u16_t i;
+
+ zmw_get_wlan_dev(dev);
+
+ zmw_declare_for_critical_section();
+
+ if (wd->wlanMode == ZM_MODE_UNKNOWN) {
+ zm_debug_msg0("Unknown Mode...Skip...");
+ return 0;
+ }
+
+ if (wd->wlanMode == ZM_MODE_AP) {
+ u16_t vapId;
+
+ vapId = zfwGetVapId(dev);
+
+ if (vapId == 0xffff) {
+ /* AP mode */
+ zfApInitStaTbl(dev);
+
+ /* AP default parameters */
+ wd->bRate = 0xf;
+ wd->gRate = 0xff;
+ wd->bRateBasic = 0xf;
+ wd->gRateBasic = 0x0;
+ /* wd->beaconInterval = 100; */
+ wd->ap.apBitmap = 1;
+ wd->ap.beaconCounter = 0;
+ /* wd->ap.vapNumber = 1; //mark by ygwei for Vap */
+
+ wd->ap.hideSsid[0] = 0;
+ wd->ap.staAgingTimeSec = 10*60;
+ wd->ap.staProbingTimeSec = 60;
+
+ for (i = 0; i < ZM_MAX_AP_SUPPORT; i++)
+ wd->ap.bcmcHead[i] = wd->ap.bcmcTail[i] = 0;
+
+ /* wd->ap.uniHead = wd->ap.uniTail = 0; */
+
+ /* load AP parameters */
+ wd->bRateBasic = wd->ws.bRateBasic;
+ wd->gRateBasic = wd->ws.gRateBasic;
+ wd->bgMode = wd->ws.bgMode;
+ if ((wd->ws.ssidLen <= 32) && (wd->ws.ssidLen != 0)) {
+ wd->ap.ssidLen[0] = wd->ws.ssidLen;
+ for (i = 0; i < wd->ws.ssidLen; i++)
+ wd->ap.ssid[0][i] = wd->ws.ssid[i];
+ wd->ws.ssidLen = 0; /* Reset Wrapper Variable */
+ }
+
+ if (wd->ap.encryMode[0] == 0)
+ wd->ap.capab[0] = 0x001;
+ else
+ wd->ap.capab[0] = 0x011;
+ /* set Short Slot Time bit if not 11b */
+ if (wd->ap.wlanType[0] != ZM_WLAN_TYPE_PURE_B)
+ wd->ap.capab[0] |= 0x400;
+
+ /* wd->ap.vapNumber = 1; //mark by ygwei for Vap Test */
+ } else {
#if 0
- /* VAP Test Code */
- wd->ap.apBitmap = 0x3;
- wd->ap.capab[1] = 0x401;
- wd->ap.ssidLen[1] = 4;
- wd->ap.ssid[1][0] = 'v';
- wd->ap.ssid[1][1] = 'a';
- wd->ap.ssid[1][2] = 'p';
- wd->ap.ssid[1][3] = '1';
- wd->ap.authAlgo[1] = wd->ws.authMode;
- wd->ap.encryMode[1] = wd->ws.encryMode;
- wd->ap.vapNumber = 2;
+ /* 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));
+ /* 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;
- }
+ 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;
+ 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;
+ /* Need to be modified when VAP is used */
+ /* wd->ap.vapNumber = 2; */
#endif
- }
+ }

- wd->ap.vapNumber++;
+ wd->ap.vapNumber++;

- zfCoreSetFrequency(dev, wd->frequency);
+ zfCoreSetFrequency(dev, wd->frequency);

- zfInitMacApMode(dev);
+ 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 )
- {
+ /* 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;
+ wd->state = ZM_WLAN_STATE_DISABLED;
+
+ zm_msg0_mm(ZM_LV_1, "Disable Wlan");

- zm_msg0_mm(ZM_LV_1, "Disable Wlan");
+ if (wd->wlanMode != ZM_MODE_AP) {
+ isConnected = zfStaIsConnected(dev);

- 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);
- }
+ 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;
+ wd->sta.wpaState = ZM_STA_WPA_STATE_INIT;

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

- /* reset connectState to None */
- wd->sta.connectState = ZM_STA_CONN_STATE_NONE;
+ /* 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--;
+ }

- /* reset leap enable variable */
- wd->sta.leapEnabled = 0;
-
- /* Disable the RIFS Status / RIFS-like frame count / RIFS count */
- if( wd->sta.rifsState == ZM_RIFS_STATE_DETECTED )
- zfHpDisableRifs(dev);
- wd->sta.rifsState = ZM_RIFS_STATE_DETECTING;
- wd->sta.rifsLikeFrameCnt = 0;
- wd->sta.rifsCount = 0;
-
- wd->sta.osRxFilter = 0;
- wd->sta.bSafeMode = 0;
-
- zfChangeAdapterState(dev, ZM_STA_STATE_DISCONNECT);
- if (ResetKeyCache)
- zfHpResetKeyCache(dev);
-
- if (isConnected)
- {
- if (wd->zfcbConnectNotify != NULL)
- {
- wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECTION_DISABLED, wd->sta.bssid);
- }
- }
- else
- {
- if (wd->zfcbConnectNotify != NULL)
- {
- wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_DISABLED, wd->sta.bssid);
- }
- }
- }
- else //if (wd->wlanMode == ZM_MODE_AP)
- {
- for (i=0; i<ZM_MAX_STA_SUPPORT; i++)
- {
- /* send deauthentication frame */
- if (wd->ap.staTable[i].valid == 1)
- {
- /* Reason : Sending station is leaving */
- zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH,
- wd->ap.staTable[i].addr, 3, 0, 0);
- }
- }
-
- if (ResetKeyCache)
- zfHpResetKeyCache(dev);
-
- wd->ap.vapNumber--;
- }
-
- /* stop beacon */
- zfHpDisableBeacon(dev);
-
- /* Flush VTxQ and MmQ */
- zfFlushVtxq(dev);
- /* Flush AP PS queues */
- zfApFlushBufferedPsFrame(dev);
- /* Free buffer in defragment list*/
- zfAgingDefragList(dev, 1);
-
- #ifdef ZM_ENABLE_AGGREGATION
- /* add by honda */
- zfAggRxFreeBuf(dev, 0); //1 for release structure memory
- /* end of add by honda */
- #endif
-
- // Clear the information for the peer stations of IBSS or AP of Station mode
- zfZeroMemory((u8_t*)wd->sta.oppositeInfo, sizeof(struct zsOppositeInfo) * ZM_MAX_OPPOSITE_COUNT);
-
- /* Turn off Software WEP/TKIP */
- if (wd->sta.SWEncryptEnable != 0)
- {
- zm_debug_msg0("Disable software encryption");
- zfStaDisableSWEncryption(dev);
- }
-
- /* Improve WEP/TKIP performace with HT AP, detail information please look bug#32495 */
- //zfHpSetTTSIFSTime(dev, 0x8);
-
- return 0;
-}
-
-u16_t zfiWlanSuspend(zdev_t* dev)
-{
- zmw_get_wlan_dev(dev);
- zmw_declare_for_critical_section();
-
- // Change the HAL state to init so that any packet can't be transmitted between
- // resume & HAL reinit. This would cause the chip hang issue in OTUS.
- zmw_enter_critical_section(dev);
- wd->halState = ZM_HAL_STATE_INIT;
- zmw_leave_critical_section(dev);
-
- return 0;
-}
-
-u16_t zfiWlanResume(zdev_t* dev, u8_t doReconn)
-{
- u16_t ret;
- zmw_get_wlan_dev(dev);
- zmw_declare_for_critical_section();
-
- /* Redownload firmware, Reinit MAC,PHY,RF */
- zfHpReinit(dev, wd->frequency);
-
- //Set channel according to AP's configuration
- zfCoreSetFrequencyExV2(dev, wd->frequency, wd->BandWidth40,
- wd->ExtOffset, NULL, 1);
-
- zfHpSetMacAddress(dev, wd->macAddr, 0);
-
- /* Start Rx */
- zfHpStartRecv(dev);
-
- zfFlushVtxq(dev);
-
- if ( wd->wlanMode != ZM_MODE_INFRASTRUCTURE &&
- wd->wlanMode != ZM_MODE_IBSS )
- {
- return 1;
- }
-
- zm_msg0_mm(ZM_LV_1, "Resume Wlan");
- if ( (zfStaIsConnected(dev)) || (zfStaIsConnecting(dev)) )
- {
- if (doReconn == 1)
- {
- zm_msg0_mm(ZM_LV_1, "Re-connect...");
- zmw_enter_critical_section(dev);
- wd->sta.connectByReasso = FALSE;
- zmw_leave_critical_section(dev);
-
- zfWlanEnable(dev);
- }
- else if (doReconn == 0)
- {
- zfHpSetRollCallTable(dev);
- }
- }
+ /* stop beacon */
+ zfHpDisableBeacon(dev);

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

- return ret;
+#ifdef ZM_ENABLE_AGGREGATION
+ /* add by honda */
+ zfAggRxFreeBuf(dev, 0); /* 1 for release structure memory */
+ /* end of add by honda */
+#endif
+
+ /* Clear the information for the peer stations
+ of IBSS or AP of Station mode
+ */
+ zfZeroMemory((u8_t *)wd->sta.oppositeInfo,
+ sizeof(struct zsOppositeInfo) * ZM_MAX_OPPOSITE_COUNT);
+
+ /* Turn off Software WEP/TKIP */
+ if (wd->sta.SWEncryptEnable != 0) {
+ zm_debug_msg0("Disable software encryption");
+ zfStaDisableSWEncryption(dev);
+ }
+
+ /* Improve WEP/TKIP performace with HT AP,
+ detail information please look bug#32495 */
+ /* zfHpSetTTSIFSTime(dev, 0x8); */
+
+ return 0;
+}
+
+u16_t zfiWlanSuspend(zdev_t *dev)
+{
+ zmw_get_wlan_dev(dev);
+ zmw_declare_for_critical_section();
+
+ /* Change the HAL state to init so that any packet
+ can't be transmitted between resume & HAL reinit.
+ This would cause the chip hang issue in OTUS.
+ */
+ zmw_enter_critical_section(dev);
+ wd->halState = ZM_HAL_STATE_INIT;
+ zmw_leave_critical_section(dev);
+
+ return 0;
+}
+
+u16_t zfiWlanResume(zdev_t *dev, u8_t doReconn)
+{
+ u16_t ret;
+ zmw_get_wlan_dev(dev);
+ zmw_declare_for_critical_section();
+
+ /* Redownload firmware, Reinit MAC,PHY,RF */
+ zfHpReinit(dev, wd->frequency);
+
+ /* Set channel according to AP's configuration */
+ zfCoreSetFrequencyExV2(dev, wd->frequency, wd->BandWidth40,
+ wd->ExtOffset, NULL, 1);
+
+ zfHpSetMacAddress(dev, wd->macAddr, 0);
+
+ /* Start Rx */
+ zfHpStartRecv(dev);
+
+ zfFlushVtxq(dev);
+
+ if (wd->wlanMode != ZM_MODE_INFRASTRUCTURE &&
+ wd->wlanMode != ZM_MODE_IBSS)
+ return 1;
+
+ zm_msg0_mm(ZM_LV_1, "Resume Wlan");
+ if ((zfStaIsConnected(dev)) || (zfStaIsConnecting(dev))) {
+ if (doReconn == 1) {
+ zm_msg0_mm(ZM_LV_1, "Re-connect...");
+ zmw_enter_critical_section(dev);
+ wd->sta.connectByReasso = FALSE;
+ zmw_leave_critical_section(dev);
+
+ zfWlanEnable(dev);
+ } else if (doReconn == 0)
+ zfHpSetRollCallTable(dev);
+ }
+
+ ret = 0;
+
+ return ret;
}

/************************************************************************/
@@ -1057,235 +979,227 @@ u16_t zfiWlanResume(zdev_t* dev, u8_t do
/* 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);
+ u16_t ret = 1;
+ zmw_get_wlan_dev(dev);

- zm_debug_msg0("");
+ zm_debug_msg0("");

- zmw_declare_for_critical_section();
+ 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_enter_critical_section(dev);

- zmw_leave_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
+ }

- return ret;
+ 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;
- }
+u16_t zfiWlanSetTxRate(zdev_t *dev, u16_t rate)
+{
+ /* jhlee HT 0 */
+ zmw_get_wlan_dev(dev);

- return ZM_ERR_INVALID_TX_RATE;
+ 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;
- }
-}
-
-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;
- }
- }
+{
+ 1000, 2000, 5500, 11000, /* 1M, 2M, 5M, 11M , 0 1 2 3 */
+ 6000, 9000, 12000, 18000, /* 6M 9M 12M 18M , 4 5 6 7 */
+ 24000, 36000, 48000, 54000, /* 24M 36M 48M 54M , 8 9 10 11 */
+ 6500, 13000, 19500, 26000, /* MCS0 MCS1 MCS2 MCS3 , 12 13 14 15 */
+ 39000, 52000, 58500, 65000, /* MCS4 MCS5 MCS6 MCS7 , 16 17 18 19 */
+ 13000, 26000, 39000, 52000, /* MCS8 MCS9 MCS10 MCS11 , 20 21 22 23 */
+ 78000, 104000, 117000, 130000, /* MCS12 MCS13 MCS14 MCS15, 24 25 26 27*/
+ 130000, 144400, 72200 /* MCS14SG, MCS15SG, MSG7SG , 28 29 30 */
+};
+
+u32_t zfiWlanQueryTxRate(zdev_t *dev)
+{
+ u8_t rateId = 0xff;
+ zmw_get_wlan_dev(dev);
+ zmw_declare_for_critical_section();
+
+ /* If Tx rate had not been trained, return maximum Tx rate instead */
+ if ((wd->wlanMode == ZM_MODE_INFRASTRUCTURE) &&
+ (zfStaIsConnected(dev))) {
+ zmw_enter_critical_section(dev);
+ /* Not in fixed rate mode */
+ if (wd->txMCS == 0xff) {
+ if ((wd->sta.oppositeInfo[0].rcCell.flag &
+ ZM_RC_TRAINED_BIT) == 0)
+ rateId = wd->sta.oppositeInfo[0].rcCell. \
+ operationRateSet[wd->sta.oppositeInfo[0]. \
+ rcCell.operationRateCount-1];
+ else
+ rateId = wd->sta.oppositeInfo[0].rcCell. \
+ operationRateSet[wd->sta.oppositeInfo[0]. \
+ rcCell.currentRateIndex];
+ }
+ zmw_leave_critical_section(dev);
+ }
+
+ if (rateId != 0xff) {
+ if (wd->sta.htCtrlBandwidth)
+ return zcRateIdToKbps40M[rateId];
+ else
+ return zcRateIdToKbps20M[rateId];
+ } else
+ return wd->CurrentTxRateKbps;
+}
+
+void zfWlanUpdateRxRate(zdev_t *dev, struct zsAdditionInfo *addInfo)
+{
+ u32_t rxRateKbps;
+ zmw_get_wlan_dev(dev);
+ /* zm_msg1_mm(ZM_LV_0, "addInfo->Tail.Data.RxMacStatus =",
+ * addInfo->Tail.Data.RxMacStatus & 0x03);
+ */
+
+ /* b5~b4: MPDU indication. */
+ /* 00: Single MPDU. */
+ /* 10: First MPDU of A-MPDU. */
+ /* 11: Middle MPDU of A-MPDU. */
+ /* 01: Last MPDU of A-MPDU. */
+ /* Only First MPDU and Single MPDU have PLCP header */
+ /* First MPDU : (mpduInd & 0x30) == 0x00 */
+ /* Single MPDU : (mpduInd & 0x30) == 0x20 */
+ if ((addInfo->Tail.Data.RxMacStatus & 0x10) == 0) {
+ /* Modulation type */
+ wd->modulationType = addInfo->Tail.Data.RxMacStatus & 0x03;
+ switch (wd->modulationType) {
+ /* CCK mode */
+ case 0x0:
+ wd->rateField = addInfo->PlcpHeader[0] & 0xff;
+ wd->rxInfo = 0;
+ break;
+ /* Legacy-OFDM mode */
+ case 0x1:
+ wd->rateField = addInfo->PlcpHeader[0] & 0x0f;
+ wd->rxInfo = 0;
+ break;
+ /* HT-OFDM mode */
+ case 0x2:
+ wd->rateField = addInfo->PlcpHeader[3];
+ wd->rxInfo = addInfo->PlcpHeader[6];
+ break;
+ default:
+ break;
+ }
+
+ rxRateKbps = zfUpdateRxRate(dev);
+ if (wd->CurrentRxRateUpdated == 1) {
+ if (rxRateKbps > wd->CurrentRxRateKbps)
+ wd->CurrentRxRateKbps = rxRateKbps;
+ } else {
+ wd->CurrentRxRateKbps = rxRateKbps;
+ wd->CurrentRxRateUpdated = 1;
+ }
+ }
}
+
#if 0
u16_t zcIndextoRateBG[16] = {1000, 2000, 5500, 11000, 0, 0, 0, 0, 48000,
- 24000, 12000, 6000, 54000, 36000, 18000, 9000};
+ 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)
-{
- 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);
+u32_t zfUpdateRxRate(zdev_t *dev)
+{
+ u8_t mcs, bandwidth;
+ u32_t rxRateKbps = 130000;
+ zmw_get_wlan_dev(dev);
+
+ switch (wd->modulationType) {
+ /* CCK mode */
+ case 0x0:
+ switch (wd->rateField) {
+ case 0x0a:
+ rxRateKbps = 1000;
+ break;
+ case 0x14:
+ rxRateKbps = 2000;
+
+ case 0x37:
+ rxRateKbps = 5500;
+ break;
+ case 0x6e:
+ rxRateKbps = 11000;
+ break;
+ default:
+ break;
+ }
+ break;
+ /* Legacy-OFDM mode */
+ case 0x1:
+ if (wd->rateField <= 15)
+ rxRateKbps = zcIndextoRateBG[wd->rateField];
+ break;
+ /* HT-OFDM mode */
+ case 0x2:
+ mcs = wd->rateField & 0x7F;
+ bandwidth = wd->rateField & 0x80;
+ if (mcs <= 15) {
+ if (bandwidth != 0) {
+ if ((wd->rxInfo & 0x80) != 0) {
+ /* Short GI 40 MHz MIMO Rate */
+ rxRateKbps = zcIndextoRateN40S[mcs];
+ } else {
+ /* Long GI 40 MHz MIMO Rate */
+ rxRateKbps = zcIndextoRateN40L[mcs];
+ }
+ } else {
+ if ((wd->rxInfo & 0x80) != 0) {
+ /* Short GI 20 MHz MIMO Rate */
+ rxRateKbps = zcIndextoRateN20S[mcs];
+ } else {
+ /* Long GI 20 MHz MIMO Rate */
+ rxRateKbps = zcIndextoRateN20L[mcs];
+ }
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ /* zm_msg1_mm(ZM_LV_0, "wd->CurrentRxRateKbps=",
+ wd->CurrentRxRateKbps);
+ */

- // ToDo: use bandwith field to define 40MB
- return rxRateKbps;
+ /* 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);
+ u8_t isConnected;
+ zmw_get_wlan_dev(dev);
+
+ zmw_declare_for_critical_section();
+
+ zm_debug_msg0("zfWlanReset");
+
+ isConnected = zfStaIsConnected(dev);

- zmw_declare_for_critical_section();
+ /* 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!"); */
+ }
+ }
+ }

- zm_debug_msg0("zfWlanReset");
+ 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);
+ }

- 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;
+ /* 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 connect timeout counter */
+ wd->sta.connectTimeoutCount = 0;

- /* reset leap enable variable */
- wd->sta.leapEnabled = 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 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);
+ zmw_get_wlan_dev(dev);
+
+ if (wd->wlanMode == ZM_MODE_AP) {
+ /* u16_t id; */

- 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);
- }
+ /*
+ * 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;
+ /* 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);
+ 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->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;
+ 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);
+ 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;
+ 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;
+ *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_get_wlan_dev(dev);

- zmw_declare_for_critical_section();
+ zmw_declare_for_critical_section();

- zmw_enter_critical_section(dev);
+ 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;
+ 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");
+ }
+}
+
+void zfiWlanSetXLinkMode(zdev_t *dev, u32_t setValue)
+{
+ zmw_get_wlan_dev(dev);
+
+ wd->XLinkMode = setValue;
+ if (setValue) {
+ /* write register for sniffer mode */
+ zfHpSetSnifferMode(dev, 1);
+ } else
+ zfHpSetSnifferMode(dev, 0);
+}
+
+extern void zfStaChannelManagement(zdev_t *dev, u8_t scan);
+
+void zfiSetChannelManagement(zdev_t *dev, u32_t setting)
+{
+ zmw_get_wlan_dev(dev);
+
+ switch (setting) {
+ case 1:
+ wd->sta.EnableHT = 1;
+ wd->BandWidth40 = 1;
+ wd->ExtOffset = 1;
+ break;
+ case 3:
+ wd->sta.EnableHT = 1;
+ wd->BandWidth40 = 1;
+ wd->ExtOffset = 3;
+ break;
+ case 0:
+ wd->sta.EnableHT = 1;
+ wd->BandWidth40 = 0;
+ wd->ExtOffset = 0;
+ break;
+ default:
+ wd->BandWidth40 = 0;
+ wd->ExtOffset = 0;
+ break;
+ }
+
+ zfCoreSetFrequencyEx(dev, wd->frequency, wd->BandWidth40,
+ wd->ExtOffset, NULL);
+}
+
+void zfiSetRifs(zdev_t *dev, u16_t setting)
{
- zmw_get_wlan_dev(dev);
+ zmw_get_wlan_dev(dev);

- wd->swSniffer = setValue;
- zm_msg1_mm(ZM_LV_0, "wd->swSniffer ", wd->swSniffer);
- if (setValue)
- {
- /* write register for sniffer mode */
- zfHpSetSnifferMode(dev, 1);
- zm_msg0_mm(ZM_LV_1, "enalbe sniffer mode");
- }
- else
- {
- zfHpSetSnifferMode(dev, 0);
- zm_msg0_mm(ZM_LV_0, "disalbe sniffer mode");
- }
-}
-
-void zfiWlanSetXLinkMode(zdev_t* dev, u32_t setValue)
-{
- zmw_get_wlan_dev(dev);
-
- wd->XLinkMode = setValue;
- if (setValue)
- {
- /* write register for sniffer mode */
- zfHpSetSnifferMode(dev, 1);
- }
- else
- {
- zfHpSetSnifferMode(dev, 0);
- }
-}
-
-extern void zfStaChannelManagement(zdev_t* dev, u8_t scan);
-void zfiSetChannelManagement(zdev_t* dev, u32_t setting)
-{
- zmw_get_wlan_dev(dev);
-
- switch (setting)
- {
- case 1:
- wd->sta.EnableHT = 1;
- wd->BandWidth40 = 1;
- wd->ExtOffset = 1;
- break;
- case 3:
- wd->sta.EnableHT = 1;
- wd->BandWidth40 = 1;
- wd->ExtOffset = 3;
- break;
- case 0:
- wd->sta.EnableHT = 1;
- wd->BandWidth40 = 0;
- wd->ExtOffset = 0;
- break;
- default:
- wd->BandWidth40 = 0;
- wd->ExtOffset = 0;
- break;
-
- }
- zfCoreSetFrequencyEx(dev, wd->frequency, wd->BandWidth40,
- wd->ExtOffset, NULL);
-}
-
-void zfiSetRifs(zdev_t* dev, u16_t setting)
-{
- zmw_get_wlan_dev(dev);
-
- wd->sta.ie.HtInfo.ChannelInfo |= ExtHtCap_RIFSMode;
- wd->sta.EnableHT = 1;
- switch (setting)
- {
- case 0:
- wd->sta.HT2040 = 0;
-// zfHpSetRifs(dev, 1, 0, (wd->sta.currentFrequency < 3000)? 1:0);
- break;
- case 1:
- wd->sta.HT2040 = 1;
-// zfHpSetRifs(dev, 1, 1, (wd->sta.currentFrequency < 3000)? 1:0);
- break;
- default:
- wd->sta.HT2040 = 0;
-// zfHpSetRifs(dev, 1, 0, (wd->sta.currentFrequency < 3000)? 1:0);
- break;
- }
-}
-
-void zfiCheckRifs(zdev_t* dev)
-{
- zmw_get_wlan_dev(dev);
-
- if(wd->sta.ie.HtInfo.ChannelInfo & ExtHtCap_RIFSMode)
- {
-// zfHpSetRifs(dev, wd->sta.EnableHT, wd->sta.HT2040, (wd->sta.currentFrequency < 3000)? 1:0);
- }
-}
-
-void zfiSetReorder(zdev_t* dev, u16_t value)
-{
- zmw_get_wlan_dev(dev);
+ wd->sta.ie.HtInfo.ChannelInfo |= ExtHtCap_RIFSMode;
+ wd->sta.EnableHT = 1;
+
+ switch (setting) {
+ case 0:
+ wd->sta.HT2040 = 0;
+ /* zfHpSetRifs(dev, 1, 0,
+ * (wd->sta.currentFrequency < 3000)? 1:0);
+ */
+ break;
+ case 1:
+ wd->sta.HT2040 = 1;
+ /* zfHpSetRifs(dev, 1, 1,
+ * (wd->sta.currentFrequency < 3000)? 1:0);
+ */
+ break;
+ default:
+ wd->sta.HT2040 = 0;
+ /* zfHpSetRifs(dev, 1, 0,
+ * (wd->sta.currentFrequency < 3000)? 1:0);
+ */
+ break;
+ }
+}
+
+void zfiCheckRifs(zdev_t *dev)
+{
+ zmw_get_wlan_dev(dev);
+
+ if (wd->sta.ie.HtInfo.ChannelInfo & ExtHtCap_RIFSMode)
+ ;
+ /* zfHpSetRifs(dev, wd->sta.EnableHT, wd->sta.HT2040,
+ * (wd->sta.currentFrequency < 3000)? 1:0);
+ */
+}
+
+void zfiSetReorder(zdev_t *dev, u16_t value)
+{
+ zmw_get_wlan_dev(dev);

- wd->reorder = value;
+ 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;
}

2009-03-23 23:39:01

by Greg KH

Subject: Re: [PATCH 2.6.29-rc8] drivers/staging/otus/80211core/ccmd.c: Fix Coding Style

Care to resend both of these, you forgot a "Signed-off-by:" to your
patch :(

thanks,

greg k-h