2 * linux/kernel/time/clockevents.c
4 * This file contains functions which manage clock event devices.
6 * Copyright(C) 2005-2006, Thomas Gleixner <tglx@linutronix.de>
7 * Copyright(C) 2005-2007, Red Hat, Inc., Ingo Molnar
8 * Copyright(C) 2006-2007, Timesys Corp., Thomas Gleixner
10 * This code is licenced under the GPL version 2. For details see
11 * kernel-base/COPYING.
14 #include <linux/clockchips.h>
15 #include <linux/hrtimer.h>
16 #include <linux/init.h>
17 #include <linux/module.h>
18 #include <linux/notifier.h>
19 #include <linux/smp.h>
20 #include <linux/sysdev.h>
21 #include <linux/tick.h>
23 /* The registered clock event devices */
24 static LIST_HEAD(clockevent_devices
);
25 static LIST_HEAD(clockevents_released
);
27 /* Notification for clock events */
28 static RAW_NOTIFIER_HEAD(clockevents_chain
);
30 /* Protection for the above */
31 static DEFINE_SPINLOCK(clockevents_lock
);
34 * clockevents_delta2ns - Convert a latch value (device ticks) to nanoseconds
35 * @latch: value to convert
36 * @evt: pointer to clock event device descriptor
38 * Math helper, returns latch value converted to nanoseconds (bound checked)
40 unsigned long clockevent_delta2ns(unsigned long latch
,
41 struct clock_event_device
*evt
)
43 u64 clc
= ((u64
) latch
<< evt
->shift
);
45 if (unlikely(!evt
->mult
)) {
50 do_div(clc
, evt
->mult
);
56 return (unsigned long) clc
;
60 * clockevents_set_mode - set the operating mode of a clock event device
61 * @dev: device to modify
64 * Must be called with interrupts disabled !
66 void clockevents_set_mode(struct clock_event_device
*dev
,
67 enum clock_event_mode mode
)
69 if (dev
->mode
!= mode
) {
70 dev
->set_mode(mode
, dev
);
74 * A nsec2cyc multiplicator of 0 is invalid and we'd crash
75 * on it, so fix it up and emit a warning:
77 if (mode
== CLOCK_EVT_MODE_ONESHOT
) {
78 if (unlikely(!dev
->mult
)) {
87 * clockevents_shutdown - shutdown the device and clear next_event
88 * @dev: device to shutdown
90 void clockevents_shutdown(struct clock_event_device
*dev
)
92 clockevents_set_mode(dev
, CLOCK_EVT_MODE_SHUTDOWN
);
93 dev
->next_event
.tv64
= KTIME_MAX
;
97 * clockevents_program_event - Reprogram the clock event device.
98 * @expires: absolute expiry time (monotonic clock)
100 * Returns 0 on success, -ETIME when the event is in the past.
102 int clockevents_program_event(struct clock_event_device
*dev
, ktime_t expires
,
105 unsigned long long clc
;
108 if (unlikely(expires
.tv64
< 0)) {
113 delta
= ktime_to_ns(ktime_sub(expires
, now
));
118 dev
->next_event
= expires
;
120 if (dev
->mode
== CLOCK_EVT_MODE_SHUTDOWN
)
123 if (delta
> dev
->max_delta_ns
)
124 delta
= dev
->max_delta_ns
;
125 if (delta
< dev
->min_delta_ns
)
126 delta
= dev
->min_delta_ns
;
128 clc
= delta
* dev
->mult
;
131 return dev
->set_next_event((unsigned long) clc
, dev
);
135 * clockevents_register_notifier - register a clock events change listener
137 int clockevents_register_notifier(struct notifier_block
*nb
)
141 spin_lock(&clockevents_lock
);
142 ret
= raw_notifier_chain_register(&clockevents_chain
, nb
);
143 spin_unlock(&clockevents_lock
);
149 * Notify about a clock event change. Called with clockevents_lock
152 static void clockevents_do_notify(unsigned long reason
, void *dev
)
154 raw_notifier_call_chain(&clockevents_chain
, reason
, dev
);
158 * Called after a notify add to make devices available which were
159 * released from the notifier call.
161 static void clockevents_notify_released(void)
163 struct clock_event_device
*dev
;
165 while (!list_empty(&clockevents_released
)) {
166 dev
= list_entry(clockevents_released
.next
,
167 struct clock_event_device
, list
);
168 list_del(&dev
->list
);
169 list_add(&dev
->list
, &clockevent_devices
);
170 clockevents_do_notify(CLOCK_EVT_NOTIFY_ADD
, dev
);
175 * clockevents_register_device - register a clock event device
176 * @dev: device to register
178 void clockevents_register_device(struct clock_event_device
*dev
)
180 BUG_ON(dev
->mode
!= CLOCK_EVT_MODE_UNUSED
);
181 BUG_ON(!dev
->cpumask
);
183 spin_lock(&clockevents_lock
);
185 list_add(&dev
->list
, &clockevent_devices
);
186 clockevents_do_notify(CLOCK_EVT_NOTIFY_ADD
, dev
);
187 clockevents_notify_released();
189 spin_unlock(&clockevents_lock
);
193 * Noop handler when we shut down an event device
195 void clockevents_handle_noop(struct clock_event_device
*dev
)
200 * clockevents_exchange_device - release and request clock devices
201 * @old: device to release (can be NULL)
202 * @new: device to request (can be NULL)
204 * Called from the notifier chain. clockevents_lock is held already
206 void clockevents_exchange_device(struct clock_event_device
*old
,
207 struct clock_event_device
*new)
211 local_irq_save(flags
);
213 * Caller releases a clock event device. We queue it into the
214 * released list and do a notify add later.
217 clockevents_set_mode(old
, CLOCK_EVT_MODE_UNUSED
);
218 list_del(&old
->list
);
219 list_add(&old
->list
, &clockevents_released
);
223 BUG_ON(new->mode
!= CLOCK_EVT_MODE_UNUSED
);
224 clockevents_shutdown(new);
226 local_irq_restore(flags
);
229 #ifdef CONFIG_GENERIC_CLOCKEVENTS
231 * clockevents_notify - notification about relevant events
233 void clockevents_notify(unsigned long reason
, void *arg
)
235 struct list_head
*node
, *tmp
;
237 spin_lock(&clockevents_lock
);
238 clockevents_do_notify(reason
, arg
);
241 case CLOCK_EVT_NOTIFY_CPU_DEAD
:
243 * Unregister the clock event devices which were
244 * released from the users in the notify chain.
246 list_for_each_safe(node
, tmp
, &clockevents_released
)
252 spin_unlock(&clockevents_lock
);
254 EXPORT_SYMBOL_GPL(clockevents_notify
);
256 ktime_t
clockevents_get_next_event(int cpu
)
258 struct tick_device
*td
;
259 struct clock_event_device
*dev
;
261 td
= &per_cpu(tick_cpu_device
, cpu
);
264 return dev
->next_event
;