#if MK_DEBUG_PRINT
		 MK_InfoPrintf(MK_TASK_WARNING, "MK_DeleteTaskFromDelayedList() - task status is not delay status!\n");
#endif
		return MK_ERROR;
	}

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

	/*modified by YHK -START*/
	oldDelayedDeltaTicks = pTask->t_DelayedDeltaTicks;
	pNext = MK_pTaskDelayedListHead; 
	while (pNext != MK_NULL) {
		if(pNext == pTask)
			break;
		pTask->t_DelayedDeltaTicks += pNext->t_DelayedDeltaTicks;
		pNext = pNext->t_pDelayedNext;
	}

	if(pNext == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_DeleteTaskFromDelayedList() - Task doesn't exist in List! Task(%s)\n", MK_pCurrentTask->t_pName);
#endif
		MK_InterruptRestore(Flags);
		return MK_ERROR;
	}

	pNext = pTask->t_pDelayedNext;
	if(pTask == MK_pTaskDelayedListHead)
	{
		if(pNext == MK_NULL) //pTask == Head
		{
			MK_pTaskDelayedListHead = MK_NULL;
		}
		else
		{
			pNext->t_pDelayedPrev = MK_NULL;
			pNext->t_DelayedDeltaTicks += oldDelayedDeltaTicks;
			MK_pTaskDelayedListHead = pNext;
		}
	}
	else
	{
		if(pNext == MK_NULL) //pTask == Tail
		{
			pTask->t_pDelayedPrev->t_pDelayedNext = MK_NULL;
		}
		else
		{
			pTask->t_pDelayedPrev->t_pDelayedNext = pNext;
			pNext->t_pDelayedPrev = pTask->t_pDelayedPrev;
			pNext->t_DelayedDeltaTicks += oldDelayedDeltaTicks;
		}
	}
	/*modified by YHK -END*/

	pTask->t_pDelayedNext = MK_NULL;
	pTask->t_pDelayedPrev = MK_NULL;
	pTask->t_Status &= ~MK_TASK_DELAYED;

	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;
}

LONG
MK_GetTaskRemainedTicksFromDelayedList(MK_TASK *pTask)
{
	MK_TASK *pNext;
	LONG	RemainedTicks;

	if (pTask == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_GetTaskRemainedTicksFromDelayedList() - Task doesn't exist! Task(%s)\n", MK_pCurrentTask->t_pName);
#endif
		return MK_ERROR;
	}
	if(pTask->t_Magic != MK_TASK_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_ERROR, "MK_GetTaskRemainedTicksFromDelayedList() - Magic error!\n");
#endif
		//while(1);
		return MK_RESOURCE_ERROR;
	}

	if(pTask->t_Status & MK_TASK_DELAYED)
	{
		pNext = MK_pTaskDelayedListHead;
		RemainedTicks = 0;

		while(pNext != pTask && pNext != MK_NULL)
		{
			RemainedTicks += pNext->t_DelayedDeltaTicks;
			pNext = pNext->t_pDelayedNext;
		}
		return (pTask->t_DelayedDeltaTicks + RemainedTicks);
	}

	return 0;
}

int
MK_GetHighPriority(void)
{
	int GroupValue, MiddleGroupValue, TableValue, Temp;
	int High;
	
	GroupValue = MK_UnMapTable[MK_ReadyGroup];
	Temp = MK_ReadyMiddleGroup[GroupValue];
	MiddleGroupValue = MK_UnMapTable[Temp];
	Temp = MK_ReadyTable[GroupValue][MiddleGroupValue];
	TableValue = MK_UnMapTable[Temp];

	High = (GroupValue<<6) | (MiddleGroupValue<<3) | TableValue;
	return High;
}

#if 0
INT MK_InterruptDisable(VOID)
{
	int old_Flags;
	old_Flags = MK_LocalControlInterrupt(MK_INTERRUPT_DISABLE);
	return old_Flags;
}

VOID MK_InterruptRestore(int Flags)
{
	int old_Flags;
	old_Flags = MK_LocalControlInterrupt(Flags);
}

INT MK_InterruptEnable(VOID)
{
	int old_Flags;
	old_Flags = MK_LocalControlInterrupt(MK_INTERRUPT_ENABLE);
	return old_Flags;
}
#endif

VOID
MK_IntEnter(VOID)
{
	MK_CountNesting++;	
}

extern unsigned long MK_IsZeroSP(void);
VOID
MK_IntExit(VOID)
{
	if ( (--MK_CountNesting) <=0 ) {
		MK_Schedule();
	}
}

INT
MK_ContextSwitchDisable(VOID)
{
	INT OldFlags;

	OldFlags=MK_ContextSwitchFlags;
	MK_ContextSwitchFlags = FALSE;

	return OldFlags;
}

INT
MK_ContextSwitchEnable(VOID)
{
	INT OldFlags;

	OldFlags=MK_ContextSwitchFlags;
	MK_ContextSwitchFlags = TRUE;

	return OldFlags;
}

VOID
MK_ContextSwitchRestore(INT ContextSwitchFlags)
{
	MK_ContextSwitchFlags = ContextSwitchFlags;
}

INT
MK_GetContextSwitchFlags(VOID)
{
	return MK_ContextSwitchFlags;
}

BOOLEAN
MK_GetSchedulePolicy(VOID)
{
	return MK_SchedulePolicy;
}

BOOLEAN	
MK_SetSchedulePolicy(BOOLEAN NewPolicy)
{
	INT OldPolicy;
	INT Flags;

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

	OldPolicy = MK_SchedulePolicy;
	MK_SchedulePolicy = NewPolicy;

	MK_InterruptRestore(Flags);

	return OldPolicy;
}

STATUS
MK_GetTaskPendingValue(MK_TASK *pTask, LONG *pValue)
{
	if (pTask == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_GetTaskPendingValue() - Task doesn't exist! Task(%s)\n", MK_pCurrentTask->t_pName);
#endif
		return MK_ERROR;
	}
	if(pTask->t_Magic != MK_TASK_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_GetTaskPendingValue() - Magic error!\n");
#endif
		return MK_RESOURCE_ERROR;
	}

	*pValue = pTask->t_pendingMemSize;
	return MK_NO_ERROR;
}

STATUS
MK_SetTaskPendingValue(MK_TASK *pTask, LONG Value)
{
	if (pTask == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_SetTaskPendingValue() - Task doesn't exist! Task(%s)\n", MK_pCurrentTask->t_pName);
#endif
		return MK_ERROR;
	}
	if(pTask->t_Magic != MK_TASK_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_SetTaskPendingValue() - Magic error!\n");
#endif
		return MK_RESOURCE_ERROR;
	}

	pTask->t_pendingMemSize = Value;
	return MK_NO_ERROR;
}

STATUS
MK_CreatePendingList(MK_PENDING_LIST *pPending, BOOLEAN Options)
{
	pPending->p_Head = MK_NULL;
	pPending->p_Tail = MK_NULL;
	pPending->p_Sem = 0;
	pPending->p_Options = Options;

	return MK_NO_ERROR;
}

STATUS
MK_DeletePendingList(MK_PENDING_LIST *pPending)
{
	pPending->p_Head = MK_NULL;
	pPending->p_Tail = MK_NULL;
	pPending->p_Sem = 0;
	//pPending = MK_NULL;

	return MK_NO_ERROR;
}

STATUS
MK_InsertTaskToPendingList(MK_PENDING_LIST *pPending, MK_TASK *pTask)
{
	MK_TASK	*pNext;
	INT Flags;

	if (pTask == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_InsertTaskToPendingList() - Task doesn't exist! Task(%s)\n", MK_pCurrentTask->t_pName);
#endif
		return MK_ERROR;
	}
	if(pTask->t_Magic != MK_TASK_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_ERROR, "MK_InsertTaskToPendingList() - Magic error!\n");
#endif
		//while(1);
		return MK_RESOURCE_ERROR;
	}

	if(pTask->t_Status & MK_TASK_SIGNAL)	/* Prevent Delayed State in Signal */
	{
		return MK_ERROR;
	}
	if(pTask->t_Status & MK_TASK_PENDING)
	{
		return MK_ERROR;
	}

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

	pTask->t_PendingList = (ULONG)pPending;
	if(pPending->p_Head == MK_NULL)
	{
		pPending->p_Head = pTask;
		pPending->p_Tail = pTask;
		pTask->t_pPendingNext = MK_NULL;
		pTask->t_pPendingPrev = MK_NULL;
	}
	else
	{
		if(pPending->p_Options == MK_SERVICE_FIFO)
		{
			pTask->t_pPendingPrev = pPending->p_Tail;
			pTask->t_pPendingNext = MK_NULL;
			pPending->p_Tail->t_pPendingNext = pTask;
			pPending->p_Tail = pTask;
		}
		else
		{
			/* pTask is the first position */
			if(pTask->t_Priority < pPending->p_Head->t_Priority)
			{
				pTask->t_pPendingNext = pPending->p_Head;
				pTask->t_pPendingPrev = MK_NULL;
				pPending->p_Head->t_pPendingPrev = pTask;
				pPending->p_Head = pTask;
			}
			else
			{
				pNext=pPending->p_Head;
				for(; pTask->t_Priority>pNext->t_Priority;)
				{
					pNext = pNext->t_pPendingNext;
					if(pNext == MK_NULL)
						break;
				}

				/* pTask is the end position */
				if(pNext == MK_NULL)
				{
					pTask->t_pPendingPrev = pPending->p_Tail;
					pPending->p_Tail->t_pPendingNext = pTask;
					pTask->t_pPendingNext = MK_NULL;
					pPending->p_Tail = pTask;
				}
				else
				{
					pTask->t_pPendingPrev = pNext->t_pPendingPrev;
					pTask->t_pPendingNext = pNext;
			  		pTask->t_pPendingPrev->t_pPendingNext = pTask;
					pNext->t_pPendingPrev = pTask;
				}
			}
		}
	}

	pTask->t_Status |= MK_TASK_PENDING;

	MK_InterruptRestore(Flags);

	return MK_NO_ERROR;
}

