/********************************************************************
	DHL_OSAL.c
	
	PHOENIX Driver HAL library
	OS Abstraction Layer implementation
	
	Copyright 2006 Digital STREAM Technology, Inc.
	All Rights Reserved

	$Id: DHL_OSAL.c  v1.00 2006/04 cafrii Exp $
	
********************************************************************/


/*
	Include files
*/


#include "DHL_Types.h"

#include "DHL_OSAL.h"
#include "DHL_OSAL_Impl.h"

#include "DHL_DBG.h"
#include "bcm_mips_defs.h"
#include "bcm_mips.h"
#include "bcmmemmgr.h"
#include "bos.h"

/* 
	define
*/

#define USE_BCM_MUTEX			0
#define USE_BCM_MSG_QUEUE	0


#if USE_BCM_MUTEX
#include "bkni.h"
#include "bkni_multi.h"
#endif

#if USE_BCM_MSG_QUEUE
#include "bos.h"
#endif


// to enable verbose debug message.
#define OSAL_DEBUG 0


// to use message queue in ISR, we should not use mutex.
// remove codes after verification.
//
#define BUGFIX_MSGQ 1


#define max(a,b) (((a) > (b)) ? (a) : (b))
#define min(a,b) (((a) < (b)) ? (a) : (b))

	
#if COMMENT
_______________(){}
#endif


void dhl_dbg_flush_console(void)
{
//BKTEMP	console_flush();
}


int osi_dbgprint(char *fmt, ...)
{
	// DMC 에서 사용하는 debug print.
	char msgPrefix[50];
    va_list v;
    int n;
    char buf[200];

	dhl_dbg_flush_console();
	
	//if (g_Trace_EpgBase <= nLevel) return 0;

	snprintf(msgPrefix, 200, "[osi %s %d] ", DHL_OS_TaskName(0), DHL_OS_TaskPriority());

	va_start(v, fmt);
	n = BKNI_Vsnprintf(buf, 200, fmt, v);
	va_end(v);

	BKNI_Printf(msgPrefix); BKNI_Printf(buf); 
	dhl_dbg_flush_console();
	
	return n;
}

#undef printf
#define printf osi_dbgprint


#if COMMENT
___Internal_alloc___(){}
#endif

/*
	this is only for osal_impl internal.
	do not use this outside.
*/

static void *osi_calloc(int n)
{
	void *p;
#ifdef BCM_DEBUG
	p = malloc_align_dbg(n, 2, __FILE__, __LINE__);
#else
	p = OS_Malloc(n);
#endif
	memset(p, 0, n);
	return p;
}
static void osi_free(void *p)
{
	// p is not compatible with OS_Free.
	// this will not reset pointer.
	
#ifdef BCM_DEBUG
	free_dbg(p, __FILE__, __LINE__);
#else
	OS_FreeDirect(p);
#endif
}


#if COMMENT
___Tick_Func___(){}
#endif

UINT32 osi_gettickcount()
{
	return bos_getticks();
}


UINT32 osi_gettickspersecond()
{
	return g_ticks_per_second;
}	


void osi_delay(UINT32 millisec)
{
	bos_sleep(millisec);
}


#if COMMENT
___Task_related_Func___(){}
#endif

extern unsigned char OSIntNesting;

BOOL osi_in_interrupt(void)
{
	return OSIntNesting > 0 ? TRUE : FALSE;
}

/*
	interrupt disable/enable:
		
*/
UINT32 osi_disableint()
{
	/*
		단순히 OS_ENTER_CRITICAL 만 하면 충분하지 않다.
		int disable 해도 OS schedule이 되기도 하는데,
		새로운 task에서의 cp0:$12의 int가 enable 되어 있다면 아무 의미가 없어진다.
		사실 OSSched() 내부에서도 OS_ENTER_CRITICAL 된 상태에서 switching 한다.

		결론은 완벽하게 int disable 하려면 scheduler도 같이 disable 시켜야 한다.
	*/
	
	UINT32 flags;
	OSSchedLock();
	flags = MIPS_SetInterrupts(OS_DISABLE); // OS_ENTER_CRITICAL(flags);
	return flags;
}

void osi_enableint(UINT32 mask)
{
	MIPS_SetInterrupts(mask);// OS_EXIT_CRITICAL(mask);
	OSSchedUnlock();
}

extern unsigned char OSLockNesting;

BOOL osi_in_tasklock(void)
{
	return OSLockNesting> 0 ? TRUE : FALSE;
}

/*
	lock/unlock task:
		disable/enable OS scheduler.
*/
UINT32 osi_locktask()
{
	OSSchedLock();
	// actually, return value is not important..
	return OSLockNesting;
}

void osi_unlocktask(UINT32 mask)
{
	//mask is unused.
	OSSchedUnlock();
}


char *osi_taskname(os_task_id tid)
{
	b_task_stats *stat=bos_get_task_info((b_task_t)tid);
	
	if(stat) return stat->name;
	
	return NULL;
}

/*
	note!
	OSTCBCur should be accessed with all interrupt disabled.
*/

int osi_taskpriority()
{
	int prio;
	UINT32 flags;
	flags = MIPS_SetInterrupts(OS_DISABLE); // OS_ENTER_CRITICAL(flags);
	prio = (int)OSTCBCur->OSTCBPrio;
	MIPS_SetInterrupts(flags);// OS_EXIT_CRITICAL(flag);
	return prio;
}


