/**********************************************************************************
 * event.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_event.h"
#include "kernel\\mk_ddi.h"
#include "util\\mk_lib.h"

#ifdef _MK_EVENT

struct mk_event_struct *MK_pEventListHead;
struct mk_event_struct *MK_pEventListTail;

VOID
MK_EventInitialize(VOID)
{
	MK_pEventListHead = MK_NULL;
	MK_pEventListTail = MK_NULL;
}

STATUS
MK_CreateEvent(MK_EVENT *pEvent, CHAR *pName)
{
	STATUS	status;
	INT Flags;

	if(pEvent->e_Magic == MK_EVENT_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_CreateEvent() - Magic error!\n");
#endif
		return MK_RESOURCE_ERROR;
	}
	
	Flags = MK_InterruptDisable();		/* Critical Region */

	pEvent->e_Events = 0;

	pEvent->e_pName = pName;
	/* create event pending list for event pending task */
	status = MK_CreatePendingList(&pEvent->s_PendingList, MK_SERVICE_FIFO);
	pEvent->s_PendingList.p_Sem = (ULONG)pEvent;
	
	pEvent->e_Magic = MK_EVENT_MAGIC;
	
	pEvent->e_pPrev = MK_NULL;
	pEvent->e_pNext = MK_NULL;
	if(MK_pEventListHead == MK_NULL)
	{
		MK_pEventListHead = pEvent;
		MK_pEventListTail = pEvent;
	}
	else
	{
		pEvent->e_pPrev = MK_pEventListTail;
		MK_pEventListTail->e_pNext = pEvent;
		MK_pEventListTail = pEvent;
	}

	MK_InterruptRestore(Flags);
	return status;
}

STATUS
MK_DeleteEvent(MK_EVENT *pEvent)
{
	INT Flags;

	if(pEvent->e_Magic != MK_EVENT_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_DeleteEvent() - Magic error!\n");
#endif
		return MK_RESOURCE_ERROR;
	}

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

	/* change ready staus to pending task's status on event flags */
	MK_ClearPendingList(&pEvent->s_PendingList);
	MK_DeletePendingList(&pEvent->s_PendingList); //Modified

	/* delete event flags on event list */
	if(MK_pEventListHead == MK_pEventListTail)
	{
		MK_pEventListHead = MK_NULL;
		MK_pEventListTail = MK_NULL;
	}
	else
	{
		if(pEvent == MK_pEventListHead)
		{
			MK_pEventListHead = pEvent->e_pNext;
			MK_pEventListHead->e_pPrev = MK_NULL;
		}

		else if(pEvent == MK_pEventListTail)
		{
			MK_pEventListTail = pEvent->e_pPrev;
			MK_pEventListTail->e_pNext = MK_NULL;
		}
		else
		{
			pEvent->e_pPrev->e_pNext = pEvent->e_pNext;
			pEvent->e_pNext->e_pPrev = pEvent->e_pPrev;
		}
	}
	pEvent->e_pNext = MK_NULL;
	pEvent->e_pPrev = MK_NULL;

	pEvent->e_Magic = 0;

	MK_InterruptRestore(Flags);

	return MK_NO_ERROR;
}

STATUS
MK_SetEvent(MK_EVENT *pEvent, ULONG Events, UINT operation)
{
	INT					Flags;
	UINT				compare;
	UINT				consume;
	MK_TASK				*pTask;
	MK_TASK				*pNext;

	if(pEvent->e_Magic != MK_EVENT_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("[%S] line %d : MK_SetEvent() - Magic error! Task\n", __FILE__, __LINE__);
#endif
		return MK_RESOURCE_ERROR;
	}
	Flags = MK_InterruptDisable();		/* Critical Region */

	if( operation & MK_EVENT_AND)
	{
		pEvent->e_Events &= Events;
	}
	else
		pEvent->e_Events |= Events;

	consume = 0;

	pTask = MK_GetFirstPendingTask(&pEvent->s_PendingList);

	while( pTask )
	{
		pNext = pTask->t_pPendingNext;
		compare = pEvent->e_Events & pTask->t_EventRequested;

		if(pTask->t_EventOperation & MK_EVENT_AND)
			compare = (compare == pTask->t_EventRequested) ? compare : 0;

		if( compare )
		{
			if(pTask->t_EventOperation & MK_CONSUME)
				consume |= pTask->t_EventRequested;
			
			pTask->t_EventActualEvents = pEvent->e_Events;

			MK_DeleteTaskFromPendingList(&pEvent->s_PendingList, pTask);
			if(pTask->t_Status & MK_TASK_DELAYED)
			{
				MK_DeleteTaskFromDelayedList(pTask);
			}
			MK_InsertTaskToReadyList(pTask);
		}
			pTask = pNext;
	}

	pEvent->e_Events &= ~consume;

	MK_Schedule();

	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;
}

STATUS
MK_EventPend(MK_EVENT *pEvent, ULONG Request, UINT Operation, ULONG *Events, LONG Ticks)
{
	INT			Flags;
	UINT		compare;
	MK_TASK		*pTask;

	if(pEvent->e_Magic != MK_EVENT_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_EventPend() - Magic error! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_RESOURCE_ERROR;
	}

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

	compare = pEvent->e_Events & Request;

	if(Operation & MK_EVENT_AND)
		compare = (compare == Request) ? compare : 0;
	
	if(compare) 
	{
		*Events = pEvent->e_Events;

		if(Operation & MK_CONSUME)
			pEvent->e_Events &= ~Request;
	}
	else //pending
	{
		if(Ticks == MK_NO_WAIT)
		{
			*Events = 0;
			MK_InterruptRestore(Flags);
			return MK_TIMEOUT;
		}

		pTask = MK_GetCurrentTask();
		pTask->t_EventRequested = Request;
		pTask->t_EventOperation = Operation;

		MK_DeleteTaskFromReadyList(pTask);
		MK_InsertTaskToPendingList(&pEvent->s_PendingList, pTask);
		
		if(Ticks > 0)
		{
			MK_InsertTaskToDelayedList(pTask, Ticks);
		}

		MK_Schedule();

		/* released by reset and deletion */
		if(pTask->t_Status & MK_TASK_FORCED)
		{
			*Events = 0;
			pTask->t_Status &= ~MK_TASK_FORCED;
			MK_InterruptRestore(Flags);
			return MK_RESOURCE_ERROR;
		}

		/* released by MK_TIMEOUT */
		if(pTask->t_Status & MK_TASK_PENDING)
		{
			MK_DeleteTaskFromPendingList(&pEvent->s_PendingList, pTask);

			*Events = 0;
			MK_InterruptRestore(Flags);
			return MK_TIMEOUT;
		}
		/* satisfy request Event Flags */
		else
		{
			*Events = pTask->t_EventActualEvents;
			MK_InterruptRestore(Flags);
			return MK_NO_ERROR;
		}
	}

	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;
}


#if _MK_DDI
STATUS
MK_EventInformation(struct mk_ddi_struct *pDDI)
{
	MK_EVENT *pEvent;
	INT Flags;

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

	for(pEvent = MK_pEventListHead; pEvent != 0; pEvent = pEvent->e_pNext)
	{
		MK_Fprintf(pDDI, "%s ", pEvent->e_pName);
	}
	MK_Fprintf(pDDI,"\n");

	MK_InterruptRestore(Flags);

	return MK_NO_ERROR;
}
#endif

#endif /* #ifdef _MK_EVENT */