/* * Copyright 2008-2012 Freescale Semiconductor Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of Freescale Semiconductor nor the * names of its contributors may be used to endorse or promote products * derived from this software without specific prior written permission. * * * ALTERNATIVELY, this software may be distributed under the terms of the * GNU General Public License ("GPL") as published by the Free Software * Foundation, either version 2 of that License or (at your option) any * later version. * * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /****************************************************************************** @File fm_pcd.h @Description FM PCD ... *//***************************************************************************/ #ifndef __FM_PCD_H #define __FM_PCD_H #include "std_ext.h" #include "error_ext.h" #include "list_ext.h" #include "fm_pcd_ext.h" #include "fm_common.h" #include "fsl_fman_prs.h" #include "fsl_fman_kg.h" #define __ERR_MODULE__ MODULE_FM_PCD /****************************/ /* Defaults */ /****************************/ #define DEFAULT_plcrAutoRefresh FALSE #define DEFAULT_fmPcdKgErrorExceptions (FM_EX_KG_DOUBLE_ECC | FM_EX_KG_KEYSIZE_OVERFLOW) #define DEFAULT_fmPcdPlcrErrorExceptions (FM_PCD_EX_PLCR_DOUBLE_ECC | FM_PCD_EX_PLCR_INIT_ENTRY_ERROR) #define DEFAULT_fmPcdPlcrExceptions 0 #define DEFAULT_fmPcdPrsErrorExceptions (FM_PCD_EX_PRS_DOUBLE_ECC) #define DEFAULT_fmPcdPrsExceptions FM_PCD_EX_PRS_SINGLE_ECC #define DEFAULT_numOfUsedProfilesPerWindow 16 #define DEFAULT_numOfSharedPlcrProfiles 4 /****************************/ /* Network defines */ /****************************/ #define UDP_HEADER_SIZE 8 #define ESP_SPI_OFFSET 0 #define ESP_SPI_SIZE 4 #define ESP_SEQ_NUM_OFFSET ESP_SPI_SIZE #define ESP_SEQ_NUM_SIZE 4 /****************************/ /* General defines */ /****************************/ #define ILLEGAL_CLS_PLAN 0xff #define ILLEGAL_NETENV 0xff #define FM_PCD_MAX_NUM_OF_ALIAS_HDRS 3 /****************************/ /* Error defines */ /****************************/ #define FM_PCD_EX_PLCR_DOUBLE_ECC 0x20000000 #define FM_PCD_EX_PLCR_INIT_ENTRY_ERROR 0x10000000 #define FM_PCD_EX_PLCR_PRAM_SELF_INIT_COMPLETE 0x08000000 #define FM_PCD_EX_PLCR_ATOMIC_ACTION_COMPLETE 0x04000000 #define GET_FM_PCD_EXCEPTION_FLAG(bitMask, exception) \ switch (exception){ \ case e_FM_PCD_KG_EXCEPTION_DOUBLE_ECC: \ bitMask = FM_EX_KG_DOUBLE_ECC; break; \ case e_FM_PCD_PLCR_EXCEPTION_DOUBLE_ECC: \ bitMask = FM_PCD_EX_PLCR_DOUBLE_ECC; break; \ case e_FM_PCD_KG_EXCEPTION_KEYSIZE_OVERFLOW: \ bitMask = FM_EX_KG_KEYSIZE_OVERFLOW; break; \ case e_FM_PCD_PLCR_EXCEPTION_INIT_ENTRY_ERROR: \ bitMask = FM_PCD_EX_PLCR_INIT_ENTRY_ERROR; break; \ case e_FM_PCD_PLCR_EXCEPTION_PRAM_SELF_INIT_COMPLETE: \ bitMask = FM_PCD_EX_PLCR_PRAM_SELF_INIT_COMPLETE; break; \ case e_FM_PCD_PLCR_EXCEPTION_ATOMIC_ACTION_COMPLETE: \ bitMask = FM_PCD_EX_PLCR_ATOMIC_ACTION_COMPLETE; break; \ case e_FM_PCD_PRS_EXCEPTION_DOUBLE_ECC: \ bitMask = FM_PCD_EX_PRS_DOUBLE_ECC; break; \ case e_FM_PCD_PRS_EXCEPTION_SINGLE_ECC: \ bitMask = FM_PCD_EX_PRS_SINGLE_ECC; break; \ default: bitMask = 0;break;} /***********************************************************************/ /* Policer defines */ /***********************************************************************/ #define FM_PCD_PLCR_GCR_STEN 0x40000000 #define FM_PCD_PLCR_DOUBLE_ECC 0x80000000 #define FM_PCD_PLCR_INIT_ENTRY_ERROR 0x40000000 #define FM_PCD_PLCR_PRAM_SELF_INIT_COMPLETE 0x80000000 #define FM_PCD_PLCR_ATOMIC_ACTION_COMPLETE 0x40000000 /***********************************************************************/ /* Memory map */ /***********************************************************************/ #if defined(__MWERKS__) && !defined(__GNUC__) #pragma pack(push,1) #endif /* defined(__MWERKS__) && ... */ typedef struct { /* General Configuration and Status Registers */ volatile uint32_t fmpl_gcr; /* 0x000 FMPL_GCR - FM Policer General Configuration */ volatile uint32_t fmpl_gsr; /* 0x004 FMPL_GSR - FM Policer Global Status Register */ volatile uint32_t fmpl_evr; /* 0x008 FMPL_EVR - FM Policer Event Register */ volatile uint32_t fmpl_ier; /* 0x00C FMPL_IER - FM Policer Interrupt Enable Register */ volatile uint32_t fmpl_ifr; /* 0x010 FMPL_IFR - FM Policer Interrupt Force Register */ volatile uint32_t fmpl_eevr; /* 0x014 FMPL_EEVR - FM Policer Error Event Register */ volatile uint32_t fmpl_eier; /* 0x018 FMPL_EIER - FM Policer Error Interrupt Enable Register */ volatile uint32_t fmpl_eifr; /* 0x01C FMPL_EIFR - FM Policer Error Interrupt Force Register */ /* Global Statistic Counters */ volatile uint32_t fmpl_rpcnt; /* 0x020 FMPL_RPC - FM Policer RED Packets Counter */ volatile uint32_t fmpl_ypcnt; /* 0x024 FMPL_YPC - FM Policer YELLOW Packets Counter */ volatile uint32_t fmpl_rrpcnt; /* 0x028 FMPL_RRPC - FM Policer Recolored RED Packet Counter */ volatile uint32_t fmpl_rypcnt; /* 0x02C FMPL_RYPC - FM Policer Recolored YELLOW Packet Counter */ volatile uint32_t fmpl_tpcnt; /* 0x030 FMPL_TPC - FM Policer Total Packet Counter */ volatile uint32_t fmpl_flmcnt; /* 0x034 FMPL_FLMC - FM Policer Frame Length Mismatch Counter */ volatile uint32_t fmpl_res0[21]; /* 0x038 - 0x08B Reserved */ /* Profile RAM Access Registers */ volatile uint32_t fmpl_par; /* 0x08C FMPL_PAR - FM Policer Profile Action Register*/ t_FmPcdPlcrProfileRegs profileRegs; /* Error Capture Registers */ volatile uint32_t fmpl_serc; /* 0x100 FMPL_SERC - FM Policer Soft Error Capture */ volatile uint32_t fmpl_upcr; /* 0x104 FMPL_UPCR - FM Policer Uninitialized Profile Capture Register */ volatile uint32_t fmpl_res2; /* 0x108 Reserved */ /* Debug Registers */ volatile uint32_t fmpl_res3[61]; /* 0x10C-0x200 Reserved Debug*/ /* Profile Selection Mapping Registers Per Port-ID (n=1-11, 16) */ volatile uint32_t fmpl_dpmr; /* 0x200 FMPL_DPMR - FM Policer Default Mapping Register */ volatile uint32_t fmpl_pmr[63]; /*+default 0x204-0x2FF FMPL_PMR1 - FMPL_PMR63, - FM Policer Profile Mapping Registers. (for port-ID 1-11, only for supported Port-ID registers) */ } t_FmPcdPlcrRegs; #if defined(__MWERKS__) && !defined(__GNUC__) #pragma pack(pop) #endif /* defined(__MWERKS__) && ... */ /***********************************************************************/ /* Driver's internal structures */ /***********************************************************************/ typedef struct { bool known; uint8_t id; } t_FmPcdKgSchemesExtractsEntry; typedef struct { t_FmPcdKgSchemesExtractsEntry extractsArray[FM_PCD_KG_MAX_NUM_OF_EXTRACTS_PER_KEY]; } t_FmPcdKgSchemesExtracts; typedef struct { t_Handle h_Manip; bool keepRes; e_FmPcdEngine nextEngine; uint8_t parseCode; } t_FmPcdInfoForManip; /**************************************************************************//** @Description A structure of parameters to communicate between the port and PCD regarding the KG scheme. *//***************************************************************************/ typedef struct { uint8_t netEnvId; /* in */ uint8_t numOfDistinctionUnits; /* in */ uint8_t unitIds[FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS]; /* in */ uint32_t vector; /* out */ } t_NetEnvParams; typedef struct { bool allocated; uint8_t ownerId; /* guestId for KG in multi-partition only. portId for PLCR in any environment */ } t_FmPcdAllocMng; typedef struct { volatile bool lock; bool used; uint8_t owners; uint8_t netEnvId; uint8_t guestId; uint8_t baseEntry; uint16_t sizeOfGrp; protocolOpt_t optArray[FM_PCD_MAX_NUM_OF_OPTIONS(FM_PCD_MAX_NUM_OF_CLS_PLANS)]; } t_FmPcdKgClsPlanGrp; typedef struct { t_Handle h_FmPcd; uint8_t schemeId; t_FmPcdLock *p_Lock; bool valid; uint8_t netEnvId; uint8_t owners; uint32_t matchVector; uint32_t ccUnits; bool nextRelativePlcrProfile; uint16_t relativeProfileId; uint16_t numOfProfiles; t_FmPcdKgKeyOrder orderedArray; e_FmPcdEngine nextEngine; e_FmPcdDoneAction doneAction; bool requiredActionFlag; uint32_t requiredAction; bool extractedOrs; uint8_t bitOffsetInPlcrProfile; bool directPlcr; #if (DPAA_VERSION >= 11) bool vspe; #endif } t_FmPcdKgScheme; typedef union { struct fman_kg_scheme_regs schemeRegs; struct fman_kg_pe_regs portRegs; struct fman_kg_cp_regs clsPlanRegs; } u_FmPcdKgIndirectAccessRegs; typedef struct { struct fman_kg_regs *p_FmPcdKgRegs; uint32_t schemeExceptionsBitMask; uint8_t numOfSchemes; t_Handle h_HwSpinlock; uint8_t schemesIds[FM_PCD_KG_NUM_OF_SCHEMES]; t_FmPcdKgScheme schemes[FM_PCD_KG_NUM_OF_SCHEMES]; t_FmPcdKgClsPlanGrp clsPlanGrps[FM_MAX_NUM_OF_PORTS]; uint8_t emptyClsPlanGrpId; t_FmPcdAllocMng schemesMng[FM_PCD_KG_NUM_OF_SCHEMES]; /* only for MASTER ! */ t_FmPcdAllocMng clsPlanBlocksMng[FM_PCD_MAX_NUM_OF_CLS_PLANS/CLS_PLAN_NUM_PER_GRP]; u_FmPcdKgIndirectAccessRegs *p_IndirectAccessRegs; } t_FmPcdKg; typedef struct { uint16_t profilesBase; uint16_t numOfProfiles; t_Handle h_FmPort; } t_FmPcdPlcrMapParam; typedef struct { uint16_t absoluteProfileId; t_Handle h_FmPcd; bool valid; t_FmPcdLock *p_Lock; t_FmPcdAllocMng profilesMng; bool requiredActionFlag; uint32_t requiredAction; e_FmPcdEngine nextEngineOnGreen; /**< Green next engine type */ u_FmPcdPlcrNextEngineParams paramsOnGreen; /**< Green next engine params */ e_FmPcdEngine nextEngineOnYellow; /**< Yellow next engine type */ u_FmPcdPlcrNextEngineParams paramsOnYellow; /**< Yellow next engine params */ e_FmPcdEngine nextEngineOnRed; /**< Red next engine type */ u_FmPcdPlcrNextEngineParams paramsOnRed; /**< Red next engine params */ } t_FmPcdPlcrProfile; typedef struct { t_FmPcdPlcrRegs *p_FmPcdPlcrRegs; uint16_t partPlcrProfilesBase; uint16_t partNumOfPlcrProfiles; t_FmPcdPlcrProfile profiles[FM_PCD_PLCR_NUM_ENTRIES]; uint16_t numOfSharedProfiles; uint16_t sharedProfilesIds[FM_PCD_PLCR_NUM_ENTRIES]; t_FmPcdPlcrMapParam portsMapping[FM_MAX_NUM_OF_PORTS]; t_Handle h_HwSpinlock; t_Handle h_SwSpinlock; } t_FmPcdPlcr; typedef struct { uint32_t *p_SwPrsCode; uint32_t *p_CurrSwPrs; uint8_t currLabel; struct fman_prs_regs *p_FmPcdPrsRegs; t_FmPcdPrsLabelParams labelsTable[FM_PCD_PRS_NUM_OF_LABELS]; uint32_t fmPcdPrsPortIdStatistics; } t_FmPcdPrs; typedef struct { struct { e_NetHeaderType hdr; protocolOpt_t opt; /* only one option !! */ } hdrs[FM_PCD_MAX_NUM_OF_INTERCHANGEABLE_HDRS]; } t_FmPcdIntDistinctionUnit; typedef struct { e_NetHeaderType hdr; protocolOpt_t opt; /* only one option !! */ e_NetHeaderType aliasHdr; } t_FmPcdNetEnvAliases; typedef struct { uint8_t netEnvId; t_Handle h_FmPcd; t_Handle h_Spinlock; bool used; uint8_t owners; uint8_t clsPlanGrpId; t_FmPcdIntDistinctionUnit units[FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS]; uint32_t unitsVectors[FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS]; uint32_t lcvs[FM_PCD_PRS_NUM_OF_HDRS]; uint32_t macsecVector; t_FmPcdNetEnvAliases aliasHdrs[FM_PCD_MAX_NUM_OF_ALIAS_HDRS]; } t_FmPcdNetEnv; typedef struct { struct fman_prs_cfg dfltCfg; bool plcrAutoRefresh; uint16_t prsMaxParseCycleLimit; } t_FmPcdDriverParam; typedef struct { t_Handle h_Fm; t_Handle h_FmMuram; t_FmRevisionInfo fmRevInfo; uint64_t physicalMuramBase; t_Handle h_Spinlock; t_List freeLocksLst; t_List acquiredLocksLst; t_Handle h_IpcSession; /* relevant for guest only */ bool enabled; uint8_t guestId; /**< Guest Partition Id */ uint8_t numOfEnabledGuestPartitionsPcds; char fmPcdModuleName[MODULE_NAME_SIZE]; char fmPcdIpcHandlerModuleName[MODULE_NAME_SIZE]; /* relevant for guest only - this is the master's name */ t_FmPcdNetEnv netEnvs[FM_MAX_NUM_OF_PORTS]; t_FmPcdKg *p_FmPcdKg; t_FmPcdPlcr *p_FmPcdPlcr; t_FmPcdPrs *p_FmPcdPrs; void *p_CcShadow; /**< CC MURAM shadow */ uint32_t ccShadowSize; uint32_t ccShadowAlign; volatile bool shadowLock; t_Handle h_ShadowSpinlock; t_Handle h_Hc; uint32_t exceptions; t_FmPcdExceptionCallback *f_Exception; t_FmPcdIdExceptionCallback *f_FmPcdIndexedException; t_Handle h_App; uintptr_t ipv6FrameIdAddr; uintptr_t capwapFrameIdAddr; bool advancedOffloadSupport; t_FmPcdDriverParam *p_FmPcdDriverParam; } t_FmPcd; #if (DPAA_VERSION >= 11) typedef uint8_t t_FmPcdFrmReplicUpdateType; #define FRM_REPLIC_UPDATE_COUNTER 0x01 #define FRM_REPLIC_UPDATE_INFO 0x02 #endif /* (DPAA_VERSION >= 11) */ /***********************************************************************/ /* PCD internal routines */ /***********************************************************************/ t_Error PcdGetVectorForOpt(t_FmPcd *p_FmPcd, uint8_t netEnvId, protocolOpt_t opt, uint32_t *p_Vector); t_Error PcdGetUnitsVector(t_FmPcd *p_FmPcd, t_NetEnvParams *p_Params); bool PcdNetEnvIsUnitWithoutOpts(t_FmPcd *p_FmPcd, uint8_t netEnvId, uint32_t unitVector); t_Error PcdGetClsPlanGrpParams(t_FmPcd *p_FmPcd, t_FmPcdKgInterModuleClsPlanGrpParams *p_GrpParams); void FmPcdSetClsPlanGrpId(t_FmPcd *p_FmPcd, uint8_t netEnvId, uint8_t clsPlanGrpId); e_NetHeaderType FmPcdGetAliasHdr(t_FmPcd *p_FmPcd, uint8_t netEnvId, e_NetHeaderType hdr); uint8_t FmPcdNetEnvGetUnitIdForSingleHdr(t_FmPcd *p_FmPcd, uint8_t netEnvId, e_NetHeaderType hdr); uint8_t FmPcdNetEnvGetUnitId(t_FmPcd *p_FmPcd, uint8_t netEnvId, e_NetHeaderType hdr, bool interchangeable, protocolOpt_t opt); t_Error FmPcdManipBuildIpReassmScheme(t_FmPcd *p_FmPcd, t_Handle h_NetEnv, t_Handle h_CcTree, t_Handle h_Manip, bool isIpv4, uint8_t groupId); t_Error FmPcdManipDeleteIpReassmSchemes(t_Handle h_Manip); t_Error FmPcdManipBuildCapwapReassmScheme(t_FmPcd *p_FmPcd, t_Handle h_NetEnv, t_Handle h_CcTree, t_Handle h_Manip, uint8_t groupId); t_Error FmPcdManipDeleteCapwapReassmSchemes(t_Handle h_Manip); bool FmPcdManipIpReassmIsIpv6Hdr(t_Handle h_Manip); t_Handle KgConfig( t_FmPcd *p_FmPcd, t_FmPcdParams *p_FmPcdParams); t_Error KgInit(t_FmPcd *p_FmPcd); t_Error KgFree(t_FmPcd *p_FmPcd); void KgSetClsPlan(t_Handle h_FmPcd, t_FmPcdKgInterModuleClsPlanSet *p_Set); bool KgIsSchemeAlwaysDirect(t_Handle h_FmPcd, uint8_t schemeId); void KgEnable(t_FmPcd *p_FmPcd); void KgDisable(t_FmPcd *p_FmPcd); t_Error KgAllocClsPlanEntries(t_Handle h_FmPcd, uint16_t numOfClsPlanEntries, uint8_t guestId, uint8_t *p_First); void KgFreeClsPlanEntries(t_Handle h_FmPcd, uint16_t numOfClsPlanEntries, uint8_t guestId, uint8_t base); /* only for MULTI partittion */ t_Error FmPcdKgAllocSchemes(t_Handle h_FmPcd, uint8_t numOfSchemes, uint8_t guestId, uint8_t *p_SchemesIds); t_Error FmPcdKgFreeSchemes(t_Handle h_FmPcd, uint8_t numOfSchemes, uint8_t guestId, uint8_t *p_SchemesIds); /* only for SINGLE partittion */ t_Error KgBindPortToSchemes(t_Handle h_FmPcd , uint8_t hardwarePortId, uint32_t spReg); t_FmPcdLock *FmPcdAcquireLock(t_Handle h_FmPcd); void FmPcdReleaseLock(t_Handle h_FmPcd, t_FmPcdLock *p_Lock); t_Handle PlcrConfig(t_FmPcd *p_FmPcd, t_FmPcdParams *p_FmPcdParams); t_Error PlcrInit(t_FmPcd *p_FmPcd); t_Error PlcrFree(t_FmPcd *p_FmPcd); void PlcrEnable(t_FmPcd *p_FmPcd); void PlcrDisable(t_FmPcd *p_FmPcd); uint16_t PlcrAllocProfilesForPartition(t_FmPcd *p_FmPcd, uint16_t base, uint16_t numOfProfiles, uint8_t guestId); void PlcrFreeProfilesForPartition(t_FmPcd *p_FmPcd, uint16_t base, uint16_t numOfProfiles, uint8_t guestId); t_Error PlcrSetPortProfiles(t_FmPcd *p_FmPcd, uint8_t hardwarePortId, uint16_t numOfProfiles, uint16_t base); t_Error PlcrClearPortProfiles(t_FmPcd *p_FmPcd, uint8_t hardwarePortId); t_Handle PrsConfig(t_FmPcd *p_FmPcd,t_FmPcdParams *p_FmPcdParams); t_Error PrsInit(t_FmPcd *p_FmPcd); void PrsEnable(t_FmPcd *p_FmPcd); void PrsDisable(t_FmPcd *p_FmPcd); void PrsFree(t_FmPcd *p_FmPcd ); t_Error PrsIncludePortInStatistics(t_FmPcd *p_FmPcd, uint8_t hardwarePortId, bool include); t_Error FmPcdCcGetGrpParams(t_Handle treeId, uint8_t grpId, uint32_t *p_GrpBits, uint8_t *p_GrpBase); uint8_t FmPcdCcGetOffset(t_Handle h_CcNode); uint8_t FmPcdCcGetParseCode(t_Handle h_CcNode); uint16_t FmPcdCcGetNumOfKeys(t_Handle h_CcNode); t_Error ValidateNextEngineParams(t_Handle h_FmPcd, t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams, e_FmPcdCcStatsMode supportedStatsMode); void FmPcdManipUpdateOwner(t_Handle h_Manip, bool add); t_Error FmPcdManipCheckParamsForCcNextEngine(t_FmPcdCcNextEngineParams *p_InfoForManip, uint32_t *requiredAction); void FmPcdManipUpdateAdResultForCc(t_Handle h_Manip, t_FmPcdCcNextEngineParams *p_CcNextEngineParams, t_Handle p_Ad, t_Handle *p_AdNewPtr); void FmPcdManipUpdateAdContLookupForCc(t_Handle h_Manip, t_Handle p_Ad, t_Handle *p_AdNew, uint32_t adTableOffset); void FmPcdManipUpdateOwner(t_Handle h_Manip, bool add); t_Error FmPcdManipCheckParamsWithCcNodeParams(t_Handle h_Manip, t_Handle h_FmPcdCcNode); #ifdef FM_CAPWAP_SUPPORT t_Handle FmPcdManipApplSpecificBuild(void); bool FmPcdManipIsCapwapApplSpecific(t_Handle h_Manip); #endif /* FM_CAPWAP_SUPPORT */ #if (DPAA_VERSION >= 11) void * FrmReplicGroupGetSourceTableDescriptor(t_Handle h_ReplicGroup); void FrmReplicGroupUpdateOwner(t_Handle h_ReplicGroup, bool add); void FrmReplicGroupUpdateAd(t_Handle h_ReplicGroup, void *p_Ad, t_Handle *h_AdNew); void FmPcdCcGetAdTablesThatPointOnReplicGroup(t_Handle h_Node, t_Handle h_ReplicGroup, t_List *p_AdTables, uint32_t *p_NumOfAdTables); #endif /* (DPAA_VERSION >= 11) */ void EnqueueNodeInfoToRelevantLst(t_List *p_List, t_CcNodeInformation *p_CcInfo, t_Handle h_Spinlock); void DequeueNodeInfoFromRelevantLst(t_List *p_List, t_Handle h_Info, t_Handle h_Spinlock); t_CcNodeInformation* FindNodeInfoInReleventLst(t_List *p_List, t_Handle h_Info, t_Handle h_Spinlock); t_List *FmPcdManipGetSpinlock(t_Handle h_Manip); t_List *FmPcdManipGetNodeLstPointedOnThisManip(t_Handle h_Manip); typedef struct { t_Handle h_StatsAd; t_Handle h_StatsCounters; #if (DPAA_VERSION >= 11) t_Handle h_StatsFLRs; #endif /* (DPAA_VERSION >= 11) */ } t_FmPcdCcStatsParams; void NextStepAd(t_Handle h_Ad, t_FmPcdCcStatsParams *p_FmPcdCcStatsParams, t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams, t_FmPcd *p_FmPcd); void ReleaseLst(t_List *p_List); static __inline__ t_Handle FmPcdGetMuramHandle(t_Handle h_FmPcd) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; ASSERT_COND(p_FmPcd); return p_FmPcd->h_FmMuram; } static __inline__ uint64_t FmPcdGetMuramPhysBase(t_Handle h_FmPcd) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; ASSERT_COND(p_FmPcd); return p_FmPcd->physicalMuramBase; } static __inline__ uint32_t FmPcdLockSpinlock(t_FmPcdLock *p_Lock) { ASSERT_COND(p_Lock); return XX_LockIntrSpinlock(p_Lock->h_Spinlock); } static __inline__ void FmPcdUnlockSpinlock(t_FmPcdLock *p_Lock, uint32_t flags) { ASSERT_COND(p_Lock); XX_UnlockIntrSpinlock(p_Lock->h_Spinlock, flags); } static __inline__ bool FmPcdLockTryLock(t_FmPcdLock *p_Lock) { uint32_t intFlags; ASSERT_COND(p_Lock); intFlags = XX_LockIntrSpinlock(p_Lock->h_Spinlock); if (p_Lock->flag) { XX_UnlockIntrSpinlock(p_Lock->h_Spinlock, intFlags); return FALSE; } p_Lock->flag = TRUE; XX_UnlockIntrSpinlock(p_Lock->h_Spinlock, intFlags); return TRUE; } static __inline__ void FmPcdLockUnlock(t_FmPcdLock *p_Lock) { ASSERT_COND(p_Lock); p_Lock->flag = FALSE; } #endif /* __FM_PCD_H */