cpu_defs.c

JAPAN RTOS TOPPERS/JSP kernel 1.4 PreRelease simulation environment JSP kernel Windows simulation

/*
 *  TOPPERS/JSP Kernel
 *      Toyohashi Open Platform for Embedded Real-Time Systems/
 *      Just Standard Profile Kernel
 * 
 *  Copyright (C) 2000-2003 by Embedded and Real-Time Systems Laboratory
 *                              Toyohashi Univ. of Technology, JAPAN
 * 
 *  忋婰挊嶌尃幰偼丆埲壓偺 (1)乣(4) 偺忦審偐丆Free Software Foundation 
 *  偵傛偭偰岞昞偝傟偰偄傞 GNU General Public License 偺 Version 2 偵婰
 *  弎偝傟偰偄傞忦審傪枮偨偡応崌偵尷傝丆杮僜僼僩僂僃傾乮杮僜僼僩僂僃傾
 *  傪夵曄偟偨傕偺傪娷傓丏埲壓摨偠乯傪巊梡丒暋惢丒夵曄丒嵞攝晍乮埲壓丆
 *  棙梡偲屇傇乯偡傞偙偲傪柍彏偱嫋戻偡傞丏
 *  (1) 杮僜僼僩僂僃傾傪僜乕僗僐乕僪偺宍偱棙梡偡傞応崌偵偼丆忋婰偺挊嶌
 *      尃昞帵丆偙偺棙梡忦審偍傛傃壓婰偺柍曐徹婯掕偑丆偦偺傑傑偺宍偱僜乕
 *      僗僐乕僪拞偵娷傑傟偰偄傞偙偲丏
 *  (2) 杮僜僼僩僂僃傾傪丆儔僀僽儔儕宍幃側偳丆懠偺僜僼僩僂僃傾奐敪偵巊
 *      梡偱偒傞宍偱嵞攝晍偡傞応崌偵偼丆嵞攝晍偵敽偆僪僉儏儊儞僩乮棙梡
 *      幰儅僯儏傾儖側偳乯偵丆忋婰偺挊嶌尃昞帵丆偙偺棙梡忦審偍傛傃壓婰
 *      偺柍曐徹婯掕傪宖嵹偡傞偙偲丏
 *  (3) 杮僜僼僩僂僃傾傪丆婡婍偵慻傒崬傓側偳丆懠偺僜僼僩僂僃傾奐敪偵巊
 *      梡偱偒側偄宍偱嵞攝晍偡傞応崌偵偼丆師偺偄偢傟偐偺忦審傪枮偨偡偙
 *      偲丏
 *    (a) 嵞攝晍偵敽偆僪僉儏儊儞僩乮棙梡幰儅僯儏傾儖側偳乯偵丆忋婰偺挊
 *        嶌尃昞帵丆偙偺棙梡忦審偍傛傃壓婰偺柍曐徹婯掕傪宖嵹偡傞偙偲丏
 *    (b) 嵞攝晍偺宍懺傪丆暿偵掕傔傞曽朄偵傛偭偰丆TOPPERS僾儘僕僃僋僩偵
 *        曬崘偡傞偙偲丏
 *  (4) 杮僜僼僩僂僃傾偺棙梡偵傛傝捈愙揑傑偨偼娫愙揑偵惗偠傞偄偐側傞懝
 *      奞偐傜傕丆忋婰挊嶌尃幰偍傛傃TOPPERS僾儘僕僃僋僩傪柶愑偡傞偙偲丏
 * 
 *  杮僜僼僩僂僃傾偼丆柍曐徹偱採嫙偝傟偰偄傞傕偺偱偁傞丏忋婰挊嶌尃幰偍
 *  傛傃TOPPERS僾儘僕僃僋僩偼丆杮僜僼僩僂僃傾偵娭偟偰丆偦偺揔梡壜擻惈傕
 *  娷傔偰丆偄偐側傞曐徹傕峴傢側偄丏傑偨丆杮僜僼僩僂僃傾偺棙梡偵傛傝捈
 *  愙揑傑偨偼娫愙揑偵惗偠偨偄偐側傞懝奞偵娭偟偰傕丆偦偺愑擟傪晧傢側偄丏
 * 
 *  @(#) $Id: cpu_defs.c,v 1.10 2003/08/01 07:55:27 takayuki Exp $
 */

#define _WIN32_WINNT 0x400

#include "hal_msg.h"
#include "cpu_defs.h"
#include "cpu_config.h"
#include "tool_config.h"

