zdpmfilter.c

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

#ifndef __ZDPMFILTER_C__
#define __ZDPMFILTER_C__

#include "zd80211.h"
#include "zd1205.h"
#include "zddebug.h"
extern struct net_device *g_dev;

#define DBG_USE_SERIAL_WRITE 0
void AgePsQ(U16 aid);
BOOLEAN TxSend(Signal_t *signal, FrmDesc_t *pfrmDesc);
#define write_str(a,b)
U8 usedID = 0;
U8 TimBitMap[(MAX_AID/8)+2];
Signal_t *txRequest[BURST_NUM] = { NULL };
static BOOLEAN	mcBuffered = FALSE;

//make tim for beacon frame
void mkTim(Element *tim, TrafficMap_t *trf, U8 dtc, U8 dtp, U16 aidLo, U16 aidHi, BOOLEAN bc)
{
	int	i;
	U8 *map = (U8*)trf->t;
	U16	N1 = 0;
	U16	N2 = 0;
	U8	index = 0;
	
	tim->buf[0] = EID_TIM;
	tim->buf[2] = dtc;	
	tim->buf[3] = dtp;	
	
	// Calculate N1
	for (i=0; i<=(aidHi/8); i++){
		if (map[i] != 0){
			break;
		}
	}
	
	if (i>0){
		// N1 is the largest even number
		N1 = (U16)(i & ~0x01);
	}
	
	// Calculate N2
	for (i=(aidHi/8); i>=0; i--){
		if (map[i] != 0){
			break;
		}
	}
	
	if (i>0){
		N2 = (U16)i;
	}
	
	// Fill the content
	if (N2==0){
		tim->buf[4] = 0;
		tim->buf[5] = map[0];
		tim->buf[1] = 4;
	}
	else{
		tim->buf[4] = (U8)N1;
		for (i=N1; i<=N2; i++){
			tim->buf[5+index++] = map[i];
		}
		tim->buf[1] = N2-N1+4;
	}

	if (bc){
		tim->buf[4] |= 0x01;
	}
}


void TxCompleted(U32 result, U8 retID, U16 aid) //in isr routine
{
	Signal_t *signal;
	FrmInfo_t *pfrmInfo;
	FrmDesc_t *pfrmDesc;
	void *buf;
	Hash_t *pHash = NULL;
	U8	bIntraBss = 0;
	
#ifdef HOST_IF_USB
	if ((result != ZD_TX_CONFIRM) && (retID == 0xff)){
		pHash = sstByAid[aid];
		if (!pHash)
			return;
		else
			pHash->FailedFrames++;	
		
		return;	
	}	
#endif	
	
	signal = txRequest[retID];
	if (signal == NULL)
	{
	    printk(KERN_ERR "TxCompleted: input signal is NULL\n");
	    return;
	}
	pfrmInfo = &signal->frmInfo;
	pfrmDesc = pfrmInfo->frmDesc;

	buf = signal->buf;
    if (pfrmDesc)
	    bIntraBss = (pfrmDesc->ConfigSet & INTRA_BSS_SET);

	//if (aid)
	{
		pHash = sstByAid[aid];
		if (!pHash)
			goto no_rate_info;
			
		if (result == ZD_TX_CONFIRM){
		//for rate adaption
			pHash->SuccessFrames++;
		}	
		else  //retry failed
			pHash->FailedFrames++;

	}		
			
	
no_rate_info:
    if (pfrmDesc)
	    freeFdesc(pfrmDesc);
	pdot11Obj->ReleaseBuffer(buf);
	freeSignal(signal);
	txRequest[retID] = NULL;

	if ((buf) && (!bIntraBss)){	//upper layer data
		pdot11Obj->TxCompleted();
	}		
}	


char DbgStr1[]="Tx ProbReq";
char DbgStr2[]="Tx Auth";
char DbgStr3[]="Tx Data";
char DbgStr4[]="msg4";
char DbgStr5[]="msg5";
char DbgStr6[]="msg6";
char DbgStr7[]="msg7";
char DbgStr8[]="msg8";
char DbgStr9[]="msg9";
char DbgStr10[]="msg10";
char DbgStr11[]="msg11";

