timer.c

MCF523X系列处理器初始化代码,对开发523X些列freescale处理器有非常重要的意思

/*
 * File:		timer.c
 * Purpose:		routines for accessing integrated timer modules
 *
 * Notes:
 *
 * Modifications:
 *
 */


#include "src/ethernet/tftp/timer.h"
#include "src/init/mcf523x/mcf523x_timer.h"
#include "src/init/mcf523x/mcf523x_intc0.h"
#include "src/init/m523xevb.h"

/********************************************************************/

/* The MCF523x has four general purpose timer modules */
mcf523x_timer timer[4] = \
	{
		{0, 0, 0, 0, 0, 0, 0, 0, 0}, 
		{0, 0, 0, 0, 0, 0, 0, 0, 0}, 
		{0, 0, 0, 0, 0, 0, 0, 0, 0}, 
		{0, 0, 0, 0, 0, 0, 0, 0, 0}
	};

const uint8 TIMER_BENCHMARK = 0;
const uint8 TIMER_NETWORK = 1;

/********************************************************************/

uint32
timer_default_isr(mcf523x_timer *t)
{
	/* Clear the pending event */
	MCF_TIMER_DTER(t->channel) = (0
		| MCF_TIMER_DTER_REF
		| MCF_TIMER_DTER_CAP);

	t->timeouts++;
	if (t->reference)
		if (--t->reference == 0)
			timer_stop(t->channel);

	return TRUE;
	
	/* Clear the pending event */
	MCF_TIMER_DTER(t->channel) = (0
		| MCF_TIMER_DTER_REF
		| MCF_TIMER_DTER_CAP);

	t->timeouts++;
	if (t->reference)
		if (--t->reference == 0)

	return TRUE;
}

uint32
timer_get_reference(uint8 channel)
{	
	return timer[channel].reference;
}

/********************************************************************/
uint32
timer_init(uint8 channel, float period, float sysclock, uint32 level)
{


	uint16 prescale;

	if ((channel > 3) || (level < 1) || (level > 7))
		return FALSE;

	/* Set the Reference Reached value to the maximum value */
	timer[channel].trr = 0xFFFF;

	/* Store TMR value */
	timer[channel].tmr = (MCF_TIMER_DTMR_ORRI
						| MCF_TIMER_DTMR_CE_NONE
						| MCF_TIMER_DTMR_OM
						| MCF_TIMER_DTMR_FRR
						| MCF_TIMER_DTMR_RST);

	if (period < (1000/sysclock)) 
	{
		period = 1000/sysclock;
		timer[channel].tmr |= (MCF_TIMER_DTMR_CLK_DIV1 
							 | MCF_TIMER_DTMR_PS(0));
	}
	else if (period > (1000 * 256 * 16)/sysclock)
	{
		period = (1000 * 256 * 16)/sysclock;
		timer[channel].tmr |= (MCF_TIMER_DTMR_CLK_DIV16 
							 | MCF_TIMER_DTMR_PS(256));
	}
	else if (period <= (1000 * 256)/sysclock)
	{
		prescale = (uint16)((period * sysclock)/1000);
		timer[channel].tmr |= (MCF_TIMER_DTMR_CLK_DIV1 
							 | MCF_TIMER_DTMR_PS(prescale));
	}
	else /* period <= (1000 * 256 * 16)/sysclock */
	{
		prescale = (uint16)((period * sysclock)/(1000 * 16));
		timer[channel].tmr |= (MCF_TIMER_DTMR_CLK_DIV16 
							 | MCF_TIMER_DTMR_PS(prescale));
	}

	/* Save the Timer settings */
	timer[channel].period = period;
	timer[channel].channel = channel;
	timer[channel].level = level;

	return TRUE;
}

/********************************************************************/
uint32
timer_set_secs(uint8 channel, uint32 secs)
{

	
	uint32 timeout;

	/* Get the timeout in seconds */
	timeout = (uint32)(((timer[channel].period * 0x10000)/1000000000) + 0.5);

	if (timeout == 0)
	{
		timer[channel].reference = 1;
		return FALSE;
	}

	/* Save the reference reached counter value */
	timer[channel].reference = secs/timeout;

	/* Reset the timeout counter */
	timer[channel].timeouts = 0;


	/* Start the timer */
	timer_start(channel);

	return TRUE;
}

/********************************************************************/

static void
timer_start(uint8 channel)
{

	
	/* Reset Timer module */
	MCF_TIMER_DTMR(channel) = 0;

	/* Clear any pending Timer events */
	MCF_TIMER_DTER(channel) = (0
		| MCF_TIMER_DTER_REF
		| MCF_TIMER_DTER_CAP);
	
	/* Set Timer Interrupt Control Register */
	MCF_INTC0_ICR20 = (uint8)(0
		| MCF_INTC0_ICRn_IL(timer[channel].level));
		
	/* Allow Timer 1 Interrupts */	
	MCF_INTC0_IMRL &= 	~( MCF_INTC0_IMRL_INT_MASK20
							| MCF_INTC0_IMRL_MASKALL );

	/* Reset the counter */
	MCF_TIMER_DTCN(channel) = 0;

	/* Write the TRR register */
	MCF_TIMER_DTRR(channel) = timer[channel].trr;

	/* Write the TMR register and start the free-running timer */
	MCF_TIMER_DTMR(channel) = timer[channel].tmr;

}

/********************************************************************/

static void
timer_stop(uint8 channel)
{
	/* Get the latest time */
	timer_read(channel);

	/* Disable timer (reset) */
	MCF_TIMER_DTMR(channel) = 0;


}

/********************************************************************/






/********************************************************************/
static uint32
timer_read(uint8 channel)
{
	uint32 now;

	now = MCF_TIMER_DTCN(channel);
	timer[channel].then = timer[channel].now;
	timer[channel].now = now;
	return now;
}

/********************************************************************/


static uint32
timer_get_time(uint8 channel)
{
	/* NOT COMPLETE!  FIX */
	return (timer[channel].now - timer[channel].then);
}

/********************************************************************/



/********************************************************************/