/**********************************************************************************
 * msgQ.c
 * coded by hspark@ce.cnu.ac.kr
 * date : 2001/06/23
 * modified by hjahn@ce.cnu.ac.kr
 * date : 2003/03/03
 **********************************************************************************/

#include "kernel\\mk_sys.h"
#include "kernel\\mk_mem.h"
#include "kernel\\mk_msgQ.h"
#include "util\\mk_lib.h"
#include "kernel\\mk_ddi.h"

#ifdef _MK_MSGQUEUE

struct mk_msg_queue_struct *MK_pMsgQueueListHead;
struct mk_msg_queue_struct *MK_pMsgQueueListTail;

VOID 
MK_MsgQueueInitialze(VOID)
{
	MK_FixedMsgQueueInitialze();
	MK_VariableMsgQueueInitialze();
	MK_pMsgQueueListHead = MK_NULL;
	MK_pMsgQueueListTail = MK_NULL;
}

STATUS 
MK_CreateMsgQueue(MK_QUEUE *pQueue, CHAR *pName, VOID *pAddr, ULONG Size, BOOLEAN Type, 
			ULONG MsgSize, BOOLEAN Options)
{	
	STATUS	status;
	INT		Flags;

	pQueue->m_Type = Type;
	pQueue->m_pName = pName;
	
	if(pQueue->m_Type == MK_FIXED_SIZE)
	{
		/* MsgSize is fixed size */
		status = MK_CreateFixedMsgQueue(&pQueue->m_Queue.mu_FixedQueue, MK_NULL, pAddr, Size, 
					MsgSize, Options);
	}
	else
	{
		/* MsgSize is Maximum size */
		status = MK_CreateVariableMsgQueue(&pQueue->m_Queue.mu_VariableQueue, MK_NULL, pAddr, 
					Size, MsgSize, Options);
	}

	if(status == MK_NO_ERROR) {
		Flags = MK_InterruptDisable();		/* Critical Region */

		pQueue->m_pNext = MK_NULL;
		pQueue->m_pPrev = MK_NULL;
		if(MK_pMsgQueueListHead == MK_NULL) {
			MK_pMsgQueueListHead = pQueue;
			MK_pMsgQueueListTail = pQueue;
		}
		else {
			pQueue->m_pPrev = MK_pMsgQueueListTail;
			MK_pMsgQueueListTail->m_pNext = pQueue;
			MK_pMsgQueueListTail = pQueue;
		}

		MK_InterruptRestore(Flags);
	}

	return status;
}

STATUS 
MK_DeleteMsgQueue(MK_QUEUE *pQueue)
{
	int Flags;
	STATUS status;

	if(pQueue->m_Type == MK_FIXED_SIZE)
	{
		status = MK_DeleteFixedMsgQueue(&pQueue->m_Queue.mu_FixedQueue);
	}
	else
	{
		status = MK_DeleteVariableMsgQueue(&pQueue->m_Queue.mu_VariableQueue);
	}

	Flags = MK_InterruptDisable();		/* Critical Region */

	if(MK_pMsgQueueListHead == MK_pMsgQueueListTail)
	{
		MK_pMsgQueueListHead = MK_NULL;
		MK_pMsgQueueListTail = MK_NULL;
	}
	else
	{
		if(pQueue == MK_pMsgQueueListHead)
		{
			MK_pMsgQueueListHead = pQueue->m_pNext;
			MK_pMsgQueueListHead->m_pPrev = MK_NULL;
		}
		else if(pQueue == MK_pMsgQueueListTail)
		{
			MK_pMsgQueueListTail = pQueue->m_pPrev;
			MK_pMsgQueueListTail->m_pNext = MK_NULL;
		}
		else
		{
			pQueue->m_pPrev->m_pNext = pQueue->m_pNext;
			pQueue->m_pNext->m_pPrev = pQueue->m_pPrev;
		}
	}
	pQueue->m_pNext = MK_NULL;
	pQueue->m_pPrev = MK_NULL;

	MK_InterruptRestore(Flags);

	return status;
}

ULONG 
MK_GetFixedMsgQueueBufferSize(MK_QUEUE *pQueue)
{
	return MK_GetFixedMsgQueueAvailableBufferSize(&pQueue->m_Queue.mu_FixedQueue);
}

