/**
	@file
		DHL_Timer.c

	@brief
		Timer implementation.

	Copyright 2006~2010 Digital STREAM Technology, Inc.
	All Rights Reserved
*/

#include "DHL_OSAL.h"
#include "DHL_DBG.h"
#include "DHL_Timer.h"

#include "DHL_DBG_Priv.h"
#include "DHL_OSAL_Config.h"

//#include <stdio.h>
////#include <string.h>


DHL_MODULE("*TMR", 0);


#if COMMENT
____Debug____(){}
#endif
//------------------------------------------------------------------
// Timer Debug Print

//int g_Trace_bDHLTimer = 0;
	// tmprint의 디버그 메시지를 감출경우 0

void *g_Trace_TimerHandle;
	// trace 하고자 하는 timer handle.



#if COMMENT
____Config____(){}
#endif


#define DHL_TIMER_TASK_PRIO  TASK_PRI_DRV_TIMER
#define DHL_TIMER_TASK_STACK 8192




#if COMMENT
____Types____(){}
#endif


/*
	아래 정의된 값들은 flags 로 사용된다.
*/
#define TIMER_FLAG_NeedAck      0x40  
	// 과거의 bNeedAck 과 동일한 역할.

#define TIMER_FLAG_OldStyleProc 0x80  
	// timer proc이 DHL_TIMER_PROC_EX가 아니라 DHL_TIMER_PROC 이다.




// DHL_Timer.h에서 8자로 명시
#define MAX_TIMER_NAME 8

#define DHL_TIMER_MAGICKEY 0x09110911


/* UINT32 파라미터를 몇 개 까지 지원하는지..
	기존 version 1 에서는 단 하나만 지원했었음.
*/
#define MAX_NUMBER_OF_TIMER_PARAM 16 

/* 타이머 태스크 msg que의 디폴트 크기. 기존 version 1 에서의 값과 동일하다.
*/
#define DEFAULT_MSG_QUE_SIZE 20


typedef struct  
{
	UINT16 nId;        // unique id that distinguish to other timer entries.
	
	BOOLEAN used;      // TRUE if this timer entry is used (and active)
	
	UINT32 period;     // timer period (if periodic timer), or timer delay (if oneshot timer)
	                   // unit is in TICKs
	                   
	UINT32 start;      // timer start tick.
	                   // if this is periodic timer, it is reset to NOW at every timer expire.

	UINT16 flags;      // flags

	DHL_TIMER_PROC_EX fn;  // timer callback function
	UINT32  params[MAX_NUMBER_OF_TIMER_PARAM];   // user parameters
	
} DHL_TIMER_ENTRY;

typedef struct DHL_TIMER_t
{
	UINT32 magic;
	
	char name[MAX_TIMER_NAME+1];
	
	DHL_TIMER_INIT_PARAM param;
		// user settings parameter for timer init
	
	int   nActiveTimer;
		// 등록된 Active 타이머 갯수.
		// 이 변수는 모든 태스크에서 수정되므로 (SetTimer에서는 application task, 
		// Oneshot 해제될 경우나 KillTimer에는 timer task 등..) 따라서 lock 상태에서 수정하기 바람.
		
	int   maxActiveIndex;
		// 타이머 record에서 배열 인덱스 값의 최대값.
		// 중간에 있는 timer를 KillTimer로 없애면 배열 가운데가 빈 상태가 되는데,
		// 이 경우 nActiveTimer와 무관한 값이 될 수 있다.
		// timer routine의 core에서 이 값을 알고 있으면 loop 오버헤드를 약간 줄일 수 있다.
		// todo..
		// 이 값이 커지는 코드는 있는데, 줄어드는 코드는 없음. 구현 필요..
	
	DHL_OS_TASK_ID nTaskId;
		// timer service task id.
	
	UINT32 curServicedTimerId;
		// cafrii 060919 add
		// 현재 timer task에서 서비스 중인 timer id.
		// timer task가 idle 상태일 경우에는 0이 된다.
		
	DHL_OS_MSGQ_ID msgQue; // message queue of timer command 

	DHL_OS_SEMA_ID semAck;   // binary semaphore for returning ACK.
	DHL_OS_SEMA_ID mutexAck; // mutex for guard semAck

	struct DHL_TIMER_t *next;
		// for management.. next timer record info..

	int nMaxSlot;
		// maximum number of timer slot info.

	int nUserParam;
		// number of user parameter. copied from param->num_user_param.
		// MAX_NUMBER_OF_TIMER_PARAM 보다 클 수 없다.

	int nMaxQueSize;
		// copied from param->msg_que_size.
		
	DHL_TIMER_ENTRY *info; 
		// 타이머 정보 변수.

} DHL_TIMER;

/*
	timer command id.

	version 2 에서는 timer id 와 command id 를 통합하여 사용한다.
	그리고 숫자의 범위도 32-bit 에서 16-bit로 축소하였다.
*/
enum TIMER_CMD_ID_t
{
	eTMR_CMD_BEGIN = 0xfff0,  // this is just marker.

	//eTMR_CMD_ADD,  
		// 이 TIMER_CMD_ID_t 명령들 이외의 값은 모두 'ADD'로 동작한다.
		// 따라서 별도의 ADD 명령을 보낼 필요가 없다.

	eTMR_CMD_DELETE,
		// Timer entry 하나를 삭제한다.
		// 삭제할 timer ID는 userParams[0]을 통해 전달한다.

	eTMR_CMD_DELETE_ALL,
		// 모든 timer entry 삭제.
	
	eTMR_CMD_SHOW,