os_task_id osi_taskid()
{
#if 0//#ifdef UCOS_II
	os_task_id id;
	OS_TCB tcb;
	OSTaskQuery( OS_PRIO_SELF, &tcb );	/* use our priority as a task id */
	id = tcb.OSTCBPrio;;
#else
	os_task_id id;
	UINT32 flags;
	flags = MIPS_SetInterrupts(OS_DISABLE); // OS_ENTER_CRITICAL(flags);
	id = OSTCBCur->OSTCBPrio;
	MIPS_SetInterrupts(flags);// OS_EXIT_CRITICAL(flag);
#endif
	return id;
}

	  
os_task_id osi_taskidfromname(char *tname)
{
	int i;
	b_task_stats *stat=NULL;
	
	for(i=0, stat=bos_get_task_info(i); stat; i++) {
		if(0==strcmp(stat->name, tname)) return (os_task_id)i;
		stat=bos_get_task_info(i);
	}
	
	return 63;
}


void osi_changetaskpriority(os_task_id tid, UINT32 newPrio, UINT32 *oldPrioPtr)
{
	
	if(tid==0) {
		tid=osi_taskpriority();
	}
	OSTaskChangePrio(tid, newPrio);
	*oldPrioPtr = tid;
}


void osi_selfdeletetask(void)
{
	OSTaskDel(OS_PRIO_SELF);
}
void osi_deletetask(os_task_id tid)
{
	bos_stop_task((b_task_t)tid);
}

#if 0
static void osi_taskbody(int *osparam)
{
	os_taskfunction func = (os_taskfunction)(osparam[0]);
	void *arg = (void *)(osparam[1]);

#if 1
	// cafrii 081014 add.
	// turn on IE bit for normal operation.
	// it is possible that parent task call OS_SpawnTask in IE disabled state.
	// in such case, child task start as IE disabled state, which is abnormal.
	//
	unsigned long status;
	
	status = bcm_read_cp0($12,0);
	status |=  ST0_IE;
	bcm_write_cp0($12,0, status);

#endif

	(*func)(arg);
	
	while (1) { // wait forever..
		DHL_OS_Delay(DHL_OS_GetTicksPerSecond()*60*60);
	};
}
#endif

/*
	in DST OSAL api, stackSize is byte size.
	in osi_show_taskinfo(), the stack size is word (4-byte) unit.

	we provide stub function to call real user task function.
	if user task function completes, it waits forever.

	os_task_id is its priority! (NOTICE: inversion value)
*/
os_task_id osi_spawntask(os_taskfunction func, const char *name, int priority, UINT32 stackSize,
                         UINT32 arg1)
{
	b_task_t tid;
	b_task_params param;
	unsigned int *p; 
	int stk_size_word = (stackSize + 3)/4; // round up. (align)

#if 0
	/* cafrii 081014 add check code:
		in uCOS, parent task has IE disabled, child (created) task also run in IE disabled state.
		OS_LockTask() makes IE disabled. So, we should not call OS_SpawnTask() after OS_LockTask().
	*/
	if (OS_IS_ISR()) {
		printf("\n!! spawn task in privileged level\n");
		printf("SR: %08x\n", bcm_read_cp0($12,0));
		stack_backtrace(0, 0, 0, 0);
	}
#endif
	param.priority=priority;
	param.stack_size=stk_size_word;

	p = (unsigned int *) osi_calloc(stk_size_word*sizeof(int) + sizeof(int)*2);
	param.stack = p;
	param.name = name;

#if	0//ndef UCOS_II	//ucOS
	p = p + stk_size_word; // we place osparam at the end of mem block. (== bottom of stack)
	p[0] = (unsigned int) func;
	p[1] = (unsigned int) arg1;
#endif


//BKTEMP	if(b_ok!=bos_start_task(&tid, &param, (b_task_func)osi_taskbody, (void *)p)) {
		if(b_ok!=bos_start_task(&tid, &param, func, (void *)arg1)) {

		printf("!! err : fail to create task\n");
		return 0;
	}
	
	return (os_task_id)tid;
}


#if COMMENT
___Sem_related_Func___(){}
#endif

#define SIZE_SEM_NAME 15

enum {
	SEM_MUTEX=0x1,
	SEM_BINARY=0X2,
	SEM_COUNTING=0X3,
	SEM_MSGQ=0x4,
};

typedef struct {
	UINT8 type;
//	UINT32 handler;
	OS_EVENT* handler;

#if USE_BCM_MUTEX
	BKNI_MutexHandle hMutex;
#endif
	char name[SIZE_SEM_NAME+1];
	//---------
	UINT8 nRecursive;
	UINT32 owner; //mutex

	void *next;  // for free list managent of reuse semaphore.
} SemType;


#if OSAL_DEBUG
int g_os_sem_create_count;

#define trace_sem_create(type) \
	printf("==== sem create: " #type " %d, os-free %d, dhl-free %d\n", \
		++g_os_sem_create_count, OSSemGetFreeCount(), osi_free_reuse_sem_count())
#else
#define trace_sem_create(type)
#endif


