mk_irtos.h

三星ic 9980的源代码. 718版.

	CHAR	*bp_pName;
	struct mk_semaphore_struct bp_Semaphore;
	struct mk_buffer_pool_struct *bp_pNext;
	struct mk_buffer_pool_struct *bp_pPrev;
} MK_POOL;

typedef struct mk_fixed_msg_queue_struct {
	ULONG	fq_Magic;
	ULONG	fq_AvailableSize;
	struct mk_fixed_queue_msg_struct *fq_pMsgListHead;
	struct mk_fixed_queue_msg_struct *fq_pMsgListTail;
	struct mk_buffer_pool_struct	fq_Pool;	/* Include SendSemaphore */
	struct mk_semaphore_struct		fq_ReceiveSemaphore;
} MK_FIXED_QUEUE;

typedef struct mk_variable_queue_msg_struct {
	ULONG	vm_StartOfMsg;
	ULONG	vm_Length;
	struct mk_variable_queue_msg_struct *vm_pNext;
} MK_VARIABLE_QUEUE_MSG;

typedef struct mk_variable_msg_queue_struct {
	ULONG	vq_Magic;
	ULONG	vq_MaxSize;
	struct mk_variable_queue_msg_struct *vq_pMsgListHead;
	struct mk_variable_queue_msg_struct *vq_pMsgListTail;
	struct mk_heap_struct vq_Heap;				/* Include SendSemaphore */
	struct mk_semaphore_struct vq_ReceiveSemaphore;
} MK_VARIABLE_QUEUE;

typedef struct mk_msg_queue_struct {
	ULONG	m_Type;
	struct mk_msg_queue_struct *m_pNext;
	struct mk_msg_queue_struct *m_pPrev;
	CHAR	*m_pName;
	union {
		struct mk_fixed_msg_queue_struct mu_FixedQueue;
		struct mk_variable_msg_queue_struct mu_VariableQueue;
	} m_Queue;
} MK_QUEUE;

typedef struct mk_port_msg_struct {
	ULONG	pm_Msg;							/* Msg Pointer */
	LONG		pm_MsgLength;
	LONG		pm_BufLength;
	struct mk_port_msg_struct	*pm_pNext;
} MK_PORT_MSG;

typedef struct mk_message_port_struct {
	ULONG	p_Magic;
	LONG	p_MsgCount;
	LONG	p_MaxMsg;
	CHAR	*p_Name;
	struct mk_message_port_struct	*p_pNext;
	struct mk_message_port_struct	*p_pPrev;
	struct mk_port_msg_struct *p_pMsgFreeList;
	struct mk_port_msg_struct *p_pMsgListHead;
	struct mk_port_msg_struct *p_pMsgListTail;
	struct mk_semaphore_struct p_SendSemaphore;
	struct mk_semaphore_struct p_ReceiveSemaphore;
} MK_PORT;

typedef struct mk_msg_mailbox_struct {
	ULONG	mb_Magic;
	ULONG	mb_Msg;								/* Msg Pointer */
	ULONG	mb_StartOfMsg;
	ULONG	mb_MsgLength;
	ULONG	mb_BufferSize;
	CHAR   	*mb_pName;
	struct mk_msg_mailbox_struct *mb_pNext;
	struct mk_msg_mailbox_struct *mb_pPrev;
	struct mk_semaphore_struct mb_SendSemaphore;
	struct mk_semaphore_struct mb_ReceiveSemaphore;
} MK_MBOX;

typedef struct mk_hisr_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	reserved1;						/* not used */
	ULONG	t_Priority;						/* Priority of Task */
	void (*t_Function)(void);				/* Fucntion for Task */
	ULONG	reserved2[4];					/* not used */
	ULONG	t_ActivateCount;				/* active count */
	VOID	*reserved3;						/* not used */
	CHAR	*t_pName;			/* Task's Name */
	//CHAR	t_pName[MK_NAME_MAX];			/* Task's Name */

	ULONG	reserved4;
	ULONG	reserved5;
#if	_MK_TPORT
	ULONG	reserved6[3];
#endif
#if	_MK_SIGNAL
	ULONG	reserved7[2];
	ULONG	reserved8;
#endif
#if	_MK_EVENT
	ULONG	reserved9[2];
	ULONG	reserved10;
#endif

	struct mk_hisr_struct *t_pHISRNext;
	struct mk_hisr_struct *t_pHISRPrev;
	struct mk_hisr_struct *t_pHISRActiveNext;
	struct mk_hisr_struct *t_pHISRActivePrev;
	
	ULONG	*reserved11[4];					/* not used */
} MK_HISR;

typedef struct mk_event_struct {
	ULONG	e_Magic;					/* Event Magic number */
	ULONG	e_Events;					/* Current event flag */
	CHAR	*e_pName;
	struct mk_event_struct *e_pNext;
	struct mk_event_struct *e_pPrev;
	struct mk_pending_list_struct s_PendingList;
} MK_EVENT;
/*-----------------------------------------------------------------
 * String Library API Function
 *-----------------------------------------------------------------*/
