[PATCH] clockevents: add core functionality

Architectures register their clock event devices, in the clock events core.
Users of the clockevents core can get clock event devices for their use.  The
clockevents core code provides notification mechanisms for various clock
related management events.

This allows to control the clock event devices without the architectures
having to worry about the details of function assignment.  This is also a
preliminary for high resolution timers and dynamic ticks to allow the core
code to control the clock functionality without intrusive changes to the
architecture code.

[Fixes-by: Ingo Molnar <mingo@elte.hu>]
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Cc: Roman Zippel <zippel@linux-m68k.org>
Cc: john stultz <johnstul@us.ibm.com>
Cc: Andi Kleen <ak@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

2 files changed, 347 insertions, 0 deletions

diff --git a/kernel/time/Makefile b/kernel/time/Makefile
index 61a3907d16fb..2bf1805914d0 100644
--- a/kernel/time/Makefile
+++ b/kernel/time/Makefile
@@ -1 +1,3 @@
 obj-y += ntp.o clocksource.o jiffies.o
+
+obj-$(CONFIG_GENERIC_CLOCKEVENTS) += clockevents.o
diff --git a/kernel/time/clockevents.c b/kernel/time/clockevents.c
new file mode 100644
index 000000000000..67932ea78c17
--- /dev/null
+++ b/kernel/time/clockevents.c
@@ -0,0 +1,345 @@
+/*
+ * linux/kernel/time/clockevents.c
+ *
+ * This file contains functions which manage clock event devices.
+ *
+ * Copyright(C) 2005-2006, Thomas Gleixner <tglx@linutronix.de>
+ * Copyright(C) 2005-2007, Red Hat, Inc., Ingo Molnar
+ * Copyright(C) 2006-2007, Timesys Corp., Thomas Gleixner
+ *
+ * This code is licenced under the GPL version 2. For details see
+ * kernel-base/COPYING.
+ */
+
+#include <linux/clockchips.h>
+#include <linux/hrtimer.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/notifier.h>
+#include <linux/smp.h>
+#include <linux/sysdev.h>
+
+/* The registered clock event devices */
+static LIST_HEAD(clockevent_devices);
+static LIST_HEAD(clockevents_released);
+
+/* Notification for clock events */
+static RAW_NOTIFIER_HEAD(clockevents_chain);
+
+/* Protection for the above */
+static DEFINE_SPINLOCK(clockevents_lock);
+
+/**
+ * clockevents_delta2ns - Convert a latch value (device ticks) to nanoseconds
+ * @latch:      value to convert
+ * @evt:        pointer to clock event device descriptor
+ *
+ * Math helper, returns latch value converted to nanoseconds (bound checked)
+ */
+unsigned long clockevent_delta2ns(unsigned long latch,
+                                  struct clock_event_device *evt)
+{
+        u64 clc = ((u64) latch << evt->shift);
+
+        do_div(clc, evt->mult);
+        if (clc < 1000)
+                clc = 1000;
+        if (clc > LONG_MAX)
+                clc = LONG_MAX;
+
+        return (unsigned long) clc;
+}
+
+/**
+ * clockevents_set_mode - set the operating mode of a clock event device
+ * @dev:        device to modify
+ * @mode:       new mode
+ *
+ * Must be called with interrupts disabled !
+ */
+void clockevents_set_mode(struct clock_event_device *dev,
+                                 enum clock_event_mode mode)
+{
+        if (dev->mode != mode) {
+                dev->set_mode(mode, dev);
+                dev->mode = mode;
+        }
+}
+
+/**
+ * clockevents_program_event - Reprogram the clock event device.
+ * @expires:    absolute expiry time (monotonic clock)
+ *
+ * Returns 0 on success, -ETIME when the event is in the past.
+ */
+int clockevents_program_event(struct clock_event_device *dev, ktime_t expires,
+                              ktime_t now)
+{
+        unsigned long long clc;
+        int64_t delta;
+
+        delta = ktime_to_ns(ktime_sub(expires, now));
+
+        if (delta <= 0)
+                return -ETIME;
+
+        dev->next_event = expires;
+
+        if (dev->mode == CLOCK_EVT_MODE_SHUTDOWN)
+                return 0;
+
+        if (delta > dev->max_delta_ns)
+                delta = dev->max_delta_ns;
+        if (delta < dev->min_delta_ns)
+                delta = dev->min_delta_ns;
+
+        clc = delta * dev->mult;
+        clc >>= dev->shift;
+
+        return dev->set_next_event((unsigned long) clc, dev);
+}
+
+/**
+ * clockevents_register_notifier - register a clock events change listener
+ */
+int clockevents_register_notifier(struct notifier_block *nb)
+{
+        int ret;
+
+        spin_lock(&clockevents_lock);
+        ret = raw_notifier_chain_register(&clockevents_chain, nb);
+        spin_unlock(&clockevents_lock);
+
+        return ret;
+}
+
+/**
+ * clockevents_unregister_notifier - unregister a clock events change listener
+ */
+void clockevents_unregister_notifier(struct notifier_block *nb)
+{
+        spin_lock(&clockevents_lock);
+        raw_notifier_chain_unregister(&clockevents_chain, nb);
+        spin_unlock(&clockevents_lock);
+}
+
+/*
+ * Notify about a clock event change. Called with clockevents_lock
+ * held.
+ */
+static void clockevents_do_notify(unsigned long reason, void *dev)
+{
+        raw_notifier_call_chain(&clockevents_chain, reason, dev);
+}
+
+/*
+ * Called after a notify add to make devices availble which were
+ * released from the notifier call.
+ */
+static void clockevents_notify_released(void)
+{
+        struct clock_event_device *dev;
+
+        while (!list_empty(&clockevents_released)) {
+                dev = list_entry(clockevents_released.next,
+                                 struct clock_event_device, list);
+                list_del(&dev->list);
+                list_add(&dev->list, &clockevent_devices);
+                clockevents_do_notify(CLOCK_EVT_NOTIFY_ADD, dev);
+        }
+}
+
+/**
+ * clockevents_register_device - register a clock event device
+ * @dev:        device to register
+ */
+void clockevents_register_device(struct clock_event_device *dev)
+{
+        BUG_ON(dev->mode != CLOCK_EVT_MODE_UNUSED);
+
+        spin_lock(&clockevents_lock);
+
+        list_add(&dev->list, &clockevent_devices);
+        clockevents_do_notify(CLOCK_EVT_NOTIFY_ADD, dev);
+        clockevents_notify_released();
+
+        spin_unlock(&clockevents_lock);
+}
+
+/*
+ * Noop handler when we shut down an event device
+ */
+static void clockevents_handle_noop(struct clock_event_device *dev)
+{
+}
+
+/**
+ * clockevents_exchange_device - release and request clock devices
+ * @old:        device to release (can be NULL)
+ * @new:        device to request (can be NULL)
+ *
+ * Called from the notifier chain. clockevents_lock is held already
+ */
+void clockevents_exchange_device(struct clock_event_device *old,
+                                 struct clock_event_device *new)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        /*
+         * Caller releases a clock event device. We queue it into the
+         * released list and do a notify add later.
+         */
+        if (old) {
+                old->event_handler = clockevents_handle_noop;
+                clockevents_set_mode(old, CLOCK_EVT_MODE_UNUSED);
+                list_del(&old->list);
+                list_add(&old->list, &clockevents_released);
+        }
+
+        if (new) {
+                BUG_ON(new->mode != CLOCK_EVT_MODE_UNUSED);
+                clockevents_set_mode(new, CLOCK_EVT_MODE_SHUTDOWN);
+        }
+        local_irq_restore(flags);
+}
+
+/**
+ * clockevents_request_device
+ */
+struct clock_event_device *clockevents_request_device(unsigned int features,
+                                                      cpumask_t cpumask)
+{
+        struct clock_event_device *cur, *dev = NULL;
+        struct list_head *tmp;
+
+        spin_lock(&clockevents_lock);
+
+        list_for_each(tmp, &clockevent_devices) {
+                cur = list_entry(tmp, struct clock_event_device, list);
+
+                if ((cur->features & features) == features &&
+                    cpus_equal(cpumask, cur->cpumask)) {
+                        if (!dev || dev->rating < cur->rating)
+                                dev = cur;
+                }
+        }
+
+        clockevents_exchange_device(NULL, dev);
+
+        spin_unlock(&clockevents_lock);
+
+        return dev;
+}
+
+/**
+ * clockevents_release_device
+ */
+void clockevents_release_device(struct clock_event_device *dev)
+{
+        spin_lock(&clockevents_lock);
+
+        clockevents_exchange_device(dev, NULL);
+        clockevents_notify_released();
+
+        spin_unlock(&clockevents_lock);
+}
+
+/**
+ * clockevents_notify - notification about relevant events
+ */
+void clockevents_notify(unsigned long reason, void *arg)
+{
+        spin_lock(&clockevents_lock);
+        clockevents_do_notify(reason, arg);
+
+        switch (reason) {
+        case CLOCK_EVT_NOTIFY_CPU_DEAD:
+                /*
+                 * Unregister the clock event devices which were
+                 * released from the users in the notify chain.
+                 */
+                while (!list_empty(&clockevents_released)) {
+                        struct clock_event_device *dev;
+
+                        dev = list_entry(clockevents_released.next,
+                                         struct clock_event_device, list);
+                        list_del(&dev->list);
+                }
+                break;
+        default:
+                break;
+        }
+        spin_unlock(&clockevents_lock);
+}
+EXPORT_SYMBOL_GPL(clockevents_notify);
+
+#ifdef CONFIG_SYSFS
+
+/**
+ * clockevents_show_registered - sysfs interface for listing clockevents
+ * @dev:        unused
+ * @buf:        char buffer to be filled with clock events list
+ *
+ * Provides sysfs interface for listing registered clock event devices
+ */
+static ssize_t clockevents_show_registered(struct sys_device *dev, char *buf)
+{
+        struct list_head *tmp;
+        char *p = buf;
+        int cpu;
+
+        spin_lock(&clockevents_lock);
+
+        list_for_each(tmp, &clockevent_devices) {
+                struct clock_event_device *ce;
+
+                ce = list_entry(tmp, struct clock_event_device, list);
+                p += sprintf(p, "%-20s F:%04x M:%d", ce->name,
+                             ce->features, ce->mode);
+                p += sprintf(p, " C:");
+                if (!cpus_equal(ce->cpumask, cpu_possible_map)) {
+                        for_each_cpu_mask(cpu, ce->cpumask)
+                                p += sprintf(p, " %d", cpu);
+                } else {
+                        /*
+                         * FIXME: Add the cpu which is handling this sucker
+                         */
+                }
+                p += sprintf(p, "\n");
+        }
+
+        spin_unlock(&clockevents_lock);
+
+        return p - buf;
+}
+
+/*
+ * Sysfs setup bits:
+ */
+static SYSDEV_ATTR(registered, 0600,
+                   clockevents_show_registered, NULL);
+
+static struct sysdev_class clockevents_sysclass = {
+        set_kset_name("clockevents"),
+};
+
+static struct sys_device clockevents_sys_device = {
+        .id     = 0,
+        .cls    = &clockevents_sysclass,
+};
+
+static int __init clockevents_sysfs_init(void)
+{
+        int error = sysdev_class_register(&clockevents_sysclass);
+
+        if (!error)
+                error = sysdev_register(&clockevents_sys_device);
+        if (!error)
+                error = sysdev_create_file(
+                                &clockevents_sys_device,
+                                &attr_registered);
+        return error;
+}
+device_initcall(clockevents_sysfs_init);
+#endif