zdpsmon.c

ZYDAS zd1211b driver for Linux2.4

                                        }
                                } else {
                                        HW_ConfigDynaKey(pdot11Obj, CAM_VAP_START_AID, (U8 *)&dot11MacAddress, pKeyContent, keyLength, encryMode, change_enc);
                                }
                                if (mBssType == INFRASTRUCTURE_BSS)
                                        MICsetKey(&pKeyContent[24], &mBcMicKey); //Tx Mic key
                                else
                                        MICsetKey(&pKeyContent[16], &mBcMicKey);// For Infra-STA mode.
                        }
                        mGkInstalled = 1;
                        return 0;
                } else if (encryMode == AES) {
                        if (mWpaBcKeyLen == keyLength && mGkInstalled == 1)//Non-First time group key update.
                                change_enc = 0;
                        mWpaBcKeyLen = keyLength;
                        mWpaBcKeyId = KeyId;
                        if (mWpaBcKeyLen == 16) {
                                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 {
                        return -1;
                }
        }// End of Group key setting.

        // Start of Pairwise key setting.
        pHash = HashSearch(sta);
        if (!pHash) {
                if (!memcmp(&sta->mac[0], ZeroAddr, 6)) {
                        int i;
                        HW_CAM_ResetRollTbl(pdot11Obj);
                        if (mGkInstalled) {
                                HW_CAM_UpdateRollTbl(pdot11Obj,0);//ReEnable group key.
                        }
                        if (mBssType != INFRASTRUCTURE_BSS) {//AP mode.
                                WPADEBUG("clear all tx key\n");
                                for (i=0; i<MAX_RECORD; i++)
                                        HashBuf[i].pkInstalled=0;
                        } else {// STA mode.
                                WPADEBUG("clear key of aid %d\n",sstByAid[0]->aid);
                                sstByAid[0]->pkInstalled=0;
                        }
                }
                return -1;
        } else {
                pHash->keyLength = keyLength;
                if (pHash->encryMode != encryMode)
                        change_enc = 1;
                pHash->encryMode = encryMode;
                aid = pHash->aid;

                if (encryMode != NO_WEP)
                        WPADEBUG("********* Set key%s for aid:%d\n",DbgStrEncryType[encryMode & 7],aid);
                else
                        WPADEBUG("********* Clear key for aid:%d\n",aid);
                if (encryMode == NO_WEP) {// Clear pairwise key
                        pHash->pkInstalled = 0;
                        if (mBssType == INFRASTRUCTURE_BSS)
                                HW_CAM_ClearRollTbl(pdot11Obj, 8);
                        else
                                HW_CAM_ClearRollTbl(pdot11Obj, aid);
                } else if (encryMode == TKIP) {
                        if (mBssType == INFRASTRUCTURE_BSS) {
                                //				zd1205_dump_data("key:", (u8*)pKeyContent, 32);
                                HW_ConfigDynaKey(pdot11Obj, 8, addr, pKeyContent, 32, encryMode, change_enc);
                        } else
                                HW_ConfigDynaKey(pdot11Obj, aid, addr, pKeyContent, 32, encryMode, change_enc);

                        MICsetKey(&pKeyContent[16], &pHash->TxMicKey);
                        MICsetKey(&pKeyContent[24], &pHash->RxMicKey);
                        pHash->KeyId = KeyId;
                        pHash->pkInstalled = 1;
                } else //if (encryMode == AES)
                {
                        if (mBssType == INFRASTRUCTURE_BSS) {
                                WPADEBUG("********* setAESkey\n");
                                HW_ConfigDynaKey(pdot11Obj, 8, addr, pKeyContent, keyLength, encryMode, change_enc);
                        } else
                                HW_ConfigDynaKey(pdot11Obj, aid, addr, pKeyContent, keyLength, encryMode, change_enc);
                        pHash->KeyId = KeyId;
                        pHash->pkInstalled = 1;
                }
                return 0;
        }
}

