zdhci.c

ZD1211 source code, based on linux 2.44 or linux 2.

	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;
    }
#if ZDCONF_80211A_SUPPORT == 1
    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;
    }
#endif
    if(PURE_A_MODE != LastScanMacMode && CurrScanCH > MAX_CHANNEL_ALLOW && ScanAround <1) {
#if ZDCONF_RF_AL7230B_SUPPORT == 1
        if(pdot11Obj->rfMode == AL7230B_RF) {
#if ZDCONF_80211A_SUPPORT == 1
            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 ++;
#endif
        }
#endif


    }
#if ZDCONF_80211A_SUPPORT == 1
    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);
    }
#endif


    //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);
	}
	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;
#if ZDCONF_AP_SUPPORT == 1			
		case EVENT_DTIM_NOTIFY:
			zd_DtimNotify();
			break;		
#endif
			
		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;

		default:
			break;		
	}	
	
	return;
}	

BOOLEAN zd_CleanupTxQ(void)
{	
	//FPRINT("*****zd_CleanupTxQ*****");
    int loopCheck = 0;
    int CleanResult = 1;
	while(CleanResult)
    {
        // To prevent unknown reason that can't clean up the txq(ex. re-queue in CleanupTxQ())
        if(loopCheck++ > 100)
        {
            printk("infinite loop occurs in %s\n", __FUNCTION__);
            loopCheck = 0;
            break;
        }
        CleanResult = CleanupTxQ();
    }
    
	if (!pTxQ->cnt){
   		pdot11Obj->QueueFlag &= ~TX_QUEUE_SET;
		return TRUE;
	}
	else
		return FALSE;
}  

#if ZDCONF_AP_SUPPORT == 1
BOOLEAN zd_CleanupAwakeQ(void)
{	
	//PSDEBUG("*****zd_CleanupAwakeQ*****");
    int loopCheck = 0;
	while(1)
    {
        // To prevent unknown reason that can't clean Awake Queue
        if(loopCheck++ > 100)
        {
            printk("infinite loop occurs in %s\n", __FUNCTION__);
            loopCheck = 0;
            break;
        }
        if(!CleanupAwakeQ()) break;
    }
    
	if (!pAwakeQ->cnt){
   		pdot11Obj->QueueFlag &= ~AWAKE_QUEUE_SET;
		return TRUE;
	}
	else{
#if 0
		Signal_t *signal;
		FrmInfo_t *pfrmInfo;
		FrmDesc_t *pfrmDesc;
        
		while(pAwakeQ->cnt){
			signal = sigDeque(pAwakeQ);
			pfrmInfo = &signal->frmInfo;
			pfrmDesc = pfrmInfo->frmDesc;
			freeFdesc(pfrmDesc);
			pdot11Obj->ReleaseBuffer(signal->buf);
			freeSignal(signal);
		}
#endif		
		return FALSE;
	}
}
#endif
void zd_ShowQInfo(void)
{
#if ZDCONF_DBGMSG_NORMAL == 1
	printk(KERN_DEBUG "AwakeQ = %x, MgtQ = %x, TxQ  = %x, mcQ  = %x\n",
	pAwakeQ->cnt, pMgtQ->cnt, pTxQ->cnt, pPsQ[0]->cnt);
	printk(KERN_DEBUG "PsQ1   = %x, PsQ2 = %x, PsQ3 = %x, PsQ4 = %x\n",
	pPsQ[1]->cnt, pPsQ[2]->cnt, pPsQ[3]->cnt, pPsQ[4]->cnt);     
#endif
}

extern U8 AuthReqState;
extern U8 AsocState;
void zd_ShowState(void)
{
#if ZDCONF_DBGMSG_NORMAL == 1
	printk(KERN_DEBUG "AuthReqState    = %04x, AsocState      = %04x\n", AuthReqState, AsocState);
	printk(KERN_DEBUG "mPwrState       = %04x, mAssoc         = %04x\n", mPwrState, mAssoc);
	printk(KERN_DEBUG "mAuthAlg        = %04x, mBssIndex      = %04x\n", mAuthAlg, mBssIndex);
	printk(KERN_DEBUG "mBssType        = %04x, ConfigFlag     = %04x\n", mBssType, pdot11Obj->ConfigFlag);
#endif
}
	
