zdhci.c

GW-US54GXS_Linux_v2.15.0.0_CE zd1211原碼

		default:
			break;		
	}	
	
	return;
}	

BOOLEAN zd_CleanupTxQ(void)
{	
	//FPRINT("*****zd_CleanupTxQ*****");
	while(CleanupTxQ());
    
	if (!pTxQ->cnt){
   		pdot11Obj->QueueFlag &= ~TX_QUEUE_SET;
		return TRUE;
	}
	else
		return FALSE;
}  

BOOLEAN zd_CleanupAwakeQ(void)
{	
	//PSDEBUG("*****zd_CleanupAwakeQ*****");
	while(CleanupAwakeQ());
    
	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;
	}
}

void zd_ShowQInfo(void)
{
	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);     
}

extern U8 AuthReqState;
extern U8 AsocState;
void zd_ShowState(void)
{
	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);
}
	
void zd_ShowHashInfo(U8 aid)
{
	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
}

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");
    
	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)
		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);
	 }	
	
	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 (pSetting->BssType == INDEPENDENT_BSS){
				mRequestFlag |= CHANNEL_SCAN_SET;
				pdot11Obj->ConfigFlag |= SCAN_AND_CONNECT_SET;
				//bReConnect = FALSE;
			}
		}    
	}	
	
	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
		mProbeWithSsid = TRUE;
	//mProbeWithSsid = FALSE;  //debug for ANY connection   
		
	if ((pSetting->BssType == INFRASTRUCTURE_BSS) || (pSetting->BssType == INDEPENDENT_BSS)) {
	        if (!InitConfig) {
         //   if (memcmp(&mSsid, &dot11DesiredSsid,  dot11DesiredSsid.buf[1]+2) != 0 ){
				bReConnect = TRUE;
        //    }
		}
        
		if (pSetting->BssType == INDEPENDENT_BSS){
			memcpy(&mSsid, &dot11DesiredSsid,  dot11DesiredSsid.buf[1]+2);
			mATIMWindow = pSetting->ATIMWindow;
		}	   
	}    
	

	mHiddenSSID = pSetting->HiddenSSID;
	if (mHiddenSSID){
		mSsid.buf[0] = EID_SSID;
		mSsid.buf[1] = 1;
		mSsid.buf[2] = 0x0;
	}
	
	memcpy(&mBrates, pSetting->Info_SupportedRates, pSetting->Info_SupportedRates[1]+2);

	if (!InitConfig){
#if defined(AMAC)		
		pdot11Obj->SetReg(reg, ZD_BasicRateTbl, 0);
#endif		
		HW_SetSupportedRate(pdot11Obj, (U8 *)&mBrates);
	}	

#if defined(OFDM)	
	if (pSetting->MacMode != PURE_B_MODE){
		if (pSetting->ShortSlotTime){
			pdot11Obj->ConfigFlag |= SHORT_SLOT_TIME_SET;
			mCap |= CAP_SHORT_SLOT_TIME;
		}	
		else{
			pdot11Obj->ConfigFlag &= ~SHORT_SLOT_TIME_SET;
			mCap &= ~CAP_SHORT_SLOT_TIME;	
		}
		
		mMaxTxRate = 0x0b; 	
		if(PURE_A_MODE != pSetting->MacMode) {
			memcpy(&mExtRates, pSetting->Ext_SupportedRates, pSetting->Ext_SupportedRates[1]+2);
			if (!InitConfig)
				HW_SetSupportedRate(pdot11Obj, (U8 *)&mExtRates);
		}

	}
	else
		mMaxTxRate = 0x03;

	if (!InitConfig) {
		if (mMacMode != pSetting->MacMode) {   //MacMode changed
			bReConnect = TRUE;
		}
	}        

	mMacMode = pSetting->MacMode;     		
#endif		
		
	memcpy((U8 *)&dot11MacAddress, pSetting->MacAddr, 6);
	memcpy(&mKeyVector[0][0], &pSetting->keyVector[0][0], sizeof(mKeyVector));
	mWepKeyLen = pSetting->WepKeyLen;
	memcpy(&mBcKeyVector[0], &pSetting->BcKeyVector[0], sizeof(mBcKeyVector));

	mBcKeyLen = pSetting->BcKeyLen;

	/* Check if we need to copy the WPA IE */	
	//if ((mDynKeyMode == DYN_KEY_TKIP) || (mDynKeyMode == DYN_KEY_AES)
	  //  || (pSetting->WPASupport == 1 && pSetting->WPAIe[1] != 0)){
	if ((pSetting->WPASupport==1 || pSetting->WPAIeLen))
	{
		//printk(KERN_ERR "Copy WPA IE in the zd_UpdateCardSetting\n");
		memcpy(&mWPAIe, pSetting->WPAIe, pSetting->WPAIeLen);
	}
    else 
    {
        memset(&mWPAIe.buf[0], 0, sizeof(mWPAIe));
    }


#if defined(AMAC)
	mOperationMode = pSetting->OperationMode;
	if (!InitConfig)
	{
		//HW_CAM_ResetRollTbl(pdot11Obj);
		if ((mOperationMode == CAM_AP_VAP) || (mOperationMode == CAM_AP_CLIENT)){
			// for Ack response
			HW_CAM_ResetRollTbl(pdot11Obj);
			HW_CAM_SetMAC(pdot11Obj, CAM_VAP_START_AID, (U8 *)&dot11MacAddress);
			HW_CAM_UpdateRollTbl(pdot11Obj, CAM_VAP_START_AID);
			
			// for Address1 matching
			HW_CAM_SetMAC(pdot11Obj, 0, (U8 *)&bcAddr);
			HW_CAM_UpdateRollTbl(pdot11Obj, 0);	
		}
		else if (pSetting->BssType == INFRASTRUCTURE_BSS)
		{// Don't clear key in AP_BSS and IBSS mode.
			HW_CAM_ClearRollTbl(pdot11Obj, CAM_VAP_START_AID);	
			HW_CAM_ClearRollTbl(pdot11Obj, 0);	
		}	
	}
	else
	{// Only clear all keys in the first time.
		HW_CAM_ResetRollTbl(pdot11Obj);
	}

