/**********************************************************************************
 * hisr.c
 * coded by khyoon
 * date : 2003/07/18
 * 
 * 
 **********************************************************************************/

#include "kernel\\mk_sys.h"
#include "kernel\\mk_task.h"
#include "kernel\\mk_hisr.h"

#ifdef _MK_HISR

MK_HISR *MK_pActiveHISRListHead[MK_HISR_MAX_PRIORITY+1];
MK_HISR *MK_pActiveHISRListTail[MK_HISR_MAX_PRIORITY+1];
MK_HISR	*MK_pHISRListHead, *MK_pHISRListTail;


/*-------------------------------------------------------------------------------
 *	MK_HISRInitialize() function initialize HISR(High Level Interrupt)
 *	input
 *		Noting
 *	output
 *		Noting
 *-------------------------------------------------------------------------------*/
void
MK_HISRInitialize(void)
{
	int priority;

	MK_pHISRListHead = MK_NULL;
	MK_pHISRListTail = MK_NULL;
	
	for (priority = 0; priority<MK_HISR_MAX_PRIORITY+1 ; priority++) {
		MK_pActiveHISRListHead[priority] = MK_NULL;
		MK_pActiveHISRListTail[priority] = MK_NULL;
	}
}


/*-------------------------------------------------------------------------------
 *	MK_HISRSchell() function first run to hisr 
 *	input
 *		Noting
 *	output
 *		Noting
 *-------------------------------------------------------------------------------*/
void 
MK_HISRShell(void)
{
	MK_HISR *pTempHISR;
	MK_HISR *pHisr;
	int	Flags;

	if( MK_pCurrentTask == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_pCurrentHISR is MK_NULL!\n");
#endif
		return;
	}

	while(1)
	{
		pHisr = (MK_HISR *)MK_pCurrentTask;
		if(pHisr->t_ActivateCount > 0)
		{
			Flags = MK_InterruptEnable();
			(*pHisr->t_Function)();
			MK_InterruptRestore(Flags);
			pHisr->t_ActivateCount--;
			
		}
		else
		{
			if (MK_pActiveHISRListHead[MK_pCurrentTask->t_Priority] == MK_pActiveHISRListTail[MK_pCurrentTask->t_Priority])
			{
				MK_pActiveHISRListHead[pHisr->t_Priority] = MK_NULL;
				MK_pActiveHISRListTail[pHisr->t_Priority] = MK_NULL;
			}
			else
			{
				pTempHISR = pHisr->t_pHISRActiveNext;
				pTempHISR->t_pHISRActivePrev = MK_NULL;

				MK_pActiveHISRListHead[pHisr->t_Priority] = pTempHISR;
			}
			MK_Schedule();			
		
		}
	}
}

void
MK_ActivateHISR(MK_HISR *pHisr)
{
	int Flags;

	Flags = MK_InterruptDisable();

	if (pHisr->t_ActivateCount)
	{
		pHisr->t_ActivateCount++;
	}
	else
	{
		pHisr->t_ActivateCount = 1;
	
		pHisr->t_pHISRActivePrev = MK_NULL;
		pHisr->t_pHISRActiveNext = MK_NULL;

		if(MK_pActiveHISRListHead[pHisr->t_Priority])
		{
			MK_pActiveHISRListTail[pHisr->t_Priority]->t_pHISRActiveNext = pHisr;
			pHisr->t_pHISRActivePrev = MK_pActiveHISRListTail[pHisr->t_Priority];
			MK_pActiveHISRListTail[pHisr->t_Priority] = pHisr;
		}
		else
		{
			MK_pActiveHISRListHead[pHisr->t_Priority] = pHisr;
			MK_pActiveHISRListTail[pHisr->t_Priority] = pHisr;
		}
		
	}

	MK_InterruptRestore(Flags);
}

void
MK_DeleteHISR(MK_HISR *pHisr)
{
	INT	Flags;

	if( pHisr->t_ActivateCount != 0 )
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_DeleteHISR() - This HISR(%s) is activated!\n", pHisr->t_pName);
#endif

	}

	Flags = MK_InterruptDisable();

	if(MK_pActiveHISRListHead[pHisr->t_Priority] != MK_pActiveHISRListTail[pHisr->t_Priority])
	{
		if(pHisr == MK_pActiveHISRListHead[pHisr->t_Priority])
		{
			MK_pActiveHISRListHead[pHisr->t_Priority] = pHisr->t_pHISRActiveNext;
			MK_pActiveHISRListHead[pHisr->t_Priority]->t_pHISRActivePrev = MK_NULL;

		}
		else if(pHisr == MK_pActiveHISRListTail[pHisr->t_Priority])
		{
			MK_pActiveHISRListTail[pHisr->t_Priority] = pHisr->t_pHISRActivePrev;
			MK_pActiveHISRListTail[pHisr->t_Priority]->t_pHISRActiveNext = MK_NULL;
		}
		else
		{
			pHisr->t_pHISRActivePrev->t_pHISRNext = pHisr->t_pHISRActiveNext;
			pHisr->t_pHISRActiveNext->t_pHISRActivePrev = pHisr->t_pHISRActivePrev;
		}
	}
	else
	{
		MK_pActiveHISRListHead[pHisr->t_Priority] = MK_NULL;
		MK_pActiveHISRListTail[pHisr->t_Priority] = MK_NULL;
	}
	
	if(MK_pHISRListHead != MK_pHISRListTail)
	{
		if(pHisr == MK_pHISRListHead)
		{
			MK_pHISRListHead = pHisr->t_pHISRNext;
			MK_pHISRListHead->t_pHISRPrev = MK_NULL;

		}
		else if(pHisr == MK_pHISRListTail)
		{
			MK_pHISRListTail = pHisr->t_pHISRPrev;
			MK_pHISRListTail->t_pHISRNext = MK_NULL;
		}
		else
		{
			pHisr->t_pHISRPrev->t_pHISRNext = pHisr->t_pHISRNext;
			pHisr->t_pHISRNext->t_pHISRPrev = pHisr->t_pHISRPrev;
		}
	}
	else
	{
		MK_pHISRListHead = MK_NULL;
		MK_pHISRListTail = MK_NULL;
	}

	pHisr->t_pHISRNext = MK_NULL;
	pHisr->t_pHISRPrev = MK_NULL;
	
	pHisr->t_Magic = 0;
	
	MK_Schedule();

	MK_InterruptRestore( Flags );
}

