/* Copyright (c) 2008-2011 Freescale Semiconductor, Inc. * All rights reserved. * * 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.c @Description FM PCD ... *//***************************************************************************/ #include "std_ext.h" #include "error_ext.h" #include "string_ext.h" #include "xx_ext.h" #include "sprint_ext.h" #include "debug_ext.h" #include "net_ext.h" #include "fm_ext.h" #include "fm_pcd_ext.h" #include "fm_common.h" #include "fm_pcd.h" #include "fm_pcd_ipc.h" #include "fm_hc.h" static t_Error CheckFmPcdParameters(t_FmPcd *p_FmPcd) { if(!p_FmPcd->h_Fm) RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("h_Fm has to be initialized")); if(p_FmPcd->guestId == NCSW_MASTER_ID) { if(p_FmPcd->p_FmPcdKg && !p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs) RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Something WRONG")); if(p_FmPcd->p_FmPcdPlcr && !p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs) RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Something WRONG")); if(!p_FmPcd->f_Exception) RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("f_FmPcdExceptions has to be initialized")); if((!p_FmPcd->f_FmPcdIndexedException) && (p_FmPcd->p_FmPcdPlcr || p_FmPcd->p_FmPcdKg)) RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("f_FmPcdIndexedException has to be initialized")); if(p_FmPcd->p_FmPcdDriverParam->prsMaxParseCycleLimit > PRS_MAX_CYCLE_LIMIT) RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("prsMaxParseCycleLimit has to be less than 8191")); } return E_OK; } static volatile bool blockingFlag = FALSE; static void FmPcdIpcMsgCompletionCB(t_Handle h_FmPcd, uint8_t *p_Msg, uint8_t *p_Reply, uint32_t replyLength, t_Error status) { UNUSED(h_FmPcd);UNUSED(p_Msg);UNUSED(p_Reply);UNUSED(replyLength);UNUSED(status); blockingFlag = FALSE; } static t_Error FmPcdHandleIpcMsgCB(t_Handle h_FmPcd, uint8_t *p_Msg, uint32_t msgLength, uint8_t *p_Reply, uint32_t *p_ReplyLength) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; t_Error err = E_OK; t_FmPcdIpcMsg *p_IpcMsg = (t_FmPcdIpcMsg*)p_Msg; t_FmPcdIpcReply *p_IpcReply = (t_FmPcdIpcReply*)p_Reply; SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR((msgLength >= sizeof(uint32_t)), E_INVALID_VALUE); #ifdef DISABLE_SANITY_CHECKS UNUSED(msgLength); #endif /* DISABLE_SANITY_CHECKS */ ASSERT_COND(p_Msg); memset(p_IpcReply, 0, (sizeof(uint8_t) * FM_PCD_MAX_REPLY_SIZE)); *p_ReplyLength = 0; switch(p_IpcMsg->msgId) { case (FM_PCD_MASTER_IS_ALIVE): *(uint8_t*)(p_IpcReply->replyBody) = 1; p_IpcReply->error = E_OK; *p_ReplyLength = sizeof(uint32_t) + sizeof(uint8_t); break; case (FM_PCD_MASTER_IS_ENABLED): /* count partitions registrations */ if(p_FmPcd->enabled) p_FmPcd->numOfEnabledGuestPartitionsPcds++; *(uint8_t*)(p_IpcReply->replyBody) = (uint8_t)p_FmPcd->enabled; p_IpcReply->error = E_OK; *p_ReplyLength = sizeof(uint32_t) + sizeof(uint8_t); break; case (FM_PCD_GUEST_DISABLE): if(p_FmPcd->numOfEnabledGuestPartitionsPcds) { p_FmPcd->numOfEnabledGuestPartitionsPcds--; p_IpcReply->error = E_OK; } else { REPORT_ERROR(MINOR, E_INVALID_STATE,("Trying to disable an unregistered partition")); p_IpcReply->error = E_INVALID_STATE; } *p_ReplyLength = sizeof(uint32_t); break; case(FM_PCD_GET_COUNTER): { e_FmPcdCounters inCounter; uint32_t outCounter; memcpy((uint8_t*)&inCounter, p_IpcMsg->msgBody, sizeof(uint32_t)); outCounter = FM_PCD_GetCounter(h_FmPcd, inCounter); memcpy(p_IpcReply->replyBody, (uint8_t*)&outCounter, sizeof(uint32_t)); p_IpcReply->error = E_OK; *p_ReplyLength = sizeof(uint32_t) + sizeof(uint32_t); break; } case (FM_PCD_ALLOC_KG_SCHEMES): { t_FmPcdIpcKgSchemesParams ipcSchemesParams; memcpy((uint8_t*)&ipcSchemesParams, p_IpcMsg->msgBody, sizeof(t_FmPcdIpcKgSchemesParams)); err = FmPcdKgAllocSchemes(h_FmPcd, ipcSchemesParams.numOfSchemes, ipcSchemesParams.guestId, p_IpcReply->replyBody); p_IpcReply->error = err; *p_ReplyLength = sizeof(uint32_t) + ipcSchemesParams.numOfSchemes*sizeof(uint8_t); break; } case (FM_PCD_FREE_KG_SCHEMES): { t_FmPcdIpcKgSchemesParams ipcSchemesParams; memcpy((uint8_t*)&ipcSchemesParams, p_IpcMsg->msgBody, sizeof(t_FmPcdIpcKgSchemesParams)); err = FmPcdKgFreeSchemes(h_FmPcd, ipcSchemesParams.numOfSchemes, ipcSchemesParams.guestId, ipcSchemesParams.schemesIds); p_IpcReply->error = err; *p_ReplyLength = sizeof(uint32_t); break; } case (FM_PCD_ALLOC_KG_CLSPLAN): { t_FmPcdIpcKgClsPlanParams ipcKgClsPlanParams; memcpy((uint8_t*)&ipcKgClsPlanParams, p_IpcMsg->msgBody, sizeof(t_FmPcdIpcKgClsPlanParams)); err = KgAllocClsPlanEntries(h_FmPcd, ipcKgClsPlanParams.numOfClsPlanEntries, ipcKgClsPlanParams.guestId, p_IpcReply->replyBody); p_IpcReply->error = err; *p_ReplyLength = sizeof(uint32_t) + sizeof(uint8_t); break; } case (FM_PCD_FREE_KG_CLSPLAN): { t_FmPcdIpcKgClsPlanParams ipcKgClsPlanParams; memcpy((uint8_t*)&ipcKgClsPlanParams, p_IpcMsg->msgBody, sizeof(t_FmPcdIpcKgClsPlanParams)); KgFreeClsPlanEntries(h_FmPcd, ipcKgClsPlanParams.numOfClsPlanEntries, ipcKgClsPlanParams.guestId, ipcKgClsPlanParams.clsPlanBase); *p_ReplyLength = sizeof(uint32_t); break; } case (FM_PCD_ALLOC_PROFILES): { t_FmPcdIpcPlcrAllocParams ipcPlcrAllocParams; uint16_t profilesBase; memcpy((uint8_t*)&ipcPlcrAllocParams, p_IpcMsg->msgBody, sizeof(t_FmPcdIpcPlcrAllocParams)); err = PlcrAllocProfiles(h_FmPcd, ipcPlcrAllocParams.hardwarePortId, ipcPlcrAllocParams.num, &profilesBase); memcpy(p_IpcReply->replyBody, (uint8_t*)&profilesBase, sizeof(uint16_t)); p_IpcReply->error = err; *p_ReplyLength = sizeof(uint32_t) + sizeof(uint16_t); break; } case (FM_PCD_FREE_PROFILES): { t_FmPcdIpcPlcrAllocParams ipcPlcrAllocParams; memcpy((uint8_t*)&ipcPlcrAllocParams, p_IpcMsg->msgBody, sizeof(t_FmPcdIpcPlcrAllocParams)); err = PlcrFreeProfiles(h_FmPcd, ipcPlcrAllocParams.hardwarePortId, ipcPlcrAllocParams.num, ipcPlcrAllocParams.plcrProfilesBase); p_IpcReply->error = err; *p_ReplyLength = sizeof(uint32_t); break; } case (FM_PCD_ALLOC_SHARED_PROFILES): { uint16_t numOfProfiles; uint16_t profilesIds[FM_PCD_PLCR_NUM_ENTRIES]; uint32_t profilesMask[FM_PCD_PLCR_NUM_ENTRIES/32]; int i; memset(profilesMask, 0, FM_PCD_PLCR_NUM_ENTRIES/32 * sizeof(uint32_t)); memcpy((uint8_t*)&numOfProfiles, p_IpcMsg->msgBody, sizeof(uint16_t)); err = PlcrAllocSharedProfiles(h_FmPcd, numOfProfiles, profilesIds); p_IpcReply->error = err; /* translate the allocated profile id's to a 32bit * 8regs mask */ for(i = 0;i> (profilesIds[i] % 32)); memcpy(p_IpcReply->replyBody, (uint8_t*)&profilesMask, sizeof(profilesMask)); *p_ReplyLength = sizeof(uint32_t) + sizeof(profilesMask); /* num-of-shared-profiles */ break; } case (FM_PCD_FREE_SHARED_PROFILES): { t_FmPcdIpcSharedPlcrAllocParams ipcSharedPlcrAllocParams; uint16_t profilesIds[FM_PCD_PLCR_NUM_ENTRIES]; int i,j, index = 0; uint32_t walking1Mask = 0x80000000; memset(profilesIds, 0, FM_PCD_PLCR_NUM_ENTRIES*sizeof(uint16_t)); memcpy((uint8_t*)&ipcSharedPlcrAllocParams, p_IpcMsg->msgBody, sizeof(t_FmPcdIpcSharedPlcrAllocParams)); for(i = 0; i>= 1; } walking1Mask = 0x80000000; } } PlcrFreeSharedProfiles(h_FmPcd, ipcSharedPlcrAllocParams.num, profilesIds); break; } case(FM_PCD_GET_SW_PRS_OFFSET): { t_FmPcdIpcSwPrsLable ipcSwPrsLable; uint32_t swPrsOffset; memcpy((uint8_t*)&ipcSwPrsLable, p_IpcMsg->msgBody, sizeof(t_FmPcdIpcSwPrsLable)); swPrsOffset = FmPcdGetSwPrsOffset(h_FmPcd, (e_NetHeaderType)ipcSwPrsLable.enumHdr, ipcSwPrsLable.indexPerHdr); memcpy(p_IpcReply->replyBody, (uint8_t*)&swPrsOffset, sizeof(uint32_t)); *p_ReplyLength = sizeof(uint32_t) + sizeof(uint32_t); break; } case(FM_PCD_PRS_INC_PORT_STATS): { t_FmPcdIpcPrsIncludePort ipcPrsIncludePort; memcpy((uint8_t*)&ipcPrsIncludePort, p_IpcMsg->msgBody, sizeof(t_FmPcdIpcPrsIncludePort)); PrsIncludePortInStatistics(h_FmPcd, ipcPrsIncludePort.hardwarePortId, ipcPrsIncludePort.include); break; } #if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0)) case(FM_PCD_DUMP_REGS): if((err = FM_PCD_DumpRegs(h_FmPcd)) != E_OK) REPORT_ERROR(MINOR, err, NO_MSG); break; case(FM_PCD_KG_DUMP_REGS): if((err = FM_PCD_KgDumpRegs(h_FmPcd)) != E_OK) REPORT_ERROR(MINOR, err, NO_MSG); break; case(FM_PCD_PLCR_DUMP_REGS): if((err = FM_PCD_PlcrDumpRegs(h_FmPcd)) != E_OK) REPORT_ERROR(MINOR, err, NO_MSG); break; case(FM_PCD_PLCR_PROFILE_DUMP_REGS): { t_Handle h_Profile; memcpy((uint8_t*)&h_Profile, p_IpcMsg->msgBody, sizeof(t_Handle)); if((err = FM_PCD_PlcrProfileDumpRegs(h_FmPcd, h_Profile)) != E_OK) REPORT_ERROR(MINOR, err, NO_MSG); break; } case(FM_PCD_PRS_DUMP_REGS): if((err = FM_PCD_PrsDumpRegs(h_FmPcd)) != E_OK) REPORT_ERROR(MINOR, err, NO_MSG); break; #endif /* (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0)) */ default: *p_ReplyLength = 0; RETURN_ERROR(MINOR, E_INVALID_SELECTION, ("command not found!!!")); } return E_OK; } void FmPcdSetClsPlanGrpId(t_FmPcd *p_FmPcd, uint8_t netEnvId, uint8_t clsPlanGrpId) { p_FmPcd->netEnvs[netEnvId].clsPlanGrpId = clsPlanGrpId; } t_Error PcdGetClsPlanGrpParams(t_FmPcd *p_FmPcd, t_FmPcdKgInterModuleClsPlanGrpParams *p_GrpParams) { uint8_t netEnvId = p_GrpParams->netEnvId; int i, k, j; if(p_FmPcd->netEnvs[netEnvId].clsPlanGrpId != ILLEGAL_CLS_PLAN) { p_GrpParams->grpExists = TRUE; p_GrpParams->clsPlanGrpId = p_FmPcd->netEnvs[netEnvId].clsPlanGrpId; return E_OK; } for (i=0; ((i < FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS) && (p_FmPcd->netEnvs[netEnvId].units[i].hdrs[0].hdr != HEADER_TYPE_NONE)); i++) { for (k=0; ((k < FM_PCD_MAX_NUM_OF_INTERCHANGEABLE_HDRS) && (p_FmPcd->netEnvs[netEnvId].units[i].hdrs[k].hdr != HEADER_TYPE_NONE)); k++) { /* if an option exists, add it to the opts list */ if(p_FmPcd->netEnvs[netEnvId].units[i].hdrs[k].opt) { /* check if this option already exists, add if it doesn't */ for(j = 0;jnumOfOptions;j++) { if(p_GrpParams->options[j] == p_FmPcd->netEnvs[netEnvId].units[i].hdrs[k].opt) break; } p_GrpParams->optVectors[j] |= p_FmPcd->netEnvs[netEnvId].unitsVectors[i]; if(j == p_GrpParams->numOfOptions) { p_GrpParams->options[p_GrpParams->numOfOptions] = p_FmPcd->netEnvs[netEnvId].units[i].hdrs[k].opt; p_GrpParams->numOfOptions++; } } } } if(p_GrpParams->numOfOptions == 0) { if(p_FmPcd->p_FmPcdKg->emptyClsPlanGrpId != ILLEGAL_CLS_PLAN) { p_GrpParams->grpExists = TRUE; p_GrpParams->clsPlanGrpId = p_FmPcd->p_FmPcdKg->emptyClsPlanGrpId; } } return E_OK; } t_Error PcdGetVectorForOpt(t_FmPcd *p_FmPcd, uint8_t netEnvId, protocolOpt_t opt, uint32_t *p_Vector) { uint8_t j,k; *p_Vector = 0; for (j=0; ((j < FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS) && (p_FmPcd->netEnvs[netEnvId].units[j].hdrs[0].hdr != HEADER_TYPE_NONE)); j++) { for (k=0; ((k < FM_PCD_MAX_NUM_OF_INTERCHANGEABLE_HDRS) && (p_FmPcd->netEnvs[netEnvId].units[j].hdrs[k].hdr != HEADER_TYPE_NONE)); k++) { if (p_FmPcd->netEnvs[netEnvId].units[j].hdrs[k].opt == opt) *p_Vector |= p_FmPcd->netEnvs[netEnvId].unitsVectors[j]; } } if (!*p_Vector) RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Requested option was not defined for this Network Environment Characteristics module")); else return E_OK; } t_Error PcdGetUnitsVector(t_FmPcd *p_FmPcd, t_NetEnvParams *p_Params) { int i; p_Params->vector = 0; for(i=0; inumOfDistinctionUnits ;i++) { if(p_FmPcd->netEnvs[p_Params->netEnvId].units[p_Params->unitIds[i]].hdrs[0].hdr == HEADER_TYPE_NONE) RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Requested unit was not defined for this Network Environment Characteristics module")); ASSERT_COND(p_FmPcd->netEnvs[p_Params->netEnvId].unitsVectors[p_Params->unitIds[i]]); p_Params->vector |= p_FmPcd->netEnvs[p_Params->netEnvId].unitsVectors[p_Params->unitIds[i]]; } return E_OK; } bool PcdNetEnvIsUnitWithoutOpts(t_FmPcd *p_FmPcd, uint8_t netEnvId, uint32_t unitVector) { int i=0, k; /* check whether a given unit may be used by non-clsPlan users. */ /* first, recognize the unit by its vector */ while (p_FmPcd->netEnvs[netEnvId].units[i].hdrs[0].hdr != HEADER_TYPE_NONE) { if (p_FmPcd->netEnvs[netEnvId].unitsVectors[i] == unitVector) { for (k=0; ((k < FM_PCD_MAX_NUM_OF_INTERCHANGEABLE_HDRS) && (p_FmPcd->netEnvs[netEnvId].units[i].hdrs[k].hdr != HEADER_TYPE_NONE)); k++) /* check that no option exists */ if((protocolOpt_t)p_FmPcd->netEnvs[netEnvId].units[i].hdrs[k].opt) return FALSE; break; } i++; } /* assert that a unit was found to mach the vector */ ASSERT_COND(p_FmPcd->netEnvs[netEnvId].units[i].hdrs[0].hdr != HEADER_TYPE_NONE); return TRUE; } bool FmPcdNetEnvIsHdrExist(t_Handle h_FmPcd, uint8_t netEnvId, e_NetHeaderType hdr) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; int i, k; ASSERT_COND(p_FmPcd); for (i=0; ((i < FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS) && (p_FmPcd->netEnvs[netEnvId].units[i].hdrs[0].hdr != HEADER_TYPE_NONE)); i++) { for (k=0; ((k < FM_PCD_MAX_NUM_OF_INTERCHANGEABLE_HDRS) && (p_FmPcd->netEnvs[netEnvId].units[i].hdrs[k].hdr != HEADER_TYPE_NONE)); k++) if (p_FmPcd->netEnvs[netEnvId].units[i].hdrs[k].hdr == hdr) return TRUE; } for (i=0; ((i < FM_PCD_MAX_NUM_OF_PRIVATE_HDRS) && (p_FmPcd->netEnvs[netEnvId].aliasHdrs[i].hdr != HEADER_TYPE_NONE)); i++) { if (p_FmPcd->netEnvs[netEnvId].aliasHdrs[i].hdr == hdr) return TRUE; } return FALSE; } e_NetHeaderType FmPcdGetAliasHdr(t_FmPcd *p_FmPcd, uint8_t netEnvId, e_NetHeaderType hdr) { int i; ASSERT_COND(p_FmPcd); for (i=0; (i < FM_PCD_MAX_NUM_OF_PRIVATE_HDRS) && (p_FmPcd->netEnvs[netEnvId].aliasHdrs[i].hdr != HEADER_TYPE_NONE); i++) { if (p_FmPcd->netEnvs[netEnvId].aliasHdrs[i].hdr == hdr) return p_FmPcd->netEnvs[netEnvId].aliasHdrs[i].aliasHdr; } return HEADER_TYPE_NONE; } void FmPcdPortRegister(t_Handle h_FmPcd, t_Handle h_FmPort, uint8_t hardwarePortId) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; uint16_t swPortIndex = 0; HW_PORT_ID_TO_SW_PORT_INDX(swPortIndex, hardwarePortId); p_FmPcd->p_FmPcdPlcr->portsMapping[swPortIndex].h_FmPort = h_FmPort; } uint32_t FmPcdGetLcv(t_Handle h_FmPcd, uint32_t netEnvId, uint8_t hdrNum) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; return p_FmPcd->netEnvs[netEnvId].lcvs[hdrNum]; } uint32_t FmPcdGetMacsecLcv(t_Handle h_FmPcd, uint32_t netEnvId) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; return p_FmPcd->netEnvs[netEnvId].macsecVector; } void FmPcdIncNetEnvOwners(t_Handle h_FmPcd, uint8_t netEnvId) { ((t_FmPcd*)h_FmPcd)->netEnvs[netEnvId].owners++; } void FmPcdDecNetEnvOwners(t_Handle h_FmPcd, uint8_t netEnvId) { ASSERT_COND(((t_FmPcd*)h_FmPcd)->netEnvs[netEnvId].owners); ((t_FmPcd*)h_FmPcd)->netEnvs[netEnvId].owners--; } uint32_t FmPcdLock(t_Handle h_FmPcd) { return XX_LockIntrSpinlock(((t_FmPcd*)h_FmPcd)->h_Spinlock); } void FmPcdUnlock(t_Handle h_FmPcd, uint32_t intFlags) { XX_UnlockIntrSpinlock(((t_FmPcd*)h_FmPcd)->h_Spinlock, intFlags); } t_Handle FmPcdGetHcHandle(t_Handle h_FmPcd) { ASSERT_COND(h_FmPcd); SANITY_CHECK_RETURN_VALUE(((t_FmPcd*)h_FmPcd)->h_Hc, E_INVALID_HANDLE, NULL); return ((t_FmPcd*)h_FmPcd)->h_Hc; } /**********************************************************************************************************/ /* API */ /**********************************************************************************************************/ t_Handle FM_PCD_Config(t_FmPcdParams *p_FmPcdParams) { t_FmPcd *p_FmPcd = NULL; t_FmPhysAddr physicalMuramBase; uint8_t i; SANITY_CHECK_RETURN_VALUE(p_FmPcdParams, E_INVALID_HANDLE,NULL); p_FmPcd = (t_FmPcd *) XX_Malloc(sizeof(t_FmPcd)); if (!p_FmPcd) { REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FM Pcd")); return NULL; } memset(p_FmPcd, 0, sizeof(t_FmPcd)); p_FmPcd->p_FmPcdDriverParam = (t_FmPcdDriverParam *) XX_Malloc(sizeof(t_FmPcdDriverParam)); if (!p_FmPcd->p_FmPcdDriverParam) { XX_Free(p_FmPcd); REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FM Pcd Driver Param")); return NULL; } memset(p_FmPcd->p_FmPcdDriverParam, 0, sizeof(t_FmPcdDriverParam)); p_FmPcd->h_Fm = p_FmPcdParams->h_Fm; p_FmPcd->guestId = FmGetGuestId(p_FmPcd->h_Fm); p_FmPcd->h_FmMuram = FmGetMuramHandle(p_FmPcd->h_Fm); FmGetPhysicalMuramBase(p_FmPcdParams->h_Fm, &physicalMuramBase); p_FmPcd->physicalMuramBase = (uint64_t)((uint64_t)(&physicalMuramBase)->low | ((uint64_t)(&physicalMuramBase)->high << 32)); for(i = 0; inetEnvs[i].clsPlanGrpId = ILLEGAL_CLS_PLAN; if (p_FmPcdParams->useHostCommand) { t_FmHcParams hcParams; memset(&hcParams, 0, sizeof(hcParams)); hcParams.h_Fm = p_FmPcd->h_Fm; hcParams.h_FmPcd = (t_Handle)p_FmPcd; memcpy((uint8_t*)&hcParams.params, (uint8_t*)&p_FmPcdParams->hc, sizeof(t_FmPcdHcParams)); p_FmPcd->h_Hc = FmHcConfigAndInit(&hcParams); if (!p_FmPcd->h_Hc) { REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FM Pcd HC")); FM_PCD_Free(p_FmPcd); return NULL; } } else if(p_FmPcd->guestId != NCSW_MASTER_ID) REPORT_ERROR(MAJOR, E_INVALID_STATE, ("No Host Command defined for a guest partition.")); if(p_FmPcdParams->kgSupport) { p_FmPcd->p_FmPcdKg = (t_FmPcdKg *)KgConfig(p_FmPcd, p_FmPcdParams); if(!p_FmPcd->p_FmPcdKg) { REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FM Pcd Keygen")); FM_PCD_Free(p_FmPcd); return NULL; } } if(p_FmPcdParams->plcrSupport) { p_FmPcd->p_FmPcdPlcr = (t_FmPcdPlcr *)PlcrConfig(p_FmPcd, p_FmPcdParams); if(!p_FmPcd->p_FmPcdPlcr) { REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FM Pcd Policer")); FM_PCD_Free(p_FmPcd); return NULL; } } if(p_FmPcdParams->prsSupport) { p_FmPcd->p_FmPcdPrs = (t_FmPcdPrs *)PrsConfig(p_FmPcd, p_FmPcdParams); if(!p_FmPcd->p_FmPcdPrs) { REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FM Pcd Parser")); FM_PCD_Free(p_FmPcd); return NULL; } } p_FmPcd->h_Spinlock = XX_InitSpinlock(); if (!p_FmPcd->h_Spinlock) { REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FM Pcd spinlock")); FM_PCD_Free(p_FmPcd); return NULL; } p_FmPcd->numOfEnabledGuestPartitionsPcds = 0; p_FmPcd->f_Exception = p_FmPcdParams->f_Exception; p_FmPcd->f_FmPcdIndexedException = p_FmPcdParams->f_ExceptionId; p_FmPcd->h_App = p_FmPcdParams->h_App; return p_FmPcd; } t_Error FM_PCD_Init(t_Handle h_FmPcd) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; t_Error err = E_OK; t_FmPcdIpcMsg msg; SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(p_FmPcd->p_FmPcdDriverParam, E_INVALID_HANDLE); if(p_FmPcd->guestId != NCSW_MASTER_ID) { uint8_t isMasterAlive = 0; t_FmPcdIpcReply reply; uint32_t replyLength; memset(p_FmPcd->fmPcdIpcHandlerModuleName, 0, (sizeof(char)) * MODULE_NAME_SIZE); if(Sprint (p_FmPcd->fmPcdIpcHandlerModuleName, "FM_PCD_%d_%d", FmGetId(p_FmPcd->h_Fm), NCSW_MASTER_ID) != 10) RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Sprint failed")); memset(p_FmPcd->fmPcdModuleName, 0, (sizeof(char)) * MODULE_NAME_SIZE); if(Sprint (p_FmPcd->fmPcdModuleName, "FM_PCD_%d_%d",FmGetId(p_FmPcd->h_Fm), p_FmPcd->guestId) != (p_FmPcd->guestId<10 ? 10:11)) RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Sprint failed")); p_FmPcd->h_IpcSession = XX_IpcInitSession(p_FmPcd->fmPcdIpcHandlerModuleName, p_FmPcd->fmPcdModuleName); if (p_FmPcd->h_IpcSession == NULL) RETURN_ERROR(MAJOR, E_NOT_AVAILABLE, ("FM PCD Guest %d IPC session", p_FmPcd->guestId)); memset(&msg, 0, sizeof(msg)); memset(&reply, 0, sizeof(reply)); msg.msgId = FM_PCD_MASTER_IS_ALIVE; msg.msgBody[0] = p_FmPcd->guestId; blockingFlag = TRUE; do { replyLength = sizeof(uint32_t) + sizeof(isMasterAlive); if ((err = XX_IpcSendMessage(p_FmPcd->h_IpcSession, (uint8_t*)&msg, sizeof(msg.msgId)+sizeof(p_FmPcd->guestId), (uint8_t*)&reply, &replyLength, FmPcdIpcMsgCompletionCB, h_FmPcd)) != E_OK) REPORT_ERROR(MAJOR, err, NO_MSG); while(blockingFlag) ; if(replyLength != (sizeof(uint32_t) + sizeof(isMasterAlive))) REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); isMasterAlive = *(uint8_t*)(reply.replyBody); } while (!isMasterAlive); } CHECK_INIT_PARAMETERS(p_FmPcd, CheckFmPcdParameters); if(p_FmPcd->p_FmPcdKg) { err = KgInit(p_FmPcd); if(err) RETURN_ERROR(MAJOR, err, NO_MSG); } if(p_FmPcd->p_FmPcdPlcr) { err = PlcrInit(p_FmPcd); if(err) RETURN_ERROR(MAJOR, err, NO_MSG); } if(p_FmPcd->p_FmPcdPrs) { err = PrsInit(p_FmPcd); if(err) RETURN_ERROR(MAJOR, err, NO_MSG); } if(p_FmPcd->guestId == NCSW_MASTER_ID) { /* register to inter-core messaging mechanism */ memset(p_FmPcd->fmPcdModuleName, 0, (sizeof(char)) * MODULE_NAME_SIZE); if(Sprint (p_FmPcd->fmPcdModuleName, "FM_PCD_%d_%d",FmGetId(p_FmPcd->h_Fm),NCSW_MASTER_ID) != 10) RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Sprint failed")); err = XX_IpcRegisterMsgHandler(p_FmPcd->fmPcdModuleName, FmPcdHandleIpcMsgCB, p_FmPcd, FM_PCD_MAX_REPLY_SIZE); if(err) RETURN_ERROR(MAJOR, err, NO_MSG); } XX_Free(p_FmPcd->p_FmPcdDriverParam); p_FmPcd->p_FmPcdDriverParam = NULL; FmRegisterPcd(p_FmPcd->h_Fm, p_FmPcd); return E_OK; } t_Error FM_PCD_Free(t_Handle h_FmPcd) { t_FmPcd *p_FmPcd =(t_FmPcd *)h_FmPcd; t_Error err = E_OK; if(p_FmPcd->enabled) FM_PCD_Disable(p_FmPcd); if (p_FmPcd->h_Spinlock) XX_FreeSpinlock(p_FmPcd->h_Spinlock); if(p_FmPcd->p_FmPcdDriverParam) { XX_Free(p_FmPcd->p_FmPcdDriverParam); p_FmPcd->p_FmPcdDriverParam = NULL; } if(p_FmPcd->p_FmPcdKg) { if((err = KgFree(p_FmPcd)) != E_OK) RETURN_ERROR(MINOR, err, NO_MSG); XX_Free(p_FmPcd->p_FmPcdKg); p_FmPcd->p_FmPcdKg = NULL; } if(p_FmPcd->p_FmPcdPlcr) { if((err = PlcrFree(p_FmPcd)) != E_OK) RETURN_ERROR(MINOR, err, NO_MSG); XX_Free(p_FmPcd->p_FmPcdPlcr); p_FmPcd->p_FmPcdPlcr = NULL; } if(p_FmPcd->p_FmPcdPrs) { if(p_FmPcd->guestId == NCSW_MASTER_ID) PrsFree(p_FmPcd); XX_Free(p_FmPcd->p_FmPcdPrs); p_FmPcd->p_FmPcdPrs = NULL; } if (p_FmPcd->h_Hc) { FmHcFree(p_FmPcd->h_Hc); p_FmPcd->h_Hc = NULL; } XX_IpcUnregisterMsgHandler(p_FmPcd->fmPcdModuleName); FmUnregisterPcd(p_FmPcd->h_Fm); XX_Free(p_FmPcd); return E_OK; } t_Error FM_PCD_Enable(t_Handle h_FmPcd) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; t_Error err = E_OK; SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_HANDLE); if(p_FmPcd->guestId == NCSW_MASTER_ID) { if(p_FmPcd->p_FmPcdKg) KgEnable(p_FmPcd); if(p_FmPcd->p_FmPcdPlcr) PlcrEnable(p_FmPcd); if(p_FmPcd->p_FmPcdPrs) PrsEnable(p_FmPcd); p_FmPcd->enabled = TRUE; } else { uint8_t enabled; t_FmPcdIpcMsg msg; t_FmPcdIpcReply reply; uint32_t replyLength; memset(&msg, 0, sizeof(msg)); memset(&reply, 0, sizeof(reply)); msg.msgId = FM_PCD_MASTER_IS_ENABLED; replyLength = sizeof(uint32_t) + sizeof(enabled); if ((err = XX_IpcSendMessage(p_FmPcd->h_IpcSession, (uint8_t*)&msg, sizeof(msg.msgId), (uint8_t*)&reply, &replyLength, NULL, NULL)) != E_OK) RETURN_ERROR(MAJOR, err, NO_MSG); if (replyLength != sizeof(uint32_t) + sizeof(enabled)) RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); p_FmPcd->enabled = (bool)!!(*(uint8_t*)(reply.replyBody)); if (!p_FmPcd->enabled) RETURN_ERROR(MAJOR, E_INVALID_STATE, ("FM-PCD master should be enabled first!")); } return E_OK; } t_Error FM_PCD_Disable(t_Handle h_FmPcd) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; t_Error err = E_OK; t_FmPcdIpcMsg msg; t_FmPcdIpcReply reply; uint32_t replyLength; SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_HANDLE); if(p_FmPcd->guestId == NCSW_MASTER_ID) { if(p_FmPcd->numOfEnabledGuestPartitionsPcds != 0) RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Trying to disable a master partition PCD while guest partitions are still enabled.")); if(p_FmPcd->p_FmPcdKg) KgDisable(p_FmPcd); if(p_FmPcd->p_FmPcdPlcr) PlcrDisable(p_FmPcd); if(p_FmPcd->p_FmPcdPrs) PrsDisable(p_FmPcd); p_FmPcd->enabled = FALSE; return E_OK; } memset(&msg, 0, sizeof(msg)); msg.msgId = FM_PCD_GUEST_DISABLE; memset(&reply, 0, sizeof(reply)); replyLength = sizeof(uint32_t); if ((err = XX_IpcSendMessage(p_FmPcd->h_IpcSession, (uint8_t*)&msg, sizeof(msg.msgId), (uint8_t*)&reply, &replyLength, NULL, NULL)) != E_OK) RETURN_ERROR(MAJOR, err, NO_MSG); if (replyLength != sizeof(uint32_t)) RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); return (t_Error)(reply.error); } t_Handle FM_PCD_SetNetEnvCharacteristics(t_Handle h_FmPcd, t_FmPcdNetEnvParams *p_NetEnvParams) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; uint32_t intFlags, specialUnits = 0; uint8_t bitId = 0; uint8_t i, j, k; uint8_t netEnvCurrId; uint8_t ipsecAhUnit = 0,ipsecEspUnit = 0; bool ipsecAhExists = FALSE, ipsecEspExists = FALSE, shim1Selected = FALSE; uint8_t hdrNum; SANITY_CHECK_RETURN_VALUE(h_FmPcd, E_INVALID_STATE, NULL); SANITY_CHECK_RETURN_VALUE(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE, NULL); intFlags = FmPcdLock(p_FmPcd); /* find a new netEnv */ for(i = 0;inetEnvs[i].used) break; if(i== FM_MAX_NUM_OF_PORTS) { REPORT_ERROR(MAJOR, E_FULL,("No more than %d netEnv's allowed.", FM_MAX_NUM_OF_PORTS)); FmPcdUnlock(p_FmPcd, intFlags); return NULL; } p_FmPcd->netEnvs[i].used = TRUE; if (!TRY_LOCK(NULL, &p_FmPcd->netEnvs[i].lock)) { FmPcdUnlock(p_FmPcd, intFlags); return NULL; } FmPcdUnlock(p_FmPcd, intFlags); netEnvCurrId = (uint8_t)i; /* clear from previous use */ memset(&p_FmPcd->netEnvs[netEnvCurrId].units, 0, FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS * sizeof(t_FmPcdIntDistinctionUnit)); memset(&p_FmPcd->netEnvs[netEnvCurrId].aliasHdrs, 0, FM_PCD_MAX_NUM_OF_PRIVATE_HDRS * sizeof(t_FmPcdNetEnvAliases)); memcpy(&p_FmPcd->netEnvs[netEnvCurrId].units, p_NetEnvParams->units, p_NetEnvParams->numOfDistinctionUnits*sizeof(t_FmPcdIntDistinctionUnit)); p_FmPcd->netEnvs[netEnvCurrId].clsPlanGrpId = ILLEGAL_CLS_PLAN; /* check that header with opt is not interchanged with the same header */ for (i=0; (i < FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS) && (p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[0].hdr != HEADER_TYPE_NONE); i++) { for (k=0; (k < FM_PCD_MAX_NUM_OF_INTERCHANGEABLE_HDRS) && (p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr != HEADER_TYPE_NONE); k++) { /* if an option exists, check that other headers are not the same header without option */ if(p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].opt) { for (j=0; (j < FM_PCD_MAX_NUM_OF_INTERCHANGEABLE_HDRS) && (p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[j].hdr != HEADER_TYPE_NONE); j++) if((p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[j].hdr == p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr) && !p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[j].opt) { REPORT_ERROR(MINOR, E_FULL, ("Illegal unit - header with opt may not be interchangeable with the same header without opt")); RELEASE_LOCK(p_FmPcd->netEnvs[netEnvCurrId].lock); return NULL; } } } } /* IPSEC_AH and IPSEC_SPI can't be 2 units, */ /* check that header with opt is not interchanged with the same header */ for(i=0; (i < FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS) && (p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[0].hdr != HEADER_TYPE_NONE); i++) { for(k=0; (k < FM_PCD_MAX_NUM_OF_INTERCHANGEABLE_HDRS) && (p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr != HEADER_TYPE_NONE); k++) { /* Some headers pairs may not be defined on different units as the parser doesn't distinguish */ if(p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr == HEADER_TYPE_IPSEC_AH) { if (ipsecEspExists && (ipsecEspUnit != i)) { REPORT_ERROR(MINOR, E_INVALID_STATE, ("HEADER_TYPE_IPSEC_AH and HEADER_TYPE_IPSEC_ESP may not be defined in separate units")); RELEASE_LOCK(p_FmPcd->netEnvs[netEnvCurrId].lock); return NULL; } else { ipsecAhUnit = i; ipsecAhExists = TRUE; } } if(p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr == HEADER_TYPE_IPSEC_ESP) { if (ipsecAhExists && (ipsecAhUnit != i)) { REPORT_ERROR(MINOR, E_INVALID_STATE, ("HEADER_TYPE_IPSEC_AH and HEADER_TYPE_IPSEC_ESP may not be defined in separate units")); RELEASE_LOCK(p_FmPcd->netEnvs[netEnvCurrId].lock); return NULL; } else { ipsecEspUnit = i; ipsecEspExists = TRUE; } } if(p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr == HEADER_TYPE_UDP_ENCAP_ESP) { /* TODO - general coding. choose the free shim header */ p_FmPcd->netEnvs[netEnvCurrId].aliasHdrs[specialUnits].hdr = HEADER_TYPE_UDP_ENCAP_ESP; p_FmPcd->netEnvs[netEnvCurrId].aliasHdrs[specialUnits++].aliasHdr = HEADER_TYPE_USER_DEFINED_SHIM1; p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr = HEADER_TYPE_USER_DEFINED_SHIM1; p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].opt = 0; } } } /* if private header (shim), check that no other headers specified */ for (i=0; (i < FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS) && (p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[0].hdr != HEADER_TYPE_NONE); i++) { if(IS_PRIVATE_HEADER(p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[0].hdr)) if(p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[1].hdr != HEADER_TYPE_NONE) { REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("SHIM header may not be interchanged with other headers")); RELEASE_LOCK(p_FmPcd->netEnvs[netEnvCurrId].lock); return NULL; } } for(i=0; inumOfDistinctionUnits;i++) { if (IS_PRIVATE_HEADER(p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[0].hdr)) switch(p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[0].hdr) { case(HEADER_TYPE_USER_DEFINED_SHIM1): if (shim1Selected) { REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("SHIM header cannot be selected with UDP_IPSEC_ESP")); RELEASE_LOCK(p_FmPcd->netEnvs[netEnvCurrId].lock); return NULL; } shim1Selected = TRUE; p_FmPcd->netEnvs[netEnvCurrId].unitsVectors[i] = 0x00000001; break; case(HEADER_TYPE_USER_DEFINED_SHIM2): p_FmPcd->netEnvs[netEnvCurrId].unitsVectors[i] = 0x00000002; break; default: REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Requested SHIM not supported")); } else { p_FmPcd->netEnvs[netEnvCurrId].unitsVectors[i] = (uint32_t)(0x80000000 >> bitId++); if(IS_SPECIAL_HEADER(p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[0].hdr)) p_FmPcd->netEnvs[netEnvCurrId].macsecVector = p_FmPcd->netEnvs[netEnvCurrId].unitsVectors[i]; } } /* define a set of hardware parser LCV's according to the defined netenv */ /* set an array of LCV's for each header in the netEnv */ for (i=0; (i < FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS) && (p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[0].hdr != HEADER_TYPE_NONE); i++) { /* private headers have no LCV in the hard parser */ if (!IS_PRIVATE_HEADER(p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[0].hdr)) { for (k=0; (k < FM_PCD_MAX_NUM_OF_INTERCHANGEABLE_HDRS) && (p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr != HEADER_TYPE_NONE); k++) { GET_PRS_HDR_NUM(hdrNum, p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr); if ((hdrNum == ILLEGAL_HDR_NUM) || (hdrNum == NO_HDR_NUM)) { REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, NO_MSG); RELEASE_LOCK(p_FmPcd->netEnvs[netEnvCurrId].lock); return NULL; } p_FmPcd->netEnvs[netEnvCurrId].lcvs[hdrNum] |= p_FmPcd->netEnvs[netEnvCurrId].unitsVectors[i]; } } } RELEASE_LOCK(p_FmPcd->netEnvs[netEnvCurrId].lock); return UINT_TO_PTR((uint64_t)netEnvCurrId+1); } t_Error FM_PCD_DeleteNetEnvCharacteristics(t_Handle h_FmPcd, t_Handle h_NetEnv) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; uint8_t netEnvId = (uint8_t)(PTR_TO_UINT(h_NetEnv)-1); SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_STATE); SANITY_CHECK_RETURN_ERROR(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE); if (!TRY_LOCK(p_FmPcd->h_Spinlock, &p_FmPcd->netEnvs[netEnvId].lock)) return ERROR_CODE(E_BUSY); /* check that no port is bound to this netEnv */ if(p_FmPcd->netEnvs[netEnvId].owners) { RELEASE_LOCK(p_FmPcd->netEnvs[netEnvId].lock); RETURN_ERROR(MINOR, E_INVALID_STATE, ("Trying to delete a netEnv that has ports/schemes/trees/clsPlanGrps bound to")); } p_FmPcd->netEnvs[netEnvId].used= FALSE; p_FmPcd->netEnvs[netEnvId].clsPlanGrpId = ILLEGAL_CLS_PLAN; memset(p_FmPcd->netEnvs[netEnvId].units, 0, sizeof(t_FmPcdIntDistinctionUnit)*FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS); memset(p_FmPcd->netEnvs[netEnvId].unitsVectors, 0, sizeof(uint32_t)*FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS); memset(p_FmPcd->netEnvs[netEnvId].lcvs, 0, sizeof(uint32_t)*FM_PCD_PRS_NUM_OF_HDRS); RELEASE_LOCK(p_FmPcd->netEnvs[netEnvId].lock); return E_OK; } void FM_PCD_HcTxConf(t_Handle h_FmPcd, t_DpaaFD *p_Fd) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; SANITY_CHECK_RETURN(h_FmPcd, E_INVALID_STATE); FmHcTxConf(p_FmPcd->h_Hc, p_Fd); } uint32_t FM_PCD_GetCounter(t_Handle h_FmPcd, e_FmPcdCounters counter) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; uint32_t replyLength, outCounter = 0; t_FmPcdIpcMsg msg; t_Error err; t_FmPcdIpcReply reply; SANITY_CHECK_RETURN_VALUE(h_FmPcd, E_INVALID_HANDLE, 0); SANITY_CHECK_RETURN_VALUE(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE, 0); if(p_FmPcd->guestId != NCSW_MASTER_ID) { memset(&msg, 0, sizeof(msg)); memset(&reply, 0, sizeof(reply)); msg.msgId = FM_PCD_GET_COUNTER; memcpy(msg.msgBody, (uint8_t *)&counter, sizeof(uint32_t)); replyLength = sizeof(uint32_t) + sizeof(uint32_t); if ((err = XX_IpcSendMessage(p_FmPcd->h_IpcSession, (uint8_t*)&msg, sizeof(msg.msgId) +sizeof(uint32_t), (uint8_t*)&reply, &replyLength, NULL, NULL)) != E_OK) RETURN_ERROR(MAJOR, err, NO_MSG); if (replyLength != sizeof(uint32_t) + sizeof(uint32_t)) RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("IPC reply length mismatch")); memcpy((uint8_t*)&outCounter, reply.replyBody, sizeof(uint32_t)); return outCounter; } switch(counter) { case(e_FM_PCD_KG_COUNTERS_TOTAL): if(!p_FmPcd->p_FmPcdKg) { REPORT_ERROR(MINOR, E_INVALID_STATE, ("Can't ask for this counters")); return 0; } break; case(e_FM_PCD_PLCR_COUNTERS_YELLOW): case(e_FM_PCD_PLCR_COUNTERS_RED): case(e_FM_PCD_PLCR_COUNTERS_RECOLORED_TO_RED): case(e_FM_PCD_PLCR_COUNTERS_RECOLORED_TO_YELLOW): case(e_FM_PCD_PLCR_COUNTERS_TOTAL): case(e_FM_PCD_PLCR_COUNTERS_LENGTH_MISMATCH): if(!p_FmPcd->p_FmPcdPlcr) { REPORT_ERROR(MINOR, E_INVALID_STATE, ("Can't ask for this counters")); return 0; } /* check that counters are enabled */ if(!(GET_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_gcr) & FM_PCD_PLCR_GCR_STEN)) { REPORT_ERROR(MINOR, E_INVALID_STATE, ("Requested counter was not enabled")); return 0; } break; case(e_FM_PCD_PRS_COUNTERS_PARSE_DISPATCH): case(e_FM_PCD_PRS_COUNTERS_L2_PARSE_RESULT_RETURNED): case(e_FM_PCD_PRS_COUNTERS_L3_PARSE_RESULT_RETURNED): case(e_FM_PCD_PRS_COUNTERS_L4_PARSE_RESULT_RETURNED): case(e_FM_PCD_PRS_COUNTERS_SHIM_PARSE_RESULT_RETURNED): case(e_FM_PCD_PRS_COUNTERS_L2_PARSE_RESULT_RETURNED_WITH_ERR): case(e_FM_PCD_PRS_COUNTERS_L3_PARSE_RESULT_RETURNED_WITH_ERR): case(e_FM_PCD_PRS_COUNTERS_L4_PARSE_RESULT_RETURNED_WITH_ERR): case(e_FM_PCD_PRS_COUNTERS_SHIM_PARSE_RESULT_RETURNED_WITH_ERR): case(e_FM_PCD_PRS_COUNTERS_SOFT_PRS_CYCLES): case(e_FM_PCD_PRS_COUNTERS_SOFT_PRS_STALL_CYCLES): case(e_FM_PCD_PRS_COUNTERS_HARD_PRS_CYCLE_INCL_STALL_CYCLES): case(e_FM_PCD_PRS_COUNTERS_MURAM_READ_CYCLES): case(e_FM_PCD_PRS_COUNTERS_MURAM_READ_STALL_CYCLES): case(e_FM_PCD_PRS_COUNTERS_MURAM_WRITE_CYCLES): case(e_FM_PCD_PRS_COUNTERS_MURAM_WRITE_STALL_CYCLES): case(e_FM_PCD_PRS_COUNTERS_FPM_COMMAND_STALL_CYCLES): if(!p_FmPcd->p_FmPcdPrs) { REPORT_ERROR(MINOR, E_INVALID_STATE, ("Can't ask for this counters")); return 0; } break; default: REPORT_ERROR(MINOR, E_INVALID_STATE, ("Unsupported type of counter")); return 0; } switch(counter) { case(e_FM_PCD_PRS_COUNTERS_PARSE_DISPATCH): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->pds); case(e_FM_PCD_PRS_COUNTERS_L2_PARSE_RESULT_RETURNED): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->l2rrs); case(e_FM_PCD_PRS_COUNTERS_L3_PARSE_RESULT_RETURNED): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->l3rrs); case(e_FM_PCD_PRS_COUNTERS_L4_PARSE_RESULT_RETURNED): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->l4rrs); case(e_FM_PCD_PRS_COUNTERS_SHIM_PARSE_RESULT_RETURNED): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->srrs); case(e_FM_PCD_PRS_COUNTERS_L2_PARSE_RESULT_RETURNED_WITH_ERR): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->l2rres); case(e_FM_PCD_PRS_COUNTERS_L3_PARSE_RESULT_RETURNED_WITH_ERR): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->l3rres); case(e_FM_PCD_PRS_COUNTERS_L4_PARSE_RESULT_RETURNED_WITH_ERR): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->l4rres); case(e_FM_PCD_PRS_COUNTERS_SHIM_PARSE_RESULT_RETURNED_WITH_ERR): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->srres); case(e_FM_PCD_PRS_COUNTERS_SOFT_PRS_CYCLES): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->spcs); case(e_FM_PCD_PRS_COUNTERS_SOFT_PRS_STALL_CYCLES): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->spscs); case(e_FM_PCD_PRS_COUNTERS_HARD_PRS_CYCLE_INCL_STALL_CYCLES): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->hxscs); case(e_FM_PCD_PRS_COUNTERS_MURAM_READ_CYCLES): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->mrcs); case(e_FM_PCD_PRS_COUNTERS_MURAM_READ_STALL_CYCLES): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->mrscs); case(e_FM_PCD_PRS_COUNTERS_MURAM_WRITE_CYCLES): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->mwcs); case(e_FM_PCD_PRS_COUNTERS_MURAM_WRITE_STALL_CYCLES): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->mwscs); case(e_FM_PCD_PRS_COUNTERS_FPM_COMMAND_STALL_CYCLES): return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fcscs); case(e_FM_PCD_KG_COUNTERS_TOTAL): return GET_UINT32(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs->kgtpc); /*Policer statictics*/ case(e_FM_PCD_PLCR_COUNTERS_YELLOW): return GET_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_ypcnt); case(e_FM_PCD_PLCR_COUNTERS_RED): return GET_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_rpcnt); case(e_FM_PCD_PLCR_COUNTERS_RECOLORED_TO_RED): return GET_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_rrpcnt); case(e_FM_PCD_PLCR_COUNTERS_RECOLORED_TO_YELLOW): return GET_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_rypcnt); case(e_FM_PCD_PLCR_COUNTERS_TOTAL): return GET_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_tpcnt); case(e_FM_PCD_PLCR_COUNTERS_LENGTH_MISMATCH): return GET_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_flmcnt); default: REPORT_ERROR(MINOR, E_INVALID_STATE, ("Unsupported type of counter")); return 0; } } #if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0)) t_Error FM_PCD_DumpRegs(t_Handle h_FmPcd) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; t_FmPcdIpcMsg msg; DECLARE_DUMP; SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE); if(p_FmPcd->guestId != NCSW_MASTER_ID) { memset(&msg, 0, sizeof(msg)); msg.msgId = FM_PCD_DUMP_REGS; return XX_IpcSendMessage(p_FmPcd->h_IpcSession, (uint8_t*)&msg, sizeof(msg.msgId), NULL, NULL, NULL, NULL); } if (p_FmPcd->p_FmPcdKg) return FM_PCD_KgDumpRegs(h_FmPcd); if (p_FmPcd->p_FmPcdPlcr) return FM_PCD_PlcrDumpRegs(h_FmPcd); if (p_FmPcd->p_FmPcdPrs) return FM_PCD_PrsDumpRegs(h_FmPcd); return E_OK; } t_Error FM_PCD_HcDumpRegs(t_Handle h_FmPcd) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; DECLARE_DUMP; SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE); SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc, E_INVALID_STATE); return FmHcDumpRegs(p_FmPcd->h_Hc); } #endif /* (defined(DEBUG_ERRORS) && ... */ t_Error FM_PCD_ConfigException(t_Handle h_FmPcd, e_FmPcdExceptions exception, bool enable) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; uint32_t bitMask = 0; SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); if(p_FmPcd->guestId != NCSW_MASTER_ID) RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("FM_PCD_ConfigException - guest mode!")); GET_FM_PCD_EXCEPTION_FLAG(bitMask, exception); if(bitMask) { if (enable) p_FmPcd->exceptions |= bitMask; else p_FmPcd->exceptions &= ~bitMask; } else RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Undefined exception")); return E_OK; } t_Error FM_PCD_SetException(t_Handle h_FmPcd, e_FmPcdExceptions exception, bool enable) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; uint32_t bitMask = 0, tmpReg; SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE); if(p_FmPcd->guestId != NCSW_MASTER_ID) RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("FM_PCD_SetException - guest mode!")); GET_FM_PCD_EXCEPTION_FLAG(bitMask, exception); if(bitMask) { if (enable) p_FmPcd->exceptions |= bitMask; else p_FmPcd->exceptions &= ~bitMask; switch(exception) { case(e_FM_PCD_KG_EXCEPTION_DOUBLE_ECC): case(e_FM_PCD_KG_EXCEPTION_KEYSIZE_OVERFLOW): if(!p_FmPcd->p_FmPcdKg) RETURN_ERROR(MINOR, E_INVALID_STATE, ("Can't ask for this interrupt - keygen is not working")); break; case(e_FM_PCD_PLCR_EXCEPTION_DOUBLE_ECC): case(e_FM_PCD_PLCR_EXCEPTION_INIT_ENTRY_ERROR): case(e_FM_PCD_PLCR_EXCEPTION_PRAM_SELF_INIT_COMPLETE): case(e_FM_PCD_PLCR_EXCEPTION_ATOMIC_ACTION_COMPLETE): if(!p_FmPcd->p_FmPcdPlcr) RETURN_ERROR(MINOR, E_INVALID_STATE, ("Can't ask for this interrupt - policer is not working")); break; case(e_FM_PCD_PRS_EXCEPTION_DOUBLE_ECC): case(e_FM_PCD_PRS_EXCEPTION_SINGLE_ECC): if(!p_FmPcd->p_FmPcdPrs) RETURN_ERROR(MINOR, E_INVALID_STATE, ("Can't ask for this interrupt - parser is not working")); break; default: RETURN_ERROR(MINOR, E_INVALID_STATE, ("Unsupported exception")); } switch(exception) { case(e_FM_PCD_KG_EXCEPTION_DOUBLE_ECC): tmpReg = GET_UINT32(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs->kgeeer); if(enable) tmpReg |= FM_PCD_KG_DOUBLE_ECC; else tmpReg &= ~FM_PCD_KG_DOUBLE_ECC; WRITE_UINT32(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs->kgeeer, tmpReg); break; case(e_FM_PCD_KG_EXCEPTION_KEYSIZE_OVERFLOW): tmpReg = GET_UINT32(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs->kgeeer); if(enable) tmpReg |= FM_PCD_KG_KEYSIZE_OVERFLOW; else tmpReg &= ~FM_PCD_KG_KEYSIZE_OVERFLOW; WRITE_UINT32(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs->kgeeer, tmpReg); break; case(e_FM_PCD_PRS_EXCEPTION_DOUBLE_ECC): tmpReg = GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->perer); if(enable) tmpReg |= FM_PCD_PRS_DOUBLE_ECC; else tmpReg &= ~FM_PCD_PRS_DOUBLE_ECC; WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->perer, tmpReg); break; case(e_FM_PCD_PRS_EXCEPTION_SINGLE_ECC): tmpReg = GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->pever); if(enable) tmpReg |= FM_PCD_PRS_SINGLE_ECC; else tmpReg &= ~FM_PCD_PRS_SINGLE_ECC; WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->pever, tmpReg); break; case(e_FM_PCD_PLCR_EXCEPTION_DOUBLE_ECC): tmpReg = GET_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_eier); if(enable) tmpReg |= FM_PCD_PLCR_DOUBLE_ECC; else tmpReg &= ~FM_PCD_PLCR_DOUBLE_ECC; WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_eier, tmpReg); break; case(e_FM_PCD_PLCR_EXCEPTION_INIT_ENTRY_ERROR): tmpReg = GET_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_eier); if(enable) tmpReg |= FM_PCD_PLCR_INIT_ENTRY_ERROR; else tmpReg &= ~FM_PCD_PLCR_INIT_ENTRY_ERROR; WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_eier, tmpReg); break; case(e_FM_PCD_PLCR_EXCEPTION_PRAM_SELF_INIT_COMPLETE): tmpReg = GET_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_ier); if(enable) tmpReg |= FM_PCD_PLCR_PRAM_SELF_INIT_COMPLETE; else tmpReg &= ~FM_PCD_PLCR_PRAM_SELF_INIT_COMPLETE; WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_ier, tmpReg); break; case(e_FM_PCD_PLCR_EXCEPTION_ATOMIC_ACTION_COMPLETE): tmpReg = GET_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_ier); if(enable) tmpReg |= FM_PCD_PLCR_ATOMIC_ACTION_COMPLETE; else tmpReg &= ~FM_PCD_PLCR_ATOMIC_ACTION_COMPLETE; WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_ier, tmpReg); break; default: RETURN_ERROR(MINOR, E_INVALID_STATE, ("Unsupported exception")); } /* for ECC exceptions driver automatically enables ECC mechanism, if disabled. Driver may disable them automatically, depending on driver's status */ if(enable && ( (exception == e_FM_PCD_KG_EXCEPTION_DOUBLE_ECC) | (exception == e_FM_PCD_PLCR_EXCEPTION_DOUBLE_ECC) | (exception == e_FM_PCD_PRS_EXCEPTION_DOUBLE_ECC) | (exception == e_FM_PCD_PRS_EXCEPTION_SINGLE_ECC))) FmEnableRamsEcc(p_FmPcd->h_Fm); if(!enable && ( (exception == e_FM_PCD_KG_EXCEPTION_DOUBLE_ECC) | (exception == e_FM_PCD_PLCR_EXCEPTION_DOUBLE_ECC) | (exception == e_FM_PCD_PRS_EXCEPTION_DOUBLE_ECC) | (exception == e_FM_PCD_PRS_EXCEPTION_SINGLE_ECC))) FmDisableRamsEcc(p_FmPcd->h_Fm); } else RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Undefined exception")); return E_OK; } t_Error FM_PCD_ForceIntr (t_Handle h_FmPcd, e_FmPcdExceptions exception) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE); if(p_FmPcd->guestId != NCSW_MASTER_ID) RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("FM_PCD_ForceIntr - guest mode!")); switch(exception) { case(e_FM_PCD_KG_EXCEPTION_DOUBLE_ECC): case(e_FM_PCD_KG_EXCEPTION_KEYSIZE_OVERFLOW): if(!p_FmPcd->p_FmPcdKg) RETURN_ERROR(MINOR, E_INVALID_STATE, ("Can't ask for this interrupt - keygen is not working")); break; case(e_FM_PCD_PLCR_EXCEPTION_DOUBLE_ECC): case(e_FM_PCD_PLCR_EXCEPTION_INIT_ENTRY_ERROR): case(e_FM_PCD_PLCR_EXCEPTION_PRAM_SELF_INIT_COMPLETE): case(e_FM_PCD_PLCR_EXCEPTION_ATOMIC_ACTION_COMPLETE): if(!p_FmPcd->p_FmPcdPlcr) RETURN_ERROR(MINOR, E_INVALID_STATE, ("Can't ask for this interrupt - policer is not working")); break; case(e_FM_PCD_PRS_EXCEPTION_DOUBLE_ECC): case(e_FM_PCD_PRS_EXCEPTION_SINGLE_ECC): if(!p_FmPcd->p_FmPcdPrs) RETURN_ERROR(MINOR, E_INVALID_STATE, ("Can't ask for this interrupt -parsrer is not working")); break; default: RETURN_ERROR(MINOR, E_INVALID_STATE, ("Invalid interrupt requested")); } switch(exception) { case e_FM_PCD_PRS_EXCEPTION_DOUBLE_ECC: if (!(p_FmPcd->exceptions & FM_PCD_EX_PRS_DOUBLE_ECC)) RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked")); WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->perfr, FM_PCD_PRS_DOUBLE_ECC); break; case e_FM_PCD_PRS_EXCEPTION_SINGLE_ECC: if (!(p_FmPcd->exceptions & FM_PCD_EX_PRS_SINGLE_ECC)) RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked")); WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->pevfr, FM_PCD_PRS_SINGLE_ECC); break; case e_FM_PCD_KG_EXCEPTION_DOUBLE_ECC: if (!(p_FmPcd->exceptions & FM_PCD_EX_KG_DOUBLE_ECC)) RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked")); WRITE_UINT32(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs->kgfeer, FM_PCD_KG_DOUBLE_ECC); break; case e_FM_PCD_KG_EXCEPTION_KEYSIZE_OVERFLOW: if (!(p_FmPcd->exceptions & FM_PCD_EX_KG_KEYSIZE_OVERFLOW)) RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked")); WRITE_UINT32(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs->kgfeer, FM_PCD_KG_KEYSIZE_OVERFLOW); break; case e_FM_PCD_PLCR_EXCEPTION_DOUBLE_ECC: if (!(p_FmPcd->exceptions & FM_PCD_EX_PLCR_DOUBLE_ECC)) RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked")); WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_eifr, FM_PCD_PLCR_DOUBLE_ECC); break; case e_FM_PCD_PLCR_EXCEPTION_INIT_ENTRY_ERROR: if (!(p_FmPcd->exceptions & FM_PCD_EX_PLCR_INIT_ENTRY_ERROR)) RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked")); WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_eifr, FM_PCD_PLCR_INIT_ENTRY_ERROR); break; case e_FM_PCD_PLCR_EXCEPTION_PRAM_SELF_INIT_COMPLETE: if (!(p_FmPcd->exceptions & FM_PCD_EX_PLCR_PRAM_SELF_INIT_COMPLETE)) RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked")); WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_ifr, FM_PCD_PLCR_PRAM_SELF_INIT_COMPLETE); break; case e_FM_PCD_PLCR_EXCEPTION_ATOMIC_ACTION_COMPLETE: if (!(p_FmPcd->exceptions & FM_PCD_EX_PLCR_ATOMIC_ACTION_COMPLETE)) RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked")); WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_ifr, FM_PCD_PLCR_ATOMIC_ACTION_COMPLETE); break; default: RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception may not be forced")); } return E_OK; } t_Error FM_PCD_ModifyCounter(t_Handle h_FmPcd, e_FmPcdCounters counter, uint32_t value) { t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE); if(p_FmPcd->guestId != NCSW_MASTER_ID) RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("FM_PCD_ModifyCounter - guest mode!")); switch(counter) { case(e_FM_PCD_KG_COUNTERS_TOTAL): if(!p_FmPcd->p_FmPcdKg) RETURN_ERROR(MINOR, E_INVALID_STATE, ("Can't ask for this counters - keygen is not working")); break; case(e_FM_PCD_PLCR_COUNTERS_YELLOW): case(e_FM_PCD_PLCR_COUNTERS_RED): case(e_FM_PCD_PLCR_COUNTERS_RECOLORED_TO_RED): case(e_FM_PCD_PLCR_COUNTERS_RECOLORED_TO_YELLOW): case(e_FM_PCD_PLCR_COUNTERS_TOTAL): case(e_FM_PCD_PLCR_COUNTERS_LENGTH_MISMATCH): if(!p_FmPcd->p_FmPcdPlcr) RETURN_ERROR(MINOR, E_INVALID_STATE, ("Can't ask for this counters - Policer is not working")); if(!(GET_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_gcr) & FM_PCD_PLCR_GCR_STEN)) RETURN_ERROR(MINOR, E_INVALID_STATE, ("Requested counter was not enabled")); break; case(e_FM_PCD_PRS_COUNTERS_PARSE_DISPATCH): case(e_FM_PCD_PRS_COUNTERS_L2_PARSE_RESULT_RETURNED): case(e_FM_PCD_PRS_COUNTERS_L3_PARSE_RESULT_RETURNED): case(e_FM_PCD_PRS_COUNTERS_L4_PARSE_RESULT_RETURNED): case(e_FM_PCD_PRS_COUNTERS_SHIM_PARSE_RESULT_RETURNED): case(e_FM_PCD_PRS_COUNTERS_L2_PARSE_RESULT_RETURNED_WITH_ERR): case(e_FM_PCD_PRS_COUNTERS_L3_PARSE_RESULT_RETURNED_WITH_ERR): case(e_FM_PCD_PRS_COUNTERS_L4_PARSE_RESULT_RETURNED_WITH_ERR): case(e_FM_PCD_PRS_COUNTERS_SHIM_PARSE_RESULT_RETURNED_WITH_ERR): case(e_FM_PCD_PRS_COUNTERS_SOFT_PRS_CYCLES): case(e_FM_PCD_PRS_COUNTERS_SOFT_PRS_STALL_CYCLES): case(e_FM_PCD_PRS_COUNTERS_HARD_PRS_CYCLE_INCL_STALL_CYCLES): case(e_FM_PCD_PRS_COUNTERS_MURAM_READ_CYCLES): case(e_FM_PCD_PRS_COUNTERS_MURAM_READ_STALL_CYCLES): case(e_FM_PCD_PRS_COUNTERS_MURAM_WRITE_CYCLES): case(e_FM_PCD_PRS_COUNTERS_MURAM_WRITE_STALL_CYCLES): case(e_FM_PCD_PRS_COUNTERS_FPM_COMMAND_STALL_CYCLES): if(!p_FmPcd->p_FmPcdPrs) RETURN_ERROR(MINOR, E_INVALID_STATE, ("Unsupported type of counter")); break; default: RETURN_ERROR(MINOR, E_INVALID_STATE, ("Unsupported type of counter")); } switch(counter) { case(e_FM_PCD_PRS_COUNTERS_PARSE_DISPATCH): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->pds, value); break; case(e_FM_PCD_PRS_COUNTERS_L2_PARSE_RESULT_RETURNED): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->l2rrs, value); break; case(e_FM_PCD_PRS_COUNTERS_L3_PARSE_RESULT_RETURNED): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->l3rrs, value); break; case(e_FM_PCD_PRS_COUNTERS_L4_PARSE_RESULT_RETURNED): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->l4rrs, value); break; case(e_FM_PCD_PRS_COUNTERS_SHIM_PARSE_RESULT_RETURNED): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->srrs, value); break; case(e_FM_PCD_PRS_COUNTERS_L2_PARSE_RESULT_RETURNED_WITH_ERR): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->l2rres, value); break; case(e_FM_PCD_PRS_COUNTERS_L3_PARSE_RESULT_RETURNED_WITH_ERR): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->l3rres, value); break; case(e_FM_PCD_PRS_COUNTERS_L4_PARSE_RESULT_RETURNED_WITH_ERR): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->l4rres, value); break; case(e_FM_PCD_PRS_COUNTERS_SHIM_PARSE_RESULT_RETURNED_WITH_ERR): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->srres, value); break; case(e_FM_PCD_PRS_COUNTERS_SOFT_PRS_CYCLES): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->spcs, value); break; case(e_FM_PCD_PRS_COUNTERS_SOFT_PRS_STALL_CYCLES): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->spscs, value); break; case(e_FM_PCD_PRS_COUNTERS_HARD_PRS_CYCLE_INCL_STALL_CYCLES): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->hxscs, value); break; case(e_FM_PCD_PRS_COUNTERS_MURAM_READ_CYCLES): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->mrcs, value); break; case(e_FM_PCD_PRS_COUNTERS_MURAM_READ_STALL_CYCLES): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->mrscs, value); break; case(e_FM_PCD_PRS_COUNTERS_MURAM_WRITE_CYCLES): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->mwcs, value); break; case(e_FM_PCD_PRS_COUNTERS_MURAM_WRITE_STALL_CYCLES): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->mwscs, value); break; case(e_FM_PCD_PRS_COUNTERS_FPM_COMMAND_STALL_CYCLES): WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fcscs, value); break; case(e_FM_PCD_KG_COUNTERS_TOTAL): WRITE_UINT32(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs->kgtpc,value); break; /*Policer counters*/ case(e_FM_PCD_PLCR_COUNTERS_YELLOW): WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_ypcnt, value); break; case(e_FM_PCD_PLCR_COUNTERS_RED): WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_rpcnt, value); break; case(e_FM_PCD_PLCR_COUNTERS_RECOLORED_TO_RED): WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_rrpcnt, value); break; case(e_FM_PCD_PLCR_COUNTERS_RECOLORED_TO_YELLOW): WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_rypcnt, value); break; case(e_FM_PCD_PLCR_COUNTERS_TOTAL): WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_tpcnt, value); break; case(e_FM_PCD_PLCR_COUNTERS_LENGTH_MISMATCH): WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_flmcnt, value); break; default: RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Unsupported type of counter")); } return E_OK; }