	eTMR_CMD_QUERY,

	eTMR_CMD_SYNC,
		// timer를 일반 dpc task로 사용하는데, 
		// 특정 메시지를 wait 모드로 동작해야한 하는 경우
		// 이 timer command를 사용하면 timer handler와 동기화가 되어
		// wait 모드의 효과가 난다.
		// app 에서 직접 semaphore, mutex 등을 관리하는 것이 번거로울 경우 
		// 간단하게 이 명령을 활용하면 된다.

	eTMR_CMD_SHUTDOWN,
};

typedef struct
{
	UINT16 idTimerOrCmd;
		// Timer ID in 'Add' mode,
		// or Command ID in other mode (delete, show, query, ...)
		// Timer ID should be unique in DHL_TIMER group.
	
	UINT16 flags;

	//UINT32 *pResult; // return value is passed to caller
		// synchronous (ack) mode는 stop (kill timer) 에서만 사용하므로,
		// 이 값은 nPeriodMs 변수 공간을 활용하도록 한다.

	UINT32 nPeriodMs;
		// timer expire 주기.
		// eTMR_CMD_DELETE 인 경우 pResult 역할을 한다.
	
	DHL_TIMER_PROC_EX func;
	UINT32 userParams[MAX_NUMBER_OF_TIMER_PARAM];  // user parameter, passed to timer proc
		// 이 userParams은 가변 길이 배열이다.
		// timer group 초기화 과정에서 특정 size로 고정된다.
		// 이 필드가 맨 마지막에 위치해야 한다.

} DHL_TIMER_COMMAND;


/**
	DHL_TIMER_COMMAND 의 크기는 가변이다. 정확한 size는 nUserParam 값에 따라 달라진다.

	SendMessage 할 때 그냥 최대 지원 갯수인 MAX_NUMBER_OF_TIMER_PARAM 를 사용하지 않는 이유는
	불필요한 memcopy overhead를 줄이기 위함이다.
*/
#define TIMER_COMMAND_SIZE(num_param) (\
	sizeof(DHL_TIMER_COMMAND) \
	- sizeof(UINT32)*MAX_NUMBER_OF_TIMER_PARAM \
	+ sizeof(UINT32)*(num_param) \
	)	


#ifndef min
	#define min(a,b) ((a)<(b)?(a):(b))
#endif


#if COMMENT
____Variables____(){}
#endif

DHL_TIMER *g_dhl_timer_list;


#if COMMENT
______Func____(){}
#endif

// forward declarations
void dhl_timer_module_init(void);



static DHL_RESULT p_timer_check_valid(DHL_TIMER *timer)
{
	if (timer == NULL || timer->magic != DHL_TIMER_MAGICKEY) {
		printf( "!! invalid timer\n");
		return DHL_FAIL_INVALID_PARAM;
	}
	if (timer->nTaskId == 0) {
		printf( "!! Timer not initialized!\n");
		return DHL_FAIL_NOT_INITIALIZED;
	}
		
	return DHL_OK;
}


#if COMMENT
______Method____(){}
#endif

/*
	add one timer entry
	this function should be called in timer task.
*/
static DHL_RESULT p_timer_add_entry(DHL_TIMER *timer, DHL_TIMER_COMMAND *cmd)
{
	int i;
	int idSelected, idEmpty;

	//ASSERT(cmd->idCmd == eTMR_CMD_ADD);
	
	idSelected = -1;
	idEmpty = -1;
	
	// id를 검색하면서, 동시에 empty slot도 찾는다.
	// 해당 ID가 이미 사용중이라면 갱신모드..
	for (i=0; i<timer->nMaxSlot; i++)
	{
		if (timer->info[i].used && timer->info[i].nId == cmd->idTimerOrCmd) {
			// 이미 사용중이다..
			// 새로운 parameter로 update하고 함수 종료..
			if (g_Trace_TimerHandle == timer)
			printf( "!! Timer [%d] already active. updated..\n", cmd->idTimerOrCmd);
			idSelected = i;
			break;
		}
		else if (timer->info[i].used == 0) {
			// 비어있는 slot을 찾는다..
			if (idEmpty < 0) idEmpty = i;
		}
	}
	
	if (idSelected < 0)
		idSelected = idEmpty;
	
	if (idSelected >= 0) 
	{
		DHL_TIMER_ENTRY *info = &timer->info[idSelected];
		if (info->used == FALSE) {
			timer->nActiveTimer++;
		}
		
		info->nId = cmd->idTimerOrCmd;
		info->period = cmd->nPeriodMs;
		info->fn = cmd->func;
		for (i=0; i<timer->nUserParam; i++)
			info->params[i] = cmd->userParams[i];
		info->flags = cmd->flags;
		
		info->start = DHL_OS_GetMsCount();
		info->used = TRUE;
		
		// maxActiveIndex를 알아두면 TimerTask에서 loop를 돌때 도움이 된다.
		if (timer->maxActiveIndex < idSelected)
			timer->maxActiveIndex = idSelected;
			
		if (g_Trace_TimerHandle == timer)
		printf( "\t index %d, ID: %d, total %d active\n", idSelected, cmd->idTimerOrCmd, timer->nActiveTimer);
	}
	else {
		if (g_Trace_TimerHandle == timer)
		printf( "!! No more timer slot for ID: %d\n", cmd->idTimerOrCmd);
		// it may be available some time later because oneshot timer will die..
	}
	
	return idSelected >= 0 ? DHL_OK : DHL_FAIL_NOT_AVAILABLE;
}

