/*******************************************************************
 * DMW_Mutex.c
 *
 * General Purpose Mutex
 *
 * Copyright 2003 Digital STREAM Technology, Inc.
 * All Rights Reserved
 *
 * $Id: DMW_Mutex.c,v 0.12  2004 cafrii Exp $
 *
 ********************************************************************/



#include "DMW_Platform.h"

#if 1
//#include <string.h>
#endif

#include "DMW_Mutex.h"


DHL_MODULE("$mtx", 0);


#define DMW_MUTEX_TEST 1




#if COMMENT

____Example_Code____(){}

/*   Mutex = { SemID, Owner, lockCnt, FailCnt, UseOsMutex, Name, flag,        traceLvl }
*/
DMW_MUTEX 
  mcmMutex = { 0,     0,     0,       0,       FALSE,  "McmMtx", OS_SEM_PRIO, 1, };

STATUS lock_mcm(int timeout)
{
	return DMW_LockMutexWait(&mcmMutex, timeout);
}

void unlock_mcm()
{
	DMW_UnlockMutex(&mcmMutex);
}

#endif /*.......................... */


void DMW_PrintMutex(DMW_MUTEX *pMutex)
{
	DHL_OS_TASK_INFO tInfo;

		DHL_OS_Printf("\t  pMutex :   0x%x\n", pMutex);
		
	if (pMutex) {
		DHL_OS_Printf("\t  semId:     0x%x\n", pMutex->semId);
		DHL_OS_Printf("\t  lockCount: %d\n", pMutex->lockCount);
		DHL_ASSERT(DHL_OS_GetTaskInfo(DHL_OS_GetTaskID(), &tInfo)==DHL_OK
			, "!!DHL_OS_GetTaskInfo Error");
		DHL_OS_Printf("\t  ownerTask: 0x%x, %s\n", pMutex->ownerTaskId, tInfo.name);
		DHL_OS_Printf("\t  FailCount: %d\n", pMutex->initFailCount);
		DHL_OS_Printf("\t  name:      %s\n", pMutex->name);
		DHL_OS_Printf("\t  %sMutex, traceLvl %d, %s\n", pMutex->useOsMutex ? "Os" : "Mw", 
					pMutex->traceLevel, pMutex->flag & OS_SEM_PRIO ? "Priority" : "FIFO");
	}
		DHL_OS_Printf("\n");
}


/* debug util */
void DMW_SetMutexTraceLevel(DMW_MUTEX *pMutex, int traceLevel)
{
	if (pMutex && pMutex->semId)
		pMutex->traceLevel = traceLevel;
		
	DMW_PrintMutex(pMutex);
}

/* debug util */
DHL_OS_TASK_ID DMW_GetOwnerTaskId(DMW_MUTEX *pMutex)
{
	if (pMutex && pMutex->semId && pMutex->lockCount > 0)
		return pMutex->ownerTaskId;
	
	return 0;
}

