arch/arm/cpu/armv7/tiger/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  * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
   8  * Alex Zuepke <azu@sysgo.de>
   9  *
  10  * (C) Copyright 2002
  11  * Gary Jennejohn, DENX Software Engineering, <gj@denx.de>
  12  *
  13  * (C) Copyright 2009
  14  * Ilya Yanok, Emcraft Systems Ltd, <yanok@emcraft.com>
  15  *
  16  * (C) Copyright 2009 DENX Software Engineering
  17  * Author: John Rigby <jrigby@gmail.com>
  18  *      Add support for MX25
  19  *
  20  * See file CREDITS for list of people who contributed to this
  21  * project.
  22  *
  23  * This program is free software; you can redistribute it and/or
  24  * modify it under the terms of the GNU General Public License as
  25  * published by the Free Software Foundation; either version 2 of
  26  * the License, or (at your option) any later version.
  27  *
  28  * This program is distributed in the hope that it will be useful,
  29  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  30  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  31  * GNU General Public License for more details.
  32  *
  33  * You should have received a copy of the GNU General Public License
  34  * along with this program; if not, write to the Free Software
  35  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  36  * MA 02111-1307 USA
  37  */
  38
  39 #include <common.h>
  40 #include <div64.h>
  41 #include <asm/io.h>
  42 #include <linux/types.h>
  43 #include <asm/arch/chip_drv_config_extern.h>
  44 #include <asm/arch/bits.h>
  45 #include "asm/arch/syscnt_drv.h"
  46 #include "asm/arch/sci_types.h"
  47
  48 #define TIMER_MAX_VALUE 0xFFFFFFFF
  49
  50
  51 static unsigned long long timestamp;
  52 static ulong lastinc;
  53
  54 /*
  55  * "time" is measured in 1 / CONFIG_SYS_HZ seconds,
  56  * "tick" is internal timer period
  57  */
  58 static inline unsigned long long tick_to_time(unsigned long long tick)
  59 {
  60         tick *= CONFIG_SYS_HZ;
  61         do_div(tick, CONFIG_SPRD_TIMER_CLK);
  62         return tick;
  63 }
  64
  65 static inline unsigned long long time_to_tick(unsigned long long time)
  66 {
  67         time *= CONFIG_SPRD_TIMER_CLK;
  68         do_div(time, CONFIG_SYS_HZ);
  69         return time;
  70 }
  71
  72 static inline unsigned long long us_to_tick(unsigned long long us)
  73 {
  74         us = us*CONFIG_SPRD_TIMER_CLK;
  75         do_div(us, CONFIG_SYS_HZ*1000);
  76         return us;
  77 }
  78
  79
  80 /* nothing really to do with interrupts, just starts up a counter. */
  81 /* The 32KHz 23-bit timer overruns in 512 seconds */
  82
  83 int timer_init(void)
  84 {
  85         REG32(GR_GEN0) |= BIT_19; //make sys cnt writable
  86         REG32(GR_GEN0) |= BIT_27; //enable rtc clk input
  87
  88         //clear any hanging interrupts & disable interrupt
  89         REG32 (SYS_CTL) &=~ (BIT_0);
  90         REG32 (SYS_CTL) |= (BIT_3);
  91         return 0;
  92 }
  93
  94 void reset_timer(void)
  95 {
  96         //capture current incrementer value time
  97         lastinc = readl(SYS_CNT0);
  98         timestamp = 0;
  99 }
 100 void reset_timer_masked(void)
 101 {
 102         reset_timer();
 103 }
 104 unsigned long long get_ticks(void)
 105 {
 106         ulong now = readl(SYS_CNT0);
 107
 108         if(now >= lastinc) {
 109         /* not roll
 110          * move stamp forward with absolut diff ticks
 111          * */
 112                 timestamp += (now - lastinc);
 113         }else{
 114                 //timer roll over
 115                 timestamp += (TIMER_MAX_VALUE - lastinc) + now;
 116         }
 117         lastinc = now;
 118         return timestamp;
 119 }
 120
 121 ulong get_timer_masked(void)
 122 {
 123         return tick_to_time(get_ticks());
 124 }
 125
 126 ulong get_timer(ulong base)
 127 {
 128         return get_timer_masked() - base;
 129 }
 130
 131 void set_timer(ulong t)
 132 {
 133         timestamp = time_to_tick(t);
 134 }
 135
 136 void __udelay (unsigned long usec)
 137 {
 138         unsigned long long tmp;
 139         ulong tmo;
 140
 141         tmo = us_to_tick(usec);
 142         tmp = get_ticks() + tmo; // get current timestamp
 143
 144         while(get_ticks() < tmp) //loop till event
 145                 /*NOP*/;
 146 }