segmgr.c

使用广泛的日本著名的开源嵌入式实时操作系统T-Kernel的源码

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

/*
 *	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	ercd;

	if ( len <= 0 ) {
		ercd = 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((INT)smPageCount((UW)len), a);
		if ( *laddr == NULL ) {
			ercd = 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 ercd = %d\n", ercd));
	return ercd;
}

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

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

	return E_OK;

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

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

/*
 * 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;
}

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

/*
 * Memory Cache Control
 */
LOCAL ER _FlushMemCache( VP laddr, INT len, UINT mode )
{
	ER	ercd;

	if ( (mode & ~(TCM_ICACHE|TCM_DCACHE)) != 0 ) {
		ercd = E_PAR;
		goto err_ret;
	}
	ercd = ChkSpaceR(laddr, len);
	if ( ercd < E_OK ){
		goto err_ret;
	}

	FlushCacheM(laddr, len, mode);

	return E_OK;

err_ret:
	DEBUG_PRINT(("_FlushMemCache ercd = %d\n", ercd));
	return ercd;
}

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

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

	switch ( fn ) {
		/* You can call all protection level */
	  case SEG_FLUSHMEMCACHE_FN:
		break;

	  default:
		/* Call protected level check */
		ercd = ChkCallPLevel();
		if ( ercd < E_OK ) {
			goto err_ret;
		}
	}

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

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

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

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

	  case SEG_FLUSHMEMCACHE_FN:
		{ SEG_FLUSHMEMCACHE_PARA *p = para;
		ercd = _FlushMemCache(p->laddr, p->len, p->mode); }
		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:
		ercd = E_NOSPT;
		break;

	  default:
		ercd = E_RSFN;
	}

err_ret:
	return ercd;
}

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

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

	/* 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;
	ercd = tk_def_ssy(SEG_SVC, &dssy);
	if ( ercd < E_OK ) {
		goto err_ret;
	}

	return E_OK;

err_ret:
	BMS_DEBUG_PRINT(("start_segmgr ercd = %d\n", ercd));
	return ercd;
}

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

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

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

	return ercd;
}