zdpmfilter.c

ZYDAS zd1211b driver for Linux2.4

                                                        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;
        usedID++;
        if (usedID > (BURST_NUM -1))
                usedID = 0;
        pdot11Obj->SetupNextSend(&fragInfo); // No need protection in CardBus

        pdot11Obj->ExitCS(flags);

        return FALSE;
}

void FlushQ(SignalQ_t *Q)
{
        Signal_t *signal;
        FrmInfo_t *pfrmInfo;
        FrmDesc_t *pfrmDesc;

        while((signal = sigDeque(Q)) != NULL) {
                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");
        if (pTxQ->cnt > 0) {
                signal = pTxQ->first;
                if (!signal)
                        return FALSE;

                pfrmInfo = &signal->frmInfo;
                pfrmDesc = pfrmInfo->frmDesc;

                if (!pdot11Obj->CheckTCBAvail(pfrmInfo->fTot))
                        return FALSE;

                signal = sigDeque(pTxQ);
                goto send_PduReq;
        }

        return FALSE;


send_PduReq:
        TxSend(signal, pfrmDesc);
        return TRUE;
}



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

        //PSDEBUG("CleanupAwakeQ");
        if (pAwakeQ->cnt > 0) {
                signal = pAwakeQ->first;
                if (!signal)
                        return FALSE;

                pfrmInfo = &signal->frmInfo;

                pfrmDesc = pfrmInfo->frmDesc;
                if (!pdot11Obj->CheckTCBAvail(pfrmInfo->fTot))
                        return FALSE;

                signal = sigDeque(pAwakeQ);
                //PSDEBUG("===== Queue out awakeQ");
                //PSDEBUG_V("pAwakeQ->cnt", pAwakeQ->cnt);
                goto send_PduReq;
        }

        return FALSE;


send_PduReq:
        TxSend(signal, pfrmDesc);
        return TRUE;
}


void AgePsQ(U16 aid)
{
        Signal_t *psSignal;
        U16 interval;
        FrmDesc_t *pfrmDesc;
        U32 eol;
        FrmInfo_t *pfrmInfo;

        if ((aid == 0) || (aid > MAX_AID))	//Invalid AID
                return;


        while (pPsQ[aid]->cnt) {
                interval = sstByAid[aid]->lsInterval;
                if (interval == 0)
                        interval = 1;

                psSignal = pPsQ[aid]->first;

                if (!psSignal)
                        break;

                pfrmInfo = &psSignal->frmInfo;
                eol = pfrmInfo->eol;
#ifndef HOST_IF_USB

                if ((HW_GetNow(pdot11Obj) - eol) < (2*interval*mBeaconPeriod*1024)) //us
                        break;

                if ((HW_GetNow(pdot11Obj) - eol) < (1024*1024)) //us
                        break;
#else

                if ((HW_GetNow(pdot11Obj) - eol) < (2*interval*mBeaconPeriod/10)) //10ms
                        break;

                if ((HW_GetNow(pdot11Obj) - eol) < (100)) //10ms
                        break;
#endif
                //Data life time-out
                psSignal = sigDeque(pPsQ[aid]);
                if (!psSignal)
                        break;

                PSDEBUG_V("*****Data life time-out, AID", aid);
                pfrmDesc = pfrmInfo->frmDesc;

                freeFdesc(pfrmDesc);
                pdot11Obj->ReleaseBuffer(psSignal->buf);
                freeSignal(psSignal);
        }


        if (!pPsQ[aid]->cnt)
                TimMapSet(TimBitMap, aid, FALSE);

        return;
}


void PsPolled(MacAddr_t *sta, U16 aid)
{
        Signal_t *signal;
        FrmInfo_t *pfrmInfo;
        FrmDesc_t *pfrmDesc;
        Frame_t	*frame;
        int i;
        U8 Num;

        //PSDEBUG("PsPolled");

        signal = sigDeque(pPsQ[aid]);
        if (!signal) {
                PSDEBUG("No Queue data for PS-POLL!!!");
                TimMapSet(TimBitMap, aid, FALSE);
                return;
        } else {

                PSDEBUG_V("Queue out psQ, AID ", aid);
                PSDEBUG_V("cnt ", pPsQ[aid]->cnt);
                pfrmInfo = &signal->frmInfo;
                pfrmDesc = pfrmInfo->frmDesc;

                Num = pfrmInfo->fTot;
                for (i=0; i<Num; i++) {
                        frame = &pfrmDesc->mpdu[i];
                        //PSDEBUG_V("pfrmInfo ", (U32)pfrmInfo);
                        //PSDEBUG_V("eol ", (U32)pfrmInfo->eol);
                        PSDEBUG_V("pfrmDesc ", (U32)pfrmDesc);
                        //PSDEBUG_V("frame ", (U32)frame);
                        if (!pPsQ[aid]->cnt) {
                                frame->header[1] &= ~MORE_DATA_BIT;
                                PSDEBUG("More bit 0");
                        } else {
                                frame->header[1] |= MORE_DATA_BIT;
                                PSDEBUG("More bit 1");
                        }

                        PSDEBUG_V("bodyLen ", frame->bodyLen);
                }


                if (!pdot11Obj->CheckTCBAvail(Num)) {
                        PSDEBUG("*****Fail to send out!!!");
                        PSDEBUG_V("Queue in psQ, AID", aid);
                        sigEnqueFirst(pPsQ[aid], signal);
                        return;
                } else
                        sigEnque(pTxQ, signal);
                return;
        }
}


void StaWakeup(MacAddr_t *sta)
{
        U16 aid;
        Signal_t *signal;