/*
 * m68k偭傐偄妱崬傒僄儈儏儗乕僞 (Windows HAL)
 */

	/* 尰嵼偺妱崬傒儅僗僋儗儀儖 */
unsigned int CurrentInterruptLevel;

	/* 妱崬傒娗棟僥乕僽儖 */
static struct tagInterruptLevel InterruptLevel[INT_NUMINTERRUPTS];

	/* 妱崬傒儅僗僋儗儀儖偺桳岠斖埻僠僃僢僋 */
#define CHECK_IMS(x) ( (x) != 0 && (x) <= INT_NUMINTERRUPTS )

	/* 椺奜娗棟僥乕僽儖 */
struct tagExceptionLevel ExceptionLevel[EXC_MAXITEMS];

	/* 帺暘偺慜偵搊榐偝傟偰偄偨峔憿壔椺奜僴儞僪儔偺傾僪儗僗 */
static LPTOP_LEVEL_EXCEPTION_FILTER AnotherExceptionFilter;

/*
 *   僔僗僥儉慡懱偺僋儕僥傿僇儖僙僋僔儑儞惗惉儖乕僠儞
 *     丒偳偆偟偰CRITICAL_SECTION傪巊偆偺傪傗傔偨偺偐
 *        -> Windows偺僋儕僥傿僇儖僙僋僔儑儞偼丄ITRON偱尵偆偲偙傠偺僨傿僗僷僢僠嬛巭偱幚憰偟偰偄傞傜偟偔丄
 *           奜晹僀儀儞僩偱婲彴偟偰偟傑偭偨僗儗僢僪偑僋儕僥傿僇儖僙僋僔儑儞撪偵偄傞僗儗僢僪偺摦嶌傪
 *           掆巭偝偣偰偟傑偆偙偲偑偱偒傞傜偟偄丅側偺偱CPU儘僢僋偺偮傕傝偱僋儕僥傿僇儖僙僋僔儑儞傪巊偭偰偄傞偲丄
 *           幚偼偨偩偺僨傿僗僷僢僠嬛巭側偺偱僴儞僪儔偑婲摦偟偰偟傑偄丄PrimaryThread偑SuspendThread傪敪峴偟偰僨僢僪儘僢僋偟偰偟傑偆丅
 *           偙偺栤戣偼帪乆敪惗偡傞旕忢偵栵夘側栤戣偩偭偨偑丄傑偝偐偦傫側偙偲偑尨場偩偲偼巚偄傕傛傜側偐偭偨丅
 *           WinProg宯偺ML偱傕乽尨場晄柧偺晄惓摨婜偑僀儎側傜僋儕僥傿僇儖僙僋僔儑儞偼巊傢側偄傎偆偑傛偄乿偲偄偭偰偄傞丅
 */

static HANDLE SystemMutex = INVALID_HANDLE_VALUE;		//僔僗僥儉儘僢僋梡偺儈儏乕僥僢僋僗僆僽僕僃僋僩
static DWORD  SystemMutexOwnerThreadID = 0;				//僔僗僥儉儘僢僋傪庢摼偟偨僗儗僢僪偺ID
static DWORD  SystemMutexLastOwnerThreadID = 0;			//嵟屻偵僔僗僥儉儘僢僋傪庢摼偟偰偄偨僗儗僢僪偺ID (僨僶僢僌梡)

	/*
	 *   enter_system_critical_section : 僔僗僥儉偺儘僢僋尃傪妉摼偡傞
	 *     BOOL * lock : 僋僢僉乕(帺暘偑巒傔偰儘僢僋尃傪妉摼偡傞偲TRUE偑曉傞)
	 */
void enter_system_critical_section(BOOL * lock)
{
	if(SystemMutex != INVALID_HANDLE_VALUE && SystemMutexOwnerThreadID != GetCurrentThreadId())
	{
		WaitForSingleObject(SystemMutex, INFINITE);	
		if(lock != NULL)
			*lock = TRUE;
		SystemMutexOwnerThreadID = GetCurrentThreadId();
	}else
	{
		if(lock != NULL)
			*lock = FALSE;
	}
}

	/*
	 *   leave_system_critical_section : 僔僗僥儉偺儘僢僋尃傪奐曻偡傞
	 *		BOOL * lock : enter_system_critical_section偱巊梡偟偨僋僢僉乕
	 */
void leave_system_critiacl_section(BOOL * lock)
{
	assert(lock != NULL);

	if(*lock == TRUE)
	{
		SystemMutexLastOwnerThreadID = SystemMutexOwnerThreadID;
		SystemMutexOwnerThreadID = 0;
		if(SystemMutex != INVALID_HANDLE_VALUE)
			ReleaseMutex(SystemMutex);	
	}
}

	/*
	 *   wait_for_thread_suspension_completion : 僗儗僢僪傪儘僢僋尃奐曻忬懺偱掆巭偝偣傞 
	 */
ER wait_for_thread_suspension_completion(HANDLE thread)
{
	BOOL lock;

	if(thread == 0 || thread == INVALID_HANDLE_VALUE)
		return E_PAR;

	enter_system_critical_section(&lock);
	SuspendThread(thread);
	leave_system_critiacl_section(&lock);

	return 0;
}



/*
 *  師偵幚峴偡傋偒妱崬傒僴儞僪儔偺偁傞儗儀儖傪庢摼偡傞
 *      ipl : 妱崬傒儅僗僋儗儀儖
 *
 *    妱傝崬傒儗儀儖儅僗僋偑ipl傑偱壓偑偭偨偲偒偵丄師偵摦偐偡傋偒妱崬傒傪慖戰偡傞丅
 *    儅僗僋儗儀儖傛傝傕忋埵偺妱崬傒偺応崌丄儁儞僨傿儞僌偝傟偨梫媮 or 婛偵幚峴偑
 *    巒傑偭偰偄傞僴儞僪儔 傪幚峴偡傞丅儅僗僋儗儀儖埲壓偺応崌丄婛偵摦偄偰偄傞
 *    僴儞僪儔偑偁傞応崌偺傒幚峴偡傞丅壗傕側偄応崌偼0傪曉偡丅
 */
static unsigned int
isns_int( unsigned int ipl )
{
	unsigned int result = INT_NUMINTERRUPTS;
	
	if((CPUStatus & CPU_STAT_LOCK) != 0)
		return 0;

	while(result > ipl)
	{
		result --;
		if( (InterruptLevel[result].Flags & (INT_STAT_PENDING|INT_STAT_RUNNING)) != 0)
			return result+1;
	}
	while(result > 0)
	{
		result --;
		if( (InterruptLevel[result].Flags & INT_STAT_RUNNING) != 0)
			return result+1;
	}
	return 0;
}

static DWORD WINAPI
InterruptHandlerWrapper(LPVOID param)
{
	unsigned int   i;
	unsigned int   PrevLevel;
	BOOL           systemLock;

	struct tagInterruptLevel * intlv = (struct tagInterruptLevel *)param;

	TlsAlloc();

	while(1==1)
	{
			/* 妱崬傒慜張棟 */

		set_logcontrol((intlv->Flags & INT_MOD_LOGMASK) != 0);
		LOG_INH_ENTER((intlv - InterruptLevel)+1);

        enter_system_critical_section(&systemLock);
        PrevLevel = CurrentInterruptLevel;
		CurrentInterruptLevel = (unsigned int)(intlv - InterruptLevel)+1;
		intlv->Flags &= ~INT_STAT_PENDING;
		intlv->Flags |=  INT_STAT_RUNNING;
		leave_system_critiacl_section(&systemLock);

        ( (void (*)(void) )(intlv->Routine))();
        
			/* 妱崬傒屻張棟 */
		enter_system_critical_section(&systemLock);
		intlv->Flags &= ~INT_STAT_RUNNING;
		i = isns_int(PrevLevel);
		if(i > PrevLevel)
			CurrentInterruptLevel = i - 1;
		else
			CurrentInterruptLevel = PrevLevel;
		leave_system_critiacl_section(&systemLock);

		LOG_INH_LEAVE((intlv - InterruptLevel)+1);

			/* 僨傿僗僷僢僠儖乕僠儞偺婲摦 */
    	if(i != 0)
	    	HALInterruptRequestAndWait(0);
		else
			idispatch();
	}

	ExitThread(0);
	return 0;
}

BOOL
def_int(unsigned int ims, void * rtn)
{
	BOOL lock;

	if(!CHECK_IMS(ims) || rtn == NULL)
		return FALSE;

	ims--;

	enter_system_critical_section(&lock);
	if(InterruptLevel[ims].ThreadHandle != INVALID_HANDLE_VALUE)
	{
		TerminateThread(InterruptLevel[ims].ThreadHandle,0);
		CloseHandle(InterruptLevel[ims].ThreadHandle);
	}
	InterruptLevel[ims].Routine = rtn;
	InterruptLevel[ims].ThreadHandle = CreateThread(NULL,0,InterruptHandlerWrapper,(LPVOID)&InterruptLevel[ims],CREATE_SUSPENDED,&InterruptLevel[ims].ThreadID);
	leave_system_critiacl_section(&lock);
	return TRUE;
}

