zdhci.c

ZYDAS zd1211b driver for Linux2.4

                                HwMicStatus = le32_to_cpu(*(U32 *)(HwMicStatusPhys));
                                j++;
                                if (j>1000) {
                                        bMicFinish = FALSE;
                                        //FPRINT("Rx MIC not finish !!!");
                                        //FPRINT_V("HwMicStatus", HwMicStatus);
                                        zdCnt.RxMicNoFinish++;
                                        break;
                                }
                        }

                        MicLow = le32_to_cpu (*(U32 *)RxMicWrBackAddr);
                        MicHigh = le32_to_cpu (*(U32 *)(HwMicHighPhys));

                        pByte = pBody + Len; //point to MIC start
                        CalMic[0] = (U8) MicLow;
                        CalMic[1] = (U8) (MicLow >> 8);
                        CalMic[2] = (U8) (MicLow >> 16);
                        CalMic[3] = (U8) (MicLow >> 24);
                        CalMic[4] = (U8) MicHigh;
                        CalMic[5] = (U8) (MicHigh >> 8);
                        CalMic[6] = (U8) (MicHigh >> 16);
                        CalMic[7] = (U8) (MicHigh >> 24);
#else
                        //Software MIC Calculation, HW MIC failed
                        MICclear(pRxMicKey);

                        //pByte = pEthHdr;
                        if (mBssType == INFRASTRUCTURE_BSS ||
                                        mBssType == INDEPENDENT_BSS)
                                pByte = &pHdr[4]; // DA = Addr1
                        else //if (mBssType == AP_BSS)
                                pByte = &pHdr[16]; //DA = Addr3

                        for (i=0; i<6; i++) {
                                MICappendByte(*pByte++, pRxMicKey);
                        }
                        if (mBssType == AP_BSS ||
                                        mBssType == INDEPENDENT_BSS)
                                pByte = &pHdr[10]; // SA=Addr2
                        else // if (mBssType == INFRASTRUCTURE_BSS)
                                pByte = &pHdr[16]; // SA=Addr3
                        for (i=0; i<6; i++) {
                                MICappendByte(*pByte++, pRxMicKey);
                        }
                        MICappendByte(0,pRxMicKey);//priority
                        MICappendByte(0,pRxMicKey);//3 zeros
                        MICappendByte(0,pRxMicKey);
                        MICappendByte(0,pRxMicKey);

                        pByte = pBody;
                        for (i=0; i<Len; i++) {
                                MICappendByte(*pByte++, pRxMicKey);
                        }

                        MICgetMIC(CalMic, pRxMicKey); // Append MIC (8 byte)

#endif
                        //FPRINT_V("Calcu HW MIC", RxCompLogBuf[RxComplogPktCnt][10]-RxCompLogBuf[RxComplogPktCnt][9]);

                        // now pBye point to MIC area
                        if (pdot11Obj->MIC_CNT && memcmp(CalMic, pByte, MIC_LNG) != 0) {
                                zd1205_dump_data("pHdr = ", pHdr, 32);
                                //FPRINT_V("Body Addr", (U32)pBody);
                                zd1205_dump_data("pBody = ", pBody, bodyLen+16);
                                zd1205_dump_data("CalMic = ", CalMic, 8);
                                zd1205_dump_data("ReceMic = ", pByte, 8);

                                printk(KERN_ERR "SW MIC Check fail\n");
                                hostap_michael_mic_failure((struct zd1205_private *)g_dev->priv, (struct hostap_ieee80211_hdr *)pHdr, pIV[3] & KEYID_MASK);
                                //pdot11Obj->MicFailure(&pEthHdr[6]);
                                return FALSE;
                        } else {
                                //FPRINT("***** MIC success *****");
                                //printk(KERN_ERR "SW MIC check OK\n");
                                return TRUE;
                        }
                }
        }

        return FALSE;
}

void zd_ReceivePkt(U8 *pHdr, U32 hdrLen, U8 *pBody, U32 bodyLen, void *buf, U8 *pEthHdr, rxInfo_t *pRxInfo)
{
        Signal_t *pRxSignal;
        FrmDesc_t *pRxFdesc;
        Frame_t *pRxFrame;
        MacAddr_t *pDa, *pSa;
        StationState sas;
        PsMode psm = PSMODE_STA_ACTIVE;
        U32 dataLen;
        U8 *pData;
        U8 mode;
        void *bcBuf;
        U8 *pBcData;
        Hash_t *pHash;
        U8 vapId = 0;
        U8 rate = pRxInfo->rate;
        U8 bDataFrm = pRxInfo->bDataFrm;
        U8 SaIndex = pRxInfo->SaIndex;
        U8 signalStrength = pRxInfo->signalStrength;
        U8 signalQuality = pRxInfo->signalQuality;
        U8 bSwCheckMIC = pRxInfo->bSwCheckMIC;

        ZDEBUG("zd_ReceivePkt");


        if (mBssType == AP_BSS) {
                pDa = (MacAddr_t *)&pHdr[16]; //A3
                pSa = (MacAddr_t *)&pHdr[10]; //A2
                if (bDataFrm) {
                        //don't care PS Bit in authenticate, (Re)assoicate and Probe Reguest frame
                        psm = (PsMode)((pHdr[1] & PW_SAVE_BIT) ? PSMODE_POWER_SAVE : PSMODE_STA_ACTIVE);
                }
                if (SaIndex == 0)
                        pHash = RxInfoIndicate(pSa, psm, rate); //12us update ps and rate information
                else {
                        pHash = sstByAid[SaIndex];
                        if (pHash)
                                RxInfoUpdate(pHash, psm, rate);
                }
        } else if (mBssType == INFRASTRUCTURE_BSS) {
                pDa = (MacAddr_t *)&pHdr[4];  //A1 will be my MAC
                //pSa = (MacAddr_t *)&pHdr[16]; //A3
                pSa = (MacAddr_t *)&pHdr[10]; //A2 for Asoc status check
                pHash = sstByAid[0];
        } else { // INDEPENDENT_BSS or PSEUDO_IBSS
                pDa = (MacAddr_t *)&pHdr[4];  //A1
                pSa = (MacAddr_t *)&pHdr[10]; //A2
                pHash = RxInfoIndicate(pSa, 0, rate);
        }


        if (bDataFrm) {
                if (!bodyLen)
                        goto rx_release;

                if (!pHash) {
                        zd_SendClass2ErrorFrame(pSa, vapId);
                        goto rx_release;
                } else {
                        sas = pHash->asoc;
                        if ((sas != STATION_STATE_ASOC) && (mBssType == AP_BSS)) {
                                //if (sas != STATION_STATE_ASOC){
                                zd_SendClass3ErrorFrame(pSa, vapId);
                                printk(KERN_ERR "Class3ErrFrm:%02X %02X %02X %02X %02X %02X\n",pSa->mac[0],pSa->mac[1],pSa->mac[2],pSa->mac[3],pSa->mac[4],pSa->mac[5]);
                                goto rx_release;
                        }
                }

                if (sas == STATION_STATE_ASOC) { //association station
                        if (mBssType == AP_BSS) {
                                if (isGroup(pDa)) {
                                        if (pHash->keyLength == 32) {
                                                //if (mDynKeyMode == DYN_KEY_TKIP){
                                                if (!pHash->pkInstalled)
                                                        goto rx_release;
                                                else if (!mGkInstalled)
                                                        goto rx_release;
                                                else if ((pHdr[1] & WEP_BIT) && (hdrLen == 32)) {
                                                        if (bSwCheckMIC) {
                                                                if (!zd_CheckMic(pHdr, pBody, bodyLen, pHash, pEthHdr)) {
                                                                        goto rx_release;
                                                                } else {
                                                                        bodyLen -= MIC_LNG; //remove MIC
                                                                }
                                                        }
                                                }
                                        }
                                        if (mCurrConnUser > 1) {
                                                mode = BC_FORWARD;
                                                bcBuf = pdot11Obj->AllocBuffer(bodyLen, &pBcData);
                                                if (bcBuf) {
                                                        memcpy(pBcData, pBody, bodyLen);
                                                        zd_WirelessForward(pHdr, pBcData, bodyLen, bcBuf, mode, NULL, pEthHdr);
                                                }
                                        }
                                        goto rx_ind;
                                } else {
                                        void *pTxHash = NULL;

                                        if (mBlockBSS) { //discard IntraBSS packet
                                                goto rx_release;
                                        }

                                        zd_QueryStaTable((U8 *)pDa, &pTxHash); //Automatic wireless forwarding

                                        if (pTxHash) {
                                                if (bSwCheckMIC) {
                                                        if ((pHash->keyLength==32) && (pHdr[1] & WEP_BIT) && (hdrLen == 32)) {

                                                                if (!zd_CheckMic(pHdr, pBody, bodyLen, pHash, pEthHdr)) {
                                                                        goto rx_release;
                                                                } else
                                                                        bodyLen -= MIC_LNG; //remove MIC
                                                        }
                                                }

                                                mode = BSS_FORWARD;
                                                zd_WirelessForward(pHdr, pBody, bodyLen, buf, mode, pTxHash, pEthHdr);
                                                return;
                                        }
                                }
                        }
                        // mic check
                        if (bSwCheckMIC) // For TKIP, always use sw-mic check.
                        {
                                //if ((pHash->keyLength==32) && (pHdr[1] & WEP_BIT) && (hdrLen == 32))
                                {
                                        if (!zd_CheckMic(pHdr, pBody, bodyLen, pHash, pEthHdr))
                                        {// sw-mic check failed, discard this packet.
                                                goto rx_release;
                                        } else
                                        {// sw-mic check ok, remove MIC
                                                bodyLen -= MIC_LNG;
                                        }
                                }
                        }
rx_ind:
                        //If Typelen field is not used for len
                        if(memcmp(pBody,zd_Snap_Apple_AARP,8)==0 || memcmp(pBody,zd_Snap_Apple_Type,8)==0) {

                                pData = pBody - 14;
                                dataLen = bodyLen + 14;     /* Plus DA, SA and TypeLen */
                                pData[12] = (bodyLen>>8) & 0xFF;
                                pData[13] = bodyLen & 0xFF;

                        } else if ((bodyLen > 5 ) && (memcmp(pBody, zd_Snap_Header, 6) == 0
                                                      || memcmp(pBody, zd_SnapBridgeTunnel, 6) == 0)) {

                                pData = pBody - 6;
                                dataLen = bodyLen + 6;		/* Plus DA, SA*/
                        } else {
                                pData = pBody - 14;
                                dataLen = bodyLen + 14;		/* Plus DA, SA and TypeLen */
                                pData[12] = (bodyLen>>8) & 0xFF;
                                pData[13] = bodyLen & 0xFF;
                        }
                        memcpy(pData, pEthHdr, 6);	/* Set DA */
                        memcpy(pData+6, pEthHdr+6, 6);	/* Set SA */
                        //if (Type == 0x888e)
                        //zd1205_dump_data("pData = ", pData, dataLen);
                        pdot11Obj->RxInd(pData, dataLen, buf);
                        return;
                }
        } else {	//Mgt Frame
                pRxSignal = allocSignal();
                if (!pRxSignal) {
                        FPRINT("zd_ReceivePkt out of signal");
                        FPRINT_V("freeSignalCount", freeSignalCount);
                        goto rx_release;
                }

                pRxFdesc = allocFdesc();
                if (!pRxFdesc) {
                        FPRINT("zd_ReceivePkt out of description");
                        FPRINT_V("freeFdescCount", freeFdescCount);
                        freeSignal(pRxSignal);
                        goto rx_release;
                } else {
                        //pRxFdesc->bDataFrm = bDataFrm;
                        pRxFdesc->signalStrength = signalStrength;
                        pRxFdesc->signalQuality = signalQuality;
                        pRxFrame = pRxFdesc->mpdu;
                        pRxFrame->HdrLen = hdrLen;
                        pRxFrame->bodyLen = bodyLen;
                        memcpy(pRxFrame->header, pHdr, hdrLen);
                        pRxFrame->body = pBody;
                        pRxSignal->buf = buf;
                        pRxSignal->vapId = vapId;
                        pRxSignal->frmInfo.frmDesc = pRxFdesc;
                        if (!RxMgtMpdu(pRxSignal)) {
                                freeSignal(pRxSignal);
                                freeFdesc(pRxFdesc);
                                pdot11Obj->ReleaseBuffer(buf);
                        }
                        return;
                }
        }

rx_release:
        pdot11Obj->ReleaseBuffer(buf);
        return;
}
void zd_InitWepData(void)
{
        mWepIv[0] = 0;
        mWepIv[1] = 0;
        mWepIv[2] = 0;
        mWepIv[3] = 0;
        mBcIv[0] = 0;
        mBcIv[1] = 0;
        mBcIv[2] = 0;
        mBcIv[3] = 0;
}

void zd_Release_80211_Buffer(void)
{
        releaseSignalBuf();
        releaseFdescBuf();
}

//Cmd Functions
BOOLEAN zd_Reset80211(zd_80211Obj_t * pObj)

{
        pdot11Obj = pObj;

        initSignalBuf();
        initFdescBuf();
        ResetPSMonitor();
        ResetPMFilter();
        zd_InitWepData();
        mBssCnt=0;
        return TRUE;
}

BOOLEAN zd_HandlePsPoll(U8 *pHdr)
{
        Frame_t psPollFrame;

        //PSDEBUG("zd_HandlePsPoll");
        psPollFrame.HdrLen = 16;
        psPollFrame.bodyLen = 0;
        memcpy(&psPollFrame.header[0], pHdr, 16);
        RxPsPoll(&psPollFrame);
        return TRUE;
}

BOOLEAN zd_StartAP(void)
{
        void *reg = pdot11Obj->reg;

        HW_SetRfChannel(pdot11Obj, mRfChannel, 1, mMacMode);

#if defined(AMAC)

        pdot11Obj->SetReg(reg, ZD_BasicRateTbl, 0);
#endif

        HW_SetSupportedRate(pdot11Obj, (U8 *)&mBrates);

#if defined(OFDM)

        if(PURE_A_MODE != mMacMode)
                HW_SetSupportedRate(pdot11Obj, (U8 *)&mExtRates);

#endif