timer.c

samsung 9908DVD源代码,

	}
//#endif

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

	/* Deleted at ActiveTimerList */
	if(pTimer->tm_Status == MK_TIMER_ENABLE)
	{
		MK_InterruptRestore(Flags);
		return MK_ERROR;	//not disable
	}

	if(MK_pTimerListHead == MK_pTimerListTail)
	{
		MK_pTimerListHead = MK_NULL;
		MK_pTimerListTail = MK_NULL;
	}
	else
	{
		if(pTimer == MK_pTimerListHead)
		{
			MK_pTimerListHead = pTimer->tm_pNext;
			MK_pTimerListHead->tm_pPrev = MK_NULL;
		}
		else if(pTimer == MK_pTimerListTail)
		{
			MK_pTimerListTail = pTimer->tm_pPrev;
			MK_pTimerListTail->tm_pNext = MK_NULL;
		}
		else
		{
			pTimer->tm_pPrev->tm_pNext = pTimer->tm_pNext;
			pTimer->tm_pNext->tm_pPrev = pTimer->tm_pPrev;
		}
	}
	pTimer->tm_pNext = MK_NULL;
	pTimer->tm_pPrev = MK_NULL;

	pTimer->tm_Magic = 0;
	
	MK_InterruptRestore(Flags);

	return MK_NO_ERROR;
}

static VOID
MK_TimerExpiration(VOID)
{
	MK_TIMER *pTimer;
	LONG	Value, Revision;
	INT		Flags;

//#if MK_DEBUG
	if(MK_pTimerActiveListHead == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_TimerExpiration() - Timer doesn't exist!\n");
#endif
		return;
	}
//#endif

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

	Revision = 0;
	for(Value = MK_pTimerActiveListHead->tm_ExpireTime; Value<=Revision; )
	{
		pTimer = MK_pTimerActiveListHead;
		MK_DeleteFromActiveTimerList(pTimer);
		
		(*pTimer->tm_Function)(pTimer->tm_Arg1);

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

		/* Timer is Repeated by RepeateTime (2003/03/03 modified by hjahn) */
		if(pTimer->tm_RepeateTime > 0)
		{
			pTimer->tm_ExpireTime = pTimer->tm_RepeateTime;
			MK_InsertToActiveTimerList(pTimer);
			pTimer->tm_Expirations++;
		}
		/* Modified */

		/* include MK_pTimerActiveListHead = MK_pTimerActiveListHead->tm_pActivedNext */
		Revision -= Value;
		if(MK_pTimerActiveListHead == MK_NULL)
			return;
		Value = MK_pTimerActiveListHead->tm_ExpireTime;

		MK_InterruptRestore(Flags);
	}

	//MK_InterruptRestore(Flags);
}

/* coded by hjahn */
STATUS
MK_GetRemainingTime( MK_TIMER *pTimer, ULONG *remainTime)
{
	MK_TIMER *pTimerList;
	BOOLEAN	Enable;
	INT		Flags;

//#if MK_DEBUG
	if(pTimer == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_ControlTimer() - Timer doesn't exist!\n");
#endif
		return MK_RESOURCE_ERROR;
	}
	if(pTimer->tm_Magic != MK_TIMER_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_GetRemainingTime() - Magic error!\n");
#endif
		return MK_RESOURCE_ERROR;
	}
//#endif

	Enable = MK_GetTimerStatus(pTimer);
	if(Enable == MK_TIMER_DISABLE)
	{
		*remainTime = pTimer->tm_ExpireTime;
		return MK_NO_ERROR;
	}

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

	pTimerList = MK_pTimerActiveListHead;


	/* if pTimer is Timer list Header */
	if( pTimerList == pTimer)
	{
		*remainTime = pTimerList->tm_ExpireTime;
	}
	else
	{
		*remainTime = pTimerList->tm_ExpireTime;

		do {
			pTimerList = pTimerList->tm_pActivedNext;
			*remainTime += pTimerList->tm_ExpireTime;
		}while(pTimerList != pTimer);
	}

	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;
}

