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/smp.h>
19 #include <linux/device.h>
21 #include "tick-internal.h"
23 /* The registered clock event devices */
24 static LIST_HEAD(clockevent_devices
);
25 static LIST_HEAD(clockevents_released
);
26 /* Protection for the above */
27 static DEFINE_RAW_SPINLOCK(clockevents_lock
);
28 /* Protection for unbind operations */
29 static DEFINE_MUTEX(clockevents_mutex
);
32 struct clock_event_device
*ce
;
36 static u64
cev_delta2ns(unsigned long latch
, struct clock_event_device
*evt
,
39 u64 clc
= (u64
) latch
<< evt
->shift
;
42 if (unlikely(!evt
->mult
)) {
46 rnd
= (u64
) evt
->mult
- 1;
49 * Upper bound sanity check. If the backwards conversion is
50 * not equal latch, we know that the above shift overflowed.
52 if ((clc
>> evt
->shift
) != (u64
)latch
)
56 * Scaled math oddities:
58 * For mult <= (1 << shift) we can safely add mult - 1 to
59 * prevent integer rounding loss. So the backwards conversion
60 * from nsec to device ticks will be correct.
62 * For mult > (1 << shift), i.e. device frequency is > 1GHz we
63 * need to be careful. Adding mult - 1 will result in a value
64 * which when converted back to device ticks can be larger
65 * than latch by up to (mult - 1) >> shift. For the min_delta
66 * calculation we still want to apply this in order to stay
67 * above the minimum device ticks limit. For the upper limit
68 * we would end up with a latch value larger than the upper
69 * limit of the device, so we omit the add to stay below the
70 * device upper boundary.
72 * Also omit the add if it would overflow the u64 boundary.
74 if ((~0ULL - clc
> rnd
) &&
75 (!ismax
|| evt
->mult
<= (1ULL << evt
->shift
)))
78 do_div(clc
, evt
->mult
);
80 /* Deltas less than 1usec are pointless noise */
81 return clc
> 1000 ? clc
: 1000;
85 * clockevents_delta2ns - Convert a latch value (device ticks) to nanoseconds
86 * @latch: value to convert
87 * @evt: pointer to clock event device descriptor
89 * Math helper, returns latch value converted to nanoseconds (bound checked)
91 u64
clockevent_delta2ns(unsigned long latch
, struct clock_event_device
*evt
)
93 return cev_delta2ns(latch
, evt
, false);
95 EXPORT_SYMBOL_GPL(clockevent_delta2ns
);
97 static int __clockevents_set_state(struct clock_event_device
*dev
,
98 enum clock_event_state state
)
100 /* Transition with legacy set_mode() callback */
102 /* Legacy callback doesn't support new modes */
103 if (state
> CLOCK_EVT_STATE_ONESHOT
)
106 * 'clock_event_state' and 'clock_event_mode' have 1-to-1
107 * mapping until *_ONESHOT, and so a simple cast will work.
109 dev
->set_mode((enum clock_event_mode
)state
, dev
);
110 dev
->mode
= (enum clock_event_mode
)state
;
114 if (dev
->features
& CLOCK_EVT_FEAT_DUMMY
)
117 /* Transition with new state-specific callbacks */
119 case CLOCK_EVT_STATE_DETACHED
:
121 * This is an internal state, which is guaranteed to go from
122 * SHUTDOWN to DETACHED. No driver interaction required.
126 case CLOCK_EVT_STATE_SHUTDOWN
:
127 return dev
->set_state_shutdown(dev
);
129 case CLOCK_EVT_STATE_PERIODIC
:
130 /* Core internal bug */
131 if (!(dev
->features
& CLOCK_EVT_FEAT_PERIODIC
))
133 return dev
->set_state_periodic(dev
);
135 case CLOCK_EVT_STATE_ONESHOT
:
136 /* Core internal bug */
137 if (!(dev
->features
& CLOCK_EVT_FEAT_ONESHOT
))
139 return dev
->set_state_oneshot(dev
);
147 * clockevents_set_state - set the operating state of a clock event device
148 * @dev: device to modify
151 * Must be called with interrupts disabled !
153 void clockevents_set_state(struct clock_event_device
*dev
,
154 enum clock_event_state state
)
156 if (dev
->state
!= state
) {
157 if (__clockevents_set_state(dev
, state
))
163 * A nsec2cyc multiplicator of 0 is invalid and we'd crash
164 * on it, so fix it up and emit a warning:
166 if (state
== CLOCK_EVT_STATE_ONESHOT
) {
167 if (unlikely(!dev
->mult
)) {
176 * clockevents_shutdown - shutdown the device and clear next_event
177 * @dev: device to shutdown
179 void clockevents_shutdown(struct clock_event_device
*dev
)
181 clockevents_set_state(dev
, CLOCK_EVT_STATE_SHUTDOWN
);
182 dev
->next_event
.tv64
= KTIME_MAX
;
186 * clockevents_tick_resume - Resume the tick device before using it again
187 * @dev: device to resume
189 int clockevents_tick_resume(struct clock_event_device
*dev
)
194 dev
->set_mode(CLOCK_EVT_MODE_RESUME
, dev
);
195 dev
->mode
= CLOCK_EVT_MODE_RESUME
;
196 } else if (dev
->tick_resume
) {
197 ret
= dev
->tick_resume(dev
);
203 #ifdef CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST
205 /* Limit min_delta to a jiffie */
206 #define MIN_DELTA_LIMIT (NSEC_PER_SEC / HZ)
209 * clockevents_increase_min_delta - raise minimum delta of a clock event device
210 * @dev: device to increase the minimum delta
212 * Returns 0 on success, -ETIME when the minimum delta reached the limit.
214 static int clockevents_increase_min_delta(struct clock_event_device
*dev
)
216 /* Nothing to do if we already reached the limit */
217 if (dev
->min_delta_ns
>= MIN_DELTA_LIMIT
) {
218 printk_deferred(KERN_WARNING
219 "CE: Reprogramming failure. Giving up\n");
220 dev
->next_event
.tv64
= KTIME_MAX
;
224 if (dev
->min_delta_ns
< 5000)
225 dev
->min_delta_ns
= 5000;
227 dev
->min_delta_ns
+= dev
->min_delta_ns
>> 1;
229 if (dev
->min_delta_ns
> MIN_DELTA_LIMIT
)
230 dev
->min_delta_ns
= MIN_DELTA_LIMIT
;
232 printk_deferred(KERN_WARNING
233 "CE: %s increased min_delta_ns to %llu nsec\n",
234 dev
->name
? dev
->name
: "?",
235 (unsigned long long) dev
->min_delta_ns
);
240 * clockevents_program_min_delta - Set clock event device to the minimum delay.
241 * @dev: device to program
243 * Returns 0 on success, -ETIME when the retry loop failed.
245 static int clockevents_program_min_delta(struct clock_event_device
*dev
)
247 unsigned long long clc
;
252 delta
= dev
->min_delta_ns
;
253 dev
->next_event
= ktime_add_ns(ktime_get(), delta
);
255 if (dev
->state
== CLOCK_EVT_STATE_SHUTDOWN
)
259 clc
= ((unsigned long long) delta
* dev
->mult
) >> dev
->shift
;
260 if (dev
->set_next_event((unsigned long) clc
, dev
) == 0)
265 * We tried 3 times to program the device with the
266 * given min_delta_ns. Try to increase the minimum
267 * delta, if that fails as well get out of here.
269 if (clockevents_increase_min_delta(dev
))
276 #else /* CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST */
279 * clockevents_program_min_delta - Set clock event device to the minimum delay.
280 * @dev: device to program
282 * Returns 0 on success, -ETIME when the retry loop failed.
284 static int clockevents_program_min_delta(struct clock_event_device
*dev
)
286 unsigned long long clc
;
289 delta
= dev
->min_delta_ns
;
290 dev
->next_event
= ktime_add_ns(ktime_get(), delta
);
292 if (dev
->state
== CLOCK_EVT_STATE_SHUTDOWN
)
296 clc
= ((unsigned long long) delta
* dev
->mult
) >> dev
->shift
;
297 return dev
->set_next_event((unsigned long) clc
, dev
);
300 #endif /* CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST */
303 * clockevents_program_event - Reprogram the clock event device.
304 * @dev: device to program
305 * @expires: absolute expiry time (monotonic clock)
306 * @force: program minimum delay if expires can not be set
308 * Returns 0 on success, -ETIME when the event is in the past.
310 int clockevents_program_event(struct clock_event_device
*dev
, ktime_t expires
,
313 unsigned long long clc
;
317 if (unlikely(expires
.tv64
< 0)) {
322 dev
->next_event
= expires
;
324 if (dev
->state
== CLOCK_EVT_STATE_SHUTDOWN
)
327 /* Shortcut for clockevent devices that can deal with ktime. */
328 if (dev
->features
& CLOCK_EVT_FEAT_KTIME
)
329 return dev
->set_next_ktime(expires
, dev
);
331 delta
= ktime_to_ns(ktime_sub(expires
, ktime_get()));
333 return force
? clockevents_program_min_delta(dev
) : -ETIME
;
335 delta
= min(delta
, (int64_t) dev
->max_delta_ns
);
336 delta
= max(delta
, (int64_t) dev
->min_delta_ns
);
338 clc
= ((unsigned long long) delta
* dev
->mult
) >> dev
->shift
;
339 rc
= dev
->set_next_event((unsigned long) clc
, dev
);
341 return (rc
&& force
) ? clockevents_program_min_delta(dev
) : rc
;
345 * Called after a notify add to make devices available which were
346 * released from the notifier call.
348 static void clockevents_notify_released(void)
350 struct clock_event_device
*dev
;
352 while (!list_empty(&clockevents_released
)) {
353 dev
= list_entry(clockevents_released
.next
,
354 struct clock_event_device
, list
);
355 list_del(&dev
->list
);
356 list_add(&dev
->list
, &clockevent_devices
);
357 tick_check_new_device(dev
);
362 * Try to install a replacement clock event device
364 static int clockevents_replace(struct clock_event_device
*ced
)
366 struct clock_event_device
*dev
, *newdev
= NULL
;
368 list_for_each_entry(dev
, &clockevent_devices
, list
) {
369 if (dev
== ced
|| dev
->state
!= CLOCK_EVT_STATE_DETACHED
)
372 if (!tick_check_replacement(newdev
, dev
))
375 if (!try_module_get(dev
->owner
))
379 module_put(newdev
->owner
);
383 tick_install_replacement(newdev
);
384 list_del_init(&ced
->list
);
386 return newdev
? 0 : -EBUSY
;
390 * Called with clockevents_mutex and clockevents_lock held
392 static int __clockevents_try_unbind(struct clock_event_device
*ced
, int cpu
)
394 /* Fast track. Device is unused */
395 if (ced
->state
== CLOCK_EVT_STATE_DETACHED
) {
396 list_del_init(&ced
->list
);
400 return ced
== per_cpu(tick_cpu_device
, cpu
).evtdev
? -EAGAIN
: -EBUSY
;
404 * SMP function call to unbind a device
406 static void __clockevents_unbind(void *arg
)
408 struct ce_unbind
*cu
= arg
;
411 raw_spin_lock(&clockevents_lock
);
412 res
= __clockevents_try_unbind(cu
->ce
, smp_processor_id());
414 res
= clockevents_replace(cu
->ce
);
416 raw_spin_unlock(&clockevents_lock
);
420 * Issues smp function call to unbind a per cpu device. Called with
421 * clockevents_mutex held.
423 static int clockevents_unbind(struct clock_event_device
*ced
, int cpu
)
425 struct ce_unbind cu
= { .ce
= ced
, .res
= -ENODEV
};
427 smp_call_function_single(cpu
, __clockevents_unbind
, &cu
, 1);
432 * Unbind a clockevents device.
434 int clockevents_unbind_device(struct clock_event_device
*ced
, int cpu
)
438 mutex_lock(&clockevents_mutex
);
439 ret
= clockevents_unbind(ced
, cpu
);
440 mutex_unlock(&clockevents_mutex
);
443 EXPORT_SYMBOL_GPL(clockevents_unbind
);
445 /* Sanity check of state transition callbacks */
446 static int clockevents_sanity_check(struct clock_event_device
*dev
)
448 /* Legacy set_mode() callback */
450 /* We shouldn't be supporting new modes now */
451 WARN_ON(dev
->set_state_periodic
|| dev
->set_state_oneshot
||
452 dev
->set_state_shutdown
|| dev
->tick_resume
);
454 BUG_ON(dev
->mode
!= CLOCK_EVT_MODE_UNUSED
);
458 if (dev
->features
& CLOCK_EVT_FEAT_DUMMY
)
461 /* New state-specific callbacks */
462 if (!dev
->set_state_shutdown
)
465 if ((dev
->features
& CLOCK_EVT_FEAT_PERIODIC
) &&
466 !dev
->set_state_periodic
)
469 if ((dev
->features
& CLOCK_EVT_FEAT_ONESHOT
) &&
470 !dev
->set_state_oneshot
)
477 * clockevents_register_device - register a clock event device
478 * @dev: device to register
480 void clockevents_register_device(struct clock_event_device
*dev
)
484 BUG_ON(clockevents_sanity_check(dev
));
486 /* Initialize state to DETACHED */
487 dev
->state
= CLOCK_EVT_STATE_DETACHED
;
490 WARN_ON(num_possible_cpus() > 1);
491 dev
->cpumask
= cpumask_of(smp_processor_id());
494 raw_spin_lock_irqsave(&clockevents_lock
, flags
);
496 list_add(&dev
->list
, &clockevent_devices
);
497 tick_check_new_device(dev
);
498 clockevents_notify_released();
500 raw_spin_unlock_irqrestore(&clockevents_lock
, flags
);
502 EXPORT_SYMBOL_GPL(clockevents_register_device
);
504 void clockevents_config(struct clock_event_device
*dev
, u32 freq
)
508 if (!(dev
->features
& CLOCK_EVT_FEAT_ONESHOT
))
512 * Calculate the maximum number of seconds we can sleep. Limit
513 * to 10 minutes for hardware which can program more than
514 * 32bit ticks so we still get reasonable conversion values.
516 sec
= dev
->max_delta_ticks
;
520 else if (sec
> 600 && dev
->max_delta_ticks
> UINT_MAX
)
523 clockevents_calc_mult_shift(dev
, freq
, sec
);
524 dev
->min_delta_ns
= cev_delta2ns(dev
->min_delta_ticks
, dev
, false);
525 dev
->max_delta_ns
= cev_delta2ns(dev
->max_delta_ticks
, dev
, true);
529 * clockevents_config_and_register - Configure and register a clock event device
530 * @dev: device to register
531 * @freq: The clock frequency
532 * @min_delta: The minimum clock ticks to program in oneshot mode
533 * @max_delta: The maximum clock ticks to program in oneshot mode
535 * min/max_delta can be 0 for devices which do not support oneshot mode.
537 void clockevents_config_and_register(struct clock_event_device
*dev
,
538 u32 freq
, unsigned long min_delta
,
539 unsigned long max_delta
)
541 dev
->min_delta_ticks
= min_delta
;
542 dev
->max_delta_ticks
= max_delta
;
543 clockevents_config(dev
, freq
);
544 clockevents_register_device(dev
);
546 EXPORT_SYMBOL_GPL(clockevents_config_and_register
);
548 int __clockevents_update_freq(struct clock_event_device
*dev
, u32 freq
)
550 clockevents_config(dev
, freq
);
552 if (dev
->state
== CLOCK_EVT_STATE_ONESHOT
)
553 return clockevents_program_event(dev
, dev
->next_event
, false);
555 if (dev
->state
== CLOCK_EVT_STATE_PERIODIC
)
556 return __clockevents_set_state(dev
, CLOCK_EVT_STATE_PERIODIC
);
562 * clockevents_update_freq - Update frequency and reprogram a clock event device.
563 * @dev: device to modify
564 * @freq: new device frequency
566 * Reconfigure and reprogram a clock event device in oneshot
567 * mode. Must be called on the cpu for which the device delivers per
568 * cpu timer events. If called for the broadcast device the core takes
569 * care of serialization.
571 * Returns 0 on success, -ETIME when the event is in the past.
573 int clockevents_update_freq(struct clock_event_device
*dev
, u32 freq
)
578 local_irq_save(flags
);
579 ret
= tick_broadcast_update_freq(dev
, freq
);
581 ret
= __clockevents_update_freq(dev
, freq
);
582 local_irq_restore(flags
);
587 * Noop handler when we shut down an event device
589 void clockevents_handle_noop(struct clock_event_device
*dev
)
594 * clockevents_exchange_device - release and request clock devices
595 * @old: device to release (can be NULL)
596 * @new: device to request (can be NULL)
598 * Called from various tick functions with clockevents_lock held and
599 * interrupts disabled.
601 void clockevents_exchange_device(struct clock_event_device
*old
,
602 struct clock_event_device
*new)
605 * Caller releases a clock event device. We queue it into the
606 * released list and do a notify add later.
609 module_put(old
->owner
);
610 clockevents_set_state(old
, CLOCK_EVT_STATE_DETACHED
);
611 list_del(&old
->list
);
612 list_add(&old
->list
, &clockevents_released
);
616 BUG_ON(new->state
!= CLOCK_EVT_STATE_DETACHED
);
617 clockevents_shutdown(new);
622 * clockevents_suspend - suspend clock devices
624 void clockevents_suspend(void)
626 struct clock_event_device
*dev
;
628 list_for_each_entry_reverse(dev
, &clockevent_devices
, list
)
634 * clockevents_resume - resume clock devices
636 void clockevents_resume(void)
638 struct clock_event_device
*dev
;
640 list_for_each_entry(dev
, &clockevent_devices
, list
)
646 * clockevents_notify - notification about relevant events
647 * Returns 0 on success, any other value on error
649 int clockevents_notify(unsigned long reason
, void *arg
)
651 struct clock_event_device
*dev
, *tmp
;
655 raw_spin_lock_irqsave(&clockevents_lock
, flags
);
658 case CLOCK_EVT_NOTIFY_BROADCAST_ON
:
659 case CLOCK_EVT_NOTIFY_BROADCAST_OFF
:
660 case CLOCK_EVT_NOTIFY_BROADCAST_FORCE
:
661 tick_broadcast_on_off(reason
, arg
);
664 case CLOCK_EVT_NOTIFY_BROADCAST_ENTER
:
665 case CLOCK_EVT_NOTIFY_BROADCAST_EXIT
:
666 ret
= tick_broadcast_oneshot_control(reason
);
669 case CLOCK_EVT_NOTIFY_CPU_DYING
:
670 tick_handover_do_timer(arg
);
673 case CLOCK_EVT_NOTIFY_CPU_DEAD
:
674 tick_shutdown_broadcast_oneshot(arg
);
675 tick_shutdown_broadcast(arg
);
678 * Unregister the clock event devices which were
679 * released from the users in the notify chain.
681 list_for_each_entry_safe(dev
, tmp
, &clockevents_released
, list
)
682 list_del(&dev
->list
);
684 * Now check whether the CPU has left unused per cpu devices
687 list_for_each_entry_safe(dev
, tmp
, &clockevent_devices
, list
) {
688 if (cpumask_test_cpu(cpu
, dev
->cpumask
) &&
689 cpumask_weight(dev
->cpumask
) == 1 &&
690 !tick_is_broadcast_device(dev
)) {
691 BUG_ON(dev
->state
!= CLOCK_EVT_STATE_DETACHED
);
692 list_del(&dev
->list
);
699 raw_spin_unlock_irqrestore(&clockevents_lock
, flags
);
702 EXPORT_SYMBOL_GPL(clockevents_notify
);
705 struct bus_type clockevents_subsys
= {
706 .name
= "clockevents",
707 .dev_name
= "clockevent",
710 static DEFINE_PER_CPU(struct device
, tick_percpu_dev
);
711 static struct tick_device
*tick_get_tick_dev(struct device
*dev
);
713 static ssize_t
sysfs_show_current_tick_dev(struct device
*dev
,
714 struct device_attribute
*attr
,
717 struct tick_device
*td
;
720 raw_spin_lock_irq(&clockevents_lock
);
721 td
= tick_get_tick_dev(dev
);
722 if (td
&& td
->evtdev
)
723 count
= snprintf(buf
, PAGE_SIZE
, "%s\n", td
->evtdev
->name
);
724 raw_spin_unlock_irq(&clockevents_lock
);
727 static DEVICE_ATTR(current_device
, 0444, sysfs_show_current_tick_dev
, NULL
);
729 /* We don't support the abomination of removable broadcast devices */
730 static ssize_t
sysfs_unbind_tick_dev(struct device
*dev
,
731 struct device_attribute
*attr
,
732 const char *buf
, size_t count
)
734 char name
[CS_NAME_LEN
];
735 ssize_t ret
= sysfs_get_uname(buf
, name
, count
);
736 struct clock_event_device
*ce
;
742 mutex_lock(&clockevents_mutex
);
743 raw_spin_lock_irq(&clockevents_lock
);
744 list_for_each_entry(ce
, &clockevent_devices
, list
) {
745 if (!strcmp(ce
->name
, name
)) {
746 ret
= __clockevents_try_unbind(ce
, dev
->id
);
750 raw_spin_unlock_irq(&clockevents_lock
);
752 * We hold clockevents_mutex, so ce can't go away
755 ret
= clockevents_unbind(ce
, dev
->id
);
756 mutex_unlock(&clockevents_mutex
);
757 return ret
? ret
: count
;
759 static DEVICE_ATTR(unbind_device
, 0200, NULL
, sysfs_unbind_tick_dev
);
761 #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
762 static struct device tick_bc_dev
= {
763 .init_name
= "broadcast",
765 .bus
= &clockevents_subsys
,
768 static struct tick_device
*tick_get_tick_dev(struct device
*dev
)
770 return dev
== &tick_bc_dev
? tick_get_broadcast_device() :
771 &per_cpu(tick_cpu_device
, dev
->id
);
774 static __init
int tick_broadcast_init_sysfs(void)
776 int err
= device_register(&tick_bc_dev
);
779 err
= device_create_file(&tick_bc_dev
, &dev_attr_current_device
);
783 static struct tick_device
*tick_get_tick_dev(struct device
*dev
)
785 return &per_cpu(tick_cpu_device
, dev
->id
);
787 static inline int tick_broadcast_init_sysfs(void) { return 0; }
790 static int __init
tick_init_sysfs(void)
794 for_each_possible_cpu(cpu
) {
795 struct device
*dev
= &per_cpu(tick_percpu_dev
, cpu
);
799 dev
->bus
= &clockevents_subsys
;
800 err
= device_register(dev
);
802 err
= device_create_file(dev
, &dev_attr_current_device
);
804 err
= device_create_file(dev
, &dev_attr_unbind_device
);
808 return tick_broadcast_init_sysfs();
811 static int __init
clockevents_init_sysfs(void)
813 int err
= subsys_system_register(&clockevents_subsys
, NULL
);
816 err
= tick_init_sysfs();
819 device_initcall(clockevents_init_sysfs
);