segmgr.c

日本著名的的嵌入式实时操作系统T-Kernel的源码及用户手册。

/*
 *----------------------------------------------------------------------
 *    T-Kernel
 *
 *    Copyright (C) 2004 by Ken Sakamura. All rights reserved.
 *    T-Kernel is distributed under the T-License.
 *----------------------------------------------------------------------
 *
 *    Version:   1.01.00
 *    Released by T-Engine Forum(http://www.t-engine.org) at 2004/6/28.
 *
 *----------------------------------------------------------------------
 */

/*
 *	segmgr.c (T-Kernel/SM)
 *	No MMU version: segment management
 */

#include "sysmgr.h"
#include "cache_info.h"
#include <sys/segment.h>
#include <sys/svc/ifsegment.h>

/*
 * Conversion to physical address 
 *	Cache control required, but cache control by page cannot be
 *	provided without MMU, so not implemented.
 */
LOCAL INT _CnvPhysicalAddr( VP laddr, INT len, VP *paddr )
{
	*paddr = toPhysicalAddress(laddr);

	/* 
 * Cache off not possible, so cache flash only is performed.*/
	FlushCache(laddr, len);

	return len;
}

/* ------------------------------------------------------------------------ */

IMPORT	INT	svc_call_limit;		/* SVC protected level (T-Kernel/OS) */

#define	TA_RNGS		( svc_call_limit << 8 )

/*
 * Memory map 
 *	Cache control required, but cache control by page cannot be
 *	provided without MMU (except for certain machines), so not implemented.
 */
LOCAL ER _MapMemory( VP paddr, INT len, UINT attr, VP *laddr )
{
	ER	err;

	if ( len <= 0 ) { err = E_PAR; goto err_ret; }

	if ( paddr == NULL ) {
		UINT a = ( (attr & MM_USER) != 0 )? TA_RNG3: TA_RNGS;
		if ( (attr & MM_CDIS) != 0 ) a |= TA_NOCACHE;

		/* Allocate memory automatically */
		*laddr = GetSysMemBlk(smPageCount(len), a);
		if ( *laddr == NULL ) { err = E_NOMEM; goto err_ret; }

	} else {
		/* Logical address conversion */
		*laddr = toLogicalAddress(paddr);

		/* Flush cache */
		FlushCache(*laddr, len);

		if ( (attr & MM_CDIS) != 0 ) {
			/* Allocate logical addresses for cache off area */
			*laddr = toNoCacheLogicalAddress(*laddr);
		}
	}

	return E_OK;

err_ret:
	DEBUG_PRINT(("_MapMemory err = %d\n", err));
	return err;
}

/*
 * Memory unmap 
 */
LOCAL ER _UnmapMemory( VP laddr )
{
	ER	err;

	/* Memory release when memory is allocated automatically by MapMemory()
	 *	If the memory is not automatically allocated, RelSysMemBlk() 
	 *	returns E_PAR.
	 */
	err = RelSysMemBlk(laddr);
	if ( err < E_OK && err != E_PAR ) goto err_ret;

	return E_OK;

err_ret:
	DEBUG_PRINT(("_UnmapMemory err = %d\n", err));
	return err;
}

/* ------------------------------------------------------------------------ */

/*
 * Address space check 
 */
LOCAL ER  _ChkSpace( VP laddr, INT len, UINT mode, UINT env )
{
	return ( laddr == NULL )? E_MACV: E_OK;
}

LOCAL INT _ChkSpaceTstr( TC *str, INT max, UINT mode, UINT env )
{
	TC	*p = str;

	if ( str == NULL ) return E_MACV;

	while ( *p != TNULL ) {
		p++;
		if ( --max == 0 ) break;
	}
	return p - str;
}

LOCAL INT _ChkSpaceBstr( UB *str, INT max, UINT mode, UINT env )
{
	UB	*p = str;

	if ( str == NULL ) return E_MACV;

	while ( *p != '\0' ) {
		p++;
		if ( --max == 0 ) break;
	}
	return p - str;
}

/* ------------------------------------------------------------------------ */

/*
 * Extended SVC entry 
 */
LOCAL INT SegSVCentry( VP para, W fn )
{
	INT	err;

	/* Call protected level check */
	err = ChkCallPLevel();
	if ( err < E_OK ) goto err_ret;

	switch ( fn ) {
	  case SEG_LOCKSPACE_FN:
	  case SEG_UNLOCKSPACE_FN:
		err = E_OK;
		break;

	  case SEG_CNVPHYSICALADDR_FN:
		{ SEG_CNVPHYSICALADDR_PARA *p = para;
		err = _CnvPhysicalAddr(p->laddr, p->len, p->paddr); }
		break;

	  case SEG_CHKSPACE_FN:
		{ SEG_CHKSPACE_PARA *p = para;
		err = _ChkSpace(p->laddr, p->len, p->mode, p->env); }
		break;
	  case SEG_CHKSPACETSTR_FN:
		{ SEG_CHKSPACETSTR_PARA *p = para;
		err = _ChkSpaceTstr(p->str, p->max, p->mode, p->env); }
		break;
	  case SEG_CHKSPACEBSTR_FN:
		{ SEG_CHKSPACEBSTR_PARA *p = para;
		err = _ChkSpaceBstr(p->str, p->max, p->mode, p->env); }
		break;

	  case SEG_MAPMEMORY_FN:
		{ SEG_MAPMEMORY_PARA *p = para;
		err = _MapMemory(p->paddr, p->len, p->attr, p->laddr); }
		break;
	  case SEG_UNMAPMEMORY_FN:
		{ SEG_UNMAPMEMORY_PARA *p = para;
		err = _UnmapMemory(p->laddr); }
		break;

	  case SEG_CHKSPACELEN_FN:
	  case SEG_READMEMSPACE_FN:
	  case SEG_WRITEMEMSPACE_FN:
	  case SEG_SETMEMSPACEB_FN:
	  case SEG_MAKESPACE_FN:
	  case SEG_UNMAKESPACE_FN:
	  case SEG_CHANGESPACE_FN:
		err = E_NOSPT;
		break;

	  default:
		err = E_RSFN;
	}

err_ret:
	return err;
}

/*
 * Initialize segment management 
 */
EXPORT ER init_segmgr( void )
{
	return E_OK;
}

/*
 * Start segment management 
 */
EXPORT ER start_segmgr( void )
{
	T_DSSY	dssy;
	ER	err;

	/* Register manager */
	dssy.ssyatr    = TA_NULL;
	dssy.ssypri    = SEG_PRI;
	dssy.svchdr    = (FP)SegSVCentry;
	dssy.breakfn   = NULL;
	dssy.startupfn = NULL;
	dssy.cleanupfn = NULL;
	dssy.eventfn   = NULL;
	dssy.resblksz  = 0;
	err = tk_def_ssy(SEG_SVC, &dssy);
	if ( err < E_OK ) goto err_ret;

	return E_OK;

err_ret:
	BMS_DEBUG_PRINT(("initialize_segmgr err = %d\n", err));
	return err;
}

/*
 * End segment manager 
 */
EXPORT ER finish_segmgr( void )
{
	ER	err;

	/* Delete subsystem registration */
	err = tk_def_ssy(SEG_SVC, NULL);

#ifdef DEBUG
	if ( err < E_OK ) DEBUG_PRINT(("finish_segmgr err = %d\n", err));
#endif

	return err;
}