/*
	delete one timer entry.
	this function should be called in timer task.
*/
static DHL_RESULT p_timer_delete_entry(DHL_TIMER *timer, UINT32 nIdTimer)
{
	int i;
	DHL_RESULT dhr = DHL_FAIL_NOT_FOUND;
	
	//ASSERT(cmd->idTimerOrCmd == eTMR_CMD_DELETE);

	if (nIdTimer == (UINT32)-1) { // delete all..
		if (g_Trace_TimerHandle == timer)
			printf( "delete all timer entry\n");

		memset(&timer->info, 0, timer->nMaxSlot*sizeof(DHL_TIMER_ENTRY));
		timer->nActiveTimer = 0;
		timer->maxActiveIndex = -1;
		dhr = DHL_OK;
	}
	
	for (i=0;i<=timer->maxActiveIndex;i++)
	{
		if ((timer->info[i].used) && (timer->info[i].nId == nIdTimer))
		{
			memset(&timer->info[i], 0, sizeof(DHL_TIMER_ENTRY));
			timer->nActiveTimer--;

			if (g_Trace_TimerHandle == timer)
			printf( "StopTimer: index: %d, ID: %d\n", i, nIdTimer);

			dhr = DHL_OK;
			
			// 뭔가 잘못되어서 같은 ID로 여러개가 등록되어 있을 수도 있기때문에
			// 여기서 loop를 나가지 않고 모든 timer record 를 다 검색해본다.
		}
	}
	return dhr;
}

/*
	show timer info
*/
static void p_timer_show(DHL_TIMER *timer, DHL_TIMER_COMMAND *cmd)
{
	DHL_RESULT dhlResult;
	int i, k;
	char buf[80];
	
	dhlResult = p_timer_check_valid(timer);
	if (dhlResult)
		return;

	DHL_OS_Printf("----- Timer Info 0x%x -----\n", timer);
	
	DHL_OS_Printf(" '%s', priority %d, max %d\n", 
			timer->name, timer->param.task_priority, timer->nMaxSlot);
	
	for (i=0; i<=timer->maxActiveIndex; i++) {
		char *fname = NULL;
		if (!timer->info[i].used) continue;
		// dhl_dbg_find_sym_by_addr((UINT32)timer->info[i].fn, &fname);
		for (buf[0]=0, k=0; k<min(4, timer->nUserParam); k++)
			sprintf(buf+strlen(buf), "%lx ", timer->info[i].params[k]); 
		DHL_OS_Printf(" (%02d) ID %d, fn %x(%s) arg (%s), %d ms, f%x %s\n", i, 
			timer->info[i].nId,
			timer->info[i].fn, fname ? fname : "?",
			buf, //timer->info[i].param,
			timer->info[i].period,
			//timer->info[i].period,
			timer->info[i].flags,
			timer->info[i].flags & eTIMER_FLAG_OneShot ? "oneshot" :
			timer->info[i].flags & eTIMER_FLAG_NowAndContinue ? "n&c" : "interval");
	}
	DHL_OS_Printf("\n");
}



void p_timer_call(DHL_TIMER *timer, UINT16 nTimerId, UINT16 flags, 
			DHL_TIMER_PROC_EX pFn, UINT32 *userParams)
{
	// timer callback이 불리는 동안에는 어떤 timer id가 service 중인지 기록을 남겨두자.
	timer->curServicedTimerId = nTimerId;
	
	if (g_Trace_TimerHandle == timer)
	printf( "\n---------- TimerExBegin: %x, ID %d, fn %x, param 0x%x \n", 
			timer, nTimerId, pFn, userParams[0]);
			
	if (flags & TIMER_FLAG_OldStyleProc)
		((DHL_TIMER_PROC)pFn)(nTimerId, userParams[0]);
	else
		pFn(nTimerId, userParams);

	if (g_Trace_TimerHandle == timer)
	printf(   "---------- TimerExEnd: %x, ID %d \n\n", timer, nTimerId);

	timer->curServicedTimerId = 0;
	// timer id 0은 여기서 처럼 특별한 의미로 사용하므로, 일반 ID로는 reserve 해야 한다.

}


void p_timer_shutdown(DHL_TIMER *timer)
{
	dprint(2, "timer stop requested..\n");

	// TimerTerminate -> TimerTask shutdown 절차 중에는 race condition을 고려하지 않는다.
	// 따라서 client는 shutdown sequence 중에는 timer start 등이 호출되지 않도록 주의해야 한다.
	
	DHL_OS_DeleteSemaphore(timer->semAck);
	timer->semAck = 0;

	DHL_OS_DeleteSemaphore(timer->mutexAck);
	timer->mutexAck = 0;

	DHL_OS_DeleteMessageQueue(timer->msgQue);
	timer->msgQue = 0;
	
	dprint(2, "timer task about to shutdown..\n");
	timer->nTaskId = 0;
	DHL_OS_SelfDeleteTask();
}


#if COMMENT
____Task____() {}
#endif

/*************************************************************************************

	timer task

	- Timer Main Task.
	- 등록된 Timer를 관리한다. 

*************************************************************************************/