char *MK_Strcpy(char *pDst, char *pSrc);
int MK_Strlen(char *pString);
int MK_Strcmp(char *pStr1, char *pStr2);
char *MK_Strcat(char *pStr1, char *pStr2);
char *MK_BlockCopy(char *pDst, char *pSrc, int Lenth);
char *MK_MemCopy(char *pDst, char Ch, int Length);

/*-----------------------------------------------------------------
 * Interrupt API Function
 *-----------------------------------------------------------------*/
INT MK_InterruptDisable(VOID);
VOID MK_InterruptRestore(INT);
INT MK_InterruptEnable(VOID);
int MK_LocalControlInterrupt(int);

int MK_IRQInstall(int Num, void(*lisr_entry)(INT));
// int MK_FIQInstall(int Num, void(*lisr_entry)(int));

/*-----------------------------------------------------------------
 * Task API Function
 *-----------------------------------------------------------------*/
MK_TASK *MK_CreateTask(MK_TASK *pTask, void(*task_entry)(ULONG, VOID*), INT Priority,
					CHAR *pTaskName, LONG TimeSlice, CHAR *pStackArea, 
					ULONG StackLength, ULONG Arg1, VOID *Arg2);
STATUS MK_DeleteTask(MK_TASK *pTask);
STATUS MK_ResetTask(MK_TASK *pTask, ULONG Arg1, VOID *Arg2);
INT MK_ChangePriority(MK_TASK *pTask, INT NewPrio);
INT MK_GetPriority(MK_TASK *pTask);
MK_TASK *MK_GetCurrentTask(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_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);
LONG MK_ChangeTimeSlice(MK_TASK *pTask, LONG newTimeSlice);
INT MK_GetTotalTasks(VOID);

/* coded by ympark */
VOID MK_Protect(MK_PROTECT *p_struct);

/*-----------------------------------------------------------------
 * Timer API Function
 *-----------------------------------------------------------------*/
STATUS MK_CreateTimer(MK_TIMER *pTimer, CHAR *pName, MK_TIMER_FUNC_T Function, INT Arg1, CHAR *Arg2, 
			   ULONG InitialTime, ULONG RepeateTime, BOOLEAN Enable);
long MK_GetTimerRepeateTime(MK_TIMER *pTimer);
long MK_SetTimerRepeateTime(MK_TIMER *pTimer, long NewTime);
BOOLEAN MK_GetTimerStatus(MK_TIMER *pTimer);
STATUS MK_ControlTimer(MK_TIMER *pTimer, BOOLEAN Enable);
STATUS MK_DeleteTimer(MK_TIMER *pTimer);
STATUS MK_GetRemainingTime( MK_TIMER *pTimer, ULONG *remainTime);
STATUS MK_ResetTimer(MK_TIMER *pTimer, void(*timer_entry)(ULONG), 
					 long ExpireTime, long RepeatTime, BOOLEAN Enable);
ULONG MK_GetSystemClock(void);
void MK_SetSystemClock(ULONG newTicks);

/*-----------------------------------------------------------------
 * Task Port API Function
 *-----------------------------------------------------------------*/
STATUS MK_TaskPortSend(MK_TASK *pTask, ULONG Value, BOOLEAN Ignore);
STATUS MK_TaskPortReceive(ULONG *Value, LONG Ticks);
VOID MK_TaskPortClear(VOID);

/*-----------------------------------------------------------------
 * Signal API Function
 *-----------------------------------------------------------------*/
STATUS MK_RegisterSignalHandler(void(*signal_entry)(ULONG));
ULONG MK_GetSignalMask(VOID);
ULONG MK_SetSignalMask(ULONG SigMask);
VOID MK_ClearSignal(VOID);
VOID MK_SignalSend(MK_TASK *pTask, ULONG Signal);
ULONG MK_ReceiveSignals(VOID);

/*-----------------------------------------------------------------
 * Semaphore API Function
 *-----------------------------------------------------------------*/
STATUS MK_CreateSemaphore(MK_SEMAPHORE *pSemaphore, char *pName, int Count, BOOLEAN Options);
int MK_GetSemaphoreCount(MK_SEMAPHORE *pSemaphore);
int MK_DeleteSemaphore(MK_SEMAPHORE *pSemaphore);
STATUS MK_SemaphorePend(MK_SEMAPHORE *pSemaphore, long Ticks);
STATUS MK_SemaphorePost(MK_SEMAPHORE *pSemaphore);
STATUS MK_SemaphoreReset(MK_SEMAPHORE *pSemaphore, int Count);

/*-----------------------------------------------------------------
 * Queue API Function
 *-----------------------------------------------------------------*/
STATUS MK_CreateMsgQueue(MK_QUEUE *pQueue, CHAR *pName, VOID *pAddr, ULONG Size, BOOLEAN Type, 
			ULONG MsgSize, BOOLEAN Options);
STATUS MK_DeleteMsgQueue(MK_QUEUE *pQueue);
STATUS MK_MsgQueuePend(MK_QUEUE *pMsgQueue, void *pMsg, 
							   ULONG BufSize, ULONG *pLength, long Ticks);
STATUS MK_MsgQueuePost(MK_QUEUE *pMsgQueue, void *pMsg, ULONG Length, 
							   long Ticks);