STATUS DMW_InitMutex(DMW_MUTEX *pMutex, char *name)
{
	DHL_OS_SEMA_ID mysema4;
	
	if (pMutex == NULL) {
		dprint(0, "!! Null argument in DMW_InitMutex\n");
		return statusInvalidArgument;
	}
	
	/* pSem에 있는 sema4가 제대로 된 것인지 확인한다. */
	
	if (pMutex->semId) {
		dprint(2, "Sema4 %x, %s Already inited.\n", pMutex->semId, pMutex->name);
		return statusOK;   /* already initialized. do nothing. */
	}
	
	if (pMutex->initFailCount < 5)
	{
		if (name == NULL || name[0] == 0) {
			/* 이름을 지정하지 않았을 경우 이 함수에서 임의 이름을 주는것도 괜찮다. */
			/* sprintf(pMutex->name, "%s%d", OS_TaskName(0), DHL_OS_GetMsCount()%10); */
		}
		else {
			strncpy(pMutex->name, name, MAX_MUTEX_NAME-1);
			pMutex->name[MAX_MUTEX_NAME-1] = 0;
		}
		
		if (pMutex->useOsMutex) {
			mysema4 = DHL_OS_CreateMutexSemaphore(pMutex->name);
		}
		else {
			mysema4 = DHL_OS_CreateBinarySemaphore(pMutex->name, OS_SEM_PRIO, TRUE);
										/* OS_SEM_FIFO --> OS_SEM_PRIO  */
										/* 아무나 먼저 급한 task가 print를 할 수 있도록. */
		}
		
		if (mysema4 == (DHL_OS_SEMA_ID)NULL) {	
			dprint(0, "!! Sema4 '%s' creation failed.\n", pMutex->name);
			pMutex->initFailCount++;
				/* semaphore가 없어도 일단 진행은 시키도록 한다. */

			return statusOutOfResource;
		}

		/* Semaphore 생성 성공.  이제 생성된 sema4를 pSem에 안전하게 assign한다.
		
		// ThreadX에서는 OS_LockTask 자체가 Mutex를 이용하는 방식으로 구현되었기 때문에
		// InitMutex에서 다시 OS_LockTask를 호출할 수 없다..
		*/
		
		if (1) {
			UINT32 mask;
			mask = DHL_OS_DisableInterrupts();
			if (pMutex->semId == 0) {
				/* OS_LockTask 된 상태에서 초기화 한다. */
				pMutex->semId = mysema4;
				mysema4 = (DHL_OS_SEMA_ID)NULL;
			}
			DHL_OS_RestoreInterrupts(mask);
		}

		/* OS_LockTask/OS_UnlockTask 사이에서 swap을 했는데도 아직 그대로이면 
		// 이미 pSem이 다른 태스크에 의해 생성이 된 경우이다. 중복 생성되었으므로 하나를 삭제해야 한다.
		*/
		if (mysema4) {  
			dprint(0, "!! Simultaneous '%s' Sema4 Creation detected %x. Safe release ours %x\n", 
						pMutex->name,
						pMutex->semId, mysema4);
			DHL_OS_DeleteSemaphore(mysema4);
			mysema4 = (DHL_OS_SEMA_ID)NULL;
		}
		else {
			dprint(2, "Sema4 %x, '%s' created. DMW_Mutex 0x%x\n", 
				pMutex->semId, pMutex->name, (int)pMutex);
		}
		
		return statusOK;
	}
	else {
		
		return statusOutOfResource;
	}
}


#if 0 /* for reference */
		
	Table 2-1:  Task State Transitions
	
	--------------------------------------------------------------------------------
	State Symbol Description 
	--------------------------------------------------------------------------------
	 
	READY  The state of a task that is not waiting for any resource other than the CPU.  
	PEND  The state of a task that is blocked due to the unavailability of some resource.  
	DELAY  The state of a task that is asleep for some duration.  
	SUSPEND  The state of a task that is unavailable for execution. This state is used primarily for debugging. 
		Suspension does not inhibit state transition, only task execution. Thus pended-suspended tasks can still 
		unblock and delayed-suspended tasks can still awaken.   
	DELAY + S  The state of a task that is both delayed and suspended.  
	PEND + S  The state of a task that is both pended and suspended.  
	PEND + T  The state of a task that is pended with a timeout value.  
	PEND + S + T  The state of a task that is both pended with a timeout value and suspended.  
	state + I  The state of task specified by state, plus an inherited priority.  
		
#endif 

#ifndef WIND_READY
	#define WIND_READY		0x00	/* ready to run */
	#define WIND_SUSPEND	0x01	/* explicitly suspended */
	#define WIND_PEND		0x02	/* pending on semaphore */
	#define WIND_DELAY		0x04	/* task delay (or timeout) */
	#define WIND_DEAD		0x08	/* dead task */
#endif


STATUS DMW_LockMutex(DMW_MUTEX *pMutex)
{
	return DMW_LockMutexWait(pMutex, 0x7fffffff); /* wait forever */
}