BOOL
ini_int(void)
{
	int i;

	SystemMutex = CreateMutex(NULL,TRUE,NULL);

	for(i=0;i<INT_NUMINTERRUPTS;i++)
	{
		InterruptLevel[i].Routine = (void *)0l;
		InterruptLevel[i].ThreadHandle = INVALID_HANDLE_VALUE;
		InterruptLevel[i].ThreadID = 0;
		InterruptLevel[i].Flags    = INT_MOD_LOGMASK;
	}


		/* 弶婜婲摦偱CPU儘僢僋忬懺傊堏峴偝偣傞 */
	CurrentInterruptLevel = 0;	//妱崬傒儅僗僋偼慡嫋壜
	CPUStatus |= CPU_STAT_LOCK;	//CPU偱妱崬傒嬛巭偵

	ReleaseMutex(SystemMutex);

	return TRUE;
}

void
fin_int(void)
{
	int    i;
	HANDLE work;

	enter_system_critical_section(NULL);

	for(i=0;i<INT_NUMINTERRUPTS;i++)
	{
		if(InterruptLevel[i].ThreadHandle != INVALID_HANDLE_VALUE)
		{
			TerminateThread(InterruptLevel[i].ThreadHandle,0);
			CloseHandle(InterruptLevel[i].ThreadHandle);
		}
		InterruptLevel[i].Routine = (void *)0l;
		InterruptLevel[i].ThreadHandle = INVALID_HANDLE_VALUE;
		InterruptLevel[i].ThreadID = 0;
		InterruptLevel[i].Flags    = 0;
	}
	CurrentInterruptLevel = 0;

	work = SystemMutex;
	SystemMutex = INVALID_HANDLE_VALUE;

	CloseHandle(work);

		//偙傟埲崀偼CPU儘僢僋忬懺偩偲巚偄崬傓
	CPUStatus |= CPU_STAT_LOCK;
}

BOOL
ras_int(unsigned int ims)
{
	BOOL lock;
	BOOL result = TRUE;

	if(!CHECK_IMS(ims))
		return FALSE;

	ims --;

	enter_system_critical_section(&lock);
	if(InterruptLevel[ims].ThreadHandle == INVALID_HANDLE_VALUE)
	{
		result = FALSE;
	}else
		InterruptLevel[ims].Flags |= INT_STAT_PENDING;
	leave_system_critiacl_section(&lock);
	return result;
}

unsigned int
sns_int( void )
{
	BOOL lock;
	int  result;

	if(sense_lock() == TRUE)
		return 0;

	enter_system_critical_section(&lock);
	result = isns_int(CurrentInterruptLevel);
	leave_system_critiacl_section(&lock);
	return result;
}

HANDLE
sch_int( void )
{
	BOOL   lock;
	HANDLE result;
	unsigned int level;

	if(sense_lock() == TRUE)
		return INVALID_HANDLE_VALUE;

	enter_system_critical_section(&lock);
	level = isns_int(CurrentInterruptLevel);
	if(level != 0)
	{
		result = InterruptLevel[level-1].ThreadHandle;
	}else
		result = INVALID_HANDLE_VALUE;
	leave_system_critiacl_section(&lock);

	return result;
}

DWORD LockerThreadID = 0;

ER
ena_int(unsigned int ims)
{
	BOOL lock;
	int  i;

	enter_system_critical_section(&lock);
	i = isns_int(CurrentInterruptLevel);
	CPUStatus &= ~CPU_STAT_LOCK;
	LockerThreadID = 0;
	leave_system_critiacl_section(&lock);

	if(i != 0)
		HALInterruptRequest(0);

	return 0 /*E_OK*/;
}

ER
dis_int(unsigned int ims)
{
	BOOL lock;

	enter_system_critical_section(&lock);
	CPUStatus |= CPU_STAT_LOCK;
	if(LockerThreadID == 0)
	{
		LockerThreadID = GetCurrentThreadId();
	}else
	{
		DWORD newThreadID = GetCurrentThreadId();
		LockerThreadID = GetCurrentThreadId();	//僽儗乕僋抲偒応
	}
	leave_system_critiacl_section(&lock);

	return 0;
}

