Linux-2.6.33.2/drivers/staging/otus/80211core/cinit.c
/*
* 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 : init.c */
/* */
/* Abstract */
/* This module contains init functions. */
/* */
/* NOTES */
/* None */
/* */
/************************************************************************/
#include "cprecomp.h"
#include "../hal/hpreg.h"
extern const u8_t zcUpToAc[8];
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};
/************************************************************************/
/* */
/* FUNCTION DESCRIPTION zfTxGenWlanHeader */
/* Generate WLAN MAC header and LLC header. */
/* */
/* INPUTS */
/* dev : device pointer */
/* buf : buffer pointer */
/* id : Index of TxD */
/* port : WLAN port */
/* */
/* OUTPUTS */
/* length of removed Ethernet header */
/* */
/* AUTHOR */
/* Stephen ZyDAS Technology Corporation 2005.5 */
/* */
/************************************************************************/
u16_t zfTxGenWlanHeader(zdev_t* dev, zbuf_t* buf, u16_t* header, u16_t seq,
u8_t flag, u16_t plusLen, u16_t minusLen, u16_t port,
u16_t* da, u16_t* sa, u8_t up, u16_t *micLen,
u16_t* snap, u16_t snapLen, struct aggControl *aggControl)
{
u16_t len;
u16_t macCtrl;
u32_t phyCtrl;
u16_t hlen = 16;
u16_t icvLen = 0;
u16_t wdsPortId;
u16_t vap = 0;
u16_t mcs = 0;
u16_t mt = 0;
u8_t qosType;
u8_t b1, b2;
u16_t wdsPort;
u8_t encExemptionActionType;
u16_t rateProbingFlag = 0;
u8_t tkipFrameOffset = 0;
#ifdef ZM_ENABLE_IBSS_WPA2PSK
u8_t res, peerIdx;
u8_t userIdx=0;
u16_t *iv16;
u32_t *iv32;
#endif
zmw_get_wlan_dev(dev);
/* Generate WLAN header */
/* Frame control */
header[4] = 0x0008 | (flag<<8);
/* Duration */
header[5] = 0x0000;
if (wd->wlanMode == ZM_MODE_INFRASTRUCTURE)
{
/* ToDS bit */
header[4] |= 0x0100;
/*Sometimes we wake up to tx/rx but AP still think we are sleeping, so still need to set this bit*/
if ( zfPowerSavingMgrIsSleeping(dev) || wd->sta.psMgr.tempWakeUp == 1 )
{
header[4] |= 0x1000;
}
/* Address 1 = BSSID */
header[6] = wd->sta.bssid[0];
header[7] = wd->sta.bssid[1];
header[8] = wd->sta.bssid[2];
/* Address 3 = DA */
header[12] = da[0];
header[13] = da[1];
header[14] = da[2];
}
else if (wd->wlanMode == ZM_MODE_PSEUDO)
{
/* Address 1 = DA */
header[6] = da[0];
header[7] = da[1];
header[8] = da[2];
/* Address 3 = 00:00:00:00:00:00 */
header[12] = 0;
header[13] = 0;
header[14] = 0;
/* PSEUDO test : WDS */
if (wd->enableWDS)
{
/* ToDS and FromDS bit */
header[4] |= 0x0300;
/* Address 4 = SA */
header[16] = 0;
header[17] = 0;
header[18] = 0;
hlen = 19;
}
}
else if (wd->wlanMode == ZM_MODE_IBSS)
{
/* Address 1 = DA */
header[6] = da[0];
header[7] = da[1];
header[8] = da[2];
/* Address 3 = BSSID */
header[12] = wd->sta.bssid[0];
header[13] = wd->sta.bssid[1];
header[14] = wd->sta.bssid[2];
#ifdef ZM_ENABLE_IBSS_WPA2PSK
zmw_enter_critical_section(dev);
res = zfStaFindOppositeByMACAddr(dev, da, &peerIdx);
if(res == 0) // Find opposite in our OppositeInfo Structure !
{
userIdx = peerIdx;
}
zmw_leave_critical_section(dev);
#endif
}
else if (wd->wlanMode == ZM_MODE_AP)
{
if (port < 0x20)
/* AP mode */
{
/* FromDS bit */
header[4] |= 0x0200;
/* Address 1 = DA */
header[6] = da[0];
header[7] = da[1];
header[8] = da[2];
/* Address 3 = SA */
header[12] = sa[0];
header[13] = sa[1];
header[14] = sa[2];
if (port < ZM_MAX_AP_SUPPORT)
{
vap = port;
header[14] += (vap<<8);
}
}
else
/* WDS port */
{
/* ToDS and FromDS bit */
header[4] |= 0x0300;
wdsPortId = port - 0x20;
/* Address 1 = RA */
header[6] = wd->ap.wds.macAddr[wdsPortId][0];
header[7] = wd->ap.wds.macAddr[wdsPortId][1];
header[8] = wd->ap.wds.macAddr[wdsPortId][2];
/* Address 3 = DA */
header[12] = da[0];
header[13] = da[1];
header[14] = da[2];
/* Address 4 = SA */
header[16] = sa[0];
header[17] = sa[1];
header[18] = sa[2];
hlen = 19;
}
} /* else if (wd->wlanMode == ZM_MODE_AP) */
/* Address 2 = TA */
header[9] = wd->macAddr[0];
header[10] = wd->macAddr[1];
#ifdef ZM_VAPMODE_MULTILE_SSID
header[11] = wd->macAddr[2]; //Multiple SSID
#else
header[11] = wd->macAddr[2] + (vap<<8); //VAP
#endif
if ( (wd->wlanMode == ZM_MODE_IBSS) && (wd->XLinkMode) )
{
header[9] = sa[0];
header[10] = sa[1];
header[11] = sa[2];
}
/* Sequence Control */
header[15] = seq;
if (wd->wlanMode == ZM_MODE_AP)
{
zfApGetStaTxRateAndQosType(dev, da, &phyCtrl, &qosType, &rateProbingFlag);
mt = (u16_t)(phyCtrl & 0x3);
mcs = (u16_t)((phyCtrl >> 16) & 0x3f);
#if 1
//zfApGetStaQosType(dev, da, &qosType);
/* if DA == WME STA */
if (qosType == 1)
{
/* QoS data */
header[4] |= 0x0080;
/* QoS Control */
header[hlen] = up;
hlen += 1;
}
#endif
}
#if 0
//AGG Test Code
if (header[6] == 0x8000)
{
/* QoS data */
header[4] |= 0x0080;
/* QoS Control */
header[hlen] = 0;
hlen += 1;
}
#endif
if (wd->wlanMode == ZM_MODE_AP) {
/* Todo: rate control here for qos field */
}
else {
/* Rate control */
zfStaGetTxRate(dev, da, &phyCtrl, &rateProbingFlag);
mt = (u16_t)(phyCtrl & 0x3);
mcs = (u16_t)((phyCtrl >> 16) & 0x3f);
}
if (wd->txMCS != 0xff)
{
/* fixed rate */
phyCtrl = ((u32_t)wd->txMCS<<16) + wd->txMT;
mcs = wd->txMCS;
mt = wd->txMT;
}
if (wd->enableAggregation)
{
/* force enable aggregation */
if (wd->enableAggregation==2 && !(header[6]&0x1))
{
/* QoS data */
header[4] |= 0x0080;
/* QoS Control */
header[hlen] = 0;
hlen += 1;
}
/* if wd->enableAggregation=1 => force disable */
/* if wd->enableAggregation=0 => auto */
}
#ifdef ZM_ENABLE_AGGREGATION
/*
* aggregation control
*/
/*
* QoS data
*/
if (wd->wlanMode == ZM_MODE_AP) {
if (aggControl && mt == 2) {
if (wd->enableAggregation==0 && !(header[6]&0x1))
{
header[4] |= 0x0080;
/*
* QoS Control
*/
header[hlen] = 0;
hlen += 1;
}
}
}
#endif
// MSDU Length
len = zfwBufGetSize(dev, buf);
/* Generate control setting */
/* Backoff, Non-Burst and hardware duration */
macCtrl = 0x208;
/* ACK */
if ((header[6] & 0x1) == 0x1)
{
/* multicast frame : Set NO-ACK bit */
macCtrl |= 0x4;
}
else
{
/* unicast frame */
#if 0
// Enable RTS according to MPDU Lengths ( not MSDU Lengths )
if (len >= wd->rtsThreshold)
{
/* Enable RTS */
macCtrl |= 1;
}
#endif
}
/* VAP test code */
//macCtrl |= 0x4;
if (wd->wlanMode == ZM_MODE_AP)
{
u8_t encryType;
u16_t iv16;
u32_t iv32;
/* Check whether this is a multicast frame */
if ((header[6] & 0x1) == 0x1)
{
/* multicast frame */
if (wd->ap.encryMode[vap] == ZM_TKIP)
{
wd->ap.iv16[vap]++;
if(wd->ap.iv16[vap] == 0)
{
wd->ap.iv32[vap]++;
}
b1 = (u8_t) (wd->ap.iv16[vap] >> 8);
b2 = (b1 | 0x20) & 0x7f;
header[hlen] = ((u16_t)b2 << 8) + b1;
b1 = (u8_t) wd->ap.iv16[vap];
b2 = 0x20 | (wd->ap.bcKeyIndex[vap] << 6);
header[hlen+1] = ((u16_t)b2 << 8) + b1;
header[hlen+2] = (u16_t) wd->ap.iv32[vap];
header[hlen+3] = (u16_t) (wd->ap.iv32[vap] >> 16);
//macCtrl |= 0x80;
macCtrl |= 0x40;
icvLen = 4;
/* set hardware MIC */
if ( (!(seq & 0xf))&&(!(flag & 0x4)) )
{
macCtrl |= 0x100;
plusLen += 8;
*micLen = 8;
}
header[4] |= 0x4000;
hlen += 4;
}
else if (wd->ap.encryMode[vap] == ZM_AES)
{
wd->ap.iv16[vap]++;
if(wd->ap.iv16[vap] == 0)
{
wd->ap.iv32[vap]++;
}
b1 = (u8_t) wd->ap.iv16[vap];
b2 = (u8_t) (wd->ap.iv16[vap] >> 8);
header[hlen] = ((u16_t)b2 << 8) + b1;
header[hlen+1] = 0x2000 | (wd->ap.bcKeyIndex[vap] << 14);
header[hlen+2] = (u16_t) (wd->ap.iv32[vap]);
header[hlen+3] = (u16_t) (wd->ap.iv32[vap] >> 16);
macCtrl |= 0xc0;
icvLen = 8; /* MIC */
header[4] |= 0x4000;
hlen += 4;
}
#ifdef ZM_ENABLE_CENC
else if (wd->ap.encryMode[vap] == ZM_CENC)
{
//u32_t txiv[4];
wd->ap.txiv[vap][0]++;
if (wd->ap.txiv[vap][0] == 0)
{
wd->ap.txiv[vap][1]++;
}
if (wd->ap.txiv[vap][1] == 0)
{
wd->ap.txiv[vap][2]++;
}
if (wd->ap.txiv[vap][2] == 0)
{
wd->ap.txiv[vap][3]++;
}
if (wd->ap.txiv[vap][3] == 0)
{
wd->ap.txiv[vap][0] = 0;
wd->ap.txiv[vap][1] = 0;
wd->ap.txiv[vap][2] = 0;
}
header[hlen] = (wd->ap.bcKeyIndex[vap] & 0x0001); /* For Key Id and reserved field */
header[hlen+1] = (u16_t)wd->ap.txiv[vap][0];
header[hlen+2] = (u16_t)(wd->ap.txiv[vap][0] >> 16);
header[hlen+3] = (u16_t)wd->ap.txiv[vap][1];
header[hlen+4] = (u16_t)(wd->ap.txiv[vap][1] >> 16);
header[hlen+5] = (u16_t)wd->ap.txiv[vap][2];
header[hlen+6] = (u16_t)(wd->ap.txiv[vap][2] >> 16);
header[hlen+7] = (u16_t)wd->ap.txiv[vap][3];
header[hlen+8] = (u16_t)(wd->ap.txiv[vap][3] >> 16);
macCtrl |= 0x80;
icvLen = 16; /* MIC */
header[4] |= 0x4000;
hlen += 9;
}
#endif //ZM_ENABLE_CENC
}
else
{
/* Get STA's encryption type */
zfApGetStaEncryType(dev, da, &encryType);
if (encryType == ZM_TKIP)
{
/* Get iv16 and iv32 */
zfApGetStaWpaIv(dev, da, &iv16, &iv32);
iv16++;
if (iv16 == 0)
{
iv32++;
}
b1 = (u8_t) (iv16 >> 8);
b2 = (b1 | 0x20) & 0x7f;
header[hlen] = ((u16_t)b2 << 8) + b1;
b1 = (u8_t) iv16;
b2 = 0x20;
header[hlen+1] = ((u16_t)b2 << 8) + b1;
header[hlen+2] = (u16_t) iv32;
header[hlen+3] = (u16_t) (iv32 >> 16);
//macCtrl |= 0x80;
macCtrl |= 0x40;
icvLen = 4;
/* set hardware MIC */
if ( (!(seq & 0xf))&&(!(flag & 0x4)) )
{
macCtrl |= 0x100;
plusLen += 8;
*micLen = 8;
}
header[4] |= 0x4000;
hlen += 4;
/* Set iv16 and iv32 */
zfApSetStaWpaIv(dev, da, iv16, iv32);
}
else if (encryType == ZM_AES)
{
/* Get iv16 and iv32 */
zfApGetStaWpaIv(dev, da, &iv16, &iv32);
iv16++;
if (iv16 == 0)
{
iv32++;
}
b1 = (u8_t) iv16;
b2 = (u8_t) (iv16 >> 8);
header[hlen] = ((u16_t)b2 << 8) + b1;
header[hlen+1] = 0x2000;
header[hlen+2] = (u16_t) (iv32);
header[hlen+3] = (u16_t) (iv32 >> 16);
macCtrl |= 0xc0;
icvLen = 8; /* MIC */
header[4] |= 0x4000;
hlen += 4;
/* Set iv16 and iv32 */
zfApSetStaWpaIv(dev, da, iv16, iv32);
}
#ifdef ZM_ENABLE_CENC
else if (encryType == ZM_CENC)
{
u32_t txiv[4];
u8_t keyIdx;
/* Get CENC TxIV */
zfApGetStaCencIvAndKeyIdx(dev, da, txiv, &keyIdx);
txiv[0] += 2;
if (txiv[0] == 0 || txiv[0] == 1)
{
txiv[1]++;
}
if (txiv[1] == 0)
{
txiv[2]++;
}
if (txiv[2] == 0)
{
txiv[3]++;
}
if (txiv[3] == 0)
{
txiv[0] = 0;
txiv[1] = 0;
txiv[2] = 0;
}
header[hlen] = (keyIdx & 0x0001); /* For Key Id and reserved field */
header[hlen+1] = (u16_t)txiv[0];
header[hlen+2] = (u16_t)(txiv[0] >> 16);
header[hlen+3] = (u16_t)txiv[1];
header[hlen+4] = (u16_t)(txiv[1] >> 16);
header[hlen+5] = (u16_t)txiv[2];
header[hlen+6] = (u16_t)(txiv[2] >> 16);
header[hlen+7] = (u16_t)txiv[3];
header[hlen+8] = (u16_t)(txiv[3] >> 16);
macCtrl |= 0x80;
icvLen = 16; /* MIC */
header[4] |= 0x4000;
hlen += 9;
/* Set CENC IV */
zfApSetStaCencIv(dev, da, txiv);
}
#endif //ZM_ENABLE_CENC
}
/* protection mode */
if (wd->ap.protectionMode == 1)
{
/* Enable Self-CTS */
macCtrl &= 0xFFFC;
macCtrl |= 2;
}
/* Rate Control */
if (port < 0x20)
{
/* AP */
/* IV */
if ((wd->ap.encryMode[vap] == ZM_WEP64) ||
(wd->ap.encryMode[vap] == ZM_WEP128) ||
(wd->ap.encryMode[vap] == ZM_WEP256))
{
header[4] |= 0x4000;
header[hlen] = 0x0; //IV
header[hlen+1] = wd->ap.bcKeyIndex[vap] << 14; //IV with Keyid--CWYang(m)
hlen += 2;
icvLen = 4;
macCtrl |= 0x40;
}
}
else
{
/* WDS */
/* TODO : Fixed rate to 54M */
phyCtrl = 0xc0001; //PHY control L
/* WDS port checking */
if ((wdsPort = (port - 0x20)) >= ZM_MAX_WDS_SUPPORT)
{
wdsPort = 0;
}
#if 1
/* IV */
switch (wd->ap.wds.encryMode[wdsPort])
{
case ZM_WEP64:
case ZM_WEP128:
case ZM_WEP256:
header[4] |= 0x4000;
header[hlen] = 0x0; //IV
header[hlen+1] = wd->ap.bcKeyIndex[vap] << 14; //IV with Keyid
hlen += 2;
icvLen = 4;
macCtrl |= 0x40;
break;
case ZM_TKIP:
wd->sta.iv16++;
if ( wd->sta.iv16 == 0 )
{
wd->sta.iv32++;
}
b1 = (u8_t) (wd->sta.iv16 >> 8);
b2 = (b1 | 0x20) & 0x7f;
header[hlen] = ((u16_t)b2 << 8) + b1;
b1 = (u8_t) wd->sta.iv16;
b2 = 0x20;
header[hlen+1] = ((u16_t)b2 << 8) + b1;
header[hlen+2] = (u16_t) wd->sta.iv32;
header[hlen+3] = (u16_t) (wd->sta.iv32 >> 16);
//macCtrl |= 0x80;
macCtrl |= 0x40;
icvLen = 4;
/* set hardware MIC */
if ( (!(seq & 0xf))&&(!(flag & 0x4)) )
{
macCtrl |= 0x100;
plusLen += 8;
*micLen = 8;
}
header[4] |= 0x4000;
hlen += 4;
break;
case ZM_AES:
wd->sta.iv16++;
if ( wd->sta.iv16 == 0 )
{
wd->sta.iv32++;
}
b1 = (u8_t) wd->sta.iv16;
b2 = (u8_t) (wd->sta.iv16 >> 8);
header[hlen] = ((u16_t)b2 << 8) + b1;
header[hlen+1] = 0x2000;
header[hlen+2] = (u16_t) (wd->sta.iv32);
header[hlen+3] = (u16_t) (wd->sta.iv32 >> 16);
macCtrl |= 0xc0; /* Set to AES in control setting */
icvLen = 8; /* MIC */
header[4] |= 0x4000; /* Set WEP bit in wlan header */
hlen += 4; /* plus IV length */
break;
}/* end of switch */
#endif
}
}
else /* wd->wlanMode != ZM_MODE_AP */
{
encExemptionActionType = zfwGetPktEncExemptionActionType(dev, buf);
if ( wd->wlanMode == ZM_MODE_INFRASTRUCTURE )
{
#if 1
/* if WME AP */
if (wd->sta.wmeConnected != 0)
{
/* QoS data */
header[4] |= 0x0080;
/* QoS Control */
header[hlen] = up;
hlen += 1;
}
#endif
if ( encExemptionActionType == ZM_ENCRYPTION_EXEMPT_NO_EXEMPTION )
{
if ( wd->sta.authMode < ZM_AUTH_MODE_WPA )
{ /* non-WPA */
if ( wd->sta.wepStatus == ZM_ENCRYPTION_WEP_ENABLED )
{
if ( (wd->sta.encryMode == ZM_WEP64)||
(wd->sta.encryMode == ZM_WEP128)||
(wd->sta.encryMode == ZM_WEP256) )
{
header[4] |= 0x4000;
header[hlen] = 0x0; //IV
header[hlen+1] = 0x0; //IV
header[hlen+1] |= (((u16_t) wd->sta.keyId) << 14);
hlen += 2;
icvLen = 4;
/* For Software WEP */
if ((wd->sta.SWEncryptEnable & ZM_SW_WEP_ENCRY_EN) != 0)
{
u8_t keyLen = 5;
u8_t iv[3];
iv[0] = 0x0;
iv[1] = 0x0;
iv[2] = 0x0;
if (wd->sta.SWEncryMode[wd->sta.keyId] == ZM_WEP64)
{
keyLen = 5;
}
else if (wd->sta.SWEncryMode[wd->sta.keyId] == ZM_WEP128)
{
keyLen = 13;
}
else if (wd->sta.SWEncryMode[wd->sta.keyId] == ZM_WEP256)
{
keyLen = 29;
}
zfWEPEncrypt(dev, buf, (u8_t*) snap, snapLen, minusLen, keyLen,
wd->sta.wepKey[wd->sta.keyId], iv);
}
else
{
macCtrl |= 0x40;
}
}
}
}
else
{ /* WPA */
if ( wd->sta.wpaState >= ZM_STA_WPA_STATE_PK_OK )
{
wd->sta.iv16++;
if ( wd->sta.iv16 == 0 )
{
wd->sta.iv32++;
}
/* set encryption mode */
if ( wd->sta.encryMode == ZM_TKIP )
{
b1 = (u8_t) (wd->sta.iv16 >> 8);
b2 = (b1 | 0x20) & 0x7f;
header[hlen] = ((u16_t)b2 << 8) + b1;
b1 = (u8_t) wd->sta.iv16;
b2 = 0x20;
// header[hlen+1] = (((u16_t) wd->sta.keyId) << 14) | (((u16_t)b2 << 8) + b1);
// STA in infrastructure mode should use keyId = 0 to transmit unicast !
header[hlen+1] = (((u16_t)b2 << 8) + b1);
header[hlen+2] = (u16_t) wd->sta.iv32;
header[hlen+3] = (u16_t) (wd->sta.iv32 >> 16);
/* If software encryption enable */
if ((wd->sta.SWEncryptEnable & ZM_SW_TKIP_ENCRY_EN) == 0)
{
//macCtrl |= 0x80;
/* TKIP same to WEP */
macCtrl |= 0x40;
icvLen = 4;
/* set hardware MIC */
if ( (!(seq & 0xf))&&(!(flag & 0x4)) )
{
macCtrl |= 0x100;
plusLen += 8;
*micLen = 8;
}
}
else
{
u8_t mic[8];
u16_t offset;
u32_t icv;
u8_t RC4Key[16];
/* TODO: Remove the criticial section here. */
zmw_declare_for_critical_section();
zmw_enter_critical_section(dev);
/* Calculate MIC */
zfCalTxMic(dev, buf, (u8_t *)snap, snapLen, minusLen, da, sa, up, mic);
offset = zfwBufGetSize(dev, buf);
/* Append MIC to the buffer */
zfCopyToIntTxBuffer(dev, buf, mic, offset, 8);
zfwBufSetSize(dev, buf, offset+8);
zmw_leave_critical_section(dev);
/* TKIP Key Mixing */
zfTkipPhase1KeyMix(wd->sta.iv32, &wd->sta.txSeed);
zfTkipPhase2KeyMix(wd->sta.iv16, &wd->sta.txSeed);
zfTkipGetseeds(wd->sta.iv16, RC4Key, &wd->sta.txSeed);
/* Encrypt Data */
zfTKIPEncrypt(dev, buf, (u8_t *)snap, snapLen, minusLen, 16, RC4Key, &icv);
icvLen = 4;
len += 8;
}
header[4] |= 0x4000;
hlen += 4;
}
else if ( wd->sta.encryMode == ZM_AES )
{
b1 = (u8_t) wd->sta.iv16;
b2 = (u8_t) (wd->sta.iv16 >> 8);
header[hlen] = ((u16_t)b2 << 8) + b1;
// header[hlen+1] = (((u16_t) wd->sta.keyId) << 14) | (0x2000);
// STA in infrastructure mode should use keyId = 0 to transmit unicast !
header[hlen+1] = 0x2000;
header[hlen+2] = (u16_t) (wd->sta.iv32);
header[hlen+3] = (u16_t) (wd->sta.iv32 >> 16);
macCtrl |= 0xc0;
icvLen = 8; /* MIC */
header[4] |= 0x4000;
hlen += 4;
}
#ifdef ZM_ENABLE_CENC
else if ( wd->sta.encryMode == ZM_CENC )
{
/* Accumlate the PN sequence */
wd->sta.txiv[0] += 2;
if (wd->sta.txiv[0] == 0 || wd->sta.txiv[0] == 1)
{
wd->sta.txiv[1]++;
}
if (wd->sta.txiv[1] == 0)
{
wd->sta.txiv[2]++;
}
if (wd->sta.txiv[2] == 0)
{
wd->sta.txiv[3]++;
}
if (wd->sta.txiv[3] == 0)
{
wd->sta.txiv[0] = 0;
wd->sta.txiv[1] = 0;
wd->sta.txiv[2] = 0;
}
header[hlen] = (wd->sta.cencKeyId & 0x0001); /* For Key Id and reserved field */
header[hlen+1] = (u16_t) wd->sta.txiv[0];
header[hlen+2] = (u16_t) (wd->sta.txiv[0] >> 16);
header[hlen+3] = (u16_t) wd->sta.txiv[1];
header[hlen+4] = (u16_t) (wd->sta.txiv[1] >> 16);
header[hlen+5] = (u16_t) wd->sta.txiv[2];
header[hlen+6] = (u16_t) (wd->sta.txiv[2] >> 16);
header[hlen+7] = (u16_t) wd->sta.txiv[3];
header[hlen+8] = (u16_t) (wd->sta.txiv[3] >> 16);
macCtrl |= 0x80;
icvLen = 16; /* MIC */
header[4] |= 0x4000;
hlen += 9;
}
#endif //ZM_ENABLE_CENC
}
}
} // if ( encExemptionActionType == ZM_ENCRYPTION_EXEMPT_NO_EXEMPTION )
} /* if ( wd->wlanMode != ZM_MODE_INFRASTRUCTURE ) */
if ( wd->wlanMode == ZM_MODE_IBSS )
{
if ( encExemptionActionType == ZM_ENCRYPTION_EXEMPT_NO_EXEMPTION )
{
#ifdef ZM_ENABLE_IBSS_WPA2PSK
if( wd->sta.oppositeInfo[userIdx].wpaState >= ZM_STA_WPA_STATE_PK_OK || wd->sta.wpaState >= ZM_STA_WPA_STATE_PK_OK)
{
int isUnicast = 1 ;
if((da[0]& 0x1))
{
isUnicast = 0 ; // Not unicast , is broadcast
}
if( wd->sta.ibssWpa2Psk == 1 )
{ /* The IV order is not the same between unicast and broadcast ! */
if ( isUnicast )
{
iv16 = &wd->sta.oppositeInfo[userIdx].iv16;
iv32 = &wd->sta.oppositeInfo[userIdx].iv32;
}
else
{
iv16 = &wd->sta.iv16;
iv32 = &wd->sta.iv32;
}
}
else
{
iv16 = &wd->sta.iv16;
iv32 = &wd->sta.iv32;
}
(*iv16)++;
if ( *iv16 == 0 )
{
*iv32++;
}
if ( wd->sta.oppositeInfo[userIdx].encryMode == ZM_AES || wd->sta.encryMode == ZM_AES)
{
//printk("Station encryption mode is AES-CCMP\n") ;
b1 = (u8_t) (*iv16);
b2 = (u8_t) ((*iv16) >> 8);
header[hlen] = ((u16_t)b2 << 8) + b1;
if ( isUnicast )
{
header[hlen+1] = 0x2000;
}
else
{
header[hlen+1] = 0x2000 | (((u16_t) wd->sta.keyId) << 14);
}
header[hlen+2] = (u16_t) (*iv32);
header[hlen+3] = (u16_t) ((*iv32) >> 16);
macCtrl |= 0xc0;
icvLen = 8; /* MIC */
}
header[4] |= 0x4000;
hlen += 4;
}
else if ( wd->sta.wepStatus == ZM_ENCRYPTION_WEP_ENABLED)
{
if ( (wd->sta.encryMode == ZM_WEP64)||
(wd->sta.encryMode == ZM_WEP128)||
(wd->sta.encryMode == ZM_WEP256) )
{
header[4] |= 0x4000;
header[hlen] = 0x0; //IV
header[hlen+1] = 0x0; //IV
header[hlen+1] |= (((u16_t) wd->sta.keyId) << 14);
hlen += 2;
icvLen = 4;
macCtrl |= 0x40;
}
}
#else
/* ----- 20070405 add by Mxzeng ----- */
if( wd->sta.wpaState >= ZM_STA_WPA_STATE_PK_OK )
{
int isUnicast = 1 ;
if((da[0]& 0x1))
{
isUnicast = 0 ; // Not unicast , is broadcast
}
wd->sta.iv16++;
if ( wd->sta.iv16 == 0 )
{
wd->sta.iv32++;
}
if ( wd->sta.encryMode == ZM_AES )
{
//printk("Station encryption mode is AES-CCMP\n") ;
b1 = (u8_t) wd->sta.iv16;
b2 = (u8_t) (wd->sta.iv16 >> 8);
header[hlen] = ((u16_t)b2 << 8) + b1;
if ( isUnicast )
{
header[hlen+1] = 0x2000;
}
else
{
header[hlen+1] = 0x2000 | (((u16_t) wd->sta.keyId) << 14);
}
header[hlen+2] = (u16_t) (wd->sta.iv32);
header[hlen+3] = (u16_t) (wd->sta.iv32 >> 16);
macCtrl |= 0xc0;
icvLen = 8; /* MIC */
}
header[4] |= 0x4000;
hlen += 4;
}
else if ( wd->sta.wepStatus == ZM_ENCRYPTION_WEP_ENABLED)
{
if ( (wd->sta.encryMode == ZM_WEP64)||
(wd->sta.encryMode == ZM_WEP128)||
(wd->sta.encryMode == ZM_WEP256) )
{
header[4] |= 0x4000;
header[hlen] = 0x0; //IV
header[hlen+1] = 0x0; //IV
header[hlen+1] |= (((u16_t) wd->sta.keyId) << 14);
hlen += 2;
icvLen = 4;
macCtrl |= 0x40;
}
}
#endif
} // End if ( encExemptionActionType == ZM_ENCRYPTION_EXEMPT_NO_EXEMPTION )
} // End if ( wd->wlanMode == ZM_MODE_IBSS )
else if ( wd->wlanMode == ZM_MODE_PSEUDO )
{
switch (wd->sta.encryMode)
{
case ZM_WEP64:
case ZM_WEP128:
case ZM_WEP256:
header[4] |= 0x4000;
header[hlen] = 0x0; //IV
header[hlen+1] = 0x0; //IV
hlen += 2;
icvLen = 4;
macCtrl |= 0x40;
break;
case ZM_TKIP:
{
wd->sta.iv16++;
if ( wd->sta.iv16 == 0 )
{
wd->sta.iv32++;
}
b1 = (u8_t) (wd->sta.iv16 >> 8);
b2 = (b1 | 0x20) & 0x7f;
header[hlen] = ((u16_t)b2 << 8) + b1;
b1 = (u8_t) wd->sta.iv16;
b2 = 0x20;
header[hlen+1] = ((u16_t)b2 << 8) + b1;
header[hlen+2] = (u16_t) wd->sta.iv32;
header[hlen+3] = (u16_t) (wd->sta.iv32 >> 16);
//macCtrl |= 0x80;
macCtrl |= 0x40;
icvLen = 4;
/* set hardware MIC */
if ( (!(seq & 0xf))&&(!(flag & 0x4)) )
{
macCtrl |= 0x100;
plusLen += 8;
*micLen = 8;
}
header[4] |= 0x4000;
hlen += 4;
}/* end of PSEUDO TKIP */
break;
case ZM_AES:
{
wd->sta.iv16++;
if ( wd->sta.iv16 == 0 )
{
wd->sta.iv32++;
}
b1 = (u8_t) wd->sta.iv16;
b2 = (u8_t) (wd->sta.iv16 >> 8);
header[hlen] = ((u16_t)b2 << 8) + b1;
header[hlen+1] = 0x2000;
header[hlen+2] = (u16_t) (wd->sta.iv32);
header[hlen+3] = (u16_t) (wd->sta.iv32 >> 16);
macCtrl |= 0xc0;
icvLen = 8; /* MIC */
header[4] |= 0x4000;
hlen += 4;
}/* end of PSEUDO AES */
break;
#ifdef ZM_ENABLE_CENC
case ZM_CENC:
/* Accumlate the PN sequence */
wd->sta.txiv[0] += 2;
if (wd->sta.txiv[0] == 0 || wd->sta.txiv[0] == 1)
{
wd->sta.txiv[1]++;
}
if (wd->sta.txiv[1] == 0)
{
wd->sta.txiv[2]++;
}
if (wd->sta.txiv[2] == 0)
{
wd->sta.txiv[3]++;
}
if (wd->sta.txiv[3] == 0)
{
wd->sta.txiv[0] = 0;
wd->sta.txiv[1] = 0;
wd->sta.txiv[2] = 0;
}
header[hlen] = 0;
header[hlen+1] = (u16_t) wd->sta.txiv[0];
header[hlen+2] = (u16_t) (wd->sta.txiv[0] >> 16);
header[hlen+3] = (u16_t) wd->sta.txiv[1];
header[hlen+4] = (u16_t) (wd->sta.txiv[1] >> 16);
header[hlen+5] = (u16_t) wd->sta.txiv[2];
header[hlen+6] = (u16_t) (wd->sta.txiv[2] >> 16);
header[hlen+7] = (u16_t) wd->sta.txiv[3];
header[hlen+8] = (u16_t) (wd->sta.txiv[3] >> 16);
macCtrl |= 0x80;
icvLen = 16; /* MIC */
header[4] |= 0x4000;
hlen += 9;
break;
#endif //ZM_ENABLE_CENC
}/* end of switch */
}
/* Generate control setting */
/* protection mode */
if (wd->enableProtectionMode)
{
if (wd->enableProtectionMode==2)
{
/* Force enable protection: self cts */
macCtrl &= 0xFFFC;
macCtrl |= 2;
}
/* if wd->enableProtectionMode=1 => force disable */
/* if wd->enableProtectionMode=0 => auto */
}
else
{
/* protection mode */
if (wd->sta.bProtectionMode == TRUE)
{
/* Enable Self-CTS */
macCtrl &= 0xFFFC;
macCtrl |= 2;
}
}
}
if (wd->txMCS != 0xff)
{
/* fixed rate */
phyCtrl = ((u32_t)wd->txMCS<<16) + wd->txMT;
mcs = wd->txMCS;
mt = wd->txMT;
}
if (mt == 2)
{
#if 0
/* HT PT: 0 Mixed mode 1 Green field */
if (wd->sta.preambleTypeHT == ZM_PREAMBLE_TYPE_GREEN_FIELD)
{
phyCtrl |= 0x4; /* Bit 2 */
}
#endif
/* Bandwidth */
if (wd->sta.htCtrlBandwidth == ZM_BANDWIDTH_40MHZ)
{
phyCtrl |= (0x80<<16); /* BIT 23 */
}
#if 0
/* STBC */
if (wd->sta.htCtrlSTBC<=0x3)
{
phyCtrl |= (wd->sta.htCtrlSTBC<<28); /* BIT 23 */
}
#endif
/* Short GI */
if(wd->sta.htCtrlSG)
{
phyCtrl |= (0x8000<<16); /* BIT 31 */
}
/* TA */
if ( ((mcs >=0x8) && (mcs<=0xf)) || (wd->sta.htCtrlSTBC) )
{
phyCtrl |= 0x1800; /* BIT 11 12 */
}
}
else if(mt == 1)
{
#if 0
//bug that cause OFDM rate become duplicate legacy rate
/* Bandwidth */
if (wd->sta.htCtrlBandwidth == ZM_BANDWIDTH_40MHZ)
{
phyCtrl |= (0x80<<16); /* BIT 23 */
mt = 3; /* duplicate legacy */
phyCtrl |= mt;
}
#endif
}
else if(mt == 0)
{
/* CCK PT: Legcy Preamble: 1 long preamble 2 short preamble */
if (wd->preambleTypeInUsed == ZM_PREAMBLE_TYPE_SHORT)
{
//phyCtrl |= 0x4; /* BIT 2 */
}
}
/* TA */
if (wd->sta.defaultTA)
{
phyCtrl |= 0x1000;
}
else
{
phyCtrl |= 0x0800;
}
//Get CurrentTxRate -- CWYang(+)
if ((mt == 0) || (mt == 1)) //B,G Rate
{
if (mcs < 16)
{
wd->CurrentTxRateKbps = zcIndextoRateBG[mcs];
}
}
else if (mt == 2)
{
if (mcs < 16)
{
if (wd->sta.htCtrlBandwidth == ZM_BANDWIDTH_40MHZ)
{
if((phyCtrl & 0x80000000) != 0)
{
/* Short GI 40 MHz MIMO Rate */
wd->CurrentTxRateKbps = zcIndextoRateN40S[mcs];
}
else
{
/* Long GI 40 MHz MIMO Rate */
wd->CurrentTxRateKbps = zcIndextoRateN40L[mcs];
}
}
else
{
if((phyCtrl & 0x80000000) != 0)
{
/* Short GI 20 MHz MIMO Rate */
wd->CurrentTxRateKbps = zcIndextoRateN20S[mcs];
}
else
{
/* Long GI 20 MHz MIMO Rate */
wd->CurrentTxRateKbps = zcIndextoRateN20L[mcs];
}
}
}
}
//802.11 header(include IV) = (hlen<<1)-8
//ethernet frame = len
//snap + mic = plusLen
//ethernet header = minusLen
//icv = icvLen
//crc32 = 4
//length=802.11 header+snap+(ethernet frame-ethernet header)+mic+icv+crc32
header[0] = ((hlen<<1)-8)+plusLen+(len-minusLen)+icvLen+4; //Length
// header[0] : MPDU Lengths
if ((header[6] & 0x1) != 0x1) // Unicast Frame
{
if (header[0] >= wd->rtsThreshold)
{
/* Enable RTS */
macCtrl |= 1;
}
}
if ( wd->sta.encryMode == ZM_TKIP )
tkipFrameOffset = 8;
if( wd->sta.EnableHT != 1 )
{ // Aggregation should not be fragmented !
if ( header[0] > ( wd->fragThreshold + tkipFrameOffset ) )
{
return 0; // Need to be fragmented ! !
}
}
//if ( wd->sta.encryMode == ZM_TKIP )
//{
// zm_debug_msg1("ctrl length = ", header[0]);
//}
//MAC control
if (rateProbingFlag != 0)
{
macCtrl |= 0x8000;
}
header[1] = macCtrl;
//PHY control L
header[2] = (u16_t) ((phyCtrl&0xffff) | 0x700 | (zcUpToAc[up&0x7]<<13));
//PHY control H
header[3] = (u16_t) ((phyCtrl>>16) | 0x700);
if (wd->enableAggregation)
{
/* force enable aggregation */
if (wd->enableAggregation==2 && !(header[6]&0x1))
{
if (((header[2] & 0x3) == 2))
{
/* Enable aggregation */
header[1] |= 0x20;
}
}
/* if wd->enableAggregation=1 => force disable */
/* if wd->enableAggregation=0 => auto */
}
#ifdef ZM_ENABLE_AGGREGATION
if (wd->addbaComplete) {
#ifdef ZM_BYPASS_AGGR_SCHEDULING
if (!(header[6]&0x1) && !rateProbingFlag && (wd->enableAggregation != 1))
{
if (((header[2] & 0x3) == 2))
{
/* Unicast frame with HT rate => Enable aggregation */
/* We only support software encryption in single packet mode */
if ((wd->sta.SWEncryptEnable & ZM_SW_TKIP_ENCRY_EN) == 0 &&
(wd->sta.SWEncryptEnable & ZM_SW_WEP_ENCRY_EN) == 0)
{
/* Set aggregation group bits per AC */
header[1] |= (0x20 | (zcUpToAc[up&0x7]<<10));
//if (wd->sta.currentFrequency < 3000)
{
/* issue: -PB42 Enable RTS/CTS to prevent OWL Tx hang up */
/* If this is Owl Ap, enable RTS/CTS protect */
if ( (wd->sta.athOwlAp == 1) || (wd->sta.RTSInAGGMode == TRUE) )
{
header[1] &= 0xfffc;
header[1] |= 0x1;
}
/* Enable RIFS : workaround 854T RTS/CTS */
/* Bit13 : TI enable RIFS */
//header[1] |= 0x2000;
}
}
}
}
#else
/*
* aggregation ampduIndication control
*/
if (aggControl && aggControl->aggEnabled) {
if (wd->enableAggregation==0 && !(header[6]&0x1))
{
if (((header[2] & 0x3) == 2))
{
/* Enable aggregation */
header[1] |= 0x20;
if (ZM_AGG_LAST_MPDU == aggControl->ampduIndication)
header[1] |= 0x4000;
}
else {
zm_debug_msg1("no aggr, header[2]&0x3 = ",header[2] & 0x3)
aggControl->aggEnabled = 0;
}
}
else {
zm_debug_msg1("no aggr, wd->enableAggregation = ", wd->enableAggregation);
zm_debug_msg1("no aggr, !header[6]&0x1 = ",!(header[6]&0x1));
aggControl->aggEnabled = 0;
}
}
#endif
#ifdef ZM_AGGR_BIT_ON
if (!(header[6]&0x1) && !rateProbingFlag)
{
if (((header[2] & 0x3) == 2))
{
/* Unicast frame with HT rate => Enable aggregation */
/* Set aggregation group bits per AC */
header[1] |= (0x20 | (zcUpToAc[up&0x7]<<10));
//if (wd->sta.currentFrequency < 3000)
{
/* Enable RTS/CTS to prevent OWL Tx hang up */
header[1] &= 0xfffc;
header[1] |= 0x1;
}
}
}
#endif
}
#endif
return (hlen<<1);
}
u16_t zfTxGenMmHeader(zdev_t* dev, u8_t frameType, u16_t* dst,
u16_t* header, u16_t len, zbuf_t* buf, u16_t vap, u8_t encrypt)
{
//u16_t bodyLen;
u8_t hlen = 32; // MAC ctrl + PHY ctrl + 802.11 MM header
zmw_get_wlan_dev(dev);
zmw_declare_for_critical_section();
/* Generate control setting */
//bodyLen = zfwBufGetSize(dev, buf);
header[0] = 24+len+4; //Length
if ((dst[0] & 0x1) != 0) //Broadcast, multicast frames
{
header[1] = 0xc; //MAC control, backoff + noack
}
else
{
header[1] = 0x8; //MAC control, backoff + (ack)
}
/* Dualband Management frame tx Rate */
if (wd->wlanMode == ZM_MODE_AP)
{
if (wd->frequency < 3000)
{
/* CCK 1M */
header[2] = 0x0f00; //PHY control L
header[3] = 0x0000; //PHY control H
}
else
{
/* CCK 6M */
header[2] = 0x0f01; //PHY control L
header[3] = 0x000B; //PHY control H
}
}
else
{
if (wd->sta.currentFrequency < 3000)
{
/* CCK 2M */
header[2] = 0x0f00; //PHY control L
header[3] = 0x0001; //PHY control H
}
else
{
/* CCK 6M */
header[2] = 0x0f01; //PHY control L
header[3] = 0x000B; //PHY control H
}
}
/* Generate WLAN header */
/* Frame control */
header[4+0] = frameType;
/* Duration */
header[4+1] = 0;
if (wd->wlanMode == ZM_MODE_INFRASTRUCTURE)
{
if ( frameType == ZM_WLAN_FRAME_TYPE_PROBEREQ )
{
header[4+8] = 0xFFFF;
header[4+9] = 0xFFFF;
header[4+10] = 0xFFFF;
}
else if ( frameType == ZM_WLAN_FRAME_TYPE_BA ) {
/* do nothing */
}
else
{
header[4+8] = wd->sta.bssid[0];
header[4+9] = wd->sta.bssid[1];
header[4+10] = wd->sta.bssid[2];
}
}
else if (wd->wlanMode == ZM_MODE_PSEUDO)
{
/* Address 3 = 00:00:00:00:00:00 */
header[4+8] = 0;
header[4+9] = 0;
header[4+10] = 0;
}
else if (wd->wlanMode == ZM_MODE_IBSS)
{
header[4+8] = wd->sta.bssid[0];
header[4+9] = wd->sta.bssid[1];
header[4+10] = wd->sta.bssid[2];
if ( frameType == ZM_WLAN_FRAME_TYPE_ATIM )
{
/* put ATIM to queue 5th */
//header[2] |= (ZM_BIT_13|ZM_BIT_14);
header[2] |= ZM_BIT_15;
}
}
else if (wd->wlanMode == ZM_MODE_AP)
{
/* Address 3 = BSSID */
header[4+8] = wd->macAddr[0];
header[4+9] = wd->macAddr[1];
#ifdef ZM_VAPMODE_MULTILE_SSID
header[4+10] = wd->macAddr[2]; //Multiple SSID
#else
header[4+10] = wd->macAddr[2] + (vap<<8); //VAP
#endif
//if in scan, must set address 3 to broadcast because of some ap would care this
//if ((wd->heartBeatNotification & ZM_BSSID_LIST_SCAN)
// == ZM_BSSID_LIST_SCAN)
//if FrameType is Probe Request, Address3 should be boradcast
if (frameType == ZM_WLAN_FRAME_TYPE_PROBEREQ)
{
header[4+8] = 0xFFFF;
header[4+9] = 0xFFFF;
header[4+10] = 0xFFFF;
}
}
/* Address 1 = DA */
header[4+2] = dst[0];
header[4+3] = dst[1];
header[4+4] = dst[2];
/* Address 2 = SA */
header[4+5] = wd->macAddr[0];
header[4+6] = wd->macAddr[1];
if (wd->wlanMode == ZM_MODE_AP)
{
#ifdef ZM_VAPMODE_MULTILE_SSID
header[4+7] = wd->macAddr[2]; //Multiple SSID
#else
header[4+7] = wd->macAddr[2] + (vap<<8); //VAP
#endif
}
else
{
header[4+7] = wd->macAddr[2];
}
/* Sequence Control */
zmw_enter_critical_section(dev);
header[4+11] = ((wd->mmseq++)<<4);
zmw_leave_critical_section(dev);
if( frameType == ZM_WLAN_FRAME_TYPE_QOS_NULL )
{
/*Qos Control*/
header[4+12] = 0x0;
hlen+=2;
header[0]+=2;
}
if ( encrypt )
{
if ( wd->sta.wepStatus == ZM_ENCRYPTION_WEP_ENABLED )
{
if ( (wd->sta.encryMode == ZM_WEP64)||
(wd->sta.encryMode == ZM_WEP128)||
(wd->sta.encryMode == ZM_WEP256) )
{
header[4] |= 0x4000;
header[16] = 0x0; //IV
header[17] = 0x0; //IV
header[17] |= (((u16_t) wd->sta.keyId) << 14);
hlen += 4;
header[0] += 8; // icvLen = 4;
header[1] |= 0x40; // enable encryption on macCtrl
}
}
}
// Enable HW duration
if ( frameType != ZM_WLAN_FRAME_TYPE_PSPOLL )
{
header[1] |= 0x200;
}
return hlen;
}
void zfInitMacApMode(zdev_t* dev)
{
u16_t i;
zmw_get_wlan_dev(dev);
zfHpEnableBeacon(dev, ZM_MODE_AP, (wd->beaconInterval/wd->ap.vapNumber), 1, 0);
/* AP mode */
zfHpSetApStaMode(dev, ZM_HAL_80211_MODE_AP);
/* VAP test code */
/* AP + VAP mode */
if (wd->ap.vapNumber >= 2)
{
for (i=1; i<ZM_MAX_AP_SUPPORT; i++)
{
if (((wd->ap.apBitmap >> i) & 0x1) != 0)
{
u16_t mac[3];
mac[0] = wd->macAddr[0];
mac[1] = wd->macAddr[1];
#ifdef ZM_VAPMODE_MULTILE_SSID
mac[2] = wd->macAddr[2]; //Multiple SSID
#else
mac[2] = wd->macAddr[2] + (i<<8); //VAP
#endif
zfHpSetMacAddress(dev, mac, i);
}
}
}
/* basic rate setting */
zfHpSetBasicRateSet(dev, wd->bRateBasic, wd->gRateBasic);
/* Set TxQs CWMIN, CWMAX, AIFS and TXO to WME AP default. */
zfUpdateDefaultQosParameter(dev, 1);
return;
}
u16_t zfChGetNextChannel(zdev_t* dev, u16_t frequency, u8_t* pbPassive)
{
u8_t i;
u8_t bPassive;
zmw_get_wlan_dev(dev);
/* Avoid NULL value */
if ( pbPassive == NULL )
{
pbPassive = &bPassive;
}
for( i=0; i<wd->regulationTable.allowChannelCnt; i++ )
{
if ( wd->regulationTable.allowChannel[i].channel == frequency )
{
if ( i == (wd->regulationTable.allowChannelCnt-1) )
{
i = 0;
}
else
{
i++;
}
if ( wd->regulationTable.allowChannel[i].channelFlags
& ZM_REG_FLAG_CHANNEL_PASSIVE )
{
*pbPassive = TRUE;
}
else
{
*pbPassive = FALSE;
}
return wd->regulationTable.allowChannel[i].channel;
}
}
return 0xffff;
}
u16_t zfChGetFirstChannel(zdev_t* dev, u8_t* pbPassive)
{
u8_t bPassive;
zmw_get_wlan_dev(dev);
/* Avoid NULL value */
if ( pbPassive == NULL )
{
pbPassive = &bPassive;
}
if ( wd->regulationTable.allowChannel[0].channelFlags & ZM_REG_FLAG_CHANNEL_PASSIVE )
{
*pbPassive = TRUE;
}
else
{
*pbPassive = FALSE;
}
return wd->regulationTable.allowChannel[0].channel;
}
u16_t zfChGetFirst2GhzChannel(zdev_t* dev)
{
u8_t i;
zmw_get_wlan_dev(dev);
for( i=0; i<wd->regulationTable.allowChannelCnt; i++ )
{
if ( wd->regulationTable.allowChannel[i].channel < 3000 )
{
/* find the first 2Ghz channel */
return wd->regulationTable.allowChannel[i].channel;
}
}
/* Can not find any 2Ghz channel */
return 0;
}
u16_t zfChGetFirst5GhzChannel(zdev_t* dev)
{
u8_t i;
zmw_get_wlan_dev(dev);
for( i=0; i<wd->regulationTable.allowChannelCnt; i++ )
{
if ( wd->regulationTable.allowChannel[i].channel > 3000 )
{
/* find the first 5Ghz channel */
return wd->regulationTable.allowChannel[i].channel;
}
}
/* Can not find any 5Ghz channel */
return 0;
}
u16_t zfChGetLastChannel(zdev_t* dev, u8_t* pbPassive)
{
u8_t bPassive;
u8_t ChannelIndex;
zmw_get_wlan_dev(dev);
ChannelIndex = wd->regulationTable.allowChannelCnt-1;
/* Avoid NULL value */
if ( pbPassive == NULL )
{
pbPassive = &bPassive;
}
if ( wd->regulationTable.allowChannel[ChannelIndex].channelFlags
& ZM_REG_FLAG_CHANNEL_PASSIVE )
{
*pbPassive = TRUE;
}
else
{
*pbPassive = FALSE;
}
return wd->regulationTable.allowChannel[ChannelIndex].channel;
}
u16_t zfChGetLast5GhzChannel(zdev_t* dev)
{
u8_t i;
u16_t last5Ghzfrequency;
zmw_get_wlan_dev(dev);
last5Ghzfrequency = 0;
for( i=0; i<wd->regulationTable.allowChannelCnt; i++ )
{
if ( wd->regulationTable.allowChannel[i].channel > 3000 )
{
last5Ghzfrequency = wd->regulationTable.allowChannel[i].channel;
}
}
return last5Ghzfrequency;
}
/* freqBand = 0 => auto check */
/* = 1 => 2.4 GHz band */
/* = 2 => 5 GHz band */
u16_t zfChNumToFreq(zdev_t* dev, u8_t ch, u8_t freqBand)
{
u16_t freq = 0xffff;
if ( freqBand == 0 )
{
if (ch > 14)
{ /* adapter is at 5 GHz band */
freqBand = 2;
}
else
{
freqBand = 1;
}
}
if ( freqBand == 2 )
{ /* the channel belongs to 5 GHz band */
if ( (ch >= 184)&&(ch <= 196) )
{
freq = 4000 + ch*5;
}
else
{
freq = 5000 + ch*5;
}
}
else
{ /* the channel belongs to 2.4 GHz band */
if ( ch == 14 )
{
freq = ZM_CH_G_14;
}
else
{
freq = ZM_CH_G_1 + (ch-1)*5;
}
}
return freq;
}
u8_t zfChFreqToNum(u16_t freq, u8_t* pbIs5GBand)
{
u8_t ch;
u8_t Is5GBand;
/* to avoid NULL value */
if ( pbIs5GBand == NULL )
{
pbIs5GBand = &Is5GBand;
}
*pbIs5GBand = FALSE;
if ( freq == ZM_CH_G_14 )
{
ch = 14;
}
else if ( freq < 4000 )
{
ch = (freq - ZM_CH_G_1) / 5 + 1;
}
else if ( freq < 5000 )
{
ch = (freq - 4000) / 5;
*pbIs5GBand = TRUE;
}
else
{
ch = (freq - 5000) / 5;
*pbIs5GBand = TRUE;
}
return ch;
}