zdasocsvc.c

该代码为linux下通过usb驱动实现的无线网络驱动程序,在2.6.18的内核下调试通过

					}
				}

				asStatus = SC_SUCCESSFUL;
				if (signal->id == SIG_REASSOC)	
					notifyStatus1 = STA_REASSOCIATED;
				pdot11Obj->StatusNotify(notifyStatus1, (U8 *)&Sta);

				if (mMacMode != PURE_B_MODE && mMacMode != PURE_A_MODE){
					if (pdot11Obj->ConfigFlag & NON_ERP_PRESENT_SET){
						U32 tmpValue;
						void *reg = pdot11Obj->reg;
						
				 		// force enabled protection mode for debug
						mErp.buf[2] |= (NON_ERP_PRESENT | 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);
		
						if (Preamble == 0){ //long preamble
							mErp.buf[2] |= BARKER_PREAMBLE;
							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); 
							//FPRINT("Enable Barker Preamble");
						}	
						pdot11Obj->ConfigFlag |= ENABLE_PROTECTION_SET;
						//FPRINT("Enable Protection Mode");
					}
				}		
		
			}
		}
		else{
//wpa_check_failed:	
			asStatus = SC_UNSPEC_FAILURE;
		}	
wpa_check_failed:
	
		aid |= 0xC000;
		if (aid != 0xC000){
			FPRINT_V("Aid", aid);
			FPRINT_V("MaxRate", MaxRate);
		}	
	
check_failed:
		if (signal->id == SIG_REASSOC)	
			type = ST_REASOC_RSP;	
		mkRe_AsocRspFrm(pfrmDesc, type, &Sta, mCap, asStatus, aid, &mBrates, pExtRate, vapId);
		sendMgtFrame(signal, pfrmDesc);

		return FALSE;
	}
	else {
		freeFdesc(pfrmDesc);
		return TRUE;
	}
}

BOOLEAN Re_AsocReq(Signal_t *signal)
{
	FrmDesc_t *pfrmDesc;
	U8 vapId = 0;
	TypeSubtype subType = ST_ASOC_REQ;
	Element *pExtRate = NULL;
    	
	FPRINT("Re_AsocReq");
	
	pfrmDesc = allocFdesc();
	if(!pfrmDesc){
		sigEnque(pMgtQ, (signal));
		return FALSE;
	}

	
	if (signal->id == SIG_REASSOC_REQ){
		subType = ST_REASOC_REQ;
	}
    
	pExtRate = &mExtRates;

	memcpy((U8 *)&AsSta, (U8 *)&mBssId, 6);

	mkRe_AsocReqFrm(pfrmDesc, subType, &mBssId, mCap, mListenInterval, 
		&mOldAP, &mSsid, &mBrates, pExtRate, &mWPAIe, vapId);
	
	pdot11Obj->StartTimer(ASOC_TIMEOUT, DO_ASOC);	
	AsocState = STE_WAIT_ASOC_RSP;
	return sendMgtFrame(signal, pfrmDesc);
}	