void zd_ShowHashInfo(U8 aid)
{
#if ZDCONF_DBGMSG_NORMAL == 1
	Hash_t *pHash = NULL;
	if (mBssType == INFRASTRUCTURE_BSS){
		aid = 0;
	}	
		pHash = sstByAid[aid];
		zd1205_dump_data("Mac Addr = ", pHash->mac, 6);
		FPRINT_V("Auth", pHash->auth);
		FPRINT_V("Asoc", pHash->asoc);
		FPRINT_V("psm", pHash->psm);
		FPRINT_V("Aid", pHash->aid);
		FPRINT_V("vapId", pHash->vapId);
		FPRINT_V("bErpSta", pHash->bErpSta);
		FPRINT_V("lsInterval", pHash->lsInterval);
		FPRINT_V("encryMode", pHash->encryMode);
		FPRINT_V("pkInstalled", pHash->pkInstalled);
		FPRINT_V("ZydasMode", pHash->ZydasMode);
		FPRINT_V("AlreadyIn", pHash->AlreadyIn);
		FPRINT_V("CurrTxRate", pHash->CurrTxRate);
		FPRINT_V("MaxRate", pHash->MaxRate);
		FPRINT_V("Preamble", pHash->Preamble);
		FPRINT_V("KeyId", pHash->KeyId);
		FPRINT_V("Rx IV16", pHash->RxSeed.IV16);
		FPRINT_V("Rx IV32", pHash->RxSeed.IV32);
		zd1205_dump_data("TK = ", pHash->TxSeed.TK, 16);
		zd1205_dump_data("Tx MIC K0 = ", (U8 *)&pHash->TxMicKey.K0, 4);
		zd1205_dump_data("Tx MIC K1 = ", (U8 *)&pHash->TxMicKey.K1, 4);
		zd1205_dump_data("Rx MIC K0 = ", (U8 *)&pHash->RxMicKey.K0, 4);
		zd1205_dump_data("Rx MIC K1 = ", (U8 *)&pHash->RxMicKey.K1, 4);
#if 0
		FPRINT_V("KeyId", mWpaBcKeyId);
		FPRINT_V("GkInstalled", mGkInstalled);
		FPRINT_V("IV16", mIv16);
		FPRINT_V("IV32", mIv32);
		zd1205_dump_data("keyContent = ", pHash->keyContent, 16);
		zd1205_dump_data("TK = ", mBcSeed.TK, 16);
		zd1205_dump_data("Tx MIC K0 = ", (U8 *)&mBcMicKey.K0, 4);
		zd1205_dump_data("Tx MIC K1 = ", (U8 *)&mBcMicKey.K1, 4);
#endif
#endif
}