/*
	ucos semaphore wrapper
		take -> SemAccept/SemPend
		give -> SemPost
*/
static DHL_RESULT _takesemaphore(SemType *sem, int ticks)
{
	DHL_RESULT result=DHL_OK;
	UINT8 err;

#if OSAL_DEBUG
	if (sem->type != SEM_MUTEX)
	{
		printf("#### take %c sem '%s' %x, h %x, tick %d\n", 
				sem->type == SEM_BINARY ? 'b' : 
				sem->type == SEM_MUTEX ? 'm' : 'c',
				sem->name, sem, sem->handler, ticks);
	}
#endif

#if 0
	if (OS_IS_ISR() && ticks != NO_WAIT)
		return DHL_FAIL_INVALID_STATE;
#endif

	if (ticks == NO_WAIT) 
	{
		INT16U value= OSSemAccept((OS_EVENT *)sem->handler);
//		printf("sem_count: %d/%d\n",value, sem->handler->OSEventCnt);
		if (value > 0)
			result = DHL_OK;
		else
			result = DHL_FAIL_TIMEOUT;
	}
	else if (ticks == WAIT_FOREVER) 
	{
		do {
			OSSemPend((OS_EVENT *)sem->handler, 0xffff, &err);
		} while (err == OS_TIMEOUT);
		if(err!=OS_NO_ERR)
		{
			printf("ERR: _takesemaphore %d\n", err);
			result=DHL_FAIL_TIMEOUT;
		}else
			result = DHL_OK;
	}
	else // unlimited tick range.
	{
		// repeat until ticks are all consumed or err occurred.
		UINT32 prev, cur, ticks_left = ticks;
		UINT32 rounds = 0; // for debugging.
		cur = osi_gettickcount();
		do {
			prev = cur;
			rounds++;
			OSSemPend((OS_EVENT *)sem->handler, min(0xffff, ticks_left), &err);
			if (err == OS_TIMEOUT) {
				// we should do more rounds until all 'ticks' consumed.
				cur = osi_gettickcount();
				if(cur >= prev)
					ticks_left -= (cur - prev); // decrease tick by elapsed time.
				else
					ticks_left -= (cur + prev); 
			} 
		} while (err == OS_TIMEOUT && ticks_left > 0);
//		if(OS_NO_ERR != err)
//		{
//			printf("!!!! OSSemPend err=%d\n",err); 
//		}
#if OSAL_DEBUG
		if (rounds > 1) {
			printf("!!!! semtype %d: total %d rounds, requested ticks: %d (0x%x)\n", 
				sem->type, rounds, ticks);
		}
#endif
		if(err!=OS_NO_ERR)
		{
//			printf("ERR: _takesemaphore %d\n", err);
			result=DHL_FAIL_TIMEOUT;
		}else
			result = DHL_OK;
	}

	return result;
}

static void _givesemaphore(SemType *sem)
{
#if OSAL_DEBUG
	if (sem->type != SEM_MUTEX)
	{
		printf("#### give %c sem %s %x, h %x\n", 
				sem->type == SEM_BINARY ? 'b' : 
				sem->type == SEM_MUTEX ? 'm' : 'c',
				sem->name, sem, sem->handler);
	}
#endif
#if 0//BKTODO: semaphore, mutex인 경우 고려 필요함. (ucOS-II에는 OSSemPostEx()가 제공되지 않는다.)
	if (sem->type == SEM_BINARY || sem->type == SEM_MUTEX)
		OSSemPostEx((OS_EVENT *)sem->handler, 1);
		// return value 'OS_SEM_OVF' is not error.
	else
		OSSemPost((OS_EVENT *)sem->handler);
#else
#if 1//BK - binary semaphore acts like counting semaphore
	if(sem->type == SEM_BINARY)
	{
		if(sem->handler->OSEventCnt > 0)
		{
			printf("skip: bin sema4 cnt=%d\n", sem->handler->OSEventCnt );
			return;
		}
	}
#endif

	OSSemPost((OS_EVENT *)sem->handler);
#endif
}


int osi_takesemaphore(os_semaphore_id sid)
{
	return osi_takesemaphore_wait(sid, WAIT_FOREVER);
}


int osi_takesemaphore_wait(os_semaphore_id sid, int ticks)
{
	DHL_RESULT result=DHL_OK;
	SemType *sem=(SemType *)sid;
	
	if(sem->type == SEM_MUTEX) {
		return osi_takemutexsemaphore_wait(sid, ticks);
	}

	result = _takesemaphore(sem, ticks);
	return result;
}


int osi_takesemaphore_nowait(os_semaphore_id sid)
{
	return osi_takesemaphore_wait(sid, NO_WAIT);
}


int osi_givesemaphore(os_semaphore_id sid)
{
	DHL_RESULT result;
	SemType *sem=(SemType *)sid;
	
	if(sem->type==SEM_MUTEX) {
		osi_givemutexsemaphore(sid);
		return DHL_OK;
	}
	_givesemaphore(sem);
	result = DHL_OK;
	return result;
}

	
int osi_flushsemaphore(os_semaphore_id sid)
{
	SemType *sem=(SemType *)sid;

	if(sem->type == SEM_MUTEX) {
		printf("!! %s: error, sem is mutex\n", __FUNCTION__);
		return DHL_FAIL_INVALID_PARAM;
	}
	
	while(OSSemAccept((OS_EVENT *)sem->handler)>0);

	return DHL_OK;
}	


void osi_deletesemaphore(os_semaphore_id sid)	
{
//	printf("!! %s: delete sem not supported!!\n", __FUNCTION__);
	INT8U	err;
	SemType *sem=(SemType *)sid;
	if(sem)
	{
#if USE_BCM_MUTEX
		if(sem->type == SEM_MUTEX) {
			BKNI_DestroyMutex(sem->hMutex);
			osi_free(sem);
			return;
		}else
#endif
		{
			OSSemDel((OS_EVENT *)sem->handler, OS_DEL_ALWAYS, &err);//BKTODO: option값 확인요함. OS_DEL_NO_PEND -> OS_DEL_ALWAYS
			osi_free(sem);
			return;
		}
	}

}


#if COMMENT
_______(){}
#endif

