/**********************************************************************************
 * mport.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_ddi.h"
#include "util\\mk_lib.h"
#include "kernel\\mk_mport.h"

#ifdef _MK_MPORT

MK_PORT	*MK_pMsgPortListHead;
MK_PORT	*MK_pMsgPortListTail;

VOID
MK_MsgPortInitialze(VOID)
{
	MK_pMsgPortListHead = MK_NULL;
	MK_pMsgPortListTail = MK_NULL;
}

STATUS
MK_CreateMsgPort(MK_PORT *pPort, CHAR *pName, VOID *pAddr, INT MsgCount, 
				 BOOLEAN Options)
{
	MK_PORT_MSG *pMsgStart;
	STATUS	Status;
	INT		i;
	INT		Flags;

	if(pPort->p_Magic == MK_PORT_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_CreateMsgPort() - Magic error!\n");
#endif
		return MK_ERROR;
	}
	
	Flags = MK_InterruptDisable();		/* Critical Region */

	pMsgStart = (MK_PORT_MSG *)pAddr;
	pPort->p_MaxMsg = MsgCount;
	pPort->p_MsgCount = 0;
	pPort->p_Name = pName;
	
	pPort->p_pMsgFreeList = pMsgStart;
	for(i=0; i<MsgCount-1; i++)
	{
		pMsgStart[i].pm_pNext = &pMsgStart[i+1];
	}
	pMsgStart[MsgCount-1].pm_pNext = MK_NULL;

	pPort->p_pMsgListHead = MK_NULL;
	pPort->p_pMsgListTail = MK_NULL;
	
	Status = MK_CreateSemaphore(&pPort->p_SendSemaphore, MK_NULL, MsgCount, Options);

	if( Status < 0)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_CreateMsgPort() - It is invalidate Count in Create Send Semaphore ! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		MK_InterruptRestore( Flags );
		return Status;
	}
	
	Status = MK_CreateSemaphore(&pPort->p_ReceiveSemaphore, MK_NULL, 0, Options);
	
	if( Status < 0)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_CreateMsgPort() - It is invalidate Count in Create Receive Semaphore ! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		MK_InterruptRestore( Flags );
		return Status;
	}
	
	pPort->p_Magic = MK_PORT_MAGIC;

	pPort->p_pNext = MK_NULL;
	pPort->p_pPrev = MK_NULL;
	if(MK_pMsgPortListHead == MK_NULL)
	{
		MK_pMsgPortListHead = pPort;
		MK_pMsgPortListTail = pPort;
	}
	else
	{
		pPort->p_pPrev = MK_pMsgPortListTail;
		MK_pMsgPortListTail->p_pNext = pPort;
		MK_pMsgPortListTail = pPort;
	}
	
	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;
}

ULONG
MK_GetMsgPortMemorySize(UINT MsgCount)
{
	return MsgCount * sizeof(MK_PORT_MSG);
}

STATUS
MK_DeleteMsgPort(MK_PORT *pPort)
{
	INT Flags;

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

	if(MK_pMsgPortListHead == MK_pMsgPortListTail)
	{
		MK_pMsgPortListHead = MK_NULL;
		MK_pMsgPortListTail = MK_NULL;
	}
	else
	{
		if(pPort == MK_pMsgPortListHead)
		{
			MK_pMsgPortListHead = pPort->p_pNext;
			MK_pMsgPortListHead->p_pPrev = MK_NULL;
		}
		else if(pPort == MK_pMsgPortListTail)
		{
			MK_pMsgPortListTail = pPort->p_pPrev;
			MK_pMsgPortListTail->p_pNext = MK_NULL;
		}
		else
		{
			pPort->p_pPrev->p_pNext = pPort->p_pNext;
			pPort->p_pNext->p_pPrev = pPort->p_pPrev;
		}
	}
	pPort->p_pNext = MK_NULL;
	pPort->p_pPrev = MK_NULL;

	MK_InterruptRestore(Flags);

	return MK_NO_ERROR;
}

UINT
MK_GetMsgPortCount(MK_PORT *pPort)
{
	if(pPort->p_Magic != MK_PORT_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_GetMsgPortCount() - Magic error! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return 0;
	}


	return pPort->p_MsgCount;
}