char DbgStr12[]="msg12";
BOOLEAN TxSend(Signal_t *signal, FrmDesc_t *pfrmDesc)
{	
	FrmInfo_t *pfrmInfo;
    U32 XCount = 0;
   	U32 nextBodyLen; 
	fragInfo_t fragInfo;
	int i;
	U8 bIntraBss = 0;
	Frame_t *pf; 
	Frame_t *nextPf;
	U32 flags;
	Hash_t *pHash = NULL;
	U32 *tmpiv = NULL;
	//U8 WepKeyLen = 0;
	//U8 *pWepKey = NULL;
        U8 tmp4pIv[8];
	U8 *pIv = tmp4pIv;
	U8 KeyId = 5;
	U32 iv32 = 0;
	BOOLEAN	bExtIV = FALSE;
	U8 EncryType;
	BOOLEAN	bGroupAddr = FALSE;
	U8 bWep = 0;
	U8 vapId = 0;
	U8 Num;
	U8 bDataFrm = signal->bDataFrm; 
	//U8 KeyInstalled = 0;

	ZDEBUG("TxSend");
		

	//txRequest[usedID] = signal;		
	memcpy(fragInfo.CalSwMic, pfrmDesc->CalMIC, MIC_LNG+1);
	pfrmInfo = &signal->frmInfo;
	bIntraBss = (pfrmDesc->ConfigSet & INTRA_BSS_SET);

	pf = pfrmDesc->mpdu;
	
	//for PS-POLL handling
	if (pfrmDesc->ConfigSet & PS_POLL_SET){
		if(mMacMode != PURE_A_MODE) {
			fragInfo.rate = RATE_1M;
			fragInfo.preamble = mPreambleType;
		}
		else if(mMacMode == PURE_A_MODE) {
			fragInfo.rate = RATE_6M;
			fragInfo.preamble = SHORT_PREAMBLE; //802.11A frame must
		}

		fragInfo.aid = 0;
		fragInfo.macHdr[0] = &pf->header[0];
		fragInfo.macBody[0] = pf->body;
		fragInfo.bodyLen[0] = 0;
		fragInfo.nextBodyLen[0] = 0;
		//fragInfo.msgID = usedID;
		fragInfo.totalFrag = 1;
		fragInfo.hdrLen = pf->HdrLen;
		fragInfo.encryType = WEP_NOT_USED;	
		fragInfo.vapId = vapId;
		fragInfo.bIntraBss = bIntraBss;
		fragInfo.buf = signal->buf;
		goto just_send;
	}

	pHash = pfrmDesc->pHash;
	bWep = wepBit(pf);
	EncryType = mKeyFormat;

   /*   if ((pf->header[0] & 0xFC) == 0x40)
        { //Probe Req, for debugging purpose.
            if (pf->body[0]==0)
            {
                if (pf->body[1] == 0)
                     printk(KERN_ERR "Probe Request with Broadcase ssid\n");
                else
                     printk(KERN_ERR "Probe Request with ssid=%s",&pf->body[2]);
            }
        }    
        else if ((pf->header[0] & 0xFC) == 0xB0)
	{
            //printk(KERN_ERR "Tx Auth\n");
	    //serial_printf(" Tx Auth\n");	
	}
        else if ((pf->header[0] & 0xFC) == 0x08)
	{
            //printk(KERN_ERR "Tx Data,keyMode=%d\n",mDynKeyMode);
            //serial_printf("Tx Data,keyMode=%d\n",mDynKeyMode);
        } */
	if (isGroup(addr1(pf))){
		bGroupAddr = TRUE;
		fragInfo.rate = pdot11Obj->BasicRate;
		fragInfo.aid = 0;
		if(PURE_A_MODE != mMacMode)
			fragInfo.preamble = 0;
		else
			fragInfo.preamble = 1;
	
		/*if ((mSwCipher) && (bWep)){
			if ((mDynKeyMode == DYN_KEY_WEP64) || (mDynKeyMode == DYN_KEY_WEP128)){
				WepKeyLen = mBcKeyLen;
				pWepKey = &mBcKeyVector[0];
				pIv = &mBcIv[1];
				KeyId = mBcKeyId;
				tmpiv = (U32 *)mBcIv;
			}
		}*/ /* The software encryption is always disabled.*/	

		if (bWep){// For 802.1x dynamic key mode
			if ((mDynKeyMode == DYN_KEY_WEP64) || (mDynKeyMode == DYN_KEY_WEP128)){
				if (mDynKeyMode == DYN_KEY_WEP64)
					EncryType = WEP64_USED;
				else
					EncryType = WEP128_USED;	
				pIv = &mBcIv[1];
				KeyId = mBcKeyId;
				tmpiv = (U32 *)mBcIv;
			}
		}
	
	}
	else{ // unicast frame		
		if (!pHash){
			// Should be Probe Response frame
			fragInfo.rate = pdot11Obj->BasicRate;
			//FPRINT_V("pHash = 0; fragInfo.rate", fragInfo.rate);
			fragInfo.aid = 0;
			if(mMacMode != PURE_A_MODE)
				fragInfo.preamble = 0;
			else
				fragInfo.preamble = 1;

		}	
		else{
			fragInfo.rate = pHash->CurrTxRate;

			//FPRINT_V("pHash != 0 fragInfo.rate", fragInfo.rate);
			fragInfo.aid = (U16)pHash->aid;
			fragInfo.preamble = pHash->Preamble;

			//if (mBssType == AP_BSS)
                        {
				EncryType = pHash->encryMode;
                        }
			
			//get pairwise key
			if (bWep)
                        {
				if ((mDynKeyMode == DYN_KEY_WEP64) || (mDynKeyMode == DYN_KEY_WEP128)){
					pIv = &pHash->wepIv[1];
					KeyId = pHash->KeyId;
					tmpiv = (U32 *)pHash->wepIv;
				}	
			}	 
		}
	}	

	if (bWep){
		if (mDynKeyMode == 0){  // static 4 keys, wep64, 128 or 256
			pIv = &mWepIv[1];
			KeyId = mKeyId;
			tmpiv = (U32 *)mWepIv;
			EncryType = mKeyFormat;
		}
	}
	
	Num = pfrmInfo->fTot;
	//FPRINT_V("Tx fTot", pfrmInfo->fTot);
	for (i=0; i<Num; i++){
		pf = &pfrmDesc->mpdu[i]; 
		if (Num == 1)
                {
           	        nextBodyLen = 0; 
			if (!bDataFrm)
                        { //Management frame
				bIntraBss = 0;
				if (frmType(pf) == ST_PROBE_RSP)

                                {
					U32 loTm, hiTm;
					HW_GetTsf(pdot11Obj, &loTm, &hiTm);
					setTs(pf, loTm, hiTm);
				}
			}		
		}		
		else
                {	
			if (Num != (i+1))
                        {
				nextPf = &pfrmDesc->mpdu[i+1];
				nextBodyLen = nextPf->bodyLen;
			}	
			else
                        {
				nextBodyLen = 0;
                        }
		}	
		
		//prepare frag information
		fragInfo.macHdr[i] = &pf->header[0];
		fragInfo.macBody[i] = pf->body;
		fragInfo.bodyLen[i] = pf->bodyLen;
		fragInfo.nextBodyLen[i] = nextBodyLen;
		
		if (bWep)
		{// Encryption is needed.
			if ((mDynKeyMode == DYN_KEY_TKIP) || (mDynKeyMode == DYN_KEY_AES))
			{// WPA encryption mode.
				if (bGroupAddr)
				{
					if (mGkInstalled)
					{
						switch(mWpaBcKeyLen)
						{
						case 32:// Group TKIP
							mIv16++;
							if (mIv16 == 0)
								mIv32++;
							pIv[0] = Hi8(mIv16);
							pIv[1] = (Hi8(mIv16) | 0x20) & 0x7f;
							pIv[2] = Lo8(mIv16);
							KeyId = mWpaBcKeyId;
							iv32 = mIv32;
							bExtIV = TRUE;
							EncryType = TKIP_USED;
							break;
						case 5: // Group WEP64
							pIv = &mBcIv[1];
							KeyId = mWpaBcKeyId;
							tmpiv = (U32 *)mBcIv;
							EncryType = WEP64_USED;
							break;
						case 13: // Group WEP128
							pIv = &mBcIv[1];
							KeyId = mWpaBcKeyId;
							tmpiv = (U32 *)mBcIv;
							EncryType = WEP128_USED;
							break;
						case 16:// Group AES
							mIv16++;
							if (mIv16 == 0)
								mIv32++;
							pIv[0] = Lo8(mIv16);
    							pIv[1] = Hi8(mIv16);
    							pIv[2] = 0;
							KeyId = mWpaBcKeyId;
							iv32 = mIv32;
							bExtIV = TRUE;
							EncryType = AES_USED;
							break;
						default: // Group key Len error
                                            		bWep=FALSE;
                                            		fragInfo.macHdr[i][1] &= ~WEP_BIT;
							break;
						}
					}
					else
					{// Group key was not installed yet.
                                            	bWep=FALSE;
                                            	fragInfo.macHdr[i][1] &= ~WEP_BIT;
					}			
				}//endof group frame.
				else 
                		{ //unicast
                                        //printk(KERN_ERR "send unicast packet,pkeyinstalled:%d\n",pHash->pkInstalled);
					//KeyInstalled = pHash->pkInstalled;
					if ((pHash) && (pHash->pkInstalled))
                    			{
						pHash->iv16++;
						if (pHash->iv16 == 0)
							pHash->iv32++;
						if (EncryType == TKIP_USED)
						{
							pIv[0]  = Hi8(pHash->iv16);
    							pIv[1]  = (Hi8(pHash->iv16) | 0x20) & 0x7f;
    							pIv[2]  = Lo8(pHash->iv16);
    						}
   						else if (EncryType == AES_USED)
   						{
    							pIv[0]  = Lo8(pHash->iv16);
    							pIv[1]  = Hi8(pHash->iv16);
    							pIv[2]  = 0;
    						}	
						KeyId = pHash->KeyId;
						iv32 = pHash->iv32;
						bExtIV = TRUE;
					}
                    			else
                    			{// No key has been installed before.
                        			bWep=FALSE;
                        			fragInfo.macHdr[i][1] &= ~WEP_BIT;
                    			}
			 	}	
			} // end of ((mDynKeyMode == DYN_KEY_TKIP) || (mDynKeyMode == DYN_KEY_AES))
			fragInfo.macHdr[i][MAC_HDR_LNG] = pIv[0];
			fragInfo.macHdr[i][MAC_HDR_LNG+1] = pIv[1];
			fragInfo.macHdr[i][MAC_HDR_LNG+2] = pIv[2];
			fragInfo.macHdr[i][MAC_HDR_LNG+3] = KeyId << 6;
            //if (mDynKeyMode != DYN_KEY_TKIP && mDynKeyMode != DYN_KEY_AES)
			if (EncryType == WEP64_USED || EncryType == WEP128_USED)
			    *tmpiv  = (((*tmpiv) & 0x00FFFFFF) + 1) | ((*tmpiv) & 0xFF000000);

 			if (bExtIV){
				fragInfo.macHdr[i][MAC_HDR_LNG+3] |= 0x20;
				fragInfo.macHdr[i][MAC_HDR_LNG+4] = (U8)(iv32);
				fragInfo.macHdr[i][MAC_HDR_LNG+5] = (U8)(iv32 >> 8);
				fragInfo.macHdr[i][MAC_HDR_LNG+6] = (U8)(iv32 >> 16);
				fragInfo.macHdr[i][MAC_HDR_LNG+7] = (U8)(iv32 >> 24);
			}	
		}
	
	}

	//fragInfo.msgID = usedID;
	fragInfo.bIntraBss = bIntraBss;
	fragInfo.buf = signal->buf;
	fragInfo.totalFrag = Num;
	fragInfo.hdrLen = MAC_HDR_LNG;
	
	if (bWep)
	{
		fragInfo.hdrLen += IV_LNG;
		if (bExtIV){
			fragInfo.hdrLen += EIV_LNG;
		}
		fragInfo.encryType = EncryType;	 
	}	
    	else
	    fragInfo.encryType=WEP_NOT_USED;

	//if (mAssoc)
	//FPRINT_V("EncryType", fragInfo.encryType);
	//fragInfo.vapId = vapId;	

	//if (fragInfo.encryType == TKIP)
	{
		//fragInfo.bWaitingMIC = pfrmDesc->bWaitingMIC;
		//fragInfo.bSwCalcMIC = pfrmDesc->bSwCalcMIC;
		//fragInfo.HwMicPhys = (U32)pfrmDesc->HwMicPhys;
	}
    
just_send:
 	flags = pdot11Obj->EnterCS();
         // The following 5 lines must be protected by a critical section.
	fragInfo.msgID = usedID;
	txRequest[usedID] = signal;		
#if ZDCONF_LP_SUPPORT == 1
    memcpy(fragInfo.EthHdr, signal->EthHdr,14);
#endif
    pdot11Obj->SetupNextSend(&fragInfo);

    do 
    {
        XCount++;
        usedID++;
        if (usedID > (BURST_NUM -1))
            usedID = 0;
        if(XCount > 1000) break;
    }while(txRequest[usedID] != NULL);

    if(XCount > 1000 && freeSignalCount != 0 )
    {
        for(;XCount > 0;XCount--)
            printk("XCount!!!!\n");
    }

    pdot11Obj->ExitCS(flags);

	return FALSE;
}