int osi_takemutexsemaphore_wait(os_semaphore_id sid, int ticks)
{
#if USE_BCM_MUTEX
	SemType *sem=(SemType *)sid;
	UINT32 flags;
	DHL_RESULT result;
	BERR_Code err;
	
	if (sem->type != SEM_MUTEX) {
		printf("!! %s: error, sem is NOT a mutex\n", __FUNCTION__);
		return DHL_FAIL_INVALID_PARAM;
	}

	if (ticks == NO_WAIT) 
	{
		err = BKNI_TryAcquireMutex(sem->hMutex);
		if(err==BERR_SUCCESS)
		{
			result = DHL_OK;
		}else
		{
			printf("ERR: _takesemaphore %d\n", err);
			result=DHL_FAIL_TIMEOUT;
		}
	}
	else if (ticks == WAIT_FOREVER) 
	{
		err = BKNI_AcquireMutex(sem->hMutex);
		if(err==BERR_SUCCESS)
		{
			result = DHL_OK;
		}else
		{
			printf("ERR: _takesemaphore %d\n", err);
			result=DHL_FAIL_TIMEOUT;
		}
	}
	else // unlimited tick range.
	{
		int prev, cur, ticks_left = ticks;
		int rounds = 0; // for debugging.
		cur = osi_gettickcount();
		do {
			prev = cur;
			rounds++;
			err = BKNI_AcquireMutexTimeout(sem->hMutex, ticks_left);
			if (err != BERR_SUCCESS) {
				// we should do more rounds until all 'ticks' consumed.
				ticks_left -= ((cur = osi_gettickcount()) - prev); // decrease tick by elapsed time.
			}
		} while (err == BERR_SUCCESS && ticks_left > 0);
		
		if(err!=BERR_SUCCESS)
		{
			printf("ERR: _takesemaphore %d\n", err);
			result=DHL_FAIL_TIMEOUT;
		}else
		{
			result = DHL_OK;
		}
	}
	if(result == DHL_OK)
	{
		flags = MIPS_SetInterrupts(OS_DISABLE); // OS_ENTER_CRITICAL(flags);
		sem->owner = (UINT32)OSTCBCur->OSTCBPrio;
		MIPS_SetInterrupts(flags);// OS_EXIT_CRITICAL(flags);
	}
#else
	SemType *sem=(SemType *)sid;
	UINT32 flags;
	DHL_RESULT result;

	if (sem->type != SEM_MUTEX) {
		printf("!! %s: error, sem is NOT a mutex\n", __FUNCTION__);
		return DHL_FAIL_INVALID_PARAM;
	}

#if 0
	//	ISR 내부인지, critical section 안인지 구분할 수 없음.
	if (OS_IS_ISR() && ticks != NO_WAIT) {
		printf("!! %s: mutex in ISR! '%s'\n", __FUNCTION__, sem->name);
		return DHL_FAIL_INVALID_STATE;
	}
#endif

	flags = MIPS_SetInterrupts(OS_DISABLE); // OS_ENTER_CRITICAL(flags);

	// check if this mutex is already ours.
	if (sem->owner == (UINT32)OSTCBCur->OSTCBPrio) {	//osi_taskid()=>OSTCBCur->OSTCBPrio
		// this task already owns this mutex.
		sem->nRecursive++;
		MIPS_SetInterrupts(flags);// OS_EXIT_CRITICAL(flags);
		result = DHL_OK;
	}
	else {	
		// its not ours. so, this mutex is similar to normal semaphores.
		// try to take..

		MIPS_SetInterrupts(flags);// OS_EXIT_CRITICAL(flags);

		result = _takesemaphore(sem, ticks);

		if (result == DHL_OK) {
			flags = MIPS_SetInterrupts(OS_DISABLE); // OS_ENTER_CRITICAL(flags);
			sem->owner = (UINT32)OSTCBCur->OSTCBPrio;
			sem->nRecursive = 0;
			MIPS_SetInterrupts(flags);// OS_EXIT_CRITICAL(flags);
		}
	}
#endif
	return result;

}


/*
	unlock mutex.
*/
void osi_givemutexsemaphore(os_semaphore_id sid)
{
#if USE_BCM_MUTEX
	SemType *sem=(SemType *)sid;
	UINT32 flags;
	UINT32 tid;
	if(sem->type != SEM_MUTEX) {
		printf("!! %s: error, sem is NOT a mutex\n", __FUNCTION__);
		return;
	}

	flags = MIPS_SetInterrupts(OS_DISABLE); // OS_ENTER_CRITICAL(flags);
	if (sem->owner == OSTCBCur->OSTCBPrio) {//osi_taskid()=>OSTCBCur->OSTCBPrio
		MIPS_SetInterrupts(flags);// OS_EXIT_CRITICAL(flags);	
		BKNI_ReleaseMutex(sem->hMutex);
	}else
	{
		MIPS_SetInterrupts(flags);// OS_EXIT_CRITICAL(flags);
		printf("!! %s: try unlock mutex (0x%x '%s') of others (tid %d)\n", 
						__FUNCTION__, sem, sem->name, sem->owner);
	}

#else

	SemType *sem=(SemType *)sid;
	UINT32 flags;
	
	if(sem->type != SEM_MUTEX) {
		printf("!! %s: error, sem is NOT a mutex\n", __FUNCTION__);
		return;
	}

	flags = MIPS_SetInterrupts(OS_DISABLE); // OS_ENTER_CRITICAL(flags);
	if (sem->owner == OSTCBCur->OSTCBPrio) {//osi_taskid()=>OSTCBCur->OSTCBPrio
		// this mutex is owned by me!
		if (sem->nRecursive > 0) {
			sem->nRecursive--;
			MIPS_SetInterrupts(flags);// OS_EXIT_CRITICAL(flags);
		}
		else {
			if(sem->owner)
			{
				// this is the last 'give'.
				sem->owner = 0;
				MIPS_SetInterrupts(flags);// OS_EXIT_CRITICAL(flags);

				// no body can 'give' this mutex.
				// so i can safely exit critical.

				_givesemaphore(sem);
			}else
			{
				printf("err: mutex no ownership\n");
			}
		}
	}
	else {
		MIPS_SetInterrupts(flags);// OS_EXIT_CRITICAL(flags);
		printf("!! %s: try unlock mutex (0x%x '%s') of others (tid %d)\n", 
				__FUNCTION__, sem, sem->name, sem->owner);
	}
#endif
}


