/* header include files (.h) */

#include "envopt.h"        /* environment options */
#include "envdep.h"        /* environment dependent */
#include "envind.h"        /* environment independent */

#include "gen.h"           /* general layer */
#include "ssi.h"           /* system services */

#include "ss_err.h"        /* errors */
#include "ss_dep.h"        /* implementation-specific */
#include "ss_queue.h"      /* queues */
#include "ss_task.h"       /* tasking */
#include "ss_strm.h"       /* STREAMS */
#include "ss_msg.h"        /* messaging */
#include "ss_mem.h"        /* memory management interface */
#include "ss_gen.h"        /* general */
#include "cm_mem.h"


/* header/extern include files (.x) */

#include "gen.x"           /* general layer */
#include "ssi.x"           /* system services */

#include "ss_dep.x"        /* implementation-specific */
#include "ss_queue.x"      /* queues */
#include "ss_task.x"       /* tasking */
#include "ss_timer.x"      /* timers */
#include "ss_strm.x"       /* STREAMS */
#include "ss_msg.x"        /* messaging */
#include "ss_mem.x"        /* memory management interface */
#include "ss_drvr.x"       /* driver tasks */
#include "ss_gen.x"        /* general */
#include "cm_mem.x"


#include "ss_region.x"     /* region control */
#include "stdlib.h"




PUBLIC RegionCb_s regionCb;


PUBLIC Cntr cfgNumRegs = SS_MAX_REGS;

PUBLIC SsRegCfg cfgRegInfo[SS_MAX_REGS];


/***********************************************************************************
* Function Name           : SInitRegion
* Input Parameters        : 
* Output Parameters       :
* Return value            :
* Global Variable Accessed:
* Global Variable Modified:
* Extern Call Functions   :
* Description             :
* Modification            :
************************************************************************************/
S16 SInitRegion(void)
{
    U32 i, j;

    if (ROK != SInitLock(&regionCb.mutex, 0))
    {
        SSLOGERROR( ERRCLS_DEBUG, ESS001, 87, "Invalid value" );
        RETVALUE(RFAILED);
    }


    for (i = 0; i < SS_MAX_REGS; i++)
    {
        cfgRegInfo[i].region = i;
        cfgRegInfo[i].numPools = SS_MAX_POOLS_PER_REG - 1;
        for (j = 0; j < SS_MAX_POOLS_PER_REG - 1; j++)
        {
            cfgRegInfo[i].pools[j].size = POOL_SIZE;
            cfgRegInfo[i].pools[j].type = SS_POOL_DYNAMIC;
        }
        cfgRegInfo[i].pools[SS_MAX_POOLS_PER_REG - 1].size = 0;
        cfgRegInfo[i].pools[SS_MAX_POOLS_PER_REG - 1].type = SS_POOL_STATIC;

        regionCb.regionIdTbl[i].regionId = i;
        regionCb.regionIdTbl[i].used = FALSE;
        regionCb.regionIdTbl[i].regCb = NULLP;
    }
    RETVALUE(ROK);
}
/***********************************************************************************
* Function Name           : SGetRegId
* Input Parameters        : 
* Output Parameters       :
* Return value            :
* Global Variable Accessed:
* Global Variable Modified:
* Extern Call Functions   :
* Description             :
* Modification            :
************************************************************************************/
S16 SRegRegId(Ent ent, Inst inst, Region regId)
{
    S8 * name;

    SLock(&regionCb.mutex);

    if (regId >= SS_MAX_REGS)
    {
        SUnlock(&regionCb.mutex);
        SSLOGERROR( ERRCLS_DEBUG, ESS001, 87, "Invalid value" );
        RETVALUE(RFAILED);
    }
    if (regionCb.regionIdTbl[regId].used == TRUE)
    {
        SUnlock(&regionCb.mutex);
        SSLOGERROR( ERRCLS_DEBUG, ESS001, 87, "Invalid value" );
        RETVALUE(RFAILED);
    }

    if (ROK != ssGetEntName(ent, &name))
    {
        SUnlock(&regionCb.mutex);
        SSLOGERROR( ERRCLS_DEBUG, ESS001, 87, "Invalid value" );
        RETVALUE(RFAILED);
    }

    regionCb.regionIdTbl[regId].ent = ent;
    regionCb.regionIdTbl[regId].inst = inst;


    regionCb.regionIdTbl[regId].used = TRUE;
    SUnlock(&regionCb.mutex);
    RETVALUE(ROK);
}
/***********************************************************************************
* Function Name           : SFreeRegId
* Input Parameters        : 
* Output Parameters       :
* Return value            :
* Global Variable Accessed:
* Global Variable Modified:
* Extern Call Functions   :
* Description             :
* Modification            :
************************************************************************************/
S16 SDeregRegId(Region region)
{
    if (region >= SS_MAX_REGS )
    {
        SSLOGERROR( ERRCLS_DEBUG, ESS001, 87, "Invalid value" );
        RETVALUE(RFAILED);
    }
    SLock(&regionCb.mutex);

    regionCb.regionIdTbl[region].used = FALSE;
    regionCb.regionIdTbl[region].regCb = NULLP;
    SUnlock(&regionCb.mutex);
    RETVALUE(ROK);
}