STATUS DMW_LockMutexWait(DMW_MUTEX *pMutex, int timeout)
{
	/* timeout 0을 지정하면 WAIT_FOREVER가 아니라 NoWait가 되버림에 유의.
	*/ 
	int nWaitCount = 0;
	int err;
	DHL_OS_TASK_ID mytid;
//	DHL_OS_TASK_INFO tInfo;

	int ticksToWait, ticksLeft, tickMonitorPeriod;
	
	mytid = DHL_OS_GetTaskID(); /* 현재 task ID */
	
	/* mutex를 생성하는 과정은 약간은 '부담'되는 일이다. (OS_LockTask/OS_UnlockTask, sema4 리스트 관리 등..)
	// 만약 리소스 부족 등의 이유로 sema4생성이 실패했었다면, 그 이후 계속 생성을 시도 하는 것 또한 
	// 비슷한 이유로 실패할 가능성이 크다.
	// 일정 횟수 이상 sema4 생성에 실패한 경우라면 이후에는 다시 생성 시도를 하지 말도록 한다.
	*/
	
	if (pMutex == NULL) {
		dprint(0, "!! NULL sema4 in DMW_LockMutex\n");
		return statusInvalidArgument;
	}
	
	if (pMutex->semId == 0) {
		STATUS r = DMW_InitMutex(pMutex, 0);
		dprint(2, "Sema4 '%s' created, result %d\n", pMutex->name, r);
	}

	/* Semaphore wait에서 OS_TakeSemaphore() 함수를 사용하지 않고
	// 주기적으로 wakeup 하여 Semaphore Take 작업 상황이 어떤지 보고하도록 한다.
	// 디버깅 용도이므로 check 주기는 충분히 커도 상관 없다. 1초 미만의 값은 사용하지 말도록 하자.
	*/ 
	ticksLeft = timeout;
	tickMonitorPeriod = 1000;
	
	while (1) 
	{
		/* mutex semaphore의 multiple-take를 흉내내기 위해서 wait 하기 전에 이미 자신의 task에서
		// semaphore가 take되었는지 체크한다.
		*/
		if (pMutex->useOsMutex == 0 && pMutex->ownerTaskId == mytid && pMutex->lockCount > 0)
		{
			/* 이미 현재 task에서 이 Sema4를 take하고 있다고 판단.. */
			pMutex->lockCount++;

			if (pMutex->traceLevel)
				dprint(2, "+ FakeLock '%s' B-sema4 in task %08x, lock count %d\n", pMutex->name, mytid, pMutex->lockCount);
			
			return statusOK;
		}
		
		ticksToWait = ticksLeft > tickMonitorPeriod ? tickMonitorPeriod : ticksLeft;
		
		if (ticksToWait <= 0)
			err = DHL_OS_TakeSemaphore(pMutex->semId, 0);
		else
			err = DHL_OS_TakeSemaphore(pMutex->semId, ticksToWait);
		
		if (err == 0) {
			/* OK! semaphore is available and we take it! */
			pMutex->ownerTaskId = mytid;
			pMutex->lockCount++;
			if (pMutex->traceLevel)
				dprint(2, "+ Lock '%s' %c-sema4 in task %08x, lock count %d\n", pMutex->name, 
						pMutex->useOsMutex ? 'M' : 'B', mytid, pMutex->lockCount);
				
			/* 원하는 목적을 달성했으므로 루프 종료. */
			return statusOK;
		}

		ticksLeft -= ticksToWait;

		if (timeout > 0 && ticksLeft <= 0) {
			/* timeout 발생..
			*/
			if (pMutex->traceLevel)
				dprint(2, "'%s' %c-sema4 wait timeout!\n", pMutex->name, pMutex->useOsMutex ? 'M' : 'B');
			return statusTimeout;
		}
		
		/* Semaphore 모니터링 코드..
		//
		// sema4를 기다리는 동안 어느 태스크가 현재 sema4를 점유하고 있는지 표시.
		// 혹시 sema4 관리가 꼬여서 hang될 경우 유용하게 사용될 수 있다.
		// 메세지를 표시해주는 주기는 더 길게 잡아도 상관없음.
		*/
		if (pMutex->traceLevel)		{
			//DHL_ASSERT(DHL_OS_GetTaskInfo(pMutex->ownerTaskId, &tInfo)==DHL_OK
			//	, "!!DHL_OS_GetTaskInfo Error");
//			int i=3;
			//dprint(2, "[%x] '%s' Sema4 owner: %s, %x, wait %d\n", 
			//	mytid, pMutex->name, 
			//	pMutex->ownerTaskId ? tInfo.name: "None",
			//	pMutex->ownerTaskId, 
			//	nWaitCount);
		}
		++nWaitCount;  /* cafrii 060919 fix.. */
		/*
		// Error Detection code
		//
		// 상식적인 시간 이상으로 Semaphore가 계속 다른 task에 의해 점유되고 있다면 이것은 문제다.
		// Sema4 점유하고 있는 태스크 정보를 주기적으로 출력하도록 하여 디버깅에 도움을 줄수 있도록 한다.
		*/
		if (nWaitCount > 10 && pMutex->ownerTaskId)
		{
			// cafrii 090717
			// 그냥 단순하게 특정 mutex lock 이 비정상적으로 길어지고 있다는 사실만 알려주고,
			// 개발자는 shell 에서 별도의 디버깅 루틴을 이용하여 정보를 획득하도록 하자.
			

			/* 그 밖에 더 추가 정보를 얻을 수 있다면 이곳에 추가. */
			
			/* 또는 자동으로 문제를 Recover할 수 있는 방법이 있다면 이곳에 추가. */
		}
		
		
	} /* end of Same4 Wait Loop */
}