void dhl_timer_task(void* arg)
{	
	int i;
	DHL_RESULT result;
	DHL_TIMER_COMMAND cmd;
	int nMinRemainingTick;
	UINT32 uNow;
	DHL_TIMER *timer = (DHL_TIMER *)arg;
//	printf( "Timer Task Launched, timer %x, %u tick/s\n", timer, _second);
//	printf( "name '%s' max slot %d\n", timer->name, timer->nMaxSlot);
	
	while (TRUE)
	{
		DHL_OS_Delay(10);
		nMinRemainingTick = 0x7fffffff;  // signed INT32 value의 최대값..

		//--------- timer expiration timeout 체크 ------------
		// 현재 가장 가까운 시간 내에 expire 될 timer를 찾는다..
		
		uNow = DHL_OS_GetMsCount();
		for (i=0; i<=timer->maxActiveIndex; i++)
		{
			int nRemainTick;
			if (timer->info[i].used == 0) continue;
			nRemainTick = (int) (timer->info[i].start + timer->info[i].period - uNow);
			// 이미 expire 된 timer라면 remain은 negative 값을 가질 것임..
			
			if (nMinRemainingTick > nRemainTick) {
				nMinRemainingTick = nRemainTick; // it can be negative!!
			}
		}

		//--------- wait message with/without timeout ------------

		// 설령, 이미 expire 된 timer entry가 있다고 하더라도
		// timer 실행 부하가 많아서 command를 아예 못받는 상황이 되지 않도록,
		// msgque 는 반드시 한번은 체크를 수행하고 나서 timer를 처리해 준다.

		if (nMinRemainingTick < 0) nMinRemainingTick = 0;

		// 아직 남은 시간이 많기 때문에 Sleep을 한다.
		if (nMinRemainingTick < 0x7fffffff) {
			if (g_Trace_TimerHandle == timer)
				dprint(2, "Timer task enter sleep for %d ticks ....\n", nMinRemainingTick);
			
			result = DHL_OS_ReceiveMessage(timer->msgQue, &cmd, nMinRemainingTick);
		}
		else {
			// 처리해야 할 남은 timer가 없다면 active 될때까지 무한정 기다리기만 하면 된다.
			//
			if (g_Trace_TimerHandle == timer)
				dprint(2, "Timer task enter sleep until timer set...z.z.z\n");
			//OS_TakeSemaphore(timer->semWakeUp);
			result = DHL_OS_ReceiveMessage(timer->msgQue, &cmd, DHL_TIMEOUT_FOREVER);
		}

		//--------- process message if we got new one ------------

		if (result == DHL_OK) // we got command
		{
			// 효율적인 dpc 명령 수행을 위한 특별한 처리.
			if (cmd.idTimerOrCmd < eTMR_CMD_BEGIN &&
				cmd.nPeriodMs == 0 && 
				(cmd.flags & eTIMER_FLAG_OneShot))
			{
				// 바로 한번 실행 후 cancel 되는 것이므로, 
				// 굳이 timer entry에 등록할 필요가 없다.

				p_timer_call(timer, cmd.idTimerOrCmd, cmd.flags, cmd.func, cmd.userParams);
				continue;
			}
			
			// add / delete / query / shutdown
			
			if (cmd.idTimerOrCmd < eTMR_CMD_BEGIN) { // This is Add command.
				result = p_timer_add_entry(timer, &cmd);
				if (g_Trace_TimerHandle == timer)
				DHL_TIMER_Show(timer);

				if (cmd.flags & eTIMER_FLAG_NowAndContinue)
					// 등록도 하지만, 지금 바로 당장 call도 해주어야 한다.
					p_timer_call(timer, cmd.idTimerOrCmd, cmd.flags, cmd.func, cmd.userParams);

			}
			else if (cmd.idTimerOrCmd == eTMR_CMD_DELETE) {
				// delete 인 경우는 삭제할 timer id가 userparam[0]을 통해 전달 된다.
				result = p_timer_delete_entry(timer, cmd.userParams[0]);
			}
			else if (cmd.idTimerOrCmd == eTMR_CMD_DELETE_ALL) {
				result = p_timer_delete_entry(timer, (UINT32)-1);
			}
			else if (cmd.idTimerOrCmd == eTMR_CMD_SYNC) {
				; // 특별히 처리할 것 없음. 그냥 아래에서 ack만 주면 됨.
			}
			else if (cmd.idTimerOrCmd == eTMR_CMD_SHOW) {
				p_timer_show(timer, &cmd);
			}
			else if (cmd.idTimerOrCmd == eTMR_CMD_QUERY) {
				// not yet..
			}
			else if (cmd.idTimerOrCmd == eTMR_CMD_SHUTDOWN) {
				break;
			}

			// 사용 예를 보면 TimerStop 에서만 ack 모드를 사용하고 있으므로,
			// TimerStop 에서 사용되지 않는 nPeriodMs 변수 공간을 result 리턴 용도로 사용한다.
			if (cmd.idTimerOrCmd == eTMR_CMD_DELETE && (cmd.flags & TIMER_FLAG_NeedAck)) {
				if (cmd.nPeriodMs) 
					*(UINT32 *)(cmd.nPeriodMs) = (UINT32)result;
				DHL_OS_GiveSemaphore(timer->semAck);
			}
			if ((cmd.idTimerOrCmd == eTMR_CMD_SYNC) && (cmd.flags & TIMER_FLAG_NeedAck)) {
				DHL_OS_GiveSemaphore(timer->semAck);
			}
		}
		else if (result == DHL_FAIL_TIMEOUT)
		{
			// it is natural.. some timer entry is timed-out.
		}
		else 
		{
			DHL_OS_Printf("!! timer rx msg result 0x%x \a\n", result);
		}

		//-------- timer entry 처리 ---------------
		
		for (i=0; i<=timer->maxActiveIndex; i++)
		{
			DHL_TIMER_ENTRY *ti = &timer->info[i];
		
			if (ti->used == FALSE)
				continue;
				
			// 지정 시간이 경과되었는지 체크. Timeout 되었으면 Timer함수 수행.
			//
			if (DHL_OS_GetMsCount() - ti->start > ti->period) // Timer expired..
			{
				UINT32 userParams[MAX_NUMBER_OF_TIMER_PARAM];
				DHL_TIMER_PROC_EX pFn;
				UINT16 id, flags;
				BOOL bOneShot;
				
				// 아래에서 oneshot 인 경우 callback 전에 먼저 ti를 clear 시키므로,
				// timer call에 필요한 모든 파라미터는 backup 해 두어야 한다.
				pFn = ti->fn;
				id = ti->nId;
				flags = ti->flags;
				memcpy(userParams, ti->params, sizeof(UINT32)*timer->nUserParam);
				bOneShot = (flags & eTIMER_FLAG_OneShot) ? TRUE : FALSE;

				if (bOneShot) {  // 1회성 Timer: 이 timer를 off시킨다.
					memset(ti, 0, sizeof(DHL_TIMER_ENTRY));
					timer->nActiveTimer--;
				}
				else {   // Periodic Timer: tick counter를 리셋시킨다.
					ti->start = DHL_OS_GetMsCount();
				}

				p_timer_call(timer, id, flags, pFn, userParams);

				if (bOneShot)
					if (g_Trace_TimerHandle == timer)
					printf( "Oneshot timer ID %d killed\n", id);
			}
			
		} // end for (timer DB)
		
	}

	p_timer_shutdown(timer);
	DHL_OS_SelfDeleteTask();
}


