From 4bd43f507c7e2f225f58235226a8381fd6bbff1a Mon Sep 17 00:00:00 2001 From: Luis R. Rodriguez Date: Mon, 27 Oct 2008 22:44:22 -0700 Subject: Staging: add otus Atheros wireless network driver Initial dump of the otus USB wireless network driver. It builds properly, but a lot of work needs to be done cleaning it up before it can be merged into the wireless driver tree. Signed-off-by: Luis R. Rodriguez Signed-off-by: Greg Kroah-Hartman --- drivers/staging/otus/80211core/coid.c | 2695 +++++++++++++++++++++++++++++++++ 1 file changed, 2695 insertions(+) create mode 100644 drivers/staging/otus/80211core/coid.c (limited to 'drivers/staging/otus/80211core/coid.c') diff --git a/drivers/staging/otus/80211core/coid.c b/drivers/staging/otus/80211core/coid.c new file mode 100644 index 000000000000..6007f3131f8f --- /dev/null +++ b/drivers/staging/otus/80211core/coid.c @@ -0,0 +1,2695 @@ +/* + * 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 : iod.c */ +/* */ +/* Abstract */ +/* This module contains OID functions. */ +/* */ +/* NOTES */ +/* None */ +/* */ +/************************************************************************/ +#include "cprecomp.h" +#include "../hal/hpreg.h" + +/************************************************************************/ +/* */ +/* FUNCTION DESCRIPTION zfiWlanQueryMacAddress */ +/* Query OWN MAC address. */ +/* */ +/* INPUTS */ +/* addr : for return MAC address */ +/* */ +/* OUTPUTS */ +/* None */ +/* */ +/* AUTHOR */ +/* Stephen Chen ZyDAS Technology Corporation 2005.10 */ +/* */ +/************************************************************************/ +void zfiWlanQueryMacAddress(zdev_t* dev, u8_t* addr) +{ + u16_t vapId = 0; + zmw_get_wlan_dev(dev); + + vapId = zfwGetVapId(dev); + + addr[0] = (u8_t)(wd->macAddr[0] & 0xff); + addr[1] = (u8_t)(wd->macAddr[0] >> 8); + addr[2] = (u8_t)(wd->macAddr[1] & 0xff); + addr[3] = (u8_t)(wd->macAddr[1] >> 8); + addr[4] = (u8_t)(wd->macAddr[2] & 0xff); + if (vapId == 0xffff) + addr[5] = (u8_t)(wd->macAddr[2] >> 8); + else + { +#ifdef ZM_VAPMODE_MULTILE_SSID + addr[5] = (u8_t)(wd->macAddr[2] >> 8); // Multiple SSID +#else + addr[5] = vapId + 1 + (u8_t)(wd->macAddr[2] >> 8); //VAP +#endif + } + + return; +} + +void zfiWlanQueryBssList(zdev_t* dev, struct zsBssList* pBssList) +{ + struct zsBssInfo* pBssInfo; + struct zsBssInfo* pDstBssInfo; + u8_t i; + u8_t* pMemList; + u8_t* pMemInfo; + + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + pMemList = (u8_t*) pBssList; + pMemInfo = pMemList + sizeof(struct zsBssList); + pBssList->head = (struct zsBssInfo*) pMemInfo; + + zmw_enter_critical_section(dev); + + pBssInfo = wd->sta.bssList.head; + pDstBssInfo = (struct zsBssInfo*) pMemInfo; + pBssList->bssCount = wd->sta.bssList.bssCount; + + for( i=0; ista.bssList.bssCount; i++ ) + { + zfMemoryCopy((u8_t*)pDstBssInfo, (u8_t*)pBssInfo, + sizeof(struct zsBssInfo)); + + if ( pBssInfo->next != NULL ) + { + pBssInfo = pBssInfo->next; + pDstBssInfo->next = pDstBssInfo + 1; + pDstBssInfo++; + } + else + { + zm_assert(i==(wd->sta.bssList.bssCount-1)); + } + } + + zmw_leave_critical_section(dev); + + zfScanMgrScanAck(dev); +} + +void zfiWlanQueryBssListV1(zdev_t* dev, struct zsBssListV1* bssListV1) +{ + struct zsBssInfo* pBssInfo; + //struct zsBssInfo* pDstBssInfo; + u8_t i, j, bdrop = 0, k = 0, Same_Count = 0; + u8_t bssid[6]; + //u8_t* pMemList; + //u8_t* pMemInfo; + zmw_get_wlan_dev(dev); + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + + bssListV1->bssCount = wd->sta.bssList.bssCount; + + pBssInfo = wd->sta.bssList.head; + ZM_MAC_WORD_TO_BYTE(wd->sta.bssid, bssid); + + for( i=0; ista.bssList.bssCount; i++ ) + { + bdrop = 0; + if ( zfStaIsConnected(dev) + && (wd->wlanMode == ZM_MODE_INFRASTRUCTURE ) ) + { + for (j = 0; j < 6; j++) + { + if ( pBssInfo->bssid[j] != bssid[j] ) + { + break; + } + } + + if ( (j == 6) + &&((pBssInfo->ssid[1] == wd->sta.ssidLen) || (pBssInfo->ssid[1] == 0) )&& (pBssInfo->frequency == wd->frequency) ) + { + if(pBssInfo->ssid[1] == 0) + pBssInfo->ssid[1] = wd->sta.ssidLen; + + if(Same_Count == 0) + {//First meet + Same_Count++; + } + else + {//same one + bdrop = 1; + bssListV1->bssCount--; + } + + } + } + + if (bdrop == 0) + { + zfMemoryCopy((u8_t*)(&bssListV1->bssInfo[k]), (u8_t*)pBssInfo, + sizeof(struct zsBssInfo)); + + if(Same_Count == 1) + { + zfMemoryCopy(&(bssListV1->bssInfo[k].ssid[2]), wd->sta.ssid, wd->sta.ssidLen); + Same_Count++; + } + + k++; + } + + if ( pBssInfo->next != NULL ) + { + pBssInfo = pBssInfo->next; + } + else + { + zm_assert(i==(wd->sta.bssList.bssCount-1)); + } + } + + zmw_leave_critical_section(dev); + + zfScanMgrScanAck(dev); +} + +void zfiWlanQueryAdHocCreatedBssDesc(zdev_t* dev, struct zsBssInfo *pBssInfo) +{ + zmw_get_wlan_dev(dev); + + zfMemoryCopy((u8_t *)pBssInfo, (u8_t *)&wd->sta.ibssBssDesc, sizeof(struct zsBssInfo)); +} + +u8_t zfiWlanQueryAdHocIsCreator(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->sta.ibssBssIsCreator; +} + +u32_t zfiWlanQuerySupportMode(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->supportMode; +} + +u32_t zfiWlanQueryTransmitPower(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + u32_t ret = 0; + + if (zfStaIsConnected(dev)) { + ret = wd->sta.connPowerInHalfDbm; + } else { + ret = zfHpGetTransmitPower(dev); + } + + return ret; +} + +/************************************************************************/ +/* */ +/* FUNCTION DESCRIPTION zfiWlanFlushBssList */ +/* Flush BSSID List. */ +/* */ +/* INPUTS */ +/* dev : device pointer */ +/* */ +/* OUTPUTS */ +/* none */ +/* */ +/* AUTHOR */ +/* Stephen Chen Atheros Communications, INC. 2006.12 */ +/* */ +/************************************************************************/ +void zfiWlanFlushBssList(zdev_t* dev) +{ + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + /* Call zfBssInfoRefresh() twice to remove all entry */ + zfBssInfoRefresh(dev, 1); + zmw_leave_critical_section(dev); +} + +void zfiWlanSetWlanMode(zdev_t* dev, u8_t wlanMode) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + wd->ws.wlanMode = wlanMode; + zmw_leave_critical_section(dev); +} + +void zfiWlanSetAuthenticationMode(zdev_t* dev, u8_t authMode) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + wd->ws.authMode = authMode; + zmw_leave_critical_section(dev); +} + +void zfiWlanSetWepStatus(zdev_t* dev, u8_t wepStatus) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + wd->ws.wepStatus = wepStatus; + zmw_leave_critical_section(dev); + +} + +void zfiWlanSetSSID(zdev_t* dev, u8_t* ssid, u8_t ssidLength) +{ + u16_t i; + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + if ( ssidLength <= 32 ) + { + zmw_enter_critical_section(dev); + + wd->ws.ssidLen = ssidLength; + zfMemoryCopy(wd->ws.ssid, ssid, ssidLength); + + if ( ssidLength < 32 ) + { + wd->ws.ssid[ssidLength] = 0; + } + + wd->ws.probingSsidList[0].ssidLen = ssidLength; + zfMemoryCopy(wd->ws.probingSsidList[0].ssid, ssid, ssidLength); + for (i=1; iws.probingSsidList[i].ssidLen = 0; + } + + zmw_leave_critical_section(dev); + } +} + +void zfiWlanSetFragThreshold(zdev_t* dev, u16_t fragThreshold) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + + if (fragThreshold == 0) + { /* fragmentation is disabled */ + wd->fragThreshold = 32767; + } + else if (fragThreshold < 256) + { + /* Minimum fragment threshold */ + wd->fragThreshold = 256; + } + else if (fragThreshold > 2346) + { + wd->fragThreshold = 2346; + } + else + { + wd->fragThreshold = fragThreshold & 0xfffe; + } + + zmw_leave_critical_section(dev); +} + +void zfiWlanSetRtsThreshold(zdev_t* dev, u16_t rtsThreshold) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + wd->rtsThreshold = rtsThreshold; + zmw_leave_critical_section(dev); +} + +void zfiWlanSetFrequency(zdev_t* dev, u32_t frequency, u8_t bImmediate) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + if ( bImmediate ) + { + zmw_enter_critical_section(dev); + wd->frequency = (u16_t) (frequency/1000); + zmw_leave_critical_section(dev); + zfCoreSetFrequency(dev, wd->frequency); + } + else + { + zmw_enter_critical_section(dev); + if( frequency == 0 ) + { // Auto select clean channel depend on wireless environment ! + wd->ws.autoSetFrequency = 0; + } + wd->ws.frequency = (u16_t) (frequency/1000); + zmw_leave_critical_section(dev); + } +} + +void zfiWlanSetBssid(zdev_t* dev, u8_t* bssid) +{ + u16_t i; + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + for (i=0; i<6; i++) + { + wd->ws.desiredBssid[i] = bssid[i]; + } + wd->ws.bDesiredBssid = TRUE; + zmw_leave_critical_section(dev); + +} + +void zfiWlanSetBeaconInterval(zdev_t* dev, + u16_t beaconInterval, + u8_t bImmediate) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + if ( bImmediate ) + { + zmw_enter_critical_section(dev); + wd->beaconInterval = beaconInterval; + zmw_leave_critical_section(dev); + + /* update beacon interval here */ + } + else + { + zmw_enter_critical_section(dev); + wd->ws.beaconInterval = beaconInterval; + zmw_leave_critical_section(dev); + } +} + + +void zfiWlanSetDtimCount(zdev_t* dev, u8_t dtim) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + if (dtim > 0) + { + wd->ws.dtim = dtim; + } + zmw_leave_critical_section(dev); +} + + +void zfiWlanSetAtimWindow(zdev_t* dev, u16_t atimWindow, u8_t bImmediate) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + if ( bImmediate ) + { + zmw_enter_critical_section(dev); + wd->sta.atimWindow = atimWindow; + zmw_leave_critical_section(dev); + + /* atim window here */ + } + else + { + zmw_enter_critical_section(dev); + wd->ws.atimWindow = atimWindow; + zmw_leave_critical_section(dev); + } +} + + +void zfiWlanSetEncryMode(zdev_t* dev, u8_t encryMode) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + if (wd->wlanMode == ZM_MODE_AP) + { + /* Hostapd Issue */ + if ((wd->ws.encryMode != ZM_AES) && (wd->ws.encryMode != ZM_TKIP)) + wd->ws.encryMode = encryMode; + } + else + wd->ws.encryMode = encryMode; + zmw_leave_critical_section(dev); +} + +void zfiWlanSetDefaultKeyId(zdev_t* dev, u8_t keyId) +{ + zmw_get_wlan_dev(dev); + + wd->sta.keyId = keyId; +} + +u8_t zfiWlanQueryIsPKInstalled(zdev_t *dev, u8_t *staMacAddr) +{ + u8_t isInstalled = 0; + +#if 1 +//#ifdef ZM_ENABLE_IBSS_WPA2PSK + u8_t res, peerIdx; + + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + res = zfStaFindOppositeByMACAddr(dev, (u16_t *)staMacAddr, &peerIdx); + if( res == 0 ) + { + isInstalled = wd->sta.oppositeInfo[peerIdx].pkInstalled; + } + zmw_leave_critical_section(dev); +//#endif +#endif + + return isInstalled; +} + +u8_t zfiWlanSetKey(zdev_t* dev, struct zsKeyInfo keyInfo) +{ + u16_t broadcast[3] = {0xffff, 0xffff, 0xffff}; + u32_t* key; + u8_t encryMode = ZM_NO_WEP; +#ifdef ZM_ENABLE_IBSS_WPA2PSK + u8_t encryType = ZM_NO_WEP; +#endif + u8_t micKey[16]; + u16_t id = 0; + u8_t vapId, i, addr[6]; + u8_t userIdx=0; + +#ifdef ZM_ENABLE_IBSS_WPA2PSK + /* Determine opposite exist or not */ + u8_t res, peerIdx; +// u8_t userIdx=0; + + zmw_get_wlan_dev(dev); + + if ( wd->sta.ibssWpa2Psk == 1 ) + { + zmw_enter_critical_section(dev); + res = zfStaFindOppositeByMACAddr(dev, (u16_t*)keyInfo.macAddr, &peerIdx); + if( res == 0 ) + { + userIdx = peerIdx; + if ( wd->sta.oppositeInfo[userIdx].camIdx == 0xff ) + wd->sta.oppositeInfo[userIdx].camIdx = userIdx; + } + zmw_leave_critical_section(dev); + } +#else + zmw_get_wlan_dev(dev); +#endif + + if ( keyInfo.flag & ZM_KEY_FLAG_AUTHENTICATOR ) + { /* set key by authenticator */ + /* set pairwise key */ + if (keyInfo.flag & ZM_KEY_FLAG_PK) + { + /* Find STA's information */ + if ((id = zfApFindSta(dev, keyInfo.macAddr)) == 0xffff) + { + /* Can't STA in the staTable */ + return ZM_STATUS_FAILURE; + } + + wd->ap.staTable[id].iv16 = 0; + wd->ap.staTable[id].iv32 = 0; + + if (keyInfo.keyLength == 32) + { /* TKIP */ + //u8_t KeyRsc[6] = {0, 0, 0, 0, 0, 0}; + + /* In the current AP mode, we set KeyRsc to zero */ + //zfTkipInit(keyInfo.key, (u8_t*) wd->macAddr, + // &(wd->ap.staTable[id].txSeed), KeyRsc); + //zfTkipInit(keyInfo.key, (u8_t*) keyInfo.macAddr, + // &(wd->ap.staTable[id].rxSeed), KeyRsc); +#ifdef ZM_ENABLE_CENC + if (keyInfo.flag & ZM_KEY_FLAG_CENC) + { + zm_debug_msg0("Set CENC pairwise Key"); + + wd->ap.staTable[id].encryMode = ZM_CENC; + + /* Reset txiv and rxiv */ + wd->ap.staTable[id].txiv[0] = 0x5c365c37; + wd->ap.staTable[id].txiv[1] = 0x5c365c36; + wd->ap.staTable[id].txiv[2] = 0x5c365c36; + wd->ap.staTable[id].txiv[3] = 0x5c365c36; + + wd->ap.staTable[id].rxiv[0] = 0x5c365c36; + wd->ap.staTable[id].rxiv[1] = 0x5c365c36; + wd->ap.staTable[id].rxiv[2] = 0x5c365c36; + wd->ap.staTable[id].rxiv[3] = 0x5c365c36; + + /* Set Key Index */ + wd->ap.staTable[id].cencKeyIdx = keyInfo.keyIndex; + + //zfCoreSetKey(dev, id+1, 1, ZM_CENC, (u16_t *)keyInfo.macAddr, + // (u32_t*) &keyInfo.key[16]); + } + else +#endif //ZM_ENABLE_CENC + { + wd->ap.staTable[id].encryMode = ZM_TKIP; + + zfMemoryCopy(micKey, &keyInfo.key[16], 8); + zfMemoryCopy(&micKey[8], &keyInfo.key[24], 8); + + //zfCoreSetKey(dev, id+1, 1, ZM_TKIP, (u16_t *)keyInfo.macAddr, + // (u32_t*) micKey); + + /* For fragmentation, we use software MIC */ + zfMemoryCopy((u8_t *)&(wd->ap.staTable[id].txMicKey), &(keyInfo.key[16]), 8); + zfMemoryCopy((u8_t *)&(wd->ap.staTable[id].rxMicKey), &(keyInfo.key[24]), 8); + + } + } + else if (keyInfo.keyLength == 16) + { /* AES */ + wd->ap.staTable[id].encryMode = ZM_AES; + } + else if (keyInfo.keyLength == 0) + { + /* Clear Key Info */ + zfApClearStaKey(dev, (u16_t *)keyInfo.macAddr); + + return ZM_STATUS_SUCCESS; + } + else + { + return ZM_STATUS_FAILURE; + } + + //zfCoreSetKey(dev, id+1, 0, wd->ap.staTable[id].encryMode, + // (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key); + zfHpSetApPairwiseKey(dev, (u16_t *)keyInfo.macAddr, + wd->ap.staTable[id].encryMode, (u32_t*) keyInfo.key, + (u32_t*) &keyInfo.key[16], id+1); + wd->ap.staTable[id].keyIdx = id + 1 + 4; + } + else if (keyInfo.flag & ZM_KEY_FLAG_GK) + { + vapId = keyInfo.vapId; + + wd->ap.iv16[vapId] = 0; + wd->ap.iv32[vapId] = 0; + + if (keyInfo.keyLength == 32) + { /* TKIP */ + //u8_t KeyRsc[6] = {0, 0, 0, 0, 0, 0}; + + //zfTkipInit(keyInfo.key, (u8_t*) wd->macAddr, + // &(wd->ap.bcSeed), KeyRsc); +#ifdef ZM_ENABLE_CENC + if (keyInfo.flag & ZM_KEY_FLAG_CENC) + { + encryMode = ZM_CENC; + zm_debug_msg0("Set CENC group Key"); + + /* Reset txiv and rxiv */ + wd->ap.txiv[vapId][0] = 0x5c365c36; + wd->ap.txiv[vapId][1] = 0x5c365c36; + wd->ap.txiv[vapId][2] = 0x5c365c36; + wd->ap.txiv[vapId][3] = 0x5c365c36; + + //zfCoreSetKey(dev, 0, 1, ZM_CENC, keyInfo.vapAddr, + // (u32_t*) &keyInfo.key[16]); + key = (u32_t*) keyInfo.key; + } + else +#endif //ZM_ENABLE_CENC + { + encryMode = ZM_TKIP; + key = (u32_t *)keyInfo.key; + + /* set MIC key to HMAC */ + //zfCoreSetKey(dev, 0, 1, ZM_TKIP, broadcast, + // (u32_t*) (&keyInfo.key[16])); + //zfCoreSetKey(dev, 0, 1, ZM_TKIP, keyInfo.vapAddr, + // (u32_t*) (&keyInfo.key[16])); + + zfMicSetKey(&(keyInfo.key[16]), &(wd->ap.bcMicKey[0])); + key = (u32_t*) keyInfo.key; + } + } + else if (keyInfo.keyLength == 16) + { /* AES */ + encryMode = ZM_AES; + key = (u32_t *)keyInfo.key; + zm_debug_msg0("CWY - Set AES Group Key"); + } + else if (keyInfo.keyLength == 0) + { + /* Clear Key Info */ + zfApClearStaKey(dev, broadcast); + + /* Turn off WEP bit in the capability field */ + wd->ap.capab[vapId] &= 0xffef; + + return ZM_STATUS_SUCCESS; + } + else + { /* WEP */ + if (keyInfo.keyLength == 5) + { + encryMode = ZM_WEP64; + } + else if (keyInfo.keyLength == 13) + { + encryMode = ZM_WEP128; + } + else if (keyInfo.keyLength == 29) + { + encryMode = ZM_WEP256; + } + + key = (u32_t*) keyInfo.key; + } + + // Modification for CAM not support VAP search + //zfCoreSetKey(dev, 0, 0, encryMode, broadcast, key); + //zfCoreSetKey(dev, 0, 0, encryMode, wd->macAddr, key); + //zfCoreSetKey(dev, 0, 0, encryMode, keyInfo.vapAddr, key); + zfHpSetApGroupKey(dev, wd->macAddr, encryMode, + key, (u32_t*) &keyInfo.key[16], vapId); + + //zfiWlanSetEncryMode(dev, encryMode); + wd->ws.encryMode = encryMode; + + /* set the multicast address encryption type */ + wd->ap.encryMode[vapId] = encryMode; + + /* set the multicast key index */ + wd->ap.bcKeyIndex[vapId] = keyInfo.keyIndex; + wd->ap.bcHalKeyIdx[vapId] = vapId + 60; + + /* Turn on WEP bit in the capability field */ + wd->ap.capab[vapId] |= 0x10; + } + } + else + { /* set by supplicant */ + + if ( keyInfo.flag & ZM_KEY_FLAG_PK ) + { /* set pairwise key */ + + //zfTkipInit(keyInfo.key, (u8_t*) wd->macAddr, + // &wd->sta.txSeed, keyInfo.initIv); + //zfTkipInit(keyInfo.key, (u8_t*) wd->sta.bssid, + // &wd->sta.rxSeed[keyInfo.keyIndex], keyInfo.initIv); + +#ifdef ZM_ENABLE_IBSS_WPA2PSK + if ( wd->sta.ibssWpa2Psk == 1 ) + { + /* unicast -- > pairwise key */ + wd->sta.oppositeInfo[userIdx].iv16 = 0; + wd->sta.oppositeInfo[userIdx].iv32 = 0; + } + else + { + wd->sta.iv16 = 0; + wd->sta.iv32 = 0; + } + + wd->sta.oppositeInfo[userIdx].pkInstalled = 1; +#else + wd->sta.iv16 = 0; + wd->sta.iv32 = 0; + + wd->sta.oppositeInfo[userIdx].pkInstalled = 1; +#endif + + if ( keyInfo.keyLength == 32 ) + { /* TKIP */ + zfTkipInit(keyInfo.key, (u8_t*) wd->macAddr, + &wd->sta.txSeed, keyInfo.initIv); + zfTkipInit(keyInfo.key, (u8_t*) wd->sta.bssid, + &wd->sta.rxSeed[keyInfo.keyIndex], keyInfo.initIv); + +#ifdef ZM_ENABLE_CENC + if (keyInfo.flag & ZM_KEY_FLAG_CENC) + { + zm_debug_msg0("Set CENC pairwise Key"); + + wd->sta.encryMode = ZM_CENC; + + /* Reset txiv and rxiv */ + wd->sta.txiv[0] = 0x5c365c36; + wd->sta.txiv[1] = 0x5c365c36; + wd->sta.txiv[2] = 0x5c365c36; + wd->sta.txiv[3] = 0x5c365c36; + + wd->sta.rxiv[0] = 0x5c365c37; + wd->sta.rxiv[1] = 0x5c365c36; + wd->sta.rxiv[2] = 0x5c365c36; + wd->sta.rxiv[3] = 0x5c365c36; + + /* Set Key Index */ + wd->sta.cencKeyId = keyInfo.keyIndex; + + //zfCoreSetKey(dev, id+1, 1, ZM_CENC, (u16_t *)keyInfo.macAddr, + // (u32_t*) &keyInfo.key[16]); + } + else +#endif //ZM_ENABLE_CENC + { + wd->sta.encryMode = ZM_TKIP; + + //zfCoreSetKey(dev, 0, 1, ZM_TKIP, wd->sta.bssid, + // (u32_t*) &keyInfo.key[16]); + + zfMicSetKey(&keyInfo.key[16], &wd->sta.txMicKey); + zfMicSetKey(&keyInfo.key[24], + &wd->sta.rxMicKey[keyInfo.keyIndex]); + } + } + else if ( keyInfo.keyLength == 16 ) + { /* AES */ +#ifdef ZM_ENABLE_IBSS_WPA2PSK + if ( wd->sta.ibssWpa2Psk == 1 ) + { + wd->sta.oppositeInfo[userIdx].encryMode = ZM_AES; + encryType = wd->sta.oppositeInfo[userIdx].encryMode; + } + else + { + wd->sta.encryMode = ZM_AES; + encryType = wd->sta.encryMode; + } +#else + wd->sta.encryMode = ZM_AES; +#endif + } + else + { + return ZM_STATUS_FAILURE; + } + + /* user 0 */ + //zfCoreSetKey(dev, 0, 0, wd->sta.encryMode, + // wd->sta.bssid, (u32_t*) keyInfo.key); + //zfHpSetStaPairwiseKey(dev, wd->sta.bssid, wd->sta.encryMode, + // (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]); + +#ifdef ZM_ENABLE_IBSS_WPA2PSK + if ( (keyInfo.keyLength==16) && (wd->sta.ibssWpa2Psk==1) ) + { /* If not AES-CCMP and ibss network , use traditional */ + zfHpSetPerUserKey(dev, + userIdx, + keyInfo.keyIndex, // key id == 0 ( Pairwise key = 0 ) + (u8_t*)keyInfo.macAddr, // RX need Source Address ( Address 2 ) + encryType, +// wd->sta.encryMode, + (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]); + + wd->sta.oppositeInfo[userIdx].wpaState = ZM_STA_WPA_STATE_PK_OK ; + } + else + {/* Big Endian and Little Endian Compatibility */ + for (i = 0; i < 3; i++) + { + addr[2 * i] = wd->sta.bssid[i] & 0xff; + addr[2 * i + 1] = wd->sta.bssid[i] >> 8; + } + zfHpSetPerUserKey(dev, + ZM_USER_KEY_PK, // user id + 0, // key id + addr,//(u8_t *)wd->sta.bssid, + wd->sta.encryMode, + (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]); + + wd->sta.keyId = 4; + } +#else + /* Big Endian and Little Endian Compatibility */ + for (i = 0; i < 3; i++) + { + addr[2 * i] = wd->sta.bssid[i] & 0xff; + addr[2 * i + 1] = wd->sta.bssid[i] >> 8; + } + zfHpSetPerUserKey(dev, + ZM_USER_KEY_PK, // user id + 0, // key id + addr,//(u8_t *)wd->sta.bssid, + wd->sta.encryMode, + (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]); + + wd->sta.keyId = 4; +#endif + + wd->sta.wpaState = ZM_STA_WPA_STATE_PK_OK; + } + else if ( keyInfo.flag & ZM_KEY_FLAG_GK ) + { /* set group key */ + + zfTkipInit(keyInfo.key, (u8_t*) wd->sta.bssid, + &wd->sta.rxSeed[keyInfo.keyIndex], keyInfo.initIv); + + if ( keyInfo.keyLength == 32 ) + { /* TKIP */ +#ifdef ZM_ENABLE_CENC + if (keyInfo.flag & ZM_KEY_FLAG_CENC) + { + encryMode = ZM_CENC; + zm_debug_msg0("Set CENC group Key"); + + /* Reset txiv and rxiv */ + wd->sta.rxivGK[0] = 0x5c365c36; + wd->sta.rxivGK[1] = 0x5c365c36; + wd->sta.rxivGK[2] = 0x5c365c36; + wd->sta.rxivGK[3] = 0x5c365c36; + + //zfCoreSetKey(dev, 0, 1, ZM_CENC, keyInfo.vapAddr, + // (u32_t*) &keyInfo.key[16]); + key = (u32_t*) keyInfo.key; + } + else +#endif //ZM_ENABLE_CENC + { + encryMode = ZM_TKIP; + key = (u32_t*) wd->sta.rxSeed[keyInfo.keyIndex].tk; + + if ( !(keyInfo.flag & ZM_KEY_FLAG_INIT_IV) ) + { + wd->sta.rxSeed[keyInfo.keyIndex].iv16 = 0; + wd->sta.rxSeed[keyInfo.keyIndex].iv32 = 0; + } + + /* set MIC key to HMAC */ + //zfCoreSetKey(dev, 8, 1, ZM_TKIP, broadcast, + // (u32_t*) (&keyInfo.key[16])); + + zfMicSetKey(&keyInfo.key[24], + &wd->sta.rxMicKey[keyInfo.keyIndex]); + } + } + else if ( keyInfo.keyLength == 16 ) + { /* AES */ + encryMode = ZM_AES; + //key = (u32_t*) wd->sta.rxSeed[keyInfo.keyIndex].tk; + } + else + { /* WEP */ + if ( keyInfo.keyLength == 5 ) + { + encryMode = ZM_WEP64; + } + else if ( keyInfo.keyLength == 13 ) + { + encryMode = ZM_WEP128; + } + else if ( keyInfo.keyLength == 29 ) + { + encryMode = ZM_WEP256; + } + + key = (u32_t*) keyInfo.key; + } + + /* user 8 */ + //zfCoreSetKey(dev, 8, 0, encryMode, broadcast, key); + //zfHpSetStaGroupKey(dev, broadcast, encryMode, + // (u32_t*) keyInfo.key, (u32_t*) (&keyInfo.key[16])); + +#ifdef ZM_ENABLE_IBSS_WPA2PSK + if ( (keyInfo.keyLength==16) && (wd->sta.ibssWpa2Psk==1) ) + {/* If not AES-CCMP and ibss network , use traditional */ + zfHpSetPerUserKey(dev, + userIdx, + keyInfo.keyIndex, // key id + // (u8_t *)broadcast, // for only 2 stations IBSS netwrl ( A2 ) + (u8_t*)keyInfo.macAddr, // for multiple ( > 2 ) stations IBSS network ( A2 ) + encryMode, + (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]); + } + else + { + zfHpSetPerUserKey(dev, + ZM_USER_KEY_GK, // user id + 0, // key id + (u8_t *)broadcast, + encryMode, + (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]); + + wd->sta.wpaState = ZM_STA_WPA_STATE_GK_OK; + } +#else + zfHpSetPerUserKey(dev, + ZM_USER_KEY_GK, // user id + 0, // key id + (u8_t *)broadcast, + encryMode, + (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]); + + wd->sta.wpaState = ZM_STA_WPA_STATE_GK_OK; +#endif + } + else + { /* legacy WEP */ + zm_debug_msg0("legacy WEP"); + + if ( keyInfo.keyIndex >= 4 ) + { + return ZM_STATUS_FAILURE; + } + + if ( keyInfo.keyLength == 5 ) + { + zm_debug_msg0("WEP 64"); + + encryMode = ZM_WEP64; + } + else if ( keyInfo.keyLength == 13 ) + { + zm_debug_msg0("WEP 128"); + + encryMode = ZM_WEP128; + } + else if ( keyInfo.keyLength == 32 ) + { + /* TKIP */ + #if 0 + // Don't reset the IV since some AP would fail in IV check and drop our connection + if ( wd->sta.wpaState != ZM_STA_WPA_STATE_PK_OK ) + { + wd->sta.iv16 = 0; + wd->sta.iv32 = 0; + } + #endif + + encryMode = ZM_TKIP; + + zfTkipInit(keyInfo.key, (u8_t*) wd->sta.bssid, + &wd->sta.rxSeed[keyInfo.keyIndex], keyInfo.initIv); + zfMicSetKey(&keyInfo.key[24], + &wd->sta.rxMicKey[keyInfo.keyIndex]); + } + else if ( keyInfo.keyLength == 16 ) + { + /* AES */ + #if 0 + // Don't reset the IV since some AP would fail in IV check and drop our connection + if ( wd->sta.wpaState != ZM_STA_WPA_STATE_PK_OK ) + { + /* broadcast -- > group key */ + /* Only initialize when set our default key ! */ + wd->sta.iv16 = 0; + wd->sta.iv32 = 0; + } + #endif + + encryMode = ZM_AES; + } + else if ( keyInfo.keyLength == 29 ) + { + zm_debug_msg0("WEP 256"); + + encryMode = ZM_WEP256; + //zfCoreSetKey(dev, 64, 1, wd->sta.encryMode, + // wd->sta.bssid, (u32_t*) (&keyInfo.key[16])); + } + else + { + return ZM_STATUS_FAILURE; + } + + { + u8_t i; + + zm_debug_msg0("key = "); + for(i = 0; i < keyInfo.keyLength; i++) + { + zm_debug_msg2("", keyInfo.key[i]); + } + } + + if ( keyInfo.flag & ZM_KEY_FLAG_DEFAULT_KEY ) + { + //for WEP default key 1~3 and ATOM platform--CWYang(+) + vapId = 0; + wd->ap.bcHalKeyIdx[vapId] = keyInfo.keyIndex; + wd->ap.bcKeyIndex[vapId] = keyInfo.keyIndex; + wd->sta.keyId = keyInfo.keyIndex; + } + + if(encryMode == ZM_TKIP) + { + if(wd->TKIP_Group_KeyChanging == 0x1) + { + zm_debug_msg0("Countermeasure : Cancel Old Timer "); + zfTimerCancel(dev, ZM_EVENT_SKIP_COUNTERMEASURE); + } + else + { + zm_debug_msg0("Countermeasure : Create New Timer "); + } + + wd->TKIP_Group_KeyChanging = 0x1; + zfTimerSchedule(dev, ZM_EVENT_SKIP_COUNTERMEASURE, 150); + } + + + + //------------------------------------------------------------------------ + + /* use default key */ + //zfCoreSetKey(dev, ZM_USER_KEY_DEFAULT+keyInfo.keyIndex, 0, + // wd->sta.encryMode, wd->sta.bssid, (u32_t*) keyInfo.key); + + if ( encryMode == ZM_TKIP || + encryMode == ZM_AES ) + { + zfHpSetDefaultKey(dev, keyInfo.keyIndex, encryMode, + (u32_t*) keyInfo.key, (u32_t*) &keyInfo.key[16]); + +#ifdef ZM_ENABLE_IBSS_WPA2PSK + if ( (keyInfo.keyLength==16) && (wd->sta.ibssWpa2Psk==1) ) + {/* If not AES-CCMP and ibss network , use traditional */ + wd->sta.wpaState = ZM_STA_WPA_STATE_PK_OK; + } + else + { + if (wd->sta.wpaState == ZM_STA_WPA_STATE_PK_OK) + wd->sta.wpaState = ZM_STA_WPA_STATE_GK_OK; + else + { + wd->sta.wpaState = ZM_STA_WPA_STATE_PK_OK; + wd->sta.encryMode = encryMode; + wd->ws.encryMode = encryMode; + } + } +#else + if (wd->sta.wpaState == ZM_STA_WPA_STATE_PK_OK) + wd->sta.wpaState = ZM_STA_WPA_STATE_GK_OK; + else if ( wd->sta.wpaState == ZM_STA_WPA_STATE_INIT ) + { + wd->sta.wpaState = ZM_STA_WPA_STATE_PK_OK; + wd->sta.encryMode = encryMode; + wd->ws.encryMode = encryMode; + } +#endif + } + else + { + zfHpSetDefaultKey(dev, keyInfo.keyIndex, encryMode, + (u32_t*) keyInfo.key, NULL); + + /* Save key for software WEP */ + zfMemoryCopy(wd->sta.wepKey[keyInfo.keyIndex], keyInfo.key, + keyInfo.keyLength); + + /* TODO: Check whether we need to save the SWEncryMode */ + wd->sta.SWEncryMode[keyInfo.keyIndex] = encryMode; + + wd->sta.encryMode = encryMode; + wd->ws.encryMode = encryMode; + } + } + } + +// wd->sta.flagKeyChanging = 1; + return ZM_STATUS_SUCCESS; +} + +/* PSEUDO test */ +u8_t zfiWlanPSEUDOSetKey(zdev_t* dev, struct zsKeyInfo keyInfo) +{ + //u16_t broadcast[3] = {0xffff, 0xffff, 0xffff}; + //u32_t* key; + u8_t micKey[16]; + + zmw_get_wlan_dev(dev); + + switch (keyInfo.keyLength) + { + case 5: + wd->sta.encryMode = ZM_WEP64; + /* use default key */ + zfCoreSetKey(dev, 64, 0, ZM_WEP64, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key); + break; + + case 13: + wd->sta.encryMode = ZM_WEP128; + /* use default key */ + zfCoreSetKey(dev, 64, 0, ZM_WEP128, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key); + break; + + case 29: + wd->sta.encryMode = ZM_WEP256; + /* use default key */ + zfCoreSetKey(dev, 64, 1, ZM_WEP256, (u16_t *)keyInfo.macAddr, (u32_t*) (&keyInfo.key[16])); + zfCoreSetKey(dev, 64, 0, ZM_WEP256, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key); + break; + + case 16: + wd->sta.encryMode = ZM_AES; + //zfCoreSetKey(dev, 0, 0, ZM_AES, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key); + zfCoreSetKey(dev, 64, 0, ZM_AES, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key); + break; + + case 32: +#ifdef ZM_ENABLE_CENC + if (keyInfo.flag & ZM_KEY_FLAG_CENC) + { + u16_t boardcastAddr[3] = {0xffff, 0xffff, 0xffff}; + u16_t Addr_a[] = { 0x0000, 0x0080, 0x0901}; + u16_t Addr_b[] = { 0x0000, 0x0080, 0x0902}; + /* CENC test: user0,1 and user2 for boardcast */ + wd->sta.encryMode = ZM_CENC; + zfCoreSetKey(dev, 0, 1, ZM_CENC, (u16_t *)Addr_a, (u32_t*) (&keyInfo.key[16])); + zfCoreSetKey(dev, 0, 0, ZM_CENC, (u16_t *)Addr_a, (u32_t*) keyInfo.key); + + zfCoreSetKey(dev, 1, 1, ZM_CENC, (u16_t *)Addr_b, (u32_t*) (&keyInfo.key[16])); + zfCoreSetKey(dev, 1, 0, ZM_CENC, (u16_t *)Addr_b, (u32_t*) keyInfo.key); + + zfCoreSetKey(dev, 2, 1, ZM_CENC, (u16_t *)boardcastAddr, (u32_t*) (&keyInfo.key[16])); + zfCoreSetKey(dev, 2, 0, ZM_CENC, (u16_t *)boardcastAddr, (u32_t*) keyInfo.key); + + /* Initialize PN sequence */ + wd->sta.txiv[0] = 0x5c365c36; + wd->sta.txiv[1] = 0x5c365c36; + wd->sta.txiv[2] = 0x5c365c36; + wd->sta.txiv[3] = 0x5c365c36; + } + else +#endif //ZM_ENABLE_CENC + { + wd->sta.encryMode = ZM_TKIP; + zfCoreSetKey(dev, 64, 1, ZM_TKIP, (u16_t *)keyInfo.macAddr, (u32_t*) micKey); + zfCoreSetKey(dev, 64, 0, ZM_TKIP, (u16_t *)keyInfo.macAddr, (u32_t*) keyInfo.key); + } + break; + default: + wd->sta.encryMode = ZM_NO_WEP; + } + + return ZM_STATUS_SUCCESS; +} + +void zfiWlanSetPowerSaveMode(zdev_t* dev, u8_t mode) +{ +#if 0 + zmw_get_wlan_dev(dev); + + wd->sta.powerSaveMode = mode; + + /* send null data with PwrBit to inform AP */ + if ( mode > ZM_STA_PS_NONE ) + { + if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE ) + { + zfSendNullData(dev, 1); + } + + /* device into PS mode */ + zfPSDeviceSleep(dev); + } +#endif + + zfPowerSavingMgrSetMode(dev, mode); +} + +void zfiWlanSetMacAddress(zdev_t* dev, u16_t* mac) +{ + zmw_get_wlan_dev(dev); + + wd->macAddr[0] = mac[0]; + wd->macAddr[1] = mac[1]; + wd->macAddr[2] = mac[2]; + + zfHpSetMacAddress(dev, mac, 0); +} + +u8_t zfiWlanQueryWlanMode(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->wlanMode; +} + +u8_t zfiWlanQueryAdapterState(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->state; +} + +u8_t zfiWlanQueryAuthenticationMode(zdev_t* dev, u8_t bWrapper) +{ + u8_t authMode; + + zmw_get_wlan_dev(dev); + + if ( bWrapper ) + { + authMode = wd->ws.authMode; + } + else + { + //authMode = wd->sta.authMode; + authMode = wd->sta.currentAuthMode; + } + + return authMode; +} + +u8_t zfiWlanQueryWepStatus(zdev_t* dev, u8_t bWrapper) +{ + u8_t wepStatus; + + zmw_get_wlan_dev(dev); + + if ( bWrapper ) + { + wepStatus = wd->ws.wepStatus; + } + else + { + wepStatus = wd->sta.wepStatus; + } + + return wepStatus; +} + +void zfiWlanQuerySSID(zdev_t* dev, u8_t* ssid, u8_t* pSsidLength) +{ + u16_t vapId = 0; + zmw_get_wlan_dev(dev); + + if (wd->wlanMode == ZM_MODE_AP) + { + vapId = zfwGetVapId(dev); + + if (vapId == 0xffff) + { + *pSsidLength = wd->ap.ssidLen[0]; + zfMemoryCopy(ssid, wd->ap.ssid[0], wd->ap.ssidLen[0]); + } + else + { + *pSsidLength = wd->ap.ssidLen[vapId + 1]; + zfMemoryCopy(ssid, wd->ap.ssid[vapId + 1], wd->ap.ssidLen[vapId + 1]); + } + } + else + { + *pSsidLength = wd->sta.ssidLen; + zfMemoryCopy(ssid, wd->sta.ssid, wd->sta.ssidLen); + } +} + +u16_t zfiWlanQueryFragThreshold(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->fragThreshold; +} + +u16_t zfiWlanQueryRtsThreshold(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->rtsThreshold; +} + +u32_t zfiWlanQueryFrequency(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return (wd->frequency*1000); +} + +/*********************************************************** + * Function: zfiWlanQueryCurrentFrequency + * Return value: + * - 0 : no validate current frequency + * - (>0): current frequency depend on "qmode" + * Input: + * - qmode: + * 0: return value depend on the support mode, this + qmode is use to solve the bug #31223 + * 1: return the actually current frequency + ***********************************************************/ +u32_t zfiWlanQueryCurrentFrequency(zdev_t* dev, u8_t qmode) +{ + u32_t frequency; + + zmw_get_wlan_dev(dev); + + switch (qmode) + { + case 0: + if (wd->sta.currentFrequency > 3000) + { + if (wd->supportMode & ZM_WIRELESS_MODE_5) + { + frequency = wd->sta.currentFrequency; + } + else if (wd->supportMode & ZM_WIRELESS_MODE_24) + { + frequency = zfChGetFirst2GhzChannel(dev); + } + else + { + frequency = 0; + } + } + else + { + if (wd->supportMode & ZM_WIRELESS_MODE_24) + { + frequency = wd->sta.currentFrequency; + } + else if (wd->supportMode & ZM_WIRELESS_MODE_5) + { + frequency = zfChGetLast5GhzChannel(dev); + } + else + { + frequency = 0; + } + } + break; + + case 1: + frequency = wd->sta.currentFrequency; + break; + + default: + frequency = 0; + } + + return (frequency*1000); +} + +u32_t zfiWlanQueryFrequencyAttribute(zdev_t* dev, u32_t freq) +{ + zmw_get_wlan_dev(dev); + + u8_t i; + u16_t frequency = (u16_t) (freq/1000); + u32_t ret = 0; + + for (i = 0; i < wd->regulationTable.allowChannelCnt; i++) + { + if ( wd->regulationTable.allowChannel[i].channel == frequency ) + { + ret = wd->regulationTable.allowChannel[i].channelFlags; + } + } + + return ret; +} + +/* BandWidth 0=>20 1=>40 */ +/* ExtOffset 0=>20 1=>high control 40 3=>low control 40 */ +void zfiWlanQueryFrequencyHT(zdev_t* dev, u32_t *bandWidth, u32_t *extOffset) +{ + zmw_get_wlan_dev(dev); + + *bandWidth = wd->BandWidth40; + *extOffset = wd->ExtOffset; +} + +u8_t zfiWlanQueryCWMode(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->cwm.cw_mode; +} + +u32_t zfiWlanQueryCWEnable(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->cwm.cw_enable; +} + +void zfiWlanQueryBssid(zdev_t* dev, u8_t* bssid) +{ + u8_t addr[6]; + + zmw_get_wlan_dev(dev); + + ZM_MAC_WORD_TO_BYTE(wd->sta.bssid, addr); + zfMemoryCopy(bssid, addr, 6); +} + +u16_t zfiWlanQueryBeaconInterval(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->beaconInterval; +} + +u32_t zfiWlanQueryRxBeaconTotal(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + wd->sta.rxBeaconTotal += wd->sta.rxBeaconCount; + + return wd->sta.rxBeaconTotal; +} + +u16_t zfiWlanQueryAtimWindow(zdev_t* dev) +{ + u16_t atimWindow; + + zmw_get_wlan_dev(dev); + + atimWindow = wd->sta.atimWindow; + + return atimWindow; +} + +u8_t zfiWlanQueryEncryMode(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + if (wd->wlanMode == ZM_MODE_AP) + return wd->ap.encryMode[0]; + else + return wd->sta.encryMode; +} + +u16_t zfiWlanQueryCapability(zdev_t* dev) +{ + u16_t capability; + + zmw_get_wlan_dev(dev); + + capability = wd->sta.capability[0] + + (((u16_t) wd->sta.capability[1]) << 8); + + return capability; + +} + +u16_t zfiWlanQueryAid(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->sta.aid; +} + +void zfiWlanQuerySupportRate(zdev_t* dev, u8_t* rateArray, u8_t* pLength) +{ + u8_t i, j=0; + + zmw_get_wlan_dev(dev); + + for( i=0; i<4; i++ ) + { + if ( wd->bRate & (0x1 << i) ) + { + rateArray[j] = zg11bRateTbl[i] + + ((wd->bRateBasic & (0x1<gRate & (0x1 << i) ) + { + rateArray[j] = zg11gRateTbl[i] + + ((wd->gRateBasic & (0x1<sta.rsnIe[1] + 2; + zfMemoryCopy(ie, wd->sta.rsnIe, len); + *pLength = len; +} + +void zfiWlanQueryWpaIe(zdev_t* dev, u8_t* ie, u8_t* pLength) +{ + u8_t len; + + zmw_get_wlan_dev(dev); + + len = wd->sta.wpaIe[1] + 2; + zfMemoryCopy(ie, wd->sta.wpaIe, len); + *pLength = len; + +} + +u8_t zfiWlanQueryMulticastCipherAlgo(zdev_t *dev) +{ + zmw_get_wlan_dev(dev); + + switch( wd->sta.currentAuthMode ) + { + case ZM_AUTH_MODE_WPA2PSK: + case ZM_AUTH_MODE_WPA2: + if ( wd->sta.rsnIe[7] == 2 ) + { + return ZM_TKIP; + } + else + { + return ZM_AES; + } + break; + + case ZM_AUTH_MODE_WPAPSK: + case ZM_AUTH_MODE_WPA: + if ( wd->sta.rsnIe[11] == 2 ) + { + return ZM_TKIP; + } + else + { + return ZM_AES; + } + break; + + default: + return wd->sta.encryMode; + } +} + +u8_t zfiWlanQueryHTMode(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + // 0:Legancy, 1:N + return wd->sta.EnableHT; +} + +u8_t zfiWlanQueryBandWidth40(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + // 0:20M, 1:40M + return wd->BandWidth40; +} + +u16_t zfiWlanQueryRegionCode(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->regulationTable.regionCode; +} +void zfiWlanSetWpaIe(zdev_t* dev, u8_t* ie, u8_t Length) +{ + u16_t vapId = 0; + zmw_get_wlan_dev(dev); + + if (wd->wlanMode == ZM_MODE_AP) // AP Mode + { + vapId = zfwGetVapId(dev); + + if (vapId == 0xffff) + vapId = 0; + else + vapId++; + + zm_assert(Length < ZM_MAX_WPAIE_SIZE); + if (Length < ZM_MAX_WPAIE_SIZE) + { + wd->ap.wpaLen[vapId] = Length; + zfMemoryCopy(wd->ap.wpaIe[vapId], ie, wd->ap.wpaLen[vapId]); + } + + } + else + { + wd->sta.wpaLen = Length; + zfMemoryCopy(wd->sta.wpaIe, ie, wd->sta.wpaLen); + } + //zfiWlanSetWpaSupport(dev, 1); + if (wd->wlanMode == ZM_MODE_AP) // AP Mode + { + wd->ap.wpaSupport[vapId] = 1; + } + else + { + wd->sta.wpaSupport = 1; + } + +} + +void zfiWlanSetWpaSupport(zdev_t* dev, u8_t WpaSupport) +{ + u16_t vapId = 0; + zmw_get_wlan_dev(dev); + + if (wd->wlanMode == ZM_MODE_AP) // AP Mode + { + vapId = zfwGetVapId(dev); + + if (vapId == 0xffff) + vapId = 0; + else + vapId++; + + wd->ap.wpaSupport[vapId] = WpaSupport; + } + else + { + wd->sta.wpaSupport = WpaSupport; + } + +} + +void zfiWlanSetProtectionMode(zdev_t* dev, u8_t mode) +{ + zmw_get_wlan_dev(dev); + + wd->sta.bProtectionMode = mode; + if (wd->sta.bProtectionMode == TRUE) + { + zfHpSetSlotTime(dev, 0); + } + else + { + zfHpSetSlotTime(dev, 1); + } + + zm_msg1_mm(ZM_LV_1, "wd->protectionMode=", wd->sta.bProtectionMode); +} + +void zfiWlanSetBasicRate(zdev_t* dev, u8_t bRateSet, u8_t gRateSet, + u32_t nRateSet) +{ + zmw_get_wlan_dev(dev); + + wd->ws.bRateBasic = bRateSet; + wd->ws.gRateBasic = gRateSet; + wd->ws.nRateBasic = nRateSet; +} + +void zfiWlanSetBGMode(zdev_t* dev, u8_t mode) +{ + zmw_get_wlan_dev(dev); + + wd->ws.bgMode = mode; +} + +void zfiWlanSetpreambleType(zdev_t* dev, u8_t type) +{ + zmw_get_wlan_dev(dev); + + wd->ws.preambleType = type; +} + +u8_t zfiWlanQuerypreambleType(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->ws.preambleType; +} + +u8_t zfiWlanQueryPowerSaveMode(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->sta.powerSaveMode; +} + +u8_t zfiWlanSetPmkidInfo(zdev_t* dev, u16_t* bssid, u8_t* pmkid) +{ + u32_t i; + + zmw_get_wlan_dev(dev); + + for(i=0; ista.pmkidInfo.bssidCount; i++) + { + if ( zfMemoryIsEqual((u8_t*) wd->sta.pmkidInfo.bssidInfo[i].bssid, + (u8_t*) bssid, 6) ) + { + /* matched */ + break; + } + } + + if ( i < wd->sta.pmkidInfo.bssidCount ) + { + /* overwrite the original one */ + zfMemoryCopy(wd->sta.pmkidInfo.bssidInfo[i].pmkid, pmkid, 16); + } + else + { + if ( i < ZM_PMKID_MAX_BSS_CNT ) + { + wd->sta.pmkidInfo.bssidInfo[i].bssid[0] = bssid[0]; + wd->sta.pmkidInfo.bssidInfo[i].bssid[1] = bssid[1]; + wd->sta.pmkidInfo.bssidInfo[i].bssid[2] = bssid[2]; + + zfMemoryCopy(wd->sta.pmkidInfo.bssidInfo[i].pmkid, pmkid, 16); + wd->sta.pmkidInfo.bssidCount++; + } + } + + return 0; +} + +u32_t zfiWlanQueryPmkidInfo(zdev_t* dev, u8_t* buf, u32_t len) +{ + //struct zsPmkidInfo* pPmkidInfo = ( struct zsPmkidInfo* ) buf; + u32_t size; + + zmw_get_wlan_dev(dev); + + size = sizeof(u32_t) + + wd->sta.pmkidInfo.bssidCount * sizeof(struct zsPmkidBssidInfo); + + if ( len < size ) + { + return wd->sta.pmkidInfo.bssidCount; + } + + zfMemoryCopy(buf, (u8_t*) &wd->sta.pmkidInfo, (u16_t) size); + + return 0; +} + +void zfiWlanSetMulticastList(zdev_t* dev, u8_t size, u8_t* pList) +{ + struct zsMulticastAddr* pMacList = (struct zsMulticastAddr*) pList; + u8_t i; + u8_t bAllMulticast = 0; + //u32_t value; + + zmw_get_wlan_dev(dev); + + wd->sta.multicastList.size = size; + for(i=0; ista.multicastList.macAddr[i].addr, + pMacList[i].addr, 6); + } + + if ( wd->sta.osRxFilter & ZM_PACKET_TYPE_ALL_MULTICAST ) + bAllMulticast = 1; + zfHpSetMulticastList(dev, size, pList, bAllMulticast); + +} + +void zfiWlanRemoveKey(zdev_t* dev, u8_t keyType, u8_t keyId) +{ + u16_t fakeMacAddr[3] = {0, 0, 0}; + u32_t fakeKey[4] = {0, 0, 0, 0}; + + zmw_get_wlan_dev(dev); + + if ( keyType == 0 ) + { + /* remove WEP key */ + zm_debug_msg0("remove WEP key"); + zfCoreSetKey(dev, ZM_USER_KEY_DEFAULT+keyId, 0, + ZM_NO_WEP, fakeMacAddr, fakeKey); + wd->sta.encryMode = ZM_NO_WEP; + } + else if ( keyType == 1 ) + { + /* remove pairwise key */ + zm_debug_msg0("remove pairwise key"); + zfHpRemoveKey(dev, ZM_USER_KEY_PK); + wd->sta.encryMode = ZM_NO_WEP; + } + else + { + /* remove group key */ + zm_debug_msg0("remove group key"); + zfHpRemoveKey(dev, ZM_USER_KEY_GK); + } +} + + +void zfiWlanQueryRegulationTable(zdev_t* dev, struct zsRegulationTable* pEntry) +{ + zmw_get_wlan_dev(dev); + + zfMemoryCopy((u8_t*) pEntry, (u8_t*) &wd->regulationTable, + sizeof(struct zsRegulationTable)); +} + +/* parameter "time" is specified in ms */ +void zfiWlanSetScanTimerPerChannel(zdev_t* dev, u16_t time) +{ + zmw_get_wlan_dev(dev); + + zm_debug_msg1("scan time (ms) = ", time); + + wd->sta.activescanTickPerChannel = time / ZM_MS_PER_TICK; +} + +void zfiWlanSetAutoReconnect(zdev_t* dev, u8_t enable) +{ + zmw_get_wlan_dev(dev); + + wd->sta.bAutoReconnect = enable; + //wd->sta.bAutoReconnectEnabled = enable; +} + +void zfiWlanSetStaWme(zdev_t* dev, u8_t enable, u8_t uapsdInfo) +{ + zmw_get_wlan_dev(dev); + + wd->ws.staWmeEnabled = enable & 0x3; + if ((enable & 0x2) != 0) + { + wd->ws.staWmeQosInfo = uapsdInfo & 0x6f; + } + else + { + wd->ws.staWmeQosInfo = 0; + } +} + +void zfiWlanSetApWme(zdev_t* dev, u8_t enable) +{ + zmw_get_wlan_dev(dev); + + wd->ws.apWmeEnabled = enable; +} + +u8_t zfiWlanQuerywmeEnable(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->ws.staWmeEnabled; +} + +void zfiWlanSetProbingHiddenSsid(zdev_t* dev, u8_t* ssid, u8_t ssidLen, + u16_t entry) +{ + zmw_get_wlan_dev(dev); + zmw_declare_for_critical_section(); + + + if ((ssidLen <= 32) && (entry < ZM_MAX_PROBE_HIDDEN_SSID_SIZE)) + { + zmw_enter_critical_section(dev); + wd->ws.probingSsidList[entry].ssidLen = ssidLen; + zfMemoryCopy(wd->ws.probingSsidList[entry].ssid, ssid, ssidLen); + zmw_leave_critical_section(dev); + } + + return; +} + +void zfiWlanSetDisableProbingWithSsid(zdev_t* dev, u8_t mode) +{ + zmw_get_wlan_dev(dev); + + wd->sta.disableProbingWithSsid = mode; + + return; +} + +void zfiWlanSetDropUnencryptedPackets(zdev_t* dev, u8_t enable) +{ + zmw_get_wlan_dev(dev); + + wd->ws.dropUnencryptedPkts = enable; +} + +void zfiWlanSetStaRxSecurityCheckCb(zdev_t* dev, zfpStaRxSecurityCheckCb pStaRxSecurityCheckCb) +{ + zmw_get_wlan_dev(dev); + + wd->sta.pStaRxSecurityCheckCb = pStaRxSecurityCheckCb; +} + +void zfiWlanSetIBSSJoinOnly(zdev_t* dev, u8_t joinOnly) +{ + zmw_get_wlan_dev(dev); + + wd->ws.ibssJoinOnly = joinOnly; +} + +/************************************************************************/ +/* */ +/* FUNCTION DESCRIPTION zfiConfigWdsPort */ +/* Configure WDS port. */ +/* */ +/* INPUTS */ +/* dev : device pointer */ +/* wdsPortId : WDS port ID, start from 0 */ +/* flag : 0=>disable WDS port, 1=>enable WDS port */ +/* wdsAddr : WDS neighbor MAC address */ +/* encType : encryption type for WDS port */ +/* wdsKey : encryption key for WDS port */ +/* */ +/* OUTPUTS */ +/* Error code */ +/* */ +/* AUTHOR */ +/* Stephen Chen ZyDAS Technology Corporation 2006.6 */ +/* */ +/************************************************************************/ +u16_t zfiConfigWdsPort(zdev_t* dev, u8_t wdsPortId, u16_t flag, u16_t* wdsAddr, + u16_t encType, u32_t* wdsKey) +{ + u16_t addr[3]; + u32_t key[4]; + + zmw_get_wlan_dev(dev); + + if (wdsPortId > ZM_MAX_WDS_SUPPORT) + { + return ZM_ERR_WDS_PORT_ID; + } + + if (flag == 1) + { + /* Enable WDS port */ + wd->ap.wds.macAddr[wdsPortId][0] = wdsAddr[0]; + wd->ap.wds.macAddr[wdsPortId][1] = wdsAddr[1]; + wd->ap.wds.macAddr[wdsPortId][2] = wdsAddr[2]; + + wd->ap.wds.wdsBitmap |= (1 << wdsPortId); + wd->ap.wds.encryMode[wdsPortId] = (u8_t) encType; + + zfCoreSetKey(dev, 10+ZM_MAX_WDS_SUPPORT, 0, (u8_t) encType, wdsAddr, wdsKey); + } + else + { + /* Disable WDS port */ + addr[0] = addr[1] = addr[2] = 0; + key[0] = key[1] = key[2] = key[3] = 0; + wd->ap.wds.wdsBitmap &= (~(1 << wdsPortId)); + zfCoreSetKey(dev, 10+ZM_MAX_WDS_SUPPORT, 0, ZM_NO_WEP, addr, key); + } + + return ZM_SUCCESS; +} +#ifdef ZM_ENABLE_CENC +/* CENC */ +void zfiWlanQueryGSN(zdev_t* dev, u8_t *gsn, u16_t vapId) +{ + //struct zsWlanDev* wd = (struct zsWlanDev*) zmw_wlan_dev(dev); + u32_t txiv[4]; + zmw_get_wlan_dev(dev); + + /* convert little endian to big endian for 32 bits */ + txiv[3] = wd->ap.txiv[vapId][0]; + txiv[2] = wd->ap.txiv[vapId][1]; + txiv[1] = wd->ap.txiv[vapId][2]; + txiv[0] = wd->ap.txiv[vapId][3]; + + zfMemoryCopy(gsn, (u8_t*)txiv, 16); +} +#endif //ZM_ENABLE_CENC +//CWYang(+) +void zfiWlanQuerySignalInfo(zdev_t* dev, u8_t *buffer) +{ + zmw_get_wlan_dev(dev); + + /*Change Signal Strength/Quality Value to Human Sense Here*/ + + buffer[0] = wd->SignalStrength; + buffer[1] = wd->SignalQuality; +} + +/* OS-XP */ +u16_t zfiStaAddIeWpaRsn(zdev_t* dev, zbuf_t* buf, u16_t offset, u8_t frameType) +{ + return zfStaAddIeWpaRsn(dev, buf, offset, frameType); +} + +/* zfiDebugCmd */ +/* cmd value-description */ +/* 0 schedule timer */ +/* 1 cancel timer */ +/* 2 clear timer */ +/* 3 test timer */ +/* 4 */ +/* 5 */ +/* 6 checksum test 0/1 */ +/* 7 enableProtectionMode */ +/* 8 rx packet content dump 0/1 */ + +u32_t zfiDebugCmd(zdev_t* dev, u32_t cmd, u32_t value) +{ + u16_t event; + u32_t tick; + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + + zmw_enter_critical_section(dev); + + if ( cmd == 0 ) + { /* schedule timer */ + event = (u16_t) ((value >> 16) & 0xffff); + tick = value & 0xffff; + zfTimerSchedule(dev, event, tick); + } + else if ( cmd == 1 ) + { /* cancel timer */ + event = (u16_t) (value & 0xffff); + zfTimerCancel(dev, event); + } + else if ( cmd == 2 ) + { /* clear timer */ + zfTimerClear(dev); + } + else if ( cmd == 3 ) + { /* test timer */ + zfTimerSchedule(dev, 1, 500); + zfTimerSchedule(dev, 2, 1000); + zfTimerSchedule(dev, 3, 1000); + zfTimerSchedule(dev, 4, 1000); + zfTimerSchedule(dev, 5, 1500); + zfTimerSchedule(dev, 6, 2000); + zfTimerSchedule(dev, 7, 2200); + zfTimerSchedule(dev, 6, 2500); + zfTimerSchedule(dev, 8, 2800); + } + else if ( cmd == 4) + { + zfTimerSchedule(dev, 1, 500); + zfTimerSchedule(dev, 2, 1000); + zfTimerSchedule(dev, 3, 1000); + zfTimerSchedule(dev, 4, 1000); + zfTimerSchedule(dev, 5, 1500); + zfTimerSchedule(dev, 6, 2000); + zfTimerSchedule(dev, 7, 2200); + zfTimerSchedule(dev, 6, 2500); + zfTimerSchedule(dev, 8, 2800); + zfTimerCancel(dev, 1); + zfTimerCancel(dev, 3); + zfTimerCancel(dev, 6); + } + else if ( cmd == 5 ) + { + wd->sta.keyId = (u8_t) value; + } + else if ( cmd == 6 ) + { + /* 0: normal 1: always set TCP/UDP checksum zero */ + wd->checksumTest = value; + } + else if ( cmd == 7 ) + { + wd->enableProtectionMode = value; + zm_msg1_mm(ZM_LV_1, "wd->enableProtectionMode=", wd->enableProtectionMode); + } + else if ( cmd == 8 ) + { + /* rx packet content dump */ + if (value) + { + wd->rxPacketDump = 1; + } + else + { + wd->rxPacketDump = 0; + } + } + + + zmw_leave_critical_section(dev); + + return 0; +} + +#ifdef ZM_ENABLE_CENC +u8_t zfiWlanSetCencPairwiseKey(zdev_t* dev, u8_t keyid, u32_t *txiv, u32_t *rxiv, + u8_t *key, u8_t *mic) +{ + struct zsKeyInfo keyInfo; + u8_t cencKey[32]; + u8_t i; + u16_t macAddr[3]; + + zmw_get_wlan_dev(dev); + + for (i = 0; i < 16; i++) + cencKey[i] = key[i]; + for (i = 0; i < 16; i++) + cencKey[i + 16] = mic[i]; + keyInfo.key = cencKey; + keyInfo.keyLength = 32; + keyInfo.keyIndex = keyid; + keyInfo.flag = ZM_KEY_FLAG_CENC | ZM_KEY_FLAG_PK; + for (i = 0; i < 3; i++) + macAddr[i] = wd->sta.bssid[i]; + keyInfo.macAddr = macAddr; + + zfiWlanSetKey(dev, keyInfo); + + /* Reset txiv and rxiv */ + //wd->sta.txiv[0] = txiv[0]; + //wd->sta.txiv[1] = txiv[1]; + //wd->sta.txiv[2] = txiv[2]; + //wd->sta.txiv[3] = txiv[3]; + // + //wd->sta.rxiv[0] = rxiv[0]; + //wd->sta.rxiv[1] = rxiv[1]; + //wd->sta.rxiv[2] = rxiv[2]; + //wd->sta.rxiv[3] = rxiv[3]; + + return 0; +} + +u8_t zfiWlanSetCencGroupKey(zdev_t* dev, u8_t keyid, u32_t *rxiv, + u8_t *key, u8_t *mic) +{ + struct zsKeyInfo keyInfo; + u8_t cencKey[32]; + u8_t i; + u16_t macAddr[6] = {0xffff, 0xffff, 0xffff}; + + zmw_get_wlan_dev(dev); + + for (i = 0; i < 16; i++) + cencKey[i] = key[i]; + for (i = 0; i < 16; i++) + cencKey[i + 16] = mic[i]; + keyInfo.key = cencKey; + keyInfo.keyLength = 32; + keyInfo.keyIndex = keyid; + keyInfo.flag = ZM_KEY_FLAG_CENC | ZM_KEY_FLAG_GK; + keyInfo.vapId = 0; + for (i = 0; i < 3; i++) + keyInfo.vapAddr[i] = wd->macAddr[i]; + keyInfo.macAddr = macAddr; + + zfiWlanSetKey(dev, keyInfo); + + /* Reset txiv and rxiv */ + wd->sta.rxivGK[0] = ((rxiv[3] >> 24) & 0xFF) + + (((rxiv[3] >> 16) & 0xFF) << 8) + + (((rxiv[3] >> 8) & 0xFF) << 16) + + ((rxiv[3] & 0xFF) << 24); + wd->sta.rxivGK[1] = ((rxiv[2] >> 24) & 0xFF) + + (((rxiv[2] >> 16) & 0xFF) << 8) + + (((rxiv[2] >> 8) & 0xFF) << 16) + + ((rxiv[2] & 0xFF) << 24); + wd->sta.rxivGK[2] = ((rxiv[1] >> 24) & 0xFF) + + (((rxiv[1] >> 16) & 0xFF) << 8) + + (((rxiv[1] >> 8) & 0xFF) << 16) + + ((rxiv[1] & 0xFF) << 24); + wd->sta.rxivGK[3] = ((rxiv[0] >> 24) & 0xFF) + + (((rxiv[0] >> 16) & 0xFF) << 8) + + (((rxiv[0] >> 8) & 0xFF) << 16) + + ((rxiv[0] & 0xFF) << 24); + + wd->sta.authMode = ZM_AUTH_MODE_CENC; + wd->sta.currentAuthMode = ZM_AUTH_MODE_CENC; + + return 0; +} +#endif //ZM_ENABLE_CENC + +u8_t zfiWlanSetDot11DMode(zdev_t* dev, u8_t mode) +{ + u8_t i; + + zmw_get_wlan_dev(dev); + + wd->sta.b802_11D = mode; + if (mode) //Enable 802.11d + { + wd->regulationTable.regionCode = NO_ENUMRD; + for (i = 0; i < wd->regulationTable.allowChannelCnt; i++) + wd->regulationTable.allowChannel[i].channelFlags |= ZM_REG_FLAG_CHANNEL_PASSIVE; + } + else //Disable + { + for (i = 0; i < wd->regulationTable.allowChannelCnt; i++) + wd->regulationTable.allowChannel[i].channelFlags &= ~ZM_REG_FLAG_CHANNEL_PASSIVE; + } + + return 0; +} + +u8_t zfiWlanSetDot11HDFSMode(zdev_t* dev, u8_t mode) +{ + zmw_get_wlan_dev(dev); + + //zm_debug_msg0("CWY - Enable 802.11h DFS"); + + // TODO : DFS Enable in 5250 to 5350 MHz and 5470 to 5725 MHz . + //if ( Adapter->ZD80211HSupport && + // Adapter->CardSetting.NetworkTypeInUse == Ndis802_11OFDM5 && + // ((ChannelNo >=52 && ChannelNo <= 64) || //5250~5350 MHZ + // (ChannelNo >=100 && ChannelNo <= 140))) //5470~5725 MHZ + //{ + // Adapter->ZD80211HSetting.DFSEnable=TRUE; + //} + //else + //{ + // Adapter->ZD80211HSetting.DFSEnable=FALSE; + //} + + wd->sta.DFSEnable = mode; + if (mode) + wd->sta.capability[1] |= ZM_BIT_0; + else + wd->sta.capability[1] &= (~ZM_BIT_0); + + return 0; +} + +u8_t zfiWlanSetDot11HTPCMode(zdev_t* dev, u8_t mode) +{ + zmw_get_wlan_dev(dev); + + // TODO : TPC Enable in 5150~5350 MHz and 5470~5725MHz. + //if ( Adapter->ZD80211HSupport && + // Adapter->CardSetting.NetworkTypeInUse == Ndis802_11OFDM5 && + // ((ChannelNo == 36 || ChannelNo == 40 || ChannelNo == 44 || ChannelNo == 48) || //5150~5250 MHZ , Not Japan + // (ChannelNo >=52 && ChannelNo <= 64) || //5250~5350 MHZ + // (ChannelNo >=100 && ChannelNo <= 140))) //5470~5725 MHZ + //{ + // Adapter->ZD80211HSetting.TPCEnable=TRUE; + //} + //else + //{ + // Adapter->ZD80211HSetting.TPCEnable=FALSE; + //} + + wd->sta.TPCEnable = mode; + if (mode) + wd->sta.capability[1] |= ZM_BIT_0; + else + wd->sta.capability[1] &= (~ZM_BIT_0); + + return 0; +} + +u8_t zfiWlanSetAniMode(zdev_t* dev, u8_t mode) +{ + zmw_get_wlan_dev(dev); + + wd->aniEnable = mode; + if (mode) + zfHpAniAttach(dev); + + return 0; +} + +#ifdef ZM_OS_LINUX_FUNC +void zfiWlanShowTally(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + zm_msg1_mm(ZM_LV_0, "Hw_UnderrunCnt = ", wd->commTally.Hw_UnderrunCnt); + zm_msg1_mm(ZM_LV_0, "Hw_TotalRxFrm = ", wd->commTally.Hw_TotalRxFrm); + zm_msg1_mm(ZM_LV_0, "Hw_CRC32Cnt = ", wd->commTally.Hw_CRC32Cnt); + zm_msg1_mm(ZM_LV_0, "Hw_CRC16Cnt = ", wd->commTally.Hw_CRC16Cnt); + zm_msg1_mm(ZM_LV_1, "Hw_DecrypErr_UNI = ", wd->commTally.Hw_DecrypErr_UNI); + zm_msg1_mm(ZM_LV_0, "Hw_RxFIFOOverrun = ", wd->commTally.Hw_RxFIFOOverrun); + zm_msg1_mm(ZM_LV_1, "Hw_DecrypErr_Mul = ", wd->commTally.Hw_DecrypErr_Mul); + zm_msg1_mm(ZM_LV_1, "Hw_RetryCnt = ", wd->commTally.Hw_RetryCnt); + zm_msg1_mm(ZM_LV_0, "Hw_TotalTxFrm = ", wd->commTally.Hw_TotalTxFrm); + zm_msg1_mm(ZM_LV_0, "Hw_RxTimeOut = ", wd->commTally.Hw_RxTimeOut); + zm_msg1_mm(ZM_LV_0, "Tx_MPDU = ", wd->commTally.Tx_MPDU); + zm_msg1_mm(ZM_LV_0, "BA_Fail = ", wd->commTally.BA_Fail); + zm_msg1_mm(ZM_LV_0, "Hw_Tx_AMPDU = ", wd->commTally.Hw_Tx_AMPDU); + zm_msg1_mm(ZM_LV_0, "Hw_Tx_MPDU = ", wd->commTally.Hw_Tx_MPDU); + + zm_msg1_mm(ZM_LV_1, "Hw_RxMPDU = ", wd->commTally.Hw_RxMPDU); + zm_msg1_mm(ZM_LV_1, "Hw_RxDropMPDU = ", wd->commTally.Hw_RxDropMPDU); + zm_msg1_mm(ZM_LV_1, "Hw_RxDelMPDU = ", wd->commTally.Hw_RxDelMPDU); + zm_msg1_mm(ZM_LV_1, "Hw_RxPhyMiscError = ", wd->commTally.Hw_RxPhyMiscError); + zm_msg1_mm(ZM_LV_1, "Hw_RxPhyXRError = ", wd->commTally.Hw_RxPhyXRError); + zm_msg1_mm(ZM_LV_1, "Hw_RxPhyOFDMError = ", wd->commTally.Hw_RxPhyOFDMError); + zm_msg1_mm(ZM_LV_1, "Hw_RxPhyCCKError = ", wd->commTally.Hw_RxPhyCCKError); + zm_msg1_mm(ZM_LV_1, "Hw_RxPhyHTError = ", wd->commTally.Hw_RxPhyHTError); + zm_msg1_mm(ZM_LV_1, "Hw_RxPhyTotalCount = ", wd->commTally.Hw_RxPhyTotalCount); + + if (!((wd->commTally.Tx_MPDU == 0) && (wd->commTally.BA_Fail == 0))) + { + zm_debug_msg_p("BA Fail Ratio(%) = ", wd->commTally.BA_Fail * 100, + (wd->commTally.BA_Fail + wd->commTally.Tx_MPDU)); + } + + if (!((wd->commTally.Hw_Tx_MPDU == 0) && (wd->commTally.Hw_Tx_AMPDU == 0))) + { + zm_debug_msg_p("Avg Agg Number = ", + wd->commTally.Hw_Tx_MPDU, wd->commTally.Hw_Tx_AMPDU); + } +} +#endif + +void zfiWlanSetMaxTxPower(zdev_t* dev, u8_t power2, u8_t power5) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + wd->maxTxPower2 = power2; + wd->maxTxPower5 = power5; + zmw_leave_critical_section(dev); +} + +void zfiWlanQueryMaxTxPower(zdev_t* dev, u8_t *power2, u8_t *power5) +{ + zmw_get_wlan_dev(dev); + + *power2 = wd->maxTxPower2; + *power5 = wd->maxTxPower5; +} + +void zfiWlanSetConnectMode(zdev_t* dev, u8_t mode) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + wd->connectMode = mode; + zmw_leave_critical_section(dev); +} + +void zfiWlanSetSupportMode(zdev_t* dev, u32_t mode) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + wd->supportMode = mode; + zmw_leave_critical_section(dev); +} + +void zfiWlanSetAdhocMode(zdev_t* dev, u32_t mode) +{ + zmw_get_wlan_dev(dev); + + wd->ws.adhocMode = mode; +} + +u32_t zfiWlanQueryAdhocMode(zdev_t* dev, u8_t bWrapper) +{ + u32_t adhocMode; + + zmw_get_wlan_dev(dev); + + if ( bWrapper ) + { + adhocMode = wd->ws.adhocMode; + } + else + { + adhocMode = wd->wfc.bIbssGMode; + } + + return adhocMode; +} + + +u8_t zfiWlanSetCountryIsoName(zdev_t* dev, u8_t *countryIsoName, u8_t length) +{ + u8_t buf[5]; + zmw_get_wlan_dev(dev); + + if (length == 4) + { + buf[2] = wd->ws.countryIsoName[0] = countryIsoName[2]; + buf[3] = wd->ws.countryIsoName[1] = countryIsoName[1]; + buf[4] = wd->ws.countryIsoName[2] = countryIsoName[0]; + } + else if (length == 3) + { + buf[2] = wd->ws.countryIsoName[0] = countryIsoName[1]; + buf[3] = wd->ws.countryIsoName[1] = countryIsoName[0]; + buf[4] = wd->ws.countryIsoName[2] = '\0'; + } + else + { + return 1; + } + + return zfHpGetRegulationTablefromISO(dev, buf, length); +} + + +const char* zfiWlanQueryCountryIsoName(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->ws.countryIsoName; +} + + + +void zfiWlanSetRegulatory(zdev_t* dev, u8_t CCS, u16_t Code, u8_t bfirstChannel) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + if (CCS) + { + /* Reset Regulation Table by Country Code */ + zfHpGetRegulationTablefromCountry(dev, Code); + } + else + { + /* Reset Regulation Table by Region Code */ + zfHpGetRegulationTablefromRegionCode(dev, Code); + } + + if (bfirstChannel) { + zmw_enter_critical_section(dev); + wd->frequency = zfChGetFirstChannel(dev, NULL); + zmw_leave_critical_section(dev); + zfCoreSetFrequency(dev, wd->frequency); + } +} + + +const char* zfiHpGetisoNamefromregionCode(zdev_t* dev, u16_t regionCode) +{ + return zfHpGetisoNamefromregionCode(dev, regionCode); +} + +u16_t zfiWlanChannelToFrequency(zdev_t* dev, u8_t channel) +{ + return zfChNumToFreq(dev, channel, 0); +} + +u8_t zfiWlanFrequencyToChannel(zdev_t* dev, u16_t freq) +{ + u8_t is5GBand = 0; + + return zfChFreqToNum(freq, &is5GBand); +} + +void zfiWlanDisableDfsChannel(zdev_t* dev, u8_t disableFlag) +{ + zfHpDisableDfsChannel(dev, disableFlag); + return; +} + +void zfiWlanSetLEDCtrlParam(zdev_t* dev, u8_t type, u8_t flag) +{ + zmw_get_wlan_dev(dev); + + zmw_declare_for_critical_section(); + + zmw_enter_critical_section(dev); + wd->ledStruct.LEDCtrlType = type; + wd->ledStruct.LEDCtrlFlagFromReg = flag; + zmw_leave_critical_section(dev); +} + +void zfiWlanEnableLeapConfig(zdev_t* dev, u8_t leapEnabled) +{ + zmw_get_wlan_dev(dev); + + wd->sta.leapEnabled = leapEnabled; +} + +u32_t zfiWlanQueryHwCapability(zdev_t* dev) +{ + return zfHpCapability(dev); +} + +u32_t zfiWlanQueryReceivedPacket(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->sta.ReceivedPktRatePerSecond; +} + +void zfiWlanCheckSWEncryption(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + if (wd->sta.SWEncryptEnable != 0) + { + zfHpSWDecrypt(dev, 1); + } +} + +u16_t zfiWlanQueryAllowChannels(zdev_t* dev, u16_t *channels) +{ + u16_t ii; + zmw_get_wlan_dev(dev); + + for (ii = 0; ii < wd->regulationTable.allowChannelCnt; ii++) + { + channels[ii] = wd->regulationTable.allowChannel[ii].channel; + } + + return wd->regulationTable.allowChannelCnt; +} + +void zfiWlanSetDynamicSIFSParam(zdev_t* dev, u8_t val) +{ + zmw_get_wlan_dev(dev); + + wd->dynamicSIFSEnable = val; + + zm_debug_msg1("wd->dynamicSIFSEnable = ", wd->dynamicSIFSEnable) +} + +u16_t zfiWlanGetMulticastAddressCount(zdev_t* dev) +{ + zmw_get_wlan_dev(dev); + + return wd->sta.multicastList.size; +} + +void zfiWlanGetMulticastList(zdev_t* dev, u8_t* pMCList) +{ + struct zsMulticastAddr* pMacList = (struct zsMulticastAddr*) pMCList; + u8_t i; + + zmw_get_wlan_dev(dev); + + for ( i=0; ista.multicastList.size; i++ ) + { + zfMemoryCopy(pMacList[i].addr, wd->sta.multicastList.macAddr[i].addr, 6); + } +} + +void zfiWlanSetPacketFilter(zdev_t* dev, u32_t PacketFilter) +{ + u8_t bAllMulticast = 0; + u32_t oldFilter; + + zmw_get_wlan_dev(dev); + + oldFilter = wd->sta.osRxFilter; + + wd->sta.osRxFilter = PacketFilter; + + if ((oldFilter & ZM_PACKET_TYPE_ALL_MULTICAST) != + (wd->sta.osRxFilter & ZM_PACKET_TYPE_ALL_MULTICAST)) + { + if ( wd->sta.osRxFilter & ZM_PACKET_TYPE_ALL_MULTICAST ) + bAllMulticast = 1; + zfHpSetMulticastList(dev, wd->sta.multicastList.size, + (u8_t*)wd->sta.multicastList.macAddr, bAllMulticast); + } +} + +u8_t zfiCompareWithMulticastListAddress(zdev_t* dev, u16_t* dstMacAddr) +{ + u8_t i; + u8_t bIsInMCListAddr = 0; + + zmw_get_wlan_dev(dev); + + for ( i=0; ista.multicastList.size; i++ ) + { + if ( zfwMemoryIsEqual((u8_t*)dstMacAddr, (u8_t*)wd->sta.multicastList.macAddr[i].addr, 6) ) + { + bIsInMCListAddr = 1; + break; + } + } + + return bIsInMCListAddr; +} + +void zfiWlanSetSafeModeEnabled(zdev_t* dev, u8_t safeMode) +{ + zmw_get_wlan_dev(dev); + + wd->sta.bSafeMode = safeMode; + + if ( safeMode ) + zfStaEnableSWEncryption(dev, 1); + else + zfStaDisableSWEncryption(dev); +} + +void zfiWlanSetIBSSAdditionalIELength(zdev_t* dev, u32_t ibssAdditionalIESize, u8_t* ibssAdditionalIE) +{ + zmw_get_wlan_dev(dev); + + if ( ibssAdditionalIESize ) + { + wd->sta.ibssAdditionalIESize = ibssAdditionalIESize; + zfMemoryCopy(wd->sta.ibssAdditionalIE, ibssAdditionalIE, (u16_t)ibssAdditionalIESize); + } + else + wd->sta.ibssAdditionalIESize = 0; +} -- cgit v1.2.3-55-g7522