UINT 
MK_GetFixedMsgQueueCount(MK_QUEUE *pQueue)
{
	return MK_GetFixedMsgQueueMsgCount(&pQueue->m_Queue.mu_FixedQueue);
}


STATUS 
MK_MsgQueuePend(MK_QUEUE *pMsgQueue,  VOID *pMsg, ULONG BufSize, ULONG *pLength, 
				LONG Ticks)
{
	STATUS status;

	if(pMsgQueue->m_Type == MK_FIXED_SIZE)
	{
		status = MK_FixedMsgQueuePend(&pMsgQueue->m_Queue.mu_FixedQueue	, pMsg, BufSize, pLength, Ticks);
	}
	else
	{
		status = MK_VariableMsgQueuePend(&pMsgQueue->m_Queue.mu_VariableQueue, (CHAR **)pMsg, BufSize, pLength, Ticks);
	}

	return status;
}

STATUS 
MK_MsgQueuePost(MK_QUEUE *pMsgQueue, VOID *pMsg, ULONG Length, LONG Ticks)
{
	STATUS status;

	if(pMsgQueue->m_Type == MK_FIXED_SIZE)
	{
		status = MK_FixedMsgQueuePost(&pMsgQueue->m_Queue.mu_FixedQueue, pMsg, Length, Ticks);
	}
	else
	{
		status = MK_VariableMsgQueuePost(&pMsgQueue->m_Queue.mu_VariableQueue, (CHAR *)pMsg, Length, Ticks);
	}

	return status;
}

STATUS
MK_MsgQueueFrontPost(MK_QUEUE *pQueue, VOID *pMsg, ULONG Length, LONG Ticks)
{
	STATUS	status;

	if(pQueue->m_Type == MK_FIXED_SIZE)
	{
		status = MK_FixedMsgQueueFrontPost(&pQueue->m_Queue.mu_FixedQueue, pMsg, Length, Ticks);
	}
	else
	{
		status = MK_VariableMsgQueueFrontPost(&pQueue->m_Queue.mu_VariableQueue, (CHAR *)pMsg, Length, Ticks);
	}

	return status;
}

#if 0
STATUS
MK_MsgQueueBroadcastPost(MK_QUEUE *pQueue, VOID *pMsg, UINT Length, LONG Ticks)
{
	STATUS	status;

	if(pQueue->m_Type == MK_FIXED_SIZE)
	{
		status = MK_FixedMsgQueueBroadcastPost(&pQueue->m_Queue.mu_FixedQueue, pMsg, Length, Ticks);
	}
	else
	{
		status = MK_VariableMsgQueueBroadcastPost(&pQueue->m_Queue.mu_VariableQueue, (CHAR *)pMsg, Length, Ticks);
	}

	return status;
}
#endif

STATUS
MK_MsgQueueReset(MK_QUEUE *pQueue)
{
	STATUS status;

	if(pQueue->m_Type == MK_FIXED_SIZE)
	{
		status = MK_FixedMsgQueueReset(&pQueue->m_Queue.mu_FixedQueue);
	}
	else
	{
		status = MK_VariableMsgQueueReset(&pQueue->m_Queue.mu_VariableQueue);
	}

	return status;
}


#if _MK_DDI
STATUS
MK_MessageQueueInformation(struct mk_ddi_struct *pDDI)
{
	MK_QUEUE *pQueue;
	int Flags;

	Flags = MK_InterruptDisable();		/* Critical Region */

	for(pQueue = MK_pMsgQueueListHead; pQueue != MK_NULL; pQueue = pQueue->m_pNext)
	{
		MK_Fprintf(pDDI, "%s ", pQueue->m_pName);
		if(pQueue->m_Type == MK_FIXED_SIZE)
		{
			MK_Fprintf(pDDI, "F ");
		}
		else
		{
			MK_Fprintf(pDDI, "V ");
		}
	}

	MK_Fprintf(pDDI,"\n");
	MK_InterruptRestore(Flags);

	return MK_NO_ERROR;
}
#endif

#endif	/* #ifdef _MK_MSGQUEUE */