ss_cfg.c

中国石油二期加油站IC系统后台通讯软件

/**************************************************************************************
* Copyright    : UTStarcom(China) Co. Ltd, Shenzhen Branch
* Version      : 0.0.1
* File Name    : ss_cfg.c
* Creation     : Spine.zhnag 2002-1-28
* Description  : 
* Modification : 
**************************************************************************************/

/*------------------------------ include files---------------------------------------*/
#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 "cm5.h"           /* common timers */

#include "ss_queue.h"      /* queues */
#include "ss_task.h"       /* tasking */
#include "cm_mem.h"        /* common memory manager */
#include "ss_queue.h"
#include "ss_task.h"
#include "ss_msg.h"
#include "ss_mem.h"
#include "ss_gen.h"
#include "ss_cfg.h"


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

#include "gen.x"           /* general layer */
#include "ssi.x"           /* system services */
#include "cm5.x"           /* common timers */
#include "ss_strm.x"       /* STREAMS */
#include "cm_mem.x"        /* common memory manager */
#include "ss_queue.x"
#include "ss_task.x"
#include "ss_drvr.x"
#include "ss_timer.x"
#include "ss_msg.x"
#include "ss_mem.x"
#include "ss_gen.x"
#include "ss_cfg.x"
#include "ss_err.h"


/*------------------------------ local definitions ----------------------------------*/


/*------------------------------ default settings -----------------------------------*/


/*------------------------------ external functions ---------------------------------*/


/*------------------------------ external data --------------------------------------*/


/*------------------------------ public data ----------------------------------------*/

PUBLIC Cntr cfgNumRegs = 1;

PUBLIC SsRegCfg gstCfgRegInfo[SS_MAX_REGS];
/* private variable declarations */

PRIVATE CmMmRegCfg gstCMMRegCfg[SS_MAX_REGS];
PRIVATE CmMmRegCb gstCMMRegCb[SS_MAX_REGS];



/*------------------------------ private data ---------------------------------------*/


/*------------------------------ public functions -----------------------------------*/


/*------------------------------ private functions ----------------------------------*/


PUBLIC S16 ssdInitMem(void)
{
	SsMemRegionCfg	stDefaultRegCfg;

	TRC0(ssdInitMem);

	/* set up the CMM configuration structure */
	stDefaultRegCfg.mdwHeapSize = SS_HEAP_SIZE;
	stDefaultRegCfg.mwNumBkts = 5;

	stDefaultRegCfg.mstBktCfg[0].size = SS_MBUF_128_SIZE;
	stDefaultRegCfg.mstBktCfg[0].numBlks = SS_DFLT_NMB_BUFS_128;
	stDefaultRegCfg.mstBktCfg[1].size = SS_MBUF_256_SIZE;
	stDefaultRegCfg.mstBktCfg[1].numBlks = SS_DFLT_NMB_BUFS_256;
	stDefaultRegCfg.mstBktCfg[2].size = SS_MBUF_512_SIZE;
	stDefaultRegCfg.mstBktCfg[2].numBlks = SS_DFLT_NMB_BUFS_512;
	stDefaultRegCfg.mstBktCfg[3].size = SS_MBUF_1024_SIZE;
	stDefaultRegCfg.mstBktCfg[3].numBlks = SS_DFLT_NMB_BUFS_1024;
	stDefaultRegCfg.mstBktCfg[4].size = SS_MBUF_2048_SIZE;
	stDefaultRegCfg.mstBktCfg[4].numBlks = SS_DFLT_NMB_BUFS_2048;

	SInitMem(0, &stDefaultRegCfg);
    
	/* initialize the STREAMS module */
    if ( ssStrmCfg(SS_DFLT_REGION, SS_DFLT_REGION) != ROK )
    {
        SSLOGERROR(ERRCLS_DEBUG, ESS287, ERRZERO, "ssStrmCfg() return Error");
		cmMmRegDeInit(&gstCMMRegCb[0]);
		free(gstCMMRegCfg[0].vAddr);
		gstCMMRegCfg[0].vAddr = NULL;
		RETVALUE(RFAILED);
    }

    RETVALUE(ROK);
}

PUBLIC S16 SInitMem(Region region,SsMemRegionCfg * Cfg)
{
	S16				i;
	S16				nPoolCount;
    SsRegionEntry 	*pRegionEnt;
    U32				dwMemSize = 0;

    TRC0(SInitMem);

    if ( SS_MAX_REGS <= region )
    {
        SSLOGERROR( ERRCLS_DEBUG, ESS001, SS_MAX_REGS, "Invalid value region number" );
        RETVALUE(RFAILED);
    }

    if ( NULLP == Cfg )
    {
        SSLOGERROR( ERRCLS_DEBUG, ESS001, 87, "Invalid configuration structure pointer" );
        RETVALUE(RFAILED);
    }

    if ( 0 == Cfg->mwNumBkts || CMM_MAX_BKT_ENT < Cfg->mwNumBkts )
    {
        SSLOGERROR( ERRCLS_DEBUG, ESS001, Cfg->mwNumBkts, "Invalid bucket number" );
        RETVALUE(RFAILED);
    }

	if ( osCp.regionTbl[region].used )
	{
        return ROK;
	}
	nPoolCount = 0;
    for ( i = 0;i < Cfg->mwNumBkts; i++ )
    {
        if ( Cfg->mstBktCfg[i].numBlks != 0 )
		{
			gstCMMRegCfg[region].bktCfg[nPoolCount].size = Cfg->mstBktCfg[i].size;
			gstCMMRegCfg[region].bktCfg[nPoolCount].numBlks = Cfg->mstBktCfg[i].numBlks;
			dwMemSize += Cfg->mstBktCfg[i].numBlks * Cfg->mstBktCfg[i].size;
			nPoolCount++;
		}
    }
	gstCMMRegCfg[region].numBkts = nPoolCount;
	gstCMMRegCfg[region].size = dwMemSize + Cfg->mdwHeapSize;
	gstCMMRegCfg[region].lType = SS_LOCK_MUTEX;
	gstCMMRegCfg[region].chFlag = 0;
	gstCMMRegCfg[region].bktQnSize = 16;

    /* allocate space for the region */
    gstCMMRegCfg[region].vAddr = (Data *)calloc(gstCMMRegCfg[region].size, sizeof(Data));
    if ( gstCMMRegCfg[region].vAddr == NULLP )
    {
        SSLOGERROR(ERRCLS_DEBUG, ESS287, gstCMMRegCfg[region].size, "Cannot static memory for region");
        RETVALUE(RFAILED);
    }

	if ( cmMmRegInit(region, &gstCMMRegCb[region], &gstCMMRegCfg[region]) != ROK )
	{
        SSLOGERROR(ERRCLS_DEBUG, ESS287, region, "Cannot register region");
		free(gstCMMRegCfg[region].vAddr);
		gstCMMRegCfg[region].vAddr = NULL;
		RETVALUE(RFAILED);
	}

    gstCfgRegInfo[region].numPools = gstCMMRegCfg[region].numBkts - 1; 
	pRegionEnt = &osCp.regionTbl[region];
    pRegionEnt->numPools = gstCfgRegInfo[region].numPools;
	for ( i = 0;  i < pRegionEnt->numPools;  i++ )
    {
		gstCfgRegInfo[region].pools[i].type = SS_POOL_DYNAMIC;
		pRegionEnt->poolTbl[i].type = gstCfgRegInfo[region].pools[i].type;
		gstCfgRegInfo[region].pools[i].size = gstCMMRegCfg[region].bktCfg[i+1].size;
		gstCfgRegInfo[region].pools[i].size -= (sizeof(SsDblk) + sizeof(SsMblk));
		pRegionEnt->poolTbl[i].u.dpool.size = gstCfgRegInfo[region].pools[i].size;
	}
    gstCfgRegInfo[region].pools[i].type = SS_POOL_STATIC;
	gstCfgRegInfo[region].pools[i].size = 0;
	pRegionEnt->poolTbl[i].type = gstCfgRegInfo[region].pools[i].type;
	pRegionEnt->poolTbl[i].u.dpool.size = gstCfgRegInfo[region].pools[i].size;

    RETVALUE(ROK);
}


PUBLIC Void ssdDeinitMem(void)
{
    S16		i;

	TRC0(ssdDeinitMem);

	for ( i = 0; i < osCp.numRegions; i++ )
	{
		cmMmRegDeInit(&gstCMMRegCb[i]);
		free(gstCMMRegCfg[i].vAddr);
		gstCMMRegCfg[i].vAddr = NULL;
	}
}