Branch data Line data Source code
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/cpu.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/interrupt.h>
22 : : #include <linux/io.h>
23 : : #include <linux/of_irq.h>
24 : : #include <linux/of_address.h>
25 : :
26 : : #include <asm/smp_plat.h>
27 : : #include <asm/smp_twd.h>
28 : :
29 : : /* set up by the platform code */
30 : : static void __iomem *twd_base;
31 : :
32 : : static struct clk *twd_clk;
33 : : static unsigned long twd_timer_rate;
34 : : static DEFINE_PER_CPU(bool, percpu_setup_called);
35 : :
36 : : static struct clock_event_device __percpu *twd_evt;
37 : : static int twd_ppi;
38 : :
39 : 0 : static void twd_set_mode(enum clock_event_mode mode,
40 : : struct clock_event_device *clk)
41 : : {
42 : : unsigned long ctrl;
43 : :
44 [ # # # ]: 0 : switch (mode) {
45 : : case CLOCK_EVT_MODE_PERIODIC:
46 : : ctrl = TWD_TIMER_CONTROL_ENABLE | TWD_TIMER_CONTROL_IT_ENABLE
47 : : | TWD_TIMER_CONTROL_PERIODIC;
48 : 0 : writel_relaxed(DIV_ROUND_CLOSEST(twd_timer_rate, HZ),
49 : : twd_base + TWD_TIMER_LOAD);
50 : : break;
51 : : case CLOCK_EVT_MODE_ONESHOT:
52 : : /* period set, and timer enabled in 'next_event' hook */
53 : : ctrl = TWD_TIMER_CONTROL_IT_ENABLE | TWD_TIMER_CONTROL_ONESHOT;
54 : : break;
55 : : case CLOCK_EVT_MODE_UNUSED:
56 : : case CLOCK_EVT_MODE_SHUTDOWN:
57 : : default:
58 : : ctrl = 0;
59 : : }
60 : :
61 : 0 : writel_relaxed(ctrl, twd_base + TWD_TIMER_CONTROL);
62 : 0 : }
63 : :
64 : 0 : static int twd_set_next_event(unsigned long evt,
65 : : struct clock_event_device *unused)
66 : : {
67 : 0 : unsigned long ctrl = readl_relaxed(twd_base + TWD_TIMER_CONTROL);
68 : :
69 : 0 : ctrl |= TWD_TIMER_CONTROL_ENABLE;
70 : :
71 : 0 : writel_relaxed(evt, twd_base + TWD_TIMER_COUNTER);
72 : 0 : writel_relaxed(ctrl, twd_base + TWD_TIMER_CONTROL);
73 : :
74 : 0 : return 0;
75 : : }
76 : :
77 : : /*
78 : : * local_timer_ack: checks for a local timer interrupt.
79 : : *
80 : : * If a local timer interrupt has occurred, acknowledge and return 1.
81 : : * Otherwise, return 0.
82 : : */
83 : : static int twd_timer_ack(void)
84 : : {
85 [ # # ]: 0 : if (readl_relaxed(twd_base + TWD_TIMER_INTSTAT)) {
86 : 0 : writel_relaxed(1, twd_base + TWD_TIMER_INTSTAT);
87 : : return 1;
88 : : }
89 : :
90 : : return 0;
91 : : }
92 : :
93 : 0 : static void twd_timer_stop(void)
94 : : {
95 : 0 : struct clock_event_device *clk = __this_cpu_ptr(twd_evt);
96 : :
97 : : twd_set_mode(CLOCK_EVT_MODE_UNUSED, clk);
98 : 0 : disable_percpu_irq(clk->irq);
99 : 0 : }
100 : :
101 : : #ifdef CONFIG_COMMON_CLK
102 : :
103 : : /*
104 : : * Updates clockevent frequency when the cpu frequency changes.
105 : : * Called on the cpu that is changing frequency with interrupts disabled.
106 : : */
107 : 0 : static void twd_update_frequency(void *new_rate)
108 : : {
109 : 0 : twd_timer_rate = *((unsigned long *) new_rate);
110 : :
111 : 0 : clockevents_update_freq(__this_cpu_ptr(twd_evt), twd_timer_rate);
112 : 0 : }
113 : :
114 : 0 : static int twd_rate_change(struct notifier_block *nb,
115 : : unsigned long flags, void *data)
116 : : {
117 : : struct clk_notifier_data *cnd = data;
118 : :
119 : : /*
120 : : * The twd clock events must be reprogrammed to account for the new
121 : : * frequency. The timer is local to a cpu, so cross-call to the
122 : : * changing cpu.
123 : : */
124 [ # # ]: 0 : if (flags == POST_RATE_CHANGE)
125 : 0 : on_each_cpu(twd_update_frequency,
126 : 0 : (void *)&cnd->new_rate, 1);
127 : :
128 : 0 : return NOTIFY_OK;
129 : : }
130 : :
131 : : static struct notifier_block twd_clk_nb = {
132 : : .notifier_call = twd_rate_change,
133 : : };
134 : :
135 : 0 : static int twd_clk_init(void)
136 : : {
137 [ # # ][ # # ]: 0 : if (twd_evt && __this_cpu_ptr(twd_evt) && !IS_ERR(twd_clk))
[ # # ]
138 : 0 : return clk_notifier_register(twd_clk, &twd_clk_nb);
139 : :
140 : : return 0;
141 : : }
142 : : core_initcall(twd_clk_init);
143 : :
144 : : #elif defined (CONFIG_CPU_FREQ)
145 : :
146 : : #include <linux/cpufreq.h>
147 : :
148 : : /*
149 : : * Updates clockevent frequency when the cpu frequency changes.
150 : : * Called on the cpu that is changing frequency with interrupts disabled.
151 : : */
152 : : static void twd_update_frequency(void *data)
153 : : {
154 : : twd_timer_rate = clk_get_rate(twd_clk);
155 : :
156 : : clockevents_update_freq(__this_cpu_ptr(twd_evt), twd_timer_rate);
157 : : }
158 : :
159 : : static int twd_cpufreq_transition(struct notifier_block *nb,
160 : : unsigned long state, void *data)
161 : : {
162 : : struct cpufreq_freqs *freqs = data;
163 : :
164 : : /*
165 : : * The twd clock events must be reprogrammed to account for the new
166 : : * frequency. The timer is local to a cpu, so cross-call to the
167 : : * changing cpu.
168 : : */
169 : : if (state == CPUFREQ_POSTCHANGE || state == CPUFREQ_RESUMECHANGE)
170 : : smp_call_function_single(freqs->cpu, twd_update_frequency,
171 : : NULL, 1);
172 : :
173 : : return NOTIFY_OK;
174 : : }
175 : :
176 : : static struct notifier_block twd_cpufreq_nb = {
177 : : .notifier_call = twd_cpufreq_transition,
178 : : };
179 : :
180 : : static int twd_cpufreq_init(void)
181 : : {
182 : : if (twd_evt && __this_cpu_ptr(twd_evt) && !IS_ERR(twd_clk))
183 : : return cpufreq_register_notifier(&twd_cpufreq_nb,
184 : : CPUFREQ_TRANSITION_NOTIFIER);
185 : :
186 : : return 0;
187 : : }
188 : : core_initcall(twd_cpufreq_init);
189 : :
190 : : #endif
191 : :
192 : 0 : static void twd_calibrate_rate(void)
193 : : {
194 : : unsigned long count;
195 : : u64 waitjiffies;
196 : :
197 : : /*
198 : : * If this is the first time round, we need to work out how fast
199 : : * the timer ticks
200 : : */
201 [ # # ]: 0 : if (twd_timer_rate == 0) {
202 : 0 : printk(KERN_INFO "Calibrating local timer... ");
203 : :
204 : : /* Wait for a tick to start */
205 : 0 : waitjiffies = get_jiffies_64() + 1;
206 : :
207 [ # # ]: 0 : while (get_jiffies_64() < waitjiffies)
208 : 0 : udelay(10);
209 : :
210 : : /* OK, now the tick has started, let's get the timer going */
211 : 0 : waitjiffies += 5;
212 : :
213 : : /* enable, no interrupt or reload */
214 : 0 : writel_relaxed(0x1, twd_base + TWD_TIMER_CONTROL);
215 : :
216 : : /* maximum value */
217 : 0 : writel_relaxed(0xFFFFFFFFU, twd_base + TWD_TIMER_COUNTER);
218 : :
219 [ # # ]: 0 : while (get_jiffies_64() < waitjiffies)
220 : 0 : udelay(10);
221 : :
222 : 0 : count = readl_relaxed(twd_base + TWD_TIMER_COUNTER);
223 : :
224 : 0 : twd_timer_rate = (0xFFFFFFFFU - count) * (HZ / 5);
225 : :
226 : 0 : printk("%lu.%02luMHz.\n", twd_timer_rate / 1000000,
227 : 0 : (twd_timer_rate / 10000) % 100);
228 : : }
229 : 0 : }
230 : :
231 : 0 : static irqreturn_t twd_handler(int irq, void *dev_id)
232 : : {
233 : : struct clock_event_device *evt = dev_id;
234 : :
235 [ # # ]: 0 : if (twd_timer_ack()) {
236 : 0 : evt->event_handler(evt);
237 : 0 : return IRQ_HANDLED;
238 : : }
239 : :
240 : : return IRQ_NONE;
241 : : }
242 : :
243 : 0 : static void twd_get_clock(struct device_node *np)
244 : : {
245 : : int err;
246 : :
247 [ # # ]: 0 : if (np)
248 : 0 : twd_clk = of_clk_get(np, 0);
249 : : else
250 : 0 : twd_clk = clk_get_sys("smp_twd", NULL);
251 : :
252 [ # # ]: 0 : if (IS_ERR(twd_clk)) {
253 : 0 : pr_err("smp_twd: clock not found %d\n", (int) PTR_ERR(twd_clk));
254 : 0 : return;
255 : : }
256 : :
257 : : err = clk_prepare_enable(twd_clk);
258 [ # # ]: 0 : if (err) {
259 : 0 : pr_err("smp_twd: clock failed to prepare+enable: %d\n", err);
260 : 0 : clk_put(twd_clk);
261 : 0 : return;
262 : : }
263 : :
264 : 0 : twd_timer_rate = clk_get_rate(twd_clk);
265 : : }
266 : :
267 : : /*
268 : : * Setup the local clock events for a CPU.
269 : : */
270 : 0 : static void twd_timer_setup(void)
271 : : {
272 : 0 : struct clock_event_device *clk = __this_cpu_ptr(twd_evt);
273 : 0 : int cpu = smp_processor_id();
274 : :
275 : : /*
276 : : * If the basic setup for this CPU has been done before don't
277 : : * bother with the below.
278 : : */
279 [ # # ]: 0 : if (per_cpu(percpu_setup_called, cpu)) {
280 : 0 : writel_relaxed(0, twd_base + TWD_TIMER_CONTROL);
281 : 0 : clockevents_register_device(clk);
282 : 0 : enable_percpu_irq(clk->irq, 0);
283 : 0 : return;
284 : : }
285 : 0 : per_cpu(percpu_setup_called, cpu) = true;
286 : :
287 : 0 : twd_calibrate_rate();
288 : :
289 : : /*
290 : : * The following is done once per CPU the first time .setup() is
291 : : * called.
292 : : */
293 : 0 : writel_relaxed(0, twd_base + TWD_TIMER_CONTROL);
294 : :
295 : 0 : clk->name = "local_timer";
296 : 0 : clk->features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT |
297 : : CLOCK_EVT_FEAT_C3STOP;
298 : 0 : clk->rating = 350;
299 : 0 : clk->set_mode = twd_set_mode;
300 : 0 : clk->set_next_event = twd_set_next_event;
301 : 0 : clk->irq = twd_ppi;
302 : 0 : clk->cpumask = cpumask_of(cpu);
303 : :
304 : 0 : clockevents_config_and_register(clk, twd_timer_rate,
305 : : 0xf, 0xffffffff);
306 : 0 : enable_percpu_irq(clk->irq, 0);
307 : : }
308 : :
309 : 0 : static int twd_timer_cpu_notify(struct notifier_block *self,
310 : : unsigned long action, void *hcpu)
311 : : {
312 [ # # # ]: 0 : switch (action & ~CPU_TASKS_FROZEN) {
313 : : case CPU_STARTING:
314 : 0 : twd_timer_setup();
315 : 0 : break;
316 : : case CPU_DYING:
317 : 0 : twd_timer_stop();
318 : 0 : break;
319 : : }
320 : :
321 : 0 : return NOTIFY_OK;
322 : : }
323 : :
324 : : static struct notifier_block twd_timer_cpu_nb = {
325 : : .notifier_call = twd_timer_cpu_notify,
326 : : };
327 : :
328 : 0 : static int __init twd_local_timer_common_register(struct device_node *np)
329 : : {
330 : : int err;
331 : :
332 : 0 : twd_evt = alloc_percpu(struct clock_event_device);
333 [ # # ]: 0 : if (!twd_evt) {
334 : : err = -ENOMEM;
335 : : goto out_free;
336 : : }
337 : :
338 : 0 : err = request_percpu_irq(twd_ppi, twd_handler, "twd", twd_evt);
339 [ # # ]: 0 : if (err) {
340 : 0 : pr_err("twd: can't register interrupt %d (%d)\n", twd_ppi, err);
341 : 0 : goto out_free;
342 : : }
343 : :
344 : 0 : err = register_cpu_notifier(&twd_timer_cpu_nb);
345 [ # # ]: 0 : if (err)
346 : : goto out_irq;
347 : :
348 : 0 : twd_get_clock(np);
349 : :
350 : : /*
351 : : * Immediately configure the timer on the boot CPU, unless we need
352 : : * jiffies to be incrementing to calibrate the rate in which case
353 : : * setup the timer in late_time_init.
354 : : */
355 [ # # ]: 0 : if (twd_timer_rate)
356 : 0 : twd_timer_setup();
357 : : else
358 : 0 : late_time_init = twd_timer_setup;
359 : :
360 : : return 0;
361 : :
362 : : out_irq:
363 : 0 : free_percpu_irq(twd_ppi, twd_evt);
364 : : out_free:
365 : 0 : iounmap(twd_base);
366 : 0 : twd_base = NULL;
367 : 0 : free_percpu(twd_evt);
368 : :
369 : 0 : return err;
370 : : }
371 : :
372 : 0 : int __init twd_local_timer_register(struct twd_local_timer *tlt)
373 : : {
374 [ # # ][ # # ]: 0 : if (twd_base || twd_evt)
375 : : return -EBUSY;
376 : :
377 : 0 : twd_ppi = tlt->res[1].start;
378 : :
379 : 0 : twd_base = ioremap(tlt->res[0].start, resource_size(&tlt->res[0]));
380 [ # # ]: 0 : if (!twd_base)
381 : : return -ENOMEM;
382 : :
383 : 0 : return twd_local_timer_common_register(NULL);
384 : : }
385 : :
386 : : #ifdef CONFIG_OF
387 : 0 : static void __init twd_local_timer_of_register(struct device_node *np)
388 : : {
389 : : int err;
390 : :
391 [ # # ][ # # ]: 0 : if (!is_smp() || !setup_max_cpus)
392 : 0 : return;
393 : :
394 : 0 : twd_ppi = irq_of_parse_and_map(np, 0);
395 [ # # ]: 0 : if (!twd_ppi) {
396 : : err = -EINVAL;
397 : : goto out;
398 : : }
399 : :
400 : 0 : twd_base = of_iomap(np, 0);
401 [ # # ]: 0 : if (!twd_base) {
402 : : err = -ENOMEM;
403 : : goto out;
404 : : }
405 : :
406 : 0 : err = twd_local_timer_common_register(np);
407 : :
408 : : out:
409 [ # # ]: 0 : WARN(err, "twd_local_timer_of_register failed (%d)\n", err);
410 : : }
411 : : CLOCKSOURCE_OF_DECLARE(arm_twd_a9, "arm,cortex-a9-twd-timer", twd_local_timer_of_register);
412 : : CLOCKSOURCE_OF_DECLARE(arm_twd_a5, "arm,cortex-a5-twd-timer", twd_local_timer_of_register);
413 : : CLOCKSOURCE_OF_DECLARE(arm_twd_11mp, "arm,arm11mp-twd-timer", twd_local_timer_of_register);
414 : : #endif
|