#if COMMENT
____LowLevel_API____(){}
#endif

DHL_RESULT DHL_TIMER_StartEx(DHL_TMHANDLE handle, UINT32 nIdTimer, UINT32 nPeriodMs, 
						DHL_TIMER_PROC_EX func, int numParam, UINT32 *params, UINT16 flags)
{
	DHL_RESULT dhlResult;
	DHL_TIMER *timer = (DHL_TIMER *)handle;
	DHL_TIMER_COMMAND cmd;
	DHL_OS_TASK_ID tid = DHL_OS_GetTaskID();
	int i;

	if ((dhlResult = p_timer_check_valid(timer))!=0)
		return dhlResult;

	if (func == NULL) {
		printf( "!! func is null [%d]!\n", nIdTimer);
		return DHL_FAIL_INVALID_PARAM;
	}
	if (nIdTimer & 0xFFFF0000) {
		printf( "!! timer id should be 16-bits range.\n");
		DHL_ASSERT(FALSE, "");
		return DHL_FAIL_INVALID_PARAM;
	}
	if (nIdTimer >= eTMR_CMD_BEGIN || nIdTimer == 0) {
		printf( "!! timer id 0x%x is in reserved range.\n", nIdTimer);
		DHL_ASSERT(FALSE, "");
		return DHL_FAIL_INVALID_PARAM;
	}
	if (nPeriodMs == 0 && !(flags & eTIMER_FLAG_OneShot)) {
		printf( "!! interval timer should have period.\n");
		DHL_ASSERT(FALSE, "");
		return DHL_FAIL_INVALID_PARAM;
	}

	// 실제 parameter의 갯수는 Initialize 할 때 지정했던 수보다 크면 안된다.
	if (numParam > timer->nUserParam) {
		numParam = timer->nUserParam;
	}
	// Initialize 에서 지정한 숫자보다 적은 것은 괜찮음. 0으로 채워짐.
	
	dprint(2, "%s: (ID %d, period %d, flags %x, %d params %x %x ..)\n", __FUNCTION__, 
		nIdTimer, nPeriodMs, flags, numParam, params[0], params[1]);

	memset(&cmd, 0, sizeof(DHL_TIMER_COMMAND));

	// ADD의 경우 별도의 command id를 사용하지 않고, 그냥 timer id를 전송한다.
	cmd.idTimerOrCmd = nIdTimer;
	cmd.nPeriodMs = nPeriodMs;
	cmd.func = func;
	cmd.flags = flags;

	for (i=0; i<numParam; i++)
		cmd.userParams[i] = params[i];

	if (tid != timer->nTaskId)
	{
		// send command asynchronously.
		// if we need return value, then we should use ack.
		//
		// cmd 자체는 최대 갯수의 user param을 포함하고 있지만 
		// OSAL 내부에서 필요한 만큼만 복사를 해 갈 것이다.
		dhlResult = DHL_OS_SendMessage(timer->msgQue, &cmd, sizeof(cmd));
		if (dhlResult) {
			// error check..
			printf( "!! %s send cmd err %x\a\n", __FUNCTION__, dhlResult);
		}		
	}
	else
	{
		// current task is THE TIMER task that we can add.
		// so, we can directly modify timer info.
		//
		dhlResult = p_timer_add_entry(timer, &cmd);
	}
	return dhlResult;
}

DHL_RESULT DHL_TIMER_Start(DHL_TMHANDLE handle, UINT32 nIdTimer, UINT32 nPeriodMs, 
						DHL_TIMER_PROC func, UINT32 param, BOOL bOneShot)
{
	UINT16 flags = \
		bOneShot == 0 ? eTIMER_FLAG_Continue : \
		bOneShot == 2 ? eTIMER_FLAG_NowAndContinue : eTIMER_FLAG_OneShot;

	flags |= TIMER_FLAG_OldStyleProc;
	return DHL_TIMER_StartEx(handle, nIdTimer, nPeriodMs, 
						(DHL_TIMER_PROC_EX) func, 1, &param, flags);
}

