** This routine handles an auxiliary clock interrupt.  It acknowledges the* interrupt and calls the routine installed by sysAuxClkConnect().** RETURNS: N/A*/void sysAuxClkInt (void)    {        /* Clear Pending Interrupt by writing '1' to it */    IXP425_REG_TIMER_WRITE(IXP425_OSST, IXP425_OSST_TIMER_2_PEND);    /* And again to avoid another interrupt */    IXP425_REG_TIMER_WRITE(IXP425_OSST, IXP425_OSST_TIMER_2_PEND);    /* call auxiliary clock service routine */    (*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** SEE ALSO: intConnect(), sysAuxClkEnable()*/STATUS sysAuxClkConnect    (    FUNCPTR routine,	/* routine called at each aux. clock interrupt */    int	    arg		/* argument with which to call routine	       */    )    {    /* temporarily set to dummy function so old routine is not accidently called     * with the new argument while we are in the process of reconnecting     */    sysAuxClkRoutine   = (FUNCPTR)sysAuxClkDummyRoutine;    sysAuxClkArg       = arg;    sysAuxClkRoutine   = routine;    if(!sysAuxClkConnected)	{        (void)intConnect ((void *)INT_VEC_TIMER2, sysAuxClkInt, 0);        sysAuxClkConnected = TRUE;	}    return (OK);    }/***************************************************************************** sysAuxClkDisconnect - clear the auxiliary clock routine** This routine disables the auxiliary clock interrupt, stops the timer,* and disconnects the routine currently connected to the auxiliary clock* interrupt.** RETURNS: N/A** SEE ALSO: sysAuxClkConnect(), sysAuxClkEnable()*/void sysAuxClkDisconnect (void)    {    if (sysAuxClkRunning)        {        /* disable the auxiliary clock interrupt */        sysAuxClkDisable ();        sysAuxClkRoutine = (FUNCPTR)sysAuxClkDummyRoutine;        sysAuxClkRunning = FALSE;        }    }/***************************************************************************** sysAuxClkDisable - turn off auxiliary clock interrupts** This routine disables auxiliary clock interrupts.** RETURNS: N/A** SEE ALSO: sysAuxClkEnable()*/void sysAuxClkDisable (void)    {    if (sysAuxClkRunning)	{	IXP425_REG_TIMER_WRITE( IXP425_OSRT2 , IXP425_OST_DISABLED );	intDisable(INT_VEC_TIMER2);	sysAuxClkRunning = FALSE;	}    }/***************************************************************************** sysAuxClkEnable - turn on auxiliary clock interrupts** This routine enables auxiliary clock interrupts.** RETURNS: N/A** SEE ALSO: sysAuxClkDisable()*/void sysAuxClkEnable (void)    {    if (!sysAuxClkRunning && sysAuxClkConnected)	{	sysAuxClkRunning  = TRUE;	IXP425_REG_TIMER_WRITE( IXP425_OSRT2 ,                                ((sysAuxClkRollOver & ~IXP425_OST_RELOAD_MASK)                                 |  IXP425_OST_ENABLE )  );	intEnable(INT_VEC_TIMER2);	}    }/***************************************************************************** sysAuxClkRateGet - get the auxiliary clock rate** This routine returns the interrupt rate of the auxiliary clock.** RETURNS: The number of ticks per second of the auxiliary clock.** SEE ALSO: sysAuxClkEnable(), sysAuxClkRateSet()*/int sysAuxClkRateGet (void)    {    return (sysAuxClkTicksPerSecond);    }/***************************************************************************** sysAuxClkRateSet - set the auxiliary clock rate** This routine sets the interrupt rate of the auxiliary clock.	It does not* enable auxiliary clock interrupts.** RETURNS: OK, or ERROR if the tick rate is invalid or the timer cannot be set.** SEE ALSO: sysAuxClkEnable(), sysAuxClkRateGet()*/STATUS sysAuxClkRateSet    (    int ticksPerSecond	    /* number of clock interrupts per second */    )    {    if (ticksPerSecond < AUX_CLK_RATE_MIN || ticksPerSecond > AUX_CLK_RATE_MAX)        return (ERROR);    sysAuxClkTicksPerSecond = ticksPerSecond;    sysAuxClkRollOver = ((TIMER_APB_CLOCK_MHZ * 0x1000000)                         / sysAuxClkTicksPerSecond);    return (OK);    }#ifdef INCLUDE_TIMESTAMP/********************************************************************************* sysTimestampInt - timestamp timer interrupt handler** This rountine handles the timestamp timer interrupt.  A user routine is* called, if one was connected by sysTimestampConnect().** RETURNS: N/A** SEE ALSO: sysTimestampConnect()*/void sysTimestampInt (void)    {     /* Clear Pending Interrupt by writing '1' to it */     IXP425_REG_TIMER_WRITE(IXP425_OSST, IXP425_OSST_TIMER_TS_PEND);    if (sysTimestampRunning && sysTimestampRoutine != NULL)        (*sysTimestampRoutine)(sysTimestampArg);    }/**************************************************************************** sysTimestampConnect - connect a user routine to a timestamp timer interrupt** This routine specifies the user interrupt routine to be called at each* timestamp timer interrupt.** RETURNS: OK, or ERROR if sysTimestampInt() has not been used.** SEE ALSO: sysTimestampEnable()*/STATUS sysTimestampConnect    (    FUNCPTR routine, /* routine called at each timestamp timer interrupt */    int arg	     /* argument with which to call routine */    )    {    static BOOL connected = FALSE;    sysTimestampRoutine = NULL;    sysTimestampArg = arg;    sysTimestampRoutine = routine;    if (!connected)        {        (void)intConnect ((void *)INT_VEC_TIMESTAMP, sysTimestampInt, 0);        connected = TRUE;        }    return OK;    }/**************************************************************************** sysTimestampEnable - enable a timestamp timer interrupt** This routine enables timestamp timer interrupts and resets the counter.** RETURNS: OK, or ERROR if the timestamp timer cannot be enabled.** SEE ALSO: sysTimestampDisable()*/STATUS sysTimestampEnable(void)    {    if(!sysTimestampRunning)	{	sysTimestampRunning = TRUE;	intEnable(INT_VEC_TIMESTAMP);	}    return (OK);    }/**************************************************************************** sysTimestampDisable - disable a timestamp timer interrupt** This routine disables the timestamp timer.  It does not directly disable* interrupts.  However, the tick counter does not increment once the* timestamp timer is disabled, thus, interrupts are no longer generated.* This routine merely resets the timer counter.** RETURNS: OK, ERROR if the timestamp timer cannot be disabled.** SEE ALSO: sysTimestampEnable()*/STATUS sysTimestampDisable (void)    {    if (sysTimestampRunning)	{	intDisable(INT_VEC_TIMESTAMP);	sysTimestampRunning = FALSE;	}    return (OK);    }/**************************************************************************** sysTimestampPeriod - get the period of a timestamp timer** This routine gets the period of the timestamp timer, in ticks.  The* period, or terminal count, is the number of ticks to which the timestamp* timer counts before rolling over and restarting the counting process.** RETURNS: The period of the timestamp timer in counter ticks.*/UINT32 sysTimestampPeriod (void)    {    /*     * Return the timestamp timer period here.     * The highest period (maximum terminal count) should be used so     * that rollover interrupts are kept to a minimum.     *     */    return (clkPeriod());    }/**************************************************************************** sysTimestampFreq - get a timestamp timer clock frequency** This routine gets the frequency of the timer clock, in ticks per* second.  The rate of the timestamp timer is set explicitly by the* hardware and typically cannot be altered.** RETURNS: The timestamp timer clock frequency, in ticks per second.*/UINT32 sysTimestampFreq (void)    {    /*     * Return the timestamp tick output frequency here.     * This value can be determined from the following equation:     *	   timerFreq = clock input frequency / prescaler     *     * When possible, read the clock input frequency and prescaler values     * directly from chip registers.     */    return (clkFreq());    }/**************************************************************************** sysTimestamp - get a timestamp timer tick count** This routine returns the current value of the timestamp timer tick counter.* The tick count can be converted to seconds by dividing it by the return of* sysTimestampFreq().** This routine should be called with interrupts locked.	 If interrupts are* not locked, sysTimestampLock() should be used instead.** RETURNS: The current timestamp timer tick count.** SEE ALSO: sysTimestampFreq(), sysTimestampLock()*/UINT32 sysTimestamp (void)    {    UINT32 ticks = 0;    if (sysTimestampRunning)    {    /* Read the timer counter register */    ticks = clkTimestamp();    }    /* return the timestamp timer tick count here */    return (ticks);    }/**************************************************************************** sysTimestampLock - lock interrupts and get the timestamp timer tick count** This routine locks interrupts when the tick counter must be stopped* in order to read it or when two independent counters must be read.* It then returns the current value of the timestamp timer tick* counter.** The tick count can be converted to seconds by dividing it by the return of* sysTimestampFreq().** If interrupts are already locked, sysTimestamp() should be* used instead.** RETURNS: The current timestamp timer tick count.** SEE ALSO: sysTimestampFreq(), sysTimestamp()*/UINT32 sysTimestampLock (void)    {    int locKey;    UINT32 ticks = 0;    if (sysTimestampRunning)    {    /* Lock Interrupts */    locKey = intLock();    /* Read the timer counter register */    ticks = clkTimestamp();    /* UnLock Interrupts */    intUnlock (locKey);    }    /* return the timestamp timer tick count here */    return (ticks);    }#endif	 /* INCLUDE_TIMESTAMP */