BOOLEAN Re_AsocRsp(Signal_t *signal)
{
    int i;
    BssInfo_t *asocBss = NULL;
    U8 Turbo_AMSDU = FALSE, Turbo_BURST = FALSE, Turbo_AMSDU_LEN = 1;
	Hash_t	*pHash;
	FrmDesc_t *pfrmDesc;
	Frame_t *rdu;
	U8 vapId = 0;	
	MacAddr_t Sta;
	U16 status;
		
	//ZDEBUG("Re_AsocRsp");
	FPRINT("Re_AsocRsp");
	
	pfrmDesc = signal->frmInfo.frmDesc;
	rdu = pfrmDesc->mpdu;
	
	memcpy((U8 *)&Sta, (U8 *)addr2(rdu), 6);
	if (memcmp(&AsSta, &Sta, 6) != 0){
		//FPRINT("Not for my Assoc AP");
		goto asoc_release;
	}
	
	pdot11Obj->StopTimer(DO_ASOC);
	AsocState = STE_ASOC_IDLE;

	
	status = status(rdu);
	if (status == SC_SUCCESSFUL){
		U8	Len;
		U8	tmpMaxRate = 0x02;
		U8	ZydasMode = 0;
		U8	Preamble = 0;
		U8	MaxRate;
		BOOLEAN bErpSta = FALSE;
		int i;
		U8	HigestBasicRate = 0;
		
		UpdateStaStatus(&Sta, STATION_STATE_ASOC, vapId);
		pHash = HashSearch(&Sta);
		if (pHash != NULL)
		{
			if (!pHash->AlreadyIn)
			{
				pHash->AlreadyIn=1;
				mCurrConnUser++;
			}
		}

		mAPCap = cap(rdu);
		
		//check capability
		if (mAPCap & CAP_SHORT_PREAMBLE){
			Preamble = 1;
		}	
		else {
			Preamble = 0;
		}	
		
		mAid = (aid(rdu) & 0x3FFF);
		getElem(rdu, EID_SUPRATES, &mAPBrates,1);
		//zd1205_dump_data("mAPBrates", &mAPBrates.buf[2], mAPBrates.buf[1]);
        
		if (getElem(rdu, EID_EXT_RATES, &mAPErates,1)){
			//zd1205_dump_data("mAPErates", &mAPErates.buf[2], mAPErates.buf[1]);
		}

		memcpy((U8 *)&mBssId, (U8 *)addr2(rdu), 6);
		mAssoc = TRUE;
		
		//update supported rates
		HW_SetSupportedRate(pdot11Obj, (U8 *)&mAPBrates);
		HW_SetSupportedRate(pdot11Obj, (U8 *)&mAPErates);

		Len = eLen(&mAPBrates);	
		for (i=0; i<Len; i++){
			if ((mAPBrates.buf[2+i] & 0x7f) > tmpMaxRate ){
				tmpMaxRate = (mAPBrates.buf[2+i] & 0x7f);
				if (mAPBrates.buf[2+i] & 0x80)
					HigestBasicRate = mAPBrates.buf[2+i];
			}	
				
			if (((mAPBrates.buf[2+i] & 0x7f) == 0x21) && (!(mAPCap & CAP_PBCC_ENABLE))){ //Zydas 16.5M
				ZydasMode = 1;
			}	
		}

       
		Len = eLen(&mAPErates);
		for (i=0; i<Len; i++){
			if ((mAPErates.buf[2+i] & 0x7f) > tmpMaxRate ){
				tmpMaxRate = (mAPErates.buf[2+i] & 0x7f);
				if (mAPErates.buf[2+i] & 0x80)
					HigestBasicRate = mAPErates.buf[2+i];
			}
		}

		//FPRINT_V("tmpMaxRate", tmpMaxRate);
		//FPRINT_V("mMaxTxRate", mMaxTxRate);
		MaxRate = RateConvert((tmpMaxRate & 0x7f));
		//FPRINT_V("MaxRate", MaxRate);
		if (MaxRate > mMaxTxRate)
			MaxRate = mMaxTxRate;
		memset(mAPBrates.buf, 0, sizeof(Element)); 
		memset(mAPErates.buf, 0, sizeof(Element));
#if ZDCONF_LP_SUPPORT == 1
        asocBss = zd1212_bssid_to_BssInfo(mBssId.mac);
        if(asocBss != NULL)
        {
            if(asocBss->zdIE_BURST.buf[0] == EID_ZYDAS)
            {
                if(asocBss->zdIE_BURST.buf[8] & BIT_7)
                    Turbo_BURST = TRUE;
                Turbo_BURST = Turbo_BURST && pdot11Obj->BURST_MODE;
            }

            if(asocBss->zdIE_AMSDU.buf[0] == EID_ZYDAS)
            {
                if(asocBss->zdIE_AMSDU.buf[8] & BIT_0)
                {
                    Turbo_AMSDU = TRUE; 
                    Turbo_AMSDU_LEN = asocBss->zdIE_AMSDU.buf[8] & BIT_1;
                }
                Turbo_AMSDU = Turbo_AMSDU && pdot11Obj->LP_MODE;
            }
        }
        else
        {
            printk("zd1212_bssid_to_BssInfo is NULL in %s, Something wrong\n", __FUNCTION__);
        }

        AssocInfoUpdate(&mBssId, MaxRate, mAid, ZydasMode, Preamble, bErpSta, Turbo_BURST, Turbo_AMSDU, Turbo_AMSDU_LEN,vapId);
#elif ZDCONF_LP_SUPPORT == 0
        AssocInfoUpdate(&mBssId, MaxRate, mAid, ZydasMode, Preamble, bErpSta,0,0,0,vapId);
#endif
			
		pdot11Obj->StatusNotify(STA_ASSOCIATED, (U8 *)&mBssId);
		pdot11Obj->Aid = mAid;
		mConnRetryCnt = 0;

		FPRINT_V("Aid", mAid);
		FPRINT_V("MaxRate", MaxRate);
	} else {
		FPRINT("Asoc Failed!!!");
		FPRINT_V("Status Code", status);
	}	

asoc_release:
	freeFdesc(pfrmDesc);
	return TRUE;		
}	


BOOLEAN AsocTimeOut(Signal_t *signal)
{
	U8 vapId = 0;
	FPRINT("AsocTimeOut");
	
	if (AsocState == STE_WAIT_ASOC_RSP){
		AsocState = STE_ASOC_IDLE;
		UpdateStaStatus(&mBssId, STATION_STATE_DIS_ASOC, vapId);
	}
	
	mRequestFlag |= CONNECT_TOUT_SET;
	return FALSE;
}


BOOLEAN AsocEntry(Signal_t *signal)
{
	FrmDesc_t *pfrmDesc;
	
	if (AsocState == STE_ASOC_IDLE){
		switch(signal->id){
			case SIG_DIASSOC_REQ:
				return DisasocReq(signal);
			
			case SIG_DISASSOC:
				return Disasoc(signal);
			
			case SIG_ASSOC:
			case SIG_REASSOC:
				return Re_Asociate(signal);
				
			case SIG_ASSOC_REQ:
			case SIG_REASSOC_REQ:
                if(memcmp(mBssId.mac, zeroMacAddress, ETH_ALEN) == 0)
                   goto asoc_discard; 
				return Re_AsocReq(signal);
				
			default:
				goto asoc_discard;		
		}
	} else if (AsocState == STE_WAIT_ASOC_RSP){	
		switch(signal->id){
			case SIG_DIASSOC_REQ:
				return DisasocReq(signal);
			
			case SIG_DISASSOC:
				return Disasoc(signal);
			
			case SIG_ASSOC:
			case SIG_REASSOC:
				return Re_Asociate(signal);
				
			case SIG_ASSOC_REQ:
			case SIG_REASSOC_REQ:
                if(memcmp(mBssId.mac, zeroMacAddress, ETH_ALEN) == 0)
                   goto asoc_discard;
				return Re_AsocReq(signal);	
				
			case SIG_ASSOC_RSP:
			case SIG_REASSOC_RSP:
				return Re_AsocRsp(signal);	
				
			case SIG_TO_ASOC:

				return AsocTimeOut(signal);		
			
			default:
				goto asoc_discard;	
		}
	} else
		goto asoc_discard;	
	
asoc_discard:
	pfrmDesc = signal->frmInfo.frmDesc;	
	freeFdesc(pfrmDesc);
	return TRUE;		
}

#endif