/***********************************************************************************
* Function Name           : SCreateRegion
* Input Parameters        : 
* Output Parameters       :
* Return value            :
* Global Variable Accessed:
* Global Variable Modified:
* Extern Call Functions   :
* Description             :
* Modification            :
************************************************************************************/
S16 SCreateRegion(Ent ent, Inst inst, Region regId, RegionCfg_s * cfg, U16 numBlock)
{
    CmMmRegCb * RegCb;
    U32 regionSize = 0;
    U32 Cnt;

    TRC0(SCreateRegion);

    if (NULLP == cfg)
    {
        SSLOGERROR( ERRCLS_DEBUG, ESS001, 87, "Invalid value" );
        RETVALUE(RFAILED);
    }
    if ( 0 == numBlock || CMM_MAX_BKT_ENT < numBlock )
    {
        SSLOGERROR( ERRCLS_DEBUG, ESS001, 87, "Invalid value" );
        RETVALUE(RFAILED);
    }

    if (regId >= SS_MAX_REGS)
    {
        SSLOGERROR( ERRCLS_DEBUG, ESS001, 87, "Invalid value" );
        RETVALUE(RFAILED);
    }

    if (RFAILED == SRegRegId(ent, inst, regId))
    {
        SSLOGERROR( ERRCLS_DEBUG, ESS001, 87, "can not get region" );
        RETVALUE(RFAILED);
    }

    #ifdef AMOS
    RegCb = (CmMmRegCb *)MALLOC(sizeof(CmMmRegCb));
    #else
    RegCb = (CmMmRegCb *)calloc(1, sizeof(CmMmRegCb));
    #endif
    if (NULLP == RegCb)
    {
        SDeregRegId(regId);
        RETVALUE(RFAILED);
    }
    for (Cnt = 0;Cnt < numBlock; Cnt++)
    {
        regionSize += cfg[Cnt].bktSize * cfg[Cnt].numBlks + cfg[Cnt].heapSize;
    }
    #ifdef AMOS
    regionCb.regionIdTbl[regId].regCfg.vAddr = (Data *)MALLOC(regionSize * sizeof(Data));
    #else
    regionCb.regionIdTbl[regId].regCfg.vAddr = (Data *)calloc(regionSize, sizeof(Data));
    #endif
    if (regionCb.regionIdTbl[regId].regCfg.vAddr == NULLP)
    {
        SDeregRegId(regId);
        free(RegCb);
        SSLOGERROR( ERRCLS_DEBUG, ESS001, 87, "Invalid value" );
        RETVALUE(RFAILED);
    }

    /* set up the CMM configuration structure */
    regionCb.regionIdTbl[regId].regCfg.size = regionSize;
    regionCb.regionIdTbl[regId].regCfg.lType = SS_LOCK_MUTEX;
    regionCb.regionIdTbl[regId].regCfg.chFlag = DFLT_REG_FLAG;
    regionCb.regionIdTbl[regId].regCfg.bktQnSize = 16;
    regionCb.regionIdTbl[regId].regCfg.numBkts = numBlock;

    for (Cnt = 0; Cnt < numBlock; Cnt ++)
    {
        regionCb.regionIdTbl[regId].regCfg.bktCfg[Cnt].size = cfg[Cnt].bktSize;
        regionCb.regionIdTbl[regId].regCfg.bktCfg[Cnt].numBlks = cfg[Cnt].numBlks;
    }
    if (cmMmRegInit(regId, RegCb, &regionCb.regionIdTbl[regId].regCfg) != ROK)
    {
        SDeregRegId(regId);
        free(regionCb.regionIdTbl[regId].regCfg.vAddr);
        free(RegCb);
        SSLOGERROR( ERRCLS_DEBUG, ESS001, 87, "Invalid value" );
        RETVALUE(RFAILED);
    }
    SLock(&regionCb.mutex);
    regionCb.regionIdTbl[regId].regCb = RegCb;
    SUnlock(&regionCb.mutex);

    RETVALUE(OK);
}

