2 * linux/kernel/time/tick-common.c
4 * This file contains the base functions to manage periodic tick
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/interrupt.h>
18 #include <linux/percpu.h>
19 #include <linux/profile.h>
20 #include <linux/sched.h>
21 #include <linux/tick.h>
23 #include <asm/irq_regs.h>
25 #include "tick-internal.h"
30 DEFINE_PER_CPU(struct tick_device
, tick_cpu_device
);
32 * Tick next event: keeps track of the tick time
34 ktime_t tick_next_period
;
36 int tick_do_timer_cpu __read_mostly
= -1;
37 DEFINE_SPINLOCK(tick_device_lock
);
40 * Debugging: see timer_list.c
42 struct tick_device
*tick_get_device(int cpu
)
44 return &per_cpu(tick_cpu_device
, cpu
);
48 * tick_is_oneshot_available - check for a oneshot capable event device
50 int tick_is_oneshot_available(void)
52 struct clock_event_device
*dev
= __get_cpu_var(tick_cpu_device
).evtdev
;
54 return dev
&& (dev
->features
& CLOCK_EVT_FEAT_ONESHOT
);
60 static void tick_periodic(int cpu
)
62 if (tick_do_timer_cpu
== cpu
) {
63 write_seqlock(&xtime_lock
);
65 /* Keep track of the next tick event */
66 tick_next_period
= ktime_add(tick_next_period
, tick_period
);
69 write_sequnlock(&xtime_lock
);
72 update_process_times(user_mode(get_irq_regs()));
73 profile_tick(CPU_PROFILING
);
77 * Event handler for periodic ticks
79 void tick_handle_periodic(struct clock_event_device
*dev
)
81 int cpu
= smp_processor_id();
86 if (dev
->mode
!= CLOCK_EVT_MODE_ONESHOT
)
89 * Setup the next period for devices, which do not have
92 next
= ktime_add(dev
->next_event
, tick_period
);
94 if (!clockevents_program_event(dev
, next
, ktime_get()))
97 next
= ktime_add(next
, tick_period
);
102 * Setup the device for a periodic tick
104 void tick_setup_periodic(struct clock_event_device
*dev
, int broadcast
)
106 tick_set_periodic_handler(dev
, broadcast
);
108 /* Broadcast setup ? */
109 if (!tick_device_is_functional(dev
))
112 if (dev
->features
& CLOCK_EVT_FEAT_PERIODIC
) {
113 clockevents_set_mode(dev
, CLOCK_EVT_MODE_PERIODIC
);
119 seq
= read_seqbegin(&xtime_lock
);
120 next
= tick_next_period
;
121 } while (read_seqretry(&xtime_lock
, seq
));
123 clockevents_set_mode(dev
, CLOCK_EVT_MODE_ONESHOT
);
126 if (!clockevents_program_event(dev
, next
, ktime_get()))
128 next
= ktime_add(next
, tick_period
);
134 * Setup the tick device
136 static void tick_setup_device(struct tick_device
*td
,
137 struct clock_event_device
*newdev
, int cpu
,
138 const cpumask_t
*cpumask
)
141 void (*handler
)(struct clock_event_device
*) = NULL
;
144 * First device setup ?
148 * If no cpu took the do_timer update, assign it to
151 if (tick_do_timer_cpu
== -1) {
152 tick_do_timer_cpu
= cpu
;
153 tick_next_period
= ktime_get();
154 tick_period
= ktime_set(0, NSEC_PER_SEC
/ HZ
);
158 * Startup in periodic mode first.
160 td
->mode
= TICKDEV_MODE_PERIODIC
;
162 handler
= td
->evtdev
->event_handler
;
163 next_event
= td
->evtdev
->next_event
;
169 * When the device is not per cpu, pin the interrupt to the
172 if (!cpus_equal(newdev
->cpumask
, *cpumask
))
173 irq_set_affinity(newdev
->irq
, *cpumask
);
176 * When global broadcasting is active, check if the current
177 * device is registered as a placeholder for broadcast mode.
178 * This allows us to handle this x86 misfeature in a generic
181 if (tick_device_uses_broadcast(newdev
, cpu
))
184 if (td
->mode
== TICKDEV_MODE_PERIODIC
)
185 tick_setup_periodic(newdev
, 0);
187 tick_setup_oneshot(newdev
, handler
, next_event
);
191 * Check, if the new registered device should be used.
193 static int tick_check_new_device(struct clock_event_device
*newdev
)
195 struct clock_event_device
*curdev
;
196 struct tick_device
*td
;
197 int cpu
, ret
= NOTIFY_OK
;
199 cpumask_of_cpu_ptr_declare(cpumask
);
201 spin_lock_irqsave(&tick_device_lock
, flags
);
203 cpu
= smp_processor_id();
204 cpumask_of_cpu_ptr_next(cpumask
, cpu
);
205 if (!cpu_isset(cpu
, newdev
->cpumask
))
208 td
= &per_cpu(tick_cpu_device
, cpu
);
211 /* cpu local device ? */
212 if (!cpus_equal(newdev
->cpumask
, *cpumask
)) {
215 * If the cpu affinity of the device interrupt can not
218 if (!irq_can_set_affinity(newdev
->irq
))
222 * If we have a cpu local device already, do not replace it
223 * by a non cpu local device
225 if (curdev
&& cpus_equal(curdev
->cpumask
, *cpumask
))
230 * If we have an active device, then check the rating and the oneshot
235 * Prefer one shot capable devices !
237 if ((curdev
->features
& CLOCK_EVT_FEAT_ONESHOT
) &&
238 !(newdev
->features
& CLOCK_EVT_FEAT_ONESHOT
))
243 if (curdev
->rating
>= newdev
->rating
)
248 * Replace the eventually existing device by the new
249 * device. If the current device is the broadcast device, do
250 * not give it back to the clockevents layer !
252 if (tick_is_broadcast_device(curdev
)) {
253 clockevents_set_mode(curdev
, CLOCK_EVT_MODE_SHUTDOWN
);
256 clockevents_exchange_device(curdev
, newdev
);
257 tick_setup_device(td
, newdev
, cpu
, cpumask
);
258 if (newdev
->features
& CLOCK_EVT_FEAT_ONESHOT
)
259 tick_oneshot_notify();
261 spin_unlock_irqrestore(&tick_device_lock
, flags
);
266 * Can the new device be used as a broadcast device ?
268 if (tick_check_broadcast_device(newdev
))
271 spin_unlock_irqrestore(&tick_device_lock
, flags
);
277 * Shutdown an event device on a given cpu:
279 * This is called on a life CPU, when a CPU is dead. So we cannot
280 * access the hardware device itself.
281 * We just set the mode and remove it from the lists.
283 static void tick_shutdown(unsigned int *cpup
)
285 struct tick_device
*td
= &per_cpu(tick_cpu_device
, *cpup
);
286 struct clock_event_device
*dev
= td
->evtdev
;
289 spin_lock_irqsave(&tick_device_lock
, flags
);
290 td
->mode
= TICKDEV_MODE_PERIODIC
;
293 * Prevent that the clock events layer tries to call
294 * the set mode function!
296 dev
->mode
= CLOCK_EVT_MODE_UNUSED
;
297 clockevents_exchange_device(dev
, NULL
);
300 /* Transfer the do_timer job away from this cpu */
301 if (*cpup
== tick_do_timer_cpu
) {
302 int cpu
= first_cpu(cpu_online_map
);
304 tick_do_timer_cpu
= (cpu
!= NR_CPUS
) ? cpu
: -1;
306 spin_unlock_irqrestore(&tick_device_lock
, flags
);
309 static void tick_suspend(void)
311 struct tick_device
*td
= &__get_cpu_var(tick_cpu_device
);
314 spin_lock_irqsave(&tick_device_lock
, flags
);
315 clockevents_set_mode(td
->evtdev
, CLOCK_EVT_MODE_SHUTDOWN
);
316 spin_unlock_irqrestore(&tick_device_lock
, flags
);
319 static void tick_resume(void)
321 struct tick_device
*td
= &__get_cpu_var(tick_cpu_device
);
323 int broadcast
= tick_resume_broadcast();
325 spin_lock_irqsave(&tick_device_lock
, flags
);
326 clockevents_set_mode(td
->evtdev
, CLOCK_EVT_MODE_RESUME
);
329 if (td
->mode
== TICKDEV_MODE_PERIODIC
)
330 tick_setup_periodic(td
->evtdev
, 0);
332 tick_resume_oneshot();
334 spin_unlock_irqrestore(&tick_device_lock
, flags
);
338 * Notification about clock event devices
340 static int tick_notify(struct notifier_block
*nb
, unsigned long reason
,
345 case CLOCK_EVT_NOTIFY_ADD
:
346 return tick_check_new_device(dev
);
348 case CLOCK_EVT_NOTIFY_BROADCAST_ON
:
349 case CLOCK_EVT_NOTIFY_BROADCAST_OFF
:
350 case CLOCK_EVT_NOTIFY_BROADCAST_FORCE
:
351 tick_broadcast_on_off(reason
, dev
);
354 case CLOCK_EVT_NOTIFY_BROADCAST_ENTER
:
355 case CLOCK_EVT_NOTIFY_BROADCAST_EXIT
:
356 tick_broadcast_oneshot_control(reason
);
359 case CLOCK_EVT_NOTIFY_CPU_DEAD
:
360 tick_shutdown_broadcast_oneshot(dev
);
361 tick_shutdown_broadcast(dev
);
365 case CLOCK_EVT_NOTIFY_SUSPEND
:
367 tick_suspend_broadcast();
370 case CLOCK_EVT_NOTIFY_RESUME
:
381 static struct notifier_block tick_notifier
= {
382 .notifier_call
= tick_notify
,
386 * tick_init - initialize the tick control
388 * Register the notifier with the clockevents framework
390 void __init
tick_init(void)
392 clockevents_register_notifier(&tick_notifier
);