void DMW_UnlockMutex(DMW_MUTEX *pMutex)
{
	DHL_OS_TASK_ID mytid;
//	DHL_OS_TASK_INFO tInfo;

	mytid = DHL_OS_GetTaskID();
	
	if (pMutex == NULL) {
		dprint(0, "!! NULL Sema4 in DMW_UnlockMutex\n");
		return;	
	}
	
	if (pMutex->semId == 0) {
		dprint(0, "!! Uninitialized Sema4 in DMW_UnlockMutex\n");
		return;	
	}
	
	pMutex->lockCount--;

	if (pMutex->traceLevel) {
		if (pMutex->useOsMutex == 0 && pMutex->lockCount > 0)
			dprint(2, "- FakeUnlock '%s' B-sema4 in task %08x, lock count %d\n", 
				pMutex->name, mytid, pMutex->lockCount);
		else
			dprint(2, "- Unlock '%s' %c-sema4 in task %08x, lock count %d\n", 
				pMutex->name, pMutex->useOsMutex ? 'M' : 'B', mytid, pMutex->lockCount);
	}
	
	if (pMutex->lockCount < 0) {
		dprint(0, "!! Warning!! Negative lock count %d !, name=%s\n", pMutex->lockCount, pMutex->name);
	}
	
	if (mytid != pMutex->ownerTaskId) {
		//DHL_ASSERT(DHL_OS_GetTaskInfo(pMutex->ownerTaskId, &tInfo)==DHL_OK
		//	, "!!DHL_OS_GetTaskInfo Error");
		//dprint(0, "!! Warning!! try unlock from not owner! current owner %s, %08x\n", 
		//		tInfo.name, pMutex->ownerTaskId);
	}
	
	if (pMutex->lockCount <= 0) {
		pMutex->ownerTaskId = 0;
	}
	
	/* Mutex semaphore의 경우라면 unlock 할때마다 give를 하고,
	// Binary sema4라면 모든 lock count가 풀릴 경우에만 give를 한다.
	*/
	if (pMutex->useOsMutex || pMutex->lockCount <= 0)
		DHL_OS_GiveSemaphore(pMutex->semId);
}


void DMW_DeleteMutex(DMW_MUTEX *pMutex)
{
	if (pMutex == NULL) {
		dprint(0, "!! NULL Mutex in DMW_UnlockMutex\n");
		return;	
	}
	
	if (pMutex->semId == 0) {
		dprint(0, "!! NULL semId in DMW_UnlockMutex\n");
		return;
	}

	dprint(2, "Sema4 '%s' deleted..\n", pMutex->name);
	
	if (1)
	{
		// cafrii 091221 fix
		// isr lock (disabled) 상태에서 os_deletesemaphore() 등을 직접 호출하지 않는다.
		// linux usermode 같은 경우 memfree 같은 함수를 isrlock 상태에서 호출할 수 없음.
#if 1
		DHL_OS_SEMA_ID sem;
		UINT32 mask = DHL_OS_DisableInterrupts();
		sem = pMutex->semId;
		pMutex->semId = 0;
		DHL_OS_RestoreInterrupts(mask);

		if (sem)
			DHL_OS_DeleteSemaphore(sem);
#else
		UINT32 mask = DHL_OS_DisableInterrupts();
		DHL_OS_DeleteSemaphore(pMutex->semId);
		pMutex->semId = 0;
		DHL_OS_RestoreInterrupts(mask);
#endif
	}
}





#if 0
________()
#endif



#if DMW_REGISTER_DEBUG_SYMBOL

static DHL_SymbolTable MutexSymbols[] =
{
	/*---- functions */
	/* DHL_FNC_SYM_ENTRY(Dmc_StopVideo), */
	
	/*---- variables */
	//DHL_VAR_SYM_ENTRY(g_Trace_bMutexDebug),
	0
};

#endif /* DMW_REGISTER_DEBUG_SYMBOL */


void DMW_RegisterMutexSymbols()
{
#if DMW_REGISTER_DEBUG_SYMBOL
	DHL_DBG_RegisterSymbols(MutexSymbols, DHL_NUMSYMBOLS(MutexSymbols));
#endif
}






#if 0
________()
#endif


/*--------------------------------------------------------------------------------------------
//
//  OS Semaphore debugging..
*/


/*=================================================================
//
//  OS Semaphore Monitoring Task
//
//  주기적으로 Semaphore 감시하여 오동작 하는 Semaphore 정보 출력
*/


#if COMMENT
____TEST____(){}
#endif


#if DMW_MUTEX_TEST

/*=================================================================*/

//#include <string.h>  /* rand(), srand()  */

int gStopMutexTest = FALSE;


/* Mutex = {  SemID, Owner, lockCnt, FailCnt, UseOsMutex, Name, flag, trace } */
DMW_MUTEX g_TestMutex0 = { 0, 0, 0, 0, TRUE, "Sample", 0, 1 };
DMW_MUTEX *g_TestMutex = &g_TestMutex0;

/* 
	trace level 1이므로, 이 모듈 level 만 충족하면 디버그 메시지가 표시됨.
	테스트 절차:

	Shell> MutexTestInit
	Shell> sml "$MTX" 2
	Shell> TestMutex

	
	Shell> set gStopMutexTest 1  // 테스트 종료 
*/

void MutexTestInit(void)
{
	DHL_DBG_RegisterVarSymbol(DHL_VAR_SYM_ARGS(gStopMutexTest));
}

void MutexTestTask1(UINT32 arg)
{
	DHL_OS_Printf("**** Start Task1 **** \n");
	
	DHL_OS_Delay(rand()%100);

	while (gStopMutexTest == FALSE) 
	{
		DMW_LockMutex(g_TestMutex);
		DHL_OS_Delay(rand()%200);
		
		DMW_UnlockMutex(g_TestMutex);
		DHL_OS_Delay(rand()%100);
	}
	DHL_OS_Printf("**** Stop Task1 **** \n");
	DHL_OS_SelfDeleteTask();
}


void MutexTestTask2(UINT32 arg)
{
	DHL_OS_Printf("**** Start Task2 **** \n");
	
	DHL_OS_Delay(rand()%100);

	while (gStopMutexTest == FALSE) 
	{
		DMW_LockMutex(g_TestMutex);
		DHL_OS_Delay(rand()%200);

		DMW_LockMutex(g_TestMutex);   /* 이중 Lock 테스트.. */
		DHL_OS_Delay(rand()%200);
		
		DMW_UnlockMutex(g_TestMutex);
		DHL_OS_Delay(rand()%100);

		DMW_UnlockMutex(g_TestMutex);
		DHL_OS_Delay(rand()%100);
	}
	DHL_OS_Printf("**** Stop Task2 **** \n");
	DHL_OS_SelfDeleteTask();
}


void MutexTestTask3(UINT32 arg)
{
	DHL_OS_Printf("**** Start Task3 **** \n");
	
	DHL_OS_Delay(rand()%100);
		
	while (gStopMutexTest == FALSE) 
	{
		DMW_LockMutex(g_TestMutex);
		DHL_OS_Delay(rand()%200);
		
		DMW_UnlockMutex(g_TestMutex);
		DHL_OS_Delay(rand()%100);
	}
	DHL_OS_Printf("**** Stop Task3 **** \n");
	DHL_OS_SelfDeleteTask();
}

void TestMutex()
{
	DHL_OS_Printf("g_TestMutex : 0x%x\n", g_TestMutex);
	
	srand(DHL_OS_GetMsCount());

	DHL_OS_CreateTask(MutexTestTask1, "Mtx1", TASK_PRI_DHL_SHELL, 4096, 0);

	DHL_OS_CreateTask(MutexTestTask2, "Mtx2", TASK_PRI_DHL_SHELL+1, 4096, 0);

	DHL_OS_CreateTask(MutexTestTask3, "Mtx3", TASK_PRI_DHL_SHELL+2, 4096, 0);
}

#endif /* DMW_MUTEX_TEST */



/*************************************************************************
  Revision history:

	0.12 2004/7/24   DeleteMutex added, bugfix
	0.11 2004/05/28  add selective debug print
	0.1  2004/01/01  initial coding

**********************************************************************/