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

#include "src/include/dbug.h"
#include "src/dev/mcf5282/timer.h"

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

/* The MCF5282 has four general purpose timer modules */
static mcf5282_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, 0, 0, 0, 0}
	};

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

/********************************************************************/
uint32
timer_default_isr(void *not_used, mcf5282_timer *t)
{
	(void) not_used;
	
	/* Clear the pending event */
	MCF5282_TIMER_DTER(t->channel) = (0
		| MCF5282_TIMER_DTER_REF
		| MCF5282_TIMER_DTER_CAP);

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

	return TRUE;
}

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

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

/********************************************************************/
void
timer_start(uint8 channel)
{
	/* Reset Timer module */
	MCF5282_TIMER_DTMR(channel) = 0;

	/* Clear any pending Timer events */
	MCF5282_TIMER_DTER(channel) = (0
		| MCF5282_TIMER_DTER_REF
		| MCF5282_TIMER_DTER_CAP);
	
	/* Set Timer Interrupt Control Register */
	MCF5282_INTC0_ICR20 = (uint8)(0
		| MCF5282_INTC_ICR_IL(timer[channel].level));
		
	/* Set Timer Interrupt Mask Register */	
	MCF5282_INTC0_IMRL &= 	~(MCF5282_INTC_IMRL_INT20 
							| MCF5282_INTC_IMRL_MASKALL);

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

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

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

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

	/* Disable timer (reset) */
	MCF5282_TIMER_DTMR(channel) = 0;
}

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

	/* Get the timeout in seconds */
	timeout = (uint32)(((timer[channel].period * 0xFFFF)/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;
}

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

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

/********************************************************************/
uint32
timer_init(uint8 channel, float period, float sysclock, uint32 level,
			void (*isr)(void*, void*))
{
	/* 
	 * This routine should only be called by the project (board) specific
	 * initialization code.
	 */
	
	uint16 prescale;

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

	/* If no period, disable timer */
	if (!period)
	{
		if (timer[channel].isr != NULL)
		{
			isr_remove_handler(channel+1,(void *)timer[channel].isr);
			timer[channel].isr = NULL;
		}
		timer[channel].tmr = 0;
		timer[channel].trr = 0;
		return TRUE;
	}

	/* Register the Timer Interrupt Service Routine */
	if (timer[channel].isr != NULL)
	{
		isr_remove_handler(channel+1, (void *)timer[channel].isr);
		timer[channel].isr = NULL;
	}
	if (isr == NULL)
	{
		isr = (void *)timer_default_isr;
	}
	if (!isr_register_handler(ISR_DBUG_ISR, TIMER_VECTOR(channel), (void *)isr,
						NULL, (void *)&timer[channel]))
	{
		timer[channel].isr = NULL;
		return FALSE;
	}

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

	/* Calculate TMR value */
	timer[channel].tmr = (MCF5282_TIMER_DTMR_ORRI
						| MCF5282_TIMER_DTMR_CE_NONE
						| MCF5282_TIMER_DTMR_OM
						| MCF5282_TIMER_DTMR_FRR
						| MCF5282_TIMER_DTMR_RST);

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

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

	return TRUE;
}

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