#if COMMENT
_______(){}
#endif

os_semaphore_id osi_createcountingsemaphore(const char *name, UINT32 options, UINT32 count)
{
	SemType *sem;

	sem=(SemType *)osi_calloc(sizeof(SemType));
	if (sem==NULL) {
		return 0;
	}
	
	if (count > 65535)
		count = 65535;
	
	strncpy(sem->name, name, SIZE_SEM_NAME-1);
	sem->type=SEM_COUNTING;
	sem->nRecursive=0;
	sem->owner=0;
	sem->handler=(OS_EVENT*)OSSemCreate(count);
	if (sem->handler == 0) {
		osi_free(sem);
		return 0;
	}
//	OSSaveUserData((OS_EVENT *)sem->handler, sem);
	
	trace_sem_create(count);

	return (os_semaphore_id)sem;
}


os_semaphore_id osi_createbinarysemaphore(const char *name, UINT32 options, BOOL flag)
{
	SemType *sem;
	
	sem=(SemType *)osi_calloc(sizeof(SemType));
	if (sem==NULL) {
		return 0;
	}
	strncpy(sem->name, name, SIZE_SEM_NAME-1);
	sem->type=SEM_BINARY;
	sem->nRecursive=0;
	sem->owner=0;
	sem->handler=(OS_EVENT*)OSSemCreate(flag==TRUE?1:0);
	if (sem->handler == 0) {
		osi_free(sem);
		return 0;
	}
//	OSSaveUserData((OS_EVENT *)sem->handler, sem);

	trace_sem_create(binary);
	
	return (os_semaphore_id)sem;
}


os_semaphore_id osi_createmutexsemaphore(const char *name)
{
//BKNOTE: uCOS-II에서 제공하는 OSMutexCreate() 사용할 필요가 있는지 확인 요함
#if USE_BCM_MUTEX
	SemType *sem;
	BERR_Code  eResult = BERR_SUCCESS;
	BKNI_MutexHandle hMutex = NULL;

	sem=(SemType *)osi_calloc(sizeof(SemType));
	if (sem==NULL) {
		return 0;
	}	

	eResult = BKNI_CreateMutex(&hMutex);
	if ((BERR_SUCCESS != eResult) || (NULL == hMutex))
	{
		osi_free(sem);
		return 0;
	}
	strncpy(sem->name, name, SIZE_SEM_NAME-1);
	sem->type=SEM_MUTEX;
	sem->nRecursive=0;
	sem->owner=0;
	sem->hMutex=hMutex;
#else
	SemType *sem;

	sem=(SemType *)osi_calloc(sizeof(SemType));
	if (sem==NULL) {
		return 0;
	}	

	strncpy(sem->name, name, SIZE_SEM_NAME-1);
	sem->type=SEM_MUTEX;
	sem->nRecursive=0;
	sem->owner=0;
	sem->handler=(OS_EVENT*)OSSemCreate(1);
	if (sem->handler == 0) {
		osi_free(sem);
		return 0;
	}
//	OSSaveUserData((OS_EVENT *)sem->handler, sem);
#endif
	trace_sem_create(mutex);
	
	return (os_semaphore_id)sem;
}
	

#if COMMENT
_______(){}
#endif

/* 
	free list of reuse semaphore.
	linked list. LIFO.
*/

void *g_os_free_sem_list;

int osi_free_reuse_sem_count(void)
{
	UINT32 flags;
	SemType *sem;
	int count = 0;
	
	flags = MIPS_SetInterrupts(OS_DISABLE); // OS_ENTER_CRITICAL(flags);

	sem = (SemType *) g_os_free_sem_list;
	while (sem) {
		count++;
		sem = (SemType *)sem->next;
	}

	MIPS_SetInterrupts(flags);// OS_EXIT_CRITICAL(flag);

	return count;
}

os_semaphore_id osi_create_reuse_semaphore(char *name, int count)
{
	os_semaphore_id sid;
	UINT32 flags;
	SemType *sem = NULL;
	
	flags = MIPS_SetInterrupts(OS_DISABLE); // OS_ENTER_CRITICAL(flags);

	if (g_os_free_sem_list) {
		sem = (SemType *)g_os_free_sem_list;
		g_os_free_sem_list = sem->next;
	}

	MIPS_SetInterrupts(flags);// OS_EXIT_CRITICAL(flag);

	if (sem && sem->handler) {
		// ok! reuse it!
		strncpy(sem->name, name, SIZE_SEM_NAME-1);
		sem->type=SEM_COUNTING;
		sem->nRecursive=0;
		sem->owner=0;
		sem->next = 0;
//BKNOTE: 이부분을 어떻게 처리해야 하나..		OSSaveUserData((OS_EVENT *)sem->handler, sem);
		
		trace_sem_create(count);

		// match initial 'count' value.
		((OS_EVENT *)(sem->handler))->OSEventCnt = count;

		sid = (os_semaphore_id)sem;
	}
	else {
		sid = osi_createcountingsemaphore(name, 0, count);
	}

	return sid;
}

