sysAuxClkRoutine = (FUNCPTR)((UINT32)routine | 1);#else    sysAuxClkRoutine = routine;#endif /* CPU_FAMILY == ARM */    return (OK);    }/********************************************************************************* sysAuxClkDisable - turn off auxiliary clock interrupts** This routine disables auxiliary clock interrupts.** RETURNS: N/A** SEE ALSO: sysAuxClkEnable()*/void sysAuxClkDisable (void)    {    UINT32 oier;        if (sysAuxClkRunning)        {        /* disable timer interrupt in the timer */                SNGKS32C_TIMER_REG_READ (SNGKS32C_TIMER_TMOD, oier);        SNGKS32C_TIMER_REG_WRITE (SNGKS32C_TIMER_TMOD, oier & ~(1 << 3));        /* disable timer interrupt in the interrupt controller */        SNGKS32C_TIMER_INT_DISABLE (AUX_TIMER_INT_LVL);        sysAuxClkRunning = FALSE;        }    }/********************************************************************************* sysAuxClkEnable - turn on auxiliary clock interrupts** This routine enables auxiliary clock interrupts.** RETURNS: N/A** SEE ALSO: sysAuxClkConnect(), sysAuxClkDisable(), sysAuxClkRateSet()*/void sysAuxClkEnable (void)    {    UINT32 oier;    static BOOL connected = FALSE;    if (!connected)        {        intConnect (INUM_TO_IVEC (INT_LVL_TIMER1), sysAuxClkInt, 0);        connected = TRUE;        }    if (!sysAuxClkRunning)        {        /*         * Calculate the number of ticks of the timer clock that this         * period requires.  Do this once, here, so that the timer interrupt         * routine does not need to perform a division.         */        sysAuxClkTicks = (AUX_TIMER_CLK / sysAuxClkTicksPerSecond);        /*         * 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 that's OK.         */        SNGKS32C_TIMER_REG_WRITE (SNGKS32C_TIMER_TDATA_1, sysAuxClkTicks);        /* enable timer 1 */        SNGKS32C_TIMER_REG_READ (SNGKS32C_TIMER_TMOD, oier);        SNGKS32C_TIMER_REG_WRITE (SNGKS32C_TIMER_TMOD, oier | 8);        /* enable clock interrupt in interrupt controller */        SNGKS32C_TIMER_INT_ENABLE (AUX_TIMER_INT_LVL);        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 (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;    if (sysAuxClkRunning)        {        sysAuxClkDisable ();        sysAuxClkEnable ();        }    return (OK);    }#endif/* it is my defination*/#if 0#ifdef  INCLUDE_TIMESTAMP/********************************************************************************* sysTimestampInt - timestamp timer interrupt handler** This routine 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)    {    if (sysTimestampRunning && sysTimestampRoutine != NULL)        (*sysTimestampRoutine)(sysTimestampArg);    }/********************************************************************************* sysTimestampConnect - connect a user routine to the timestamp timer interrupt** This routine specifies the user interrupt routine to be called at each* timestamp timer interrupt.  It does not enable the timestamp timer itself.** RETURNS: OK, or ERROR if sysTimestampInt() interrupt handler is not used.*/STATUS sysTimestampConnect    (    FUNCPTR routine,    /* routine called at each timestamp timer interrupt */    int arg     /* argument with which to call routine */    )    {    return ERROR;    /* System clock tick specifies a rollover event */    }/********************************************************************************* sysTimestampEnable - initialize and enable the timestamp timer** This routine connects the timestamp timer interrupt and initializes the* counter registers.  If the timestamp timer is already running, this routine* merely resets the timer counter.** The rate of the timestamp timer should be set explicitly within the BSP,* in the sysHwInit() routine.  This routine does not initialize the timer* rate.** RETURNS: OK, or ERROR if hardware cannot be enabled.*/STATUS sysTimestampEnable (void)    {    if (!sysTimestampRunning)        {        sysTimestampRunning = TRUE;        }    sysClkEnable();    /* make sure that system clock is running */    return (OK);    }/********************************************************************************* sysTimestampDisable - disable the timestamp timer** This routine disables the timestamp timer.  Interrupts are not disabled,* although the tick counter will not increment after the timestamp timer* is disabled, thus interrupts will no longer be generated.** RETURNS: OK, or ERROR if timer cannot be disabled.*/STATUS sysTimestampDisable (void)    {    if (sysTimestampRunning)        sysTimestampRunning = FALSE;    return (OK);    }/********************************************************************************* sysTimestampPeriod - get the timestamp timer period** This routine returns the period of the timestamp timer in ticks.* The period, or terminal count, is the number of ticks to which the timestamp* timer will count before rolling over and restarting the counting process.** RETURNS: The period of the timestamp timer in counter ticks.*/UINT32 sysTimestampPeriod (void)    {    return (SYS_TIMER_CLK / sysClkTicksPerSecond);    }/********************************************************************************* sysTimestampFreq - get the timestamp timer clock frequency** This routine returns the frequency of the timer clock, in ticks per second.** RETURNS: The timestamp timer clock frequency, in ticks per second.*/UINT32 sysTimestampFreq (void)    {    return (SYS_TIMER_CLK);    }/********************************************************************************* sysTimestamp - get the 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 by the return of* sysTimestampFreq().** This routine should be called with interrupts locked.  If interrupts are* not already locked, sysTimestampLock() should be used instead.** RETURNS: The current timestamp timer tick count.** SEE ALSO: sysTimestampLock()*/UINT32 sysTimestamp (void)    {    UINT32 count;    SNGKS32C_TIMER_REG_READ (SNGKS32C_TIMER_TCNT_0, count);    /* timer counts down to 0 from sysClkTicks load value */    return (sysTimestampPeriod() - count);    }/********************************************************************************* sysTimestampLock - get the 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 by the return of* sysTimestampFreq().** This routine locks interrupts for cases where it is necessary to stop the* tick counter in order to read it, or when two independent counters must* be read.  If interrupts are already locked, sysTimestamp() should be* used instead.** RETURNS: The current timestamp timer tick count.** SEE ALSO: sysTimestamp()*/UINT32 sysTimestampLock (void)    {    UINT32 result;    result = sysTimestamp ();    return (result);    }#endif  /* INCLUDE_TIMESTAMP */#endif /*it is my define*/#if 0void myDelay(){	int i;		*(volatile UINT32 *)0xfffff800 = 0x35;	*(volatile UINT32 *)0xfffff810 = 0x35;		while(1)	{	*(volatile UINT32 *)0xfffff834 = 0x35;/*lit*/		for(i=0;i<1000000;i++);		*(volatile UINT32 *)0xfffff830 = 0x35;		for(i=0;i<1000000;i++);		}}#endif