/* sngks32cTimer.c - Samsung KS32C timer library *//* Copyright 1984-2001 Wind River Systems, Inc. */#include "copyright_wrs.h"/*modification history--------------------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"void myDelay();/* defines *//* The default is to assume memory mapped I/O */#ifndef AT91C_ST_REG_READ#define AT91C_ST_REG_READ(reg, result) \    ((result) = *(volatile UINT32 *)(reg))#endif #ifndef AT91C_ST_REG_WRITE#define AT91C_ST_REG_WRITE(reg, data) \    (*((volatile UINT32 *)(reg)) = (data))#endif #ifndef AT91C_ST_INT_ENABLE#define AT91C_ST_INT_ENABLE(level) intEnable(level)#endif#ifndef AT91C_ST_INT_DISABLE#define AT91C_ST_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)    {/*	int status,mask;*/    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)        {        AT91C_ST_REG_WRITE (AT91C_ST_IDR, 1);/*disable the PIT  interrupt */	         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)    {      if (sysClkRunning)        {                /* disable pit interrupt in the st controller */	        AT91C_ST_REG_WRITE (AT91C_ST_IDR , 1);        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)    {    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.         */        AT91C_ST_REG_WRITE (AT91C_ST_PIMR, SYS_ST_CLK / sysClkTicksPerSecond);        /* enable pit  interrupt in st interrupt enable controller  sys interrupt in AIC */        AT91C_ST_REG_WRITE (AT91C_ST_IER, 1);	 AT91C_ST_REG_WRITE (AT91C_AIC_IECR,2);	                   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*/#if 0void sysAuxClkInt (void)    {    /* call auxiliary clock service routine */    if (sysAuxClkRoutine != NULL)        (*sysAuxClkRoutine) (sysAuxClkArg);    }/********************************************************************************* sysAuxClkConnect - connect a routine to the auxiliary clock interrupt** This routine specifies the interrupt service routine to be called at each* auxiliary clock interrupt.  It does not enable auxiliary clock interrupts.** RETURNS: OK, or ERROR if the routine cannot be connected to the interrupt.** SEE ALSO: intConnect(), sysAuxClkEnable()*/STATUS sysAuxClkConnect    (    FUNCPTR routine,    /* routine called at each aux clock interrupt */    int arg             /* argument to auxiliary clock interrupt routine */    )    {    sysAuxClkRoutine    = NULL;    sysAuxClkArg        = arg;#if ((CPU_FAMILY == ARM) && ARM_THUMB)    /* set b0 so that sysClkConnect() can be used from shell */