mirror of
https://github.com/autc04/Retro68.git
synced 2024-11-28 05:51:04 +00:00
222 lines
8.2 KiB
C
222 lines
8.2 KiB
C
/*
|
|
(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;
|
|
}
|