void zd_UpdateCardSetting(card_Setting_t *pSetting)
{
	void *reg = pdot11Obj->reg;
	static BOOLEAN InitConfig = TRUE;
	U8 bcAddr[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
	U32 tmpValue;
	BOOLEAN bReConnect = FALSE;
	//FPRINT("zd_UpdateCardSetting");
    UpdateBcn++;
    
	if (pSetting->AuthMode == 0){ //open system only
		mAuthAlogrithms[0] = OPEN_SYSTEM;
		mAuthAlogrithms[1] = NULL_AUTH;
		mAuthAlg = OPEN_SYSTEM;
	}
	else if (pSetting->AuthMode == 1){	//shared key only
		mAuthAlogrithms[0] = SHARE_KEY;
		mAuthAlogrithms[1] = NULL_AUTH;
		mAuthAlg = SHARE_KEY;
	}
	else if (pSetting->AuthMode == 2){	//auto auth mode
		mAuthAlogrithms[0] = OPEN_SYSTEM;
		mAuthAlogrithms[1] = SHARE_KEY;
        
	}

	if (mAuthMode != pSetting->AuthMode){
		if (!InitConfig)
			bReConnect = TRUE;
	}

	mAuthMode = pSetting->AuthMode;     	
	
	if (mLimitedUser != pSetting->LimitedUser){
		mLimitedUser = pSetting->LimitedUser;
	}
		
	mBlockBSS = pSetting->BlockBSS;
	mSwCipher = pSetting->SwCipher;	
	mKeyFormat = pSetting->EncryMode;
	mKeyId = pSetting->EncryKeyId;
	mBcKeyId = pSetting->BcKeyId;
	mDynKeyMode = pSetting->DynKeyMode;
	mFragThreshold = pSetting->FragThreshold;
	mRtsThreshold = pSetting->RTSThreshold;
	mBeaconPeriod = pSetting->BeaconInterval;
	mDtimPeriod = pSetting->DtimPeriod;
	
	if (!InitConfig)
    {
        if (pSetting->BssType == INFRASTRUCTURE_BSS) // In IBSS mode, Enable beacon transmission at IBSS creation or Join.
            HW_EnableBeacon(pdot11Obj, mBeaconPeriod, mDtimPeriod, pSetting->BssType);
        
    }

		//HW_EnableBeacon(pdot11Obj, mBeaconPeriod, mDtimPeriod, mBssType);
	
	if (mRadioOn != pSetting->RadioOn){
	 	mRadioOn = pSetting->RadioOn;
	 	if (!InitConfig)
	 		HW_RadioOnOff(pdot11Obj, mRadioOn);
	 }	
	
    mPhpm.buf[0] = EID_DSPARMS;
    mPhpm.buf[1] = 1;
    mPhpm.buf[2] = mRfChannel;
	if (mRfChannel != pSetting->Channel){
		mRfChannel = pSetting->Channel;
		mPhpm.buf[0] = EID_DSPARMS;
		mPhpm.buf[1] = 1;
		mPhpm.buf[2] = mRfChannel;

		if (!InitConfig){
			if (pSetting->BssType != INFRASTRUCTURE_BSS)
            {
				HW_SetRfChannel(pdot11Obj, mRfChannel, 0,pSetting->MacMode);
#if ZDCONF_AP_SUPPORT == 1
                if(pSetting->BssType == AP_BSS)
                    HW_SetRfChannel(pdot11Obj, mRfChannel, 1,pSetting->MacMode);
#endif

            }

#if ZDCONF_ADHOC_SUPPORT == 1                
			if (pSetting->BssType == INDEPENDENT_BSS){
				mRequestFlag |= CHANNEL_SCAN_SET;
				pdot11Obj->ConfigFlag |= SCAN_AND_CONNECT_SET;
				//bReConnect = FALSE;
			}
#endif
		}    
	}	
	
	mPreambleType = pSetting->PreambleType;	

	if (mPreambleType)
		mCap |= CAP_SHORT_PREAMBLE;
	else
		mCap &= ~CAP_SHORT_PREAMBLE;
	
	mPrivacyInvoked = pSetting->EncryOnOff;
	if (pSetting->DynKeyMode > 0)
		mPrivacyInvoked = TRUE;
		
	if (mPrivacyInvoked)
		mCap |= CAP_PRIVACY;
	else
		mCap &= ~CAP_PRIVACY;	
		
	memcpy(&dot11DesiredSsid, pSetting->Info_SSID,  pSetting->Info_SSID[1]+2);

	if (dot11DesiredSsid.buf[1] == 0)
		mProbeWithSsid = FALSE; 
	else
    {
        memcpy(&mSsid, &dot11DesiredSsid,  dot11DesiredSsid.buf[1]+2);
		mProbeWithSsid = TRUE;
    }
    
	//mProbeW