S16 SDelRegion(Region regId)
{
    if (regId == SS_DFLT_REGION || regId >= SS_MAX_REGS)
    {
        SSLOGERROR( ERRCLS_DEBUG, ESS001, 87, "Invalid value" );
        RETVALUE(RFAILED);
    }
    SLock(&regionCb.mutex);
    if (regionCb.regionIdTbl[regId].used == FALSE)
    {
        SUnlock(&regionCb.mutex);
        SSLOGERROR( ERRCLS_DEBUG, ESS001, 87, "Invalid value" );
        RETVALUE(RFAILED);
    }

    cmMmRegDeInit(regionCb.regionIdTbl[regId].regCb);
    #ifdef AMOS
    FREE(regionCb.regionIdTbl[regId].regCfg.vAddr);
    FREE(regionCb.regionIdTbl[regId].regCb);
    #else
    free(regionCb.regionIdTbl[regId].regCfg.vAddr);
    free(regionCb.regionIdTbl[regId].regCb);
    #endif

    SDeregRegId(regId);
    SUnlock(&regionCb.mutex);
    RETVALUE(ROK);
}





/***********************************************************************************
* Function Name           : SRegShow
* Input Parameters        : 
* Output Parameters       :
* Return value            :
* Global Variable Accessed:
* Global Variable Modified:
* Extern Call Functions   :
* Description             :
* Modification            :
************************************************************************************/


S16 SRegShow(Region region, Pool pool)
{
    S16 ret;
    SMemCtl mctl;


    TRC1(SChkRes);


#if (ERRCLASS & ERRCLS_INT_PAR)

    /* validate region ID */
    if (region >= SS_MAX_REGS)
    {
        SSLOGERROR(ERRCLS_INT_PAR, ESS362, region, "Invalid region");
        RETVALUE(RFAILED);
    }

    /* validate pool ID */
    if (pool >= SS_MAX_POOLS_PER_REG)
    {
        SSLOGERROR(ERRCLS_INT_PAR, ESS363, region, "Invalid pool");
        RETVALUE(RFAILED);
    }

#endif

    /* acquire one semaphore, to protect against deregistration */
    SS_ACQUIRE_SEMA(&osCp.regionTblSem, ret);
    if (ret != ROK)
    {

#if (ERRCLASS & ERRCLS_DEBUG)
        SSLOGERROR(ERRCLS_DEBUG, ESS365, (ErrVal) ret,
                   "Could not lock region table");
#endif

        RETVALUE(RFAILED);
    }


#if (ERRCLASS & ERRCLS_INT_PAR)
    /* verify that this region is around */
    if (osCp.regionTbl[region].used == FALSE)
    {
        SS_RELEASE_SEMA(&osCp.regionTblSem);

        SSLOGERROR(ERRCLS_INT_PAR, ESS366, region, "Region not registered");
        RETVALUE(RFAILED);
    }

    /* verify that this is a valid pool */
    if (osCp.regionTbl[region].poolTbl[pool].type != SS_POOL_DYNAMIC)
    {
        SSLOGERROR(ERRCLS_DEBUG, ESS367, ERRZERO, "Invalid pool");
        RETVALUE(RFAILED);
    }
#endif


    /* call the memory manager to check resources */
    mctl.op = SS_MEM_SHOW;
    ret = (osCp.regionTbl[region].ctl)
          (osCp.regionTbl[region].regCb, SS_MEM_SHOW, &mctl);

    /* release the semaphore we took */
    SS_RELEASE_SEMA(&osCp.regionTblSem);


    RETVALUE(ret);
}