📄 zdhci.c
字号:
pdot11Obj->StatusNotify(STA_ASSOCIATED, (U8 *)&mBssId);
return TRUE;
}
return FALSE;
}
void zd_ResetDevice(void)
{
U16 BeaconInterval = 0x2;
U32 tmpvalue;
void *reg = pdot11Obj->reg;
// Device will reset after 1ms
HW_UpdateBcnInterval(pdot11Obj, BeaconInterval);
pdot11Obj->SetReg(reg, ZD_Pre_TBTT, 0x1);
//++ Ensure the following is an atomic operation.
#ifndef HOST_IF_USB
i_state = pdot11Obj->EnterCS();
#endif
if(pdot11Obj->bDeviceInSleep)
{
printk("In SLLLLLLLLLLLLLLLLLLP @ %s\n", __FUNCTION__);
return;
}
tmpvalue = pdot11Obj->GetReg(reg, ZD_PS_Ctrl);
pdot11Obj->SetReg(reg, ZD_PS_Ctrl, (tmpvalue | BIT_0));
pdot11Obj->bDeviceInSleep = 1;
#ifndef HOST_IF_USB
pdot11Obj->ExitCS(i_state);
// Delay 1ms to ensure device had been reset
pdot11Obj->DelayUs(1000);
#endif
}
BOOLEAN zd_PseudoIbssConnect(void)
{
void *reg = pdot11Obj->reg;
U8 IBSS_BSSID[6];
memset(IBSS_BSSID, 0, 6);
//++
// Set EIFS=0x32 to prevent chamber low Tx-throughput (sometimes)
// problem. In chamber environment, almost no Rx-frame, once
// we detect a CRC16/CRC32 error frame, we adopt EIFS, because of
// less of RX-frame, it's less posibility to change EIFS to DIFS
// by FA (Frame Analyzer), and therefore damage the Tx-Throughput.
// We must use SleepResetDevice to trigger FA to adpot 0x32.
pdot11Obj->SetReg(reg, ZD_IFS_Value, 0x5032032);
zd_ResetDevice();
//update Bssid
pdot11Obj->SetReg(reg, ZD_BSSID_P1, zd_cpu_to_le32(*(U32 *)&IBSS_BSSID[0]));
pdot11Obj->SetReg(reg, ZD_BSSID_P2, zd_cpu_to_le32(*(U32 *)&IBSS_BSSID[4]));
HW_SetRfChannel(pdot11Obj, mRfChannel, 1, mMacMode);
mAssoc = TRUE;
pdot11Obj->StatusNotify(STA_ASSOCIATED, (U8 *)IBSS_BSSID);
return TRUE;
}
BOOLEAN zd_CmdConnect(U8 index, U8 bssType)
{
if (bssType == INFRASTRUCTURE_BSS)
{
//printk(KERN_ERR "Build Infra-Type BSS\n");
return zd_InfraConnect(index-1);
}
else if (bssType==INDEPENDENT_BSS)
{
//printk(KERN_ERR "Build IBSS\n");
return zd_IbssConnect();
}
else if (bssType == PSEUDO_IBSS)
return zd_PseudoIbssConnect();
return TRUE;
}
BOOLEAN zd_CmdDisConnect(void)
{
mAssoc = FALSE;
mRequestFlag |= DIS_CONNECT_SET;
return TRUE;
}
BOOLEAN zd_CmdRoaming(void)
{
if ((mRequestFlag & (ROAMING_SET | CHANNEL_SCAN_SET)) || pdot11Obj->bChScanning || (pdot11Obj->ConfigFlag & SCAN_AND_CONNECT_SET))
return FALSE;
mAssoc = FALSE;
if (mBssType == INDEPENDENT_BSS)
mRequestFlag |= CHANNEL_SCAN_SET;
else
mRequestFlag |= ROAMING_SET;
return TRUE;
}
BOOLEAN zd_CmdFlushQ(void)
{
if (pdot11Obj->QueueFlag & TX_QUEUE_SET){
FlushQ(pTxQ);
}
else if (pdot11Obj->QueueFlag & MGT_QUEUE_SET){
FlushQ(pMgtQ);
}
else if (pdot11Obj->QueueFlag & AWAKE_QUEUE_SET){
FlushQ(pAwakeQ);
}
return TRUE;
}
BOOLEAN zd_CmdProcess(U16 CmdId, void *parm1, U32 parm2)
{
BOOLEAN status = TRUE;
switch(CmdId){
case CMD_RESET_80211:
status = zd_Reset80211((zd_80211Obj_t *)parm1);
break;
case CMD_ENABLE:
if (mBssType == AP_BSS)
status = zd_StartAP();
else
{
if ((pdot11Obj->ConfigFlag & SCAN_AND_CONNECT_SET)||(mRequestFlag & CHANNEL_SCAN_SET))
{
// printk("Scan and connect is underGoing\n");
break;
}
else if (!mIfaceOpened)
{
status = zd_StartSTA(1);
mIfaceOpened = TRUE;
}
else
{
pdot11Obj->ConfigFlag |= SCAN_AND_CONNECT_SET;
zd_ChooseAP(0);
}
}
break;
case CMD_DISASOC: //IAPP cth
status = zd_CmdDisasoc((MacAddr_t*)parm1, (U8)parm2);
break;
case CMD_DEAUTH://MAC filter cth
status = zd_CmdDeauth((MacAddr_t*)parm1, (U8)parm2);
break;
case CMD_PS_POLL:
//PSDEBUG("CMD_PS_POLL");
status = zd_HandlePsPoll((U8 *)parm1);
break;
case CMD_PASSIVE_SCAN:
status = zd_PassiveScan();
break;
case CMD_DISASOC_ALL:
status = zd_DisasocAll((U8)parm2);
break;
case CMD_CONNECT:
{
U8 *pBsstype=(U8*)parm1;
status = zd_CmdConnect((U8)parm2,*pBsstype);
}
break;
case CMD_PROBE_REQ:
//FPRINT("CMD_PROBE_REQ");
status = zd_CmdProbeReq((U8)parm2);
pdot11Obj->ConfigFlag |= JUST_CHANNEL_SCAN;
break;
case CMD_DIS_CONNECT:
status = zd_CmdDisConnect();
break;
case CMD_FLUSH_QUEUE:
status = zd_CmdFlushQ();
break;
case CMD_ROAMING:
status = zd_CmdRoaming();
break;
default:
status = FALSE;
break;
}
return status;
}
//Event Nofify Functions
void zd_NextBcn(void)
{
if (mBssType == AP_BSS){
if (mDtimCount == 0)
mDtimCount = mDtimPeriod;
mDtimCount--;
}
ConfigBcnFIFO();
if (pTxQ->cnt)
pdot11Obj->QueueFlag |= TX_QUEUE_SET;
return;
}
void zd_DtimNotify(void)
{
SendMcPkt();
return;
}
extern BOOLEAN Tchal_WaitChalRsp(Signal_t *signal);
void zd_SendTChalMsg(void)
{
Tchal_WaitChalRsp(NULL);
return;
}
extern BOOLEAN AuthTimeOut(Signal_t *signal);
void zd_SendTAuthMsg(void)
{
AuthTimeOut(NULL);
return;
}
extern BOOLEAN AsocTimeOut(Signal_t *signal);
void zd_SendTAsocMsg(void)
{
AsocTimeOut(NULL);
return;
}
void zd_SwitchNextCH(void)
{
void *reg = pdot11Obj->reg;
static u8 LastScanMacMode;
static u8 ScanAround = 0;
//static u8 ScanWait = 0;
static u8 initMAC_Mode = 0xff;
if(initMAC_Mode == 0xff)
initMAC_Mode = mMacMode;
//FPRINT("zd_SwitchNextCH");
if ((PURE_A_MODE != mMacMode && CurrScanCH > MAX_CHANNEL_ALLOW) ||
(PURE_A_MODE == mMacMode && CurrScanCH > dot11A_Channel_Amount - 1)
//In 11a, channel array index 0 is also meaningful.
){ //Scan Finish...
#ifdef HMAC_DEBUG
U8 i, j;
U16 cap;
#endif
if (mBssType == AP_BSS)
pdot11Obj->SetReg(reg, ZD_Rx_Filter, AP_RX_FILTER);
else
pdot11Obj->SetReg(reg, ZD_Rx_Filter, STA_RX_FILTER);
if (pdot11Obj->ConfigFlag & PASSIVE_CHANNEL_SCAN_SET)
pdot11Obj->ConfigFlag &= ~PASSIVE_CHANNEL_SCAN_SET;
if (pdot11Obj->ConfigFlag & IBSS_CHANNEL_SCAN_SET)
{
pdot11Obj->ConfigFlag &= ~IBSS_CHANNEL_SCAN_SET;
//mRequestFlag |= IBSS_CONNECT_SET;
}
CurrScanCH = 1;
pdot11Obj->bChScanning = 0;
ScanAround=0;
if (pdot11Obj->ConfigFlag & ACTIVE_CHANNEL_SCAN_SET)
{
#ifdef HMAC_DEBUG
printk("\nSSID BSSID CH Signal Mode Basic-Rates Ext-Rates b/g AP");
printk("\n------------------------------------------------------------------------------------");
for (i=0; i<mBssNum; i++)
{
printk("\n");
for (j=0; j<mBssInfo[i].ssid.buf[1]; j++) {
printk("%c", mBssInfo[i].ssid.buf[2+j]);
}
for (j=mBssInfo[i].ssid.buf[1]; j<12; j++) {
printk(" ");
}
printk("%02x:%02x:%02x:%02x:%02x:%02x",
mBssInfo[i].bssid.mac[0], mBssInfo[i].bssid.mac[1], mBssInfo[i].bssid.mac[2],
mBssInfo[i].bssid.mac[3], mBssInfo[i].bssid.mac[4], mBssInfo[i].bssid.mac[5]);
printk(" %2d", mBssInfo[i].Phpm.buf[2]);
printk(" %2d", mBssInfo[i].signalStrength);
cap = mBssInfo[i].cap;
cap &= (CAP_PRIVACY | CAP_IBSS | CAP_ESS);
switch(cap) {
case 0x01:
printk(" Infra ");
break;
case 0x02:
printk(" Ad_Hoc ");
break;
case 0x11:
printk(" Infra, W");
break;
case 0x12:
printk(" Ad_Hoc,W");
break;
default :
break;
}
printk(" ");
for (j=0; j<mBssInfo[i].supRates.buf[1]; j++) {
printk(" %x", mBssInfo[i].supRates.buf[2+j]);
}
printk(" ");
for (j=0; j<mBssInfo[i].extRates.buf[1]; j++) {
printk(" %x", mBssInfo[i].extRates.buf[2+j]);
}
if (mBssInfo[i].apMode == PURE_B_AP)
printk(" B-AP");
else if (mBssInfo[i].apMode == PURE_G_AP)
printk(" G-AP");
else if (mBssInfo[i].apMode == MIXED_AP)
printk(" M-AP");
}
else if (mBssInfo[i].apMode == PURE_A_AP)
printk(" A_AP");
else
VerAssert();
printk("\n");
FPRINT("****** Scan Finished ******");
#endif
pdot11Obj->ConfigFlag &= ~ACTIVE_CHANNEL_SCAN_SET;
mBssCnt = mBssNum;
}//End of ACTIVE_CHANNEL_SCAN_SET
if (pdot11Obj->ConfigFlag & JUST_CHANNEL_SCAN){
pdot11Obj->ConfigFlag &= ~JUST_CHANNEL_SCAN;
if (mAssoc)
{
mMacMode = initMAC_Mode;
HW_SetRfChannel(pdot11Obj, mRfChannel, 1, initMAC_Mode);
}
}
else
{
if (mBssType == INFRASTRUCTURE_BSS)
zd_ChooseAP(0);
else if (mBssType == INDEPENDENT_BSS)
zd_IbssConnect();
}
if (pdot11Obj->ConfigFlag & SCAN_AND_CONNECT_SET)
{
pdot11Obj->ConfigFlag &= ~SCAN_AND_CONNECT_SET;
}
initMAC_Mode = 0xff;
return;
}//End of (CurrentScannedChannel > MAX_CHANNEL_ALLOW)
CurrScanCH++;
if(mMacMode != PURE_A_MODE && CurrScanCH <= MAX_CHANNEL_ALLOW + 1) {
//printk("HW_SetRfChannel:%s(%d)\n",__FILE__,__LINE__);
HW_SetRfChannel(pdot11Obj, CurrScanCH, 1,mMacMode);
LastScanMacMode = mMacMode;
}
else if(mMacMode == PURE_A_MODE && CurrScanCH<=dot11A_Channel_Amount){
//printk("HW_SetRfChannel:%s(%d)\n",__FILE__,__LINE__);
HW_SetRfChannel(pdot11Obj, dot11A_Channel[CurrScanCH-1],1, mMacMode);
LastScanMacMode = mMacMode;
}
if(PURE_A_MODE != LastScanMacMode && CurrScanCH > MAX_CHANNEL_ALLOW && ScanAround <1) {
if(pdot11Obj->rfMode == AL7230B_RF) {
mMacMode = PURE_A_MODE;
CurrScanCH = 1;
ChangeMacMode(PURE_A_MODE,dot11A_Channel[CurrScanCH-1]);
pdot11Obj->DelayUs(1000);
HW_SetRfChannel(pdot11Obj, dot11A_Channel[CurrScanCH-1],0,mMacMode); ScanAround ++;
}
}
else if(ScanAround < 1 &&PURE_A_MODE == LastScanMacMode && CurrScanCH > dot11A_Channel_Amount - 1){
ScanAround ++;
CurrScanCH = 1;
mMacMode = MIXED_MODE;
ChangeMacMode(MIXED_MODE, CurrScanCH);
pdot11Obj->DelayUs(1000);
HW_SetRfChannel(pdot11Obj, CurrScanCH, 0,mMacMode);
}
//for debug
//pdot11Obj->SetReg(reg, ZD_USB_DEBUG_PORT, 0x22222222);
if (pdot11Obj->ConfigFlag & PASSIVE_CHANNEL_SCAN_SET)
pdot11Obj->StartTimer(SCAN_TIMEOUT, DO_SCAN);
if (pdot11Obj->ConfigFlag & ACTIVE_CHANNEL_SCAN_SET)
zd_ProbeReq();
return;
}
void zd_UpdateCurrTxRate(U8 rate, U16 aid)
{
Hash_t *pHash;
if (mBssType == INFRASTRUCTURE_BSS){
pHash = sstByAid[0];
pHash->CurrTxRate = rate;
}
else {
if (aid){
pHash = sstByAid[aid];
#if !defined(OFDM)
pHash->CurrTxRate = rate;
#else
if (rate < pHash->CurrTxRate){ //Retry Failed happened
pHash->FailedFrames++;
//FPRINT_V("FailedFrames", pHash->FailedFrames);
}
#endif
}
}
}
void zd_EnableProtection(U8 protect)
{
U32 tmpValue;
void *reg = pdot11Obj->reg;
if (protect){
//FPRINT("zd_EnableProtection");
pdot11Obj->ConfigFlag |= ENABLE_PROTECTION_SET;
mErp.buf[2] |= USE_PROTECTION;
if(pdot11Obj->bDeviceInSleep)
{
printk("In SLLLLLLLLLLLLLLLLLLP @ %s\n", __FUNCTION__);
return ;
}
tmpValue = pdot11Obj->GetReg(reg, ZD_RTS_CTS_Rate);
tmpValue &= ~CTS_MOD_TYPE_OFDM;
tmpValue |= CTS_RATE_11M;
pdot11Obj->SetReg(reg, ZD_RTS_CTS_Rate, tmpValue);
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -