/**********************************************************************************
 * mk_task.h                                                                         
 * coded by hspark@ce.cnu.ac.kr
 * date : 2002/06/23
 **********************************************************************************/

#ifndef __MK_TASK_H__
#define __MK_TASK_H__

#include "kernel\\mk_sys.h"
#include "kernel\\mk_ddi.h"

#define		MK_TASK_MAGIC			0xF3CD03E2L		/* Magic Value of Task */

/* Task's Status */
#define		MK_TASK_READY			0x00000001		/* Ready State */
#define		MK_TASK_DELAYED			0x00000002		/* Delayed State */
#define		MK_TASK_PENDING			0x00000004		/* Pending State */
#define		MK_TASK_DORMANT			0x00000008		/* Dormant State */
#define		MK_TASK_SIGNAL			0x00000010		/* Signaled Stated */
#define		MK_TASK_FORCED			0x00000020	/* Force to READY by Resource Deleete */
#define		MK_TASK_SUSPEND			0x00000040	/* Suspned : not ready state */

#define		MK_TASK_MIN_PRIORITY	0
#define		MK_TASK_MAX_PRIORITY	255
#define     Idle_Task		255
#define		MK_DEFAULT_TIMESLICE	1

#define		MK_TASK_FIFO			0		/* FIFO Schedule in Same Priority Task */
#define		MK_TASK_RR				1		/* Round-Robin Schedule in Same Priority Task */

#define		MK_SERVICE_FIFO			0
#define		MK_SERVICE_PRIORITY		1

#define		MK_WAIT_FOREVER			-1
#define		MK_NO_WAIT				0

/*add*/
#define		MK_INTERRUPT_DISABLE		0xc0
#define		MK_INTERRUPT_ENABLE		0x00

typedef	void(*MK_TASK_FUNC_T)(ULONG, VOID *);

#pragma packed on
typedef struct mk_task_struct {
	ULONG	t_Magic;						/* Magic Value of Task Control Block */
	ULONG	t_CurrentOfStack;				/* Current Pointer of Stack */
	ULONG	t_TopOfStack;					/* Top Pointer of Stack */
	ULONG	t_BottomOfStack;				/* Bottom Pointer of Stack */
	ULONG	t_PreviousCurrentOfStack;		/* Used in Signal */
	ULONG	t_LengthofStackArea;			/* Length of Reserved Stack Area */
	ULONG	t_Status;						/* Status of Task */
	ULONG	t_Priority;						/* Priority of Task */
	MK_TASK_FUNC_T	t_Function;				/* Fucntion for Task */
	LONG	t_RemainedTimeSlice;			/* Remained Time Slice */
	LONG	t_TimeSlice;					/* Initialized TimeSlice */
	LONG	t_UsedTimeSlice;				/* Accumulated Timeslice */
	LONG	t_DelayedDeltaTicks;			/* Use temporary in DelayedList */
	ULONG	t_Arg1;
	VOID	*t_Arg2;
	CHAR	*t_pName;			/* Task's Name */
	//CHAR	t_pName[MK_NAME_MAX];			/* Task's Name */

	ULONG	t_PendingList;					/* Pending List to whitch task is pending */
	ULONG	t_pendingMemSize;					/* Value during memory Pending */

#ifdef	_MK_TPORT
	ULONG	t_PortPending;
	ULONG	t_PortValueAvailable;
	ULONG	t_PortValue;					/* Value during port Pending */
#endif
#ifdef	_MK_SIGNAL
	ULONG	t_Signal;
	ULONG	t_SigMask;
	VOID	(*t_pSigFunction)(ULONG);
#endif
#ifdef	_MK_EVENT
	ULONG	t_EventRequested;				/* Event Flag */
	ULONG	t_EventOperation;				/* Event Flag */
	ULONG	t_EventActualEvents;			/* Event Flag */
#endif

	struct mk_task_struct *t_pTaskNext;
	struct mk_task_struct *t_pTaskPrev;
	struct mk_task_struct *t_pTaskReadyNext;
	struct mk_task_struct *t_pTaskReadyPrev;
	struct mk_task_struct *t_pDelayedNext;
	struct mk_task_struct *t_pDelayedPrev;
	struct mk_task_struct *t_pPendingNext;
	struct mk_task_struct *t_pPendingPrev;	
} MK_TASK;

