44d178cd573342b5cc3578353c18b724e9b4f1e8
[linux-2.6.git] / 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 #include <linux/jiffies.h>
17 #include <linux/percpu.h>
18 #include <linux/clockchips.h>
19 #include <linux/irq.h>
20 #include <linux/io.h>
21
22 #include <asm/hardware/arm_twd.h>
23 #include <asm/hardware/gic.h>
24 #include <mach/hardware.h>
25 #include <asm/irq.h>
26
27 static DEFINE_PER_CPU(struct clock_event_device, local_clockevent);
28
29 /*
30  * Used on SMP for either the local timer or IPI_TIMER
31  */
32 void local_timer_interrupt(void)
33 {
34         struct clock_event_device *clk = &__get_cpu_var(local_clockevent);
35
36         clk->event_handler(clk);
37 }
38
39 #ifdef CONFIG_LOCAL_TIMERS
40
41 #define TWD_BASE(cpu)   (twd_base_addr + (cpu) * twd_size)
42
43 /* set up by the platform code */
44 void __iomem *twd_base_addr;
45 unsigned int twd_size;
46
47 static unsigned long mpcore_timer_rate;
48
49 static void local_timer_set_mode(enum clock_event_mode mode,
50                                  struct clock_event_device *clk)
51 {
52         void __iomem *base = TWD_BASE(smp_processor_id());
53         unsigned long ctrl;
54
55         switch(mode) {
56         case CLOCK_EVT_MODE_PERIODIC:
57                 /* timer load already set up */
58                 ctrl = TWD_TIMER_CONTROL_ENABLE | TWD_TIMER_CONTROL_IT_ENABLE
59                         | TWD_TIMER_CONTROL_PERIODIC;
60                 break;
61         case CLOCK_EVT_MODE_ONESHOT:
62                 /* period set, and timer enabled in 'next_event' hook */
63                 ctrl = TWD_TIMER_CONTROL_IT_ENABLE | TWD_TIMER_CONTROL_ONESHOT;
64                 break;
65         case CLOCK_EVT_MODE_UNUSED:
66         case CLOCK_EVT_MODE_SHUTDOWN:
67         default:
68                 ctrl = 0;
69         }
70
71         __raw_writel(ctrl, base + TWD_TIMER_CONTROL);
72 }
73
74 static int local_timer_set_next_event(unsigned long evt,
75                                       struct clock_event_device *unused)
76 {
77         void __iomem *base = TWD_BASE(smp_processor_id());
78         unsigned long ctrl = __raw_readl(base + TWD_TIMER_CONTROL);
79
80         __raw_writel(evt, base + TWD_TIMER_COUNTER);
81         __raw_writel(ctrl | TWD_TIMER_CONTROL_ENABLE, base + TWD_TIMER_CONTROL);
82
83         return 0;
84 }
85
86 /*
87  * local_timer_ack: checks for a local timer interrupt.
88  *
89  * If a local timer interrupt has occurred, acknowledge and return 1.
90  * Otherwise, return 0.
91  */
92 int local_timer_ack(void)
93 {
94         void __iomem *base = TWD_BASE(smp_processor_id());
95
96         if (__raw_readl(base + TWD_TIMER_INTSTAT)) {
97                 __raw_writel(1, base + TWD_TIMER_INTSTAT);
98                 return 1;
99         }
100
101         return 0;
102 }
103
104 static void __cpuinit twd_calibrate_rate(unsigned int cpu)
105 {
106         void __iomem *base = TWD_BASE(cpu);
107         unsigned long load, count;
108         u64 waitjiffies;
109
110         /*
111          * If this is the first time round, we need to work out how fast
112          * the timer ticks
113          */
114         if (mpcore_timer_rate == 0) {
115                 printk("Calibrating local timer... ");
116
117                 /* Wait for a tick to start */
118                 waitjiffies = get_jiffies_64() + 1;
119
120                 while (get_jiffies_64() < waitjiffies)
121                         udelay(10);
122
123                 /* OK, now the tick has started, let's get the timer going */
124                 waitjiffies += 5;
125
126                                  /* enable, no interrupt or reload */
127                 __raw_writel(0x1, base + TWD_TIMER_CONTROL);
128
129                                  /* maximum value */
130                 __raw_writel(0xFFFFFFFFU, base + TWD_TIMER_COUNTER);
131
132                 while (get_jiffies_64() < waitjiffies)
133                         udelay(10);
134
135                 count = __raw_readl(base + TWD_TIMER_COUNTER);
136
137                 mpcore_timer_rate = (0xFFFFFFFFU - count) * (HZ / 5);
138
139                 printk("%lu.%02luMHz.\n", mpcore_timer_rate / 1000000,
140                         (mpcore_timer_rate / 100000) % 100);
141         }
142
143         load = mpcore_timer_rate / HZ;
144
145         __raw_writel(load, base + TWD_TIMER_LOAD);
146 }
147
148 /*
149  * Setup the local clock events for a CPU.
150  */
151 void __cpuinit local_timer_setup(unsigned int cpu)
152 {
153         struct clock_event_device *clk = &per_cpu(local_clockevent, cpu);
154         unsigned long flags;
155
156         twd_calibrate_rate(cpu);
157
158         clk->name               = "local_timer";
159         clk->features           = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT;
160         clk->rating             = 350;
161         clk->set_mode           = local_timer_set_mode;
162         clk->set_next_event     = local_timer_set_next_event;
163         clk->irq                = IRQ_LOCALTIMER;
164         clk->cpumask            = cpumask_of_cpu(cpu);
165         clk->shift              = 20;
166         clk->mult               = div_sc(mpcore_timer_rate, NSEC_PER_SEC, clk->shift);
167         clk->max_delta_ns       = clockevent_delta2ns(0xffffffff, clk);
168         clk->min_delta_ns       = clockevent_delta2ns(0xf, clk);
169
170         /* Make sure our local interrupt controller has this enabled */
171         local_irq_save(flags);
172         get_irq_chip(IRQ_LOCALTIMER)->unmask(IRQ_LOCALTIMER);
173         local_irq_restore(flags);
174
175         clockevents_register_device(clk);
176 }
177
178 /*
179  * take a local timer down
180  */
181 void __cpuexit local_timer_stop(unsigned int cpu)
182 {
183         __raw_writel(0, TWD_BASE(cpu) + TWD_TIMER_CONTROL);
184 }
185
186 #else   /* CONFIG_LOCAL_TIMERS */
187
188 static void dummy_timer_set_mode(enum clock_event_mode mode,
189                                  struct clock_event_device *clk)
190 {
191 }
192
193 void __cpuinit local_timer_setup(unsigned int cpu)
194 {
195         struct clock_event_device *clk = &per_cpu(local_clockevent, cpu);
196
197         clk->name               = "dummy_timer";
198         clk->features           = CLOCK_EVT_FEAT_DUMMY;
199         clk->rating             = 200;
200         clk->set_mode           = dummy_timer_set_mode;
201         clk->broadcast          = smp_timer_broadcast;
202         clk->cpumask            = cpumask_of_cpu(cpu);
203
204         clockevents_register_device(clk);
205 }
206
207 #endif  /* !CONFIG_LOCAL_TIMERS */