ER
chg_ims(unsigned int ims)
{
	BOOL lock;
	int  i;

		//chg_ims 偼 ims==0 傪嫋偡
	if(ims != 0 && !CHECK_IMS(ims))
		return -17 /*E_PAR*/;

	enter_system_critical_section(&lock);
	CurrentInterruptLevel = ims;
	if(CurrentInterruptLevel == INT_NUMINTERRUPTS)
		CPUStatus |= CPU_STAT_LOCK;
	else
		CPUStatus &= ~CPU_STAT_LOCK;
	i = isns_int(ims);
	leave_system_critiacl_section(&lock);

	if(i != 0)
		HALInterruptRequest(0);

	return 0 /*E_OK*/;
}

ER
get_ims(unsigned int *p_ims)
{
	BOOL lock;

	if(p_ims == (void *)0l)
		return -17 /*E_PAR*/;

	enter_system_critical_section(&lock);
	if((CPUStatus & CPU_STAT_LOCK) != 0)
		*p_ims = INT_NUMINTERRUPTS;
	else
		*p_ims = CurrentInterruptLevel;
	leave_system_critiacl_section(&lock);
	return 0 /*E_OK*/;
}

ER
vget_ims(unsigned int *p_ims)
{
	BOOL lock;

	if(p_ims == (void *)0l)
		return -17 /*E_PAR*/;

	enter_system_critical_section(&lock);
	*p_ims = CurrentInterruptLevel;
	leave_system_critiacl_section(&lock);
	return 0 /*E_OK*/;
}

/*
 * 嵟忋埵儗儀儖Windows峔憿壔椺奜僴儞僪儔
 */

LONG WINAPI
HALExceptionHandler( EXCEPTION_POINTERS * exc )
{
	int i;
	int result;

	if((CPUStatus & CPU_STAT_EXC) == 0)
		CPUStatus |= CPU_STAT_DOUBLEFAULT;

	CPUStatus |= CPU_STAT_EXC;
	for(i=0;i<EXC_MAXITEMS;i++)
	{
		if(ExceptionLevel[i].ExceptionCode == exc->ExceptionRecord->ExceptionCode)
		{
			result = EXCEPTION_CONTINUE_SEARCH;
	
			LOG_EXC_ENTER(i);
			( * ((void (*)(void *,int *))ExceptionLevel[i].Routine)) (exc,&i);
			LOG_EXC_LEAVE(i);

			CPUStatus &= ~CPU_STAT_EXC;
			return result;
		}
	}
	CPUStatus &= ~CPU_STAT_EXC;
	return EXCEPTION_CONTINUE_SEARCH;
}

BOOL
ini_exc(void)
{
	int i;

	for(i=0;i<EXC_MAXITEMS;i++)
	{
		ExceptionLevel[i].ExceptionCode = 0;
		ExceptionLevel[i].Routine = 0l;
	}

	AnotherExceptionFilter = SetUnhandledExceptionFilter(HALExceptionHandler);
	
	return TRUE;
}

void
fin_exc(void)
{}

BOOL
def_exc(DWORD exc, void * routine)
{
	int j;
	int i;

	if(routine == 0l)
	{
		for(i=0;i<EXC_MAXITEMS;i++)
			if(ExceptionLevel[i].ExceptionCode == exc)
			{
				ExceptionLevel[i].ExceptionCode = 0;
				ExceptionLevel[i].Routine = 0;
				return TRUE;
			}
		return FALSE;
	}

	j = EXC_MAXITEMS;
	for(i=0;i<EXC_MAXITEMS;i++)
	{
		if(ExceptionLevel[i].ExceptionCode != 0)
		{
				/* 搊榐偟傛偆偲偟偰偄傞斣崋偑婛偵搊榐偝傟偰偄側偄偐偳偆偐挷傋傞 */
			if(ExceptionLevel[i].ExceptionCode == exc)
				return FALSE;
		}else
		{
				/* 嬻偒斣崋偺嵟彫傪妎偊傞 */
			if(j > i)
				j = i;
		}
	}

	FatalAssertion(i == EXC_MAXITEMS, "No available exception slot left.");

		//This sequence will never change
	ExceptionLevel[j].Routine = routine;
	ExceptionLevel[j].ExceptionCode = exc;

	return TRUE;
}

ER set_intlogmask( unsigned int ims, BOOL mask )
{
	BOOL lock;

	if( !CHECK_IMS(ims) )
		return FALSE;

	-- ims;

	enter_system_critical_section(&lock);
	if(mask == TRUE)
		InterruptLevel[ims].Flags |= INT_MOD_LOGMASK;
	else
		InterruptLevel[ims].Flags &= ~INT_MOD_LOGMASK;
	leave_system_critiacl_section(&lock);

	return TRUE;
}