#endif	
    
	//mPwrState = pSetting->PwrState;
	if (pSetting->BssType == AP_BSS){
		memcpy(&mSsid, &dot11DesiredSsid,  dot11DesiredSsid.buf[1]+2);
		memcpy((U8 *)&mBssId, pSetting->MacAddr, 6);
		
		// Update the mCap information
		mCap &= ~BIT_1;
		mCap |= BIT_0;
		
		//mGkInstalled = 0;
		zd_InitWepData();	
		if (!InitConfig){
			zd_CmdProcess(CMD_DISASOC_ALL, 0, ZD_UNSPEC_REASON);
		}	

	}
	
#if defined(OFDM)
	mErp.buf[2] = 0; //reset erp info
	
	if ((mCap & CAP_SHORT_PREAMBLE) == 0){
		mErp.buf[2] |= BARKER_PREAMBLE; 
		if (pdot11Obj){
			tmpValue = pdot11Obj->GetReg(reg, ZD_RTS_CTS_Rate); 
			tmpValue &= ~NON_BARKER_PMB_SET;
			tmpValue |= CTS_RATE_11M;
			pdot11Obj->SetReg(reg, ZD_RTS_CTS_Rate, tmpValue); 
		}	
	}	
	
	if (pdot11Obj)
		pdot11Obj->ConfigFlag &= ~ENABLE_PROTECTION_SET;
	
	if (pSetting->BssType == INDEPENDENT_BSS){
		if (mMacMode == PURE_G_MODE)
			mErp.buf[2] = 0;
		else
			mErp.buf[2] = (NON_ERP_PRESENT | USE_PROTECTION | BARKER_PREAMBLE);	
	}	
#endif	
	
	if (!InitConfig){
		//if (mBssType != pSetting->BssType){
		if (mBssType != pSetting->BssType)
		//if (pSetting->BssType != INFRASTRUCTURE_BSS)
        {
			//int i;

			mBssType = pSetting->BssType;
			if (pSetting->BssType == AP_BSS){
				zd_StartAP();
 				bReConnect = FALSE;
 			}
			else{
				zd_StartSTA(0);
				bReConnect = FALSE;
			}
				
			//for (i=0; i<(MAX_AID+1); i++)
				//CleanupHash(sstByAid[i]);
			//InitHashTbl();	
			zd_InitWepData();	
			//zd_CmdFlushQ();	
		}	
	}
	
	mBssType = pSetting->BssType;
	pdot11Obj->BssType = mBssType;

	if (bReConnect)
	{
		if (pSetting->BssType == INFRASTRUCTURE_BSS)
		{
		    BOOLEAN ret;
		    pdot11Obj->ConfigFlag |= SCAN_AND_CONNECT_SET;
			if (pSetting->ap_scan == 1)
			{
				ret = zd_ChooseAP(1); // Choose AP by dot11DesiredBssid.
			}
			else
				ret = zd_ChooseAP(0);
    
	    	if (ret == FALSE)
	        {
	            zd_StartSTA(0);//ReScan all channels to find the selected BSS.
	        }
		}
	}
	
	InitConfig = FALSE;
}	


void zd_PsPoll(void)
{
	Signal_t *signal;
	FrmDesc_t *pfrmDesc;
	
	//FPRINT("zd_PsPoll");
	
	if ((signal = allocSignal()) == NULL){
		return;
	}	
		
	pfrmDesc = allocFdesc();
	if(!pfrmDesc){
		freeSignal(signal);
		return;
	}
	
	sendPsPollFrame(signal, pfrmDesc, &mBssId, mAid);
	mRequestFlag &= ~PS_POLL_SET;
	return;
}

void zd_NullData(void)
{
	Signal_t *signal;
	FrmDesc_t *pfrmDesc;
	
	//FPRINT("zd_NullData");
	
	if ((signal = allocSignal()) == NULL){
		return;
	}	
		
	pfrmDesc = allocFdesc();
	if(!pfrmDesc){
		freeSignal(signal);
		return;
	}
	
	sendNullDataFrame(signal, pfrmDesc, &mBssId);
	mRequestFlag &= ~PS_CHANGE_SET;
	return;
}

void zd_DisConnect(void)
{
	//FPRINT("zd_DisConnect");
	
        zd_CmdProcess(CMD_ROAMING,0,0);
	mRequestFlag &= ~DIS_CONNECT_SET;
	
	/*pdot11Obj->ConfigFlag |= SCAN_AND_CONNECT_SET;
	pdot11Obj->bChScanning = 0;
	mRequestFlag &= ~DIS_CONNECT_SET;
#if 0    
	zd_CmdProbeReq((U8)mProbeWithSsid);
#else
	zd_ChooseAP();
#endif    */
}

void zd_Roaming(void)
{
	//FPRINT("zd_Roaming");
	pdot11Obj->ConfigFlag |= SCAN_AND_CONNECT_SET;
	//pdot11Obj->bChScanning = 0;
	mRequestFlag &= ~ROAMING_SET;
	zd_CmdProbeReq((U8)mProbeWithSsid);
}
	
void zd_ConnectMon(void)
{
	//FPRINT_V("mRequestFlag", mRequestFlag);
	if (mRequestFlag & DIS_CONNECT_SET){
		mRequestFlag = 0;
		FPRINT("DIS_CONNECT_SET");
		zd_DisConnec