[ubicom32]: add 2.6.32 support
[openwrt/svn-archive/archive.git] / target / linux / ubicom32 / files / arch / ubicom32 / kernel / timer_device.c
1 /*
2 * arch/ubicom32/kernel/timer_device.c
3 * Implements a Ubicom32 clock device and event devices.
4 *
5 * (C) Copyright 2009, Ubicom, Inc.
6 *
7 * This file is part of the Ubicom32 Linux Kernel Port.
8 *
9 * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10 * it and/or modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation, either version 2 of the
12 * License, or (at your option) any later version.
13 *
14 * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
16 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with the Ubicom32 Linux Kernel Port. If not,
21 * see <http://www.gnu.org/licenses/>.
22 *
23 * Ubicom32 implementation derived from (with many thanks):
24 * arch/m68knommu
25 * arch/blackfin
26 * arch/parisc
27 */
28 #include <linux/types.h>
29 #include <linux/clockchips.h>
30 #include <linux/clocksource.h>
31 #include <linux/spinlock.h>
32 #include <asm/ip5000.h>
33 #include <asm/machdep.h>
34
35 #if defined(CONFIG_SMP)
36 #include <asm/smp.h>
37 #endif
38
39 #if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST)
40 #define MAX_TIMERS (2 + CONFIG_TIMER_EXTRA_ALLOC)
41 #else
42 #define MAX_TIMERS (NR_CPUS + CONFIG_TIMER_EXTRA_ALLOC)
43 #endif
44
45 #if (MAX_TIMERS > 10)
46 #error "Ubicom32 only has 10 timers"
47 #endif
48
49 static unsigned int frequency;
50 static struct clock_event_device timer_device_devs[MAX_TIMERS];
51 static struct irqaction timer_device_irqs[MAX_TIMERS];
52 static int timer_device_next_timer = 0;
53
54 DEFINE_SPINLOCK(timer_device_lock);
55
56 /*
57 * timer_device_set_next_event()
58 * Cause the timer to go off "cycles" from now.
59 */
60 static int timer_device_set_next_event(unsigned long cycles, struct clock_event_device *dev)
61 {
62 timer_set(dev->irq, cycles);
63 return 0;
64 }
65
66 /*
67 * timer_device_set_mode()
68 * Handle the mode switch for a clock event device.
69 */
70 static void timer_device_set_mode(enum clock_event_mode mode, struct clock_event_device *dev)
71 {
72 switch (mode) {
73 case CLOCK_EVT_MODE_SHUTDOWN:
74 /*
75 * Make sure the vector is disabled
76 * until the next event is set.
77 */
78 printk(KERN_NOTICE "timer[%d]: shutdown\n", dev->irq);
79 ldsr_disable_vector(dev->irq);
80 break;
81
82 case CLOCK_EVT_MODE_ONESHOT:
83 /*
84 * Make sure the vector is disabled
85 * until the next event is set.
86 */
87 printk(KERN_NOTICE "timer[%d]: oneshot\n", dev->irq);
88 ldsr_disable_vector(dev->irq);
89 break;
90
91 case CLOCK_EVT_MODE_PERIODIC:
92 /*
93 * The periodic request is 1 per jiffies
94 */
95 printk(KERN_NOTICE "timer[%d]: periodic: %d cycles\n",
96 dev->irq, frequency / CONFIG_HZ);
97 timer_set(dev->irq, frequency / CONFIG_HZ);
98 break;
99
100 case CLOCK_EVT_MODE_UNUSED:
101 case CLOCK_EVT_MODE_RESUME:
102 printk(KERN_WARNING "timer[%d]: unimplemented mode: %d\n",
103 dev->irq, mode);
104 break;
105 };
106 }
107
108 /*
109 * timer_device_event()
110 * Call the device's event handler.
111 *
112 * The pointer is initialized by the generic Linux code
113 * to the function to be called.
114 */
115 static irqreturn_t timer_device_event(int irq, void *dev_id)
116 {
117 struct clock_event_device *dev = (struct clock_event_device *)dev_id;
118
119 if (dev->mode == CLOCK_EVT_MODE_PERIODIC) {
120 /*
121 * The periodic request is 1 per jiffies
122 */
123 timer_reset(dev->irq, frequency / CONFIG_HZ);
124 } else {
125 /*
126 * The timer will go off again at the rollover
127 * point. We must disable the IRQ to prevent
128 * getting a spurious interrupt.
129 */
130 ldsr_disable_vector(dev->irq);
131 }
132
133 if (!dev->event_handler) {
134 printk(KERN_CRIT "no registered event handler\n");
135 return IRQ_HANDLED;
136 }
137
138 dev->event_handler(dev);
139 return IRQ_HANDLED;
140 }
141
142 /*
143 * timer_device_clockbase_read()
144 * Provide a primary clocksource around the sysval timer.
145 */
146 static cycle_t timer_device_clockbase_read(void)
147 {
148 return (cycle_t)UBICOM32_IO_TIMER->sysval;
149 }
150
151 /*
152 * Primary Clock Source Description
153 *
154 * We use 24 for the shift factor because we want
155 * to ensure there are less than 2^24 clocks
156 * in a jiffie of 10 ms.
157 */
158 static struct clocksource timer_device_clockbase = {
159 .name = "sysval",
160 .rating = 400,
161 .flags = CLOCK_SOURCE_IS_CONTINUOUS,
162 .mask = CLOCKSOURCE_MASK(32),
163 .shift = 24,
164 .mult = 0,
165 .read = timer_device_clockbase_read,
166 };
167
168 /*
169 * timer_device_alloc_event()
170 * Allocate a timer device event.
171 */
172 static int timer_device_alloc_event(const char *name, int cpuid, const struct cpumask *cpumask)
173 {
174 struct clock_event_device *dev;
175 struct irqaction *action;
176
177 /*
178 * Are we out of configured timers?
179 */
180 spin_lock(&timer_device_lock);
181 if (timer_device_next_timer >= MAX_TIMERS) {
182 spin_unlock(&timer_device_lock);
183 printk(KERN_WARNING "out of timer event entries\n");
184 return -1;
185 }
186 dev = &timer_device_devs[timer_device_next_timer];
187 action = &timer_device_irqs[timer_device_next_timer];
188 timer_device_next_timer++;
189 spin_unlock(&timer_device_lock);
190
191 /*
192 * Now allocate a timer to ourselves.
193 */
194 dev->irq = timer_alloc();
195 if (dev->irq == -1) {
196 spin_lock(&timer_device_lock);
197 timer_device_next_timer--;
198 spin_unlock(&timer_device_lock);
199 printk(KERN_WARNING "out of hardware timers\n");
200 return -1;
201 }
202
203 /*
204 * Init the IRQ action structure. Make sure
205 * this in place before you register the clock
206 * event device.
207 */
208 action->name = name;
209 action->flags = IRQF_DISABLED | IRQF_TIMER;
210 action->handler = timer_device_event;
211 //cpumask_copy(&action->mask, mask);
212 action->dev_id = dev;
213 setup_irq(dev->irq, action);
214 irq_set_affinity(dev->irq, cpumask);
215 ldsr_disable_vector(dev->irq);
216
217 /*
218 * init clock dev structure.
219 *
220 * The min_delta_ns is chosen to ensure that setting next
221 * event will never be requested with too small of value.
222 */
223 dev->name = name;
224 dev->rating = timer_device_clockbase.rating;
225 dev->shift = timer_device_clockbase.shift;
226 dev->features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT;
227 dev->set_mode = timer_device_set_mode;
228 dev->set_next_event = timer_device_set_next_event;
229 dev->mult = div_sc(frequency, NSEC_PER_SEC, dev->shift);
230 dev->max_delta_ns = clockevent_delta2ns(0xffffffff, dev);
231 dev->min_delta_ns = clockevent_delta2ns(100, dev);
232 //dev->cpumask = mask;
233 printk(KERN_NOTICE "timer[%d]: %s - created\n", dev->irq, dev->name);
234
235 /*
236 * Now register the device.
237 */
238 clockevents_register_device(dev);
239 return dev->irq;
240 }
241
242 #if defined(CONFIG_LOCAL_TIMERS)
243 /*
244 * local_timer_setup()
245 * Allocation function for creating a per cpu local timer.
246 */
247 int __cpuinit local_timer_setup(unsigned int cpu)
248 {
249 return timer_device_alloc_event("timer-cpu", cpu);
250 }
251 #endif
252
253 /*
254 * timer_device_init()
255 * Create and init a generic clock driver for Ubicom32.
256 */
257 void timer_device_init(void)
258 {
259 int i;
260
261 /*
262 * Get the frequency from the processor device tree node or use
263 * the default if not available. We will store this as the frequency
264 * of the timer to avoid future calculations.
265 */
266 frequency = processor_frequency();
267 if (frequency == 0) {
268 frequency = CLOCK_TICK_RATE;
269 }
270
271 /*
272 * Setup the primary clock source around sysval. Linux does not
273 * supply a Mhz multiplier so convert down to khz.
274 */
275 timer_device_clockbase.mult =
276 clocksource_khz2mult(frequency / 1000,
277 timer_device_clockbase.shift);
278 if (clocksource_register(&timer_device_clockbase)) {
279 printk(KERN_ERR "timer: clocksource failed to register\n");
280 return;
281 }
282
283 /*
284 * Always allocate a primary timer.
285 */
286 timer_device_alloc_event("timer-primary", -1, cpu_all_mask);
287
288 #if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST)
289 /*
290 * If BROADCAST is selected we need to add a broadcast timer.
291 */
292 timer_device_alloc_event("timer-broadcast", -1, cpu_all_mask);
293 #endif
294
295 /*
296 * Allocate extra timers that are requested.
297 */
298 for (i = 0; i < CONFIG_TIMER_EXTRA_ALLOC; i++) {
299 timer_device_alloc_event("timer-extra", -1, cpu_all_mask);
300 }
301 }