1da177e4c3
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
133 lines
3.9 KiB
C
133 lines
3.9 KiB
C
/*
|
|
* arch/v850/kernel/highres_timer.c -- High resolution timing routines
|
|
*
|
|
* Copyright (C) 2001,02,03 NEC Electronics Corporation
|
|
* Copyright (C) 2001,02,03 Miles Bader <miles@gnu.org>
|
|
*
|
|
* This file is subject to the terms and conditions of the GNU General
|
|
* Public License. See the file COPYING in the main directory of this
|
|
* archive for more details.
|
|
*
|
|
* Written by Miles Bader <miles@gnu.org>
|
|
*/
|
|
|
|
#include <asm/system.h>
|
|
#include <asm/v850e_timer_d.h>
|
|
#include <asm/highres_timer.h>
|
|
|
|
#define HIGHRES_TIMER_USEC_SHIFT 12
|
|
|
|
/* Pre-calculated constant used for converting ticks to real time
|
|
units. We initialize it to prevent it being put into BSS. */
|
|
static u32 highres_timer_usec_prescale = 1;
|
|
|
|
void highres_timer_slow_tick_irq (void) __attribute__ ((noreturn));
|
|
void highres_timer_slow_tick_irq (void)
|
|
{
|
|
/* This is an interrupt handler, so it must be very careful to
|
|
not to trash any registers. At this point, the stack-pointer
|
|
(r3) has been saved in the chip ram location ENTRY_SP by the
|
|
interrupt vector, so we can use it as a scratch register; we
|
|
must also restore it before returning. */
|
|
asm ("ld.w %0[r0], sp;"
|
|
"add 1, sp;"
|
|
"st.w sp, %0[r0];"
|
|
"ld.w %1[r0], sp;" /* restore pre-irq stack-pointer */
|
|
"reti"
|
|
::
|
|
"i" (HIGHRES_TIMER_SLOW_TICKS_ADDR),
|
|
"i" (ENTRY_SP_ADDR)
|
|
: "memory");
|
|
}
|
|
|
|
void highres_timer_reset (void)
|
|
{
|
|
V850E_TIMER_D_TMD (HIGHRES_TIMER_TIMER_D_UNIT) = 0;
|
|
HIGHRES_TIMER_SLOW_TICKS = 0;
|
|
}
|
|
|
|
void highres_timer_start (void)
|
|
{
|
|
u32 fast_tick_rate;
|
|
|
|
/* Start hardware timer. */
|
|
v850e_timer_d_configure (HIGHRES_TIMER_TIMER_D_UNIT,
|
|
HIGHRES_TIMER_SLOW_TICK_RATE);
|
|
|
|
fast_tick_rate =
|
|
(V850E_TIMER_D_BASE_FREQ
|
|
>> V850E_TIMER_D_DIVLOG2 (HIGHRES_TIMER_TIMER_D_UNIT));
|
|
|
|
/* The obvious way of calculating microseconds from fast ticks
|
|
is to do:
|
|
|
|
usec = fast_ticks * 10^6 / fast_tick_rate
|
|
|
|
However, divisions are much slower than multiplications, and
|
|
the above calculation can overflow, so we do this instead:
|
|
|
|
usec = fast_ticks * (10^6 * 2^12 / fast_tick_rate) / 2^12
|
|
|
|
since we can pre-calculate (10^6 * (2^12 / fast_tick_rate))
|
|
and use a shift for dividing by 2^12, this avoids division,
|
|
and is almost as accurate (it differs by about 2 microseconds
|
|
at the extreme value of the fast-tick counter's ranger). */
|
|
highres_timer_usec_prescale = ((1000000 << HIGHRES_TIMER_USEC_SHIFT)
|
|
/ fast_tick_rate);
|
|
|
|
/* Enable the interrupt (which is hardwired to this use), and
|
|
give it the highest priority. */
|
|
V850E_INTC_IC (IRQ_INTCMD (HIGHRES_TIMER_TIMER_D_UNIT)) = 0;
|
|
}
|
|
|
|
void highres_timer_stop (void)
|
|
{
|
|
/* Stop the timer. */
|
|
V850E_TIMER_D_TMCD (HIGHRES_TIMER_TIMER_D_UNIT) =
|
|
V850E_TIMER_D_TMCD_CAE;
|
|
/* Disable its interrupt, just in case. */
|
|
v850e_intc_disable_irq (IRQ_INTCMD (HIGHRES_TIMER_TIMER_D_UNIT));
|
|
}
|
|
|
|
inline void highres_timer_read_ticks (u32 *slow_ticks, u32 *fast_ticks)
|
|
{
|
|
int flags;
|
|
u32 fast_ticks_1, fast_ticks_2, _slow_ticks;
|
|
|
|
local_irq_save (flags);
|
|
fast_ticks_1 = V850E_TIMER_D_TMD (HIGHRES_TIMER_TIMER_D_UNIT);
|
|
_slow_ticks = HIGHRES_TIMER_SLOW_TICKS;
|
|
fast_ticks_2 = V850E_TIMER_D_TMD (HIGHRES_TIMER_TIMER_D_UNIT);
|
|
local_irq_restore (flags);
|
|
|
|
if (fast_ticks_2 < fast_ticks_1)
|
|
_slow_ticks++;
|
|
|
|
*slow_ticks = _slow_ticks;
|
|
*fast_ticks = fast_ticks_2;
|
|
}
|
|
|
|
inline void highres_timer_ticks_to_timeval (u32 slow_ticks, u32 fast_ticks,
|
|
struct timeval *tv)
|
|
{
|
|
unsigned long sec, sec_rem, usec;
|
|
|
|
usec = ((fast_ticks * highres_timer_usec_prescale)
|
|
>> HIGHRES_TIMER_USEC_SHIFT);
|
|
|
|
sec = slow_ticks / HIGHRES_TIMER_SLOW_TICK_RATE;
|
|
sec_rem = slow_ticks % HIGHRES_TIMER_SLOW_TICK_RATE;
|
|
|
|
usec += sec_rem * (1000000 / HIGHRES_TIMER_SLOW_TICK_RATE);
|
|
|
|
tv->tv_sec = sec;
|
|
tv->tv_usec = usec;
|
|
}
|
|
|
|
void highres_timer_read (struct timeval *tv)
|
|
{
|
|
u32 fast_ticks, slow_ticks;
|
|
highres_timer_read_ticks (&slow_ticks, &fast_ticks);
|
|
highres_timer_ticks_to_timeval (slow_ticks, fast_ticks, tv);
|
|
}
|