1 /*
2 * linux/arch/arm/kernel/smp_twd.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/clk.h>
14 #include <linux/cpufreq.h>
15 #include <linux/delay.h>
16 #include <linux/device.h>
17 #include <linux/err.h>
18 #include <linux/smp.h>
19 #include <linux/jiffies.h>
20 #include <linux/clockchips.h>
21 #include <linux/irq.h>
22 #include <linux/io.h>
23
24 #include <asm/smp_twd.h>
25 #include <asm/localtimer.h>
26 #include <asm/hardware/gic.h>
27
28 /* set up by the platform code */
29 void __iomem *twd_base;
30
31 static struct clk *twd_clk;
32 static unsigned long twd_timer_rate;
33
34 static struct clock_event_device __percpu **twd_evt;
35
twd_set_mode(enum clock_event_mode mode,struct clock_event_device * clk)36 static void twd_set_mode(enum clock_event_mode mode,
37 struct clock_event_device *clk)
38 {
39 unsigned long ctrl;
40
41 switch (mode) {
42 case CLOCK_EVT_MODE_PERIODIC:
43 /* timer load already set up */
44 ctrl = TWD_TIMER_CONTROL_ENABLE | TWD_TIMER_CONTROL_IT_ENABLE
45 | TWD_TIMER_CONTROL_PERIODIC;
46 __raw_writel(twd_timer_rate / HZ, twd_base + TWD_TIMER_LOAD);
47 break;
48 case CLOCK_EVT_MODE_ONESHOT:
49 /* period set, and timer enabled in 'next_event' hook */
50 ctrl = TWD_TIMER_CONTROL_IT_ENABLE | TWD_TIMER_CONTROL_ONESHOT;
51 break;
52 case CLOCK_EVT_MODE_UNUSED:
53 case CLOCK_EVT_MODE_SHUTDOWN:
54 default:
55 ctrl = 0;
56 }
57
58 __raw_writel(ctrl, twd_base + TWD_TIMER_CONTROL);
59 }
60
twd_set_next_event(unsigned long evt,struct clock_event_device * unused)61 static int twd_set_next_event(unsigned long evt,
62 struct clock_event_device *unused)
63 {
64 unsigned long ctrl = __raw_readl(twd_base + TWD_TIMER_CONTROL);
65
66 ctrl |= TWD_TIMER_CONTROL_ENABLE;
67
68 __raw_writel(evt, twd_base + TWD_TIMER_COUNTER);
69 __raw_writel(ctrl, twd_base + TWD_TIMER_CONTROL);
70
71 return 0;
72 }
73
74 /*
75 * local_timer_ack: checks for a local timer interrupt.
76 *
77 * If a local timer interrupt has occurred, acknowledge and return 1.
78 * Otherwise, return 0.
79 */
twd_timer_ack(void)80 int twd_timer_ack(void)
81 {
82 if (__raw_readl(twd_base + TWD_TIMER_INTSTAT)) {
83 __raw_writel(1, twd_base + TWD_TIMER_INTSTAT);
84 return 1;
85 }
86
87 return 0;
88 }
89
twd_timer_stop(struct clock_event_device * clk)90 void twd_timer_stop(struct clock_event_device *clk)
91 {
92 twd_set_mode(CLOCK_EVT_MODE_UNUSED, clk);
93 disable_percpu_irq(clk->irq);
94 }
95
96 #ifdef CONFIG_CPU_FREQ
97
98 /*
99 * Updates clockevent frequency when the cpu frequency changes.
100 * Called on the cpu that is changing frequency with interrupts disabled.
101 */
twd_update_frequency(void * data)102 static void twd_update_frequency(void *data)
103 {
104 twd_timer_rate = clk_get_rate(twd_clk);
105
106 clockevents_update_freq(*__this_cpu_ptr(twd_evt), twd_timer_rate);
107 }
108
twd_cpufreq_transition(struct notifier_block * nb,unsigned long state,void * data)109 static int twd_cpufreq_transition(struct notifier_block *nb,
110 unsigned long state, void *data)
111 {
112 struct cpufreq_freqs *freqs = data;
113
114 /*
115 * The twd clock events must be reprogrammed to account for the new
116 * frequency. The timer is local to a cpu, so cross-call to the
117 * changing cpu.
118 */
119 if (state == CPUFREQ_POSTCHANGE || state == CPUFREQ_RESUMECHANGE)
120 smp_call_function_single(freqs->cpu, twd_update_frequency,
121 NULL, 1);
122
123 return NOTIFY_OK;
124 }
125
126 static struct notifier_block twd_cpufreq_nb = {
127 .notifier_call = twd_cpufreq_transition,
128 };
129
twd_cpufreq_init(void)130 static int twd_cpufreq_init(void)
131 {
132 if (twd_evt && *__this_cpu_ptr(twd_evt) && !IS_ERR(twd_clk))
133 return cpufreq_register_notifier(&twd_cpufreq_nb,
134 CPUFREQ_TRANSITION_NOTIFIER);
135
136 return 0;
137 }
138 core_initcall(twd_cpufreq_init);
139
140 #endif
141
twd_calibrate_rate(void)142 static void __cpuinit twd_calibrate_rate(void)
143 {
144 unsigned long count;
145 u64 waitjiffies;
146
147 /*
148 * If this is the first time round, we need to work out how fast
149 * the timer ticks
150 */
151 if (twd_timer_rate == 0) {
152 printk(KERN_INFO "Calibrating local timer... ");
153
154 /* Wait for a tick to start */
155 waitjiffies = get_jiffies_64() + 1;
156
157 while (get_jiffies_64() < waitjiffies)
158 udelay(10);
159
160 /* OK, now the tick has started, let's get the timer going */
161 waitjiffies += 5;
162
163 /* enable, no interrupt or reload */
164 __raw_writel(0x1, twd_base + TWD_TIMER_CONTROL);
165
166 /* maximum value */
167 __raw_writel(0xFFFFFFFFU, twd_base + TWD_TIMER_COUNTER);
168
169 while (get_jiffies_64() < waitjiffies)
170 udelay(10);
171
172 count = __raw_readl(twd_base + TWD_TIMER_COUNTER);
173
174 twd_timer_rate = (0xFFFFFFFFU - count) * (HZ / 5);
175
176 printk("%lu.%02luMHz.\n", twd_timer_rate / 1000000,
177 (twd_timer_rate / 10000) % 100);
178 }
179 }
180
twd_handler(int irq,void * dev_id)181 static irqreturn_t twd_handler(int irq, void *dev_id)
182 {
183 struct clock_event_device *evt = *(struct clock_event_device **)dev_id;
184
185 if (twd_timer_ack()) {
186 evt->event_handler(evt);
187 return IRQ_HANDLED;
188 }
189
190 return IRQ_NONE;
191 }
192
twd_get_clock(void)193 static struct clk *twd_get_clock(void)
194 {
195 struct clk *clk;
196 int err;
197
198 clk = clk_get_sys("smp_twd", NULL);
199 if (IS_ERR(clk)) {
200 pr_err("smp_twd: clock not found: %d\n", (int)PTR_ERR(clk));
201 return clk;
202 }
203
204 err = clk_prepare(clk);
205 if (err) {
206 pr_err("smp_twd: clock failed to prepare: %d\n", err);
207 clk_put(clk);
208 return ERR_PTR(err);
209 }
210
211 err = clk_enable(clk);
212 if (err) {
213 pr_err("smp_twd: clock failed to enable: %d\n", err);
214 clk_unprepare(clk);
215 clk_put(clk);
216 return ERR_PTR(err);
217 }
218
219 return clk;
220 }
221
222 /*
223 * Setup the local clock events for a CPU.
224 */
twd_timer_setup(struct clock_event_device * clk)225 void __cpuinit twd_timer_setup(struct clock_event_device *clk)
226 {
227 struct clock_event_device **this_cpu_clk;
228
229 if (!twd_evt) {
230 int err;
231
232 twd_evt = alloc_percpu(struct clock_event_device *);
233 if (!twd_evt) {
234 pr_err("twd: can't allocate memory\n");
235 return;
236 }
237
238 err = request_percpu_irq(clk->irq, twd_handler,
239 "twd", twd_evt);
240 if (err) {
241 pr_err("twd: can't register interrupt %d (%d)\n",
242 clk->irq, err);
243 return;
244 }
245 }
246
247 if (!twd_clk)
248 twd_clk = twd_get_clock();
249
250 if (!IS_ERR_OR_NULL(twd_clk))
251 twd_timer_rate = clk_get_rate(twd_clk);
252 else
253 twd_calibrate_rate();
254
255 __raw_writel(0, twd_base + TWD_TIMER_CONTROL);
256
257 clk->name = "local_timer";
258 clk->features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT |
259 CLOCK_EVT_FEAT_C3STOP;
260 clk->rating = 350;
261 clk->set_mode = twd_set_mode;
262 clk->set_next_event = twd_set_next_event;
263
264 this_cpu_clk = __this_cpu_ptr(twd_evt);
265 *this_cpu_clk = clk;
266
267 clockevents_config_and_register(clk, twd_timer_rate,
268 0xf, 0xffffffff);
269 enable_percpu_irq(clk->irq, 0);
270 }
271