zdpmfilter.c

ZYDAS zd1211b driver for Linux2.4

#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];
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 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++;