/**
	@file
		DHL_OSAL.h
	
	@brief	
		OS Abstraction Layer Interface	

	Copyright 2006~2010 Digital STREAM Technology, Inc.
	All Rights Reserved

	Release History:
	
*/


#ifndef __DHL_OSAL_H__
#define __DHL_OSAL_H__


#include "DHL_Types.h"
#include "DHL_OSAL_Impl.h"
#include "ministd.h"
#include "bkni.h"



#ifndef USE_ADS_TOOLCHAIN
/**
	ADS toolchain을 사용하는 경우에는 __func__가 기본적으로 사용되므로
	아래에서 문제가 있기 때문에 막도록 한다.
*/
  #define __func__ __FUNCTION__
#endif

#ifdef __cplusplus
extern "C" {
#endif


#if COMMENT
____Overview____(){}
#endif

/** \file DHL_OSAL.h
	DHL_OSAL 헤더파일 내용 설명
	
	module overview
		OS Abstract Layer를 제공하는 헤더 파일이다.
			
	OS Heap
		메모리 할당, 해제 하는 API
		

	implementations
		
	dependencies		
		
*/

#if COMMENT
____Config____(){}
#endif

/**
	task는 system 전체적으로 관리되어야 하는 리소스이다.
	특히 priority는 다른 task들과의 상대적인 관계를 고려해야 하므로,
	하나의 파일에서 관리하도록 한다.
*/
#include "DHL_OSAL_Config.h"



#if COMMENT
____Types____(){}
#endif

/*
	태스크, 세마포어, 메시지큐에 대한 간략한 설명.
*/

/** \typedef DHL_OS_TASK_ID
	
	태스크:
	
		RTOS에서 동시 처리 가능한 실행 단위를 의미한다.
		일반 OS에서 process, thread, task 등의 개념과 유사하며,
		혼동을 방지하기 위해 Task라는 용어로 통일하여 사용한다.
		
		RTOS에서 모든 task는 주소 공간을 공유한다. 이런 점에서는 process와는 
		구별된다.
		
		태스크를 생성할 때에 stack 크기와 우선순위를 지정해야 한다.

*/
/** \typedef DHL_OS_SEMA_ID

	세마포어:
	
		각종 태스크 동기화에 사용된다.
		세 종류의 세마포어를 지원한다.
		
		-# CountingSemaphore
			- 제한된 수의 리소스를 서로 안전하게 공유하기 위해 사용된다.
		-# BinarySemaphore
			- Counting 세마포어의 내부 count값이 최대 1인 경우에 해당된다.
		-# MutexSemaphore
			- critical section에 동시 진입이 되지 않도록 보호하는데 사용된다.
		
		모든 세마포어는 생성시에는 서로 다른 API를 사용하지만,
		사용시에는 Take/Give 와 같은 용어의 통일된 API를 사용한다.
		
		세마포어의 Take 는 lock의 개념이고,
		세마포어의 Give 는 unlock의 개념이다.
		
*/
/**	\typedef DHL_OS_MSGQ_ID

	메시지큐:
	
		임의 타입의 데이터를 입출력 할 수 있는 FIFO 버퍼.
		선입선출 방식으로 동작한다. 
		
		큐가 만들어 질 때 입력 가능한 최대 데이터크기를 지정해야 하며,
		모든 input/output 메시지는 그 지정된 크기보다 작아야 한다.
		따라서 이 메시지큐는 가변 크기의 메시지를 처리하는데에는 
		그다지 적합하지는 않다.
		
		큐가 만들어 질 때 입력 가능한 최대 데이터 갯수도 지정해야 한다.
		output 이 되지 않으면서 계속 input 만 되는 경우 
		que overflow가 될 수 있다.
		
	보다 상세한 설명은 구글 문서의 "OSAL API 디자인" 문서를 참고한다.
		
*/

#if	1//def UCOS_II
typedef os_taskfunction OS_TASKFUNCTION;
typedef os_task_id DHL_OS_TASK_ID;
typedef os_semaphore_id DHL_OS_SEMA_ID;
typedef os_messagequeue_id DHL_OS_MSGQ_ID;

#define OS_SEMAPHORE_ID DHL_OS_SEMA_ID

#else
typedef UINT32 DHL_OS_TASK_ID;
typedef UINT32 DHL_OS_SEMA_ID;
typedef UINT32 DHL_OS_MSGQ_ID;
#endif


#define NO_WAIT 0
#define WAIT_FOREVER (UINT32)-1


/** @brief
	DHL_OS_CreateTask() API에 지정하는 task main 함수의 prototype.

*/
typedef void (*DHL_OS_TASKFUNCTION)(void* arg);


/** @brief
	DHL_OS_GetTaskInfo() API에서 사용되는 task 정보 구조체.

*/
typedef struct
{
	DHL_OS_TASK_ID tid; ///< [out] 이 구조체 정보가 설명하고 있는 태스크
	const char *name;   ///< [out] 태스크의 이름. pointer임에 유의.
	int priority;       ///< [out] 태스크 priority.
	
	/*
		if there are more common attributes, add here..
	*/

} DHL_OS_TASK_INFO;


/** @brief
	DHL_OS_GetHeapStatus() API에서 사용되는 Heap 상태 정보 구조체.
*/
typedef struct
{
	UINT32 size_heap; // size of entire heap

	UINT32 num_alloc_chunk; // number of alloc chunk
	UINT32 size_alloc;       // total byte size alloc chunk

	UINT32 num_free_chunk;  // number of free chunk
	UINT32 size_free;        // total byte size free chunk
} DHL_OS_HEAP_STATUS;



#if COMMENT
____Defines____(){}
#endif

/** @brief 무한대를 의미하는 특별한 timeout

	각종 suspend (blocking) API 들의 timeout 인자에 이 값을 사용하면 
	wait forever의 의미로 사용된다.
*/
#define DHL_TIMEOUT_FOREVER ((UINT32)-1)


/** @name
	특별한 OS object ID
	@{
*/

#define DHL_INVALID_TASK_ID (DHL_OS_TASK_ID)0
#define DHL_INVALID_SEMA_ID (DHL_OS_SEMA_ID)0
#define DHL_INVALID_MSGQ_ID (DHL_OS_MSGQ_ID)0

/*@}*/




#if COMMENT
____Task_API____(){}
#endif

/**
	@name OS Task API 
	@{
*/

/**
	@brief 태스크를 생성한다.
	
	생성된 태스크는 우선 순위 조건에 따라 이 API 함수가 리턴하기도 전에 먼저
	실행 될 수도 있다.
	
	인자로 지정한 태스크 함수의 실행이 끝나면 태스크는 자동으로 종료되어야 한다.
	(DHL_OS_SelfDeleteTask 를 호출한 것과 동일한 효과를 내야 한다)
	
	@param[in] func        생성될 태스크 함수 본체.
	@param[in] name        태스크 이름.     
	@param[in] priority    태스크 우선 순위.
	@param[in] stackSize   BYTE 단위의 태스크 스택 크기.
	@param[in] arg1        태스크 함수 본체에 넘겨질 인자.
	
	@return
		DHL_OS_TASK_ID 타입의 태스크 ID 를 리턴한다.
		생성에 실패할 경우 DHL_INVALID_TASK_ID 를 리턴한다.

	@todo: name 이름 길이 제한 지정 필요?
*/
DHL_OS_TASK_ID DHL_OS_CreateTask(DHL_OS_TASKFUNCTION func, const char *name, 
                                 int priority, int stackSize, UINT32 arg1);

/**
	@brief 현재 실행중인 태스크를 삭제한다.
*/
void DHL_OS_SelfDeleteTask(void);

/**
	@brief 주어진 태스크의 우선 순위를 변경한다.

	@param[in] tid		우선순위를 변경 할 태스크의 ID.
	@param[in] newPrio	새로 적용할 우선순위.
	@param[out] pOldPrio	변경되기 전 우선순위를 저장할 주소.
*/
void DHL_OS_SetTaskPriority(DHL_OS_TASK_ID tid, UINT32 newPrio, UINT32 *pOldPrio);

/**
	@brief 태스크의 이름으로 태스크 ID를 얻는다.

	@param[in] name		찾고자 하는 태스크의 이름
	@param[out] returnTid	찾아진 태스크 ID를 저장할 주소.

	@return
		- DHL_OK: 성공.
		- DHL_FAIL_NOT_FOUND: 해당 태스크가 존재하지 않음.
		- DHL_FAIL_INVALID_PARAM: name 또는 returnTid 포인터가 잘못됨.		
*/
DHL_RESULT DHL_OS_FindTaskByName(const char *name, DHL_OS_TASK_ID *returnTid);

/*
	@brief 현재 실행중인 태스크의 ID를 리턴한다.
		ISR 루틴이 실행 중인 상태라면 에러를 리턴해야 한다.

	@return		현재 태스크의 식별자.
		- DHL_INVALID_TASK_ID: 현재 태스크를 얻어 올 수 없는 상황인 경우
*/
DHL_OS_TASK_ID DHL_OS_GetTaskID(void);

/**
	@brief 태스크의 상세 정보를 조회한다.
	caller는 pTaskInfo에 적절한 변수의 포인터를 넘겨줘야 한다.

	@param[in]  tid         정보 조회를 할 태스크의 ID.
	@param[out] pTaskInfo 태스크 정보가 채워질 구조체 포인터.
	
	@return               DHL_RESULT 타입 결과 리턴.
	 - DHL_OK: 성공.
	 - DHL_FAIL_INVALID_HANDLE: 잘못된 태스크 ID 입력.
	 - DHL_FAIL_NULL_POINTER: pTaskInfo 포인터가 NULL인 경우.
	 - DHL_FAIL_NOT_FOUNT: 태스크 정보를 얻을 수 없는 경우
*/
DHL_RESULT DHL_OS_GetTaskInfo(DHL_OS_TASK_ID tid, DHL_OS_TASK_INFO *pTaskInfo);

/**
	@brief 현재 동작중인 모든 태스크의 정보를 디버그 콘솔 화면에 출력한다.
	
	OS_DbgPrintf 를 사용하여 출력된다.
	Shell 에서 i 명령을 입력할 경우 실행되는 함수이다.

	@param[in] level  얼마나 상세히 출력할 것인지 지정하는 레벨. 
		0을 지정하면 디폴트 정보를 출력한다.

*/
//void DHL_OS_ShowOSInfo(int level);

char *DHL_OS_TaskName(DHL_OS_TASK_ID tid);
int DHL_OS_TaskPriority();


/*@}*/

/****************************************************/
#if COMMENT
____Sem_API____(){}
#endif

/** @name Semaphore API
	@{
*/

/**
	@brief Counting 세마포어를 생성한다.

	@param[in] name 생성될 세마포어의 이름.
	@param[in] options suspend type. OS_SEM_PRIO 또는 OS_SEM_FIFO.
	@param[in] count 생성될 세마포어의 최대 count .
	
	@return               
		생성된 세마포어의 식별자.
		생성에 실패할 경우 DHL_INVALID_SEMA_ID 를 리턴한다.
*/
DHL_OS_SEMA_ID DHL_OS_CreateCountingSemaphore(const char *name, UINT32 options, UINT32 count);

/**
	@brief Binary 세마포어를 생성한다.

	@param[in] name 생성될 binary 세마포어의 이름.
	@param[in] options suspend type. OS_SEM_PRIO 또는 OS_SEM_FIFO.
	@param[in] flag 초기 count 값. TRUE이면 1, 아니면 0이다.
	
	@return               
		생성된 세마포어의 식별자.
		생성에 실패할 경우 DHL_INVALID_SEMA_ID 를 리턴한다.
*/
DHL_OS_SEMA_ID DHL_OS_CreateBinarySemaphore(const char *name, UINT32 options, BOOL flag);

/**
	@brief Mutex 세마포어를 생성한다.

	@param[in] name 생성될 mutex 세마포어의 이름.
	
	@return               
		생성된 세마포어의 식별자.
		생성에 실패할 경우 DHL_INVALID_SEMA_ID 를 리턴한다.
*/
DHL_OS_SEMA_ID DHL_OS_CreateMutexSemaphore(const char *name);				

/**
	@brief 세마포어를 삭제한다.

	semaphore delete를 지원하지 않는 RTOS의 경우 (ex: uCOS), 
	HAL 내부에서 emulation을 해야 함. (free list 관리..)

	@param[in] sem 삭제할 세마포어의 식별자.
*/
void DHL_OS_DeleteSemaphore(DHL_OS_SEMA_ID sem);


/**
	@brief  세마포어를 획득한다. 

	세마포어를 획득할 때까지 이 함수는 중단된다. millsec이 
	지나도록 	획득하지 못하면 DHL_FAIL_TIMEOUT을 리턴한다. 

	@param[in] sem 획득하려고 하는 세마포어의 식별자.
	@param[in] millisec timeout까지 대기 시간.
		DHL_TIMEOUT_FOREVER 를 지정하면 timeout 없이 무한 대기한다.
	
	@return     	DHL_RESULT 타입 결과 리턴한다.          
		- DHL_OK: 성공.
		- DHL_FAIL_TIMEOUT: millisec 시간 내에 세마포어를 획득하는데 실패.
		- DHL_FAIL_INVALID_HANDLE: 잘 못된 세마포어 ID 입력.
*/
DHL_RESULT DHL_OS_TakeSemaphore(DHL_OS_SEMA_ID sem, UINT32 millisec);

/**
	@brief 세마포어를 반납한다. 입력 세마포어를 대기하는 태스크가 있으면 다시 스케쥴링 된다.

	@param[in] sem 반납하려고 하는 세마포어의 식별자.
	
	@return     	DHL_RESULT 타입 결과 리턴한다.          
		- DHL_OK: 성공.
		- DHL_FAIL_INVALID_HANDLE: 잘 못된 세마포어 ID 입력.
*/
DHL_RESULT DHL_OS_GiveSemaphore(DHL_OS_SEMA_ID sem);

/*@}*/

/****************************************************/
#if COMMENT
____MsgQ_API____(){}
#endif

/** @name Message Queue API
	@{
*/

/**
	@brief 메시지 큐를 생성한다.

	@param[in] name 생성할 메시지 큐의 이름.
	@param[in] options Suspend 정책. 0이면 FIFO, 1이면 Priority 방식.
	@param[in] maxMessages 최대 메시지 갯수.
	@param[in] maxMessageLength 메시지 하나의 최대 길이.
	
	@return
		DHL_OS_MSGQ_ID 타입의 태스크 ID 를 리턴한다.
		생성에 실패할 경우 DHL_INVALID_MSGQ_ID 를 리턴한다.
*/
DHL_OS_MSGQ_ID DHL_OS_CreateMessageQueue(const char *name, UINT32 options, 
            UINT32 maxMessages, UINT32 maxMessageLength);
/**
	@brief 메시지 큐를 삭제한다.

	@param[in] qid 삭제할 메시지 큐의 ID.
*/
void DHL_OS_DeleteMessageQueue(DHL_OS_MSGQ_ID qid);

/**
	@brief 주어진 메시지 큐에 메시지를 전달한다.
		메시지 큐가 꽉찬 경우에는 suspend되지 않고 바로 리턴한다.

	@param[in] qid 메시지가 전달되어질 메시지 큐의 ID.
	@param[in] buffer 메시지의 시작 주소.

	@return 
		- DHL_OK: 성공적으로 전달.
		- DHL_FAIL_INVALID_HANDLE: 잘못된 메시지 큐 ID 입력.
		- DHL_FAIL_INVALID_PARAM: 파라미터 오류. buffer가 NULL인 경우임.
		- DHL_FAIL_BUSY: 메시지 큐가 꽉참.
		- DHL_FAIL: 알 수 없는 에러
*/
DHL_RESULT DHL_OS_SendMessage(DHL_OS_MSGQ_ID qid, void *buffer, int bytes);

/**
	@brief 주어진 메시지 큐로부터 메시지를 전달받는다.

	@param[in] qid 메시지를 가져올 메시지 큐의 ID.
	@param[out] msgBuf 메시지를 저장할 공간의 주소.
	@param[in] millisec timeout까지 대기 시간. 
		DHL_TIMEOUT_FOREVER 를 지정하면 무제한 기다린다.

	@return 
		- DHL_OK: 성공적으로 획득.
		- DHL_FAIL_TIMEOUT: millisec 시간 내에 메시지를 획득하는데 실패.
		- DHL_FAIL_INVALID_HANDLE: 잘못된 메시지 큐 ID 입력.
		- DHL_FAIL_INVALID_PARAM: 잘못된 msgBuf 주소 입력.
*/
DHL_RESULT DHL_OS_ReceiveMessage(DHL_OS_MSGQ_ID qid, void *msgBuf, UINT32 millisec); 

/*@}*/

/****************************************************/
#if COMMENT
____Heap_API____(){}
#endif


/*
	이 DHL_OS_USE_HEAP_DEBUG flag의 실제 정의는 이 API 헤더에서 하지 말고,
	DHL_OSAL_Config.h 에 추가하기 바람.
	각 플랫폼 별로, 또는 개발자 상황에 맞게 수정하여 사용.
*/

#if DHL_OS_USE_HEAP_DEBUG

void *DHL_OS_DbgMalloc(int size, const char *_file, unsigned _line);
void DHL_OS_DbgFree(void **pptr, const char *_file, unsigned _line);

#define DHL_OS_Malloc(size) DHL_OS_DbgMalloc(size, __FILE__, __LINE__)
#define DHL_OS_Free(p) DHL_OS_DbgFree(p, __FILE__, __LINE__)

#else

/**
	@name OS Heap API
	@{
*/

/**
	@brief 	메모리 영역을 할당한다.

	할당 받은 메모리는 memset 0 로 clear 되어 있어야 한다.

	@param[in] size 할당 받을 메모리 공간의 사이즈.
	
	@return     	할당 받은 메모리의 시작 주소.          
*/
void *DHL_OS_Malloc(int size);
//#define DHL_OS_Malloc(size) _DHL_OS_Malloc(size, __func__, __LINE__)

/**
	@brief 	할당 받은 메모리를 해지한다. 
			메모리의 시작 주소를 가리키던 포인터는 0으로 바꿔준다.

	pptr이 null 이거나, *pptr이 null 일 경우 아무런 동작하지 않고 그냥 리턴한다.
	이 경우 시스템이 오동작 하지 않아야 한다.
	
	@param[in] pptr 해지 할 메모리 영역의 시작 주소를 갖고 있는 포인터 변수의 주소.
			이중 포인터로 되어 있음에 유의한다.
*/
void DHL_OS_Free(void **pptr);
//#define DHL_OS_Free(p) _DHL_OS_Free(p, __func__, __LINE__)

#endif


/** @brief heap 상태 정보 조회.

	@param[in] pHeapStatus heap 상태 정보가 채워질 변수 주소.
*/
void DHL_OS_GetHeapStatus(DHL_OS_HEAP_STATUS *pHeapStatus);

/*@}*/

/****************************************************/
#if COMMENT
____Tick_API____(){}
#endif

/**
	@name OS Tick & Delay API
	@{
*/

/**
	@brief 호출한 태스크를 입력 시간 동안 대기상태로 만든다.
	@param[in]  millisec         
		대기상태를 유지할 시간(시스템 tick 단위).
*/
void DHL_OS_Delay(UINT32 millisec);

/** 
	@brief 부팅이후 경과 시간을 ms 단위로 리턴한다.
	@return	부팅이후 경과시간. ms 단위.
*/
UINT32 DHL_OS_GetMsCount(void);
UINT32 DHL_OS_GetTickCount(void);

UINT32 DHL_OS_GetTicksPerSecond(void);
#define OS_GetTicksPerSecond DHL_OS_GetTicksPerSecond



/*@}*/

/****************************************************/
#if COMMENT
____IRQ_API____(){}
#endif

/**
	@name OS Interrupt API
	@{
*/

/**
	@brief 인터럽트의 상태를 확인한다.
		현재 상태가 ISR 상태인지와는 다르다.
		현재 상태가 ISR 상태인지를 알려면 DHL_OS_GetTaskID()를 사용한다.
	@return 인터럽트 잠김 상태 리턴.
	 - TRUE: 인터럽트가 잠긴 상태
	 - FALSE: 인터럽트가 풀린 상태
*/
BOOL DHL_OS_GetIntState(void);

/**
	@brief 인터럽트를 잠근다.

	그 동안 중복 사용되는 경우가 없었으므로 단순한 처리를 위해 중복 호출은 허용하지 않도록 한다.
	중복 호출시 잘못된 사용을 간주하여 ASSERT 발생.
	
	@return               
		인터럽트를 잠그기 전의 mask상태.		
*/
UINT32 DHL_OS_DisableInterrupts(void);

/**
	@brief 잠겨있는 인터럽트를 푼다.

	인터럽트 락이 아닌 상황에서 호출시에는 아무런 동작도 하지 않고 즉시 리턴한다.
	
	@param[in]  mask         
		인터럽트를 잠그기 전의 mask 상태.
*/
void DHL_OS_RestoreInterrupts(UINT32 mask);

/*@}*/

/****************************************************/
#if COMMENT
____DebugIO_API____(){}
#endif

/**
	@name OS Debug Console I/O
	@{
*/

/**
	@brief 
	콘솔에 메시지를 출력한다.

	LineFeed (LF, 0xA, '\\n') 만으로도 개행이 되어야 한다.
	CR LF 조합으로 쓸 경우에도 문제가 없어야 한다.

	@param[in] fmt
		출력 할 데이터. %로 formatize 된 형태.
	@return 
		출력된 글자 수를 리턴한다. (맨 마지막 NULL 문자는 제외)
*/
	//int DHL_OS_Printf(const char *fmt, ...);
	//int _DHL_OS_Printf(const char *fmt, ...);
#define DHL_OS_Printf BKNI_Printf
#define _DHL_OS_Printf BKNI_Printf





/** @brief DHL_OS_GetChar()의 확장키 열거 타입.

	타입 이름 자체는 중요하지 않으므로 naming rule을 지키지 않았음.

	실제로 DHL_OS_GetChar() 함수의 리턴값은 int 로 되어 있다.
	모든 키 값을 enum으로 다 표현할 수는 없기 때문.

	이름 또한 EXTKEY로 되어 있으나 반드시 확장키만 있는 것은 아님.
	TAB, CR 등은 확장 키는 아니지만 '\\t', '\\r' 대신에 사용할 수 있다.

	진짜 확장 키인지를 체크하려면 0x7F로 시작하는지로 체크하면 됨. 	
*/
enum DHL_EXTKEY_t
{
	DHL_EXTKEY_NONE = 0x00,
	
	DHL_EXTKEY_TAB = 0x09,  // TAB
	DHL_EXTKEY_CR  = 0x0d,  // CR
	DHL_EXTKEY_ESC = 0x1b,  // ESC
	
	DHL_EXTKEY_F1  = 0x7F31317e, // F1
	DHL_EXTKEY_F2  = 0x7F31327e, // F2
	DHL_EXTKEY_F3  = 0x7F31337e, // F3
	DHL_EXTKEY_F4  = 0x7F31347e, // F4
	DHL_EXTKEY_F5  = 0x7F31357e, // F5
	DHL_EXTKEY_F6  = 0x7F31377e, // F6
	DHL_EXTKEY_F7  = 0x7F31387e, // F7
	DHL_EXTKEY_F8  = 0x7F31397e, // F8
	DHL_EXTKEY_F9  = 0x7F32307e, // F9
	DHL_EXTKEY_F10 = 0x7F32317e, // F10
	DHL_EXTKEY_F11 = 0x7F32337e, // F11
	DHL_EXTKEY_F12 = 0x7F32347e, // F12
	
	DHL_EXTKEY_DEL = 0x7F00337e, // DEL

	DHL_EXTKEY_UP  = 0x7F000041, // Up
	DHL_EXTKEY_DN  = 0x7F000042, // Down
	DHL_EXTKEY_RG  = 0x7F000043, // Right
	DHL_EXTKEY_LF  = 0x7F000044, // Left

	DHL_EXTKEY_PGUP = 0x7F00357e, // Page Up
	DHL_EXTKEY_PGDN = 0x7F00367e, // Page Down

	DHL_EXTKEY_HOME = 0x7F000048, // Home
	DHL_EXTKEY_END  = 0x7F000046, // End

};


#define DHL_OS_CheckExtKey(key) (((key)&0xff000000)==0x7f000000)

/**
	@brief 
	Consol 에서 키 입력을 하나 받아서 리턴한다.

	만약 키 입력이 없는 경우라면 키 입력을 받을 때 까지 suspend 된다.
	확장 키도 입력을 받는다.
	
	@return 
		입력된 키 값을 리턴한다. 
		일반 문자, 숫자, 기호 등이라면 ASCII 코드 값을 리턴한다.
		확장 키가 입력 될 경우 8-bit 보다 큰 값이 리턴 된다.
*/
int DHL_OS_GetChar(void);

/*@}*/

/****************************************************/
#if COMMENT
____Init____(){}
#endif

/**
	@name OS Init 
	@{
*/

/**
	@brief OSAL을 초기화 한다.

	모든 OSAL 함수는 이 초기화 이후에 사용되어야 한다.
*/
void DHL_OS_Init(void);

/*@}*/

/****************************************************/


#ifdef __cplusplus
} /* extern "C" */
#endif


#endif	/* __DHL_OSAL_H__ */