STATUS
MK_MsgPortPend(MK_PORT *pPort, VOID **pMessage, LONG *pMsgLength, LONG *pBufLength,
				LONG Ticks)
{
	STATUS Status;
	MK_PORT_MSG *pPortMsg;
	INT Flags;

	if(pPort->p_Magic != MK_PORT_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_MsgPortPend() - Magic error! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_RESOURCE_ERROR;
	}

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

	Status = MK_SemaphorePend(&pPort->p_ReceiveSemaphore, Ticks);
	if( Status < 0)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_MsgPortPend() - Receive SemaphorePend Magic error or timeout! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		MK_InterruptRestore( Flags );
		return Status;
	}
	if(pPort->p_pMsgListHead == MK_NULL)
	{
		MK_KernelInfoPrintf((MK_TASK_ERROR, "MK_MsgPortPend() - Msg is not exist though MsgPort gets semaphore! Task(%s)\n",
					MK_GetCurrentTask()->t_pName));
		MK_InterruptRestore( Flags );
		return MK_ERROR;
	}

	if(pPort->p_pMsgListHead == pPort->p_pMsgListTail)
	{
		pPortMsg = pPort->p_pMsgListHead;
		pPort->p_pMsgListHead = MK_NULL;
		pPort->p_pMsgListTail = MK_NULL;
		pPortMsg->pm_pNext = MK_NULL;
	}
	else
	{
		pPortMsg = pPort->p_pMsgListHead;
		pPort->p_pMsgListHead = pPortMsg->pm_pNext;
		pPortMsg->pm_pNext = MK_NULL;
	}
	*pMessage = (CHAR *)pPortMsg->pm_Msg;
	*pMsgLength = pPortMsg->pm_MsgLength;
	*pBufLength = pPortMsg->pm_BufLength;

	pPort->p_MsgCount--;

	pPortMsg->pm_pNext = pPort->p_pMsgFreeList;
	pPort->p_pMsgFreeList = pPortMsg;

	MK_SemaphorePost(&pPort->p_SendSemaphore);

	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;
}

STATUS
MK_MsgPortPost(MK_PORT *pPort, CHAR *pMessage, LONG pMsgLength, LONG pBufLength,
			   LONG Ticks)
{
	STATUS Status;
	MK_PORT_MSG *pPortMsg;
	INT Flags;

	if(pPort->p_Magic != MK_PORT_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_MsgPortPost() - Magic error! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_RESOURCE_ERROR;
	}

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

	Status = MK_SemaphorePend(&pPort->p_SendSemaphore, Ticks);
	if( Status < 0)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_MsgPortPost() - Send SemaphorePend Magic error or timeout! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		MK_InterruptRestore( Flags );
		return Status;
	}

	if(pPort->p_pMsgFreeList == MK_NULL)
	{
		MK_KernelInfoPrintf((MK_TASK_ERROR, "MK_MsgPortPost() - FreeMsgList is not exist though MsgPort gets semaphore! Task(%s)\n",
					MK_GetCurrentTask()->t_pName));
		MK_InterruptRestore( Flags );
		return MK_ERROR;
	}

	pPortMsg = pPort->p_pMsgFreeList;
	pPort->p_pMsgFreeList = pPortMsg->pm_pNext;
	pPortMsg->pm_pNext = MK_NULL;

	pPortMsg->pm_Msg = (ULONG)pMessage;
	pPortMsg->pm_MsgLength = pMsgLength;
	pPortMsg->pm_BufLength = pBufLength;

	if(pPort->p_pMsgListHead == MK_NULL)
	{
		pPort->p_pMsgListHead = pPortMsg;
		pPort->p_pMsgListTail = pPortMsg;
	}
	else
	{
		pPort->p_pMsgListTail->pm_pNext = pPortMsg;
		pPort->p_pMsgListTail = pPortMsg;
	}
	pPort->p_MsgCount++;

	MK_SemaphorePost(&pPort->p_ReceiveSemaphore);

	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;
}

#if _MK_DDI
STATUS
MK_MessagePortInformation(struct mk_ddi_struct *pDDI)
{
	MK_PORT *pPort;
	int Flags;

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

	for(pPort = MK_pMsgPortListHead; pPort != MK_NULL; pPort = pPort->p_pNext)
	{
		MK_Fprintf(pDDI, "%s ", pPort->p_Name);
	}

	MK_Fprintf(pDDI,"\n");

	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;
}
#endif


#endif	/* #ifdef _MK_MPORT */