STATUS
MK_DeleteTaskFromPendingList(MK_PENDING_LIST *pPending, MK_TASK *pTask)
{
	INT Flags;

	if (pTask == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_DeleteTaskFormPendingList() - Task doesn't exist! Task(%s)\n", MK_pCurrentTask->t_pName);
#endif
		return MK_ERROR;
	}
	if(pTask->t_Magic != MK_TASK_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_ERROR, "MK_DeleteTaskFromPendingList() - Magic error!\n");
#endif
		return MK_RESOURCE_ERROR;
	}

	if(pPending->p_Head == MK_NULL)
	{
		return MK_ERROR;
	}
	if( !(pTask->t_Status & MK_TASK_PENDING) )
	{
		return MK_ERROR;
	} 

	Flags = MK_InterruptDisable();

	if(pPending->p_Head == pPending->p_Tail)
	{
		pPending->p_Head = MK_NULL;
		pPending->p_Tail = MK_NULL;
	}
	else
	{
		if(pTask == pPending->p_Head)
		{
			pPending->p_Head = pTask->t_pPendingNext;
			pPending->p_Head->t_pPendingPrev = MK_NULL;
		}
		else if(pTask == pPending->p_Tail)
		{
			pPending->p_Tail = pTask->t_pPendingPrev;
			pPending->p_Tail->t_pPendingNext = MK_NULL;
		}
		else
		{
			pTask->t_pPendingPrev->t_pPendingNext = pTask->t_pPendingNext;
			pTask->t_pPendingNext->t_pPendingPrev = pTask->t_pPendingPrev;

		}
	}

	pTask->t_pPendingNext = MK_NULL;
	pTask->t_pPendingPrev = MK_NULL;

	pTask->t_PendingList = 0;
	pTask->t_Status &= ~MK_TASK_PENDING;

	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;
}

int
MK_ClearPendingList(MK_PENDING_LIST *pPending)
{
	MK_TASK *pTask;
	MK_TASK *NewpTask;
	INT		Count, Flags;

	Flags = MK_InterruptDisable();

	Count = 0;
	pTask = pPending->p_Head;
	while(pTask != MK_NULL)
	{
		/* A chained task was deleted. (2003/03/03 Modified by hjahn) */
		NewpTask = pTask->t_pPendingNext;
		/* Modified */

		MK_DeleteTaskFromPendingList(pPending, pTask);
		if(pTask->t_Status & MK_TASK_DELAYED)
		{
			MK_DeleteTaskFromDelayedList(pTask);
		}
		MK_InsertTaskToReadyList(pTask);
		pTask->t_Status |= MK_TASK_FORCED;
		
		pTask = NewpTask;
		
		Count++;
	}

	MK_InterruptRestore(Flags);
	return Count;
}

MK_TASK *
MK_GetFirstPendingTask(MK_PENDING_LIST *pPending)
{
	return pPending->p_Head;
}

#if 0
void MK_Task_Information(MK_TASK *pTask, STATUS *status)
{
	if( pTask->t_Status == MK_TASK_PENDING)
		*status = 4;
	else
		*status = 0;
}
#endif
#if 0
STATUS 
MK_Task_Information(MK_TASK *ptask, CHAR *pname,  UINT *status, 
	UINT *priority, LONG *timeslice, void **stack_base,
	UINT *stack_size, void *reserved1, void *reserved2) 
{
	MK_BlockCopy(pname, ptask->t_pName, sizeof(ptask->tpName));
	*status = ptask->t_Status;
	*priority = ptask->t_Priority;
	
	
}
#endif

#if 0
#ifdef _MK_DDI
STATUS
MK_TaskInformation(struct mk_ddi_struct *pDDI)
{
	MK_TASK *pTask;
	int Flags;

	pTask = MK_pTaskListHead;

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

	while(pTask != MK_NULL)
	{
		MK_Fprintf(pDDI, "%s ", pTask->t_pName);
		MK_Fprintf(pDDI, "%d ", pTask->t_Priority);

		if(pTask->t_Status & MK_TASK_READY)
		{
			MK_Fprintf(pDDI, "%c", 'R');
		}

		if(pTask->t_Status & MK_TASK_DELAYED)
		{
			MK_Fprintf(pDDI, "%c", 'D');
		}
		if(pTask->t_Status & MK_TASK_PENDING)
		{
			MK_Fprintf(pDDI, "%c", 'P');
		}
		if(pTask->t_Status & MK_TASK_DORMANT)
		{
			MK_Fprintf(pDDI, "%c", 'M');
		}
		if(pTask->t_Status & MK_TASK_SIGNAL)
		{
			MK_Fprintf(pDDI, "%c", 'S');
		}
		if(pTask->t_Status & MK_TASK_FORCED)
		{
			MK_Fprintf(pDDI, "%c", 'S');
		}
		if(pTask->t_Status & MK_TASK_SUSPEND)
		{
			MK_Fprintf(pDDI, "%c", 'U');
		}
	}

	MK_Fprintf(pDDI,"\n");
	MK_InterruptRestore(Flags);

	return MK_NO_ERROR;
}

#endif /* _MK_DDI */
#endif