pTask->t_pPendingPrev = MK_NULL;

	MK_InterruptRestore( Flags );
	return MK_NO_ERROR;
}

#ifdef	_MK_SIGNAL
static void
MK_BasicSignalHandler(void)
{
	MK_TASK *pTask;
	ULONG	Signal;
	ULONG	*PrevStack;
	int		Priority;
	int		Flags;

	pTask = MK_pCurrentTask;
	Signal = pTask->t_Signal;

	(*pTask->t_pSigFunction)(Signal);	/* Execute Registerd Signal Handler */

	Flags = MK_InterruptDisable();		/* Critical Region */

	PrevStack = (ULONG *)pTask->t_PreviousCurrentOfStack;

	/* Restore Information From Stack */
	pTask->t_CurrentOfStack =					*--PrevStack;
	pTask->t_PreviousCurrentOfStack =			*--PrevStack;

	/* In MK_TASK_SIGNAL, State can be MK_TASK_READY, MK_TASK_DELAYED, 
	MK_TASK_PENDING at the same time */

	if( (pTask->t_Status & MK_TASK_DELAYED) || (pTask->t_Status & MK_TASK_PENDING) )
	{
		MK_DeleteTaskFromReadyList(pTask);
	}
	pTask->t_Status &= ~MK_TASK_SIGNAL;

	Priority = MK_GetHighPriority();
	pTask = MK_pTaskReadyListHead[Priority];
	MK_pCurrentTask = pTask;
	MK_StartHighPriorityTask(&pTask->t_CurrentOfStack);

	MK_InterruptRestore(Flags);			/* Never reach this line */
}

STATUS
MK_SignalSend(MK_TASK *pTask, UINT Signal)
{
	MK_TASK *pCurrentTask;
	CHAR	*pStack;
	int		Flags;

	if( pTask->t_Status & MK_TASK_SIGNAL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_SignalSend() - now signal handler is running but received signal(%x) is ignord!", Signal);
#endif
		return MK_ERROR;
	}

	if( pTask->t_pSigFunction == 0)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_SignalSend() - no registered signal hanler function is exist!");
#endif
		return MK_ERROR;
	}

	if( (pTask->t_SigMask & Signal) == 1)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_SignalSend() - Singal sended to %s is all masked!", MK_GetTaskName(pTask));
#endif
		return MK_ERROR;
	}

	Flags = MK_InterruptDisable();		/* Critical Region */

	pCurrentTask = MK_pCurrentTask;

	if(pTask != pCurrentTask)
	{
		pStack = (CHAR *)pTask->t_CurrentOfStack;
		
		pStack -= sizeof(ULONG);
		*(ULONG *)pStack = pTask->t_CurrentOfStack;
		pStack -= sizeof(ULONG);
		*(ULONG *)pStack = pTask->t_PreviousCurrentOfStack;
		
		/* Context */	
		
		pStack -= sizeof(ULONG);
		*(ULONG *)pStack = (ULONG)MK_BasicSignalHandler;	/* LR(A14) */
		pStack -= sizeof(ULONG);
		*(ULONG *)pStack = 0;			/* A13 */
		pStack -= sizeof(ULONG);
		*(ULONG *)pStack = 0;			/* A12 */
		pStack -= sizeof(ULONG);
		*(ULONG *)pStack = 0;			/* A11 */
		pStack -= sizeof(ULONG);
		*(ULONG *)pStack = 0;			/* A10 */
	
		pStack -= sizeof(ULONG);
		*(ULONG *)pStack = 0;			/* A9 */	
		pStack -= sizeof(ULONG);
	    *(ULONG *)pStack = 0;			/* A8 */
    		
		pStack -= sizeof(UINT);
		*(UINT *)pStack = 0;			/* R7 */	
		pStack -= sizeof(UINT);
    	*(UINT *)pStack = 0;			/* R6 */
    	pStack -= sizeof(UINT);
    	*(UINT *)pStack = 0;			/* R5 */
    	pStack -= sizeof(UINT);
    	*(UINT *)pStack = 0;			/* R4 */
    	pStack -= sizeof(UINT);
    	*(UINT *)pStack = 0;			/* R3 */
    	pStack -= sizeof(UINT);
    	*(UINT *)pStack = 0;			/* R2 */
    	pStack -= sizeof(UINT);
    	*(UINT *)pStack = 0;			/* R1 */
    	pStack -= sizeof(UINT);
    	*(UINT *)pStack = 0;			/* R0 */ 
    	pStack -= sizeof(UINT);    
    	*(UINT *)pStack = 0x0040;		/* SR */
    	pStack -= sizeof(UINT);

		pTask->t_PreviousCurrentOfStack = pTask->t_CurrentOfStack;
		pTask->t_CurrentOfStack = (ULONG)pStack;
		pTask->t_Signal = ~pTask->t_SigMask & Signal;
		pTask->t_Status |= MK_TASK_SIGNAL;

		if( !(pTask->t_Status & MK_TASK_READY) )
		{
			MK_InsertTaskToReadyList(pTask);
		}

		MK_Schedule();		

	}
	else
	{
		(*pTask->t_pSigFunction)(Signal);
	}

	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;
}
#endif	/* #ifdef	_MK_SIGANL */