STATUS
MK_ResetTimer(MK_TIMER *pTimer, MK_TIMER_FUNC_T Function, 
			  ULONG InitialTime, ULONG RepeateTime, BOOLEAN Enable)
{
	INT	Flags;

//#if MK_DEBUG
	if(pTimer == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_ControlTimer() - Timer doesn't exist!\n");
#endif
		return MK_RESOURCE_ERROR;
	}
	if(pTimer->tm_Magic != MK_TIMER_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_ResetTimer() - Magic error!\n");
#endif
		return MK_RESOURCE_ERROR;
	}
//#endif

	if(pTimer->tm_Status == MK_TIMER_ENABLE)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_Resetimer() - Timer is active state!\n");
#endif
		return MK_ERROR;
	}

	Flags = MK_InterruptDisable();		/* Critical Region */
	
	if(InitialTime > 0) {
		pTimer->tm_InitialTime = InitialTime;
		pTimer->tm_ExpireTime = InitialTime;
		pTimer->tm_Expirations = 0;
	}
	else {/*Just to report ERROR!!*/
		MK_Printf("WARNING!! I n i t i a l  T i m e  i s  0 !!\n");
		MK_InterruptRestore(Flags);
		return MK_ERROR;
	}
	
	if(RepeateTime > 0)
		pTimer->tm_RepeateTime = RepeateTime;
	else
		pTimer->tm_RepeateTime = 0;

	pTimer->tm_RepeateTime = RepeateTime;
	pTimer->tm_Function = Function;

	if(Enable == MK_TIMER_ENABLE)
	{
		MK_InsertToActiveTimerList(pTimer);
	}

	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;	
}

ULONG
MK_GetSystemClock(VOID)
{
	return MK_Ticks;
}

VOID
MK_SetSystemClock(ULONG newTicks)
{
	MK_Ticks = newTicks;
}
/* coded by hjahn - end */


#ifdef _MK_DDI
STATUS
MK_TimerInformation(struct mk_ddi_struct *pDDI)
{
	MK_TIMER *pTimer;
	int Flags;

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

	for(pTimer = MK_pTimerListHead; pTimer != MK_NULL; pTimer = pTimer->tm_pNext)
	{
		MK_Fprintf(pDDI, "%s ", pTimer->tm_pName);

		if(pTimer->tm_Status == MK_TIMER_ENABLE)
		{
			MK_Fprintf(pDDI, "E ");
		}
		else
		{
			MK_Fprintf(pDDI, "D ");
		}
	}
	MK_Fprintf(pDDI,"\n");
	MK_InterruptRestore(Flags);

	return MK_NO_ERROR;
}
#endif	/*#ifdef _MK_DDI */


VOID
MK_TimeTick(INT id)
{
	MK_TIMER	*pTimer;
	INT		Flags;
	int		Priority;
	MK_HISR		*pCurrentHisr;
	MK_HISR		*pNextHisr;

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

 	//MK_Printf("#");
	
	MK_Ticks++;

	pTimer = MK_pTimerActiveListHead;
	if(pTimer != MK_NULL)
	{
		pTimer->tm_ExpireTime--;

		if(pTimer->tm_ExpireTime <= 0)
		{
			MK_TimerExpiration();
		}
	}
#if 1 /*for round-robin HISR*/
	if (MK_pCurrentTask->t_Magic == MK_HISR_MAGIC) {
		pCurrentHisr = (MK_HISR *)MK_pCurrentTask;
		Priority = pCurrentHisr->t_Priority;
		pNextHisr = MK_pActiveHISRListHead[Priority]->t_pHISRActiveNext;
		if((pNextHisr != MK_NULL) && (pCurrentHisr != pNextHisr)) {
			pNextHisr->t_pHISRActivePrev = MK_NULL;
			MK_pActiveHISRListHead[Priority]  = pNextHisr;
			MK_pActiveHISRListTail[Priority]->t_pHISRActiveNext = pCurrentHisr;
			MK_pActiveHISRListTail[Priority] = pCurrentHisr;
			MK_pActiveHISRListTail[Priority]->t_pHISRActiveNext = MK_NULL;			
		}
	}
	else {
#endif 
		MK_pCurrentTask->t_UsedTimeSlice++;
		if(MK_GetSchedulePolicy() != MK_TASK_FIFO)
		{
			MK_pCurrentTask->t_RemainedTimeSlice--;
		}
#if 1
	}
#endif

	if(MK_pTaskDelayedListHead != MK_NULL)
	{
		MK_pTaskDelayedListHead->t_DelayedDeltaTicks--;
		if(MK_pTaskDelayedListHead->t_DelayedDeltaTicks <= 0)
		{
			MK_Wakeup();
		}
	}

#if 0	/* 2004/03/26, HeeSang Park - Moved from irq.c */
		rTDCON = rTDCON & 0xffffffff;	/* Clear Interrupt Source Status */
#endif /* 1 */	

	//MK_Schedule();
	MK_InterruptRestore(Flags);
}