MK_HISR *
MK_CreateHISR(MK_HISR *pHisr, char *name, MK_HISR_FUNC_T function, int Priority,
						char *StackPtr, int StackLength)
{
	INT		Flags;
	CHAR	*pStack;
	ULONG	Temp;
	
if(pHisr->t_Magic == MK_HISR_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_CreateHISR() - Magic error!\n");
#endif
		return (MK_HISR *)MK_ERROR;
	}

	if (Priority < MK_HISR_MIN_PRIORITY || Priority > MK_HISR_MAX_PRIORITY)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_ERROR, "MK_CreateHISR() - Priority(%dL)\n", Priority);
#endif
		return (MK_HISR *)MK_ERROR;	
	}

	if(StackLength <= 0)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_ERROR, "MK_CreateHISR() - StackLength(%dL)\n",
		StackLength);
#endif
		return (MK_HISR *)MK_ERROR;	/* return -1, 0xFFFFFFFFL */
	}

	Flags = MK_InterruptDisable();

	pHisr->t_Function = function;
	pHisr->t_Priority = Priority;

	pHisr->t_ActivateCount = 0;

	//MK_BlockCopy(pHisr->t_pName, name, MK_NAME_MAX-1);
	//pHisr->t_pName[MK_NAME_MAX-1] = '\0';
	pHisr->t_pName = name;

	pHisr->t_TopOfStack = (ULONG) StackPtr;
	pHisr->t_LengthofStackArea = StackLength;

#if 1
	Temp = (ULONG)StackPtr + StackLength;
	Temp &= 0xFFFFFFFC;
	Temp -= 4;
	pHisr->t_BottomOfStack = Temp;

	pStack = (CHAR *) Temp;

	pStack -= sizeof(ULONG);
//	*(ULONG *)pStack = (ULONG)MK_TaskShell;	/* LR(A14) */
	*(ULONG *)pStack = (ULONG)MK_HISRShell;	/* LR(A14) */
	
	pStack -= sizeof(ULONG);
	*(ULONG *)pStack = 0;			/* A13 */
	pStack -= sizeof(ULONG);
	*(ULONG *)pStack = 0;			/* A12 */
	pStack -= sizeof(ULONG);
	*(ULONG *)pStack = 0;			/* A11 */
	pStack -= sizeof(ULONG);
	*(ULONG *)pStack = 0;			/* A10 */
	
	pStack -= sizeof(ULONG);
	*(ULONG *)pStack = 0;			/* A9 */	
	pStack -= sizeof(ULONG);
    *(ULONG *)pStack = 0;			/* A8 */
	
	pStack -= sizeof(UINT);
	*(UINT *)pStack = 0;			/* R7 */	
	pStack -= sizeof(UINT);
    *(UINT *)pStack = 0;			/* R6 */
    pStack -= sizeof(UINT);
    *(UINT *)pStack = 0;			/* R5 */
    pStack -= sizeof(UINT);
    *(UINT *)pStack = 0;			/* R4 */
    pStack -= sizeof(UINT);
    *(UINT *)pStack = 0;			/* R3 */
    pStack -= sizeof(UINT);
    *(UINT *)pStack = 0;			/* R2 */
    pStack -= sizeof(UINT);
    *(UINT *)pStack = 0;			/* R1 */
    pStack -= sizeof(UINT);
    *(UINT *)pStack = 0;			/* R0 */    	
#if 0	
    pStack -= sizeof(UINT);
	*(UINT *)pStack = 0;			/* SPCH */
	pStack -= sizeof(UINT);
    *(UINT *)pStack = 0;			/* SPCL */
#endif	
    pStack -= sizeof(UINT);    
    *(UINT *)pStack = 0x0040;			/* SR, SSR */    
    pStack -= sizeof(UINT);

	pHisr->t_CurrentOfStack = (ULONG) pStack;
#endif
	
	pHisr->t_Magic = MK_HISR_MAGIC;
	
	pHisr->t_pHISRPrev = MK_NULL;
	pHisr->t_pHISRNext = MK_NULL;

	if(MK_pHISRListHead == MK_NULL) {
		MK_pHISRListHead = pHisr;
		MK_pHISRListTail = pHisr;
	}
	else {
		MK_pHISRListTail->t_pHISRNext = pHisr;
		pHisr->t_pHISRPrev = MK_pHISRListTail;
		MK_pHISRListTail = pHisr;
	}

	pHisr->t_pHISRActivePrev = MK_NULL;
	pHisr->t_pHISRActiveNext = MK_NULL;

//	MK_TotalHISR++;

	MK_InterruptRestore(Flags);

	return MK_NO_ERROR;//pHisr;	//MK_NO_ERROR
}

#endif	/* #if _MK_HISR */