ARM: 7336/1: smp_twd: Don't register CPUFREQ notifiers if local timers are not initia...
[linux-3.10.git] / arch / arm / kernel / smp_twd.c
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
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
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  */
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
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  */
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
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
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
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
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
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  */
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 }