📄 zdhci.c
字号:
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;
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);
}
else {
//FPRINT("zd_DisableProtection");
pdot11Obj->ConfigFlag &= ~ENABLE_PROTECTION_SET;
mErp.buf[2] &= ~USE_PROTECTION;
//pdot11Obj->ConfigFlag &= ~SHORT_SLOT_TIME_SET;
mCap |= CAP_SHORT_SLOT_TIME;
pdot11Obj->SetReg(reg, ZD_CWmin_CWmax, CW_SHORT_SLOT);
}
}
void zd_EnableBarker(U8 barker)
{
void *reg = pdot11Obj->reg;
if (barker){
//FPRINT("zd_EnableBarker");
pdot11Obj->ConfigFlag |= BARKER_PREAMBLE_SET;
mErp.buf[2] |= BARKER_PREAMBLE;
pdot11Obj->SetReg(reg, ZD_RTS_CTS_Rate, 0x30000);
}
else {
//FPRINT("zd_DisableBarker");
pdot11Obj->ConfigFlag &= ~BARKER_PREAMBLE_SET;
mErp.buf[2] &= ~BARKER_PREAMBLE;
pdot11Obj->SetReg(reg, ZD_RTS_CTS_Rate, 0x30000);
}
if(PURE_A_MODE == mMacMode) //Use Slowest rate when CTS/RTS,MZCai
pdot11Obj->SetReg(reg, ZD_RTS_CTS_Rate,0x01090109);
else
pdot11Obj->SetReg(reg, ZD_RTS_CTS_Rate, 0x30000);
}
void zd_EnableShortSlot(U8 slot)
{
void *reg = pdot11Obj->reg;
if (slot){
//FPRINT("zd_EnableShortSlot");
pdot11Obj->ConfigFlag |= SHORT_SLOT_TIME_SET;
pdot11Obj->SetReg(reg, ZD_IFS_Value, 0x547c00a);
pdot11Obj->SetReg(reg, ZD_CWmin_CWmax, CW_NORMAL_SLOT);
}
else {
//FPRINT("zd_DisableShortSlot");
pdot11Obj->ConfigFlag &= ~SHORT_SLOT_TIME_SET;
pdot11Obj->SetReg(reg, ZD_IFS_Value, 0x547c032);
pdot11Obj->SetReg(reg, ZD_CWmin_CWmax, CW_LONG_SLOT);
}
}
void zd_PsChange(U8 PwrState)
{
//FPRINT("zd_PsChange");
mPwrState = PwrState;
mRequestFlag |= PS_CHANGE_SET;
return;
}
void zd_EventNotify(U16 EventId, U32 parm1, U32 parm2, U32 parm3)
{
//struct zd1205_private *macp = g_dev->priv;
switch(EventId){
case EVENT_TBCN:
zd_NextBcn();
break;
case EVENT_DTIM_NOTIFY:
zd_DtimNotify();
break;
case EVENT_TX_COMPLETE:
TxCompleted(parm1, (U8)parm2, (U16)parm3);
break;
case EVENT_TCHAL_TIMEOUT:
zd_SendTChalMsg();
break;
case EVENT_SCAN_TIMEOUT:
zd_SwitchNextCH();
break;
case EVENT_UPDATE_TX_RATE:
zd_UpdateCurrTxRate((U8)parm1, (U16)parm2);
break;
case EVENT_SW_RESET:
//zd_SwReset();
break;
case EVENT_BUF_RELEASE:
zd_Release_80211_Buffer();
break;
case EVENT_AUTH_TIMEOUT:
zd_SendTAuthMsg();
break;
case EVENT_ASOC_TIMEOUT:
zd_SendTAsocMsg();
break;
case EVENT_PS_CHANGE:
zd_PsChange((U8)parm1);
break;
case EVENT_MORE_DATA:
mRequestFlag |= PS_POLL_SET;
break;
case EVENT_ENABLE_PROTECTION:
zd_EnableProtection((U8)parm1);
break;
case EVENT_ENABLE_BARKER:
zd_EnableBarker((U8)parm1);
break;
case EVENT_SHORT_SLOT:
zd_EnableShortSlot((U8)parm1);
break;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -