zdpsmon.c

ZYDAS zd1211b driver for Linux2.4

        ZDEBUG("RxInfoIndicate");

        //if (isGroup(sta))
        //return NULL;

        pHash = HashSearch(sta);
        if (!pHash) {
                if (mBssType == PSEUDO_IBSS) {
                        pHash = HashInsert(sta);
                        if (!pHash)
                                return NULL;
                        else {
                                pHash->asoc = STATION_STATE_ASOC;
                                zd1205_dump_data(" HashInsert macAddr = ", (U8 *)&pHash->mac[0], 6);
                                goto updateInfo;
                        }
                } else
                        return NULL;
        } else {
updateInfo:
                if (rate > pHash->MaxRate)
                        pHash->MaxRate = rate;

                pHash->RxRate = rate;
                pHash->ttl = HW_GetNow(pdot11Obj);

                if (mBssType == AP_BSS) {
                        PsMode oldPsm = pHash->psm;
                        StationState asoc = pHash->asoc;

                        if (psm == PSMODE_STA_ACTIVE) {
                                if (oldPsm == PSMODE_POWER_SAVE) {
                                        StaWakeup(sta);
                                        if (asoc == STATION_STATE_ASOC) {
                                                if (mPsStaCnt >0) {
                                                        mPsStaCnt--;
                                                }
                                        }
                                }
                        } else {
                                if (oldPsm == PSMODE_STA_ACTIVE) {
                                        if (asoc == STATION_STATE_ASOC) {
                                                if (mPsStaCnt < MAX_AID) {
                                                        mPsStaCnt++;
                                                }
                                        }
                                } else if (oldPsm == PSMODE_POWER_SAVE) {
                                        if (asoc == STATION_STATE_ASOC) {
                                                if (mPsStaCnt == 0)
                                                        mPsStaCnt++;
                                        }
                                }
                        }
                }

                pHash->psm = psm;
        }

        return pHash;
}


void RxInfoUpdate(Hash_t *pHash, PsMode psm, U8 rate)
{
        PsMode oldPsm = pHash->psm;
        StationState asoc = pHash->asoc;

        if (rate > pHash->MaxRate)
                pHash->MaxRate = rate;

        pHash->RxRate = rate;
        pHash->ttl = HW_GetNow(pdot11Obj);

        if (psm == PSMODE_STA_ACTIVE) {
                if (oldPsm == PSMODE_POWER_SAVE) {
                        StaWakeup((MacAddr_t *)pHash->mac);
                        if (asoc == STATION_STATE_ASOC) {
                                if (mPsStaCnt >0) {
                                        mPsStaCnt--;
                                }
                        }
                }
        } else {
                if (oldPsm == PSMODE_STA_ACTIVE) {
                        if (asoc == STATION_STATE_ASOC) {
                                if (mPsStaCnt < MAX_AID) {
                                        mPsStaCnt++;
                                }
                        }
                } else if (oldPsm == PSMODE_POWER_SAVE) {
                        if (asoc == STATION_STATE_ASOC) {
                                if (mPsStaCnt == 0)
                                        mPsStaCnt++;
                        }

                }
        }


        pHash->psm = psm;
}


BOOLEAN UpdateStaStatus(MacAddr_t *sta, StationState staSte, U8 vapId)
{
        Hash_t *pHash;

        ZDEBUG("UpdateStaStatus");

        if (mBssType == AP_BSS) {
                pHash = HashSearch(sta);
                if (pHash)
                        goto UpdateStatus;
                else {
                        if ((STATION_STATE_AUTH_OPEN == staSte) || (STATION_STATE_AUTH_KEY == staSte)) {
                                if ((mCurrConnUser + 1) > mLimitedUser) {
                                        //AgeHashTbl();
                                        return FALSE;
                                } else {
                                        pHash = HashInsert(sta);
                                        if (!pHash)
                                                return FALSE;
                                }
                        } else
                                return FALSE;
                }
        } else if (mBssType == INFRASTRUCTURE_BSS) {
                if ((STATION_STATE_AUTH_OPEN == staSte) || (STATION_STATE_AUTH_KEY == staSte)) {
                        CleanupHash(sstByAid[0]);
                        pHash = HashInsert(sta);
                } else {
                        pHash = sstByAid[0]; //use aid = 0 to store AP's info
                }
        } else if (mBssType == INDEPENDENT_BSS) {
                pHash = HashSearch(sta);
                if (pHash)
                        goto UpdateStatus;
                else {
                        pHash = HashInsert(sta);
                        if (!pHash)
                                return FALSE;
                        else
                                zd1205_dump_data(" HashInsert macAddr = ", (U8 *)&pHash->mac[0], 6);
                }
        } else
                return FALSE;

UpdateStatus:
        switch(staSte) {
        case STATION_STATE_AUTH_OPEN:
        case STATION_STATE_AUTH_KEY:
                pHash->auth = staSte;
                break;

        case STATION_STATE_ASOC:
                if (mBssType == AP_BSS) {
                        if (((mCurrConnUser + 1) > mLimitedUser) && (!pHash->AlreadyIn)) {
                                return FALSE;
                        }

                        if (pHash->psm == PSMODE_POWER_SAVE) {
                                if (mPsStaCnt > 0) {
                                        mPsStaCnt--;
                                }

                        }

                        pHash->asoc = STATION_STATE_ASOC;
                        /*if (!pHash->AlreadyIn){
                        	pHash->AlreadyIn = 1;
                        	mCurrConnUser++;
                        }*/
                } else {
                        pHash->asoc = STATION_STATE_ASOC;
                }

                if (mBssType != INDEPENDENT_BSS)
                        CleanupKeyInfo(pHash);

                memcpy(&pdot11Obj->CurrSsid[0], (U8 *)&mSsid, mSsid.buf[1]+2);
                break;

        case STATION_STATE_NOT_AUTH:
        case STATION_STATE_DIS_ASOC:
                if (mBssType == AP_BSS) {
                        if (pHash->asoc == STATION_STATE_ASOC) {
                                if (pHash->psm == PSMODE_POWER_SAVE) {
                                        FlushQ(pPsQ[pHash->aid]);
                                        if (mPsStaCnt > 0) {
                                                mPsStaCnt--;
                                                if (mPsStaCnt == 0) {
                                                        FlushQ(pAwakeQ);
                                                        FlushQ(pPsQ[0]);
                                                }
                                        }
                                }
                                /*if (pHash->AlreadyIn){
                                	pHash->AlreadyIn = 0;
                                	mCurrConnUser--;	
                                }*/
                        }
                }

                pHash->auth = STATION_STATE_NOT_AUTH;
                pHash->asoc = STATION_STATE_DIS_ASOC;
                CleanupKeyInfo(pHash);
                //for Rx-Retry filter
                HW_CAM_ClearRollTbl(pdot11Obj, pHash->aid);
                {
                        MacAddr_t	*pMac;
                        Hash_t 		*sta_info;
                        U8 			entry;
                        pMac = (MacAddr_t *) pHash->mac;
                        entry = GetEntry(pMac);
                        sta_info=HashTbl[entry];
                        if (sta_info) {
                                if (memcmp(sta_info->mac, pHash->mac, 6)==0) {
                                        HashTbl[entry]=sta_info->pNext;
                                        freeHashBuf(pHash);
                                } else {
                                        while (sta_info->pNext != NULL && memcmp(sta_info->pNext->mac, pHash->mac, 6) != 0)
                                                sta_info = sta_info->pNext;
                                        if (sta_info->pNext != NULL) {
                                                Hash_t	*sta_info1;
                                                sta_info1 = sta_info->pNext;
                                                sta_info->pNext =  sta_info->pNext->pNext;
                                                freeHashBuf(sta_info1);
                                        } else {
                                                printk(KERN_DEBUG "Could not remove STA:" MACSTR "\n", MAC2STR(pHash->mac));
                                        }
                                }
                        }
                }

                break;

        }

        return TRUE;
}


void SsInquiry(MacAddr_t *sta, StationState *sst, StationState *asst)
{
        ZDEBUG("SsInquiry");
        if (isGroup(sta)) {
                *asst = STATION_STATE_NOT_AUTH;
                *sst = STATION_STATE_DIS_ASOC;
        } else {
                Hash_t *pHash;
                pHash = HashSearch(sta);

                if (!pHash) {
                        *asst = STATION_STATE_NOT_AUTH;
                        *sst = STATION_STATE_DIS_ASOC;
                } else {
                        *asst = pHash->auth;
                        if ((*asst == STATION_STATE_AUTH_OPEN) || (*asst == STATION_STATE_AUTH_KEY))
                                *sst = pHash->asoc;
                        else
                                *sst = STATION_STATE_DIS_ASOC;
                }
        }

}


U16 AIdLookup(MacAddr_t *sta)
{
        Hash_t *pHash;

        ZDEBUG("AIdLookup");
        pHash = HashSearch(sta);
        if (!pHash)
                return (U16)0;
        else
                return pHash->aid;
}


void AssocInfoUpdate(MacAddr_t *sta, U8 MaxRate, U8 lsInterval, U8 ZydasMode, U8 Preamble, BOOLEAN bErpSta, U8 vapId)
{
        Hash_t *pHash;

        ZDEBUG("AssocInfoUpdate");
        if (isGroup(sta))
                return;

        pHash = HashSearch(sta);
        if (!pHash)
                return;
        else {
                pHash->MaxRate = MaxRate;
                pHash->CurrTxRate = MaxRate;
                pHash->lsInterval = lsInterval;
                pHash->ZydasMode = ZydasMode;
                pHash->Preamble = Preamble;
                pHash->bErpSta = bErpSta;
                pHash->vapId = vapId;
        }
}

int zd_SetKeyInfo(U8 *addr, U8 encryMode, U8 keyLength, U8 KeyId, U8 *pKeyContent)
{
        Hash_t *pHash;
        MacAddr_t *sta = (MacAddr_t *)addr;
        U8 bcAddr[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
        U8 ZeroAddr[6]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
        U16 aid;
        U8 change_enc = 0;

        if (isGroup(sta)) {
                change_enc = 1;
                if (keyLength == 0) {
                        WPADEBUG("Clear Group key RollTbl (aid0)\n");
                        HW_CAM_ClearRollTbl(pdot11Obj, 0);//Clear group key.(aid0)
                } else if (encryMode == WEP64 || encryMode == WEP128) {

                        if (mWpaBcKeyLen == keyLength && mGkInstalled == 1)
                                change_enc = 0; // Nonfirst time group key update.
                        mWpaBcKeyLen = keyLength;
                        mBcKeyId = KeyId;// We tell KeyLength to hdwr by encryMode, while, the key ID is set by the driver when transmit packet.

                        if (mOperationMode != CAM_AP_VAP) {
                                HW_ConfigDynaKey(pdot11Obj, 32, &bcAddr[0], pKeyContent, keyLength, encryMode, change_enc);
                                // Also set default key for Multicast case to avoid Tx-underrun.
                                HW_CAM_Write(pdot11Obj, DEFAULT_ENCRY_TYPE, encryMode);
                                HW_ConfigStatKey(pdot11Obj, pKeyContent, keyLength, STA_KEY_START_ADDR+(KeyId * 8));
                        } else
                                HW_ConfigDynaKey(pdot11Obj, CAM_VAP_START_AID, (U8 *)&dot11MacAddress, pKeyContent, keyLength, encryMode,change_enc);

                        mGkInstalled = 1;
                        return 0;
                } else if (encryMode == TKIP) {
                        //only vaild for Tx
                        if (mWpaBcKeyLen == keyLength && mGkInstalled==1)//Non-First time group key update.
                                change_enc = 0;

                        mWpaBcKeyLen = keyLength;
                        mWpaBcKeyId = KeyId;
                        if (mWpaBcKeyLen == 32) {
                                if (mOperationMode != CAM_AP_VAP) {
                                        //Tmep key(16), Tx Mic Key(8), Rx Mic Key(8)
                                        HW_ConfigDynaKey(pdot11Obj, 32, &bcAddr[0], pKeyContent, keyLength, encryMode, change_enc);
                                        // Also set default key for Multicast case to avoid Tx-underrun.
                                        //if ((mDebugFlag & BIT_1)==0)
                                        {
                                                HW_CAM_Write(pdot11Obj, DEFAULT_ENCRY_TYPE, encryMode);
                                                HW_ConfigStatKey(pdot11Obj, pKeyContent, keyLength, STA_KEY_START_ADDR+(KeyId * 8));