void FlushQ(SignalQ_t *Q)
{
	Signal_t *signal;
    FrmInfo_t *pfrmInfo;
    FrmDesc_t *pfrmDesc;
    int loopCheck = 0;
	
	while((signal = sigDeque(Q)) != NULL){
        // General loop check only. for future hidden bug
        if(loopCheck++ > 100)
        {
            printk("infinite loop occurs in %s\n", __FUNCTION__);
            loopCheck = 0;
            break;
        }
        pfrmInfo = &signal->frmInfo;
	    pfrmDesc = pfrmInfo->frmDesc;
	    pdot11Obj->ReleaseBuffer(signal->buf);
		freeFdesc(pfrmDesc);
		freeSignal(signal);
	}
}


void TimMapSet(U8 *map, U16 aid, BOOLEAN flag)
{
	U8	mask, index;


	if ((aid == 0) || (aid > MAX_AID)) 
		return;
		
	index = aid / 8;
	mask = 0x01 << (aid % 8);
	
	if (flag)
		map[index] |= mask;
	else
		map[index] &= ~mask;	
}



BOOLEAN CleanupTxQ(void)
{
	Signal_t *signal;
	FrmInfo_t *pfrmInfo;
	FrmDesc_t *pfrmDesc;

	//PSDEBUG("CleanupTxQ");