/* sngks32cTimer.c - Samsung S3C44B0X timer library *//* Copyright 2004-2005 Amine@263.net *//* Copyright 1984-2001 Wind River Systems, Inc. */#include "copyright_wrs.h"/*modification history--------------------01o,27jul04,a_m  BSP定制 for 思創S3C44B0X黃金開發板01e,19apr02,m_h  sysAuxClkConnect for THUMB01d,27sep01,m_h  sysClkRateSet() doesn't change the clock rate01c,18jul01,m_h  Fix timestamp timer01b,26apr01,m_h  convert tabs to spaces for readability01a,12apr01,m_h  created from snds100 template.*//*DESCRIPTIONThis is a timer driver for Samsung's KS32C50100 microprocessor which isan ARM based processor with several integrated peripherals.It has an interrupt controller, two 32-bit timers, one Ethernet controller,two HDLC controllers, one IIC controller, general purpose I/O ports, and a 2-channel DMA controller.The 32-bit timers can be programmed in interval mode or toggle mode.  Ininterval mode, an output pulse is generated when the countdown value inthe count register reaches  zero.  This will generate a frequency of(SYSCLK/count).  On the other hand, in the toggle mode, the output togglesits state for each time the countdown value reaches zero.  In this case, theoutput frequency will be (SYSCLK/(2*count)).The Timer Data register is used to load the countdown value.  When the timeris enabled using the Timer Mode register, the Timer Count register is loadedwith the count in Timer Data register.  The count value is decremented for everyinternal clock edge.  Once the count becomes zero, an interrupt is generated(if enabled in the interrupt controller) and the Timer Count register isreloaded automatically.The internal timer registers are accessed in a straight-forward fashion.They are accessible as 32-bit integers from the internal system registeroffsets, as given in sngks32cTimer.h file.  The macros SNGKS32C_TIMER_REG_WRITEand SNGKS32C_TIMER_REG_READ does nothing but reading and writing 32-bitintegers from and to the given addresses.This driver provides 3 main functions, system clock support, auxiliaryclock support, and timestamp timer support.  If necessary, each functionmay be conditioned by a separate INCLUDE_ macro.  The timestamp functionis always conditional upon the INCLUDE_TIMESTAMP macro.The SNGKS32C ARM7 timer register definitions are given in sngks32cTimer.h file.The macros SYS_CLK_RATE_MIN, SYS_CLK_RATE_MAX, AUX_CLK_RATE_MIN, andAUX_CLK_RATE_MAX must be defined in sngks32carm7.h to provide parameter checking for the sys[Aux]ClkRateSet() routines.INCLUDES:sngks32cTimer.htimestampDev.hSEE ALSO:<Samsung KS32C50100 User's Manual>*//* includes */#include "vxWorks.h"#include "config.h"#include "drv/timer/timerDev.h"#include "drv/timer/timestampDev.h"#include "sngks32cTimer.h"/* defines *//* The default is to assume memory mapped I/O */#ifndef SNGKS32C_TIMER_REG_READ#define SNGKS32C_TIMER_REG_READ(reg, result) \    ((result) = *(volatile UINT32 *)(reg))#endif /*SNGKS32C_TIMER_READ*/#ifndef SNGKS32C_TIMER_REG_WRITE#define SNGKS32C_TIMER_REG_WRITE(reg, data) \    (*((volatile UINT32 *)(reg)) = (data))#endif /*SNGKS32C_TIMER_WRITE*/#ifndef SNGKS32C_TIMER_INT_ENABLE#define SNGKS32C_TIMER_INT_ENABLE(level) intEnable(level)#endif#ifndef SNGKS32C_TIMER_INT_DISABLE#define SNGKS32C_TIMER_INT_DISABLE(level) intDisable(level)#endif/* locals */LOCAL FUNCPTR sysClkRoutine    = NULL; /* routine to call on clock tick */LOCAL int sysClkArg            = (int)NULL; /* its argument */LOCAL int sysClkRunning        = FALSE;LOCAL int sysClkConnected      = FALSE;LOCAL int sysClkTicksPerSecond = 60;LOCAL FUNCPTR sysAuxClkRoutine    = NULL;LOCAL int sysAuxClkArg            = (int)NULL;LOCAL int sysAuxClkRunning        = FALSE;LOCAL int sysAuxClkTicksPerSecond = 100;LOCAL int sysAuxClkTicks;#ifdef INCLUDE_TIMESTAMPLOCAL BOOL      sysTimestampRunning     = FALSE;         /* running flag */LOCAL FUNCPTR   sysTimestampRoutine     = NULL;          /* routine to call on intr */LOCAL int       sysTimestampArg         = 0;             /* arg for routine */      void      sysTimestampInt (void);                  /* forward declaration */#endif  /* INCLUDE_TIMESTAMP *//********************************************************************************* sysClkInt - interrupt level processing for system clock** This routine handles a system clock interrupt.  It acknowledges the* interrupt and calls the routine installed by sysClkConnect().*/void sysClkInt (void)    {    /* call system clock service routine */    if (sysClkRoutine != NULL)        (* sysClkRoutine) (sysClkArg);    }/********************************************************************************* sysClkConnect - connect a routine to the system clock interrupt** This routine specifies the interrupt service routine to be called at each* clock interrupt.  Normally, it is called from usrRoot() in usrConfig.c to * connect usrClock() to the system clock interrupt.** RETURN: OK, or ERROR if the routine cannot be connected to the interrupt.** SEE ALSO: intConnect(), usrClock(), sysClkEnable()*/STATUS sysClkConnect    (    FUNCPTR routine,    /* routine to be called at each clock interrupt */    int arg        /* argument with which to call routine */    )    {    if (sysClkConnected == FALSE)        {        /*SNGKS32C_TIMER_REG_WRITE (SNGKS32C_TIMER_TMOD, SNGKS32C_TIMER_INITIALIZE);*/		/* Amine: deleted and added */	#if (BOARD_TYPE == BOARD_ARMEPS) /*use timer5*/        /*dead zone=0, pre2=100*/	    SNGKS32C_TIMER_REG_WRITE (S3C44B0X_TCFG0, (99<<16));    /*by Amine on 20060608*/	    /*all interrupt, mux5=1/4*/        SNGKS32C_TIMER_REG_WRITE (S3C44B0X_TCFG1, (1<<20));	#else        /*dead zone=0, pre0=100*/        SNGKS32C_TIMER_REG_WRITE (S3C44B0X_TCFG0, 0x00000063);  /*by Amine on 20060608*/        /*all interrupt, mux0=1/4*/        SNGKS32C_TIMER_REG_WRITE (S3C44B0X_TCFG1, 0x00000001);	#endif	        SNGKS32C_TIMER_REG_WRITE (S3C44B0X_TCON, 0x00000000);                sysHwInit2 ();        sysClkConnected = TRUE;        }    sysClkRoutine   = NULL;    sysClkArg        = arg;#if ((CPU_FAMILY == ARM) && ARM_THUMB)    /* set b0 so that sysClkConnect() can be used from shell */    sysClkRoutine = (FUNCPTR)((UINT32)routine | 1);#else    sysClkRoutine = routine;#endif /* CPU_FAMILY == ARM */    return (OK);    }/********************************************************************************* sysClkDisable - turn off system clock interrupts** This routine disables system clock interrupts.** RETURNS: N/A** SEE ALSO: sysClkEnable()*/void sysClkDisable (void)    {    /*int oier;*/	/* Amine: deleted */        if (sysClkRunning)        {      	/* Amine: deleted */          /*SNGKS32C_TIMER_REG_READ (SNGKS32C_TIMER_TMOD, oier);*/        /*SNGKS32C_TIMER_REG_WRITE (SNGKS32C_TIMER_TMOD, oier & ~(1));*/		/* Amine: added */		SNGKS32C_TIMER_REG_WRITE (S3C44B0X_TCON, 0x00000000);		        /* disable timer interrupt in the interrupt controller */            SNGKS32C_TIMER_INT_DISABLE (SYS_TIMER_INT_LVL);        sysClkRunning = FALSE;        }    }/********************************************************************************* sysClkEnable - turn on system clock interrupts** This routine enables system clock interrupts.** RETURNS: N/A** SEE ALSO: sysClkConnect(), sysClkDisable(), sysClkRateSet()*/void sysClkEnable (void)    {    /*UINT32 oier;*/	/* Amine: deleted */    if (!sysClkRunning)        {        /*         * Load the match register with a new value calculated by         * adding the ticks per interrupt to the current value of the         * counter register.  Note that this may wraparound to a value         * less than the current counter value but thats OK.         */		/* Amine: deleted */        /*SNGKS32C_TIMER_REG_WRITE (SNGKS32C_TIMER_TDATA_0, SYS_TIMER_CLK / sysClkTicksPerSecond);*/        /*SNGKS32C_TIMER_REG_READ (SNGKS32C_TIMER_TMOD,oier);*/        /*SNGKS32C_TIMER_REG_WRITE (SNGKS32C_TIMER_TMOD, oier|1);*/		/* Amine: added */	#if(BOARD_TYPE == BOARD_ARMEPS)		/*set T5 count*/		SNGKS32C_TIMER_REG_WRITE (S3C44B0X_TCNTB5, (165*(1000/sysClkTicksPerSecond)));        /*update T5*/        SNGKS32C_TIMER_REG_WRITE (S3C44B0X_TCON, 0x02000000);        /*auto reload and start T5*/		SNGKS32C_TIMER_REG_WRITE (S3C44B0X_TCON, 0x05000000);	#else		/*set T0 count*/		SNGKS32C_TIMER_REG_WRITE (S3C44B0X_TCNTB0, (165*(1000/sysClkTicksPerSecond)));        /*update T0*/        SNGKS32C_TIMER_REG_WRITE (S3C44B0X_TCON, 0x00000002);        /*auto reload and start T0*/		SNGKS32C_TIMER_REG_WRITE (S3C44B0X_TCON, 0x00000009);	#endif                /* enable clock interrupt in interrupt controller */                SNGKS32C_TIMER_INT_ENABLE (SYS_TIMER_INT_LVL);        sysClkRunning = TRUE;        }    }/********************************************************************************* sysClkRateGet - get the system clock rate** This routine returns the system clock rate.** RETURNS: The number of ticks per second of the system clock.** SEE ALSO: sysClkEnable(), sysClkRateSet()*/int sysClkRateGet (void)    {    return (sysClkTicksPerSecond);    }/********************************************************************************* sysClkRateSet - set the system clock rate** This routine sets the interrupt rate of the system clock.* It is called by usrRoot() in usrConfig.c.** RETURNS: OK, or ERROR if the tick rate is invalid or the timer cannot be set.** SEE ALSO: sysClkEnable(), sysClkRateGet()*/STATUS sysClkRateSet    (    int ticksPerSecond        /* number of clock interrupts per second */    )    {    if (ticksPerSecond < SYS_CLK_RATE_MIN || ticksPerSecond > SYS_CLK_RATE_MAX)        return (ERROR);    sysClkTicksPerSecond = ticksPerSecond;    if (sysClkRunning)        {        sysClkDisable ();        sysClkEnable ();        }    return (OK);    }/********************************************************************************* sysAuxClkInt - handle an auxiliary clock interrupt** This routine handles an auxiliary clock interrupt.  It acknowledges the* interrupt and calls the routine installed by sysAuxClkConnect().** RETURNS: N/A*/void sysAuxClkInt (void)