void osi_delete_reuse_semaphore(os_semaphore_id sid)
{
	/* necessary condition for deleting.
		no task should be pending for this semaphore.
	*/
	UINT32 flags;
	SemType *sem = (SemType *)sid;

	if (sem->type != SEM_COUNTING) {
		printf("!! %s: only csem should be reusable.\n", __FUNCTION__);
		return;
	}

	flags = MIPS_SetInterrupts(OS_DISABLE); // OS_ENTER_CRITICAL(flags);
	
	sem->next = (void *) g_os_free_sem_list;
	g_os_free_sem_list = sem;

	MIPS_SetInterrupts(flags);// OS_EXIT_CRITICAL(flag);

}


#if COMMENT
____MsgQ____(){}
#endif


#define MFIFO_INIT(fifo, size) do {(fifo)->bf_wrap=0; \
	(fifo)->bf_read=(fifo)->bf_write=0;\
	(fifo)->bf_last=(size);}while(0)

#define MFIFO_WRITE_PTR(fifo) ((fifo)->q_buf + ((fifo)->bf_write)*((fifo)->item_sz))
#define MFIFO_READ_PTR(fifo)  ((fifo)->q_buf + ((fifo)->bf_read)*((fifo)->item_sz))


// availabe free slots in queue.
#define MFIFO_WRITE_PEEK(fifo) \
	/* |====W---R===| */ ((unsigned)(((fifo)->bf_write < (fifo)->bf_read) ? (fifo)->bf_read - (fifo)->bf_write : ( \
	/* |---R===W---| */ ((fifo)->bf_write > (fifo)->bf_read) ? (fifo)->bf_last - (fifo)->bf_write  : ( \
	/* |---RW---| */ (fifo)->bf_wrap ? 0 : (fifo)->bf_last - (fifo)->bf_write))))

// current message items in queue.
#define MFIFO_READ_PEEK(fifo) \
	/* |====W---R===| */ ((unsigned)(((fifo)->bf_write < (fifo)->bf_read) ? (fifo)->bf_last - (fifo)->bf_read : ( \
	/* |---R===W---| */ ((fifo)->bf_write > (fifo)->bf_read) ? (fifo)->bf_write - (fifo)->bf_read : ( \
	/* |---RW---| */ (fifo)->bf_wrap ? (fifo)->bf_last - (fifo)->bf_read:0))))

/// write to fifo. for our case, increment size is always 1.
#define MFIFO_WRITE_COMMIT(fifo) do { \
	/*BDBG_ASSERT(MFIFO_WRITE_PEEK(fifo) >= 1);*/  \
	(fifo)->bf_write += 1; \
	if ((fifo)->bf_write >= (fifo)->bf_last) {(fifo)->bf_write = 0;(fifo)->bf_wrap++;}  \
	} while(0)

/// read out from fifo. for our case, increment size is always 1.
#define MFIFO_READ_COMMIT(fifo) do { \
	/*BDBG_ASSERT(MFIFO_READ_PEEK(fifo) >= 1);*/  \
	(fifo)->bf_read += 1; \
	if ((fifo)->bf_read >= (fifo)->bf_last) {(fifo)->bf_read = 0;(fifo)->bf_wrap--;}  \
	} while(0)


/*
	MsgqType 도 SemType 의 앞부분과 동일한 구조를 취한다.
	모두 uCOS 입장에서 동일한 osi event type으로 처리 가능.
*/

typedef struct 
{
	UINT8 type;
	UINT32 handler;  // actually, this is os couting semaphore
	char name[SIZE_SEM_NAME+1];
	//---------
	UINT32 dummy_guard;
	os_messagequeue_id csem;    // counting semaphore for messages
	os_messagequeue_id mutex;   // access mutex for this queue.
	
	UINT16 item_sz;  // only support uniform size.
	UINT16 max_num_item; // maximum number of items that this queue can have.

	//UINT16 num_item; // number of message items currently exist in queue.

	// fifo implementation.
	//struct osi_q_fifo fifo;

	UINT16 bf_write; // this is index, not pointer.
	UINT16 bf_read;
	UINT16 bf_last;  // same as max_num_item.
	int    bf_wrap;
	
	UINT8 *q_buf;
	
} MsgqType;


void osi_printmessagequeue(MsgqType *msgq)
{
}

void osi_deletemessagequeue(os_messagequeue_id qid)
{
#if USE_BCM_MSG_QUEUE
	b_queue_t* p_msg_queue = (b_queue_t*)(qid);
	bos_delete_queue(p_msg_queue);
	OS_FreeDirect(&p_msg_queue);
#else
	printf("!! %s: delete queue not supported!!\n", __FUNCTION__);
#endif
}