void
MK_Printf(char *fmt,...)
{
#if MK_KERNEL_PRINT
	va_list ap;
	//char string[256];
	char string[50];

	va_start(ap,fmt);
	vsprintf(string,fmt,ap);
#if MK_CALMRISC16
	// printf("%s", string);
	UART_SendString( (signed char *)string );
#else
	MK_Puts(string);
#endif /* MK_CALMRISC16 */
	va_end(ap);
#endif
}

void
MK_InfoPrintf(LOGLEVEL ErrorInfo, char *fmt, ...)
{
#if 0

#if MK_DEBUG_PRINT
	va_list ap;
	//char string[256];
	char string[50];

	if(ErrorInfo >= MK_SYSTEM_INFO)
	{
		va_start(ap,fmt);
		vsprintf(string,fmt,ap);
#if MK_CALMRISC16
		printf("%s", string);
#else
		MK_Puts(string);
#endif /* MK_CALMRISC16 */
		va_end(ap);
	}
#endif
#endif /* 0 */
	// printf("INFO");

}

void
MK_Panic(char *fmt, ...)
{
#if MK_DEBUG_PRINT
	va_list ap;
	//char string[256];
	char string[50];

	va_start(ap,fmt);
	vsprintf(string,fmt,ap);
#if MK_CALMRISC16
	printf("%s", string);
#else
	MK_Puts(string);
#endif /* MK_CALMRISC16 */
	va_end(ap);
#endif
//	for(;;); /* infinite loop */
}

int 
MK_Sprintf(char * buf, char *fmt, ...)
{
#if MK_DEBUG_PRINT
	va_list ap;
	int i;

	va_start(ap,fmt);
	i = vsprintf(buf,fmt,ap);
	va_end(ap);
	return i;
#else
	return 0;
#endif
}

#if 0
#ifdef _MK_DDI
void 
MK_Fprintf(struct mk_ddi_struct *pDDI, char *fmt, ...)
{
	va_list ap;
	char string[256];
	int Length;

	va_start(ap,fmt);
	Length = vsprintf(string,fmt,ap);
	MK_Write(pDDI, string, Length);
	va_end(ap);
}
#endif	/* #if MK_DDI */
#endif  /* 0 */
void
MK_SystemInitialize(void)
{
	MK_InterruptInitialize();

#if (MK_DEBUG_PRINT | MK_KERNEL_PRINT)
#if !MK_CALMRISC16
	UART_Initialize();
#endif
#endif
}

void
MK_RTOSInitialize(void)
{
	MK_MemoryInitialize();
	MK_TaskInitialize();

#ifdef _MK_HISR
	MK_HISRInitialize();
#endif

#ifdef _MK_MSGQUEUE
	MK_MsgQueueInitialze();
#endif

#ifdef _MK_SEMAPHORE
	MK_SemaphoreInitialize();
#endif

#ifdef _MK_SYSTEMTIMER
	MK_SystemTimerInitialize();
#endif

#ifdef _MK_EVENT
	MK_EventInitialize();
#endif

#ifdef _MK_MAILBOX
	MK_MsgMailBoxInitialze();
#endif

#ifdef _MK_MPORT
	MK_MsgPortInitialze();
#endif

#ifdef _MK_TPORT
	MK_TaskPortInitialize();
#endif

#ifdef _MK_DDI
//	MK_DDIInitialize();
#endif

#ifdef _MK_PIPE
//	MK_PipeInitialize();
#endif

#ifdef _MK_SHELL
//	MK_ShellInitalize();
#endif
}

void
SWIHandler_Test(void)
{
#if MK_DEBUG_PRINT
#if MK_CALMRISC16
	printf("SWI Service Routine\n");
#else
	MK_Puts("SWI Service Routine\n");
#endif /* MK_CALMRISC16 */
#endif
	MK_InterruptDisable();
	for(;;);
}

#if 0
void
IRQHandler_Test(void)
{
#if MK_DEBUG_PRINT
	MK_Puts("IRQ Routine\n");
#endif

	rSRCPND = 0xFFFFFFFF;	/* clear */
	for(;;);
}
#endif	/* #if 0 */

#if 0
void
Undefined_Handler_Test(void)
{
#if MK_DEBUG_PRINT
#if MK_CALMRISC16
	printf("\nUndefined ISR - Dump Register\n\n");
#else
	MK_Puts("\nUndefined ISR - Dump Register\n\n");
#endif /* MK_CALMRISC16 */	
#endif
	MK_InterruptDisable();
	for(;;);
}

void
Prefetch_Handler_Test(void)
{
#if MK_DEBUG_PRINT
#if MK_CALMRISC16
	printf("Prefetch ISR\n");
#else
	MK_Puts("Prefetch ISR\n");
#endif /* MK_CALMRISC16 */	
#endif
	MK_InterruptDisable();
	for(;;);
}

void 
Abort_Handler_Test(void)
{
#if MK_DEBUG_PRINT
#if MK_CALMRISC16
	printf("Abort ISR\n");
#else
	MK_Puts("Abort ISR\n");
#endif /* MK_CALMRISC16 */	
#endif
	MK_InterruptDisable();
	for(;;);
}
#endif