#ifndef __DST_OSLAYER_H__
#define __DST_OSLAYER_H__

#include "dsthallocal.h"
#include <pthread.h> 

typedef void (*OS_TASKFUNCTION)(DS_U32 arg1);
#define	OS_TASK_ID			DS_U32
#define	OS_MESSAGEQUEUE_ID	DS_U32
#define	OS_SEMAPHORE_ID		DS_U32
#define	OS_MUTEX_ID			DS_U32

#ifndef OS_WAIT_FOREVER
#define	OS_WAIT_FOREVER		0xFFFFFFFF
#endif

//
// ¿©±â¼­ Á¤ÀÇµÈ DefinitionÀº °°Àº À̸§ÀÇ API°¡ ¼±¾ðµÇÁö ¾ÊÀ½.
//

//#define OS_DeleteTask			gmCL_ThreadKill
//#define OS_SelfDeleteTask()		gmCL_ThreadExit(0)


#define	OS_GetTicksPerSecond()	(100)
//#define OS_Delay(tick)			usleep((tick) * (1000000/OS_GetTicksPerSecond()))
//#define OS_mDelay(mil)			usleep((mil) * 1000)


//#define	OS_DeleteSemaphore		gmCL_SemaphoreDelete
//#define	OS_TakeSemaphore		gmCL_SemaphoreWait
//#define	OS_GiveSemaphore		gmCL_SemaphorePost


//#define	OS_TakeMutex			gmCL_MutexLock
//#define	OS_TakeMutex_NoWait		gmCL_MutexTryLock
//#define	OS_GiveMutex			gmCL_MutexUnlock



#ifdef __cplusplus
extern "C"{
#endif

void OS_Init(void);

// ================ Thread API =======================
#ifndef OS_SpawnTask
DS_U32 OS_SpawnTask (void (*func)(DS_U32), char *name, DS_U16 prio, DS_U16 stacksize, DS_U32 arg);
#endif

#if !defined(OS_DeleteTask)
DS_U32 OS_DeleteTask(DS_U32 TaskId);
#endif

#if !defined(OS_SelfDeleteTask)
void OS_SelfDeleteTask(void);
#endif

#ifndef OS_SuspendTask
DS_U32 OS_SuspendTask(DS_U32 TaskId);
#endif

#ifndef OS_ResumeTask
DS_U32 OS_ResumeTask(DS_U32 TaskId);
#endif

#ifndef OS_GetSelfTaskId
OS_TASK_ID OS_GetSelfTaskId(void);
#endif

// ================ Time API  ========================
#ifndef OS_GetTicksPerSecond
DS_U32 OS_GetTicksPerSecond (void);
#endif

#ifndef OS_Delay
void OS_Delay(DS_U32 Ticks);
#endif

#ifndef OS_mDelay
void OS_mDelay(DS_U32 milliseconds);
#endif

#ifndef OS_uDelay
void OS_uDelay(DS_U32 useconds);
#endif


#ifndef OS_GetTickCount
DS_U32 OS_GetTickCount(void);
#endif

// ================ Semaphore ========================
#ifndef OS_CreateCountingSemaphore
DS_U32 OS_CreateCountingSemaphore (const char *name, DS_U32 options, DS_U32 count);
#endif

#ifndef OS_CreateBinarySemaphore
DS_U32 OS_CreateBinarySemaphore(const char *name, DS_U32 options, DS_U32 count);
#endif

#ifndef OS_DeleteSemaphore
DS_U32 OS_DeleteSemaphore (DS_U32 SemId);
#endif

#ifndef OS_TakeSemaphore
DS_U32 OS_TakeSemaphore (DS_U32 SemId);
#endif

#ifndef OS_TakeSemaphore_Wait
DS_U32 OS_TakeSemaphore_Wait(DS_U32 SemId, DS_U32 timeout);
#endif

#ifndef OS_TakeSemaphore_NoWait
DS_U32 OS_TakeSemaphore_NoWait(DS_U32 SemId);
#endif

#ifndef OS_GiveSemaphore
DS_U32 OS_GiveSemaphore(DS_U32 SemId);
#endif

#ifndef OS_FlushSemaphore
DS_U32 OS_FlushSemaphore(DS_U32 SemId);
#endif

// ================ Mutex API ===========================
#ifndef OS_CreateMutex
OS_MUTEX_ID OS_CreateMutex(const char *name);
#endif

#ifndef OS_DeleteMutex
DS_U32 OS_DeleteMutex(OS_MUTEX_ID mutexId);
#endif

#ifndef OS_TakeMutex
DS_U32 OS_TakeMutex(OS_MUTEX_ID mutexId);
#endif

#ifndef OS_TakeMutex_NoWait
DS_U32 OS_TakeMutex_NoWait(DS_U32 mutexId);
#endif

#ifndef OS_GiveMutex
DS_U32 OS_GiveMutex(DS_U32 mutexId);
#endif


// ================ Message Queue API ====================
#ifndef OS_CreateMessageQueue
DS_U32 OS_CreateMessageQueue (const char *name, DS_U32 option, DS_U32 maxMessage, DS_U32 messageLength);
#endif

#ifndef OS_SendMessage
DS_U32 OS_SendMessage (DS_U32 qId, DS_U32 *pBuffer, DS_U32 nBytes);
#endif

#ifndef OS_ReceiveMessage
DS_U32 OS_ReceiveMessage(DS_U32 qId, DS_U32 *msgBuf, DS_U32 maxLen, DS_U32 *retLen);
#endif

#ifndef OS_ReceiveMessage_Wait
DS_U32 OS_ReceiveMessage_Wait(DS_U32 qId, DS_U32 *msgBuf, DS_U32 maxLen, DS_U32 *retLen, DS_U32 timeOut);
#endif

#ifndef OS_ReceiveMessage_NoWait
DS_U32 OS_ReceiveMessage_NoWait(DS_U32 qId, DS_U32 *msgBuf, DS_U32 maxLen, DS_U32 *retLen);
#endif

#ifndef OS_DeleteMessageQueue
DS_U32 OS_DeleteMessageQueue(DS_U32 qId);
#endif

// ================ Dynamic Memory API ====================
#define OS_malloc(a)				_OS_malloc(a, __func__, __LINE__)
#define OS_calloc(a, b)			    _OS_calloc(a, b, __func__, __LINE__)
#define OS_realloc(a, b)			_OS_realloc(a, b, __func__, __LINE__)
#define OS_free(a)					_OS_free(a, __func__, __LINE__)

void *_OS_malloc(unsigned int size, const char* func, int nLine);
void *_OS_calloc(unsigned int count, unsigned int size, const char* func, int nLine); 
void *_OS_realloc(void* memory, unsigned int size, const char* func, int nLine); 
void   _OS_free(void *where, const char* func, int nLine);

void *OS_malloc2(unsigned int size);
void *OS_calloc2(unsigned int count, unsigned int size); 
void *OS_realloc2(void* memory, unsigned int size); 
void   OS_free2(void *where);

DS_U32 OS_ReadRegister( DS_U32 Address );
DS_U32 OS_ReadRegisterWord( DS_U32 Address );
DS_U32 OS_ReadRegisterByte( DS_U32 Address );
DS_U32 OS_WriteRegister( DS_U32 Address, DS_U32 Value );
DS_U32 OS_WriteRegisterWord( DS_U32 Address, DS_U32 Value );
DS_U32 OS_WriteRegisterByte( DS_U32 Address, DS_U32 Value );
DS_U32 OS_GetLoaderVer(void);
#ifdef __cplusplus
	}
#endif

#endif	/* __DST_OSLAYER_H__ */