diff options
Diffstat (limited to 'drivers/staging/otus/80211core/ccmd.c')
| -rw-r--r-- | drivers/staging/otus/80211core/ccmd.c | 1861 |
1 files changed, 1861 insertions, 0 deletions
diff --git a/drivers/staging/otus/80211core/ccmd.c b/drivers/staging/otus/80211core/ccmd.c new file mode 100644 index 000000000000..479977973671 --- /dev/null +++ b/drivers/staging/otus/80211core/ccmd.c @@ -0,0 +1,1861 @@ +/* + * Copyright (c) 2007-2008 Atheros Communications Inc. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/* */ +/* Module Name : cmd.c */ +/* */ +/* Abstract */ +/* This module contains command interface functions. */ +/* */ +/* NOTES */ +/* None */ +/* */ +/************************************************************************/ +#include "cprecomp.h" +#include "../hal/hpreg.h" + + +u16_t zfWlanReset(zdev_t* dev); +u32_t zfUpdateRxRate(zdev_t* dev); + + +extern void zfiUsbRecv(zdev_t *dev, zbuf_t *buf); +extern void zfiUsbRegIn(zdev_t* dev, u32_t* rsp, u16_t rspLen); +extern void zfiUsbOutComplete(zdev_t* dev, zbuf_t *buf, u8_t status, u8_t *hdr); +extern void zfiUsbRegOutComplete(zdev_t* dev); +extern u16_t zfHpReinit(zdev_t* dev, u32_t frequency); + +/* Get size (byte) of driver core global data structure. */ +/* This size will be used by driver wrapper to allocate */ +/* a memory space for driver core to store global variables */ +u16_t zfiGlobalDataSize(zdev_t* dev) +{ + u32_t ret; + ret = (sizeof(struct zsWlanDev)); + zm_assert((ret>>16) == 0); + return (u16_t)ret; +} + + +/* Initialize WLAN hardware and software, resource will be allocated */ +/* for WLAN operation, must be called first before other function. */ +extern u16_t zfiWlanOpen(zdev_t* dev, struct zsCbFuncTbl* cbFuncTbl) +{ + //u16_t ret; + //u32_t i; + //u8_t* ch; + //u8_t bPassive; + u32_t devSize; + struct zfCbUsbFuncTbl cbUsbFuncTbl; + zmw_get_wlan_dev(dev); + + zm_debug_msg0("start"); + + devSize = sizeof(struct zsWlanDev); + /* Zeroize zsWlanDev struct */ + zfZeroMemory((u8_t*)wd, (u16_t)devSize); + +#ifdef ZM_ENABLE_AGGREGATION + zfAggInit(dev); +#endif + + zfCwmInit(dev); + + wd->commTally.RateCtrlTxMPDU = 0; + wd->commTally.RateCtrlBAFail = 0; + wd->preambleTypeInUsed = ZM_PREAMBLE_TYPE_SHORT; + + if (cbFuncTbl == NULL) + { + /* zfcbRecvEth() is mandatory */ + zm_assert(0); + } + else + { + if (cbFuncTbl->zfcbRecvEth == NULL) + { + /* zfcbRecvEth() is mandatory */ + zm_assert(0); + } + wd->zfcbAuthNotify = cbFuncTbl->zfcbAuthNotify; + wd->zfcbAuthNotify = cbFuncTbl->zfcbAuthNotify; + wd->zfcbAsocNotify = cbFuncTbl->zfcbAsocNotify; + wd->zfcbDisAsocNotify = cbFuncTbl->zfcbDisAsocNotify; + wd->zfcbApConnectNotify = cbFuncTbl->zfcbApConnectNotify; + wd->zfcbConnectNotify = cbFuncTbl->zfcbConnectNotify; + wd->zfcbScanNotify = cbFuncTbl->zfcbScanNotify; + wd->zfcbMicFailureNotify = cbFuncTbl->zfcbMicFailureNotify; + wd->zfcbApMicFailureNotify = cbFuncTbl->zfcbApMicFailureNotify; + wd->zfcbIbssPartnerNotify = cbFuncTbl->zfcbIbssPartnerNotify; + wd->zfcbMacAddressNotify = cbFuncTbl->zfcbMacAddressNotify; + wd->zfcbSendCompleteIndication = cbFuncTbl->zfcbSendCompleteIndication; + wd->zfcbRecvEth = cbFuncTbl->zfcbRecvEth; + wd->zfcbRestoreBufData = cbFuncTbl->zfcbRestoreBufData; + wd->zfcbRecv80211 = cbFuncTbl->zfcbRecv80211; +#ifdef ZM_ENABLE_CENC + wd->zfcbCencAsocNotify = cbFuncTbl->zfcbCencAsocNotify; +#endif //ZM_ENABLE_CENC + wd->zfcbClassifyTxPacket = cbFuncTbl->zfcbClassifyTxPacket; + wd->zfcbHwWatchDogNotify = cbFuncTbl->zfcbHwWatchDogNotify; + } + + //add by honda 0330 + cbUsbFuncTbl.zfcbUsbRecv = zfiUsbRecv; + cbUsbFuncTbl.zfcbUsbRegIn = zfiUsbRegIn; + cbUsbFuncTbl.zfcbUsbOutComplete = zfiUsbOutComplete; + cbUsbFuncTbl.zfcbUsbRegOutComplete = zfiUsbRegOutComplete; + zfwUsbRegisterCallBack(dev, &cbUsbFuncTbl); + /* Init OWN MAC address */ + wd->macAddr[0] = 0x8000; + wd->macAddr[1] = 0x0000; + wd->macAddr[2] = 0x0000; + + wd->regulationTable.regionCode = 0xffff; + + zfHpInit(dev, wd->frequency); + + /* init region code */ + //wd->regulationTable.regionCode = NULL1_WORLD; //Only 2.4g RegCode + //zfHpGetRegulationTablefromRegionCode(dev, NULL1_WORLD); + //zfiWlanSetDot11DMode(dev , 1); // Enable 802.11d + /* Get the first channel */ + //wd->frequency = zfChGetFirstChannel(dev, &bPassive); +#ifdef ZM_AP_DEBUG + //wd->frequency = 2437; +#endif + + //STA mode + wd->sta.mTxRate = 0x0; + wd->sta.uTxRate = 0x3; + wd->sta.mmTxRate = 0x0; + wd->sta.adapterState = ZM_STA_STATE_DISCONNECT; + wd->sta.capability[0] = 0x01; + wd->sta.capability[1] = 0x00; + + wd->sta.preambleTypeHT = 0; + wd->sta.htCtrlBandwidth = 0; + wd->sta.htCtrlSTBC = 0; + wd->sta.htCtrlSG = 0; + wd->sta.defaultTA = 0; + //wd->sta.activescanTickPerChannel = ZM_TIME_ACTIVE_SCAN/ZM_MS_PER_TICK; + { + u8_t Dur = ZM_TIME_ACTIVE_SCAN; + zfwGetActiveScanDur(dev, &Dur); + wd->sta.activescanTickPerChannel = Dur/ZM_MS_PER_TICK; + + } + wd->sta.passiveScanTickPerChannel = ZM_TIME_PASSIVE_SCAN/ZM_MS_PER_TICK; + wd->sta.bAutoReconnect = TRUE; + wd->sta.dropUnencryptedPkts = FALSE; + + /* set default to bypass all multicast packet for linux, window XP would set 0 by wrapper initialization */ + wd->sta.bAllMulticast = 1; + + /* Initial the RIFS Status / RIFS-like frame count / RIFS count */ + wd->sta.rifsState = ZM_RIFS_STATE_DETECTING; + wd->sta.rifsLikeFrameCnt = 0; + wd->sta.rifsCount = 0; + + wd->sta.osRxFilter = 0; + wd->sta.bSafeMode = 0; + + //Common + zfResetSupportRate(dev, ZM_DEFAULT_SUPPORT_RATE_DISCONNECT); + wd->beaconInterval = 100; + wd->rtsThreshold = 2346; + wd->fragThreshold = 32767; + wd->wlanMode = ZM_MODE_INFRASTRUCTURE; + wd->txMCS = 0xff; //AUTO + wd->dtim = 1; + //wd->txMT = 1; //OFDM + wd->tick = 1; + wd->maxTxPower2 = 0xff; + wd->maxTxPower5 = 0xff; + wd->supportMode = 0xffffffff; + wd->ws.adhocMode = ZM_ADHOCBAND_G; + wd->ws.autoSetFrequency = 0xff; + + //AP mode + //wd->bgMode = wd->ws.bgMode; + wd->ap.ssidLen[0] = 6; + wd->ap.ssid[0][0] = 'Z'; + wd->ap.ssid[0][1] = 'D'; + wd->ap.ssid[0][2] = '1'; + wd->ap.ssid[0][3] = '2'; + wd->ap.ssid[0][4] = '2'; + wd->ap.ssid[0][5] = '1'; + + // Init the country iso name as NA + wd->ws.countryIsoName[0] = 0; + wd->ws.countryIsoName[1] = 0; + wd->ws.countryIsoName[2] = '\0'; + + /* init fragmentation is disabled */ + //zfiWlanSetFragThreshold(dev, 0); + + /* airopeek : swSniffer 1=>on 0=>off */ + wd->swSniffer = 0; + wd->XLinkMode = 0; + +// jhlee HT 0 +#if 1 + /* AP Mode*/ + /* Init HT Capability Info */ + wd->ap.HTCap.Data.ElementID = ZM_WLAN_EID_HT_CAPABILITY; + wd->ap.HTCap.Data.Length = 26; + //wd->ap.HTCap.Data.SupChannelWidthSet = 0; + //wd->ap.HTCap.Data.MIMOPowerSave = 3; + //wd->ap.HTCap.Data.ShortGIfor40MHz = 0; + //wd->ap.HTCap.Data.ShortGIfor20MHz = 0; + //wd->ap.HTCap.Data.DSSSandCCKin40MHz = 0; + wd->ap.HTCap.Data.AMPDUParam |= HTCAP_MaxRxAMPDU3; + wd->ap.HTCap.Data.MCSSet[0] = 0xFF; // MCS 0 ~ 7 + wd->ap.HTCap.Data.MCSSet[1] = 0xFF; // MCS 8 ~ 15 + + /* Init Extended HT Capability Info */ + wd->ap.ExtHTCap.Data.ElementID = ZM_WLAN_EID_EXTENDED_HT_CAPABILITY; + wd->ap.ExtHTCap.Data.Length = 22; + wd->ap.ExtHTCap.Data.ControlChannel = 6; + //wd->ap.ExtHTCap.Data.ExtChannelOffset = 3; + wd->ap.ExtHTCap.Data.ChannelInfo |= ExtHtCap_RecomTxWidthSet; + //wd->ap.ExtHTCap.Data.RIFSMode = 1; + wd->ap.ExtHTCap.Data.OperatingInfo |= 1; + + /* STA Mode*/ + /* Init HT Capability Info */ + wd->sta.HTCap.Data.ElementID = ZM_WLAN_EID_HT_CAPABILITY; + wd->sta.HTCap.Data.Length = 26; + + /* Test with 5G-AP : 7603 */ + //wd->sta.HTCap.Data.SupChannelWidthSet = 1; + wd->sta.HTCap.Data.HtCapInfo |= HTCAP_SMEnabled; + wd->sta.HTCap.Data.HtCapInfo |= HTCAP_SupChannelWidthSet; + wd->sta.HTCap.Data.HtCapInfo |= HTCAP_ShortGIfor40MHz; + wd->sta.HTCap.Data.HtCapInfo |= HTCAP_DSSSandCCKin40MHz; +#ifndef ZM_DISABLE_AMSDU8K_SUPPORT + wd->sta.HTCap.Data.HtCapInfo |= HTCAP_MaxAMSDULength; +#endif + //wd->sta.HTCap.Data.MIMOPowerSave = 0; + //wd->sta.HTCap.Data.ShortGIfor40MHz = 0; + //wd->sta.HTCap.Data.ShortGIfor20MHz = 0; + //wd->sta.HTCap.Data.DSSSandCCKin40MHz = 0; + wd->sta.HTCap.Data.AMPDUParam |= HTCAP_MaxRxAMPDU3; + wd->sta.HTCap.Data.MCSSet[0] = 0xFF; // MCS 0 ~ 7 + wd->sta.HTCap.Data.MCSSet[1] = 0xFF; // MCS 8 ~ 15 + wd->sta.HTCap.Data.PCO |= HTCAP_TransmissionTime3; + //wd->sta.HTCap.Data.TransmissionTime = 0; + /* Init Extended HT Capability Info */ + wd->sta.ExtHTCap.Data.ElementID = ZM_WLAN_EID_EXTENDED_HT_CAPABILITY; + wd->sta.ExtHTCap.Data.Length = 22; + wd->sta.ExtHTCap.Data.ControlChannel = 6; + + //wd->sta.ExtHTCap.Data.ExtChannelOffset |= 3; + wd->sta.ExtHTCap.Data.ChannelInfo |= ExtHtCap_ExtChannelOffsetBelow; + + //wd->sta.ExtHTCap.Data.RecomTxWidthSet = 1; + //wd->sta.ExtHTCap.Data.RIFSMode = 1; + wd->sta.ExtHTCap.Data.OperatingInfo |= 1; +#endif + +#if 0 + /* WME test code */ + wd->ap.qosMode[0] = 1; +#endif + + wd->ledStruct.ledMode[0] = 0x2221; + wd->ledStruct.ledMode[1] = 0x2221; + + zfTimerInit(dev); + + ZM_PERFORMANCE_INIT(dev); + + zfBssInfoCreate(dev); + zfScanMgrInit(dev); + zfPowerSavingMgrInit(dev); + +#if 0 + /* Test code */ + { + u32_t key[4] = {0xffffffff, 0xff, 0, 0}; + u16_t addr[3] = {0x8000, 0x01ab, 0x0000}; + //zfSetKey(dev, 0, 0, ZM_WEP64, addr, key); + //zfSetKey(dev, 0, 0, ZM_AES, addr, key); + //zfSetKey(dev, 64, 0, 1, wd->macAddr, key); + } +#endif + + // WME settings + wd->ws.staWmeEnabled = 1; // Enable WME by default + #define ZM_UAPSD_Q_SIZE 32 //2^N + wd->ap.uapsdQ = zfQueueCreate(dev, ZM_UAPSD_Q_SIZE); + zm_assert(wd->ap.uapsdQ != NULL); + wd->sta.uapsdQ = zfQueueCreate(dev, ZM_UAPSD_Q_SIZE); + zm_assert(wd->sta.uapsdQ != NULL); + + //zfHpInit(dev, wd->frequency); + + /* MAC address */ + //zfHpSetMacAddress(dev, wd->macAddr, 0); + zfHpGetMacAddress(dev); + + zfCoreSetFrequency(dev, wd->frequency); + +#if ZM_PCI_LOOP_BACK == 1 + zfwWriteReg(dev, ZM_REG_PCI_CONTROL, 6); +#endif /* #if ZM_PCI_LOOP_BACK == 1 */ + + //zfiWlanSetDot11DMode(dev , 1); // Enable 802.11d + //zfiWlanSetDot11HDFSMode(dev , 1); // Enable 802.11h DFS + wd->sta.DFSEnable = 1; + wd->sta.capability[1] |= ZM_BIT_0; + + //zfiWlanSetFrequency(dev, 5260000, TRUE); + //zfiWlanSetAniMode(dev , 1); // Enable ANI + + /* Trgger Rx DMA */ + zfHpStartRecv(dev); + + zm_debug_msg0("end"); + + return 0; +} + +/* WLAN hardware will be shutdown and all resource will be release */ +u16_t zfiWlanClose(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + zm_msg0_init(ZM_LV_0, "enter"); + + wd->state = ZM_WLAN_STATE_CLOSEDED; + + //zfiWlanDisable(dev, 1); + zfWlanReset(dev); + + zfHpStopRecv(dev); + + /* Disable MAC */ + /* Disable PHY */ + /* Disable RF */ + + zfHpRelease(dev); + + zfQueueDestroy(dev, wd->ap.uapsdQ); + zfQueueDestroy(dev, wd->sta.uapsdQ); + + zfBssInfoDestroy(dev); + +#ifdef ZM_ENABLE_AGGREGATION + /* add by honda */ + zfAggRxFreeBuf(dev, 1); //1 for release structure memory + /* end of add by honda */ +#endif + + zm_msg0_init(ZM_LV_0, "exit"); + + return 0; +} + +void zfGetWrapperSetting(zdev_t* dev) +{ + u8_t bPassive; + u16_t vapId = 0; + + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); +#if 0 + if ( (wd->ws.countryIsoName[0] != 0) + || (wd->ws.countryIsoName[1] != 0) + || (wd->ws.countryIsoName[2] != '\0') ) + { + zfHpGetRegulationTablefromRegionCode( + dev, + zfHpGetRegionCodeFromIsoName(dev, wd->ws.countryIsoName) ); + } +#endif + zmw_enter_critical_section(dev); + + wd->wlanMode = wd->ws.wlanMode; + + /* set channel */ + if ( wd->ws.frequency ) + { + wd->frequency = wd->ws.frequency; + wd->ws.frequency = 0; + } + else + { + wd->frequency = zfChGetFirstChannel(dev, &bPassive); + + if ( wd->wlanMode == ZM_MODE_IBSS ) + { + if (wd->ws.adhocMode == ZM_ADHOCBAND_A) + { + wd->frequency = ZM_CH_A_36; + } + else + { + wd->frequency = ZM_CH_G_6; + } + } + } +#ifdef ZM_AP_DEBUG + /* honda add for debug, 2437 channel 6, 2452 channel 9 */ + wd->frequency = 2437; + /* end of add by honda */ +#endif + + /* set preamble type */ + switch (wd->ws.preambleType) + { + case ZM_PREAMBLE_TYPE_AUTO: + case ZM_PREAMBLE_TYPE_SHORT: + case ZM_PREAMBLE_TYPE_LONG: + wd->preambleType = wd->ws.preambleType; + break; + default: + wd->preambleType = ZM_PREAMBLE_TYPE_SHORT; + break; + } + wd->ws.preambleType = 0; + + if ( wd->wlanMode == ZM_MODE_AP ) + { + vapId = zfwGetVapId(dev); + + if (vapId == 0xffff) + { + wd->ap.authAlgo[0] = wd->ws.authMode; + wd->ap.encryMode[0] = wd->ws.encryMode; + } + else + { + wd->ap.authAlgo[vapId + 1] = wd->ws.authMode; + wd->ap.encryMode[vapId + 1] = wd->ws.encryMode; + } + wd->ws.authMode = 0; + wd->ws.encryMode = ZM_NO_WEP; + + /* Get beaconInterval from WrapperSetting */ + if ((wd->ws.beaconInterval >= 20) && (wd->ws.beaconInterval <= 1000)) + { + wd->beaconInterval = wd->ws.beaconInterval; + } + else + { + wd->beaconInterval = 100; //100ms + } + + if (wd->ws.dtim > 0) + { + wd->dtim = wd->ws.dtim; + } + else + { + wd->dtim = 1; + } + + wd->ap.qosMode = wd->ws.apWmeEnabled & 0x1; + wd->ap.uapsdEnabled = (wd->ws.apWmeEnabled & 0x2) >> 1; + } + else + { + wd->sta.authMode = wd->ws.authMode; + wd->sta.currentAuthMode = wd->ws.authMode; + wd->sta.wepStatus = wd->ws.wepStatus; + + if ( wd->ws.beaconInterval ) + { + wd->beaconInterval = wd->ws.beaconInterval; + } + else + { + wd->beaconInterval = 0x64; + } + + if ( wd->wlanMode == ZM_MODE_IBSS ) + { + /* 1. Set default channel 6 (2437MHz) */ +// wd->frequency = 2437; + + /* 2. Otus support 802.11g Mode */ + if ((wd->ws.adhocMode == ZM_ADHOCBAND_G) || + (wd->ws.adhocMode == ZM_ADHOCBAND_BG) || + (wd->ws.adhocMode == ZM_ADHOCBAND_ABG) ) { + wd->wfc.bIbssGMode = 1; + } else { + wd->wfc.bIbssGMode = 0; + } + + /* 3. set short preamble */ + //wd->sta.preambleType = ZM_PREAMBLE_TYPE_SHORT ; + } + + /* set ATIM window */ + if ( wd->ws.atimWindow ) + { + wd->sta.atimWindow = wd->ws.atimWindow; + } + else + { + //wd->sta.atimWindow = 0x0a; + wd->sta.atimWindow = 0; + } + + //wd->sta.connectingHiddenAP = 1;//wd->ws.connectingHiddenAP; + wd->sta.dropUnencryptedPkts = wd->ws.dropUnencryptedPkts; + wd->sta.ibssJoinOnly = wd->ws.ibssJoinOnly; + + if ( wd->ws.bDesiredBssid ) + { + zfMemoryCopy(wd->sta.desiredBssid, wd->ws.desiredBssid, 6); + wd->sta.bDesiredBssid = TRUE; + wd->ws.bDesiredBssid = FALSE; + } + else + { + wd->sta.bDesiredBssid = FALSE; + } + + /* check ssid */ + if ( wd->ws.ssidLen != 0 ) + { + if ( (!zfMemoryIsEqual(wd->ws.ssid, wd->sta.ssid, + wd->sta.ssidLen))|| + (wd->ws.ssidLen != wd->sta.ssidLen)|| + (wd->sta.authMode == ZM_AUTH_MODE_WPA)|| + (wd->sta.authMode == ZM_AUTH_MODE_WPAPSK) || + (wd->ws.staWmeQosInfo!= 0) ) + { + /*if u-APSD test(set QosInfo), clear connectByReasso to do association (not reassociation)*/ + wd->sta.connectByReasso = FALSE; + wd->sta.failCntOfReasso = 0; + wd->sta.pmkidInfo.bssidCount = 0; + + wd->sta.ssidLen = wd->ws.ssidLen; + zfMemoryCopy(wd->sta.ssid, wd->ws.ssid, wd->sta.ssidLen); + + if ( wd->sta.ssidLen < 32 ) + { + wd->sta.ssid[wd->sta.ssidLen] = 0; + } + } + } + else + { /* ANY BSS */ + wd->sta.ssid[0] = 0; + wd->sta.ssidLen = 0; + } + + wd->sta.wmeEnabled = wd->ws.staWmeEnabled; + wd->sta.wmeQosInfo = wd->ws.staWmeQosInfo; + + } + + zmw_leave_critical_section(dev); +} + +u16_t zfWlanEnable(zdev_t* dev) +{ + u8_t bssid[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0}; + u16_t i; + + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + if ( wd->wlanMode == ZM_MODE_UNKNOWN ) + { + zm_debug_msg0("Unknown Mode...Skip..."); + return 0; + } + + if (wd->wlanMode == ZM_MODE_AP) + { + u16_t vapId; + + vapId = zfwGetVapId(dev); + + if (vapId == 0xffff) + { + /* AP mode */ + zfApInitStaTbl(dev); + + /* AP default parameters */ + wd->bRate = 0xf; + wd->gRate = 0xff; + wd->bRateBasic = 0xf; + wd->gRateBasic = 0x0; + //wd->beaconInterval = 100; + wd->ap.apBitmap = 1; + wd->ap.beaconCounter = 0; + //wd->ap.vapNumber = 1; //mark by ygwei for Vap + + wd->ap.hideSsid[0] = 0; + wd->ap.staAgingTimeSec = 10*60; + wd->ap.staProbingTimeSec = 60; + + for (i=0; i<ZM_MAX_AP_SUPPORT; i++) + { + wd->ap.bcmcHead[i] = wd->ap.bcmcTail[i] = 0; + } + + //wd->ap.uniHead = wd->ap.uniTail = 0; + + /* load AP parameters */ + wd->bRateBasic = wd->ws.bRateBasic; + wd->gRateBasic = wd->ws.gRateBasic; + wd->bgMode = wd->ws.bgMode; + if ((wd->ws.ssidLen <= 32) && (wd->ws.ssidLen != 0)) + { + wd->ap.ssidLen[0] = wd->ws.ssidLen; + for(i=0; i<wd->ws.ssidLen; i++) + { + wd->ap.ssid[0][i] = wd->ws.ssid[i]; + } + wd->ws.ssidLen = 0; // Reset Wrapper Variable + } + + if (wd->ap.encryMode[0] == 0) + { + wd->ap.capab[0] = 0x001; + } + else + { + wd->ap.capab[0] = 0x011; + } + /* set Short Slot Time bit if not 11b */ + if (wd->ap.wlanType[0] != ZM_WLAN_TYPE_PURE_B) + { + wd->ap.capab[0] |= 0x400; + } + + // wd->ap.vapNumber = 1; // mark by ygwei for Vap Test + } + else + { +#if 0 + /* VAP Test Code */ + wd->ap.apBitmap = 0x3; + wd->ap.capab[1] = 0x401; + wd->ap.ssidLen[1] = 4; + wd->ap.ssid[1][0] = 'v'; + wd->ap.ssid[1][1] = 'a'; + wd->ap.ssid[1][2] = 'p'; + wd->ap.ssid[1][3] = '1'; + wd->ap.authAlgo[1] = wd->ws.authMode; + wd->ap.encryMode[1] = wd->ws.encryMode; + wd->ap.vapNumber = 2; +#else + /* VAP Test Code */ + wd->ap.apBitmap = 0x1 | (0x01 << (vapId+1)); + + if ((wd->ws.ssidLen <= 32) && (wd->ws.ssidLen != 0)) + { + wd->ap.ssidLen[vapId+1] = wd->ws.ssidLen; + for(i=0; i<wd->ws.ssidLen; i++) + { + wd->ap.ssid[vapId+1][i] = wd->ws.ssid[i]; + } + wd->ws.ssidLen = 0; // Reset Wrapper Variable + } + + if (wd->ap.encryMode[vapId+1] == 0) + { + wd->ap.capab[vapId+1] = 0x401; + } + else + { + wd->ap.capab[vapId+1] = 0x411; + } + + wd->ap.authAlgo[vapId+1] = wd->ws.authMode; + wd->ap.encryMode[vapId+1] = wd->ws.encryMode; + + /* Need to be modified when VAP is used */ + //wd->ap.vapNumber = 2; +#endif + } + + wd->ap.vapNumber++; + + zfCoreSetFrequency(dev, wd->frequency); + + zfInitMacApMode(dev); + + /* Disable protection mode */ + zfApSetProtectionMode(dev, 0); + + zfApSendBeacon(dev); + } /*if (wd->wlanMode == ZM_MODE_AP) */ + else + { + zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_INTERNAL); + zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_EXTERNAL); + + zmw_enter_critical_section(dev); + wd->sta.oppositeCount = 0; /* reset opposite count */ + //wd->sta.bAutoReconnect = wd->sta.bAutoReconnectEnabled; + //wd->sta.scanWithSSID = 0; + zfStaInitOppositeInfo(dev); + zmw_leave_critical_section(dev); + + zfStaResetStatus(dev, 0); + + if ( (wd->sta.cmDisallowSsidLength != 0)&& + (wd->sta.ssidLen == wd->sta.cmDisallowSsidLength)&& + (zfMemoryIsEqual(wd->sta.ssid, wd->sta.cmDisallowSsid, + wd->sta.ssidLen)) && + (wd->sta.wepStatus == ZM_ENCRYPTION_TKIP)) + { /* countermeasures */ + zm_debug_msg0("countermeasures disallow association"); + + } + else + { + switch( wd->wlanMode ) + { + case ZM_MODE_IBSS: + /* some registers may be set here */ + if ( wd->sta.authMode == ZM_AUTH_MODE_WPA2PSK ) + { + zfHpSetApStaMode(dev, ZM_HAL_80211_MODE_IBSS_WPA2PSK); + } + else + { + zfHpSetApStaMode(dev, ZM_HAL_80211_MODE_IBSS_GENERAL); + } + + zm_msg0_mm(ZM_LV_0, "ZM_MODE_IBSS"); + zfIbssConnectNetwork(dev); + break; + + case ZM_MODE_INFRASTRUCTURE: + /* some registers may be set here */ + zfHpSetApStaMode(dev, ZM_HAL_80211_MODE_STA); + + zfInfraConnectNetwork(dev); + break; + + case ZM_MODE_PSEUDO: + /* some registers may be set here */ + zfHpSetApStaMode(dev, ZM_HAL_80211_MODE_STA); + + zfUpdateBssid(dev, bssid); + zfCoreSetFrequency(dev, wd->frequency); + break; + + default: + break; + } + } + + } + + + //if ( (wd->wlanMode != ZM_MODE_INFRASTRUCTURE)&& + // (wd->wlanMode != ZM_MODE_AP) ) + if ( wd->wlanMode == ZM_MODE_PSEUDO ) + { + /* Reset Wlan status */ + zfWlanReset(dev); + + if (wd->zfcbConnectNotify != NULL) + { + wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECT, wd->sta.bssid); + } + zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTED); + } + + + if(wd->wlanMode == ZM_MODE_AP) + { + if (wd->zfcbConnectNotify != NULL) + { + wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECT, wd->sta.bssid); + } + //zfChangeAdapterState(dev, ZM_STA_STATE_CONNECTED); + } + + // Assign default Tx Rate + if ( wd->sta.EnableHT ) + { + u32_t oneTxStreamCap; + oneTxStreamCap = (zfHpCapability(dev) & ZM_HP_CAP_11N_ONE_TX_STREAM); + if(oneTxStreamCap) + wd->CurrentTxRateKbps = 135000; + else + wd->CurrentTxRateKbps = 270000; + wd->CurrentRxRateKbps = 270000; + } + else + { + wd->CurrentTxRateKbps = 54000; + wd->CurrentRxRateKbps = 54000; + } + + wd->state = ZM_WLAN_STATE_ENABLED; + + return 0; +} + +/* Enable/disable Wlan operation */ +u16_t zfiWlanEnable(zdev_t* dev) +{ + u16_t ret; + + zmw_get_wlan_dev(dev); + + zm_msg0_mm(ZM_LV_1, "Enable Wlan"); + + zfGetWrapperSetting(dev); + + zfZeroMemory((u8_t*) &wd->trafTally, sizeof(struct zsTrafTally)); + + // Reset cmMicFailureCount to 0 for new association request + if ( wd->sta.cmMicFailureCount == 1 ) + { + zfTimerCancel(dev, ZM_EVENT_CM_TIMER); + wd->sta.cmMicFailureCount = 0; + } + + zfFlushVtxq(dev); + if ((wd->queueFlushed & 0x10) != 0) + { + zfHpUsbReset(dev); + } + ret = zfWlanEnable(dev); + + return ret; +} +/* Add a flag named ResetKeyCache to show if KeyCache should be cleared. + for hostapd in AP mode, if driver receives iwconfig ioctl + after setting group key, it shouldn't clear KeyCache. */ +u16_t zfiWlanDisable(zdev_t* dev, u8_t ResetKeyCache) +{ + u16_t i; + u8_t isConnected; + + zmw_get_wlan_dev(dev); + +#ifdef ZM_ENABLE_IBSS_WPA2PSK + zmw_declare_for_critical_section(); +#endif + wd->state = ZM_WLAN_STATE_DISABLED; + + zm_msg0_mm(ZM_LV_1, "Disable Wlan"); + + if ( wd->wlanMode != ZM_MODE_AP ) + { + isConnected = zfStaIsConnected(dev); + + if ( (wd->wlanMode == ZM_MODE_INFRASTRUCTURE)&& + (wd->sta.currentAuthMode != ZM_AUTH_MODE_WPA2) ) + { + /* send deauthentication frame */ + if (isConnected) + { + //zfiWlanDeauth(dev, NULL, 0); + zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, wd->sta.bssid, 3, 0, 0); + //zmw_debug_msg0("send a Deauth frame!"); + } + } + + // Remove all the connected peer stations + if ( wd->wlanMode == ZM_MODE_IBSS ) + { + wd->sta.ibssBssIsCreator = 0; + zfTimerCancel(dev, ZM_EVENT_IBSS_MONITOR); + zfStaIbssMonitoring(dev, 1); + } + +#ifdef ZM_ENABLE_IBSS_WPA2PSK + zmw_enter_critical_section(dev); + wd->sta.ibssWpa2Psk = 0; + zmw_leave_critical_section(dev); +#endif + + wd->sta.wpaState = ZM_STA_WPA_STATE_INIT; + + /* reset connect timeout counter */ + wd->sta.connectTimeoutCount = 0; + + /* reset connectState to None */ + wd->sta.connectState = ZM_STA_CONN_STATE_NONE; + + /* reset leap enable variable */ + wd->sta.leapEnabled = 0; + + /* Disable the RIFS Status / RIFS-like frame count / RIFS count */ + if( wd->sta.rifsState == ZM_RIFS_STATE_DETECTED ) + zfHpDisableRifs(dev); + wd->sta.rifsState = ZM_RIFS_STATE_DETECTING; + wd->sta.rifsLikeFrameCnt = 0; + wd->sta.rifsCount = 0; + + wd->sta.osRxFilter = 0; + wd->sta.bSafeMode = 0; + + zfChangeAdapterState(dev, ZM_STA_STATE_DISCONNECT); + if (ResetKeyCache) + zfHpResetKeyCache(dev); + + if (isConnected) + { + if (wd->zfcbConnectNotify != NULL) + { + wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECTION_DISABLED, wd->sta.bssid); + } + } + else + { + if (wd->zfcbConnectNotify != NULL) + { + wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_DISABLED, wd->sta.bssid); + } + } + } + else //if (wd->wlanMode == ZM_MODE_AP) + { + for (i=0; i<ZM_MAX_STA_SUPPORT; i++) + { + /* send deauthentication frame */ + if (wd->ap.staTable[i].valid == 1) + { + /* Reason : Sending station is leaving */ + zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, + wd->ap.staTable[i].addr, 3, 0, 0); + } + } + + if (ResetKeyCache) + zfHpResetKeyCache(dev); + + wd->ap.vapNumber--; + } + + /* stop beacon */ + zfHpDisableBeacon(dev); + + /* Flush VTxQ and MmQ */ + zfFlushVtxq(dev); + /* Flush AP PS queues */ + zfApFlushBufferedPsFrame(dev); + /* Free buffer in defragment list*/ + zfAgingDefragList(dev, 1); + + #ifdef ZM_ENABLE_AGGREGATION + /* add by honda */ + zfAggRxFreeBuf(dev, 0); //1 for release structure memory + /* end of add by honda */ + #endif + + // Clear the information for the peer stations of IBSS or AP of Station mode + zfZeroMemory((u8_t*)wd->sta.oppositeInfo, sizeof(struct zsOppositeInfo) * ZM_MAX_OPPOSITE_COUNT); + + /* Turn off Software WEP/TKIP */ + if (wd->sta.SWEncryptEnable != 0) + { + zm_debug_msg0("Disable software encryption"); + zfStaDisableSWEncryption(dev); + } + + /* Improve WEP/TKIP performace with HT AP, detail information please look bug#32495 */ + //zfHpSetTTSIFSTime(dev, 0x8); + + return 0; +} + +u16_t zfiWlanSuspend(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + zmw_declare_for_critical_section(); + + // Change the HAL state to init so that any packet can't be transmitted between + // resume & HAL reinit. This would cause the chip hang issue in OTUS. + zmw_enter_critical_section(dev); + wd->halState = ZM_HAL_STATE_INIT; + zmw_leave_critical_section(dev); + + return 0; +} + +u16_t zfiWlanResume(zdev_t* dev, u8_t doReconn) +{ + u16_t ret; + zmw_get_wlan_dev(dev); + zmw_declare_for_critical_section(); + + /* Redownload firmware, Reinit MAC,PHY,RF */ + zfHpReinit(dev, wd->frequency); + + //Set channel according to AP's configuration + zfCoreSetFrequencyExV2(dev, wd->frequency, wd->BandWidth40, + wd->ExtOffset, NULL, 1); + + zfHpSetMacAddress(dev, wd->macAddr, 0); + + /* Start Rx */ + zfHpStartRecv(dev); + + zfFlushVtxq(dev); + + if ( wd->wlanMode != ZM_MODE_INFRASTRUCTURE && + wd->wlanMode != ZM_MODE_IBSS ) + { + return 1; + } + + zm_msg0_mm(ZM_LV_1, "Resume Wlan"); + if ( (zfStaIsConnected(dev)) || (zfStaIsConnecting(dev)) ) + { + if (doReconn == 1) + { + zm_msg0_mm(ZM_LV_1, "Re-connect..."); + zmw_enter_critical_section(dev); + wd->sta.connectByReasso = FALSE; + zmw_leave_critical_section(dev); + + zfWlanEnable(dev); + } + else if (doReconn == 0) + { + zfHpSetRollCallTable(dev); + } + } + + ret = 0; + + return ret; +} + +/************************************************************************/ +/* */ +/* FUNCTION DESCRIPTION zfiWlanFlushAllQueuedBuffers */ +/* Flush Virtual TxQ, MmQ, PS frames and defragment list */ +/* */ +/* INPUTS */ +/* dev : device pointer */ +/* */ +/* OUTPUTS */ +/* None */ +/* */ +/* AUTHOR */ +/* Stephen Chen Atheros Communications, INC. 2007.1 */ +/* */ +/************************************************************************/ +void zfiWlanFlushAllQueuedBuffers(zdev_t* dev) +{ + /* Flush VTxQ and MmQ */ + zfFlushVtxq(dev); + /* Flush AP PS queues */ + zfApFlushBufferedPsFrame(dev); + /* Free buffer in defragment list*/ + zfAgingDefragList(dev, 1); +} + +/* Do WLAN site survey */ +u16_t zfiWlanScan(zdev_t* dev) +{ + u16_t ret = 1; + zmw_get_wlan_dev(dev); + + zm_debug_msg0(""); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + + if (wd->wlanMode == ZM_MODE_AP) + { + wd->heartBeatNotification |= ZM_BSSID_LIST_SCAN; + wd->sta.scanFrequency = 0; + //wd->sta.pUpdateBssList->bssCount = 0; + ret = 0; + } + else + { + #if 0 + if ( !zfStaBlockWlanScan(dev) ) + { + zm_debug_msg0("scan request"); + //zfTimerSchedule(dev, ZM_EVENT_SCAN, ZM_TICK_ZERO); + ret = 0; + goto start_scan; + } + #else + goto start_scan; + #endif + } + + zmw_leave_critical_section(dev); + + return ret; + +start_scan: + zmw_leave_critical_section(dev); + + if(wd->ledStruct.LEDCtrlFlagFromReg & ZM_LED_CTRL_FLAG_ALPHA) // flag for Alpha + wd->ledStruct.LEDCtrlFlag |= ZM_LED_CTRL_FLAG_ALPHA; + + ret = zfScanMgrScanStart(dev, ZM_SCAN_MGR_SCAN_EXTERNAL); + + zm_debug_msg1("ret = ", ret); + + return ret; +} + + +/* rate */ +/* 0 : AUTO */ +/* 1 : CCK 1M */ +/* 2 : CCK 2M */ +/* 3 : CCK 5.5M */ +/* 4 : CCK 11M */ +/* 5 : OFDM 6M */ +/* 6 : OFDM 9M */ +/* 7 : OFDM 12M */ +/* 8 : OFDM 18M */ +/* 9 : OFDM 24M */ +/* 10 : OFDM 36M */ +/* 11 : OFDM 48M */ +/* 12 : OFDM 54M */ +/* 13 : MCS 0 */ +/* 28 : MCS 15 */ +u16_t zcRateToMCS[] = + {0xff, 0, 1, 2, 3, 0xb, 0xf, 0xa, 0xe, 0x9, 0xd, 0x8, 0xc}; +u16_t zcRateToMT[] = {0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1}; + +u16_t zfiWlanSetTxRate(zdev_t* dev, u16_t rate) +{ // jhlee HT 0 + zmw_get_wlan_dev(dev); + + if (rate <=12) + { + wd->txMCS = zcRateToMCS[rate]; + wd->txMT = zcRateToMT[rate]; + return ZM_SUCCESS; + } + else if ((rate<=28)||(rate==13+32)) + { + wd->txMCS = rate - 12 - 1; + wd->txMT = 2; + return ZM_SUCCESS; + } + + return ZM_ERR_INVALID_TX_RATE; +} + +const u32_t zcRateIdToKbps40M[] = + { + 1000, 2000, 5500, 11000, /* 1M, 2M, 5M, 11M , 0 1 2 3*/ + 6000, 9000, 12000, 18000, /* 6M 9M 12M 18M , 4 5 6 7*/ + 24000, 36000, 48000, 54000, /* 24M 36M 48M 54M , 8 9 10 11*/ + 13500, 27000, 40500, 54000, /* MCS0 MCS1 MCS2 MCS3 , 12 13 14 15*/ + 81000, 108000, 121500, 135000, /* MCS4 MCS5 MCS6 MCS7 , 16 17 18 19*/ + 27000, 54000, 81000, 108000, /* MCS8 MCS9 MCS10 MCS11 , 20 21 22 23*/ + 162000, 216000, 243000, 270000, /* MCS12 MCS13 MCS14 MCS15 , 24 25 26 27*/ + 270000, 300000, 150000 /* MCS14SG, MCS15SG, MCS7SG , 28 29 30*/ + }; + +const u32_t zcRateIdToKbps20M[] = + { + 1000, 2000, 5500, 11000, /* 1M, 2M, 5M, 11M , 0 1 2 3*/ + 6000, 9000, 12000, 18000, /* 6M 9M 12M 18M , 4 5 6 7*/ + 24000, 36000, 48000, 54000, /* 24M 36M 48M 54M , 8 9 10 11*/ + 6500, 13000, 19500, 26000, /* MCS0 MCS1 MCS2 MCS3 , 12 13 14 15*/ + 39000, 52000, 58500, 65000, /* MCS4 MCS5 MCS6 MCS7 , 16 17 18 19*/ + 13000, 26000, 39000, 52000, /* MCS8 MCS9 MCS10 MCS11 , 20 21 22 23*/ + 78000, 104000, 117000, 130000, /* MCS12 MCS13 MCS14 MCS15 , 24 25 26 27*/ + 130000, 144400, 72200 /* MCS14SG, MCS15SG, MSG7SG , 28 29 30*/ + }; + +u32_t zfiWlanQueryTxRate(zdev_t* dev) +{ + u8_t rateId = 0xff; + zmw_get_wlan_dev(dev); + zmw_declare_for_critical_section(); + + /* If Tx rate had not been trained, return maximum Tx rate instead */ + if ((wd->wlanMode == ZM_MODE_INFRASTRUCTURE) && (zfStaIsConnected(dev))) + { + zmw_enter_critical_section(dev); + //Not in fixed rate mode + if (wd->txMCS == 0xff) + { + if ((wd->sta.oppositeInfo[0].rcCell.flag & ZM_RC_TRAINED_BIT) == 0) + { + rateId = wd->sta.oppositeInfo[0].rcCell.operationRateSet[wd->sta.oppositeInfo[0].rcCell.operationRateCount-1]; + } + else + { + rateId = wd->sta.oppositeInfo[0].rcCell.operationRateSet[wd->sta.oppositeInfo[0].rcCell.currentRateIndex]; + } + } + zmw_leave_critical_section(dev); + } + if (rateId != 0xff) + { + if (wd->sta.htCtrlBandwidth) + { + return zcRateIdToKbps40M[rateId]; + } + else + { + return zcRateIdToKbps20M[rateId]; + } + } + else + { + return wd->CurrentTxRateKbps; + } +} + +void zfWlanUpdateRxRate(zdev_t* dev, struct zsAdditionInfo* addInfo) +{ + u32_t rxRateKbps; + zmw_get_wlan_dev(dev); + //zm_msg1_mm(ZM_LV_0, "addInfo->Tail.Data.RxMacStatus =", addInfo->Tail.Data.RxMacStatus & 0x03); + + /* b5~b4: MPDU indication. */ + /* 00: Single MPDU. */ + /* 10: First MPDU of A-MPDU. */ + /* 11: Middle MPDU of A-MPDU. */ + /* 01: Last MPDU of A-MPDU. */ + /* Only First MPDU and Single MPDU have PLCP header */ + /* First MPDU : (mpduInd & 0x30) == 0x00 */ + /* Single MPDU : (mpduInd & 0x30) == 0x20 */ + if ((addInfo->Tail.Data.RxMacStatus & 0x10) == 0) + { + /* Modulation type */ + wd->modulationType = addInfo->Tail.Data.RxMacStatus & 0x03; + switch(wd->modulationType) + { + case 0x0: wd->rateField = addInfo->PlcpHeader[0] & 0xff; //CCK mode + wd->rxInfo = 0; + break; + case 0x1: wd->rateField = addInfo->PlcpHeader[0] & 0x0f; //Legacy-OFDM mode + wd->rxInfo = 0; + break; + case 0x2: wd->rateField = addInfo->PlcpHeader[3]; //HT-OFDM mode + wd->rxInfo = addInfo->PlcpHeader[6]; + break; + default: break; + } + + rxRateKbps = zfUpdateRxRate(dev); + if (wd->CurrentRxRateUpdated == 1) + { + if (rxRateKbps > wd->CurrentRxRateKbps) + { + wd->CurrentRxRateKbps = rxRateKbps; + } + } + else + { + wd->CurrentRxRateKbps = rxRateKbps; + wd->CurrentRxRateUpdated = 1; + } + } +} +#if 0 +u16_t zcIndextoRateBG[16] = {1000, 2000, 5500, 11000, 0, 0, 0, 0, 48000, + 24000, 12000, 6000, 54000, 36000, 18000, 9000}; +u32_t zcIndextoRateN20L[16] = {6500, 13000, 19500, 26000, 39000, 52000, 58500, + 65000, 13000, 26000, 39000, 52000, 78000, 104000, + 117000, 130000}; +u32_t zcIndextoRateN20S[16] = {7200, 14400, 21700, 28900, 43300, 57800, 65000, + 72200, 14400, 28900, 43300, 57800, 86700, 115600, + 130000, 144400}; +u32_t zcIndextoRateN40L[16] = {13500, 27000, 40500, 54000, 81000, 108000, 121500, + 135000, 27000, 54000, 81000, 108000, 162000, 216000, + 243000, 270000}; +u32_t zcIndextoRateN40S[16] = {15000, 30000, 45000, 60000, 90000, 120000, 135000, + 150000, 30000, 60000, 90000, 120000, 180000, 240000, + 270000, 300000}; +#endif + +extern u16_t zcIndextoRateBG[16]; +extern u32_t zcIndextoRateN20L[16]; +extern u32_t zcIndextoRateN20S[16]; +extern u32_t zcIndextoRateN40L[16]; +extern u32_t zcIndextoRateN40S[16]; + +u32_t zfiWlanQueryRxRate(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + wd->CurrentRxRateUpdated = 0; + return wd->CurrentRxRateKbps; +} + +u32_t zfUpdateRxRate(zdev_t* dev) +{ + u8_t mcs, bandwidth; + u32_t rxRateKbps = 130000; + zmw_get_wlan_dev(dev); + + switch (wd->modulationType) + { + case 0x0: //CCK mode + switch (wd->rateField) + { + case 0x0a: rxRateKbps = 1000; + break; + case 0x14: rxRateKbps = 2000; + + case 0x37: rxRateKbps = 5500; + break; + case 0x6e: rxRateKbps = 11000; + break; + default: + break; + } + break; + case 0x1: //Legacy-OFDM mode + if (wd->rateField <= 15) + { + rxRateKbps = zcIndextoRateBG[wd->rateField]; + } + break; + case 0x2: //HT-OFDM mode + mcs = wd->rateField & 0x7F; + bandwidth = wd->rateField & 0x80; + if (mcs <= 15) + { + if (bandwidth != 0) + { + if((wd->rxInfo & 0x80) != 0) + { + /* Short GI 40 MHz MIMO Rate */ + rxRateKbps = zcIndextoRateN40S[mcs]; + } + else + { + /* Long GI 40 MHz MIMO Rate */ + rxRateKbps = zcIndextoRateN40L[mcs]; + } + } + else + { + if((wd->rxInfo & 0x80) != 0) + { + /* Short GI 20 MHz MIMO Rate */ + rxRateKbps = zcIndextoRateN20S[mcs]; + } + else + { + /* Long GI 20 MHz MIMO Rate */ + rxRateKbps = zcIndextoRateN20L[mcs]; + } + } + } + break; + default: + break; + } + //zm_msg1_mm(ZM_LV_0, "wd->CurrentRxRateKbps=", wd->CurrentRxRateKbps); + + // ToDo: use bandwith field to define 40MB + return rxRateKbps; +} + +/* Get WLAN stastics */ +u16_t zfiWlanGetStatistics(zdev_t* dev) +{ + /* Return link statistics */ + return 0; +} + +u16_t zfiWlanReset(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + wd->state = ZM_WLAN_STATE_DISABLED; + + return zfWlanReset(dev); +} + +/* Reset WLAN */ +u16_t zfWlanReset(zdev_t* dev) +{ + u8_t isConnected; + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zm_debug_msg0("zfWlanReset"); + + isConnected = zfStaIsConnected(dev); + + //if ( wd->wlanMode != ZM_MODE_AP ) + { + if ( (wd->wlanMode == ZM_MODE_INFRASTRUCTURE)&& + (wd->sta.currentAuthMode != ZM_AUTH_MODE_WPA2) ) + { + /* send deauthentication frame */ + if (isConnected) + { + //zfiWlanDeauth(dev, NULL, 0); + zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, wd->sta.bssid, 3, 0, 0); + //zmw_debug_msg0("send a Deauth frame!"); + } + } + } + + zfChangeAdapterState(dev, ZM_STA_STATE_DISCONNECT); + zfHpResetKeyCache(dev); + + if (isConnected) + { + //zfiWlanDisable(dev); + if (wd->zfcbConnectNotify != NULL) + { + wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_CONNECTION_RESET, wd->sta.bssid); + } + } + else + { + if (wd->zfcbConnectNotify != NULL) + { + wd->zfcbConnectNotify(dev, ZM_STATUS_MEDIA_RESET, wd->sta.bssid); + } + } + + /* stop beacon */ + zfHpDisableBeacon(dev); + + /* Free buffer in defragment list*/ + zfAgingDefragList(dev, 1); + + /* Flush VTxQ and MmQ */ + zfFlushVtxq(dev); + + #ifdef ZM_ENABLE_AGGREGATION + /* add by honda */ + zfAggRxFreeBuf(dev, 0); //1 for release structure memory + /* end of add by honda */ + #endif + + zfStaRefreshBlockList(dev, 1); + + zmw_enter_critical_section(dev); + + zfTimerCancel(dev, ZM_EVENT_IBSS_MONITOR); + zfTimerCancel(dev, ZM_EVENT_CM_BLOCK_TIMER); + zfTimerCancel(dev, ZM_EVENT_CM_DISCONNECT); + + wd->sta.connectState = ZM_STA_CONN_STATE_NONE; + wd->sta.connectByReasso = FALSE; + wd->sta.cmDisallowSsidLength = 0; + wd->sta.bAutoReconnect = 0; + wd->sta.InternalScanReq = 0; + wd->sta.encryMode = ZM_NO_WEP; + wd->sta.wepStatus = ZM_ENCRYPTION_WEP_DISABLED; + wd->sta.wpaState = ZM_STA_WPA_STATE_INIT; + wd->sta.cmMicFailureCount = 0; + wd->sta.ibssBssIsCreator = 0; +#ifdef ZM_ENABLE_IBSS_WPA2PSK + wd->sta.ibssWpa2Psk = 0; +#endif + /* reset connect timeout counter */ + wd->sta.connectTimeoutCount = 0; + + /* reset leap enable variable */ + wd->sta.leapEnabled = 0; + + /* Reset the RIFS Status / RIFS-like frame count / RIFS count */ + if( wd->sta.rifsState == ZM_RIFS_STATE_DETECTED ) + zfHpDisableRifs(dev); + wd->sta.rifsState = ZM_RIFS_STATE_DETECTING; + wd->sta.rifsLikeFrameCnt = 0; + wd->sta.rifsCount = 0; + + wd->sta.osRxFilter = 0; + wd->sta.bSafeMode = 0; + + // Clear the information for the peer stations of IBSS or AP of Station mode + zfZeroMemory((u8_t*)wd->sta.oppositeInfo, sizeof(struct zsOppositeInfo) * ZM_MAX_OPPOSITE_COUNT); + + zmw_leave_critical_section(dev); + + zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_INTERNAL); + zfScanMgrScanStop(dev, ZM_SCAN_MGR_SCAN_EXTERNAL); + + /* Turn off Software WEP/TKIP */ + if (wd->sta.SWEncryptEnable != 0) + { + zm_debug_msg0("Disable software encryption"); + zfStaDisableSWEncryption(dev); + } + + /* Improve WEP/TKIP performace with HT AP, detail information please look bug#32495 */ + //zfHpSetTTSIFSTime(dev, 0x8); + + /* Keep Pseudo mode */ + if ( wd->wlanMode != ZM_MODE_PSEUDO ) + { + wd->wlanMode = ZM_MODE_INFRASTRUCTURE; + } + return 0; +} + +/* Deauthenticate a STA */ +u16_t zfiWlanDeauth(zdev_t* dev, u16_t* macAddr, u16_t reason) +{ + zmw_get_wlan_dev(dev); + + if ( wd->wlanMode == ZM_MODE_AP ) + { + //u16_t id; + + /* + * we will reset all key in zfHpResetKeyCache() when call + * zfiWlanDisable(), if we want to reset PairwiseKey for each sta, + * need to use a nullAddr to let keyindex not match. + * otherwise hardware will still find PairwiseKey when AP change + * encryption mode from WPA to WEP + */ + + /* + if ((id = zfApFindSta(dev, macAddr)) != 0xffff) + { + u32_t key[8]; + u16_t nullAddr[3] = { 0x0, 0x0, 0x0 }; + + if (wd->ap.staTable[i].encryMode != ZM_NO_WEP) + { + zfHpSetApPairwiseKey(dev, nullAddr, + ZM_NO_WEP, &key[0], &key[4], i+1); + } + //zfHpSetApPairwiseKey(dev, (u16_t *)macAddr, + // ZM_NO_WEP, &key[0], &key[4], id+1); + wd->ap.staTable[id].encryMode = ZM_NO_WEP; + wd->ap.staTable[id].keyIdx = 0xff; + } + */ + + zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, macAddr, reason, 0, 0); + } + else + { + zfSendMmFrame(dev, ZM_WLAN_FRAME_TYPE_DEAUTH, wd->sta.bssid, 3, 0, 0); + } + + /* Issue DEAUTH command to FW */ + return 0; +} + + +/* XP packet filter feature : */ +/* 1=>enable: All multicast address packets, not just the ones enumerated in the multicast address list. */ +/* 0=>disable */ +void zfiWlanSetAllMulticast(zdev_t* dev, u32_t setting) +{ + zmw_get_wlan_dev(dev); + zm_msg1_mm(ZM_LV_0, "sta.bAllMulticast = ", setting); + wd->sta.bAllMulticast = (u8_t)setting; +} + + +/* HT configure API */ +void zfiWlanSetHTCtrl(zdev_t* dev, u32_t *setting, u32_t forceTxTPC) +{ + zmw_get_wlan_dev(dev); + + wd->preambleType = (u8_t)setting[0]; + wd->sta.preambleTypeHT = (u8_t)setting[1]; + wd->sta.htCtrlBandwidth = (u8_t)setting[2]; + wd->sta.htCtrlSTBC = (u8_t)setting[3]; + wd->sta.htCtrlSG = (u8_t)setting[4]; + wd->sta.defaultTA = (u8_t)setting[5]; + wd->enableAggregation = (u8_t)setting[6]; + wd->enableWDS = (u8_t)setting[7]; + + wd->forceTxTPC = forceTxTPC; +} + +/* FB50 in OS XP, RD private test code */ +void zfiWlanQueryHTCtrl(zdev_t* dev, u32_t *setting, u32_t *forceTxTPC) +{ + zmw_get_wlan_dev(dev); + + setting[0] = wd->preambleType; + setting[1] = wd->sta.preambleTypeHT; + setting[2] = wd->sta.htCtrlBandwidth; + setting[3] = wd->sta.htCtrlSTBC; + setting[4] = wd->sta.htCtrlSG; + setting[5] = wd->sta.defaultTA; + setting[6] = wd->enableAggregation; + setting[7] = wd->enableWDS; + + *forceTxTPC = wd->forceTxTPC; +} + +void zfiWlanDbg(zdev_t* dev, u8_t setting) +{ + zmw_get_wlan_dev(dev); + + wd->enableHALDbgInfo = setting; +} + +/* FB50 in OS XP, RD private test code */ +void zfiWlanSetRxPacketDump(zdev_t* dev, u32_t setting) +{ + zmw_get_wlan_dev(dev); + if (setting) + { + wd->rxPacketDump = 1; /* enable */ + } + else + { + wd->rxPacketDump = 0; /* disable */ + } +} + + +/* FB50 in OS XP, RD private test code */ +/* Tally */ +void zfiWlanResetTally(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + + wd->commTally.txUnicastFrm = 0; //txUnicastFrames + wd->commTally.txMulticastFrm = 0; //txMulticastFrames + wd->commTally.txUnicastOctets = 0; //txUniOctets byte size + wd->commTally.txMulticastOctets = 0; //txMultiOctets byte size + wd->commTally.txFrmUpperNDIS = 0; + wd->commTally.txFrmDrvMgt = 0; + wd->commTally.RetryFailCnt = 0; + wd->commTally.Hw_TotalTxFrm = 0; //Hardware total Tx Frame + wd->commTally.Hw_RetryCnt = 0; //txMultipleRetriesFrames + wd->commTally.Hw_UnderrunCnt = 0;// + wd->commTally.DriverRxFrmCnt = 0;// + wd->commTally.rxUnicastFrm = 0; //rxUnicastFrames + wd->commTally.rxMulticastFrm = 0; //rxMulticastFrames + wd->commTally.NotifyNDISRxFrmCnt = 0;// + wd->commTally.rxUnicastOctets = 0; //rxUniOctets byte size + wd->commTally.rxMulticastOctets = 0; //rxMultiOctets byte size + wd->commTally.DriverDiscardedFrm = 0;// Discard by ValidateFrame + wd->commTally.LessThanDataMinLen = 0;// + wd->commTally.GreaterThanMaxLen = 0;// + wd->commTally.DriverDiscardedFrmCauseByMulticastList = 0; + wd->commTally.DriverDiscardedFrmCauseByFrmCtrl = 0; + wd->commTally.rxNeedFrgFrm = 0; // need more frg frm + wd->commTally.DriverRxMgtFrmCnt = 0; + wd->commTally.rxBroadcastFrm = 0; //Receive broadcast frame count + wd->commTally.rxBroadcastOctets = 0; //Receive broadcast frame byte size + wd->commTally.Hw_TotalRxFrm = 0;// + wd->commTally.Hw_CRC16Cnt = 0; //rxPLCPCRCErrCnt + wd->commTally.Hw_CRC32Cnt = 0; //rxCRC32ErrCnt + wd->commTally.Hw_DecrypErr_UNI = 0;// + wd->commTally.Hw_DecrypErr_Mul = 0;// + wd->commTally.Hw_RxFIFOOverrun = 0;// + wd->commTally.Hw_RxTimeOut = 0; + wd->commTally.LossAP = 0;// + + wd->commTally.Tx_MPDU = 0; + wd->commTally.BA_Fail = 0; + wd->commTally.Hw_Tx_AMPDU = 0; + wd->commTally.Hw_Tx_MPDU = 0; + + wd->commTally.txQosDropCount[0] = 0; + wd->commTally.txQosDropCount[1] = 0; + wd->commTally.txQosDropCount[2] = 0; + wd->commTally.txQosDropCount[3] = 0; + wd->commTally.txQosDropCount[4] = 0; + + wd->commTally.Hw_RxMPDU = 0; + wd->commTally.Hw_RxDropMPDU = 0; + wd->commTally.Hw_RxDelMPDU = 0; + + wd->commTally.Hw_RxPhyMiscError = 0; + wd->commTally.Hw_RxPhyXRError = 0; + wd->commTally.Hw_RxPhyOFDMError = 0; + wd->commTally.Hw_RxPhyCCKError = 0; + wd->commTally.Hw_RxPhyHTError = 0; + wd->commTally.Hw_RxPhyTotalCount = 0; + +#if (defined(GCCK) && defined(OFDM)) + wd->commTally.rx11bDataFrame = 0; + wd->commTally.rxOFDMDataFrame = 0; +#endif + + zmw_leave_critical_section(dev); +} + +/* FB50 in OS XP, RD private test code */ +void zfiWlanQueryTally(zdev_t* dev, struct zsCommTally *tally) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + zfMemoryCopy((u8_t*)tally, (u8_t*)&wd->commTally, sizeof(struct zsCommTally)); + zmw_leave_critical_section(dev); +} +void zfiWlanQueryTrafTally(zdev_t* dev, struct zsTrafTally *tally) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + zfMemoryCopy((u8_t*)tally, (u8_t*)&wd->trafTally, sizeof(struct zsTrafTally)); + zmw_leave_critical_section(dev); +} + +void zfiWlanQueryMonHalRxInfo(zdev_t* dev, struct zsMonHalRxInfo *monHalRxInfo) +{ + zfHpQueryMonHalRxInfo(dev, (u8_t *)monHalRxInfo); +} + +/* parse the modeMDKEnable to DrvCore */ +void zfiDKEnable(zdev_t* dev, u32_t enable) +{ + zmw_get_wlan_dev(dev); + + wd->modeMDKEnable = enable; + zm_debug_msg1("modeMDKEnable = ", wd->modeMDKEnable); +} + +/* airoPeek */ +u32_t zfiWlanQueryPacketTypePromiscuous(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->swSniffer; +} + +/* airoPeek */ +void zfiWlanSetPacketTypePromiscuous(zdev_t* dev, u32_t setValue) +{ + zmw_get_wlan_dev(dev); + + wd->swSniffer = setValue; + zm_msg1_mm(ZM_LV_0, "wd->swSniffer ", wd->swSniffer); + if (setValue) + { + /* write register for sniffer mode */ + zfHpSetSnifferMode(dev, 1); + zm_msg0_mm(ZM_LV_1, "enalbe sniffer mode"); + } + else + { + zfHpSetSnifferMode(dev, 0); + zm_msg0_mm(ZM_LV_0, "disalbe sniffer mode"); + } +} + +void zfiWlanSetXLinkMode(zdev_t* dev, u32_t setValue) +{ + zmw_get_wlan_dev(dev); + + wd->XLinkMode = setValue; + if (setValue) + { + /* write register for sniffer mode */ + zfHpSetSnifferMode(dev, 1); + } + else + { + zfHpSetSnifferMode(dev, 0); + } +} + +extern void zfStaChannelManagement(zdev_t* dev, u8_t scan); +void zfiSetChannelManagement(zdev_t* dev, u32_t setting) +{ + zmw_get_wlan_dev(dev); + + switch (setting) + { + case 1: + wd->sta.EnableHT = 1; + wd->BandWidth40 = 1; + wd->ExtOffset = 1; + break; + case 3: + wd->sta.EnableHT = 1; + wd->BandWidth40 = 1; + wd->ExtOffset = 3; + break; + case 0: + wd->sta.EnableHT = 1; + wd->BandWidth40 = 0; + wd->ExtOffset = 0; + break; + default: + wd->BandWidth40 = 0; + wd->ExtOffset = 0; + break; + + } + zfCoreSetFrequencyEx(dev, wd->frequency, wd->BandWidth40, + wd->ExtOffset, NULL); +} + +void zfiSetRifs(zdev_t* dev, u16_t setting) +{ + zmw_get_wlan_dev(dev); + + wd->sta.ie.HtInfo.ChannelInfo |= ExtHtCap_RIFSMode; + wd->sta.EnableHT = 1; + switch (setting) + { + case 0: + wd->sta.HT2040 = 0; +// zfHpSetRifs(dev, 1, 0, (wd->sta.currentFrequency < 3000)? 1:0); + break; + case 1: + wd->sta.HT2040 = 1; +// zfHpSetRifs(dev, 1, 1, (wd->sta.currentFrequency < 3000)? 1:0); + break; + default: + wd->sta.HT2040 = 0; +// zfHpSetRifs(dev, 1, 0, (wd->sta.currentFrequency < 3000)? 1:0); + break; + } +} + +void zfiCheckRifs(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + if(wd->sta.ie.HtInfo.ChannelInfo & ExtHtCap_RIFSMode) + { +// zfHpSetRifs(dev, wd->sta.EnableHT, wd->sta.HT2040, (wd->sta.currentFrequency < 3000)? 1:0); + } +} + +void zfiSetReorder(zdev_t* dev, u16_t value) +{ + zmw_get_wlan_dev(dev); + + wd->reorder = value; +} + +void zfiSetSeqDebug(zdev_t* dev, u16_t value) +{ + zmw_get_wlan_dev(dev); + + wd->seq_debug = value; +} |