clockevents: fix reprogramming decision in oneshot broadcast
[linux-3.10.git] / 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         if (!tick_device_is_functional(dev))
226                 goto out;
227
228         switch (*reason) {
229         case CLOCK_EVT_NOTIFY_BROADCAST_ON:
230         case CLOCK_EVT_NOTIFY_BROADCAST_FORCE:
231                 if (!cpu_isset(cpu, tick_broadcast_mask)) {
232                         cpu_set(cpu, tick_broadcast_mask);
233                         if (td->mode == TICKDEV_MODE_PERIODIC)
234                                 clockevents_set_mode(dev,
235                                                      CLOCK_EVT_MODE_SHUTDOWN);
236                 }
237                 if (*reason == CLOCK_EVT_NOTIFY_BROADCAST_FORCE)
238                         dev->features |= CLOCK_EVT_FEAT_DUMMY;
239                 break;
240         case CLOCK_EVT_NOTIFY_BROADCAST_OFF:
241                 if (cpu_isset(cpu, tick_broadcast_mask)) {
242                         cpu_clear(cpu, tick_broadcast_mask);
243                         if (td->mode == TICKDEV_MODE_PERIODIC)
244                                 tick_setup_periodic(dev, 0);
245                 }
246                 break;
247         }
248
249         if (cpus_empty(tick_broadcast_mask))
250                 clockevents_set_mode(bc, CLOCK_EVT_MODE_SHUTDOWN);
251         else {
252                 if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)
253                         tick_broadcast_start_periodic(bc);
254                 else
255                         tick_broadcast_setup_oneshot(bc);
256         }
257 out:
258         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
259 }
260
261 /*
262  * Powerstate information: The system enters/leaves a state, where
263  * affected devices might stop.
264  */
265 void tick_broadcast_on_off(unsigned long reason, int *oncpu)
266 {
267         if (!cpu_isset(*oncpu, cpu_online_map))
268                 printk(KERN_ERR "tick-braodcast: ignoring broadcast for "
269                        "offline CPU #%d\n", *oncpu);
270         else
271                 smp_call_function_single(*oncpu, tick_do_broadcast_on_off,
272                                          &reason, 1, 1);
273 }
274
275 /*
276  * Set the periodic handler depending on broadcast on/off
277  */
278 void tick_set_periodic_handler(struct clock_event_device *dev, int broadcast)
279 {
280         if (!broadcast)
281                 dev->event_handler = tick_handle_periodic;
282         else
283                 dev->event_handler = tick_handle_periodic_broadcast;
284 }
285
286 /*
287  * Remove a CPU from broadcasting
288  */
289 void tick_shutdown_broadcast(unsigned int *cpup)
290 {
291         struct clock_event_device *bc;
292         unsigned long flags;
293         unsigned int cpu = *cpup;
294
295         spin_lock_irqsave(&tick_broadcast_lock, flags);
296
297         bc = tick_broadcast_device.evtdev;
298         cpu_clear(cpu, tick_broadcast_mask);
299
300         if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC) {
301                 if (bc && cpus_empty(tick_broadcast_mask))
302                         clockevents_set_mode(bc, CLOCK_EVT_MODE_SHUTDOWN);
303         }
304
305         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
306 }
307
308 void tick_suspend_broadcast(void)
309 {
310         struct clock_event_device *bc;
311         unsigned long flags;
312
313         spin_lock_irqsave(&tick_broadcast_lock, flags);
314
315         bc = tick_broadcast_device.evtdev;
316         if (bc)
317                 clockevents_set_mode(bc, CLOCK_EVT_MODE_SHUTDOWN);
318
319         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
320 }
321
322 int tick_resume_broadcast(void)
323 {
324         struct clock_event_device *bc;
325         unsigned long flags;
326         int broadcast = 0;
327
328         spin_lock_irqsave(&tick_broadcast_lock, flags);
329
330         bc = tick_broadcast_device.evtdev;
331
332         if (bc) {
333                 clockevents_set_mode(bc, CLOCK_EVT_MODE_RESUME);
334
335                 switch (tick_broadcast_device.mode) {
336                 case TICKDEV_MODE_PERIODIC:
337                         if(!cpus_empty(tick_broadcast_mask))
338                                 tick_broadcast_start_periodic(bc);
339                         broadcast = cpu_isset(smp_processor_id(),
340                                               tick_broadcast_mask);
341                         break;
342                 case TICKDEV_MODE_ONESHOT:
343                         broadcast = tick_resume_broadcast_oneshot(bc);
344                         break;
345                 }
346         }
347         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
348
349         return broadcast;
350 }
351
352
353 #ifdef CONFIG_TICK_ONESHOT
354
355 static cpumask_t tick_broadcast_oneshot_mask;
356
357 /*
358  * Debugging: see timer_list.c
359  */
360 cpumask_t *tick_get_broadcast_oneshot_mask(void)
361 {
362         return &tick_broadcast_oneshot_mask;
363 }
364
365 static int tick_broadcast_set_event(ktime_t expires, int force)
366 {
367         struct clock_event_device *bc = tick_broadcast_device.evtdev;
368         ktime_t now = ktime_get();
369         int res;
370
371         for(;;) {
372                 res = clockevents_program_event(bc, expires, now);
373                 if (!res || !force)
374                         return res;
375                 now = ktime_get();
376                 expires = ktime_add(now, ktime_set(0, bc->min_delta_ns));
377         }
378 }
379
380 int tick_resume_broadcast_oneshot(struct clock_event_device *bc)
381 {
382         clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
383         return 0;
384 }
385
386 /*
387  * Handle oneshot mode broadcasting
388  */
389 static void tick_handle_oneshot_broadcast(struct clock_event_device *dev)
390 {
391         struct tick_device *td;
392         cpumask_t mask;
393         ktime_t now, next_event;
394         int cpu;
395
396         spin_lock(&tick_broadcast_lock);
397 again:
398         dev->next_event.tv64 = KTIME_MAX;
399         next_event.tv64 = KTIME_MAX;
400         mask = CPU_MASK_NONE;
401         now = ktime_get();
402         /* Find all expired events */
403         for (cpu = first_cpu(tick_broadcast_oneshot_mask); cpu != NR_CPUS;
404              cpu = next_cpu(cpu, tick_broadcast_oneshot_mask)) {
405                 td = &per_cpu(tick_cpu_device, cpu);
406                 if (td->evtdev->next_event.tv64 <= now.tv64)
407                         cpu_set(cpu, mask);
408                 else if (td->evtdev->next_event.tv64 < next_event.tv64)
409                         next_event.tv64 = td->evtdev->next_event.tv64;
410         }
411
412         /*
413          * Wakeup the cpus which have an expired event.
414          */
415         tick_do_broadcast(mask);
416
417         /*
418          * Two reasons for reprogram:
419          *
420          * - The global event did not expire any CPU local
421          * events. This happens in dyntick mode, as the maximum PIT
422          * delta is quite small.
423          *
424          * - There are pending events on sleeping CPUs which were not
425          * in the event mask
426          */
427         if (next_event.tv64 != KTIME_MAX) {
428                 /*
429                  * Rearm the broadcast device. If event expired,
430                  * repeat the above
431                  */
432                 if (tick_broadcast_set_event(next_event, 0))
433                         goto again;
434         }
435         spin_unlock(&tick_broadcast_lock);
436 }
437
438 /*
439  * Powerstate information: The system enters/leaves a state, where
440  * affected devices might stop
441  */
442 void tick_broadcast_oneshot_control(unsigned long reason)
443 {
444         struct clock_event_device *bc, *dev;
445         struct tick_device *td;
446         unsigned long flags;
447         int cpu;
448
449         spin_lock_irqsave(&tick_broadcast_lock, flags);
450
451         /*
452          * Periodic mode does not care about the enter/exit of power
453          * states
454          */
455         if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)
456                 goto out;
457
458         bc = tick_broadcast_device.evtdev;
459         cpu = smp_processor_id();
460         td = &per_cpu(tick_cpu_device, cpu);
461         dev = td->evtdev;
462
463         if (!(dev->features & CLOCK_EVT_FEAT_C3STOP))
464                 goto out;
465
466         if (reason == CLOCK_EVT_NOTIFY_BROADCAST_ENTER) {
467                 if (!cpu_isset(cpu, tick_broadcast_oneshot_mask)) {
468                         cpu_set(cpu, tick_broadcast_oneshot_mask);
469                         clockevents_set_mode(dev, CLOCK_EVT_MODE_SHUTDOWN);
470                         if (dev->next_event.tv64 < bc->next_event.tv64)
471                                 tick_broadcast_set_event(dev->next_event, 1);
472                 }
473         } else {
474                 if (cpu_isset(cpu, tick_broadcast_oneshot_mask)) {
475                         cpu_clear(cpu, tick_broadcast_oneshot_mask);
476                         clockevents_set_mode(dev, CLOCK_EVT_MODE_ONESHOT);
477                         if (dev->next_event.tv64 != KTIME_MAX)
478                                 tick_program_event(dev->next_event, 1);
479                 }
480         }
481
482 out:
483         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
484 }
485
486 /*
487  * Reset the one shot broadcast for a cpu
488  *
489  * Called with tick_broadcast_lock held
490  */
491 static void tick_broadcast_clear_oneshot(int cpu)
492 {
493         cpu_clear(cpu, tick_broadcast_oneshot_mask);
494 }
495
496 /**
497  * tick_broadcast_setup_oneshot - setup the broadcast device
498  */
499 void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
500 {
501         bc->event_handler = tick_handle_oneshot_broadcast;
502         clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
503         bc->next_event.tv64 = KTIME_MAX;
504 }
505
506 /*
507  * Select oneshot operating mode for the broadcast device
508  */
509 void tick_broadcast_switch_to_oneshot(void)
510 {
511         struct clock_event_device *bc;
512         unsigned long flags;
513
514         spin_lock_irqsave(&tick_broadcast_lock, flags);
515
516         tick_broadcast_device.mode = TICKDEV_MODE_ONESHOT;
517         bc = tick_broadcast_device.evtdev;
518         if (bc)
519                 tick_broadcast_setup_oneshot(bc);
520         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
521 }
522
523
524 /*
525  * Remove a dead CPU from broadcasting
526  */
527 void tick_shutdown_broadcast_oneshot(unsigned int *cpup)
528 {
529         unsigned long flags;
530         unsigned int cpu = *cpup;
531
532         spin_lock_irqsave(&tick_broadcast_lock, flags);
533
534         /*
535          * Clear the broadcast mask flag for the dead cpu, but do not
536          * stop the broadcast device!
537          */
538         cpu_clear(cpu, tick_broadcast_oneshot_mask);
539
540         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
541 }
542
543 #endif