VOID
MK_Timer0Initialize(VOID)
{
	unsigned int vector_H,vector_I;
	unsigned long ulTemp1;
#if 0
	//MK_IRQInstall(INT_BT, MK_TimeTick);
	//BTCON= 0x57;
	//BTCNT= 0x7f;

	MK_IRQInstall(INT_TIMERA, MK_TimeTick);

	
	IO_WData32_EX((unsigned char *)&rTACON_H, 7, 0x1800);
	IO_WData32_EX((unsigned char *)&rTAPRE_H, 0, 80);
	IO_WData32_EX((unsigned char *)&rTADATA1_H, 0, 999);
	IO_WData32_EX((unsigned char *)&rTACMD_H, 0, 3);

	IO_WData32_EX((unsigned char *)&rINTMASK_H,0,0x20 );


	MK_IRQInstall(INT_TIMERD, MK_TimeTick);

	
	IO_WData32_EX((unsigned char *)&rTDCON_H, 5, 0x1000);
	IO_WData32_EX((unsigned char *)&rTDPRE_H, 0, 80);
	//IO_WData32_EX((unsigned char *)&rTDDATA1_H, 0, /*499*/999);
	IO_WData32_EX((unsigned char *)&rTDDATA1_H, 0, /*499*/9999);//20 ms 
	IO_WData32_EX((unsigned char *)&rTDCMD_H, 0, 3);

       vector_H =rINTMASK_H;
	vector_I = rINTMASK_L;
	vector_I |= 0x200;
	IO_WData32_EX((unsigned char *)&rINTMASK_H,0,0x200 );
#endif 
#if 1
	MK_IRQInstall(INT_TIMERC, MK_TimeTick);

	
	IO_WData32_EX((unsigned char *)&rTCCON_H, 5, 0x1000);
	IO_WData32_EX((unsigned char *)&rTCPRE_H, 0, 107); 		// 108MHz/108=1Mhz
	//IO_WData32_EX((unsigned char *)&rTDDATA1_H, 0, /*499*/999);
	IO_WData32_EX((unsigned char *)&rTCDATA1_H, 0, 999);	///1ms 付促 interrupt ...
	//IO_WData32_EX((unsigned char *)&rTCDATA1_H, 0, 1499);	///1.5ms 付促 interrupt ...
	//IO_WData32_EX((unsigned char *)&rTCDATA1_H, 0, 249);
	
	//IO_WData32_EX((unsigned char *)&rTCDATA1_H, 0xf, /*499*/0x423f);//2000 ms 
	IO_WData32_EX((unsigned char *)&rTCCMD_H, 0, 3);

	// ulTemp1 = IO_RData32_EX ( ( unsigned char *)rINTMASK_H );
	// ulTemp1 = ulTemp1 | 0x100;
	
       vector_H =rINTMASK_H;
	vector_I = rINTMASK_L;
	vector_I |= 0x100;
	
	IO_WData32_EX((unsigned char *)&rINTMASK_H,/*0x18*/0x1A,0x1708);//0x1300 );//Lumin9908 should keep the IR_INT
	// IO_WData32_EX((unsigned char *)&rINTMASK_H,vector_H,vector_I);
#else
	MK_IRQInstall(INT_TIMERC, MK_TimeTick);

	ulTemp1 = IO_RData32_EX ( ( unsigned char *)&rINTMASK_H);
	ulTemp1 &= ~INT_TIMERC;
	IO_WData32_EX ( (unsigned char *)&rINTMASK_H, ( (unsigned int)ulTemp1>>16), (unsigned int)ulTemp1 );
	IO_WData32_EX ( (unsigned char *)&rINTMOD_H, 0, 0 );	
	IO_WData32_EX((unsigned char *)&rTCCON_H, 5, 0x1000);
	IO_WData32_EX((unsigned char *)&rTCPRE_H, 0, 80);
	IO_WData32_EX((unsigned char *)&rTCDATA1_H, 0, 249);
	
	IO_WData32_EX((unsigned char *)&rTCCMD_H, 0, 3);

	ulTemp1 = IO_RData32_EX ( ( unsigned char *)&rINTMASK_H);
	ulTemp1 |= INT_TIMERC;
	IO_WData32_EX ( (unsigned char *)&rINTMASK_H, ( (unsigned int)ulTemp1>>16), (unsigned int)ulTemp1 );	
#endif
}

#endif	/* #ifdef _MK_TIMER */