DHL_RESULT DHL_TIMER_Stop(DHL_TMHANDLE handle, UINT32 nIdTimer)
{
	DHL_RESULT dhlResult, dhReturnValue = DHL_OK;
	DHL_TIMER *timer = (DHL_TIMER *)handle;
	DHL_TIMER_COMMAND cmd;
	DHL_OS_TASK_ID tid = DHL_OS_GetTaskID();
	
	if ((dhlResult = p_timer_check_valid(timer))!=0)
		return dhlResult;

	// 잘못된 timer id 는 아무런 영향을 끼치지 않는다. 제거.
#if 0
	if (nIdTimer == 0) { // cafrii 060919 add
		printf( "!! invalid timer id 0\n", nIdTimer);
		return DHL_FAIL_INVALID_PARAM;
	}
#endif

	memset(&cmd, 0, sizeof(DHL_TIMER_COMMAND));

	cmd.idTimerOrCmd = eTMR_CMD_DELETE;
	cmd.userParams[0] = nIdTimer & 0xFFFF; // id는 16-bits..
	
	if (tid != timer->nTaskId)
	{
		int wait_count;
		cmd.flags |= TIMER_FLAG_NeedAck; // we always request ACK when send STOP command.
		cmd.nPeriodMs = (UINT32)&dhReturnValue;

		// need ack mechanism..
		DHL_OS_TakeSemaphore(timer->mutexAck, DHL_TIMEOUT_FOREVER);
		DHL_OS_TakeSemaphore(timer->semAck, 0); // reset to none
	
		dhlResult = DHL_OS_SendMessage(timer->msgQue, &cmd, sizeof(cmd));
		if (dhlResult) {
			// error check..
			printf( "!! %s send cmd err %x\a\n", __FUNCTION__, dhlResult);
		}

		for (wait_count=0 ; wait_count<5; wait_count++) {
			if (wait_count)
				printf( "!! timer not responding.. wait %d..\n", wait_count);
			dhlResult = DHL_OS_TakeSemaphore(timer->semAck, 1000);
			if (dhlResult == DHL_OK) break;
		}

		dhlResult = dhReturnValue;
		DHL_OS_GiveSemaphore(timer->mutexAck);
	}
	else
	{
		// current task is THE TIMER task that we can add.
		// so, we can directly modify timer info.
		//
		dhlResult = p_timer_delete_entry(timer, nIdTimer);
	}
	return dhlResult;
}


DHL_RESULT DHL_TIMER_Sync(DHL_TMHANDLE handle)
{
	DHL_RESULT dhlResult, dhReturnValue = DHL_OK;
	DHL_TIMER *timer = (DHL_TIMER *)handle;
	DHL_TIMER_COMMAND cmd;
	DHL_OS_TASK_ID tid = DHL_OS_GetTaskID();
	
	if ((dhlResult = p_timer_check_valid(timer))!=0)
		return dhlResult;

	memset(&cmd, 0, sizeof(DHL_TIMER_COMMAND));

	cmd.idTimerOrCmd = eTMR_CMD_SYNC;
	
	if (tid != timer->nTaskId)
	{
		int wait_count;
		cmd.flags |= TIMER_FLAG_NeedAck; // we need ACK for this command.

		// need ack mechanism..
		DHL_OS_TakeSemaphore(timer->mutexAck, DHL_TIMEOUT_FOREVER);
		DHL_OS_TakeSemaphore(timer->semAck, 0); // reset to none
	
		dhlResult = DHL_OS_SendMessage(timer->msgQue, &cmd, sizeof(cmd));
		if (dhlResult) {
			// error check..
			printf( "!! %s send cmd err %x\a\n", __FUNCTION__, dhlResult);
		}

		for (wait_count=0 ; wait_count<5; wait_count++) {
			if (wait_count)
				printf( "!! timer '%s' not responding.. wait %d..\n", timer->name, wait_count);
			dhlResult = DHL_OS_TakeSemaphore(timer->semAck, 1000);
			if (dhlResult == DHL_OK) break;
		}

		dhlResult = dhReturnValue;
		DHL_OS_GiveSemaphore(timer->mutexAck);
	}
	else
	{
		DHL_ASSERT(FALSE, "invalid usage\n");
	}
	return dhlResult;
}

void DHL_TIMER_Show(DHL_TMHANDLE handle)
{
	DHL_RESULT dhlResult;
	DHL_TIMER *timer;
	DHL_TIMER_COMMAND cmd;
	DHL_OS_TASK_ID tid = DHL_OS_GetTaskID();
	
	if (handle == 0)
		timer = g_dhl_timer_list;
	else
		timer = (DHL_TIMER *)handle;
	
	while (timer)
	{
		if ((dhlResult = p_timer_check_valid(timer))!=0)
			return;

		memset(&cmd, 0, sizeof(DHL_TIMER_COMMAND));
		cmd.idTimerOrCmd = eTMR_CMD_SHOW;
		// this SHOW command do not use ACK.

		if (tid != timer->nTaskId)
		{
			// send command asynchronously..
			dhlResult = DHL_OS_SendMessage(timer->msgQue, &cmd, sizeof(cmd));
			if (dhlResult) {
				// error check..
				printf( "!! %s send cmd err %x\a\n", __FUNCTION__, dhlResult);
			}
		}
		else {
			p_timer_show(timer, &cmd);
		}

		if (handle) // show only specified timer.
			break;
			
		if (tid != timer->nTaskId) {
			DHL_OS_Delay(100);
				// wait for timer tasks to print information
		}		
		timer = timer->next;
	}
	
}


