2 * linux/kernel/time/tick-broadcast.c
4 * This file contains functions which emulate a local clock-event
5 * device via a broadcast event source.
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
11 * This code is licenced under the GPL version 2. For details see
12 * kernel-base/COPYING.
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>
23 #include "tick-internal.h"
26 * Broadcast support for broken x86 hardware, where the local apic
27 * timer stops in C3 state.
30 struct tick_device tick_broadcast_device
;
31 static cpumask_t tick_broadcast_mask
;
32 static DEFINE_SPINLOCK(tick_broadcast_lock
);
34 #ifdef CONFIG_TICK_ONESHOT
35 static void tick_broadcast_clear_oneshot(int cpu
);
37 static inline void tick_broadcast_clear_oneshot(int cpu
) { }
41 * Debugging: see timer_list.c
43 struct tick_device
*tick_get_broadcast_device(void)
45 return &tick_broadcast_device
;
48 cpumask_t
*tick_get_broadcast_mask(void)
50 return &tick_broadcast_mask
;
54 * Start the device in periodic mode
56 static void tick_broadcast_start_periodic(struct clock_event_device
*bc
)
59 tick_setup_periodic(bc
, 1);
63 * Check, if the device can be utilized as broadcast device:
65 int tick_check_broadcast_device(struct clock_event_device
*dev
)
67 if (tick_broadcast_device
.evtdev
||
68 (dev
->features
& CLOCK_EVT_FEAT_C3STOP
))
71 clockevents_exchange_device(NULL
, dev
);
72 tick_broadcast_device
.evtdev
= dev
;
73 if (!cpus_empty(tick_broadcast_mask
))
74 tick_broadcast_start_periodic(dev
);
79 * Check, if the device is the broadcast device
81 int tick_is_broadcast_device(struct clock_event_device
*dev
)
83 return (dev
&& tick_broadcast_device
.evtdev
== dev
);
87 * Check, if the device is disfunctional and a place holder, which
88 * needs to be handled by the broadcast device.
90 int tick_device_uses_broadcast(struct clock_event_device
*dev
, int cpu
)
95 spin_lock_irqsave(&tick_broadcast_lock
, flags
);
98 * Devices might be registered with both periodic and oneshot
99 * mode disabled. This signals, that the device needs to be
100 * operated from the broadcast device and is a placeholder for
101 * the cpu local device.
103 if (!tick_device_is_functional(dev
)) {
104 dev
->event_handler
= tick_handle_periodic
;
105 cpu_set(cpu
, tick_broadcast_mask
);
106 tick_broadcast_start_periodic(tick_broadcast_device
.evtdev
);
110 * When the new device is not affected by the stop
111 * feature and the cpu is marked in the broadcast mask
112 * then clear the broadcast bit.
114 if (!(dev
->features
& CLOCK_EVT_FEAT_C3STOP
)) {
115 int cpu
= smp_processor_id();
117 cpu_clear(cpu
, tick_broadcast_mask
);
118 tick_broadcast_clear_oneshot(cpu
);
121 spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
126 * Broadcast the event to the cpus, which are set in the mask
128 int tick_do_broadcast(cpumask_t mask
)
130 int ret
= 0, cpu
= smp_processor_id();
131 struct tick_device
*td
;
134 * Check, if the current cpu is in the mask
136 if (cpu_isset(cpu
, mask
)) {
137 cpu_clear(cpu
, mask
);
138 td
= &per_cpu(tick_cpu_device
, cpu
);
139 td
->evtdev
->event_handler(td
->evtdev
);
143 if (!cpus_empty(mask
)) {
145 * It might be necessary to actually check whether the devices
146 * have different broadcast functions. For now, just use the
147 * one of the first device. This works as long as we have this
148 * misfeature only on x86 (lapic)
150 cpu
= first_cpu(mask
);
151 td
= &per_cpu(tick_cpu_device
, cpu
);
152 td
->evtdev
->broadcast(mask
);
159 * Periodic broadcast:
160 * - invoke the broadcast handlers
162 static void tick_do_periodic_broadcast(void)
166 spin_lock(&tick_broadcast_lock
);
168 cpus_and(mask
, cpu_online_map
, tick_broadcast_mask
);
169 tick_do_broadcast(mask
);
171 spin_unlock(&tick_broadcast_lock
);
175 * Event handler for periodic broadcast ticks
177 static void tick_handle_periodic_broadcast(struct clock_event_device
*dev
)
179 tick_do_periodic_broadcast();
182 * The device is in periodic mode. No reprogramming necessary:
184 if (dev
->mode
== CLOCK_EVT_MODE_PERIODIC
)
188 * Setup the next period for devices, which do not have
192 ktime_t next
= ktime_add(dev
->next_event
, tick_period
);
194 if (!clockevents_program_event(dev
, next
, ktime_get()))
196 tick_do_periodic_broadcast();
201 * Powerstate information: The system enters/leaves a state, where
202 * affected devices might stop
204 static void tick_do_broadcast_on_off(void *why
)
206 struct clock_event_device
*bc
, *dev
;
207 struct tick_device
*td
;
208 unsigned long flags
, *reason
= why
;
211 spin_lock_irqsave(&tick_broadcast_lock
, flags
);
213 cpu
= smp_processor_id();
214 td
= &per_cpu(tick_cpu_device
, cpu
);
216 bc
= tick_broadcast_device
.evtdev
;
219 * Is the device in broadcast mode forever or is it not
220 * affected by the powerstate ?
222 if (!dev
|| !tick_device_is_functional(dev
) ||
223 !(dev
->features
& CLOCK_EVT_FEAT_C3STOP
))
226 if (*reason
== CLOCK_EVT_NOTIFY_BROADCAST_ON
) {
227 if (!cpu_isset(cpu
, tick_broadcast_mask
)) {
228 cpu_set(cpu
, tick_broadcast_mask
);
229 if (td
->mode
== TICKDEV_MODE_PERIODIC
)
230 clockevents_set_mode(dev
,
231 CLOCK_EVT_MODE_SHUTDOWN
);
234 if (cpu_isset(cpu
, tick_broadcast_mask
)) {
235 cpu_clear(cpu
, tick_broadcast_mask
);
236 if (td
->mode
== TICKDEV_MODE_PERIODIC
)
237 tick_setup_periodic(dev
, 0);
241 if (cpus_empty(tick_broadcast_mask
))
242 clockevents_set_mode(bc
, CLOCK_EVT_MODE_SHUTDOWN
);
244 if (tick_broadcast_device
.mode
== TICKDEV_MODE_PERIODIC
)
245 tick_broadcast_start_periodic(bc
);
247 tick_broadcast_setup_oneshot(bc
);
250 spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
254 * Powerstate information: The system enters/leaves a state, where
255 * affected devices might stop.
257 void tick_broadcast_on_off(unsigned long reason
, int *oncpu
)
261 if (!cpu_isset(*oncpu
, cpu_online_map
)) {
262 printk(KERN_ERR
"tick-braodcast: ignoring broadcast for "
263 "offline CPU #%d\n", *oncpu
);
267 tick_do_broadcast_on_off(&reason
);
269 smp_call_function_single(*oncpu
,
270 tick_do_broadcast_on_off
,
277 * Set the periodic handler depending on broadcast on/off
279 void tick_set_periodic_handler(struct clock_event_device
*dev
, int broadcast
)
282 dev
->event_handler
= tick_handle_periodic
;
284 dev
->event_handler
= tick_handle_periodic_broadcast
;
288 * Remove a CPU from broadcasting
290 void tick_shutdown_broadcast(unsigned int *cpup
)
292 struct clock_event_device
*bc
;
294 unsigned int cpu
= *cpup
;
296 spin_lock_irqsave(&tick_broadcast_lock
, flags
);
298 bc
= tick_broadcast_device
.evtdev
;
299 cpu_clear(cpu
, tick_broadcast_mask
);
301 if (tick_broadcast_device
.mode
== TICKDEV_MODE_PERIODIC
) {
302 if (bc
&& cpus_empty(tick_broadcast_mask
))
303 clockevents_set_mode(bc
, CLOCK_EVT_MODE_SHUTDOWN
);
306 spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
309 void tick_suspend_broadcast(void)
311 struct clock_event_device
*bc
;
314 spin_lock_irqsave(&tick_broadcast_lock
, flags
);
316 bc
= tick_broadcast_device
.evtdev
;
318 clockevents_set_mode(bc
, CLOCK_EVT_MODE_SHUTDOWN
);
320 spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
323 int tick_resume_broadcast(void)
325 struct clock_event_device
*bc
;
329 spin_lock_irqsave(&tick_broadcast_lock
, flags
);
331 bc
= tick_broadcast_device
.evtdev
;
334 clockevents_set_mode(bc
, CLOCK_EVT_MODE_RESUME
);
336 switch (tick_broadcast_device
.mode
) {
337 case TICKDEV_MODE_PERIODIC
:
338 if(!cpus_empty(tick_broadcast_mask
))
339 tick_broadcast_start_periodic(bc
);
340 broadcast
= cpu_isset(smp_processor_id(),
341 tick_broadcast_mask
);
343 case TICKDEV_MODE_ONESHOT
:
344 broadcast
= tick_resume_broadcast_oneshot(bc
);
348 spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
354 #ifdef CONFIG_TICK_ONESHOT
356 static cpumask_t tick_broadcast_oneshot_mask
;
359 * Debugging: see timer_list.c
361 cpumask_t
*tick_get_broadcast_oneshot_mask(void)
363 return &tick_broadcast_oneshot_mask
;
366 static int tick_broadcast_set_event(ktime_t expires
, int force
)
368 struct clock_event_device
*bc
= tick_broadcast_device
.evtdev
;
369 ktime_t now
= ktime_get();
373 res
= clockevents_program_event(bc
, expires
, now
);
377 expires
= ktime_add(now
, ktime_set(0, bc
->min_delta_ns
));
381 int tick_resume_broadcast_oneshot(struct clock_event_device
*bc
)
383 clockevents_set_mode(bc
, CLOCK_EVT_MODE_ONESHOT
);
388 * Reprogram the broadcast device:
390 * Called with tick_broadcast_lock held and interrupts disabled.
392 static int tick_broadcast_reprogram(void)
394 ktime_t expires
= { .tv64
= KTIME_MAX
};
395 struct tick_device
*td
;
399 * Find the event which expires next:
401 for (cpu
= first_cpu(tick_broadcast_oneshot_mask
); cpu
!= NR_CPUS
;
402 cpu
= next_cpu(cpu
, tick_broadcast_oneshot_mask
)) {
403 td
= &per_cpu(tick_cpu_device
, cpu
);
404 if (td
->evtdev
->next_event
.tv64
< expires
.tv64
)
405 expires
= td
->evtdev
->next_event
;
408 if (expires
.tv64
== KTIME_MAX
)
411 return tick_broadcast_set_event(expires
, 0);
415 * Handle oneshot mode broadcasting
417 static void tick_handle_oneshot_broadcast(struct clock_event_device
*dev
)
419 struct tick_device
*td
;
424 spin_lock(&tick_broadcast_lock
);
426 dev
->next_event
.tv64
= KTIME_MAX
;
427 mask
= CPU_MASK_NONE
;
429 /* Find all expired events */
430 for (cpu
= first_cpu(tick_broadcast_oneshot_mask
); cpu
!= NR_CPUS
;
431 cpu
= next_cpu(cpu
, tick_broadcast_oneshot_mask
)) {
432 td
= &per_cpu(tick_cpu_device
, cpu
);
433 if (td
->evtdev
->next_event
.tv64
<= now
.tv64
)
438 * Wakeup the cpus which have an expired event. The broadcast
439 * device is reprogrammed in the return from idle code.
441 if (!tick_do_broadcast(mask
)) {
443 * The global event did not expire any CPU local
444 * events. This happens in dyntick mode, as the
445 * maximum PIT delta is quite small.
447 if (tick_broadcast_reprogram())
450 spin_unlock(&tick_broadcast_lock
);
454 * Powerstate information: The system enters/leaves a state, where
455 * affected devices might stop
457 void tick_broadcast_oneshot_control(unsigned long reason
)
459 struct clock_event_device
*bc
, *dev
;
460 struct tick_device
*td
;
464 spin_lock_irqsave(&tick_broadcast_lock
, flags
);
467 * Periodic mode does not care about the enter/exit of power
470 if (tick_broadcast_device
.mode
== TICKDEV_MODE_PERIODIC
)
473 bc
= tick_broadcast_device
.evtdev
;
474 cpu
= smp_processor_id();
475 td
= &per_cpu(tick_cpu_device
, cpu
);
478 if (!(dev
->features
& CLOCK_EVT_FEAT_C3STOP
))
481 if (reason
== CLOCK_EVT_NOTIFY_BROADCAST_ENTER
) {
482 if (!cpu_isset(cpu
, tick_broadcast_oneshot_mask
)) {
483 cpu_set(cpu
, tick_broadcast_oneshot_mask
);
484 clockevents_set_mode(dev
, CLOCK_EVT_MODE_SHUTDOWN
);
485 if (dev
->next_event
.tv64
< bc
->next_event
.tv64
)
486 tick_broadcast_set_event(dev
->next_event
, 1);
489 if (cpu_isset(cpu
, tick_broadcast_oneshot_mask
)) {
490 cpu_clear(cpu
, tick_broadcast_oneshot_mask
);
491 clockevents_set_mode(dev
, CLOCK_EVT_MODE_ONESHOT
);
492 if (dev
->next_event
.tv64
!= KTIME_MAX
)
493 tick_program_event(dev
->next_event
, 1);
498 spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
502 * Reset the one shot broadcast for a cpu
504 * Called with tick_broadcast_lock held
506 static void tick_broadcast_clear_oneshot(int cpu
)
508 cpu_clear(cpu
, tick_broadcast_oneshot_mask
);
512 * tick_broadcast_setup_highres - setup the broadcast device for highres
514 void tick_broadcast_setup_oneshot(struct clock_event_device
*bc
)
516 if (bc
->mode
!= CLOCK_EVT_MODE_ONESHOT
) {
517 bc
->event_handler
= tick_handle_oneshot_broadcast
;
518 clockevents_set_mode(bc
, CLOCK_EVT_MODE_ONESHOT
);
519 bc
->next_event
.tv64
= KTIME_MAX
;
524 * Select oneshot operating mode for the broadcast device
526 void tick_broadcast_switch_to_oneshot(void)
528 struct clock_event_device
*bc
;
531 spin_lock_irqsave(&tick_broadcast_lock
, flags
);
533 tick_broadcast_device
.mode
= TICKDEV_MODE_ONESHOT
;
534 bc
= tick_broadcast_device
.evtdev
;
536 tick_broadcast_setup_oneshot(bc
);
537 spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
542 * Remove a dead CPU from broadcasting
544 void tick_shutdown_broadcast_oneshot(unsigned int *cpup
)
547 unsigned int cpu
= *cpup
;
549 spin_lock_irqsave(&tick_broadcast_lock
, flags
);
552 * Clear the broadcast mask flag for the dead cpu, but do not
553 * stop the broadcast device!
555 cpu_clear(cpu
, tick_broadcast_oneshot_mask
);
557 spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);