sysAuxClkRoutine   = routine;    sysAuxClkArg       = arg;    if(!sysAuxClkConnected)	{        (void)intConnect (INUM_TO_IVEC(template_INT_TMR1), sysAuxClkInt, 0);        /* Lock Interrupts */        locKey = intLock();        sysEnable_Reload_TMR1 ();        /* UnLock Interrupts */        intUnlock (locKey);         sysAuxClkConnected = TRUE;	}    return (OK);    }/***************************************************************************** sysAuxClkDisable - turn off auxiliary clock interrupts** This routine disables auxiliary clock interrupts.** RETURNS: N/A** SEE ALSO: sysAuxClkEnable()*/void sysAuxClkDisable (void)    {    int locKey;    if (sysAuxClkRunning)	{        intDisable(template_INT_TMR1);        /* Lock Interrupts */        locKey = intLock();        sysDisable_TMR1 ();        /* UnLock Interrupts */        intUnlock (locKey);        sysAuxClkRunning = FALSE;	}    }/***************************************************************************** sysAuxClkEnable - turn on auxiliary clock interrupts** This routine enables auxiliary clock interrupts.** RETURNS: N/A** SEE ALSO: sysAuxClkDisable()*/void sysAuxClkEnable (void)    {    int locKey;    if (!sysAuxClkRunning)	{        /* Lock Interrupts */        locKey = intLock();        sysWrite_TCR1 (sysClockTimerRollOver);        sysWrite_TRR1 (sysClockTimerRollOver);        sysEnable_TMR1 ();        /* UnLock Interrupts */        intUnlock (locKey);        intEnable(template_INT_TMR1);        sysAuxClkRunning  = TRUE;	}    }/***************************************************************************** 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 (sysAuxClockTicksPerSecond);    }/***************************************************************************** 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 */    )    {    int locKey;    if (ticksPerSecond < AUX_CLK_RATE_MIN || ticksPerSecond > AUX_CLK_RATE_MAX)    return (ERROR);    /* Lock Interrupts */    locKey = intLock();    /* 600MHz/16 = 37.5MHz, at 37.5Mhz clock, 60 ticks per sec. requires rollover of 625000 */    sysWrite_CSel_TMR1 (template_TMR_CSEL_CORE16);    /* UnLock Interrupts */    intUnlock (locKey);    sysAuxClockTicksPerSecond = ticksPerSecond;    sysAuxClockTimerRollOver = (_busClockRate / sysAuxClockTicksPerSecond);    if (sysAuxClkRunning)        {        sysAuxClkDisable ();        sysAuxClkEnable ();        }    return (OK);    }#endif#ifdef INCLUDE_TIMESTAMP/**************************************************************************** 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 */    )    {    return (ERROR);    }/**************************************************************************** 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;	}    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)	{	sysTimestampRunning = FALSE;	}    return (ERROR);    }/**************************************************************************** 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 (sysClockTimerRollOver);    }/**************************************************************************** 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 (_busClockRate);    }/**************************************************************************** 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 = sysRead_TCR0 ();    }    /* 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 = sysRead_TCR0 ();    /* UnLock Interrupts */    intUnlock (locKey);    }    /* return the timestamp timer tick count here */    return (ticks);    }#endif   /* INCLUDE_TIMESTAMP */