DHL_RESULT DHL_TIMER_Initialize(DHL_TIMER_INIT_PARAM *param, DHL_TMHANDLE *pHandle)
{
	DHL_RESULT dhlResult = DHL_OK;
	int nAllocSize;
	char buf[20];
	UINT32 mask;
	DHL_TIMER *timer = NULL;

	dprint(2, "%s: timer '%s' init, max %d, pri %d, stack %d, #param %d, qsize %d\n", 
			__FUNCTION__, param->name, param->max_timer_entry,
			param->task_priority, param->stack_size, 
			param->num_user_param, param->msg_que_size);

	*pHandle = NULL; // initialize first..

	if (param->max_timer_entry <= 0)
		return DHL_FAIL_INVALID_PARAM;
	
	nAllocSize = sizeof(DHL_TIMER) + 4 + param->max_timer_entry * sizeof(DHL_TIMER_ENTRY) + 4;
	// assign some guard band space between master timer info and timer slot entries.
	
	timer = (DHL_TIMER *) DHL_OS_Malloc(nAllocSize);
	if (timer == NULL)
		return DHL_FAIL_OUT_OF_MEMORY;
	
	memset(timer, 0, nAllocSize);
	
	// name of timers
	strncpy(timer->name, param->name, MAX_TIMER_NAME);
	timer->name[MAX_TIMER_NAME] = 0;

	// max timer slots
	timer->nMaxSlot = param->max_timer_entry;
	
	// no active timer now.
	timer->maxActiveIndex = -1;

	// timer slots
	timer->info = (DHL_TIMER_ENTRY *) ((UINT8 *)timer + sizeof(DHL_TIMER) + 4);

	// num user param
	if (param->num_user_param == 0)
		timer->nUserParam = 1;   // for backward compatibility
	else if (param->num_user_param > 0 && param->num_user_param <= MAX_NUMBER_OF_TIMER_PARAM)
		timer->nUserParam = param->num_user_param;
	else {
		printf( "!! num user param %d invalid.\n", param->num_user_param);
		goto label_end;
	}

	// message que size
	if (param->msg_que_size == 0)
		timer->nMaxQueSize = DEFAULT_MSG_QUE_SIZE; // for backward compatibility
	else if (param->msg_que_size > 0)
		timer->nMaxQueSize = param->msg_que_size;
	else {
		printf( "!! que size %d invalid.\n", param->msg_que_size);
		goto label_end;
	}
	
	// task는 맨 마지막에 생성하는 게 좋다. priority 관련하여 먼저 실행 가능성이 있으므로..
	//
	
	memset(buf, 0, sizeof(buf));
	strcpy(buf, "TS");	// timer ack sem
	strncpy(buf+2, timer->name, 6);
	timer->semAck = DHL_OS_CreateBinarySemaphore(buf, 0, 0);
	
	if (timer->semAck == 0) {
		printf( "!! Creating sem err\n");
		dhlResult = DHL_FAIL_OUT_OF_RESOURCE;
		goto label_end;
	}

	// param->use_mutex_lock is never used at all.

	memset(buf, 0, sizeof(buf));
	strcpy(buf, "TM");	// timer ack mutex
	strncpy(buf+2, timer->name, 6);
	timer->mutexAck = DHL_OS_CreateMutexSemaphore(buf);

	if (timer->mutexAck == 0) {
		printf( "!! Creating mutex err\n");
		dhlResult = DHL_FAIL_OUT_OF_RESOURCE;
		goto label_end;
	}

	memset(buf, 0, sizeof(buf));
	strcpy(buf, "TQ");	// timer cmd que
	strncpy(buf+2, timer->name, 6);
#if 0//BRCM
	timer->msgQue = DHL_OS_CreateMessageQueue(buf, 0, 
		TIMER_COMMAND_SIZE(timer->nUserParam), TIMER_COMMAND_SIZE(timer->nUserParam));
#else
	timer->msgQue = DHL_OS_CreateMessageQueue(buf, 0, 
		timer->nMaxQueSize, TIMER_COMMAND_SIZE(timer->nUserParam));
#endif
	if (timer->msgQue == 0) {
		printf( "!! Creating msgq err\n");
		dhlResult = DHL_FAIL_OUT_OF_RESOURCE;
		goto label_end;
	}

	timer->magic = DHL_TIMER_MAGICKEY;
	
	//timer->fnLock = dhl_timer_lock;
	//timer->fnUnlock = dhl_timer_unclock;

	timer->param = *param;
	timer->param.name = timer->name;

	mask = DHL_OS_DisableInterrupts();
	timer->next = g_dhl_timer_list;
	g_dhl_timer_list = timer;
	DHL_OS_RestoreInterrupts(mask);

	//memdump(timer, sizeof(*timer), "timer");
	//console_flush();
	
	/*
		timer task priority가 높을 경우 이 함수가 종료되지 전에도 바로 timer task가
		실행 될 수 있음에 유의할 것.
	*/
	timer->nTaskId = DHL_OS_CreateTask((DHL_OS_TASKFUNCTION) dhl_timer_task, timer->name, 
						param->task_priority, param->stack_size, (UINT32)timer);

	if (timer->nTaskId == (DHL_OS_TASK_ID) 0) {
		printf( "!! Creating task err\n");
		dhlResult = DHL_FAIL_OUT_OF_RESOURCE;
		goto label_end;
	}

	//dhl_timer_show(0);

	if (pHandle)
		*pHandle = (DHL_TMHANDLE) timer;
	timer = 0;

label_end:
	
	if (timer) {
		// clean up!
		printf( "!! err occurred in timer init. clean up!\n");

		if (timer->semAck)
			DHL_OS_DeleteSemaphore(timer->semAck);
		if (timer->mutexAck)
			DHL_OS_DeleteSemaphore(timer->mutexAck);
		if (timer->msgQue)
			DHL_OS_DeleteMessageQueue(timer->msgQue);
		
		DHL_OS_Free((void**)&timer);
	}

	return dhlResult;
}


