minix/u-boot
1
0
Fork 0
mirror of https://github.com/Stichting-MINIX-Research-Foundation/u-boot.git synced 2025-09-10 12:39:22 -04:00
Code Issues Packages Projects Releases Wiki Activity

arm: a320: fix broken timer

Browse Source 
timer.c used static data and are called before relocation.
Move all static variables into global_data structure. Also cleanup
timer.c from unused stubs and make it truly use 64 bit tick values.

Remove reset_timer_masked() get_timer_masked()

reference: arch/arm/cpu/arm926ejs/at91/timer.c

Based on Reinhard Meyer <u-boot@emk-elektronik.de>'s patches
5dca710a3d7703e41da0e9894f2d71f9e25bea6b
cfff263f41e32c7ba2ee9162a8cc6423eb5a8390

Signed-off-by: Po-Yu Chuang <ratbert@faraday-tech.com>
Tested-by: Macpaul Lin <macpaul@gmail.com>
This commit is contained in:
Po-Yu Chuang 2011-08-10 17:44:21 +00:00 committed by Albert ARIBAUD
parent a3e09cc28c
commit 60d1ea94ea
1 changed files with 58 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

150
arch/arm/cpu/arm920t/a320/timer.c
View File

@ -18,20 +18,35 @@
*/ */
#include <common.h> #include <common.h>
#include <div64.h>
#include <asm/io.h> #include <asm/io.h>
#include <faraday/ftpmu010.h> #include <faraday/ftpmu010.h>
#include <faraday/fttmr010.h> #include <faraday/fttmr010.h>
static ulong timestamp; DECLARE_GLOBAL_DATA_PTR;
static ulong lastdec;
static struct fttmr010 *tmr = (struct fttmr010 *)CONFIG_FTTMR010_BASE;
#define TIMER_CLOCK 32768 #define TIMER_CLOCK 32768
#define TIMER_LOAD_VAL 0xffffffff #define TIMER_LOAD_VAL 0xffffffff
static inline unsigned long long tick_to_time(unsigned long long tick)
{
tick *= CONFIG_SYS_HZ;
do_div(tick, gd->timer_rate_hz);
return tick;
}
static inline unsigned long long usec_to_tick(unsigned long long usec)
{
usec *= gd->timer_rate_hz;
do_div(usec, 1000000);
return usec;
}
int timer_init(void) int timer_init(void)
{ {
struct fttmr010 *tmr = (struct fttmr010 *)CONFIG_FTTMR010_BASE;
unsigned int cr; unsigned int cr;
debug("%s()\n", __func__); debug("%s()\n", __func__);
@ -59,106 +74,57 @@ int timer_init(void)
cr |= FTTMR010_TM3_ENABLE; cr |= FTTMR010_TM3_ENABLE;
writel(cr, &tmr->cr); writel(cr, &tmr->cr);
/* init the timestamp and lastdec value */ gd->timer_rate_hz = TIMER_CLOCK;
reset_timer_masked(); gd->tbu = gd->tbl = 0;
return 0; return 0;
} }
/* /*
* timer without interrupts * Get the current 64 bit timer tick count
*/
/*
* reset time
*/
void reset_timer_masked(void)
{
/* capure current decrementer value time */
lastdec = readl(&tmr->timer3_counter) / (TIMER_CLOCK / CONFIG_SYS_HZ);
timestamp = 0; /* start "advancing" time stamp from 0 */
debug("%s(): lastdec = %lx\n", __func__, lastdec);
}
/*
* return timer ticks
*/
ulong get_timer_masked(void)
{
/* current tick value */
ulong now = readl(&tmr->timer3_counter) / (TIMER_CLOCK / CONFIG_SYS_HZ);
debug("%s(): now = %lx, lastdec = %lx\n", __func__, now, lastdec);
if (lastdec >= now) {
/*
* normal mode (non roll)
* move stamp fordward with absoulte diff ticks
*/
timestamp += lastdec - now;
} else {
/*
* we have overflow of the count down timer
*
* nts = ts + ld + (TLV - now)
* ts=old stamp, ld=time that passed before passing through -1
* (TLV-now) amount of time after passing though -1
* nts = new "advancing time stamp"...it could also roll and
* cause problems.
*/
timestamp += lastdec + TIMER_LOAD_VAL - now;
}
lastdec = now;
debug("%s() returns %lx\n", __func__, timestamp);
return timestamp;
}
/*
* return difference between timer ticks and base
*/
ulong get_timer(ulong base)
{
debug("%s(%lx)\n", __func__, base);
return get_timer_masked() - base;
}
/* delay x useconds AND preserve advance timestamp value */
void __udelay(unsigned long usec)
{
long tmo = usec * (TIMER_CLOCK / 1000) / 1000;
unsigned long now, last = readl(&tmr->timer3_counter);
debug("%s(%lu)\n", __func__, usec);
while (tmo > 0) {
now = readl(&tmr->timer3_counter);
if (now > last) /* count down timer overflow */
tmo -= TIMER_LOAD_VAL + last - now;
else
tmo -= last - now;
last = now;
}
}
/*
* This function is derived from PowerPC code (read timebase as long long).
* On ARM it just returns the timer value.
*/ */
unsigned long long get_ticks(void) unsigned long long get_ticks(void)
{ {
debug("%s()\n", __func__); struct fttmr010 *tmr = (struct fttmr010 *)CONFIG_FTTMR010_BASE;
return get_timer(0); ulong now = TIMER_LOAD_VAL - readl(&tmr->timer3_counter);
/* increment tbu if tbl has rolled over */
if (now < gd->tbl)
gd->tbu++;
gd->tbl = now;
return (((unsigned long long)gd->tbu) << 32) | gd->tbl;
}
void __udelay(unsigned long usec)
{
unsigned long long start;
ulong tmo;
start = get_ticks(); /* get current timestamp */
tmo = usec_to_tick(usec); /* convert usecs to ticks */
while ((get_ticks() - start) < tmo)
; /* loop till time has passed */
} }
/* /*
* This function is derived from PowerPC code (timebase clock frequency). * get_timer(base) can be used to check for timeouts or
* On ARM it returns the number of timer ticks per second. * to measure elasped time relative to an event:
*
* ulong start_time = get_timer(0) sets start_time to the current
* time value.
* get_timer(start_time) returns the time elapsed since then.
*
* The time is used in CONFIG_SYS_HZ units!
*/
ulong get_timer(ulong base)
{
return tick_to_time(get_ticks()) - base;
}
/*
* Return the number of timer ticks per second.
*/ */
ulong get_tbclk(void) ulong get_tbclk(void)
{ {
debug("%s()\n", __func__); return gd->timer_rate_hz;
return CONFIG_SYS_HZ;
} }