From 6da728bb0e44fbaf8adc6048d39cc0f71a8dc22c Mon Sep 17 00:00:00 2001 From: Mandy Lavi Date: Tue, 28 Jul 2015 19:03:27 +0300 Subject: fmd: support aging in CC Signed-off-by: Mandy Lavi diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/HC/hc.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/HC/hc.c index 8bc0889..633eb3a 100644 --- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/HC/hc.c +++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/HC/hc.c @@ -49,15 +49,22 @@ #define HC_HCOR_OPCODE_KG_SCM 0x1 #define HC_HCOR_OPCODE_SYNC 0x2 #define HC_HCOR_OPCODE_CC 0x3 +#define HC_HCOR_OPCODE_CC_AGE_MASK 0x4 #define HC_HCOR_OPCODE_CC_CAPWAP_REASSM_TIMEOUT 0x5 #define HC_HCOR_OPCODE_CC_REASSM_TIMEOUT 0x10 #define HC_HCOR_OPCODE_CC_IP_FRAG_INITIALIZATION 0x11 -#define HC_HCOR_ACTION_REG_REASSM_TIMEOUT_ACTIVE_SHIFT 24 -#define HC_HCOR_EXTRA_REG_REASSM_TIMEOUT_TSBS_SHIFT 24 -#define HC_HCOR_ACTION_REG_REASSM_TIMEOUT_RES_SHIFT 16 -#define HC_HCOR_ACTION_REG_REASSM_TIMEOUT_RES_MASK 0xF -#define HC_HCOR_ACTION_REG_IP_FRAG_SCRATCH_POOL_CMD_SHIFT 24 -#define HC_HCOR_ACTION_REG_IP_FRAG_SCRATCH_POOL_BPID 16 +#define HC_HCOR_OPCODE_CC_UPDATE_WITH_AGING 0x13 +#define HC_HCOR_ACTION_REG_REASSM_TIMEOUT_ACTIVE_SHIFT 24 +#define HC_HCOR_EXTRA_REG_REASSM_TIMEOUT_TSBS_SHIFT 24 +#define HC_HCOR_EXTRA_REG_CC_AGING_ADD 0x80000000 +#define HC_HCOR_EXTRA_REG_CC_AGING_REMOVE 0x40000000 +#define HC_HCOR_EXTRA_REG_CC_AGING_CHANGE_MASK 0xC0000000 +#define HC_HCOR_EXTRA_REG_CC_REMOVE_INDX_SHIFT 24 +#define HC_HCOR_EXTRA_REG_CC_REMOVE_INDX_MASK 0x1F000000 +#define HC_HCOR_ACTION_REG_REASSM_TIMEOUT_RES_SHIFT 16 +#define HC_HCOR_ACTION_REG_REASSM_TIMEOUT_RES_MASK 0xF +#define HC_HCOR_ACTION_REG_IP_FRAG_SCRATCH_POOL_CMD_SHIFT 24 +#define HC_HCOR_ACTION_REG_IP_FRAG_SCRATCH_POOL_BPID 16 #define HC_HCOR_GBL 0x20000000 @@ -110,7 +117,7 @@ typedef struct t_HcFrame { t_FmPcdCcCapwapReassmTimeoutParams ccCapwapReassmTimeout; t_FmPcdCcReassmTimeoutParams ccReassmTimeout; } hcSpecificData; -} _PackedType t_HcFrame; +} t_HcFrame; #if defined(__MWERKS__) && !defined(__GNUC__) #pragma pack(pop) @@ -277,6 +284,7 @@ t_Handle FmHcConfigAndInit(t_FmHcParams *p_FmHcParams) } err = FM_PORT_ConfigMaxFrameLength(p_FmHc->h_HcPortDev, (uint16_t)sizeof(t_HcFrame)); + if (err != E_OK) { REPORT_ERROR(MAJOR, err, ("FM HC port init!")); @@ -647,11 +655,10 @@ t_Error FmHcPcdKgSetClsPlan(t_Handle h_FmHc, t_FmPcdKgInterModuleClsPlanSet *p_S p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); p_HcFrame->actionReg = FmPcdKgBuildWriteClsPlanBlockActionReg((uint8_t)(i / CLS_PLAN_NUM_PER_GRP)); p_HcFrame->extraReg = HC_HCOR_KG_SCHEME_REGS_MASK; - ASSERT_COND(IN_RANGE(0, (i-p_Set->baseEntry) ,FM_PCD_MAX_NUM_OF_CLS_PLANS-1)); + idx = (uint8_t)(i - p_Set->baseEntry); ASSERT_COND(idx < FM_PCD_MAX_NUM_OF_CLS_PLANS); memcpy(&p_HcFrame->hcSpecificData.clsPlanEntries, &p_Set->vectors[idx], CLS_PLAN_NUM_PER_GRP*sizeof(uint32_t)); - p_HcFrame->commandSequence = seqNum; BUILD_FD(sizeof(t_HcFrame)); @@ -1185,6 +1192,97 @@ t_Error FmHcPcdCcDoDynamicChange(t_Handle h_FmHc, uint32_t oldAdAddrOffset, uint return E_OK; } +t_Error FmHcPcdCcDoDynamicChangeWithAging(t_Handle h_FmHc, + uint32_t oldAdAddrOffset, + uint32_t newAdAddrOffset, + e_FmCcModifyState modifyState, + uint16_t keyIndex) +{ + t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; + t_HcFrame *p_HcFrame; + t_DpaaFD fmFd; + t_Error err = E_OK; + uint32_t seqNum; + + SANITY_CHECK_RETURN_ERROR(p_FmHc, E_INVALID_HANDLE); + + p_HcFrame = GetBuf(p_FmHc, &seqNum); + if (!p_HcFrame) + RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame object")); + memset(p_HcFrame, 0, sizeof(t_HcFrame)); + + p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_CC_UPDATE_WITH_AGING); + p_HcFrame->actionReg = newAdAddrOffset; + p_HcFrame->actionReg |= 0xc0000000; + p_HcFrame->extraReg = oldAdAddrOffset; + + switch (modifyState) + { + case e_MODIFY_STATE_ADD: + p_HcFrame->extraReg |= HC_HCOR_EXTRA_REG_CC_AGING_ADD; + break; + + case e_MODIFY_STATE_REMOVE: + p_HcFrame->extraReg |= HC_HCOR_EXTRA_REG_CC_AGING_REMOVE; + p_HcFrame->extraReg |= ((keyIndex << HC_HCOR_EXTRA_REG_CC_REMOVE_INDX_SHIFT) & HC_HCOR_EXTRA_REG_CC_REMOVE_INDX_MASK); + break; + + case e_MODIFY_STATE_CHANGE: + p_HcFrame->extraReg &= ~HC_HCOR_EXTRA_REG_CC_AGING_CHANGE_MASK; + break; + } + + p_HcFrame->commandSequence = seqNum; + + BUILD_FD(SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC); + + err = EnQFrm(p_FmHc, &fmFd, seqNum); + + PutBuf(p_FmHc, p_HcFrame, seqNum); + + if (err != E_OK) + RETURN_ERROR(MAJOR, err, NO_MSG); + + return E_OK; +} + +t_Error FmHcPcdCcResetAgingMask(t_Handle h_FmHc, uint32_t adAddrOffset, uint32_t newAgeMask, uint32_t *p_OldAgeMask) +{ + t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; + t_HcFrame *p_HcFrame; + t_DpaaFD fmFd; + t_Error err = E_OK; + uint32_t seqNum; + + SANITY_CHECK_RETURN_ERROR(p_FmHc, E_INVALID_HANDLE); + + p_HcFrame = GetBuf(p_FmHc, &seqNum); + if (!p_HcFrame) + RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame object")); + memset(p_HcFrame, 0, sizeof(t_HcFrame)); + + p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_CC_AGE_MASK); + p_HcFrame->actionReg = adAddrOffset; + p_HcFrame->extraReg = newAgeMask; + p_HcFrame->commandSequence = seqNum; + + BUILD_FD(SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC); + + err = EnQFrm(p_FmHc, &fmFd, seqNum); + + /* On command completion the FMC writes to HCER the 'aging-mask' field + before it was updated by this command. This way the user may identify + which bits were cleared by FMC before setting them. */ + *p_OldAgeMask = p_HcFrame->extraReg; + + PutBuf(p_FmHc, p_HcFrame, seqNum); + + if (err != E_OK) + RETURN_ERROR(MAJOR, err, NO_MSG); + + return E_OK; +} + t_Error FmHcPcdSync(t_Handle h_FmHc) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_cc.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_cc.c index 863b61d..f439167 100644 --- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_cc.c +++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_cc.c @@ -270,7 +270,7 @@ static void FillAdOfTypeContLookup(t_Handle h_Ad, t_AdOfTypeContLookup *p_AdContLookup = (t_AdOfTypeContLookup *)h_Ad; t_Handle h_TmpAd; t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; - uint32_t tmpReg32; + uint32_t tmpReg32, agingMask; t_Handle p_AdNewPtr = NULL; UNUSED(h_Manip); @@ -367,8 +367,16 @@ static void FillAdOfTypeContLookup(t_Handle h_Ad, tmpReg32 |= p_Node->parseCode; WRITE_UINT32(p_AdContLookup->pcAndOffsets, tmpReg32); - Mem2IOCpy32((void*)&p_AdContLookup->gmask, p_Node->p_GlblMask, - CC_GLBL_MASK_SIZE); + if (p_Node->agingSupport) + { + /* Building a mask of 1-s for all node's keys */ + agingMask = CC_BUILD_AGING_MASK(p_Node->numOfKeys); + Mem2IOCpy32((void*)&p_AdContLookup->gmask, &agingMask, + CC_AGING_MASK_SIZE); + } + else + Mem2IOCpy32((void*)&p_AdContLookup->gmask, p_Node->p_GlblMask, + CC_GLBL_MASK_SIZE); } } @@ -851,6 +859,7 @@ static t_Handle BuildNewAd( p_FmPcdCcNodeTmp->h_AdTable = p_FmPcdModifyCcKeyAdditionalParams->p_AdTableNew; + p_FmPcdCcNodeTmp->agingSupport = p_CcNode->agingSupport; p_FmPcdCcNodeTmp->lclMask = p_CcNode->lclMask; p_FmPcdCcNodeTmp->parseCode = p_CcNode->parseCode; p_FmPcdCcNodeTmp->offset = p_CcNode->offset; @@ -897,7 +906,8 @@ static t_Handle BuildNewAd( static t_Error DynamicChangeHc( t_Handle h_FmPcd, t_List *h_OldPointersLst, t_List *h_NewPointersLst, t_FmPcdModifyCcKeyAdditionalParams *p_AdditionalParams, - bool useShadowStructs) + bool useShadowStructs, + e_FmCcModifyState modifyState) { t_List *p_PosOld, *p_PosNew; uint32_t oldAdAddrOffset, newAdAddrOffset; @@ -942,7 +952,15 @@ static t_Error DynamicChangeHc( } /* Invoke host command to copy from new AD to old AD */ - err = FmHcPcdCcDoDynamicChange(((t_FmPcd *)h_FmPcd)->h_Hc, + if ((!p_AdditionalParams->tree) && + (((t_FmPcdCcNode *)(p_AdditionalParams->h_CurrentNode))->agingSupport)) + err = FmHcPcdCcDoDynamicChangeWithAging(((t_FmPcd *)h_FmPcd)->h_Hc, + oldAdAddrOffset, + newAdAddrOffset, + modifyState, + p_AdditionalParams->savedKeyIndex); + else + err = FmHcPcdCcDoDynamicChange(((t_FmPcd *)h_FmPcd)->h_Hc, oldAdAddrOffset, newAdAddrOffset); if (err) { @@ -990,7 +1008,8 @@ static t_Error DoDynamicChange( /* Invoke host-command to copy from the new Ad to existing Ads */ err = DynamicChangeHc(h_FmPcd, h_OldPointersLst, h_NewPointersLst, - p_AdditionalParams, useShadowStructs); + p_AdditionalParams, useShadowStructs, + p_AdditionalParams->modifyState); if (err) RETURN_ERROR(MAJOR, err, NO_MSG); @@ -1029,7 +1048,8 @@ static t_Error DoDynamicChange( /* HC to copy from the new Ad (old updated structures) to current Ad (uses shadow structures) */ err = DynamicChangeHc(h_FmPcd, h_OldPointersLst, h_NewPointersLst, - p_AdditionalParams, useShadowStructs); + p_AdditionalParams, useShadowStructs, + e_MODIFY_STATE_CHANGE); if (err) RETURN_ERROR(MAJOR, err, NO_MSG); } @@ -1693,7 +1713,8 @@ t_Error ValidateNextEngineParams( static uint8_t GetGenParseCode(e_FmPcdExtractFrom src, uint32_t offset, bool glblMask, uint8_t *parseArrayOffset, bool fromIc, - ccPrivateInfo_t icCode) + ccPrivateInfo_t icCode, + bool aging) { if (!fromIc) { @@ -1723,7 +1744,10 @@ static uint8_t GetGenParseCode(e_FmPcdExtractFrom src, { case (CC_PRIVATE_INFO_IC_KEY_EXACT_MATCH): *parseArrayOffset = 0x50; - return CC_PC_GENERIC_IC_GMASK; + if (aging) + return CC_PC_GENERIC_IC_AGING_MASK; + else + return CC_PC_GENERIC_IC_GMASK; case (CC_PRIVATE_INFO_IC_HASH_EXACT_MATCH): *parseArrayOffset = 0x48; @@ -3420,7 +3444,7 @@ static void UpdateAdPtrOfTreesWhichPointsOnCrntMdfNode( static t_FmPcdModifyCcKeyAdditionalParams * ModifyNodeCommonPart( t_Handle h_FmPcdCcNodeOrTree, uint16_t keyIndex, - e_ModifyState modifyState, bool ttlCheck, bool hashCheck, bool tree) + e_FmCcModifyState modifyState, bool ttlCheck, bool hashCheck, bool tree) { t_FmPcdModifyCcKeyAdditionalParams *p_FmPcdModifyCcKeyAdditionalParams; int i = 0, j = 0; @@ -3503,6 +3527,7 @@ static t_FmPcdModifyCcKeyAdditionalParams * ModifyNodeCommonPart( p_FmPcdModifyCcKeyAdditionalParams->h_CurrentNode = h_FmPcdCcNodeOrTree; p_FmPcdModifyCcKeyAdditionalParams->savedKeyIndex = keyIndex; + p_FmPcdModifyCcKeyAdditionalParams->modifyState = modifyState; while (i < numOfKeys) { @@ -4527,7 +4552,7 @@ static t_Error MatchTableSet(t_Handle h_FmPcd, t_FmPcdCcNode *p_CcNode, p_CcNode->parseCode = GetGenParseCode( p_CcNodeParam->extractCcParams.extractNonHdr.src, p_CcNode->offset, glblMask, &p_CcNode->prsArrayOffset, - fromIc, icCode); + fromIc, icCode, p_CcNode->agingSupport); if (p_CcNode->parseCode == CC_PC_GENERIC_IC_HASH_INDEXED) { @@ -4541,6 +4566,7 @@ static t_Error MatchTableSet(t_Handle h_FmPcd, t_FmPcdCcNode *p_CcNode, } } if ((p_CcNode->parseCode == CC_PC_GENERIC_IC_GMASK) + || (p_CcNode->parseCode == CC_PC_GENERIC_IC_AGING_MASK) || (p_CcNode->parseCode == CC_PC_GENERIC_IC_HASH_INDEXED)) { p_CcNode->offset += p_CcNode->prsArrayOffset; @@ -5735,6 +5761,58 @@ t_Error FmPcdCcModifyKeyAndNextEngine(t_Handle h_FmPcd, t_Handle h_FmPcdCcNode, return err; } +static t_Error FmPcdCcGetAgingMask(t_Handle h_FmPcd, + t_Handle h_FmPcdCcNode, + uint16_t keyIndex, + bool reset, + uint32_t *p_Mask) +{ + t_FmPcd *p_FmPcd = (t_FmPcd *)h_FmPcd; + t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_FmPcdCcNode; + t_FmPcdCcNextEngineParams *p_NextEngineParams = NULL; + t_List h_NodesLst; + uint32_t newAgingMask, oldAgingMask, adAddrOffset; + t_AdOfTypeContLookup *p_AdContLookup; + t_Error err; + + INIT_LIST(&h_NodesLst); + + /* Building a list of all action descriptors that point to this node. + No sharing on AD with aging, so there should be only one parent. */ + if (!LIST_IsEmpty(&p_CcNode->ccPrevNodesLst)) + UpdateAdPtrOfNodesWhichPointsOnCrntMdfNode(p_CcNode, &h_NodesLst, + &p_NextEngineParams); + ASSERT_COND(LIST_NumOfObjs(&h_NodesLst) == 1); + + adAddrOffset = FmPcdCcGetNodeAddrOffsetFromNodeInfo(p_FmPcd, LIST_FIRST(&h_NodesLst)); + + if (reset) + { + if (keyIndex == FM_PCD_LAST_KEY_INDEX) + /* If no specific key index provided the entire aging mask will be reset */ + newAgingMask = CC_BUILD_AGING_MASK(p_CcNode->numOfKeys); + else + /* Only the bit that corresponds to the provided index is reset, + other bits in the mask will be preserved */ + newAgingMask = (0x80000000 >> keyIndex); + + err = FmHcPcdCcResetAgingMask(p_FmPcd->h_Hc, adAddrOffset, newAgingMask, &oldAgingMask); + if (err) + RETURN_ERROR(MAJOR, err, NO_MSG); + + *p_Mask = (oldAgingMask & newAgingMask); + } + else + { + p_AdContLookup = (t_AdOfTypeContLookup *)(PTR_MOVE(XX_PhysToVirt(p_FmPcd->physicalMuramBase), adAddrOffset)); + *p_Mask = GET_UINT32(p_AdContLookup->gmask); + } + + ReleaseLst(&h_NodesLst); + + return E_OK; +} + uint32_t FmPcdCcGetNodeAddrOffsetFromNodeInfo(t_Handle h_FmPcd, t_Handle h_Pointer) { @@ -7167,6 +7245,14 @@ t_Handle FM_PCD_HashTableSet(t_Handle h_FmPcd, t_FmPcdHashTableParams *p_Param) if (p_Param->maxNumOfKeys % numOfSets) DBG(INFO, ("'maxNumOfKeys' is not a multiple of hash number of ways, so number of ways will be rounded up")); + if ((p_Param->agingSupport) && (numOfWays > 31)) + { + XX_Free(p_ExactMatchCcNodeParam); + REPORT_ERROR(MAJOR, E_INVALID_VALUE, + ("Aging supported enabled and %d keys requested per hash bucket. Aging cannot be supported when more then 31 keys", numOfWays)); + return NULL; + } + if ((p_Param->statisticsMode == e_FM_PCD_CC_STATS_MODE_FRAME) || (p_Param->statisticsMode == e_FM_PCD_CC_STATS_MODE_BYTE_AND_FRAME)) { @@ -7215,14 +7301,16 @@ t_Handle FM_PCD_HashTableSet(t_Handle h_FmPcd, t_FmPcdHashTableParams *p_Param) for (i = 0; i < numOfSets; i++) { - /* Each exact-match node will be marked as a 'bucket' and provided with a pointer to statistics counters, - to be used for 'miss' entry statistics */ + /* Each exact-match node will be marked as a 'bucket' and provided with + a pointer to statistics counters, to be used for 'miss' entry + statistics */ p_CcNode = (t_FmPcdCcNode *)XX_Malloc(sizeof(t_FmPcdCcNode)); if (!p_CcNode) break; memset(p_CcNode, 0, sizeof(t_FmPcdCcNode)); p_CcNode->isHashBucket = TRUE; + p_CcNode->agingSupport = p_Param->agingSupport; p_CcNode->h_MissStatsCounters = h_MissStatsCounters; err = MatchTableSet(h_FmPcd, p_CcNode, p_ExactMatchCcNodeParam); @@ -7529,3 +7617,138 @@ t_Error FM_PCD_HashTableGetMissStatistics( return FM_PCD_MatchTableGetMissStatistics(h_HashBucket, p_MissStatistics); } + +t_Error FM_PCD_HashTableGetKeyAging(t_Handle h_HashTbl, + uint8_t *p_Key, + uint8_t keySize, + bool reset, + bool *p_KeyAging) +{ + t_FmPcdCcNode *p_HashTbl = (t_FmPcdCcNode *)h_HashTbl; + t_FmPcd *p_FmPcd; + t_Handle h_HashBucket; + uint8_t bucketIndex; + uint16_t lastIndex, keyIndex; + uint32_t agingMask, keyAgingBit; + t_Error err; + + SANITY_CHECK_RETURN_ERROR(p_HashTbl, E_INVALID_HANDLE); + SANITY_CHECK_RETURN_ERROR(p_Key, E_NULL_POINTER); + SANITY_CHECK_RETURN_ERROR(p_KeyAging, E_NULL_POINTER); + p_FmPcd = (t_FmPcd *)p_HashTbl->h_FmPcd; + SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); + SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc, E_INVALID_HANDLE); + + err = FM_PCD_MatchTableGetIndexedHashBucket(p_HashTbl, keySize, p_Key, + p_HashTbl->kgHashShift, + &h_HashBucket, &bucketIndex, + &lastIndex); + if (err) + RETURN_ERROR(MAJOR, err, NO_MSG); + + if (!((t_FmPcdCcNode *)h_HashBucket)->agingSupport) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Aging support was not enabled for this hash table")); + + if (!FmPcdLockTryLockAll(p_FmPcd)) + { + DBG(TRACE, ("FmPcdLockTryLockAll failed")); + return ERROR_CODE(E_BUSY); + } + + err = FindKeyIndex(h_HashBucket, keySize, p_Key, NULL, &keyIndex); + if (GET_ERROR_TYPE(err) != E_OK) + { + FmPcdLockUnlockAll(p_FmPcd); + RETURN_ERROR( + MAJOR, + err, + ("The received key and mask pair was not found in the match table of the provided node")); + } + + err = FmPcdCcGetAgingMask(p_FmPcd, h_HashBucket, keyIndex, reset, &agingMask); + + keyAgingBit = (0x80000000 >> keyIndex); + *p_KeyAging = ((agingMask & keyAgingBit) ? TRUE : FALSE); + + FmPcdLockUnlockAll(p_FmPcd); + + switch(GET_ERROR_TYPE(err)) + { + case E_OK: + return E_OK; + + case E_BUSY: + DBG(TRACE, ("E_BUSY error")); + return ERROR_CODE(E_BUSY); + + default: + RETURN_ERROR(MAJOR, err, NO_MSG); + } +} + +t_Error FM_PCD_HashTableGetBucketAging(t_Handle h_HashTbl, + uint16_t bucketId, + bool reset, + uint32_t *p_BucketAgingMask, + uint8_t *agedKeysArray[31]) +{ + t_FmPcdCcNode *p_HashTbl = (t_FmPcdCcNode *)h_HashTbl; + t_FmPcd *p_FmPcd; + t_FmPcdCcNode *p_HashBucket; + uint32_t tmpMask, keyIndex = 0, indx = 0; + t_Error err; + + SANITY_CHECK_RETURN_ERROR(p_HashTbl, E_INVALID_HANDLE); + p_FmPcd = (t_FmPcd *)p_HashTbl->h_FmPcd; + SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); + SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc, E_INVALID_HANDLE); + + p_HashBucket = (t_FmPcdCcNode *)(p_HashTbl->keyAndNextEngineParams[bucketId].nextEngineParams.params.ccParams.h_CcNode); + + if (!p_HashBucket->agingSupport) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Aging support was not enabled for this hash table")); + + if (!FmPcdLockTryLockAll(p_FmPcd)) + { + DBG(TRACE, ("FmPcdLockTryLockAll failed")); + return ERROR_CODE(E_BUSY); + } + + err = FmPcdCcGetAgingMask(p_FmPcd, p_HashBucket, FM_PCD_LAST_KEY_INDEX, reset, p_BucketAgingMask); + + /* If the user provided a valid pointer, the aged keys will be copied + into the provided array of pointers */ + if ((agedKeysArray) && (*p_BucketAgingMask)) + { + tmpMask = *p_BucketAgingMask; + + while (tmpMask) + { + /* If a bit is set in the aging mask and it doesn't correspond to miss entry, + copy the key into the aged keys array */ + if ((tmpMask & 0x80000000) && (keyIndex != p_HashBucket->numOfKeys)) + { + memcpy(agedKeysArray[indx], p_HashBucket->keyAndNextEngineParams[keyIndex].key, p_HashBucket->userSizeOfExtraction); + indx++; + } + + tmpMask = (tmpMask << 1); + keyIndex++; + } + } + + FmPcdLockUnlockAll(p_FmPcd); + + switch(GET_ERROR_TYPE(err)) + { + case E_OK: + return E_OK; + + case E_BUSY: + DBG(TRACE, ("E_BUSY error")); + return ERROR_CODE(E_BUSY); + + default: + RETURN_ERROR(MAJOR, err, NO_MSG); + } +} diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_cc.h b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_cc.h index 3bc7585..00d3f05 100644 --- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_cc.h +++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_cc.h @@ -107,6 +107,7 @@ #define CC_PC_GENERIC_WITH_MASK 0x28 #define CC_PC_GENERIC_IC_GMASK 0x2B #define CC_PC_GENERIC_IC_HASH_INDEXED 0x2C +#define CC_PC_GENERIC_IC_AGING_MASK 0x2D #define CC_PR_OFFSET 0x25 #define CC_PR_WITHOUT_OFFSET 0x26 @@ -174,6 +175,7 @@ #define GLBL_MASK_FOR_HASH_INDEXED 0xfff00000 #define CC_GLBL_MASK_SIZE 4 +#define CC_AGING_MASK_SIZE 4 typedef uint32_t ccPrivateInfo_t; /**< private info of CC: */ @@ -183,6 +185,7 @@ typedef uint32_t ccPrivateInfo_t; /**< private info of CC: */ #define CC_PRIVATE_INFO_IC_KEY_EXACT_MATCH 0x20000000 #define CC_PRIVATE_INFO_IC_DEQ_FQID_INDEX_LOOKUP 0x10000000 +#define CC_BUILD_AGING_MASK(numOfKeys) ((((1LL << ((numOfKeys) + 1)) - 1)) << (31 - (numOfKeys))) /***********************************************************************/ /* Memory map */ /***********************************************************************/ @@ -229,13 +232,6 @@ typedef union /* Driver's internal structures */ /***********************************************************************/ -typedef enum e_ModifyState -{ - e_MODIFY_STATE_ADD = 0, - e_MODIFY_STATE_REMOVE, - e_MODIFY_STATE_CHANGE -} e_ModifyState; - typedef struct t_FmPcdStatsObj { t_Handle h_StatsAd; @@ -271,23 +267,24 @@ typedef struct typedef struct { - t_Handle p_AdTableNew; - t_Handle p_KeysMatchTableNew; - t_Handle p_AdTableOld; - t_Handle p_KeysMatchTableOld; - uint16_t numOfKeys; - t_Handle h_CurrentNode; - uint16_t savedKeyIndex; - t_Handle h_NodeForAdd; - t_Handle h_NodeForRmv; - t_Handle h_ManipForRmv; - t_Handle h_ManipForAdd; - t_FmPcdStatsObj *p_StatsObjForRmv; + t_Handle p_AdTableNew; + t_Handle p_KeysMatchTableNew; + t_Handle p_AdTableOld; + t_Handle p_KeysMatchTableOld; + uint16_t numOfKeys; + t_Handle h_CurrentNode; + uint16_t savedKeyIndex; + t_Handle h_NodeForAdd; + t_Handle h_NodeForRmv; + t_Handle h_ManipForRmv; + t_Handle h_ManipForAdd; + t_FmPcdStatsObj *p_StatsObjForRmv; #if (DPAA_VERSION >= 11) - t_Handle h_FrmReplicForAdd; - t_Handle h_FrmReplicForRmv; + t_Handle h_FrmReplicForAdd; + t_Handle h_FrmReplicForRmv; #endif /* (DPAA_VERSION >= 11) */ - bool tree; + bool tree; + e_FmCcModifyState modifyState; t_FmPcdCcKeyAndNextEngineParams keyAndNextEngineParams[CC_MAX_NUM_OF_KEYS]; } t_FmPcdModifyCcKeyAdditionalParams; @@ -311,6 +308,7 @@ typedef struct uint32_t countersArraySize; bool isHashBucket; /**< Valid for match table node that is a bucket of a hash table only */ + bool agingSupport; /**< Valid for match table node that is a bucket of a hash table only */ t_Handle h_MissStatsCounters; /**< Valid for hash table node and match table that is a bucket; Holds the statistics counters allocated by the hash table and are shared by all hash table buckets; */ diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/inc/fm_common.h b/drivers/net/ethernet/freescale/fman/Peripherals/FM/inc/fm_common.h index 30eae1b..654294d 100644 --- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/inc/fm_common.h +++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/inc/fm_common.h @@ -230,6 +230,13 @@ typedef struct }t_CcNodeInformation; #define CC_NODE_F_OBJECT(ptr) LIST_OBJECT(ptr, t_CcNodeInformation, node) +typedef enum e_FmCcModifyState +{ + e_MODIFY_STATE_ADD = 0, + e_MODIFY_STATE_REMOVE, + e_MODIFY_STATE_CHANGE +} e_FmCcModifyState; + typedef struct { t_Handle h_Manip; diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/inc/fm_hc.h b/drivers/net/ethernet/freescale/fman/Peripherals/FM/inc/fm_hc.h index 492aa8a..c4f62d7 100644 --- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/inc/fm_hc.h +++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/inc/fm_hc.h @@ -71,6 +71,8 @@ t_Error FmHcPcdKgSetSchemeCounter(t_Handle h_FmHc, t_Handle h_Scheme, uint32 uint32_t FmHcPcdKgGetSchemeCounter(t_Handle h_FmHc, t_Handle h_Scheme); t_Error FmHcPcdCcDoDynamicChange(t_Handle h_FmHc, uint32_t oldAdAddrOffset, uint32_t newAdAddrOffset); +t_Error FmHcPcdCcDoDynamicChangeWithAging(t_Handle h_FmHc, uint32_t oldAdAddrOffset, uint32_t newAdAddrOffset, e_FmCcModifyState modifyState, uint16_t keyIndex); +t_Error FmHcPcdCcResetAgingMask(t_Handle h_FmHc, uint32_t adAddrOffset, uint32_t newAgeMask, uint32_t *p_OldAgeMask); t_Error FmHcPcdPlcrSetProfile(t_Handle h_FmHc, t_Handle h_Profile, t_FmPcdPlcrProfileRegs *p_PlcrRegs); t_Error FmHcPcdPlcrDeleteProfile(t_Handle h_FmHc, t_Handle h_Profile); diff --git a/drivers/net/ethernet/freescale/fman/inc/Peripherals/fm_pcd_ext.h b/drivers/net/ethernet/freescale/fman/inc/Peripherals/fm_pcd_ext.h index ef37770..e67fbb6 100644 --- a/drivers/net/ethernet/freescale/fman/inc/Peripherals/fm_pcd_ext.h +++ b/drivers/net/ethernet/freescale/fman/inc/Peripherals/fm_pcd_ext.h @@ -1101,9 +1101,9 @@ typedef enum e_FmPcdAction { typedef enum e_FmPcdManipHdrInsrtType { e_FM_PCD_MANIP_INSRT_GENERIC, /**< Insert according to offset & size */ e_FM_PCD_MANIP_INSRT_BY_HDR, /**< Insert according to protocol */ -#ifdef FM_CAPWAP_SUPPORT +#if ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT)) e_FM_PCD_MANIP_INSRT_BY_TEMPLATE /**< Insert template to start of frame */ -#endif /* FM_CAPWAP_SUPPORT */ +#endif /* ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT)) */ } e_FmPcdManipHdrInsrtType; /**************************************************************************//** @@ -1155,23 +1155,23 @@ typedef enum e_FmPcdManipHdrInsrtSpecificL2 { @Description Enumeration type for selecting QoS mapping mode Note: In all cases except 'e_FM_PCD_MANIP_HDR_QOS_MAPPING_NONE' - User should instruct the port to read the parser-result + User should instruct the port to read the hash-result *//***************************************************************************/ typedef enum e_FmPcdManipHdrQosMappingMode { e_FM_PCD_MANIP_HDR_QOS_MAPPING_NONE = 0, /**< No mapping, QoS field will not be changed */ - e_FM_PCD_MANIP_HDR_QOS_MAPPING_AS_IS, /**< QoS field will be overwritten by the last byte in the parser-result. */ + e_FM_PCD_MANIP_HDR_QOS_MAPPING_AS_IS, /**< QoS field will be overwritten by the last byte in the hash-result. */ } e_FmPcdManipHdrQosMappingMode; /**************************************************************************//** @Description Enumeration type for selecting QoS source Note: In all cases except 'e_FM_PCD_MANIP_HDR_QOS_SRC_NONE' - User should left room for the parser-result on input/output buffer - and instruct the port to read/write the parser-result to the buffer (RPD should be set) + User should left room for the hash-result on input/output buffer + and instruct the port to read/write the hash-result to the buffer (RPD should be set) *//***************************************************************************/ typedef enum e_FmPcdManipHdrQosSrc { e_FM_PCD_MANIP_HDR_QOS_SRC_NONE = 0, /**< TODO */ - e_FM_PCD_MANIP_HDR_QOS_SRC_USER_DEFINED, /**< QoS will be taken from the last byte in the parser-result. */ + e_FM_PCD_MANIP_HDR_QOS_SRC_USER_DEFINED, /**< QoS will be taken from the last byte in the hash-result. */ } e_FmPcdManipHdrQosSrc; #endif /* (DPAA_VERSION >= 11) */ @@ -1193,6 +1193,7 @@ typedef enum e_FmPcdManipHdrInsrtByHdrType { *//***************************************************************************/ typedef enum e_FmPcdManipHdrCustomType { e_FM_PCD_MANIP_HDR_CUSTOM_IP_REPLACE, /**< Replace IPv4/IPv6 */ + e_FM_PCD_MANIP_HDR_CUSTOM_GEN_FIELD_REPLACE, /**< Replace IPv4/IPv6 */ } e_FmPcdManipHdrCustomType; /**************************************************************************//** @@ -1239,14 +1240,14 @@ typedef enum e_FmPcdManipReassemWaysNumber { e_FM_PCD_MANIP_EIGHT_WAYS_HASH /**< Eight ways hash */ } e_FmPcdManipReassemWaysNumber; -#ifdef FM_CAPWAP_SUPPORT +#if ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT)) /**************************************************************************//** @Description Enumeration type for selecting type of statistics mode *//***************************************************************************/ typedef enum e_FmPcdStatsType { e_FM_PCD_STATS_PER_FLOWID = 0 /**< Flow ID is used as index for getting statistics */ } e_FmPcdStatsType; -#endif /* FM_CAPWAP_SUPPORT */ +#endif /* ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT)) */ /**************************************************************************//** @Description Enumeration type for selecting manipulation type @@ -1988,6 +1989,12 @@ typedef struct t_FmPcdHashTableParams { uint8_t matchKeySize; /**< Size of the exact match keys held by the hash buckets */ t_FmPcdCcNextEngineParams ccNextEngineParamsForMiss; /**< Parameters for defining the next engine when a key is not matched */ + + bool agingSupport; /**< TRUE to enable aging support for all keys of this hash table; + Aging status of a key enables the application to monitor if the + key was accessed for a certain period of time, meaning if a + packet that matches this key was received since this bit was last + set by the application */ } t_FmPcdHashTableParams; /**************************************************************************//** @@ -2131,7 +2138,7 @@ typedef struct t_FmManipHdrInfo { t_FmPcdFields fullField; /**< Relevant only when byField = TRUE: Extract field */ } t_FmManipHdrInfo; -#ifdef FM_CAPWAP_SUPPORT +#if ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT)) /**************************************************************************//** @Description Parameters for defining an insertion manipulation of type e_FM_PCD_MANIP_INSRT_TO_START_OF_FRAME_TEMPLATE @@ -2221,8 +2228,8 @@ typedef struct t_FmPcdManipFragOrReasmParams { relevant if 'frag' = FALSE, 'hdr' = HEADER_TYPE_CAPWAP */ } u; } t_FmPcdManipFragOrReasmParams; +#endif /* ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT)) */ -#endif /* FM_CAPWAP_SUPPORT */ /**************************************************************************//** @Description Parameters for defining header removal by header type @@ -2564,6 +2571,24 @@ typedef struct t_FmPcdManipHdrFieldUpdateParams { } u; } t_FmPcdManipHdrFieldUpdateParams; + + +/**************************************************************************//** + @Description Parameters for defining custom header manipulation for generic field replacement +*//***************************************************************************/ +typedef struct t_FmPcdManipHdrCustomGenFieldReplace { + uint8_t srcOffset; /**< Location of new data - Offset from + Parse Result (>= 16, srcOffset+size <= 32, ) */ + uint8_t dstOffset; /**< Location of data to be overwritten - Offset from + start of frame (dstOffset + size <= 256). */ + uint8_t size; /**< The number of bytes (<=16) to be replaced */ + uint8_t mask; /**< Optional 1 byte mask. Set to select bits for + replacement (1 - bit will be replaced); + Clear to use field as is. */ + uint8_t maskOffset; /**< Relevant if mask != 0; + Mask offset within the replaces "size" */ +} t_FmPcdManipHdrCustomGenFieldReplace; + /**************************************************************************//** @Description Parameters for defining custom header manipulation for IP replacement *//***************************************************************************/ @@ -2583,9 +2608,10 @@ typedef struct t_FmPcdManipHdrCustomIpHdrReplace { @Description Parameters for defining custom header manipulation *//***************************************************************************/ typedef struct t_FmPcdManipHdrCustomParams { - e_FmPcdManipHdrCustomType type; /**< Type of header field update manipulation */ + e_FmPcdManipHdrCustomType type; /**< Type of header field update manipulation */ union { - t_FmPcdManipHdrCustomIpHdrReplace ipHdrReplace; /**< Parameters IP header replacement */ + t_FmPcdManipHdrCustomIpHdrReplace ipHdrReplace; /**< Parameters IP header replacement */ + t_FmPcdManipHdrCustomGenFieldReplace genFieldReplace; /**< Parameters IP header replacement */ } u; } t_FmPcdManipHdrCustomParams; @@ -2604,12 +2630,19 @@ typedef struct t_FmPcdManipHdrInsrtSpecificL2Params { @Description Parameters for defining IP insertion manipulation *//***************************************************************************/ typedef struct t_FmPcdManipHdrInsrtIpParams { - bool calcL4Checksum; /**< Calculate L4 checksum. */ - e_FmPcdManipHdrQosMappingMode mappingMode; /**< TODO */ - uint8_t lastPidOffset; /**< the offset of the last Protocol within - the inserted header */ - uint16_t id; /**< 16 bit New IP ID */ - t_FmPcdManipHdrInsrt insrt; /**< size and data to be inserted. */ + bool calcL4Checksum; /**< Calculate L4 checksum. */ + e_FmPcdManipHdrQosMappingMode mappingMode; /**< TODO */ + uint8_t lastPidOffset; /**< the offset of the last Protocol within + the inserted header */ + uint16_t id; /**< 16 bit New IP ID */ + bool dontFragOverwrite; + /**< IPv4 only. DF is overwritten with the hash-result next-to-last byte. + * This byte is configured to be overwritten when RPD is set. */ + uint8_t lastDstOffset; + /**< IPv6 only. if routing extension exist, user should set the offset of the destination address + * in order to calculate UDP checksum pseudo header; + * Otherwise set it to '0'. */ + t_FmPcdManipHdrInsrt insrt; /**< size and data to be inserted. */ } t_FmPcdManipHdrInsrtIpParams; #endif /* (DPAA_VERSION >= 11) */ @@ -2624,7 +2657,7 @@ typedef struct t_FmPcdManipHdrInsrtByHdrParams { /**< Used when type = e_FM_PCD_MANIP_INSRT_BY_HDR_SPECIFIC_L2: Selects which L2 headers to insert */ #if (DPAA_VERSION >= 11) - t_FmPcdManipHdrInsrtIpParams ipParams; /**< Used when type = e_FM_PCD_MANIP_INSRT_BY_HDR_IP */ + t_FmPcdManipHdrInsrtIpParams ipParams; /**< Used when type = e_FM_PCD_MANIP_INSRT_BY_HDR_IP */ t_FmPcdManipHdrInsrt insrt; /**< Used when type is one of e_FM_PCD_MANIP_INSRT_BY_HDR_UDP, e_FM_PCD_MANIP_INSRT_BY_HDR_UDP_LITE, or e_FM_PCD_MANIP_INSRT_BY_HDR_CAPWAP */ @@ -2642,10 +2675,10 @@ typedef struct t_FmPcdManipHdrInsrtParams { relevant if 'type' = e_FM_PCD_MANIP_INSRT_BY_HDR */ t_FmPcdManipHdrInsrtGenericParams generic; /**< Parameters for defining generic header insertion manipulation, relevant if 'type' = e_FM_PCD_MANIP_INSRT_GENERIC */ -#ifdef FM_CAPWAP_SUPPORT +#if ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT)) t_FmPcdManipHdrInsrtByTemplateParams byTemplate; /**< Parameters for defining header insertion manipulation by template, relevant if 'type' = e_FM_PCD_MANIP_INSRT_BY_TEMPLATE */ -#endif /* FM_CAPWAP_SUPPORT */ +#endif /* ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT)) */ } u; } t_FmPcdManipHdrInsrtParams; @@ -2678,8 +2711,14 @@ typedef struct t_FmPcdManipHdrParams { bool custom; /**< TRUE, to define custom manipulation */ t_FmPcdManipHdrCustomParams customParams; /**< Parameters for custom manipulation, relevant if 'custom' = TRUE */ - bool dontParseAfterManip;/**< FALSE to activate the parser a second time after - completing the manipulation on the frame */ + bool dontParseAfterManip;/**< TRUE to de-activate the parser after the manipulation defined in this node. + Restrictions: + 1. MUST be set if the next engine after the CC is not another CC node + (but rather Policer or Keygen), and this is the last (no h_NextManip) in a chain + of manipulation nodes. This includes single nodes (i.e. no h_NextManip and + also never pointed as h_NextManip of other manipulation nodes) + 2. MUST be set if the next engine after the CC is another CC node, and + this is NOT the last manipulation node (i.e. it has h_NextManip).*/ } t_FmPcdManipHdrParams; /**************************************************************************//** @@ -2729,11 +2768,11 @@ typedef struct t_FmPcdManipParams { Handle to another (previously defined) manipulation node; Allows concatenation of manipulation actions; This parameter is optional and may be NULL. */ -#ifdef FM_CAPWAP_SUPPORT +#if ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT)) bool fragOrReasm; /**< TRUE, if defined fragmentation/reassembly manipulation */ t_FmPcdManipFragOrReasmParams fragOrReasmParams; /**< Parameters for fragmentation/reassembly manipulation, relevant if fragOrReasm = TRUE */ -#endif /* FM_CAPWAP_SUPPORT */ +#endif /* ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT)) */ } t_FmPcdManipParams; /**************************************************************************//** @@ -2864,15 +2903,14 @@ typedef struct t_FmPcdFrmReplicGroupParams { } t_FmPcdFrmReplicGroupParams; #endif /* (DPAA_VERSION >= 11) */ -#ifdef FM_CAPWAP_SUPPORT +#if ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT)) /**************************************************************************//** @Description structure for defining statistics node *//***************************************************************************/ typedef struct t_FmPcdStatsParams { e_FmPcdStatsType type; /**< type of statistics node */ } t_FmPcdStatsParams; -#endif /* FM_CAPWAP_SUPPORT */ - +#endif /* ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT)) */ /**************************************************************************//** @Function FM_PCD_NetEnvCharacteristicsSet @@ -3726,6 +3764,77 @@ t_Error FM_PCD_HashTableGetMissStatistics(t_Handle h_HashTbl, t_FmPcdCcKeyStatistics *p_MissStatistics); /**************************************************************************//** +@Function FM_PCD_HashTableGetKeyAging + +@Description This routine may be used to retrieve the aging status for the + provided key. + +@Param[in] h_HashTbl A handle to a hash table +@Param[in] p_Key Pointer to a key +@Param[in] keySize Size of provided key +@Param[in] reset TRUE if the user wishes to reset the aging + status of this key to 1 after reading it; + FALSE otherwise (key aging status will be + read and not changed); +@Param[out] p_KeyAging FALSE if the provided key was accessed since + it's status was last set, TRUE otherwise. + +@Return E_OK on success; Error code otherwise. + +@Cautions Allowed only following FM_PCD_HashTableSet() with aging support + enabled. +*//***************************************************************************/ +t_Error FM_PCD_HashTableGetKeyAging(t_Handle h_HashTbl, + uint8_t *p_Key, + uint8_t keySize, + bool reset, + bool *p_KeyAging); + +/**************************************************************************//** +@Function FM_PCD_HashTableGetBucketAging + +@Description This routine may be used to retrieve the aging status for the + hash table bucket. + +@Param[in] h_HashTbl A handle to a hash table +@Param[in] bucketId Id of the requested bucket +@Param[in] reset TRUE if the user wishes to reset the aging + status of this bucket to all 1-s after reading; + FALSE otherwise (aging mask will be read + and not changed) +@Param[out] p_BucketAgingMask Aging mask of the requested bucket; + A zero bit in the mask means that the key + represented by that bit was accessed since the + bit was last set, otherwise the bit remains + set to 1; + The MSB bit represents the first key in the + bucket, the 2nd MSB bit represents the second + key, etc.. +@Param[out] agedKeysArray If the user will provide a handle to a + preallocated array, this routine will copy + into that array all the keys from the requested + bucket for which the aging status is non-zero, + meaning all the keys that were not accessed since + their aging mask was last set; + The user may set this parameters to NULL to + disable this option + +@Return E_OK on success; Error code otherwise + +@Cautions Allowed only following FM_PCD_HashTableSet() with aging support + Enabled; + If agedKeysArray is provided, it must have 31 entries large enough + to hold the entire keys +*//***************************************************************************/ +t_Error FM_PCD_HashTableGetBucketAging(t_Handle h_HashTbl, + uint16_t bucketId, + bool reset, + uint32_t *p_BucketAgingMask, + uint8_t *agedKeysArray[31]); + + + +/**************************************************************************//** @Function FM_PCD_ManipNodeSet @Description This routine should be called for defining a manipulation @@ -3844,7 +3953,7 @@ t_Error FM_PCD_FrmReplicRemoveMember(t_Handle h_FrmReplicGroup, uint16_t memberIndex); #endif /* (DPAA_VERSION >= 11) */ -#ifdef FM_CAPWAP_SUPPORT +#if ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT)) /**************************************************************************//** @Function FM_PCD_StatisticsSetNode @@ -3858,7 +3967,7 @@ t_Error FM_PCD_FrmReplicRemoveMember(t_Handle h_FrmReplicGroup, @Cautions Allowed only following FM_PCD_Init(). *//***************************************************************************/ t_Handle FM_PCD_StatisticsSetNode(t_Handle h_FmPcd, t_FmPcdStatsParams *p_FmPcdstatsParams); -#endif /* FM_CAPWAP_SUPPORT */ +#endif /* ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT)) */ /** @} */ /* end of FM_PCD_Runtime_build_grp group */ /** @} */ /* end of FM_PCD_Runtime_grp group */ -- cgit v0.10.2