BOOLEAN zd_GetKeyInfo(U8 *addr, U8 *encryMode, U8 *keyLength, U8 *pKeyContent)
{
        Hash_t *pHash;
        MacAddr_t *sta = (MacAddr_t *)addr;

        ZDEBUG("zd_GetKeyInfo");
        if (isGroup(sta)) {
                return FALSE;
        }

        pHash = HashSearch(sta);
        if (!pHash) {
                *encryMode = 0;
                *keyLength = 0;
                return FALSE;
        } else {
                *encryMode = pHash->encryMode;
                *keyLength = pHash->keyLength;
                memcpy(pKeyContent, &pHash->keyContent[0], pHash->keyLength);
                return TRUE;
        }
}

/**
 * zd_SetKeyContext - Set Key context to CAM (used for WPA/WPA2)
 * @addr: MAC address of AP we associated with
 * @encryMode: Encryption mode
 * @keyLength: Length of key context
 * @keyId: Key index
 * @pKeyContent: Context of key
 */
#if 0

int zd_SetKeyContext(U8 *addr, U8 encryMode, U8 keyLength, U8 KeyId, U8 *pKeyContent)
{
        Hash_t *pHash;

        if (isGroup(addr)) {
                mWpaBcKeyLen = keyLength;
                mWpaBcKeyId = KeyId;

                if (encryMode == DYN_KEY_TKIP) {
                        if (keyLength == 32) {
                                zd1205_config_dyn_key(encryMode, pKeyContent, KeyId);
                                MICsetKey(&pKeyContent[24], &mBcMicKey);
                        }

                        mGkInstalled = 1;
                        return 0;
                } else if (encryMode == DYN_KEY_AES) {
                        printk(KERN_ERR "***** set group key ID: %d\n",KeyId);
                        zd1205_config_dyn_key(encryMode, pKeyContent, KeyId);
                        mGkInstalled = 1;
                        return 0;
                } else {
                        WPADEBUG("zd_SetKeyContext: encryMode: %d not support\n", encryMode);
                        return -1;
                }

        }

        pHash = HashSearch((MacAddr_t*)addr);

        if(!pHash) {
                WPADEBUG("Can't find AP's MAC address in the hash table\n");
                return -1;
        } else {
                pHash->encryMode = encryMode;

                if (encryMode == DYN_KEY_TKIP) {
                        zd1205_config_dyn_key(encryMode, pKeyContent, KeyId);

                        MICsetKey(&pKeyContent[16], &pHash->TxMicKey);
                        MICsetKey(&pKeyContent[24], &pHash->RxMicKey);
                        pHash->KeyId = KeyId;
                        pHash->pkInstalled = 1;
                } else if (encryMode == DYN_KEY_AES) {
                        zd1205_config_dyn_key(encryMode, pKeyContent, KeyId);
                        pHash->KeyId = KeyId;
                        pHash->pkInstalled = 1;
                }
                else {
                        WPADEBUG("zd_SetKeyContext: encryMode: %d not support\n", encryMode);
                }
        }

        return 0;
}
#endif

#if defined(PHY_1202)
int zd_GetKeyInfo_ext(U8 *addr, U8 *encryMode, U8 *keyLength, U8 *pKeyContent, U16 iv16, U32 iv32)
{
        Hash_t *pHash;
        MacAddr_t *sta = (MacAddr_t *)addr;

        ZDEBUG("zd_GetKeyInfo_ext");
        if (isGroup(sta)) {
                return -1;
        }

        if (mDynKeyMode != DYN_KEY_TKIP)
                return -1;

        pHash = HashSearch(sta);
        if (!pHash) {
                *encryMode = 0;
                *keyLength = 0;
                return -1;
        } else {
                if (pHash->pkInstalled == 0)
                        return -2;

                if ((iv16 == pHash->RxSeed.IV16) && (iv32 == pHash->RxSeed.IV32)) {
                        // iv out of sequence
                        //FPRINT_V("iv16", iv16);
                        //FPRINT_V("iv32", iv32);
                        //return -3;
                }

                *encryMode = pHash->encryMode;
                *keyLength = pHash->keyLength;
                //do key mixing
                Tkip_phase1_key_mix(iv32, &pHash->RxSeed);
                Tkip_phase2_key_mix(iv16, &pHash->RxSeed);
                Tkip_getseeds(iv16, pKeyContent, &pHash->RxSeed);
                pHash->RxSeed.IV16 = iv16;
                pHash->RxSeed.IV32 = iv32;
                return pHash->aid;
        }
}


