/* * 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. */ #include "std_ext.h" #include "error_ext.h" #include "sprint_ext.h" #include "string_ext.h" #include "fm_common.h" #include "fm_hc.h" /**************************************************************************//** @Description defaults *//***************************************************************************/ #define DEFAULT_dataMemId 0 #define HC_HCOR_OPCODE_PLCR_PRFL 0x0 #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_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 #define HC_HCOR_KG_SCHEME_COUNTER 0x00000400 #if (DPAA_VERSION == 10) #define HC_HCOR_KG_SCHEME_REGS_MASK 0xFFFFF800 #else #define HC_HCOR_KG_SCHEME_REGS_MASK 0xFFFFFE00 #endif /* (DPAA_VERSION == 10) */ #define SIZE_OF_HC_FRAME_PORT_REGS (sizeof(t_HcFrame)-sizeof(struct fman_kg_scheme_regs)+sizeof(t_FmPcdKgPortRegs)) #define SIZE_OF_HC_FRAME_SCHEME_REGS sizeof(t_HcFrame) #define SIZE_OF_HC_FRAME_PROFILES_REGS (sizeof(t_HcFrame)-sizeof(struct fman_kg_scheme_regs)+sizeof(t_FmPcdPlcrProfileRegs)) #define SIZE_OF_HC_FRAME_PROFILE_CNT (sizeof(t_HcFrame)-sizeof(t_FmPcdPlcrProfileRegs)+sizeof(uint32_t)) #define SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC 16 #define HC_CMD_POOL_SIZE (INTG_MAX_NUM_OF_CORES) #define BUILD_FD(len) \ do { \ memset(&fmFd, 0, sizeof(t_DpaaFD)); \ DPAA_FD_SET_ADDR(&fmFd, p_HcFrame); \ DPAA_FD_SET_OFFSET(&fmFd, 0); \ DPAA_FD_SET_LENGTH(&fmFd, len); \ } while (0) #if defined(__MWERKS__) && !defined(__GNUC__) #pragma pack(push,1) #endif /* defined(__MWERKS__) && ... */ typedef struct t_FmPcdKgPortRegs { volatile uint32_t spReg; volatile uint32_t cppReg; } t_FmPcdKgPortRegs; typedef struct t_HcFrame { volatile uint32_t opcode; volatile uint32_t actionReg; volatile uint32_t extraReg; volatile uint32_t commandSequence; union { struct fman_kg_scheme_regs schemeRegs; struct fman_kg_scheme_regs schemeRegsWithoutCounter; t_FmPcdPlcrProfileRegs profileRegs; volatile uint32_t singleRegForWrite; /* for writing SP, CPP, profile counter */ t_FmPcdKgPortRegs portRegsForRead; volatile uint32_t clsPlanEntries[CLS_PLAN_NUM_PER_GRP]; t_FmPcdCcCapwapReassmTimeoutParams ccCapwapReassmTimeout; t_FmPcdCcReassmTimeoutParams ccReassmTimeout; } hcSpecificData; } t_HcFrame; #if defined(__MWERKS__) && !defined(__GNUC__) #pragma pack(pop) #endif /* defined(__MWERKS__) && ... */ typedef struct t_FmHc { t_Handle h_FmPcd; t_Handle h_HcPortDev; t_FmPcdQmEnqueueCallback *f_QmEnqueue; /**< A callback for enqueuing frames to the QM */ t_Handle h_QmArg; /**< A handle to the QM module */ uint8_t dataMemId; /**< Memory partition ID for data buffers */ uint32_t seqNum[HC_CMD_POOL_SIZE]; /* FIFO of seqNum to use when taking buffer */ uint32_t nextSeqNumLocation; /* seqNum location in seqNum[] for next buffer */ volatile bool enqueued[HC_CMD_POOL_SIZE]; /* HC is active - frame is enqueued and not confirmed yet */ t_HcFrame *p_Frm[HC_CMD_POOL_SIZE]; } t_FmHc; static t_Error FillBufPool(t_FmHc *p_FmHc) { uint32_t i; ASSERT_COND(p_FmHc); for (i = 0; i < HC_CMD_POOL_SIZE; i++) { #ifdef FM_LOCKUP_ALIGNMENT_ERRATA_FMAN_SW004 p_FmHc->p_Frm[i] = (t_HcFrame *)XX_MallocSmart((sizeof(t_HcFrame) + (16 - (sizeof(t_FmHc) % 16))), p_FmHc->dataMemId, 16); #else p_FmHc->p_Frm[i] = (t_HcFrame *)XX_MallocSmart(sizeof(t_HcFrame), p_FmHc->dataMemId, 16); #endif /* FM_LOCKUP_ALIGNMENT_ERRATA_FMAN_SW004 */ if (!p_FmHc->p_Frm[i]) RETURN_ERROR(MAJOR, E_NO_MEMORY, ("FM HC frames!")); } /* Initialize FIFO of seqNum to use during GetBuf */ for (i = 0; i < HC_CMD_POOL_SIZE; i++) { p_FmHc->seqNum[i] = i; } p_FmHc->nextSeqNumLocation = 0; return E_OK; } static __inline__ t_HcFrame * GetBuf(t_FmHc *p_FmHc, uint32_t *p_SeqNum) { uint32_t intFlags; ASSERT_COND(p_FmHc); intFlags = FmPcdLock(p_FmHc->h_FmPcd); if (p_FmHc->nextSeqNumLocation == HC_CMD_POOL_SIZE) { /* No more buffers */ FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); return NULL; } *p_SeqNum = p_FmHc->seqNum[p_FmHc->nextSeqNumLocation]; p_FmHc->nextSeqNumLocation++; FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); return p_FmHc->p_Frm[*p_SeqNum]; } static __inline__ void PutBuf(t_FmHc *p_FmHc, t_HcFrame *p_Buf, uint32_t seqNum) { uint32_t intFlags; UNUSED(p_Buf); intFlags = FmPcdLock(p_FmHc->h_FmPcd); ASSERT_COND(p_FmHc->nextSeqNumLocation); p_FmHc->nextSeqNumLocation--; p_FmHc->seqNum[p_FmHc->nextSeqNumLocation] = seqNum; FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); } static __inline__ t_Error EnQFrm(t_FmHc *p_FmHc, t_DpaaFD *p_FmFd, uint32_t seqNum) { t_Error err = E_OK; uint32_t intFlags; uint32_t timeout=100; intFlags = FmPcdLock(p_FmHc->h_FmPcd); ASSERT_COND(!p_FmHc->enqueued[seqNum]); p_FmHc->enqueued[seqNum] = TRUE; FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); DBG(TRACE, ("Send Hc, SeqNum %d, buff@0x%x, fd offset 0x%x", seqNum, DPAA_FD_GET_ADDR(p_FmFd), DPAA_FD_GET_OFFSET(p_FmFd))); err = p_FmHc->f_QmEnqueue(p_FmHc->h_QmArg, (void *)p_FmFd); if (err) RETURN_ERROR(MINOR, err, ("HC enqueue failed")); while (p_FmHc->enqueued[seqNum] && --timeout) XX_UDelay(100); if (!timeout) RETURN_ERROR(MINOR, E_TIMEOUT, ("HC Callback, timeout exceeded")); return err; } t_Handle FmHcConfigAndInit(t_FmHcParams *p_FmHcParams) { t_FmHc *p_FmHc; t_FmPortParams fmPortParam; t_Error err; p_FmHc = (t_FmHc *)XX_Malloc(sizeof(t_FmHc)); if (!p_FmHc) { REPORT_ERROR(MINOR, E_NO_MEMORY, ("HC obj")); return NULL; } memset(p_FmHc,0,sizeof(t_FmHc)); p_FmHc->h_FmPcd = p_FmHcParams->h_FmPcd; p_FmHc->f_QmEnqueue = p_FmHcParams->params.f_QmEnqueue; p_FmHc->h_QmArg = p_FmHcParams->params.h_QmArg; p_FmHc->dataMemId = DEFAULT_dataMemId; err = FillBufPool(p_FmHc); if (err != E_OK) { REPORT_ERROR(MAJOR, err, NO_MSG); FmHcFree(p_FmHc); return NULL; } if (!FmIsMaster(p_FmHcParams->h_Fm)) return (t_Handle)p_FmHc; memset(&fmPortParam, 0, sizeof(fmPortParam)); fmPortParam.baseAddr = p_FmHcParams->params.portBaseAddr; fmPortParam.portType = e_FM_PORT_TYPE_OH_HOST_COMMAND; fmPortParam.portId = p_FmHcParams->params.portId; fmPortParam.liodnBase = p_FmHcParams->params.liodnBase; fmPortParam.h_Fm = p_FmHcParams->h_Fm; fmPortParam.specificParams.nonRxParams.errFqid = p_FmHcParams->params.errFqid; fmPortParam.specificParams.nonRxParams.dfltFqid = p_FmHcParams->params.confFqid; fmPortParam.specificParams.nonRxParams.qmChannel = p_FmHcParams->params.qmChannel; p_FmHc->h_HcPortDev = FM_PORT_Config(&fmPortParam); if (!p_FmHc->h_HcPortDev) { REPORT_ERROR(MAJOR, E_INVALID_HANDLE, ("FM HC port!")); XX_Free(p_FmHc); return NULL; } 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!")); FmHcFree(p_FmHc); return NULL; } /* final init */ err = FM_PORT_Init(p_FmHc->h_HcPortDev); if (err != E_OK) { REPORT_ERROR(MAJOR, err, ("FM HC port init!")); FmHcFree(p_FmHc); return NULL; } err = FM_PORT_Enable(p_FmHc->h_HcPortDev); if (err != E_OK) { REPORT_ERROR(MAJOR, err, ("FM HC port enable!")); FmHcFree(p_FmHc); return NULL; } return (t_Handle)p_FmHc; } void FmHcFree(t_Handle h_FmHc) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; int i; if (!p_FmHc) return; for (i=0; ip_Frm[i]) XX_FreeSmart(p_FmHc->p_Frm[i]); else break; if (p_FmHc->h_HcPortDev) FM_PORT_Free(p_FmHc->h_HcPortDev); XX_Free(p_FmHc); } /*****************************************************************************/ t_Error FmHcSetFramesDataMemory(t_Handle h_FmHc, uint8_t memId) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; int i; SANITY_CHECK_RETURN_ERROR(p_FmHc, E_INVALID_HANDLE); p_FmHc->dataMemId = memId; for (i=0; ip_Frm[i]) XX_FreeSmart(p_FmHc->p_Frm[i]); return FillBufPool(p_FmHc); } void FmHcTxConf(t_Handle h_FmHc, t_DpaaFD *p_Fd) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; t_HcFrame *p_HcFrame; uint32_t intFlags; ASSERT_COND(p_FmHc); intFlags = FmPcdLock(p_FmHc->h_FmPcd); p_HcFrame = (t_HcFrame *)PTR_MOVE(DPAA_FD_GET_ADDR(p_Fd), DPAA_FD_GET_OFFSET(p_Fd)); DBG(TRACE, ("Hc Conf, SeqNum %d, FD@0x%x, fd offset 0x%x", p_HcFrame->commandSequence, DPAA_FD_GET_ADDR(p_Fd), DPAA_FD_GET_OFFSET(p_Fd))); if (!(p_FmHc->enqueued[p_HcFrame->commandSequence])) REPORT_ERROR(MINOR, E_INVALID_FRAME, ("Not an Host-Command frame received!")); else p_FmHc->enqueued[p_HcFrame->commandSequence] = FALSE; FmPcdUnlock(p_FmHc->h_FmPcd, intFlags); } t_Error FmHcPcdKgSetScheme(t_Handle h_FmHc, t_Handle h_Scheme, struct fman_kg_scheme_regs *p_SchemeRegs, bool updateCounter) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; t_Error err = E_OK; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; uint8_t physicalSchemeId; uint32_t seqNum; p_HcFrame = GetBuf(p_FmHc, &seqNum); if (!p_HcFrame) RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame object")); physicalSchemeId = FmPcdKgGetSchemeId(h_Scheme); memset(p_HcFrame, 0, sizeof(t_HcFrame)); p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); p_HcFrame->actionReg = FmPcdKgBuildWriteSchemeActionReg(physicalSchemeId, updateCounter); p_HcFrame->extraReg = HC_HCOR_KG_SCHEME_REGS_MASK; memcpy(&p_HcFrame->hcSpecificData.schemeRegs, p_SchemeRegs, sizeof(struct fman_kg_scheme_regs)); if (!updateCounter) { p_HcFrame->hcSpecificData.schemeRegs.kgse_dv0 = p_SchemeRegs->kgse_dv0; p_HcFrame->hcSpecificData.schemeRegs.kgse_dv1 = p_SchemeRegs->kgse_dv1; p_HcFrame->hcSpecificData.schemeRegs.kgse_ccbs = p_SchemeRegs->kgse_ccbs; p_HcFrame->hcSpecificData.schemeRegs.kgse_mv = p_SchemeRegs->kgse_mv; } p_HcFrame->commandSequence = seqNum; BUILD_FD(sizeof(t_HcFrame)); err = EnQFrm(p_FmHc, &fmFd, seqNum); PutBuf(p_FmHc, p_HcFrame, seqNum); if (err != E_OK) RETURN_ERROR(MINOR, err, NO_MSG); return E_OK; } t_Error FmHcPcdKgDeleteScheme(t_Handle h_FmHc, t_Handle h_Scheme) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; t_Error err = E_OK; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; uint8_t physicalSchemeId = FmPcdKgGetSchemeId(h_Scheme); uint32_t seqNum; 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_KG_SCM); p_HcFrame->actionReg = FmPcdKgBuildWriteSchemeActionReg(physicalSchemeId, TRUE); p_HcFrame->extraReg = HC_HCOR_KG_SCHEME_REGS_MASK; memset(&p_HcFrame->hcSpecificData.schemeRegs, 0, sizeof(struct fman_kg_scheme_regs)); p_HcFrame->commandSequence = seqNum; BUILD_FD(sizeof(t_HcFrame)); err = EnQFrm(p_FmHc, &fmFd, seqNum); PutBuf(p_FmHc, p_HcFrame, seqNum); if (err != E_OK) RETURN_ERROR(MINOR, err, NO_MSG); return E_OK; } t_Error FmHcPcdKgCcGetSetParams(t_Handle h_FmHc, t_Handle h_Scheme, uint32_t requiredAction, uint32_t value) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; t_Error err = E_OK; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; uint8_t relativeSchemeId; uint8_t physicalSchemeId = FmPcdKgGetSchemeId(h_Scheme); uint32_t tmpReg32 = 0; uint32_t seqNum; /* Scheme is locked by calling routine */ /* WARNING - this lock will not be efficient if other HC routine will attempt to change * "kgse_mode" or "kgse_om" without locking scheme ! */ relativeSchemeId = FmPcdKgGetRelativeSchemeId(p_FmHc->h_FmPcd, physicalSchemeId); if ( relativeSchemeId == FM_PCD_KG_NUM_OF_SCHEMES) RETURN_ERROR(MAJOR, E_NOT_IN_RANGE, NO_MSG); if (!FmPcdKgGetRequiredActionFlag(p_FmHc->h_FmPcd, relativeSchemeId) || !(FmPcdKgGetRequiredAction(p_FmHc->h_FmPcd, relativeSchemeId) & requiredAction)) { if ((requiredAction & UPDATE_NIA_ENQ_WITHOUT_DMA) && (FmPcdKgGetNextEngine(p_FmHc->h_FmPcd, relativeSchemeId) == e_FM_PCD_PLCR)) { if ((FmPcdKgIsDirectPlcr(p_FmHc->h_FmPcd, relativeSchemeId) == FALSE) || (FmPcdKgIsDistrOnPlcrProfile(p_FmHc->h_FmPcd, relativeSchemeId) == TRUE)) RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("In this situation PP can not be with distribution and has to be shared")); err = FmPcdPlcrCcGetSetParams(p_FmHc->h_FmPcd, FmPcdKgGetRelativeProfileId(p_FmHc->h_FmPcd, relativeSchemeId), requiredAction); if (err) RETURN_ERROR(MAJOR, err, NO_MSG); } else /* From here we deal with KG-Schemes only */ { /* Pre change general code */ 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_KG_SCM); p_HcFrame->actionReg = FmPcdKgBuildReadSchemeActionReg(physicalSchemeId); p_HcFrame->extraReg = HC_HCOR_KG_SCHEME_REGS_MASK; p_HcFrame->commandSequence = seqNum; BUILD_FD(SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC); if ((err = EnQFrm(p_FmHc, &fmFd, seqNum)) != E_OK) { PutBuf(p_FmHc, p_HcFrame, seqNum); RETURN_ERROR(MINOR, err, NO_MSG); } /* specific change */ if ((requiredAction & UPDATE_NIA_ENQ_WITHOUT_DMA) && ((FmPcdKgGetNextEngine(p_FmHc->h_FmPcd, relativeSchemeId) == e_FM_PCD_DONE) && (FmPcdKgGetDoneAction(p_FmHc->h_FmPcd, relativeSchemeId) == e_FM_PCD_ENQ_FRAME))) { tmpReg32 = p_HcFrame->hcSpecificData.schemeRegs.kgse_mode; ASSERT_COND(tmpReg32 & (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME)); p_HcFrame->hcSpecificData.schemeRegs.kgse_mode = tmpReg32 | NIA_BMI_AC_ENQ_FRAME_WITHOUT_DMA; } if ((requiredAction & UPDATE_KG_NIA_CC_WA) && (FmPcdKgGetNextEngine(p_FmHc->h_FmPcd, relativeSchemeId) == e_FM_PCD_CC)) { tmpReg32 = p_HcFrame->hcSpecificData.schemeRegs.kgse_mode; ASSERT_COND(tmpReg32 & (NIA_ENG_FM_CTL | NIA_FM_CTL_AC_CC)); tmpReg32 &= ~NIA_FM_CTL_AC_CC; p_HcFrame->hcSpecificData.schemeRegs.kgse_mode = tmpReg32 | NIA_FM_CTL_AC_PRE_CC; } if (requiredAction & UPDATE_KG_OPT_MODE) p_HcFrame->hcSpecificData.schemeRegs.kgse_om = value; if (requiredAction & UPDATE_KG_NIA) { tmpReg32 = p_HcFrame->hcSpecificData.schemeRegs.kgse_mode; tmpReg32 &= ~(NIA_ENG_MASK | NIA_AC_MASK); tmpReg32 |= value; p_HcFrame->hcSpecificData.schemeRegs.kgse_mode = tmpReg32; } /* Post change general code */ p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); p_HcFrame->actionReg = FmPcdKgBuildWriteSchemeActionReg(physicalSchemeId, FALSE); p_HcFrame->extraReg = HC_HCOR_KG_SCHEME_REGS_MASK; BUILD_FD(sizeof(t_HcFrame)); err = EnQFrm(p_FmHc, &fmFd, seqNum); PutBuf(p_FmHc, p_HcFrame, seqNum); if (err != E_OK) RETURN_ERROR(MINOR, err, NO_MSG); } } return E_OK; } uint32_t FmHcPcdKgGetSchemeCounter(t_Handle h_FmHc, t_Handle h_Scheme) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; t_Error err; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; uint32_t retVal; uint8_t relativeSchemeId; uint8_t physicalSchemeId = FmPcdKgGetSchemeId(h_Scheme); uint32_t seqNum; relativeSchemeId = FmPcdKgGetRelativeSchemeId(p_FmHc->h_FmPcd, physicalSchemeId); if ( relativeSchemeId == FM_PCD_KG_NUM_OF_SCHEMES) { REPORT_ERROR(MAJOR, E_NOT_IN_RANGE, NO_MSG); return 0; } /* first read scheme and check that it is valid */ p_HcFrame = GetBuf(p_FmHc, &seqNum); if (!p_HcFrame) { REPORT_ERROR(MINOR, E_NO_MEMORY, ("HC Frame object")); return 0; } memset(p_HcFrame, 0, sizeof(t_HcFrame)); p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); p_HcFrame->actionReg = FmPcdKgBuildReadSchemeActionReg(physicalSchemeId); p_HcFrame->extraReg = HC_HCOR_KG_SCHEME_REGS_MASK; p_HcFrame->commandSequence = seqNum; BUILD_FD(SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC); err = EnQFrm(p_FmHc, &fmFd, seqNum); if (err != E_OK) { PutBuf(p_FmHc, p_HcFrame, seqNum); REPORT_ERROR(MINOR, err, NO_MSG); return 0; } if (!FmPcdKgHwSchemeIsValid(p_HcFrame->hcSpecificData.schemeRegs.kgse_mode)) { PutBuf(p_FmHc, p_HcFrame, seqNum); REPORT_ERROR(MAJOR, E_ALREADY_EXISTS, ("Scheme is invalid")); return 0; } retVal = p_HcFrame->hcSpecificData.schemeRegs.kgse_spc; PutBuf(p_FmHc, p_HcFrame, seqNum); return retVal; } t_Error FmHcPcdKgSetSchemeCounter(t_Handle h_FmHc, t_Handle h_Scheme, uint32_t value) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; t_Error err = E_OK; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; uint8_t relativeSchemeId, physicalSchemeId; uint32_t seqNum; physicalSchemeId = FmPcdKgGetSchemeId(h_Scheme); relativeSchemeId = FmPcdKgGetRelativeSchemeId(p_FmHc->h_FmPcd, physicalSchemeId); if ( relativeSchemeId == FM_PCD_KG_NUM_OF_SCHEMES) RETURN_ERROR(MAJOR, E_NOT_IN_RANGE, NO_MSG); /* first read scheme and check that it is valid */ 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_KG_SCM); p_HcFrame->actionReg = FmPcdKgBuildWriteSchemeActionReg(physicalSchemeId, TRUE); p_HcFrame->extraReg = HC_HCOR_KG_SCHEME_COUNTER; /* write counter */ p_HcFrame->hcSpecificData.singleRegForWrite = value; p_HcFrame->commandSequence = seqNum; BUILD_FD(sizeof(t_HcFrame)); err = EnQFrm(p_FmHc, &fmFd, seqNum); PutBuf(p_FmHc, p_HcFrame, seqNum); return err; } t_Error FmHcPcdKgSetClsPlan(t_Handle h_FmHc, t_FmPcdKgInterModuleClsPlanSet *p_Set) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; uint8_t i, idx; uint32_t seqNum; t_Error err = E_OK; ASSERT_COND(p_FmHc); p_HcFrame = GetBuf(p_FmHc, &seqNum); if (!p_HcFrame) RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame object")); for (i = p_Set->baseEntry; i < (p_Set->baseEntry+p_Set->numOfClsPlanEntries); i+=8) { memset(p_HcFrame, 0, sizeof(t_HcFrame)); 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; idx = (uint8_t)(i - p_Set->baseEntry); memcpy(__DEVOLATILE(uint32_t *, &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)); if ((err = EnQFrm(p_FmHc, &fmFd, seqNum)) != E_OK) { PutBuf(p_FmHc, p_HcFrame, seqNum); RETURN_ERROR(MINOR, err, NO_MSG); } } PutBuf(p_FmHc, p_HcFrame, seqNum); return err; } t_Error FmHcPcdKgDeleteClsPlan(t_Handle h_FmHc, uint8_t grpId) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; t_FmPcdKgInterModuleClsPlanSet *p_ClsPlanSet; p_ClsPlanSet = (t_FmPcdKgInterModuleClsPlanSet *)XX_Malloc(sizeof(t_FmPcdKgInterModuleClsPlanSet)); if (!p_ClsPlanSet) RETURN_ERROR(MAJOR, E_NO_MEMORY, ("Classification plan set")); memset(p_ClsPlanSet, 0, sizeof(t_FmPcdKgInterModuleClsPlanSet)); p_ClsPlanSet->baseEntry = FmPcdKgGetClsPlanGrpBase(p_FmHc->h_FmPcd, grpId); p_ClsPlanSet->numOfClsPlanEntries = FmPcdKgGetClsPlanGrpSize(p_FmHc->h_FmPcd, grpId); ASSERT_COND(p_ClsPlanSet->numOfClsPlanEntries <= FM_PCD_MAX_NUM_OF_CLS_PLANS); if (FmHcPcdKgSetClsPlan(p_FmHc, p_ClsPlanSet) != E_OK) { XX_Free(p_ClsPlanSet); RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); } XX_Free(p_ClsPlanSet); FmPcdKgDestroyClsPlanGrp(p_FmHc->h_FmPcd, grpId); return E_OK; } t_Error FmHcPcdCcCapwapTimeoutReassm(t_Handle h_FmHc, t_FmPcdCcCapwapReassmTimeoutParams *p_CcCapwapReassmTimeoutParams ) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; t_Error err; uint32_t seqNum; SANITY_CHECK_RETURN_VALUE(h_FmHc, E_INVALID_HANDLE,0); 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_CAPWAP_REASSM_TIMEOUT); memcpy(&p_HcFrame->hcSpecificData.ccCapwapReassmTimeout, p_CcCapwapReassmTimeoutParams, sizeof(t_FmPcdCcCapwapReassmTimeoutParams)); p_HcFrame->commandSequence = seqNum; BUILD_FD(sizeof(t_HcFrame)); err = EnQFrm(p_FmHc, &fmFd, seqNum); PutBuf(p_FmHc, p_HcFrame, seqNum); return err; } t_Error FmHcPcdCcIpFragScratchPollCmd(t_Handle h_FmHc, bool fill, t_FmPcdCcFragScratchPoolCmdParams *p_FmPcdCcFragScratchPoolCmdParams) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; t_Error err; uint32_t seqNum; SANITY_CHECK_RETURN_VALUE(h_FmHc, E_INVALID_HANDLE,0); 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_IP_FRAG_INITIALIZATION); p_HcFrame->actionReg = (uint32_t)(((fill == TRUE) ? 0 : 1) << HC_HCOR_ACTION_REG_IP_FRAG_SCRATCH_POOL_CMD_SHIFT); p_HcFrame->actionReg |= p_FmPcdCcFragScratchPoolCmdParams->bufferPoolId << HC_HCOR_ACTION_REG_IP_FRAG_SCRATCH_POOL_BPID; if (fill == TRUE) { p_HcFrame->extraReg = p_FmPcdCcFragScratchPoolCmdParams->numOfBuffers; } p_HcFrame->commandSequence = seqNum; BUILD_FD(sizeof(t_HcFrame)); if ((err = EnQFrm(p_FmHc, &fmFd, seqNum)) != E_OK) { PutBuf(p_FmHc, p_HcFrame, seqNum); RETURN_ERROR(MINOR, err, NO_MSG); } p_FmPcdCcFragScratchPoolCmdParams->numOfBuffers = p_HcFrame->extraReg; PutBuf(p_FmHc, p_HcFrame, seqNum); return E_OK; } t_Error FmHcPcdCcTimeoutReassm(t_Handle h_FmHc, t_FmPcdCcReassmTimeoutParams *p_CcReassmTimeoutParams, uint8_t *p_Result) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; t_Error err; uint32_t seqNum; SANITY_CHECK_RETURN_VALUE(h_FmHc, E_INVALID_HANDLE,0); 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_REASSM_TIMEOUT); p_HcFrame->actionReg = (uint32_t)((p_CcReassmTimeoutParams->activate ? 0 : 1) << HC_HCOR_ACTION_REG_REASSM_TIMEOUT_ACTIVE_SHIFT); p_HcFrame->extraReg = (p_CcReassmTimeoutParams->tsbs << HC_HCOR_EXTRA_REG_REASSM_TIMEOUT_TSBS_SHIFT) | p_CcReassmTimeoutParams->iprcpt; p_HcFrame->commandSequence = seqNum; BUILD_FD(sizeof(t_HcFrame)); if ((err = EnQFrm(p_FmHc, &fmFd, seqNum)) != E_OK) { PutBuf(p_FmHc, p_HcFrame, seqNum); RETURN_ERROR(MINOR, err, NO_MSG); } *p_Result = (uint8_t) ((p_HcFrame->actionReg >> HC_HCOR_ACTION_REG_REASSM_TIMEOUT_RES_SHIFT) & HC_HCOR_ACTION_REG_REASSM_TIMEOUT_RES_MASK); PutBuf(p_FmHc, p_HcFrame, seqNum); return E_OK; } t_Error FmHcPcdPlcrCcGetSetParams(t_Handle h_FmHc,uint16_t absoluteProfileId, uint32_t requiredAction) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; t_Error err; uint32_t tmpReg32 = 0; uint32_t requiredActionTmp, requiredActionFlag; uint32_t seqNum; SANITY_CHECK_RETURN_VALUE(h_FmHc, E_INVALID_HANDLE,0); /* Profile is locked by calling routine */ /* WARNING - this lock will not be efficient if other HC routine will attempt to change * "fmpl_pegnia" "fmpl_peynia" or "fmpl_pernia" without locking Profile ! */ requiredActionTmp = FmPcdPlcrGetRequiredAction(p_FmHc->h_FmPcd, absoluteProfileId); requiredActionFlag = FmPcdPlcrGetRequiredActionFlag(p_FmHc->h_FmPcd, absoluteProfileId); if (!requiredActionFlag || !(requiredActionTmp & requiredAction)) { if (requiredAction & UPDATE_NIA_ENQ_WITHOUT_DMA) { p_HcFrame = GetBuf(p_FmHc, &seqNum); if (!p_HcFrame) RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame object")); /* first read scheme and check that it is valid */ memset(p_HcFrame, 0, sizeof(t_HcFrame)); p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_PLCR_PRFL); p_HcFrame->actionReg = FmPcdPlcrBuildReadPlcrActionReg(absoluteProfileId); p_HcFrame->extraReg = 0x00008000; p_HcFrame->commandSequence = seqNum; BUILD_FD(SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC); if ((err = EnQFrm(p_FmHc, &fmFd, seqNum)) != E_OK) { PutBuf(p_FmHc, p_HcFrame, seqNum); RETURN_ERROR(MINOR, err, NO_MSG); } tmpReg32 = p_HcFrame->hcSpecificData.profileRegs.fmpl_pegnia; if (!(tmpReg32 & (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME))) { PutBuf(p_FmHc, p_HcFrame, seqNum); RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Next engine of this policer profile has to be assigned to FM_PCD_DONE")); } tmpReg32 |= NIA_BMI_AC_ENQ_FRAME_WITHOUT_DMA; p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_PLCR_PRFL); p_HcFrame->actionReg = FmPcdPlcrBuildWritePlcrActionReg(absoluteProfileId); p_HcFrame->actionReg |= FmPcdPlcrBuildNiaProfileReg(TRUE, FALSE, FALSE); p_HcFrame->extraReg = 0x00008000; p_HcFrame->hcSpecificData.singleRegForWrite = tmpReg32; BUILD_FD(SIZE_OF_HC_FRAME_PROFILE_CNT); if ((err = EnQFrm(p_FmHc, &fmFd, seqNum)) != E_OK) { PutBuf(p_FmHc, p_HcFrame, seqNum); RETURN_ERROR(MINOR, err, NO_MSG); } tmpReg32 = p_HcFrame->hcSpecificData.profileRegs.fmpl_peynia; if (!(tmpReg32 & (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME))) { PutBuf(p_FmHc, p_HcFrame, seqNum); RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Next engine of this policer profile has to be assigned to FM_PCD_DONE")); } tmpReg32 |= NIA_BMI_AC_ENQ_FRAME_WITHOUT_DMA; p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_PLCR_PRFL); p_HcFrame->actionReg = FmPcdPlcrBuildWritePlcrActionReg(absoluteProfileId); p_HcFrame->actionReg |= FmPcdPlcrBuildNiaProfileReg(FALSE, TRUE, FALSE); p_HcFrame->extraReg = 0x00008000; p_HcFrame->hcSpecificData.singleRegForWrite = tmpReg32; BUILD_FD(SIZE_OF_HC_FRAME_PROFILE_CNT); if ((err = EnQFrm(p_FmHc, &fmFd, seqNum)) != E_OK) { PutBuf(p_FmHc, p_HcFrame, seqNum); RETURN_ERROR(MINOR, err, NO_MSG); } tmpReg32 = p_HcFrame->hcSpecificData.profileRegs.fmpl_pernia; if (!(tmpReg32 & (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME))) { PutBuf(p_FmHc, p_HcFrame, seqNum); RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Next engine of this policer profile has to be assigned to FM_PCD_DONE")); } tmpReg32 |= NIA_BMI_AC_ENQ_FRAME_WITHOUT_DMA; p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_PLCR_PRFL); p_HcFrame->actionReg = FmPcdPlcrBuildWritePlcrActionReg(absoluteProfileId); p_HcFrame->actionReg |= FmPcdPlcrBuildNiaProfileReg(FALSE, FALSE, TRUE); p_HcFrame->extraReg = 0x00008000; p_HcFrame->hcSpecificData.singleRegForWrite = tmpReg32; BUILD_FD(SIZE_OF_HC_FRAME_PROFILE_CNT); if ((err = EnQFrm(p_FmHc, &fmFd, seqNum)) != E_OK) { PutBuf(p_FmHc, p_HcFrame, seqNum); RETURN_ERROR(MINOR, err, NO_MSG); } PutBuf(p_FmHc, p_HcFrame, seqNum); } } return E_OK; } t_Error FmHcPcdPlcrSetProfile(t_Handle h_FmHc, t_Handle h_Profile, t_FmPcdPlcrProfileRegs *p_PlcrRegs) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; t_Error err = E_OK; uint16_t profileIndx; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; uint32_t seqNum; p_HcFrame = GetBuf(p_FmHc, &seqNum); if (!p_HcFrame) RETURN_ERROR(MINOR, E_NO_MEMORY, ("HC Frame object")); profileIndx = FmPcdPlcrProfileGetAbsoluteId(h_Profile); memset(p_HcFrame, 0, sizeof(t_HcFrame)); p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_PLCR_PRFL); p_HcFrame->actionReg = FmPcdPlcrBuildWritePlcrActionRegs(profileIndx); p_HcFrame->extraReg = 0x00008000; memcpy(&p_HcFrame->hcSpecificData.profileRegs, p_PlcrRegs, sizeof(t_FmPcdPlcrProfileRegs)); p_HcFrame->commandSequence = seqNum; BUILD_FD(sizeof(t_HcFrame)); err = EnQFrm(p_FmHc, &fmFd, seqNum); PutBuf(p_FmHc, p_HcFrame, seqNum); if (err != E_OK) RETURN_ERROR(MINOR, err, NO_MSG); return E_OK; } t_Error FmHcPcdPlcrDeleteProfile(t_Handle h_FmHc, t_Handle h_Profile) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; uint16_t absoluteProfileId = FmPcdPlcrProfileGetAbsoluteId(h_Profile); t_Error err = E_OK; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; uint32_t seqNum; 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_PLCR_PRFL); p_HcFrame->actionReg = FmPcdPlcrBuildWritePlcrActionReg(absoluteProfileId); p_HcFrame->actionReg |= 0x00008000; p_HcFrame->extraReg = 0x00008000; memset(&p_HcFrame->hcSpecificData.profileRegs, 0, sizeof(t_FmPcdPlcrProfileRegs)); p_HcFrame->commandSequence = seqNum; BUILD_FD(sizeof(t_HcFrame)); err = EnQFrm(p_FmHc, &fmFd, seqNum); PutBuf(p_FmHc, p_HcFrame, seqNum); if (err != E_OK) RETURN_ERROR(MINOR, err, NO_MSG); return E_OK; } t_Error FmHcPcdPlcrSetProfileCounter(t_Handle h_FmHc, t_Handle h_Profile, e_FmPcdPlcrProfileCounters counter, uint32_t value) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; uint16_t absoluteProfileId = FmPcdPlcrProfileGetAbsoluteId(h_Profile); t_Error err = E_OK; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; uint32_t seqNum; /* first read scheme and check that it is valid */ 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_PLCR_PRFL); p_HcFrame->actionReg = FmPcdPlcrBuildWritePlcrActionReg(absoluteProfileId); p_HcFrame->actionReg |= FmPcdPlcrBuildCounterProfileReg(counter); p_HcFrame->extraReg = 0x00008000; p_HcFrame->hcSpecificData.singleRegForWrite = value; p_HcFrame->commandSequence = seqNum; BUILD_FD(SIZE_OF_HC_FRAME_PROFILE_CNT); err = EnQFrm(p_FmHc, &fmFd, seqNum); PutBuf(p_FmHc, p_HcFrame, seqNum); if (err != E_OK) RETURN_ERROR(MINOR, err, NO_MSG); return E_OK; } uint32_t FmHcPcdPlcrGetProfileCounter(t_Handle h_FmHc, t_Handle h_Profile, e_FmPcdPlcrProfileCounters counter) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; uint16_t absoluteProfileId = FmPcdPlcrProfileGetAbsoluteId(h_Profile); t_Error err; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; uint32_t retVal = 0; uint32_t seqNum; SANITY_CHECK_RETURN_VALUE(h_FmHc, E_INVALID_HANDLE,0); /* first read scheme and check that it is valid */ p_HcFrame = GetBuf(p_FmHc, &seqNum); if (!p_HcFrame) { REPORT_ERROR(MINOR, E_NO_MEMORY, ("HC Frame object")); return 0; } memset(p_HcFrame, 0, sizeof(t_HcFrame)); p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_PLCR_PRFL); p_HcFrame->actionReg = FmPcdPlcrBuildReadPlcrActionReg(absoluteProfileId); p_HcFrame->extraReg = 0x00008000; p_HcFrame->commandSequence = seqNum; BUILD_FD(SIZE_OF_HC_FRAME_READ_OR_CC_DYNAMIC); err = EnQFrm(p_FmHc, &fmFd, seqNum); if (err != E_OK) { PutBuf(p_FmHc, p_HcFrame, seqNum); REPORT_ERROR(MINOR, err, NO_MSG); return 0; } switch (counter) { case e_FM_PCD_PLCR_PROFILE_GREEN_PACKET_TOTAL_COUNTER: retVal = p_HcFrame->hcSpecificData.profileRegs.fmpl_pegpc; break; case e_FM_PCD_PLCR_PROFILE_YELLOW_PACKET_TOTAL_COUNTER: retVal = p_HcFrame->hcSpecificData.profileRegs.fmpl_peypc; break; case e_FM_PCD_PLCR_PROFILE_RED_PACKET_TOTAL_COUNTER: retVal = p_HcFrame->hcSpecificData.profileRegs.fmpl_perpc; break; case e_FM_PCD_PLCR_PROFILE_RECOLOURED_YELLOW_PACKET_TOTAL_COUNTER: retVal = p_HcFrame->hcSpecificData.profileRegs.fmpl_perypc; break; case e_FM_PCD_PLCR_PROFILE_RECOLOURED_RED_PACKET_TOTAL_COUNTER: retVal = p_HcFrame->hcSpecificData.profileRegs.fmpl_perrpc; break; default: REPORT_ERROR(MAJOR, E_INVALID_SELECTION, NO_MSG); } PutBuf(p_FmHc, p_HcFrame, seqNum); return retVal; } t_Error FmHcKgWriteSp(t_Handle h_FmHc, uint8_t hardwarePortId, uint32_t spReg, bool add) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; t_Error err = E_OK; uint32_t seqNum; ASSERT_COND(p_FmHc); 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)); /* first read SP register */ p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); p_HcFrame->actionReg = FmPcdKgBuildReadPortSchemeBindActionReg(hardwarePortId); p_HcFrame->extraReg = HC_HCOR_KG_SCHEME_REGS_MASK; p_HcFrame->commandSequence = seqNum; BUILD_FD(SIZE_OF_HC_FRAME_PORT_REGS); if ((err = EnQFrm(p_FmHc, &fmFd, seqNum)) != E_OK) { PutBuf(p_FmHc, p_HcFrame, seqNum); RETURN_ERROR(MINOR, err, NO_MSG); } /* spReg is the first reg, so we can use it both for read and for write */ if (add) p_HcFrame->hcSpecificData.portRegsForRead.spReg |= spReg; else p_HcFrame->hcSpecificData.portRegsForRead.spReg &= ~spReg; p_HcFrame->actionReg = FmPcdKgBuildWritePortSchemeBindActionReg(hardwarePortId); BUILD_FD(sizeof(t_HcFrame)); err = EnQFrm(p_FmHc, &fmFd, seqNum); PutBuf(p_FmHc, p_HcFrame, seqNum); if (err != E_OK) RETURN_ERROR(MINOR, err, NO_MSG); return E_OK; } t_Error FmHcKgWriteCpp(t_Handle h_FmHc, uint8_t hardwarePortId, uint32_t cppReg) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; t_Error err = E_OK; uint32_t seqNum; ASSERT_COND(p_FmHc); 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)); /* first read SP register */ p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_KG_SCM); p_HcFrame->actionReg = FmPcdKgBuildWritePortClsPlanBindActionReg(hardwarePortId); p_HcFrame->extraReg = HC_HCOR_KG_SCHEME_REGS_MASK; p_HcFrame->hcSpecificData.singleRegForWrite = cppReg; p_HcFrame->commandSequence = seqNum; BUILD_FD(sizeof(t_HcFrame)); err = EnQFrm(p_FmHc, &fmFd, seqNum); PutBuf(p_FmHc, p_HcFrame, seqNum); if (err != E_OK) RETURN_ERROR(MINOR, err, NO_MSG); return E_OK; } t_Error FmHcPcdCcDoDynamicChange(t_Handle h_FmHc, uint32_t oldAdAddrOffset, uint32_t newAdAddrOffset) { 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); p_HcFrame->actionReg = newAdAddrOffset; p_HcFrame->actionReg |= 0xc0000000; p_HcFrame->extraReg = oldAdAddrOffset; 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 FmHcPcdSync(t_Handle h_FmHc) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; t_HcFrame *p_HcFrame; t_DpaaFD fmFd; t_Error err = E_OK; uint32_t seqNum; ASSERT_COND(p_FmHc); 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)); /* first read SP register */ p_HcFrame->opcode = (uint32_t)(HC_HCOR_GBL | HC_HCOR_OPCODE_SYNC); p_HcFrame->actionReg = 0; p_HcFrame->extraReg = 0; p_HcFrame->commandSequence = seqNum; BUILD_FD(sizeof(t_HcFrame)); err = EnQFrm(p_FmHc, &fmFd, seqNum); PutBuf(p_FmHc, p_HcFrame, seqNum); if (err != E_OK) RETURN_ERROR(MINOR, err, NO_MSG); return E_OK; } t_Handle FmHcGetPort(t_Handle h_FmHc) { t_FmHc *p_FmHc = (t_FmHc*)h_FmHc; return p_FmHc->h_HcPortDev; }