STATUS MK_MsgQueueReset(MK_QUEUE *pQueue);
STATUS MK_MsgQueueFrontPost(MK_QUEUE *pQueue, void *pMsg, ULONG Length, long Ticks);
STATUS MK_MsgQueueBroadcastPost(MK_QUEUE *pQueue, void *pMsg, ULONG Length, long Ticks);

ULONG MK_GetMsgQueueAvailableSize(MK_QUEUE *pQueue);
ULONG MK_GetFixedMsgQueueNeededSize(ULONG Count, ULONG	Size);
ULONG MK_GetFixedMsgQueueBufferSize(MK_QUEUE *pQueue);
ULONG MK_GetFixedMsgQueueCount(MK_QUEUE *pQueue);

/*-----------------------------------------------------------------
 * Message Port API Function
 *-----------------------------------------------------------------*/
STATUS MK_CreateMsgPort(MK_PORT *pPort, char *pName, void *pAddr, 
						int MsgCount, BOOLEAN Options);
ULONG MK_GetMsgPortMemorySize(UINT MsgCount);
STATUS MK_DeleteMsgPort(MK_PORT *pPort);
ULONG MK_GetMsgPortCount(MK_PORT *pPort);
STATUS MK_MsgPortPend(MK_PORT *pPort, void **pMessage, int *pMsgLength, 
					  int *pBufLength, long Ticks);
STATUS MK_MsgPortPost(MK_PORT *pPort, char *pMessage, LONG pMsgLength, 
					  LONG pBufLength, long Ticks);

/*-----------------------------------------------------------------
 * Memory Management API Function
 *-----------------------------------------------------------------*/
STATUS MK_CreateHeapManager(MK_HEAP *pHeap, char *pName, void *pAddr, unsigned long Length, 
							ULONG	MinSize, BOOLEAN Options);
STATUS MK_DeleteHeapManager(MK_HEAP *pHeap);
STATUS MK_ResetHeapManager(MK_HEAP *pHeap);
STATUS MK_GetHeapInformation(MK_HEAP *pHeap, void **pStartAddr, ULONG *pSize, 
	   ULONG *pMinSize, ULONG *pAvailableSize);
STATUS MK_GetMemory(MK_HEAP *pHeap, void **pAddr, ULONG Size, long Ticks);
STATUS MK_FreeMemory(void *pAddr);
ULONG MK_GetHeapMaxMemorySize(MK_HEAP *pHeap);

STATUS MK_CreateBufferPool(MK_POOL *pPool, CHAR *pName, VOID *pAddr, INT Count, 
						 ULONG Size, BOOLEAN Options);
STATUS MK_DeleteBufferPool(MK_POOL *pPool);
STATUS MK_ResetBufferPool(MK_POOL *pPool);
STATUS MK_GetBuf(MK_POOL *pPool, void **pAddr, long Ticks);
STATUS MK_FreeBuf(void *pAddr);
ULONG MK_GetPoolNeededSize(ULONG Count, ULONG	Size);
ULONG MK_GetPoolBufferSize(MK_POOL *pPool);
ULONG MK_GetPoolBufferFreeCount(MK_POOL *pPool);


/*-----------------------------------------------------------------
 * Message Mailbox API Function
 *-----------------------------------------------------------------*/
STATUS MK_CreateMsgMailBox(MK_MBOX *pMBox, char *pName, void *pAddr, ULONG Size, 
						   BOOLEAN Options);
ULONG MK_GetMsgMailBoxMemorySize(ULONG Size);
STATUS MK_DeleteMsgMailBox(MK_MBOX *pMBox);
STATUS MK_MsgMailBoxReset(MK_MBOX *pMBox);
STATUS MK_MsgMailBoxPend(MK_MBOX *pMBox, void **pMsg, ULONG BufSize, ULONG *pLength, 
						 long Ticks);
STATUS MK_MsgMailBoxPost(MK_MBOX *pMBox, void *pMsg, ULONG Length, long Ticks);
STATUS MK_MsgMailBoxBroadcastPost(MK_MBOX *pMBox, void *pMsg, ULONG Length, long Ticks);

/*-----------------------------------------------------------------
 * HISR API Function
 *-----------------------------------------------------------------*/
MK_HISR *MK_CreateHISR(MK_HISR *pHisr, CHAR *name, void(*hisr_entry)(void), INT Priority,
						CHAR *StackPtr, INT StackLength);
VOID MK_ActivateHISR(MK_HISR *pHisr);
VOID MK_DeleteHISR(MK_HISR *pHisr);
MK_HISR *MK_GetCurrentHISR(VOID);

/*-----------------------------------------------------------------
 * API Function
 *-----------------------------------------------------------------*/
STATUS MK_CreateEvent(MK_EVENT *pEvent, char *pName);
STATUS MK_DeleteEvent(MK_EVENT *pEvent);
STATUS MK_SetEvent(MK_EVENT *pEvent, ULONG Events, UINT operation);
STATUS MK_EventPend(MK_EVENT *pEvent, ULONG Request, UINT Operation, ULONG *Events,
					LONG Ticks);

#endif