/**
	@todo
		Task 종료 OSAL API가 없다면 internal 용도의 function을 만들어서 
		OSAL_Priv.h 에 등록해 놓고 사용하면 될 것 같음.
		
*/
void       DHL_TIMER_Terminate(DHL_TMHANDLE handle)
{
	DHL_RESULT dhlResult;
	DHL_TIMER *timer = (DHL_TIMER *)handle;
	UINT32 i;
	DHL_TIMER_COMMAND cmd;
	DHL_OS_TASK_ID tid = DHL_OS_GetTaskID();

	// TimerTask가 자동으로 죽을때까지 기다릴 시간..
#define WAIT_TIME         5 // second.
#define CHECK_PER_SECOND  5 // times.

	if ((dhlResult = p_timer_check_valid(timer))!=0)
		return;

	if (tid == timer->nTaskId) {
		printf( "!! %s: cannot shutdown timer in itself\n", __FUNCTION__);
		return;
	}

	memset(&cmd, 0, sizeof(DHL_TIMER_COMMAND));
	cmd.idTimerOrCmd = eTMR_CMD_SHUTDOWN;

	dhlResult = DHL_OS_SendMessage(timer->msgQue, &cmd, sizeof(cmd));
	if (dhlResult) {
		// error check..
		printf( "!! %s send cmd err %x\n", __FUNCTION__, dhlResult);
	}
	
	for (i = 0; i < WAIT_TIME*CHECK_PER_SECOND; ++i) {
		if (timer->nTaskId == 0) {
			break;
		}
		DHL_OS_Delay(1000/CHECK_PER_SECOND);
	}
	
	// 충분히 기다렸건만, Self Delete가 되지 않았을 경우에는 강제 종료시킨다.
	//
	if (timer->nTaskId != 0) 
	{
		printf( "!! timer shutdown timeout!\n");
#if 0
		DHL_ASSERT(dhl_os_delete_task(timer->nTaskId) == DHL_OK, 
			"!! timer task destroy failled.. \n");
#endif
	}
	
#if 0 // remove. if command not works, something is wrong.
	// 원래 Timer task에서 삭제해야하는 것들이다.
	
	if (timer->semAck) {
		OS_DeleteSemaphore(timer->semAck);
		timer->semAck = 0;
	}
	if (timer->mutexAck) {
		OS_DeleteSemaphore(timer->mutexAck);
		timer->mutexAck = 0;
	}
#endif
	
	timer->nTaskId = 0;
	
	DHL_OS_Free((void**)&timer);

}



#if COMMENT
____HighLevel_API____(){}
#endif


DHL_TMHANDLE g_dhl_timer=NULL;


DHL_RESULT DHL_SYS_TimerInit(void)
{
	DHL_TIMER_INIT_PARAM* param;

//	dhl_timer_module_init();
	param = (DHL_TIMER *) DHL_OS_Malloc(sizeof(DHL_TIMER_INIT_PARAM));

	if (g_dhl_timer)
		return DHL_OK;  // dhl timer already initialized.
	
	memset(param, 0, sizeof(DHL_TIMER_INIT_PARAM));

	param->max_timer_entry = DHL_TIMER_MAX_ENTRY;
	param->name = "DHLTMR";
	param->task_priority = DHL_TIMER_TASK_PRIO;
	param->stack_size = DHL_TIMER_TASK_STACK;
	param->use_mutex_lock = 0; // we should support ISR!!
	
	return DHL_TIMER_Initialize(param, &g_dhl_timer);
}

DHL_RESULT DHL_SYS_StartTimer(UINT32 nIdTimer, UINT32 nPeriodMs, 
						DHL_TIMER_PROC func, UINT32 param, BOOL bOneShot)
{
	return DHL_TIMER_Start(g_dhl_timer, nIdTimer, nPeriodMs, 
						func, param, bOneShot);
}

DHL_RESULT DHL_SYS_KillTimer(UINT32 nIdTimer)
{
	return DHL_TIMER_Stop(g_dhl_timer, nIdTimer);
}

void DHL_SYS_ShowTimer(void)
{
	DHL_TIMER_Show(g_dhl_timer);
}


#if COMMENT
____Symbol____(){}
#endif

#if DHL_REGISTER_DEUBG_SYMBOLS
static DHL_SymbolTable dhl_timer_symbol[] =
{
	//---- functions
	//DHL_FNC_SYM_ENTRY(DHL_SYS_PrintTimer),
	//DHL_FNC_SYM_ENTRY(DHL_SYS_KillTimer),
	
	//---- variables
	//DHL_VAR_SYM_ENTRY(g_Trace_bDHLTimer),
	DHL_VAR_SYM_ENTRY(g_Trace_TimerHandle),
	
};
#endif // DHL_REGISTER_DEBUG_SYMBOL



#if COMMENT
____Init____(){}
#endif

void dhl_timer_module_init(void)
{
	static BOOL s_module_init=FALSE;

	if (s_module_init)
		return;

#if DHL_REGISTER_DEUBG_SYMBOLS
	DHL_DBG_RegisterSymbols(dhl_timer_symbol, DHL_NUMSYMBOLS(dhl_timer_symbol));
#endif	

	s_module_init = TRUE;
}

/* end of file */