int zd_SetTsc(U8 *addr, U8 KeyId, U8 direction, U32 tscHigh, U16 tscLow)
{
        Hash_t *pHash;
        MacAddr_t *sta = (MacAddr_t *)addr;

        ZDEBUG("zd_SetTsc");
        if (isGroup(sta)) {
                return -1;
        }

        pHash = HashSearch(sta);
        if (!pHash)
                return -1;
        else {
                pHash->KeyId = KeyId;
                if (direction == 0) { //Tx
                        pHash->TxSeed.IV16 = tscLow;
                        pHash->TxSeed.IV32 = tscHigh;
                } else if (direction == 1) { //Rx
                        pHash->RxSeed.IV16 = tscLow;
                        pHash->RxSeed.IV32 = tscHigh;
                }
                return 0;
        }
}


int zd_GetTsc(U8 *addr, U8 KeyId, U8 direction, U32 *tscHigh, U16 *tscLow)
{
        Hash_t *pHash;
        MacAddr_t *sta = (MacAddr_t *)addr;

        ZDEBUG("zd_GetTsc");
        if (isGroup(sta)) {
                return -1;
        }

        pHash = HashSearch(sta);
        if (!pHash)
                return -1;
        else {
                if (direction == 0) { //Tx
                        *tscLow = pHash->TxSeed.IV16;
                        *tscHigh = pHash->TxSeed.IV32;
                } else if (direction == 1) { //Rx
                        *tscLow = pHash->RxSeed.IV16;
                        *tscHigh = pHash->RxSeed.IV32;
                }
                return 0;
        }
}
#endif


BOOLEAN zd_CheckIvSeq(U8 aid, U16 iv16, U32 iv32)
{
        Hash_t *pHash = NULL;
        U16 oldIv16;
        U32 oldIv32;


        ZDEBUG("zd_CheckIvSeq");

        if (mDynKeyMode != DYN_KEY_TKIP) {
                FPRINT("Not in DYN_KEY_TKIP mode");
                return FALSE;
        }

        pHash = sstByAid[aid];
        if (!pHash) {
                FPRINT("zd_CheckIvSeq failed");
                return FALSE;
        } else {
                if (pHash->pkInstalled == 0) {
                        FPRINT("pkInstalled == 0");
                        return FALSE;
                }

                oldIv16 = pHash->RxSeed.IV16;
                oldIv32 = pHash->RxSeed.IV32;

#if 1

                if ((oldIv16 == iv16) && (oldIv32 == iv32)) {
                        // iv out of sequence
                        FPRINT("iv out of sequence");
                        FPRINT_V("iv16", iv16);
                        FPRINT_V("iv32", iv32);
                        return FALSE;
                }

#else //If fifo overrun, this will failed
                if (iv32 == oldIv32) {
                        if (iv16 != oldIv16+1) {
                                // iv out of sequence
                                FPRINT("iv out of sequence");
                                FPRINT_V("iv16", iv16);
                                FPRINT_V("iv32", iv32);
                                return FALSE;
                        }
                } else {
                        if ((iv16 != 0) || (oldIv16 != 0xffff)) {
                                // iv out of sequence
                                FPRINT("iv out of sequence");
                                FPRINT_V("iv16", iv16);
                                FPRINT_V("iv32", iv32);
                                return FALSE;
                        }
                }
#endif

                pHash->RxSeed.IV16 = iv16;
                pHash->RxSeed.IV32 = iv32;
                return TRUE;
        }
}


#endif