board/armltd/integrator/timer.c

   1 /*
   2  * (C) Copyright 2002
   3  * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
   4  * Marius Groeger <mgroeger@sysgo.de>
   5  *
   6  * (C) Copyright 2002
   7  * David Mueller, ELSOFT AG, <d.mueller@elsoft.ch>
   8  *
   9  * (C) Copyright 2003
  10  * Texas Instruments, <www.ti.com>
  11  * Kshitij Gupta <Kshitij@ti.com>
  12  *
  13  * (C) Copyright 2004
  14  * ARM Ltd.
  15  * Philippe Robin, <philippe.robin@arm.com>
  16  *
  17  * See file CREDITS for list of people who contributed to this
  18  * project.
  19  *
  20  * This program is free software; you can redistribute it and/or
  21  * modify it under the terms of the GNU General Public License as
  22  * published by the Free Software Foundation; either version 2 of
  23  * the License, or (at your option) any later version.
  24  *
  25  * This program is distributed in the hope that it will be useful,
  26  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28  * GNU General Public License for more details.
  29  *
  30  * You should have received a copy of the GNU General Public License
  31  * along with this program; if not, write to the Free Software
  32  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  33  * MA 02111-1307 USA
  34  */
  35
  36 #include <common.h>
  37 #include <div64.h>
  38
  39 #ifdef CONFIG_ARCH_CINTEGRATOR
  40 #define DIV_CLOCK_INIT  1
  41 #define TIMER_LOAD_VAL  0xFFFFFFFFL
  42 #else
  43 #define DIV_CLOCK_INIT  256
  44 #define TIMER_LOAD_VAL  0x0000FFFFL
  45 #endif
  46 /* The Integrator/CP timer1 is clocked at 1MHz
  47  * can be divided by 16 or 256
  48  * and can be set up as a 32-bit timer
  49  */
  50 /* U-Boot expects a 32 bit timer, running at CONFIG_SYS_HZ */
  51 /* Keep total timer count to avoid losing decrements < div_timer */
  52 static unsigned long long total_count = 0;
  53 static unsigned long long lastdec;       /* Timer reading at last call     */
  54 /* Divisor applied to timer clock */
  55 static unsigned long long div_clock = DIV_CLOCK_INIT;
  56 static unsigned long long div_timer = 1; /* Divisor to convert timer reading
  57                                           * change to U-Boot ticks
  58                                           */
  59 /* CONFIG_SYS_HZ = CONFIG_SYS_HZ_CLOCK/(div_clock * div_timer) */
  60 static ulong timestamp;         /* U-Boot ticks since startup */
  61
  62 #define READ_TIMER (*(volatile ulong *)(CONFIG_SYS_TIMERBASE+4))
  63
  64 /* all function return values in U-Boot ticks i.e. (1/CONFIG_SYS_HZ) sec
  65  *  - unless otherwise stated
  66  */
  67
  68 /* starts up a counter
  69  * - the Integrator/CP timer can be set up to issue an interrupt */
  70 int timer_init (void)
  71 {
  72         /* Load timer with initial value */
  73         *(volatile ulong *)(CONFIG_SYS_TIMERBASE + 0) = TIMER_LOAD_VAL;
  74 #ifdef CONFIG_ARCH_CINTEGRATOR
  75         /* Set timer to be
  76          *      enabled          1
  77          *      periodic         1
  78          *      no interrupts    0
  79          *      X                0
  80          *      divider 1       00 == less rounding error
  81          *      32 bit           1
  82          *      wrapping         0
  83          */
  84         *(volatile ulong *)(CONFIG_SYS_TIMERBASE + 8) = 0x000000C2;
  85 #else
  86         /* Set timer to be
  87          *      enabled          1
  88          *      free-running     0
  89          *      XX              00
  90          *      divider 256     10
  91          *      XX              00
  92          */
  93         *(volatile ulong *)(CONFIG_SYS_TIMERBASE + 8) = 0x00000088;
  94 #endif
  95
  96         /* init the timestamp */
  97         total_count = 0ULL;
  98         reset_timer_masked();
  99
 100         div_timer = CONFIG_SYS_HZ_CLOCK;
 101         do_div(div_timer, CONFIG_SYS_HZ);
 102         do_div(div_timer, div_clock);
 103
 104         return (0);
 105 }
 106
 107 /*
 108  * timer without interrupts
 109  */
 110 void reset_timer (void)
 111 {
 112         reset_timer_masked ();
 113 }
 114
 115 ulong get_timer (ulong base_ticks)
 116 {
 117         return get_timer_masked () - base_ticks;
 118 }
 119
 120 void set_timer (ulong ticks)
 121 {
 122         timestamp   = ticks;
 123         total_count = ticks * div_timer;
 124 }
 125
 126 /* delay usec useconds */
 127 void __udelay (unsigned long usec)
 128 {
 129         ulong tmo, tmp;
 130
 131         /* Convert to U-Boot ticks */
 132         tmo  = usec * CONFIG_SYS_HZ;
 133         tmo /= (1000000L);
 134
 135         tmp  = get_timer_masked();      /* get current timestamp */
 136         tmo += tmp;                     /* form target timestamp */
 137
 138         while (get_timer_masked () < tmo) {/* loop till event */
 139                 /*NOP*/;
 140         }
 141 }
 142
 143 void reset_timer_masked (void)
 144 {
 145         /* capure current decrementer value    */
 146         lastdec   = READ_TIMER;
 147         /* start "advancing" time stamp from 0 */
 148         timestamp = 0L;
 149 }
 150
 151 /* converts the timer reading to U-Boot ticks          */
 152 /* the timestamp is the number of ticks since reset    */
 153 ulong get_timer_masked (void)
 154 {
 155         /* get current count */
 156         unsigned long long now = READ_TIMER;
 157
 158         if(now > lastdec) {
 159                 /* Must have wrapped */
 160                 total_count += lastdec + TIMER_LOAD_VAL + 1 - now;
 161         } else {
 162                 total_count += lastdec - now;
 163         }
 164         lastdec = now;
 165
 166         /* Reuse "now" */
 167         now = total_count;
 168         do_div(now, div_timer);
 169         timestamp = now;
 170
 171         return timestamp;
 172 }
 173
 174 /* waits specified delay value and resets timestamp */
 175 void udelay_masked (unsigned long usec)
 176 {
 177         udelay(usec);
 178 }
 179
 180 /*
 181  * This function is derived from PowerPC code (read timebase as long long).
 182  * On ARM it just returns the timer value.
 183  */
 184 unsigned long long get_ticks(void)
 185 {
 186         return get_timer(0);
 187 }
 188
 189 /*
 190  * Return the timebase clock frequency
 191  * i.e. how often the timer decrements
 192  */
 193 ulong get_tbclk (void)
 194 {
 195         unsigned long long tmp = CONFIG_SYS_HZ_CLOCK;
 196
 197         do_div(tmp, div_clock);
 198
 199         return tmp;
 200 }