FreeBSD/Linux Kernel Cross Reference
sys/contrib/ncsw/Peripherals/FM/Pcd/fm_pcd.c

     /*
      * 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.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"
    #include "fm_muram_ext.h"
    
    
    /****************************************/
    /*       static functions               */
    /****************************************/
    
    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 IpcMsgCompletionCB(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 IpcMsgHandlerCB(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_FmIpcResourceAllocParams      ipcAllocParams;
               uint16_t                        base;
               memcpy(&ipcAllocParams, p_IpcMsg->msgBody, sizeof(t_FmIpcResourceAllocParams));
               base =  PlcrAllocProfilesForPartition(h_FmPcd,
                                                     ipcAllocParams.base,
                                                     ipcAllocParams.num,
                                                     ipcAllocParams.guestId);
               memcpy(p_IpcReply->replyBody, (uint16_t*)&base, sizeof(uint16_t));
               *p_ReplyLength = sizeof(uint32_t) + sizeof(uint16_t);
               break;
           }
           case (FM_PCD_FREE_PROFILES):
           {
               t_FmIpcResourceAllocParams   ipcAllocParams;
               memcpy(&ipcAllocParams, p_IpcMsg->msgBody, sizeof(t_FmIpcResourceAllocParams));
               PlcrFreeProfilesForPartition(h_FmPcd,
                                            ipcAllocParams.base,
                                            ipcAllocParams.num,
                                            ipcAllocParams.guestId);
               break;
           }
           case (FM_PCD_SET_PORT_PROFILES):
           {
               t_FmIpcResourceAllocParams   ipcAllocParams;
               memcpy(&ipcAllocParams, p_IpcMsg->msgBody, sizeof(t_FmIpcResourceAllocParams));
               PlcrSetPortProfiles(h_FmPcd,
                                   ipcAllocParams.guestId,
                                   ipcAllocParams.num,
                                   ipcAllocParams.base);
               break;
           }
           case (FM_PCD_CLEAR_PORT_PROFILES):
           {
               t_FmIpcResourceAllocParams   ipcAllocParams;
               memcpy(&ipcAllocParams, p_IpcMsg->msgBody, sizeof(t_FmIpcResourceAllocParams));
               PlcrClearPortProfiles(h_FmPcd,
                                     ipcAllocParams.guestId);
               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;
           }
           default:
               *p_ReplyLength = 0;
               RETURN_ERROR(MINOR, E_INVALID_SELECTION, ("command not found!!!"));
       }
       return E_OK;
   }
   
   static uint32_t NetEnvLock(t_Handle h_NetEnv)
   {
       ASSERT_COND(h_NetEnv);
       return XX_LockIntrSpinlock(((t_FmPcdNetEnv*)h_NetEnv)->h_Spinlock);
   }
   
   static void NetEnvUnlock(t_Handle h_NetEnv, uint32_t intFlags)
   {
       ASSERT_COND(h_NetEnv);
       XX_UnlockIntrSpinlock(((t_FmPcdNetEnv*)h_NetEnv)->h_Spinlock, intFlags);
   }
   
   static void EnqueueLockToFreeLst(t_FmPcd *p_FmPcd, t_FmPcdLock *p_Lock)
   {
       uint32_t   intFlags;
   
       intFlags = XX_LockIntrSpinlock(p_FmPcd->h_Spinlock);
       NCSW_LIST_AddToTail(&p_Lock->node, &p_FmPcd->freeLocksLst);
       XX_UnlockIntrSpinlock(p_FmPcd->h_Spinlock, intFlags);
   }
   
   static t_FmPcdLock * DequeueLockFromFreeLst(t_FmPcd *p_FmPcd)
   {
       t_FmPcdLock *p_Lock = NULL;
       uint32_t    intFlags;
   
       intFlags = XX_LockIntrSpinlock(p_FmPcd->h_Spinlock);
       if (!NCSW_LIST_IsEmpty(&p_FmPcd->freeLocksLst))
       {
           p_Lock = FM_PCD_LOCK_OBJ(p_FmPcd->freeLocksLst.p_Next);
           NCSW_LIST_DelAndInit(&p_Lock->node);
       }
       if (p_FmPcd->h_Spinlock)
           XX_UnlockIntrSpinlock(p_FmPcd->h_Spinlock, intFlags);
   
       return p_Lock;
   }
   
   static void EnqueueLockToAcquiredLst(t_FmPcd *p_FmPcd, t_FmPcdLock *p_Lock)
   {
       uint32_t   intFlags;
   
       intFlags = XX_LockIntrSpinlock(p_FmPcd->h_Spinlock);
       NCSW_LIST_AddToTail(&p_Lock->node, &p_FmPcd->acquiredLocksLst);
       XX_UnlockIntrSpinlock(p_FmPcd->h_Spinlock, intFlags);
   }
   
   static t_Error FillFreeLocksLst(t_FmPcd *p_FmPcd)
   {
       t_FmPcdLock *p_Lock;
       int         i;
   
       for (i=0; i<10; i++)
       {
           p_Lock = (t_FmPcdLock *)XX_Malloc(sizeof(t_FmPcdLock));
           if (!p_Lock)
               RETURN_ERROR(MINOR, E_NO_MEMORY, ("FM-PCD lock obj!"));
           memset(p_Lock, 0, sizeof(t_FmPcdLock));
           INIT_LIST(&p_Lock->node);
           p_Lock->h_Spinlock = XX_InitSpinlock();
           if (!p_Lock->h_Spinlock)
           {
               XX_Free(p_Lock);
               RETURN_ERROR(MINOR, E_INVALID_STATE, ("FM-PCD spinlock obj!"));
           }
           EnqueueLockToFreeLst(p_FmPcd, p_Lock);
       }
   
       return E_OK;
   }
   
   static void ReleaseFreeLocksLst(t_FmPcd *p_FmPcd)
   {
       t_FmPcdLock *p_Lock;
   
       p_Lock = DequeueLockFromFreeLst(p_FmPcd);
       while (p_Lock)
       {
           XX_FreeSpinlock(p_Lock->h_Spinlock);
           XX_Free(p_Lock);
           p_Lock = DequeueLockFromFreeLst(p_FmPcd);
       }
   }
   
   
   
   /*****************************************************************************/
   /*              Inter-module API routines                                    */
   /*****************************************************************************/
   
   void FmPcdSetClsPlanGrpId(t_FmPcd *p_FmPcd, uint8_t netEnvId, uint8_t clsPlanGrpId)
   {
       ASSERT_COND(p_FmPcd);
       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;
   
       ASSERT_COND(p_FmPcd);
       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;j<p_GrpParams->numOfOptions;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;
   
       ASSERT_COND(p_FmPcd);
       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;
   
       ASSERT_COND(p_FmPcd);
       ASSERT_COND(p_Params->netEnvId < FM_MAX_NUM_OF_PORTS);
   
       p_Params->vector = 0;
       for (i=0; i<p_Params->numOfDistinctionUnits ;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;
   
       ASSERT_COND(p_FmPcd);
       /* 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_ALIAS_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;
   }
   
   uint8_t FmPcdNetEnvGetUnitId(t_FmPcd *p_FmPcd, uint8_t netEnvId, e_NetHeaderType hdr, bool interchangeable, protocolOpt_t opt)
   {
       uint8_t     i, k;
   
       ASSERT_COND(p_FmPcd);
   
       if (interchangeable)
       {
           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) &&
                       (p_FmPcd->netEnvs[netEnvId].units[i].hdrs[k].opt == opt))
   
                   return i;
               }
           }
       }
       else
       {
           for (i=0; (i < FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS) &&
                    (p_FmPcd->netEnvs[netEnvId].units[i].hdrs[0].hdr != HEADER_TYPE_NONE); i++)
               if ((p_FmPcd->netEnvs[netEnvId].units[i].hdrs[0].hdr == hdr) &&
                   (p_FmPcd->netEnvs[netEnvId].units[i].hdrs[0].opt == opt) &&
                   (p_FmPcd->netEnvs[netEnvId].units[i].hdrs[1].hdr == HEADER_TYPE_NONE))
                       return i;
   
           for (i=0; (i < FM_PCD_MAX_NUM_OF_ALIAS_HDRS) &&
                    (p_FmPcd->netEnvs[netEnvId].aliasHdrs[i].hdr != HEADER_TYPE_NONE); i++)
               if ((p_FmPcd->netEnvs[netEnvId].aliasHdrs[i].hdr == hdr) &&
                   (p_FmPcd->netEnvs[netEnvId].aliasHdrs[i].opt == opt))
                   return p_FmPcd->netEnvs[netEnvId].aliasHdrs[i].aliasHdr;
       }
   
       return FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS;
   }
   
   t_Error FmPcdUnregisterReassmPort(t_Handle h_FmPcd, t_Handle h_ReasmCommonPramTbl)
   {
       t_FmPcd                         *p_FmPcd = (t_FmPcd*)h_FmPcd;
       t_FmPcdCcReassmTimeoutParams    ccReassmTimeoutParams = {0};
       uint8_t                         result;
       t_Error                         err = E_OK;
   
       ASSERT_COND(p_FmPcd);
       ASSERT_COND(h_ReasmCommonPramTbl);
   
       ccReassmTimeoutParams.iprcpt   = (uint32_t)(XX_VirtToPhys(h_ReasmCommonPramTbl) - p_FmPcd->physicalMuramBase);
       ccReassmTimeoutParams.activate = FALSE; /*Disable Timeout Task*/
   
       if ((err = FmHcPcdCcTimeoutReassm(p_FmPcd->h_Hc, &ccReassmTimeoutParams, &result)) != E_OK)
           RETURN_ERROR(MAJOR, err, NO_MSG);
   
       switch (result)
       {
           case (0):
               return E_OK;
           case (1):
               RETURN_ERROR(MAJOR, E_INVALID_STATE, (""));
           case (2):
               RETURN_ERROR(MAJOR, E_INVALID_STATE, (""));
           case (3):
               RETURN_ERROR(MAJOR, E_INVALID_HANDLE, ("Disable Timeout Task with invalid IPRCPT"));
           default:
               RETURN_ERROR(MAJOR, E_INVALID_VALUE, NO_MSG);
       }
   
       return E_OK;
   }
   
   e_NetHeaderType FmPcdGetAliasHdr(t_FmPcd *p_FmPcd, uint8_t netEnvId, e_NetHeaderType hdr)
   {
       int         i;
   
       ASSERT_COND(p_FmPcd);
       ASSERT_COND(netEnvId < FM_MAX_NUM_OF_PORTS);
   
       for (i=0; (i < FM_PCD_MAX_NUM_OF_ALIAS_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;
   
       ASSERT_COND(h_FmPcd);
       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;
   
       ASSERT_COND(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;
   
       ASSERT_COND(h_FmPcd);
       return p_FmPcd->netEnvs[netEnvId].macsecVector;
   }
   
   uint8_t FmPcdGetNetEnvId(t_Handle h_NetEnv)
   {
       return ((t_FmPcdNetEnv*)h_NetEnv)->netEnvId;
   }
   
   void FmPcdIncNetEnvOwners(t_Handle h_FmPcd, uint8_t netEnvId)
   {
       uint32_t    intFlags;
   
       ASSERT_COND(h_FmPcd);
   
       intFlags = NetEnvLock(&((t_FmPcd*)h_FmPcd)->netEnvs[netEnvId]);
       ((t_FmPcd*)h_FmPcd)->netEnvs[netEnvId].owners++;
       NetEnvUnlock(&((t_FmPcd*)h_FmPcd)->netEnvs[netEnvId], intFlags);
   }
   
   void FmPcdDecNetEnvOwners(t_Handle h_FmPcd, uint8_t netEnvId)
   {
       uint32_t    intFlags;
   
       ASSERT_COND(h_FmPcd);
       ASSERT_COND(((t_FmPcd*)h_FmPcd)->netEnvs[netEnvId].owners);
   
       intFlags = NetEnvLock(&((t_FmPcd*)h_FmPcd)->netEnvs[netEnvId]);
       ((t_FmPcd*)h_FmPcd)->netEnvs[netEnvId].owners--;
       NetEnvUnlock(&((t_FmPcd*)h_FmPcd)->netEnvs[netEnvId], intFlags);
   }
   
   uint32_t FmPcdLock(t_Handle h_FmPcd)
   {
       ASSERT_COND(h_FmPcd);
       return XX_LockIntrSpinlock(((t_FmPcd*)h_FmPcd)->h_Spinlock);
   }
   
   void FmPcdUnlock(t_Handle h_FmPcd, uint32_t intFlags)
   {
       ASSERT_COND(h_FmPcd);
       XX_UnlockIntrSpinlock(((t_FmPcd*)h_FmPcd)->h_Spinlock, intFlags);
   }
   
   t_FmPcdLock * FmPcdAcquireLock(t_Handle h_FmPcd)
   {
       t_FmPcdLock *p_Lock;
       ASSERT_COND(h_FmPcd);
       p_Lock = DequeueLockFromFreeLst((t_FmPcd*)h_FmPcd);
       if (!p_Lock)
       {
           FillFreeLocksLst(h_FmPcd);
           p_Lock = DequeueLockFromFreeLst((t_FmPcd*)h_FmPcd);
       }
   
       if (p_Lock)
           EnqueueLockToAcquiredLst((t_FmPcd*)h_FmPcd, p_Lock);
       return p_Lock;
   }
   
   void FmPcdReleaseLock(t_Handle h_FmPcd, t_FmPcdLock *p_Lock)
   {
       uint32_t intFlags;
       ASSERT_COND(h_FmPcd);
       intFlags = FmPcdLock(h_FmPcd);
       NCSW_LIST_DelAndInit(&p_Lock->node);
       FmPcdUnlock(h_FmPcd, intFlags);
       EnqueueLockToFreeLst((t_FmPcd*)h_FmPcd, p_Lock);
   }
   
   bool FmPcdLockTryLockAll(t_Handle h_FmPcd)
   {
       uint32_t    intFlags;
       t_List      *p_Pos, *p_SavedPos=NULL;
   
       ASSERT_COND(h_FmPcd);
       intFlags = FmPcdLock(h_FmPcd);
       NCSW_LIST_FOR_EACH(p_Pos, &((t_FmPcd*)h_FmPcd)->acquiredLocksLst)
       {
           t_FmPcdLock *p_Lock = FM_PCD_LOCK_OBJ(p_Pos);
           if (!FmPcdLockTryLock(p_Lock))
           {
               p_SavedPos = p_Pos;
               break;
           }
       }
       if (p_SavedPos)
       {
           NCSW_LIST_FOR_EACH(p_Pos, &((t_FmPcd*)h_FmPcd)->acquiredLocksLst)
           {
               t_FmPcdLock *p_Lock = FM_PCD_LOCK_OBJ(p_Pos);
               if (p_Pos == p_SavedPos)
                   break;
               FmPcdLockUnlock(p_Lock);
           }
       }
       FmPcdUnlock(h_FmPcd, intFlags);
   
       CORE_MemoryBarrier();
   
       if (p_SavedPos)
           return FALSE;
   
       return TRUE;
   }
   
   void FmPcdLockUnlockAll(t_Handle h_FmPcd)
   {
       uint32_t    intFlags;
       t_List      *p_Pos;
   
       ASSERT_COND(h_FmPcd);
       intFlags = FmPcdLock(h_FmPcd);
       NCSW_LIST_FOR_EACH(p_Pos, &((t_FmPcd*)h_FmPcd)->acquiredLocksLst)
       {
           t_FmPcdLock *p_Lock = FM_PCD_LOCK_OBJ(p_Pos);
           p_Lock->flag = FALSE;
       }
       FmPcdUnlock(h_FmPcd, intFlags);
   
       CORE_MemoryBarrier();
   }
   
   t_Error FmPcdHcSync(t_Handle h_FmPcd)
   {
       ASSERT_COND(h_FmPcd);
       ASSERT_COND(((t_FmPcd*)h_FmPcd)->h_Hc);
   
       return FmHcPcdSync(((t_FmPcd*)h_FmPcd)->h_Hc);
   }
   
   t_Handle FmPcdGetHcHandle(t_Handle h_FmPcd)
   {
       ASSERT_COND(h_FmPcd);
       return ((t_FmPcd*)h_FmPcd)->h_Hc;
   }
   
   bool FmPcdIsAdvancedOffloadSupported(t_Handle h_FmPcd)
   {
       ASSERT_COND(h_FmPcd);
       return ((t_FmPcd*)h_FmPcd)->advancedOffloadSupport;
   }
   /*********************** End of inter-module routines ************************/
   
   
   /****************************************/
   /*       API Init unit functions        */
   /****************************************/
   
   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);
       if (p_FmPcd->h_FmMuram)
       {
           FmGetPhysicalMuramBase(p_FmPcdParams->h_Fm, &physicalMuramBase);
           p_FmPcd->physicalMuramBase = (uint64_t)((uint64_t)(&physicalMuramBase)->low | ((uint64_t)(&physicalMuramBase)->high << 32));
       }
   
       for (i = 0; i<FM_MAX_NUM_OF_PORTS; i++)
           p_FmPcd->netEnvs[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;
       }
       INIT_LIST(&p_FmPcd->freeLocksLst);
       INIT_LIST(&p_FmPcd->acquiredLocksLst);
   
       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;
   
       p_FmPcd->p_CcShadow                 = NULL;
       p_FmPcd->ccShadowSize               = 0;
       p_FmPcd->ccShadowAlign              = 0;
   
       p_FmPcd->h_ShadowSpinlock = XX_InitSpinlock();
       if (!p_FmPcd->h_ShadowSpinlock)
       {
           REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FM PCD shadow spinlock"));
           FM_PCD_Free(p_FmPcd);
           return NULL;
       }
   
       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);
   
       FM_GetRevision(p_FmPcd->h_Fm, &p_FmPcd->fmRevInfo);
   
       if (p_FmPcd->guestId != NCSW_MASTER_ID)
       {
           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)
           {
               t_FmPcdIpcReply         reply;
               uint32_t                replyLength;
               uint8_t                 isMasterAlive = 0;
   
               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,
                                                IpcMsgCompletionCB,
                                                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, IpcMsgHandlerCB, p_FmPcd, FM_PCD_MAX_REPLY_SIZE);
           if (err)
               RETURN_ERROR(MAJOR, err, NO_MSG);
       }
   
       /* IPv6 Frame-Id used for fragmentation */
       p_FmPcd->ipv6FrameIdAddr = PTR_TO_UINT(FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, 4, 4));
       if (!p_FmPcd->ipv6FrameIdAddr)
       {
           FM_PCD_Free(p_FmPcd);
           RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM allocation for IPv6 Frame-Id"));
       }
       IOMemSet32(UINT_TO_PTR(p_FmPcd->ipv6FrameIdAddr), 0,  4);
  
      /* CAPWAP Frame-Id used for fragmentation */
      p_FmPcd->capwapFrameIdAddr = PTR_TO_UINT(FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, 2, 4));
      if (!p_FmPcd->capwapFrameIdAddr)
      {
          FM_PCD_Free(p_FmPcd);
          RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM allocation for CAPWAP Frame-Id"));
      }
      IOMemSet32(UINT_TO_PTR(p_FmPcd->capwapFrameIdAddr), 0,  2);
  
      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->ipv6FrameIdAddr)
          FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, UINT_TO_PTR(p_FmPcd->ipv6FrameIdAddr));
  
      if (p_FmPcd->capwapFrameIdAddr)
          FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, UINT_TO_PTR(p_FmPcd->capwapFrameIdAddr));
  
      if (p_FmPcd->enabled)
          FM_PCD_Disable(p_FmPcd);
  
      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)
      {
          PlcrFree(p_FmPcd);
          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);
  
      ReleaseFreeLocksLst(p_FmPcd);
  
      if (p_FmPcd->h_Spinlock)
          XX_FreeSpinlock(p_FmPcd->h_Spinlock);
  
      if (p_FmPcd->h_ShadowSpinlock)
          XX_FreeSpinlock(p_FmPcd->h_ShadowSpinlock);
  
      XX_Free(p_FmPcd);
  
      return E_OK;
  }
  
  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_ConfigHcFramesDataMemory(t_Handle h_FmPcd, uint8_t memId)
  {
      t_FmPcd         *p_FmPcd = (t_FmPcd*)h_FmPcd;
  
      SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE);
      SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc, E_INVALID_HANDLE);
  
      return FmHcSetFramesDataMemory(p_FmPcd->h_Hc, memId);
  }
  
  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->enabled)
          return E_OK;
  
      if ((p_FmPcd->guestId != NCSW_MASTER_ID) &&
          p_FmPcd->h_IpcSession)
      {
          uint8_t         enabled;
          t_FmPcdIpcMsg   msg;
          t_FmPcdIpcReply reply;
          uint32_t        replyLength;
  
          memset(&reply, 0, sizeof(reply));
          memset(&msg, 0, sizeof(msg));
          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;
      }
      else if (p_FmPcd->guestId != NCSW_MASTER_ID)
          RETURN_ERROR(MINOR, E_NOT_SUPPORTED,
                       ("running in guest-mode without IPC!"));
  
      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;
  
      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;
  
      SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_HANDLE);
  
      if (!p_FmPcd->enabled)
          return E_OK;
  
      if ((p_FmPcd->guestId != NCSW_MASTER_ID) &&
          p_FmPcd->h_IpcSession)
      {
          t_FmPcdIpcMsg       msg;
          t_FmPcdIpcReply     reply;
          uint32_t            replyLength;
  
          memset(&reply, 0, sizeof(reply));
          memset(&msg, 0, sizeof(msg));
          msg.msgId = FM_PCD_GUEST_DISABLE;
          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"));
          if (reply.error == E_OK)
              p_FmPcd->enabled = FALSE;
  
          return (t_Error)(reply.error);
      }
      else if (p_FmPcd->guestId != NCSW_MASTER_ID)
          RETURN_ERROR(MINOR, E_NOT_SUPPORTED,
                       ("running in guest-mode without IPC!"));
  
      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;
  }
  
  t_Handle FM_PCD_NetEnvCharacteristicsSet(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;
      t_FmPcdNetEnvParams     *p_ModifiedNetEnvParams;
  
      SANITY_CHECK_RETURN_VALUE(h_FmPcd, E_INVALID_STATE, NULL);
      SANITY_CHECK_RETURN_VALUE(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE, NULL);
      SANITY_CHECK_RETURN_VALUE(p_NetEnvParams, E_NULL_POINTER, NULL);
  
      intFlags = FmPcdLock(p_FmPcd);
  
      /* find a new netEnv */
      for (i = 0; i < FM_MAX_NUM_OF_PORTS; i++)
          if (!p_FmPcd->netEnvs[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;
      FmPcdUnlock(p_FmPcd, intFlags);
  
      /* As anyone doesn't have handle of this netEnv yet, no need
         to protect it with spinlocks */
  
      p_ModifiedNetEnvParams = (t_FmPcdNetEnvParams *)XX_Malloc(sizeof(t_FmPcdNetEnvParams));
      if (!p_ModifiedNetEnvParams)
      {
          REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FmPcdNetEnvParams"));
          return NULL;
      }
  
      memcpy(p_ModifiedNetEnvParams, p_NetEnvParams, sizeof(t_FmPcdNetEnvParams));
      p_NetEnvParams = p_ModifiedNetEnvParams;
  
      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_ALIAS_HDRS * sizeof(t_FmPcdNetEnvAliases));
      memcpy(&p_FmPcd->netEnvs[netEnvCurrId].units, p_NetEnvParams->units, p_NetEnvParams->numOfDistinctionUnits*sizeof(t_FmPcdIntDistinctionUnit));
  
      p_FmPcd->netEnvs[netEnvCurrId].netEnvId = netEnvCurrId;
      p_FmPcd->netEnvs[netEnvCurrId].h_FmPcd = p_FmPcd;
  
      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"));
                          XX_Free(p_ModifiedNetEnvParams);
                          return NULL;
                      }
                  }
              }
          }
      }
  
      /* Specific headers checking  */
      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 */
              /* IPSEC_AH and IPSEC_SPI can't be 2 units,  */
              /* check that header with opt is not interchanged with the same header */
              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"));
                      XX_Free(p_ModifiedNetEnvParams);
                      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"));
                      XX_Free(p_ModifiedNetEnvParams);
                      return NULL;
                  }
                  else
                  {
                      ipsecEspUnit = i;
                      ipsecEspExists = TRUE;
                  }
              }
              /* ENCAP_ESP  */
              if (p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr == HEADER_TYPE_UDP_ENCAP_ESP)
              {
                  /* IPSec UDP encapsulation is currently set to use SHIM1 */
                  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 (DPAA_VERSION >= 11) || ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT))
              /* UDP_LITE  */
              if (p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr == HEADER_TYPE_UDP_LITE)
              {
                  p_FmPcd->netEnvs[netEnvCurrId].aliasHdrs[specialUnits].hdr = HEADER_TYPE_UDP_LITE;
                  p_FmPcd->netEnvs[netEnvCurrId].aliasHdrs[specialUnits++].aliasHdr = HEADER_TYPE_UDP;
                  p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr = HEADER_TYPE_UDP;
                  p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].opt = 0;
              }
  #endif /* (DPAA_VERSION >= 11) || ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT)) */
  
              /* IP FRAG  */
              if ((p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr == HEADER_TYPE_IPv4) &&
                  (p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].opt == IPV4_FRAG_1))
              {
                  /* If IPv4+Frag, we need to set 2 units - SHIM 2 and IPv4. We first set SHIM2, and than check if
                   * IPv4 exists. If so we don't need to set an extra unit
                   * We consider as "having IPv4" any IPv4 without interchangable headers
                   * but including any options.  */
                  p_FmPcd->netEnvs[netEnvCurrId].aliasHdrs[specialUnits].hdr = HEADER_TYPE_IPv4;
                  p_FmPcd->netEnvs[netEnvCurrId].aliasHdrs[specialUnits].opt = IPV4_FRAG_1;
                  p_FmPcd->netEnvs[netEnvCurrId].aliasHdrs[specialUnits++].aliasHdr = HEADER_TYPE_USER_DEFINED_SHIM2;
                  p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr = HEADER_TYPE_USER_DEFINED_SHIM2;
                  p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].opt = 0;
  
                  /* check if IPv4 header exists by itself */
                  if (FmPcdNetEnvGetUnitId(p_FmPcd, netEnvCurrId, HEADER_TYPE_IPv4, FALSE, 0) == FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS)
                  {
                      p_FmPcd->netEnvs[netEnvCurrId].units[p_NetEnvParams->numOfDistinctionUnits].hdrs[0].hdr = HEADER_TYPE_IPv4;
                      p_FmPcd->netEnvs[netEnvCurrId].units[p_NetEnvParams->numOfDistinctionUnits++].hdrs[0].opt = 0;
                  }
              }
              if ((p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr == HEADER_TYPE_IPv6) &&
                  (p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].opt == IPV6_FRAG_1))
              {
                  /* If IPv6+Frag, we need to set 2 units - SHIM 2 and IPv6. We first set SHIM2, and than check if
                   * IPv4 exists. If so we don't need to set an extra unit
                   * We consider as "having IPv6" any IPv6 without interchangable headers
                   * but including any options.  */
                  p_FmPcd->netEnvs[netEnvCurrId].aliasHdrs[specialUnits].hdr = HEADER_TYPE_IPv6;
                  p_FmPcd->netEnvs[netEnvCurrId].aliasHdrs[specialUnits].opt = IPV6_FRAG_1;
                  p_FmPcd->netEnvs[netEnvCurrId].aliasHdrs[specialUnits++].aliasHdr = HEADER_TYPE_USER_DEFINED_SHIM2;
                  p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr = HEADER_TYPE_USER_DEFINED_SHIM2;
                  p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].opt = 0;
  
                  /* check if IPv6 header exists by itself */
                  if (FmPcdNetEnvGetUnitId(p_FmPcd, netEnvCurrId, HEADER_TYPE_IPv6, FALSE, 0) == FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS)
                  {
                      p_FmPcd->netEnvs[netEnvCurrId].units[p_NetEnvParams->numOfDistinctionUnits].hdrs[0].hdr = HEADER_TYPE_IPv6;
                      p_FmPcd->netEnvs[netEnvCurrId].units[p_NetEnvParams->numOfDistinctionUnits++].hdrs[0].opt = 0;
                  }
              }
  #if (DPAA_VERSION >= 11)
              /* CAPWAP FRAG  */
              if ((p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr == HEADER_TYPE_CAPWAP) &&
                  (p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].opt == CAPWAP_FRAG_1))
              {
                  p_FmPcd->netEnvs[netEnvCurrId].aliasHdrs[specialUnits].hdr = HEADER_TYPE_CAPWAP;
                  p_FmPcd->netEnvs[netEnvCurrId].aliasHdrs[specialUnits].opt = CAPWAP_FRAG_1;
                  p_FmPcd->netEnvs[netEnvCurrId].aliasHdrs[specialUnits++].aliasHdr = HEADER_TYPE_USER_DEFINED_SHIM2;
                  p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr = HEADER_TYPE_USER_DEFINED_SHIM2;
                  p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].opt = 0;
              }
  #endif /* (DPAA_VERSION >= 11) */
          }
      }
  
      /* 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"));
                  XX_Free(p_ModifiedNetEnvParams);
                  return NULL;
              }
      }
  
      for (i = 0; i < p_NetEnvParams->numOfDistinctionUnits; 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"));
                          XX_Free(p_ModifiedNetEnvParams);
                          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++)
              {
                  hdrNum = GetPrsHdrNum(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);
                      XX_Free(p_ModifiedNetEnvParams);
                      return NULL;
                  }
                  p_FmPcd->netEnvs[netEnvCurrId].lcvs[hdrNum] |= p_FmPcd->netEnvs[netEnvCurrId].unitsVectors[i];
              }
          }
      }
      XX_Free(p_ModifiedNetEnvParams);
  
      p_FmPcd->netEnvs[netEnvCurrId].h_Spinlock = XX_InitSpinlock();
      if (!p_FmPcd->netEnvs[netEnvCurrId].h_Spinlock)
      {
          REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FM Pcd NetEnv spinlock"));
          return NULL;
      }
      return &p_FmPcd->netEnvs[netEnvCurrId];
  }
  
  t_Error FM_PCD_NetEnvCharacteristicsDelete(t_Handle h_NetEnv)
  {
      t_FmPcdNetEnv   *p_NetEnv = (t_FmPcdNetEnv*)h_NetEnv;
      t_FmPcd         *p_FmPcd = p_NetEnv->h_FmPcd;
      uint32_t        intFlags;
      uint8_t         netEnvId = p_NetEnv->netEnvId;
  
      SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_STATE);
      SANITY_CHECK_RETURN_ERROR(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE);
  
      /* check that no port is bound to this netEnv */
      if (p_FmPcd->netEnvs[netEnvId].owners)
      {
          RETURN_ERROR(MINOR, E_INVALID_STATE,
                  ("Trying to delete a netEnv that has ports/schemes/trees/clsPlanGrps bound to"));
      }
  
      intFlags = FmPcdLock(p_FmPcd);
  
      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);
  
      if (p_FmPcd->netEnvs[netEnvId].h_Spinlock)
          XX_FreeSpinlock(p_FmPcd->netEnvs[netEnvId].h_Spinlock);
  
      FmPcdUnlock(p_FmPcd, intFlags);
      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);
  }
  
  t_Error FM_PCD_SetAdvancedOffloadSupport(t_Handle h_FmPcd)
  {
      t_FmPcd                     *p_FmPcd = (t_FmPcd*)h_FmPcd;
      t_FmCtrlCodeRevisionInfo    revInfo;
      t_Error                     err;
  
      SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE);
      SANITY_CHECK_RETURN_ERROR(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE);
      SANITY_CHECK_RETURN_ERROR(!p_FmPcd->enabled, E_INVALID_STATE);
  
      if ((err = FM_GetFmanCtrlCodeRevision(p_FmPcd->h_Fm, &revInfo)) != E_OK)
      {
          DBG(WARNING, ("FM in guest-mode without IPC, can't validate firmware revision."));
          revInfo.packageRev = IP_OFFLOAD_PACKAGE_NUMBER;
      }
      if (!IS_OFFLOAD_PACKAGE(revInfo.packageRev))
          RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("Fman ctrl code package"));
  
      if (!p_FmPcd->h_Hc)
          RETURN_ERROR(MAJOR, E_INVALID_HANDLE, ("HC must be initialized in this mode"));
  
      p_FmPcd->advancedOffloadSupport = TRUE;
  
      return E_OK;
  }
  
  uint32_t FM_PCD_GetCounter(t_Handle h_FmPcd, e_FmPcdCounters counter)
  {
      t_FmPcd                 *p_FmPcd = (t_FmPcd*)h_FmPcd;
      uint32_t                outCounter = 0;
      t_Error                 err;
  
      SANITY_CHECK_RETURN_VALUE(h_FmPcd, E_INVALID_HANDLE, 0);
      SANITY_CHECK_RETURN_VALUE(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE, 0);
  
      switch (counter)
      {
          case (e_FM_PCD_KG_COUNTERS_TOTAL):
              if (!p_FmPcd->p_FmPcdKg)
              {
                  REPORT_ERROR(MAJOR, E_INVALID_STATE, ("KeyGen is not activated"));
                  return 0;
              }
              if ((p_FmPcd->guestId != NCSW_MASTER_ID) &&
                  !p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs &&
                  !p_FmPcd->h_IpcSession)
              {
                  REPORT_ERROR(MINOR, E_NOT_SUPPORTED,
                               ("running in guest-mode without neither IPC nor mapped register!"));
                  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(MAJOR, E_INVALID_STATE, ("Policer is not activated"));
                  return 0;
              }
              if ((p_FmPcd->guestId != NCSW_MASTER_ID) &&
                  !p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs &&
                  !p_FmPcd->h_IpcSession)
              {
                  REPORT_ERROR(MINOR, E_NOT_SUPPORTED,
                               ("running in \"guest-mode\" without neither IPC nor mapped register!"));
                  return 0;
              }
  
              /* check that counters are enabled */
              if (p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs &&
                  !(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;
              }
              ASSERT_COND(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs ||
                          ((p_FmPcd->guestId != NCSW_MASTER_ID) && p_FmPcd->h_IpcSession));
              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(MAJOR, E_INVALID_STATE, ("Parser is not activated"));
                  return 0;
              }
              if ((p_FmPcd->guestId != NCSW_MASTER_ID) &&
                  !p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs &&
                  !p_FmPcd->h_IpcSession)
              {
                  REPORT_ERROR(MINOR, E_NOT_SUPPORTED,
                               ("running in guest-mode without neither IPC nor mapped register!"));
                  return 0;
              }
              break;
          default:
              REPORT_ERROR(MAJOR, E_INVALID_STATE, ("Unsupported type of counter"));
              return 0;
      }
  
      if ((p_FmPcd->guestId != NCSW_MASTER_ID) &&
          p_FmPcd->h_IpcSession)
      {
          t_FmPcdIpcMsg           msg;
          t_FmPcdIpcReply         reply;
          uint32_t                replyLength;
  
          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)
      {
          /* Parser statistics */
          case (e_FM_PCD_PRS_COUNTERS_PARSE_DISPATCH):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_pds);
          case (e_FM_PCD_PRS_COUNTERS_L2_PARSE_RESULT_RETURNED):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_l2rrs);
          case (e_FM_PCD_PRS_COUNTERS_L3_PARSE_RESULT_RETURNED):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_l3rrs);
          case (e_FM_PCD_PRS_COUNTERS_L4_PARSE_RESULT_RETURNED):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_l4rrs);
          case (e_FM_PCD_PRS_COUNTERS_SHIM_PARSE_RESULT_RETURNED):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_srrs);
          case (e_FM_PCD_PRS_COUNTERS_L2_PARSE_RESULT_RETURNED_WITH_ERR):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_l2rres);
          case (e_FM_PCD_PRS_COUNTERS_L3_PARSE_RESULT_RETURNED_WITH_ERR):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_l3rres);
          case (e_FM_PCD_PRS_COUNTERS_L4_PARSE_RESULT_RETURNED_WITH_ERR):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_l4rres);
          case (e_FM_PCD_PRS_COUNTERS_SHIM_PARSE_RESULT_RETURNED_WITH_ERR):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_srres);
          case (e_FM_PCD_PRS_COUNTERS_SOFT_PRS_CYCLES):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_spcs);
          case (e_FM_PCD_PRS_COUNTERS_SOFT_PRS_STALL_CYCLES):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_spscs);
          case (e_FM_PCD_PRS_COUNTERS_HARD_PRS_CYCLE_INCL_STALL_CYCLES):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_hxscs);
          case (e_FM_PCD_PRS_COUNTERS_MURAM_READ_CYCLES):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_mrcs);
          case (e_FM_PCD_PRS_COUNTERS_MURAM_READ_STALL_CYCLES):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_mrscs);
          case (e_FM_PCD_PRS_COUNTERS_MURAM_WRITE_CYCLES):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_mwcs);
          case (e_FM_PCD_PRS_COUNTERS_MURAM_WRITE_STALL_CYCLES):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_mwscs);
          case (e_FM_PCD_PRS_COUNTERS_FPM_COMMAND_STALL_CYCLES):
                 return GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_fcscs);
          case (e_FM_PCD_KG_COUNTERS_TOTAL):
                 return GET_UINT32(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs->fmkg_tpc);
  
          /* Policer statistics */
          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);
      }
      return 0;
  }
  
  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;
          }
  
          switch (exception)
          {
              case (e_FM_PCD_KG_EXCEPTION_DOUBLE_ECC):
                  tmpReg = GET_UINT32(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs->fmkg_eeer);
                  if (enable)
                      tmpReg |= FM_EX_KG_DOUBLE_ECC;
                  else
                      tmpReg &= ~FM_EX_KG_DOUBLE_ECC;
                  WRITE_UINT32(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs->fmkg_eeer, tmpReg);
                  break;
              case (e_FM_PCD_KG_EXCEPTION_KEYSIZE_OVERFLOW):
                  tmpReg = GET_UINT32(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs->fmkg_eeer);
                  if (enable)
                      tmpReg |= FM_EX_KG_KEYSIZE_OVERFLOW;
                  else
                      tmpReg &= ~FM_EX_KG_KEYSIZE_OVERFLOW;
                  WRITE_UINT32(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs->fmkg_eeer, tmpReg);
                  break;
              case (e_FM_PCD_PRS_EXCEPTION_DOUBLE_ECC):
                  tmpReg = GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_perer);
                  if (enable)
                      tmpReg |= FM_PCD_PRS_DOUBLE_ECC;
                  else
                      tmpReg &= ~FM_PCD_PRS_DOUBLE_ECC;
                  WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_perer, tmpReg);
                  break;
              case (e_FM_PCD_PRS_EXCEPTION_SINGLE_ECC):
                  tmpReg = GET_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_pever);
                  if (enable)
                      tmpReg |= FM_PCD_PRS_SINGLE_ECC;
                  else
                      tmpReg &= ~FM_PCD_PRS_SINGLE_ECC;
                  WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_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;
          }
          /* 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);
      }
  
      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(MAJOR, 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"));
              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"));
              break;
          case e_FM_PCD_KG_EXCEPTION_DOUBLE_ECC:
              if (!(p_FmPcd->exceptions & FM_EX_KG_DOUBLE_ECC))
                  RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked"));
              WRITE_UINT32(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs->fmkg_feer, FM_EX_KG_DOUBLE_ECC);
              break;
          case e_FM_PCD_KG_EXCEPTION_KEYSIZE_OVERFLOW:
              if (!(p_FmPcd->exceptions & FM_EX_KG_KEYSIZE_OVERFLOW))
                  RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked"));
              WRITE_UINT32(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs->fmkg_feer, FM_EX_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;
      }
  
      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, ("Invalid 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, ("Invalid 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->fmpr_pds, value);
              break;
          case (e_FM_PCD_PRS_COUNTERS_L2_PARSE_RESULT_RETURNED):
                 WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_l2rrs, value);
              break;
          case (e_FM_PCD_PRS_COUNTERS_L3_PARSE_RESULT_RETURNED):
                 WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_l3rrs, value);
               break;
         case (e_FM_PCD_PRS_COUNTERS_L4_PARSE_RESULT_RETURNED):
                 WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_l4rrs, value);
              break;
          case (e_FM_PCD_PRS_COUNTERS_SHIM_PARSE_RESULT_RETURNED):
                 WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_srrs, value);
              break;
          case (e_FM_PCD_PRS_COUNTERS_L2_PARSE_RESULT_RETURNED_WITH_ERR):
                 WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_l2rres, value);
              break;
          case (e_FM_PCD_PRS_COUNTERS_L3_PARSE_RESULT_RETURNED_WITH_ERR):
                 WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_l3rres, value);
              break;
          case (e_FM_PCD_PRS_COUNTERS_L4_PARSE_RESULT_RETURNED_WITH_ERR):
                 WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_l4rres, value);
              break;
          case (e_FM_PCD_PRS_COUNTERS_SHIM_PARSE_RESULT_RETURNED_WITH_ERR):
                 WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_srres, value);
              break;
          case (e_FM_PCD_PRS_COUNTERS_SOFT_PRS_CYCLES):
                 WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_spcs, value);
              break;
          case (e_FM_PCD_PRS_COUNTERS_SOFT_PRS_STALL_CYCLES):
                 WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_spscs, value);
              break;
          case (e_FM_PCD_PRS_COUNTERS_HARD_PRS_CYCLE_INCL_STALL_CYCLES):
                 WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_hxscs, value);
              break;
          case (e_FM_PCD_PRS_COUNTERS_MURAM_READ_CYCLES):
                 WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_mrcs, value);
              break;
          case (e_FM_PCD_PRS_COUNTERS_MURAM_READ_STALL_CYCLES):
                 WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_mrscs, value);
              break;
          case (e_FM_PCD_PRS_COUNTERS_MURAM_WRITE_CYCLES):
                 WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_mwcs, value);
              break;
          case (e_FM_PCD_PRS_COUNTERS_MURAM_WRITE_STALL_CYCLES):
                 WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_mwscs, value);
              break;
          case (e_FM_PCD_PRS_COUNTERS_FPM_COMMAND_STALL_CYCLES):
                 WRITE_UINT32(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs->fmpr_fcscs, value);
               break;
          case (e_FM_PCD_KG_COUNTERS_TOTAL):
              WRITE_UINT32(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs->fmkg_tpc,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;
      }
  
      return E_OK;
  }
  
  t_Handle FM_PCD_GetHcPort(t_Handle h_FmPcd)
  {
      t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd;
      return FmHcGetPort(p_FmPcd->h_Hc);
  }
  

Cache object: c965485246b7e899c7f1ddd550b1ab3a