Pull context-bitmap into release branch
[linux-2.6] / arch / arm / mach-realview / localtimer.c
1 /*
2  *  linux/arch/arm/mach-realview/localtimer.c
3  *
4  *  Copyright (C) 2002 ARM Ltd.
5  *  All Rights Reserved
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11 #include <linux/init.h>
12 #include <linux/kernel.h>
13 #include <linux/delay.h>
14 #include <linux/device.h>
15 #include <linux/smp.h>
16
17 #include <asm/mach/time.h>
18 #include <asm/hardware/arm_twd.h>
19 #include <asm/hardware/gic.h>
20 #include <asm/hardware.h>
21 #include <asm/io.h>
22 #include <asm/irq.h>
23
24 #include "core.h"
25
26 #define TWD_BASE(cpu)   (__io_address(REALVIEW_TWD_BASE) + \
27                          ((cpu) * REALVIEW_TWD_SIZE))
28
29 static unsigned long mpcore_timer_rate;
30
31 /*
32  * local_timer_ack: checks for a local timer interrupt.
33  *
34  * If a local timer interrupt has occured, acknowledge and return 1.
35  * Otherwise, return 0.
36  */
37 int local_timer_ack(void)
38 {
39         void __iomem *base = TWD_BASE(smp_processor_id());
40
41         if (__raw_readl(base + TWD_TIMER_INTSTAT)) {
42                 __raw_writel(1, base + TWD_TIMER_INTSTAT);
43                 return 1;
44         }
45
46         return 0;
47 }
48
49 void __cpuinit local_timer_setup(unsigned int cpu)
50 {
51         void __iomem *base = TWD_BASE(cpu);
52         unsigned int load, offset;
53         u64 waitjiffies;
54         unsigned int count;
55
56         /*
57          * If this is the first time round, we need to work out how fast
58          * the timer ticks
59          */
60         if (mpcore_timer_rate == 0) {
61                 printk("Calibrating local timer... ");
62
63                 /* Wait for a tick to start */
64                 waitjiffies = get_jiffies_64() + 1;
65
66                 while (get_jiffies_64() < waitjiffies)
67                         udelay(10);
68
69                 /* OK, now the tick has started, let's get the timer going */
70                 waitjiffies += 5;
71
72                                  /* enable, no interrupt or reload */
73                 __raw_writel(0x1, base + TWD_TIMER_CONTROL);
74
75                                  /* maximum value */
76                 __raw_writel(0xFFFFFFFFU, base + TWD_TIMER_COUNTER);
77
78                 while (get_jiffies_64() < waitjiffies)
79                         udelay(10);
80
81                 count = __raw_readl(base + TWD_TIMER_COUNTER);
82
83                 mpcore_timer_rate = (0xFFFFFFFFU - count) * (HZ / 5);
84
85                 printk("%lu.%02luMHz.\n", mpcore_timer_rate / 1000000,
86                         (mpcore_timer_rate / 100000) % 100);
87         }
88
89         load = mpcore_timer_rate / HZ;
90
91         __raw_writel(load, base + TWD_TIMER_LOAD);
92         __raw_writel(0x7,  base + TWD_TIMER_CONTROL);
93
94         /*
95          * Now maneuver our local tick into the right part of the jiffy.
96          * Start by working out where within the tick our local timer
97          * interrupt should go.
98          */
99         offset = ((mpcore_timer_rate / HZ) / (NR_CPUS + 1)) * (cpu + 1);
100
101         /*
102          * gettimeoffset() will return a number of us since the last tick.
103          * Convert this number of us to a local timer tick count.
104          * Be careful of integer overflow whilst keeping maximum precision.
105          *
106          * with HZ=100 and 1MHz (fpga) ~ 1GHz processor:
107          * load = 1 ~ 10,000
108          * mpcore_timer_rate/10000 = 100 ~ 100,000
109          *
110          * so the multiply value will be less than 10^9 always.
111          */
112         load = (system_timer->offset() * (mpcore_timer_rate / 10000)) / 100;
113
114         /* Add on our offset to get the load value */
115         load = (load + offset) % (mpcore_timer_rate / HZ);
116
117         __raw_writel(load, base + TWD_TIMER_COUNTER);
118
119         /* Make sure our local interrupt controller has this enabled */
120         __raw_writel(1 << IRQ_LOCALTIMER,
121                      __io_address(REALVIEW_GIC_DIST_BASE) + GIC_DIST_ENABLE_SET);
122 }
123
124 /*
125  * take a local timer down
126  */
127 void __cpuexit local_timer_stop(unsigned int cpu)
128 {
129         __raw_writel(0, TWD_BASE(cpu) + TWD_TIMER_CONTROL);
130 }