typedef struct mk_pending_list_struct {
	struct mk_task_struct	*p_Head;
	struct mk_task_struct	*p_Tail;
	ULONG			p_Sem;
	BOOLEAN					p_Options;
} MK_PENDING_LIST;
#pragma packed off

	
extern MK_TASK	*MK_pTaskReadyListHead[MK_TASK_MAX_PRIORITY+1]; 
extern MK_TASK	*MK_pTaskReadyListTail[MK_TASK_MAX_PRIORITY+1];
extern MK_TASK	*MK_pTaskListHead, *MK_pTaskListTail;
extern MK_TASK	*MK_pTaskDelayedListHead;
extern MK_TASK	*MK_pCurrentTask;

VOID MK_StartHighPriorityTask(ULONG *pCurrentStack);
VOID MK_ContextSwitch(ULONG *pOldStack, ULONG *pNewStack);
VOID MK_TaskInitialize( VOID );
MK_TASK *MK_CreateTask(MK_TASK *pTask, MK_TASK_FUNC_T Function, INT Priority,
					CHAR *pTaskName, LONG TimeSlice, CHAR *pStackArea, 
					LONG StackLength, ULONG Arg1, VOID *Arg2);

//STATUS MK_DeleteTask(MK_TASK *pTask, MK_TASK_FUNC_T Function, ULONG Arg1, VOID *Arg2);
STATUS MK_DeleteTask(MK_TASK *pTask);
STATUS MK_ResetTask(MK_TASK *pTask, ULONG Arg1, VOID *Arg2);
VOID MK_Start(VOID);
INT MK_ChangePriority(MK_TASK *pTask, INT NewPrio);
INT MK_GetPriority(MK_TASK *pTask);
MK_TASK *MK_GetCurrentTask(VOID);
UINT MK_GetCurrentTaskStackPointer(VOID);
STATUS MK_Suspend(MK_TASK *pTask);
STATUS MK_Resume(MK_TASK *pTask);
VOID MK_SleepTicks(LONG Ticks);
STATUS MK_Unsleep(MK_TASK *pTask);
INT MK_GetHighPriority(VOID);
INT MK_ContextSwitchDisable(VOID);
INT MK_ContextSwitchEnable(VOID);
VOID MK_ContextSwitchRestore(INT ContextSwitchFlags);
INT MK_GetContextSwitchFlags(VOID);
BOOLEAN MK_GetSchedulePolicy(VOID);
BOOLEAN MK_SetSchedulePolicy(BOOLEAN NewPolicy);
CHAR *MK_GetTaskName(MK_TASK *pTask);



/* coded by hjahn */
LONG MK_ChangeTimeSlice(MK_TASK *pTask, LONG newTimeSlice);
INT MK_GetTotalTasks(VOID);
VOID MK_AddTotalTasks(VOID);
VOID MK_DelTotalTasks(VOID);
/* coded by hjahn - end */

/* Internal Function */
VOID MK_TaskMagicCheck( MK_TASK *pTask, CHAR *argv);
INT MK_PENDINGLOCK(VOID);
INT MK_PENDINGUNLOCK(VOID);
VOID MK_TaskShell(VOID);
VOID MK_Schedule(VOID);
VOID MK_Wakeup(VOID);
STATUS MK_InsertTaskToReadyList(MK_TASK *pTask);
STATUS MK_DeleteTaskFromReadyList(MK_TASK *pTask);
STATUS MK_InsertTaskToDelayedList(MK_TASK *pTask, LONG Ticks);
STATUS MK_DeleteTaskFromDelayedList(MK_TASK *pTask);
LONG MK_GetTaskRemainedTicksFromDelayedList(MK_TASK *pTask);
VOID MK_IntEnter(VOID);
VOID MK_IntExit(VOID);
STATUS MK_GetTaskPendingValue(MK_TASK *pTask, LONG *pValue);
STATUS MK_SetTaskPendingValue(MK_TASK *pTask, LONG Value);
STATUS MK_CreatePendingList(MK_PENDING_LIST *pPending, BOOLEAN Options);
STATUS MK_DeletePendingList(MK_PENDING_LIST *pPending);
STATUS MK_InsertTaskToPendingList(MK_PENDING_LIST *pPending, MK_TASK *pTask);
STATUS MK_DeleteTaskFromPendingList(MK_PENDING_LIST *pPending, MK_TASK *pTask);
INT MK_ClearPendingList(MK_PENDING_LIST *pPending);
MK_TASK *MK_GetFirstPendingTask(MK_PENDING_LIST *pPending);
STATUS MK_TaskInformation(struct mk_ddi_struct *pDDI);


#endif /* __MK_TASK_H__*/