URL
https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk
Subversion Repositories openrisc_me
[/] [openrisc/] [trunk/] [gnu-src/] [newlib-1.18.0/] [newlib/] [libc/] [machine/] [spu/] [spu_timer_slih.c] - Rev 207
Compare with Previous | Blame | View Log
/* (C) Copyright IBM Corp. 2008 All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of IBM nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* Second Level Interrupt handler and related services for SPU timers. */ #include "spu_timer_internal.h" /* Resets decrementer to the specified value. Also updates software timebase to account for the time between the last decrementer reset and now. There are two cases: * Called by application to start a new timer. * Called by spu_clock to active the next timer. In both cases, the amount of time is the current interval timeout minus the current decrementer value. */ void __reset_spu_decr (int val) { /* The interrupt occurs when the msb goes from 0 to 1 or when the decrementer goes from 0 to -1. To be precisely accurate we should set the timer to the intverval -1, unless the interval passed in is 0 in which case it should be left at 0. */ int enable_val = (__likely (val)) ? val - 1 : 0; /* Decrementer must be stopped before writing it - minimize the time stopped. */ unsigned mask = __disable_spu_decr (); /* Perform tb correction before resettting the decrementer. the corrected value is the current timeout value minus the current decrementer value. Occasionally the read returns 0 - a second read will clear this condition. */ spu_readch (SPU_RdDec); int decval = spu_readch (SPU_RdDec); /* Restart decrementer with next timeout val. */ __enable_spu_decr (enable_val, mask); /* Update the timebase values before enabling for interrupts. */ __spu_tb_val += __spu_tb_timeout - decval; __spu_tb_timeout = enable_val; } /* Update software timebase and timeout value for the 'next to expire' timer. Called when starting a new timer so the timer list will have timeouts relative to the current time. */ static inline void __update_spu_tb_val (void) { int elapsed = __spu_tb_timeout - spu_readch (SPU_RdDec); #ifdef SPU_TIMER_DEBUG if (elapsed < 0) ABORT (); #endif __spu_tb_val += elapsed; /* Adjust the timeout for the timer next to expire. Note this could cause the timeout to go negative, if it was just about to expire when we called spu_timer_start. This is OK, since this can happen any time interrupts are disabled. We just schedule an immediate timeout in this case. */ if (__spu_timers_active) { __spu_timers_active->tmout -= elapsed; if (__spu_timers_active->tmout < 0) __spu_timers_active->tmout = 0; } } /* Add an allocated timer to the active list. The active list is sorted by timeout value. The timer at the head of the list is the timer that will expire next. The rest of the timers have a timeout value that is relative to the timer ahead of it on the list. This relative value is determined here, when the timer is added to the active list. When its position in the list is found, the timer's timeout value is set to its interval minus the sum of all the timeout values ahead of it. The timeout value for the timer following the newly added timer is then adjusted to a new relative value. If the newly added timer is at the head of the list, the decrementer is reset. This function is called by SLIH to restart multiple timers (reset == 0) or by spu_timer_start() to start a single timer (reset == 1). */ void __spu_timer_start (int id, int reset) { spu_timer_t *t; spu_timer_t **pn; spu_timer_t *start = &__spu_timers[id]; unsigned tmout_time = 0; unsigned my_intvl = start->intvl; unsigned was_enabled = spu_readch (SPU_RdMachStat) & 0x1; spu_idisable (); t = __spu_timers_active; pn = &__spu_timers_active; /* If the active list is empty, just add the timer with the timeout set to the interval. Otherwise find the place in the list for the timer, setting its timeout to its interval minus the sum of timeouts ahead of it. */ start->state = SPU_TIMER_ACTIVE; if (__likely (!t)) { __spu_timers_active = start; start->next = NULL; start->tmout = my_intvl; } else { /* Update swtb and timeout val of the next timer, so all times are relative to now. */ if (reset) __update_spu_tb_val (); while (t && (my_intvl >= (tmout_time + t->tmout))) { tmout_time += t->tmout; pn = &t->next;; t = t->next; } start->next = t; start->tmout = my_intvl - tmout_time; *pn = start; /* Adjust timeout for timer after us. */ if (t) t->tmout -= start->tmout; } if (reset && (__spu_timers_active == start)) __reset_spu_decr (__spu_timers_active->tmout); if (__unlikely (was_enabled)) spu_ienable (); } /* SLIH for decrementer. Manages software timebase and timers. Called by SPU FLIH. Assumes decrementer is still running (event not yet acknowledeged). */ unsigned int spu_clock_slih (unsigned status) { int decr_reset_val; spu_timer_t *active, *handled; unsigned was_enabled = spu_readch (SPU_RdMachStat) & 0x1; status &= ~MFC_DECREMENTER_EVENT; spu_idisable (); /* The decrementer has now expired. The decrementer event was acknowledged in the FLIH but not disabled. The decrementer will continue to run while we're running the clock/timer handler. The software clock keeps running, and accounts for all the time spent running handlers. Add the current timeout to the software timebase and set the timeout to DECR_MAX. This allows the "clock read" code to continue to work while we're in here, and gives us the most possible time to finish before another underflow. */ __spu_tb_val += __spu_tb_timeout; __spu_tb_timeout = DECR_MAX; /* For all timers that have the current timeout value, move them from the active list to the handled list and call their handlers. Note that the handled/stopped lists may be manipulated by the handlers if they wish to stop/free the timers. Note that only the first expired timer will reflect the real timeout value; the rest of the timers that had the same timeout value will have a relative value of zero. */ if (__spu_timers_active) { __spu_timers_active->tmout = 0; while ((active = __spu_timers_active) && (active->tmout <= TIMER_INTERVAL_WINDOW)) { __spu_timers_active = active->next; active->next = __spu_timers_handled; __spu_timers_handled = active; active->state = SPU_TIMER_HANDLED; (*active->func) (active->id); } } /* put the handled timers back on the list and restart decrementer. */ while ((handled = __spu_timers_handled) != NULL) { __spu_timers_handled = handled->next; __spu_timer_start (handled->id, 0); } /* Reset the decrementer before returning. If we have any active timers, we set it to the timeout value for the timer at the head of the list, else the default clock value. */ decr_reset_val = __spu_timers_active ? __spu_timers_active->tmout : CLOCK_START_VALUE; __reset_spu_decr (decr_reset_val); if (__likely (was_enabled)) spu_ienable (); return status; }