//BKTODO: ucOS-II에서 제공하는 OSQCreate/OSQPost/OSQPend 등을 warp한 bos_create_queue/bos_post_event/bos_pend_event로 교체할지 여부.
os_messagequeue_id osi_createmessagequeue(const char *name, UINT32 options, 
                      UINT32 maxMessages, UINT32 maxMessageLength)
{
#if USE_BCM_MSG_QUEUE
	b_queue_t*	p_msg_queue= (b_queue_t*)OS_Malloc(sizeof(b_queue_t));
	//BKNOTE: OS가 사용할 memory를 할당함.. 주의 (osi_deletemessagequeue 에서도 해제되지 않는다.. )
	b_event_t * p_bufferQ = (b_event_t *)OS_Malloc(maxMessages*maxMessageLength);
	if(bos_create_queue(p_msg_queue, p_bufferQ, maxMessages)!=b_ok)
	{
		printf("FATAL: bos_create_queue\n");
	}else
	{
		printf("Q[%s] create 0x%x\n", p_msg_queue);
	}
	return (os_messagequeue_id)p_msg_queue;
#else
	MsgqType *msgq;
	char buf[SIZE_SEM_NAME+10];
	os_semaphore_id csem = 0;
#if !BUGFIX_MSGQ
	os_semaphore_id mutex = 0;
#endif

	if (maxMessages > 65535) {
		printf("!! %s: max msg exceed limit\n", __FUNCTION__);
		return (os_messagequeue_id)NULL;
	}
	
	if (name == NULL) name = "";

	// create csem..
	strcpy(buf, "S:");
	strncpy(buf+2, name, SIZE_SEM_NAME-2);
	csem = osi_createcountingsemaphore(buf, 0, 0);
	if (csem == 0) {
		return (os_messagequeue_id)NULL;
	}

#if !BUGFIX_MSGQ
	// create mutex..
	strcpy(buf, "M:");
	strncpy(buf+2, name, SIZE_SEM_NAME-2);
	mutex = osi_createmutexsemaphore(buf);
	if (mutex == 0) {
		osi_deletesemaphore(csem);
		return (os_messagequeue_id)NULL;
	}
#endif

	// to avoid memory frag, we alloc only one chunk of memory.
	msgq = (MsgqType *) osi_calloc(sizeof(MsgqType) + maxMessages*maxMessageLength);
	if (msgq == NULL) {
		printf("!! %s: out of mem for queue\n", __FUNCTION__);
		// oops! we cannot delete mutex sem!
		osi_deletesemaphore(csem);
#if !BUGFIX_MSGQ
		osi_deletesemaphore(mutex);
#endif
		return (os_messagequeue_id)NULL;
	}
	
	msgq->type = SEM_MSGQ;
	msgq->handler = ((SemType *)csem)->handler;

	msgq->dummy_guard = 0xcafe2008;
	msgq->csem = csem;
#if !BUGFIX_MSGQ
	msgq->mutex = mutex;
#endif

	msgq->item_sz = maxMessageLength;
	msgq->max_num_item = maxMessages;

	//msgq->num_item = 0;
	msgq->q_buf = ((UINT8 *)msgq + sizeof(MsgqType));

	MFIFO_INIT(msgq, msgq->max_num_item);

	if (name && name[0])
		strncpy(msgq->name, name, SIZE_SEM_NAME-1);
	else
		msgq->name[0] = 0;
	
	// override mutex user data with queue's pointer.
//	OSSaveUserData((OS_EVENT *)msgq->handler, msgq);

	return (os_messagequeue_id)msgq;
#endif
}

int	osi_sendmessage(os_messagequeue_id qid, void *buffer, int nBytes)
{
#if USE_BCM_MSG_QUEUE
	b_queue_t* p_msg_queue = (b_queue_t*)(qid);
	printf("Q send 0x%x\n", p_msg_queue);
	bos_post_event(*p_msg_queue, (b_event_t *)buffer);
	return DHL_OK;
#else

	DHL_RESULT result = DHL_OK;
	MsgqType *msgq = (MsgqType *)qid;
	
#if BUGFIX_MSGQ
	UINT32 flags;
#endif

#if BUGFIX_MSGQ
	flags = MIPS_SetInterrupts(OS_DISABLE); // OS_ENTER_CRITICAL(flags);
#else
	osi_takemutexsemaphore_wait(msgq->mutex, WAIT_FOREVER);
#endif

	if (MFIFO_WRITE_PEEK(msgq) > 0)
	{
		memcpy(MFIFO_WRITE_PTR(msgq), buffer, min(nBytes, msgq->item_sz));
		MFIFO_WRITE_COMMIT(msgq);

#if OSAL_DEBUG
		printf("#### queue send, q %x, '%s' h %x, r%d w%d\n", 
			msgq, msgq->name, msgq->handler, msgq->bf_read, msgq->bf_write);
#endif
		osi_givesemaphore(msgq->csem); // now, some other task will wake up.
	}
	else
	{
		// fifo full!
		result = DHL_FAIL_NOT_AVAILABLE;
	}

#if BUGFIX_MSGQ
	MIPS_SetInterrupts(flags);// OS_EXIT_CRITICAL(flags);
#else
	osi_givemutexsemaphore(msgq->mutex);
#endif

	return result;
#endif
}

int osi_receivemessage(os_messagequeue_id qid, void *msgBuf)
{
#if USE_BCM_MSG_QUEUE
	b_queue_t* p_msg_queue = (b_queue_t*)(qid);
	b_event_t * p_event = bos_pend_event(*p_msg_queue,-1);
	if(p_event==NULL)
	{
		msgBuf = NULL;
		return DHL_FAIL_TIMEOUT;
	}else
	{
		msgBuf = (void *)p_event;
		return DHL_OK;
	}
#else
	return osi_receivemessage_wait(qid, msgBuf, WAIT_FOREVER);
#endif
}

/*
	note!
	receive message usually used in one task.
*/
//int osi_receivemessage_wait(os_messagequeue_id qid, void *msgBuf, int maxLen, int *msgLen, int ticks)
int osi_receivemessage_wait(os_messagequeue_id qid, void *msgBuf, int ticks)
{
#if USE_BCM_MSG_QUEUE
	b_queue_t* p_msg_queue = (b_queue_t*)(qid);
	b_event_t * p_event = bos_pend_event(*p_msg_queue,ticks /*not ticks, it's msec*/);
	if(p_event==NULL)
	{
		msgBuf = NULL;
		return DHL_FAIL_TIMEOUT;
	}else
	{
		msgBuf = (void *)p_event;
		return DHL_OK;
	}
#else

	DHL_RESULT result = DHL_OK;
	MsgqType *msgq = (MsgqType *)qid;
	BOOL bexit = FALSE;

#if BUGFIX_MSGQ
	UINT32 flags;
#endif

	while (bexit == FALSE)
	{
		result = osi_takesemaphore_wait(msgq->csem, ticks);

		if (result == DHL_FAIL_TIMEOUT)
			break;

		if (result != DHL_OK) {
			printf("!! %s: unexpected err 0x%x in take csem\n", __FUNCTION__, result);
			break;
		}
#if OSAL_DEBUG		
		printf("#### queue receive, q %x, '%s' h %x\n", msgq, msgq->name, msgq->handler);
#endif
		// if csem is taken, it means that there are available messages in the queue.

#if BUGFIX_MSGQ
		flags = MIPS_SetInterrupts(OS_DISABLE); // OS_ENTER_CRITICAL(flag);
#else
		osi_takemutexsemaphore_wait(msgq->mutex, WAIT_FOREVER);
#endif

		if (MFIFO_READ_PEEK(msgq) > 0)
		{
//			int copyLen = min(maxLen, msgq->item_sz);
			int copyLen  = msgq->item_sz;
			memcpy(msgBuf, MFIFO_READ_PTR(msgq), copyLen);
			MFIFO_READ_COMMIT(msgq);

			result = DHL_OK;
			bexit = TRUE;
		}
		else
		{
			// fifo empty??
			printf("!! %s: csem taken, but queue empty?\n", __FUNCTION__);
			osi_printmessagequeue(msgq);
		}

#if BUGFIX_MSGQ
		MIPS_SetInterrupts(flags);// OS_EXIT_CRITICAL(flags);
#else
		osi_givemutexsemaphore(msgq->mutex);
#endif

	}

	return result;
#endif
}


int osi_receivemessage_nowait(os_messagequeue_id qid, void *msgBuf)
{
	return osi_receivemessage_wait(qid, msgBuf, NO_WAIT);
}


#if COMMENT
____Memory____(){}
#endif


#if OSAL_HEAP_DEBUG

#warning build osal with OSAL_HEAP_DEBUG option.

void *os_dbg_malloc(int size, char *file, int line)
{
	// just call ministd api.
	return malloc_align_dbg(size, 2, file, line);
}

void *os_dbg_calloc(int n, int m, char *file, int line)
{
	void *p;
	p = malloc_align_dbg(n*m, 2, file, line);
	if (p)
		memset(p, 0, n*m);

	return p;
}

void os_dbg_free(void *ptr, char *file, int line)
{
	void **pptr = (void **)ptr;
	
	if (pptr == NULL) return;

	// cafrii 081006 add
	if (*pptr == NULL) return; // already free()'ed pointer?
	
	free_dbg(*pptr, file, line);

	*pptr = NULL;
}

#else // OSAL_HEAP_DEBUG

#undef malloc
#undef calloc
#undef free

void *OS_Malloc(int size)
{
	void* p = malloc(size);
	return p;
}

void OS_FreeDirect(void *ptr)
{
	free(ptr);
}

void *OS_Calloc(int n, int m)
{
	void *p;
	p = OS_Malloc(n*m);
	if (p)
		memset(p, 0, n*m);

	return p;
}

void OS_Free(void *ptr)
{
	void *p;
	
	if (ptr == NULL) return;
	p = *(void **)ptr;
	OS_FreeDirect(p);
}

#endif

extern bcm_heap_t *g_p_sdram_heap;

void dump_heap(int threshold)
{
#ifdef BCM_DEBUG
	// show all heap blocks, greater than threshold.
	mem_reportbrief_ex(g_p_sdram_heap, threshold);
#endif
}


void os_heap_status(dhl_heap_status *pstat)
{
#ifdef BCM_DEBUG

	struct bcm_heap_status bhs;

	memset(pstat, 0, sizeof(dhl_heap_status));
	
	if (mem_status(g_p_sdram_heap, &bhs) == 0) {
		pstat->size_heap = bhs.size_heap;
		pstat->num_alloc_chunk = bhs.num_alloc_chunk;
		pstat->size_alloc = bhs.size_alloc;
		pstat->num_free_chunk = bhs.num_free_chunk;
		pstat->size_free = bhs.size_free;
	}
#endif
}


#if COMMENT
____Debug____(){}
#endif

#undef printf  // do not add tag.
#if 0
char *osi_get_eventinfo(void *p, char *outbuf, int outbuflen)
{
	int k;
	OS_EVENT *pevent = (OS_EVENT *)p;
	SemType *sem;
	UBYTE *t;
	char buf[3*16 + 20];

	if (pevent == NULL) {
		//printf("\t --> no event\n");
		outbuf[0] = 0;
		return outbuf;
	}

	sem = (SemType *)OSGetUserData(pevent);
	if (sem == NULL) {
		// this event is not created by our OSAL. maybe it belongs driver code.
		// then, we track more using pevent itself.
		snprintf(outbuf, outbuflen, "%s event %x", 
			pevent->OSEventPtr ? "que/mbox" : "sem", // uCOS internal.
			(int)pevent);
		return outbuf;
	}

	buf[0] = 0;
	if (pevent)
	{
		t = pevent->OSEventTbl;
		for (k=0; k<63; k++) {
			if (t[k/8] & (1<<(k%8)))
				sprintf(buf + strlen(buf), "%d ", k);
		}
		// this is pending task list.
	}

	snprintf(outbuf, outbuflen, "%s '%s' w-list %s",
			sem->type == SEM_MUTEX ? "mtx" :
			sem->type == SEM_BINARY ? "bsm" : 
			sem->type == SEM_COUNTING ? "csm" :
			sem->type == SEM_MSGQ ? "que" : "???",
			sem->name, 
			buf);

	return outbuf;
}
#endif

void osi_show_taskinfo(int level)
{
//	bos_print_taskinfo_ex(level, osi_get_eventinfo);
	bos_print_taskinfo();
}


/* end of file */