Merge branch 'merge' of git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc
[linux-2.6] / kernel / time / tick-broadcast.c
1 /*
2  * linux/kernel/time/tick-broadcast.c
3  *
4  * This file contains functions which emulate a local clock-event
5  * device via a broadcast event source.
6  *
7  * Copyright(C) 2005-2006, Thomas Gleixner <tglx@linutronix.de>
8  * Copyright(C) 2005-2007, Red Hat, Inc., Ingo Molnar
9  * Copyright(C) 2006-2007, Timesys Corp., Thomas Gleixner
10  *
11  * This code is licenced under the GPL version 2. For details see
12  * kernel-base/COPYING.
13  */
14 #include <linux/cpu.h>
15 #include <linux/err.h>
16 #include <linux/hrtimer.h>
17 #include <linux/irq.h>
18 #include <linux/percpu.h>
19 #include <linux/profile.h>
20 #include <linux/sched.h>
21 #include <linux/tick.h>
22
23 #include "tick-internal.h"
24
25 /*
26  * Broadcast support for broken x86 hardware, where the local apic
27  * timer stops in C3 state.
28  */
29
30 struct tick_device tick_broadcast_device;
31 static cpumask_t tick_broadcast_mask;
32 static DEFINE_SPINLOCK(tick_broadcast_lock);
33
34 #ifdef CONFIG_TICK_ONESHOT
35 static void tick_broadcast_clear_oneshot(int cpu);
36 #else
37 static inline void tick_broadcast_clear_oneshot(int cpu) { }
38 #endif
39
40 /*
41  * Debugging: see timer_list.c
42  */
43 struct tick_device *tick_get_broadcast_device(void)
44 {
45         return &tick_broadcast_device;
46 }
47
48 cpumask_t *tick_get_broadcast_mask(void)
49 {
50         return &tick_broadcast_mask;
51 }
52
53 /*
54  * Start the device in periodic mode
55  */
56 static void tick_broadcast_start_periodic(struct clock_event_device *bc)
57 {
58         if (bc)
59                 tick_setup_periodic(bc, 1);
60 }
61
62 /*
63  * Check, if the device can be utilized as broadcast device:
64  */
65 int tick_check_broadcast_device(struct clock_event_device *dev)
66 {
67         if ((tick_broadcast_device.evtdev &&
68              tick_broadcast_device.evtdev->rating >= dev->rating) ||
69              (dev->features & CLOCK_EVT_FEAT_C3STOP))
70                 return 0;
71
72         clockevents_exchange_device(NULL, dev);
73         tick_broadcast_device.evtdev = dev;
74         if (!cpus_empty(tick_broadcast_mask))
75                 tick_broadcast_start_periodic(dev);
76         return 1;
77 }
78
79 /*
80  * Check, if the device is the broadcast device
81  */
82 int tick_is_broadcast_device(struct clock_event_device *dev)
83 {
84         return (dev && tick_broadcast_device.evtdev == dev);
85 }
86
87 /*
88  * Check, if the device is disfunctional and a place holder, which
89  * needs to be handled by the broadcast device.
90  */
91 int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu)
92 {
93         unsigned long flags;
94         int ret = 0;
95
96         spin_lock_irqsave(&tick_broadcast_lock, flags);
97
98         /*
99          * Devices might be registered with both periodic and oneshot
100          * mode disabled. This signals, that the device needs to be
101          * operated from the broadcast device and is a placeholder for
102          * the cpu local device.
103          */
104         if (!tick_device_is_functional(dev)) {
105                 dev->event_handler = tick_handle_periodic;
106                 cpu_set(cpu, tick_broadcast_mask);
107                 tick_broadcast_start_periodic(tick_broadcast_device.evtdev);
108                 ret = 1;
109         } else {
110                 /*
111                  * When the new device is not affected by the stop
112                  * feature and the cpu is marked in the broadcast mask
113                  * then clear the broadcast bit.
114                  */
115                 if (!(dev->features & CLOCK_EVT_FEAT_C3STOP)) {
116                         int cpu = smp_processor_id();
117
118                         cpu_clear(cpu, tick_broadcast_mask);
119                         tick_broadcast_clear_oneshot(cpu);
120                 }
121         }
122         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
123         return ret;
124 }
125
126 /*
127  * Broadcast the event to the cpus, which are set in the mask
128  */
129 int tick_do_broadcast(cpumask_t mask)
130 {
131         int ret = 0, cpu = smp_processor_id();
132         struct tick_device *td;
133
134         /*
135          * Check, if the current cpu is in the mask
136          */
137         if (cpu_isset(cpu, mask)) {
138                 cpu_clear(cpu, mask);
139                 td = &per_cpu(tick_cpu_device, cpu);
140                 td->evtdev->event_handler(td->evtdev);
141                 ret = 1;
142         }
143
144         if (!cpus_empty(mask)) {
145                 /*
146                  * It might be necessary to actually check whether the devices
147                  * have different broadcast functions. For now, just use the
148                  * one of the first device. This works as long as we have this
149                  * misfeature only on x86 (lapic)
150                  */
151                 cpu = first_cpu(mask);
152                 td = &per_cpu(tick_cpu_device, cpu);
153                 td->evtdev->broadcast(mask);
154                 ret = 1;
155         }
156         return ret;
157 }
158
159 /*
160  * Periodic broadcast:
161  * - invoke the broadcast handlers
162  */
163 static void tick_do_periodic_broadcast(void)
164 {
165         cpumask_t mask;
166
167         spin_lock(&tick_broadcast_lock);
168
169         cpus_and(mask, cpu_online_map, tick_broadcast_mask);
170         tick_do_broadcast(mask);
171
172         spin_unlock(&tick_broadcast_lock);
173 }
174
175 /*
176  * Event handler for periodic broadcast ticks
177  */
178 static void tick_handle_periodic_broadcast(struct clock_event_device *dev)
179 {
180         tick_do_periodic_broadcast();
181
182         /*
183          * The device is in periodic mode. No reprogramming necessary:
184          */
185         if (dev->mode == CLOCK_EVT_MODE_PERIODIC)
186                 return;
187
188         /*
189          * Setup the next period for devices, which do not have
190          * periodic mode:
191          */
192         for (;;) {
193                 ktime_t next = ktime_add(dev->next_event, tick_period);
194
195                 if (!clockevents_program_event(dev, next, ktime_get()))
196                         return;
197                 tick_do_periodic_broadcast();
198         }
199 }
200
201 /*
202  * Powerstate information: The system enters/leaves a state, where
203  * affected devices might stop
204  */
205 static void tick_do_broadcast_on_off(void *why)
206 {
207         struct clock_event_device *bc, *dev;
208         struct tick_device *td;
209         unsigned long flags, *reason = why;
210         int cpu;
211
212         spin_lock_irqsave(&tick_broadcast_lock, flags);
213
214         cpu = smp_processor_id();
215         td = &per_cpu(tick_cpu_device, cpu);
216         dev = td->evtdev;
217         bc = tick_broadcast_device.evtdev;
218
219         /*
220          * Is the device not affected by the powerstate ?
221          */
222         if (!dev || !(dev->features & CLOCK_EVT_FEAT_C3STOP))
223                 goto out;
224
225         /*
226          * Defect device ?
227          */
228         if (!tick_device_is_functional(dev)) {
229                 /*
230                  * AMD C1E wreckage fixup:
231                  *
232                  * Device was registered functional in the first
233                  * place. Now the secondary CPU detected the C1E
234                  * misfeature and notifies us to fix it up
235                  */
236                 if (*reason != CLOCK_EVT_NOTIFY_BROADCAST_FORCE)
237                         goto out;
238         }
239
240         switch (*reason) {
241         case CLOCK_EVT_NOTIFY_BROADCAST_ON:
242         case CLOCK_EVT_NOTIFY_BROADCAST_FORCE:
243                 if (!cpu_isset(cpu, tick_broadcast_mask)) {
244                         cpu_set(cpu, tick_broadcast_mask);
245                         if (td->mode == TICKDEV_MODE_PERIODIC)
246                                 clockevents_set_mode(dev,
247                                                      CLOCK_EVT_MODE_SHUTDOWN);
248                 }
249                 break;
250         case CLOCK_EVT_NOTIFY_BROADCAST_OFF:
251                 if (cpu_isset(cpu, tick_broadcast_mask)) {
252                         cpu_clear(cpu, tick_broadcast_mask);
253                         if (td->mode == TICKDEV_MODE_PERIODIC)
254                                 tick_setup_periodic(dev, 0);
255                 }
256                 break;
257         }
258
259         if (cpus_empty(tick_broadcast_mask))
260                 clockevents_set_mode(bc, CLOCK_EVT_MODE_SHUTDOWN);
261         else {
262                 if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)
263                         tick_broadcast_start_periodic(bc);
264                 else
265                         tick_broadcast_setup_oneshot(bc);
266         }
267 out:
268         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
269 }
270
271 /*
272  * Powerstate information: The system enters/leaves a state, where
273  * affected devices might stop.
274  */
275 void tick_broadcast_on_off(unsigned long reason, int *oncpu)
276 {
277         if (!cpu_isset(*oncpu, cpu_online_map))
278                 printk(KERN_ERR "tick-braodcast: ignoring broadcast for "
279                        "offline CPU #%d\n", *oncpu);
280         else
281                 smp_call_function_single(*oncpu, tick_do_broadcast_on_off,
282                                          &reason, 1, 1);
283 }
284
285 /*
286  * Set the periodic handler depending on broadcast on/off
287  */
288 void tick_set_periodic_handler(struct clock_event_device *dev, int broadcast)
289 {
290         if (!broadcast)
291                 dev->event_handler = tick_handle_periodic;
292         else
293                 dev->event_handler = tick_handle_periodic_broadcast;
294 }
295
296 /*
297  * Remove a CPU from broadcasting
298  */
299 void tick_shutdown_broadcast(unsigned int *cpup)
300 {
301         struct clock_event_device *bc;
302         unsigned long flags;
303         unsigned int cpu = *cpup;
304
305         spin_lock_irqsave(&tick_broadcast_lock, flags);
306
307         bc = tick_broadcast_device.evtdev;
308         cpu_clear(cpu, tick_broadcast_mask);
309
310         if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC) {
311                 if (bc && cpus_empty(tick_broadcast_mask))
312                         clockevents_set_mode(bc, CLOCK_EVT_MODE_SHUTDOWN);
313         }
314
315         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
316 }
317
318 void tick_suspend_broadcast(void)
319 {
320         struct clock_event_device *bc;
321         unsigned long flags;
322
323         spin_lock_irqsave(&tick_broadcast_lock, flags);
324
325         bc = tick_broadcast_device.evtdev;
326         if (bc)
327                 clockevents_set_mode(bc, CLOCK_EVT_MODE_SHUTDOWN);
328
329         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
330 }
331
332 int tick_resume_broadcast(void)
333 {
334         struct clock_event_device *bc;
335         unsigned long flags;
336         int broadcast = 0;
337
338         spin_lock_irqsave(&tick_broadcast_lock, flags);
339
340         bc = tick_broadcast_device.evtdev;
341
342         if (bc) {
343                 clockevents_set_mode(bc, CLOCK_EVT_MODE_RESUME);
344
345                 switch (tick_broadcast_device.mode) {
346                 case TICKDEV_MODE_PERIODIC:
347                         if(!cpus_empty(tick_broadcast_mask))
348                                 tick_broadcast_start_periodic(bc);
349                         broadcast = cpu_isset(smp_processor_id(),
350                                               tick_broadcast_mask);
351                         break;
352                 case TICKDEV_MODE_ONESHOT:
353                         broadcast = tick_resume_broadcast_oneshot(bc);
354                         break;
355                 }
356         }
357         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
358
359         return broadcast;
360 }
361
362
363 #ifdef CONFIG_TICK_ONESHOT
364
365 static cpumask_t tick_broadcast_oneshot_mask;
366
367 /*
368  * Debugging: see timer_list.c
369  */
370 cpumask_t *tick_get_broadcast_oneshot_mask(void)
371 {
372         return &tick_broadcast_oneshot_mask;
373 }
374
375 static int tick_broadcast_set_event(ktime_t expires, int force)
376 {
377         struct clock_event_device *bc = tick_broadcast_device.evtdev;
378         ktime_t now = ktime_get();
379         int res;
380
381         for(;;) {
382                 res = clockevents_program_event(bc, expires, now);
383                 if (!res || !force)
384                         return res;
385                 now = ktime_get();
386                 expires = ktime_add(now, ktime_set(0, bc->min_delta_ns));
387         }
388 }
389
390 int tick_resume_broadcast_oneshot(struct clock_event_device *bc)
391 {
392         clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
393         return 0;
394 }
395
396 /*
397  * Reprogram the broadcast device:
398  *
399  * Called with tick_broadcast_lock held and interrupts disabled.
400  */
401 static int tick_broadcast_reprogram(void)
402 {
403         ktime_t expires = { .tv64 = KTIME_MAX };
404         struct tick_device *td;
405         int cpu;
406
407         /*
408          * Find the event which expires next:
409          */
410         for (cpu = first_cpu(tick_broadcast_oneshot_mask); cpu != NR_CPUS;
411              cpu = next_cpu(cpu, tick_broadcast_oneshot_mask)) {
412                 td = &per_cpu(tick_cpu_device, cpu);
413                 if (td->evtdev->next_event.tv64 < expires.tv64)
414                         expires = td->evtdev->next_event;
415         }
416
417         if (expires.tv64 == KTIME_MAX)
418                 return 0;
419
420         return tick_broadcast_set_event(expires, 0);
421 }
422
423 /*
424  * Handle oneshot mode broadcasting
425  */
426 static void tick_handle_oneshot_broadcast(struct clock_event_device *dev)
427 {
428         struct tick_device *td;
429         cpumask_t mask;
430         ktime_t now;
431         int cpu;
432
433         spin_lock(&tick_broadcast_lock);
434 again:
435         dev->next_event.tv64 = KTIME_MAX;
436         mask = CPU_MASK_NONE;
437         now = ktime_get();
438         /* Find all expired events */
439         for (cpu = first_cpu(tick_broadcast_oneshot_mask); cpu != NR_CPUS;
440              cpu = next_cpu(cpu, tick_broadcast_oneshot_mask)) {
441                 td = &per_cpu(tick_cpu_device, cpu);
442                 if (td->evtdev->next_event.tv64 <= now.tv64)
443                         cpu_set(cpu, mask);
444         }
445
446         /*
447          * Wakeup the cpus which have an expired event. The broadcast
448          * device is reprogrammed in the return from idle code.
449          */
450         if (!tick_do_broadcast(mask)) {
451                 /*
452                  * The global event did not expire any CPU local
453                  * events. This happens in dyntick mode, as the
454                  * maximum PIT delta is quite small.
455                  */
456                 if (tick_broadcast_reprogram())
457                         goto again;
458         }
459         spin_unlock(&tick_broadcast_lock);
460 }
461
462 /*
463  * Powerstate information: The system enters/leaves a state, where
464  * affected devices might stop
465  */
466 void tick_broadcast_oneshot_control(unsigned long reason)
467 {
468         struct clock_event_device *bc, *dev;
469         struct tick_device *td;
470         unsigned long flags;
471         int cpu;
472
473         spin_lock_irqsave(&tick_broadcast_lock, flags);
474
475         /*
476          * Periodic mode does not care about the enter/exit of power
477          * states
478          */
479         if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)
480                 goto out;
481
482         bc = tick_broadcast_device.evtdev;
483         cpu = smp_processor_id();
484         td = &per_cpu(tick_cpu_device, cpu);
485         dev = td->evtdev;
486
487         if (!(dev->features & CLOCK_EVT_FEAT_C3STOP))
488                 goto out;
489
490         if (reason == CLOCK_EVT_NOTIFY_BROADCAST_ENTER) {
491                 if (!cpu_isset(cpu, tick_broadcast_oneshot_mask)) {
492                         cpu_set(cpu, tick_broadcast_oneshot_mask);
493                         clockevents_set_mode(dev, CLOCK_EVT_MODE_SHUTDOWN);
494                         if (dev->next_event.tv64 < bc->next_event.tv64)
495                                 tick_broadcast_set_event(dev->next_event, 1);
496                 }
497         } else {
498                 if (cpu_isset(cpu, tick_broadcast_oneshot_mask)) {
499                         cpu_clear(cpu, tick_broadcast_oneshot_mask);
500                         clockevents_set_mode(dev, CLOCK_EVT_MODE_ONESHOT);
501                         if (dev->next_event.tv64 != KTIME_MAX)
502                                 tick_program_event(dev->next_event, 1);
503                 }
504         }
505
506 out:
507         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
508 }
509
510 /*
511  * Reset the one shot broadcast for a cpu
512  *
513  * Called with tick_broadcast_lock held
514  */
515 static void tick_broadcast_clear_oneshot(int cpu)
516 {
517         cpu_clear(cpu, tick_broadcast_oneshot_mask);
518 }
519
520 /**
521  * tick_broadcast_setup_highres - setup the broadcast device for highres
522  */
523 void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
524 {
525         bc->event_handler = tick_handle_oneshot_broadcast;
526         clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
527         bc->next_event.tv64 = KTIME_MAX;
528 }
529
530 /*
531  * Select oneshot operating mode for the broadcast device
532  */
533 void tick_broadcast_switch_to_oneshot(void)
534 {
535         struct clock_event_device *bc;
536         unsigned long flags;
537
538         spin_lock_irqsave(&tick_broadcast_lock, flags);
539
540         tick_broadcast_device.mode = TICKDEV_MODE_ONESHOT;
541         bc = tick_broadcast_device.evtdev;
542         if (bc)
543                 tick_broadcast_setup_oneshot(bc);
544         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
545 }
546
547
548 /*
549  * Remove a dead CPU from broadcasting
550  */
551 void tick_shutdown_broadcast_oneshot(unsigned int *cpup)
552 {
553         unsigned long flags;
554         unsigned int cpu = *cpup;
555
556         spin_lock_irqsave(&tick_broadcast_lock, flags);
557
558         /*
559          * Clear the broadcast mask flag for the dead cpu, but do not
560          * stop the broadcast device!
561          */
562         cpu_clear(cpu, tick_broadcast_oneshot_mask);
563
564         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
565 }
566
567 #endif