| /* |
| * linux/kernel/time/clocksource.c |
| * |
| * This file contains the functions which manage clocksource drivers. |
| * |
| * Copyright (C) 2004, 2005 IBM, John Stultz (johnstul@us.ibm.com) |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| * |
| * TODO WishList: |
| * o Allow clocksource drivers to be unregistered |
| * o get rid of clocksource_jiffies extern |
| */ |
| |
| #include <linux/clocksource.h> |
| #include <linux/sysdev.h> |
| #include <linux/init.h> |
| #include <linux/module.h> |
| #include <linux/sched.h> /* for spin_unlock_irq() using preempt_count() m68k */ |
| #include <linux/tick.h> |
| |
| /* XXX - Would like a better way for initializing curr_clocksource */ |
| extern struct clocksource clocksource_jiffies; |
| |
| /*[Clocksource internal variables]--------- |
| * curr_clocksource: |
| * currently selected clocksource. Initialized to clocksource_jiffies. |
| * next_clocksource: |
| * pending next selected clocksource. |
| * clocksource_list: |
| * linked list with the registered clocksources |
| * clocksource_lock: |
| * protects manipulations to curr_clocksource and next_clocksource |
| * and the clocksource_list |
| * override_name: |
| * Name of the user-specified clocksource. |
| */ |
| static struct clocksource *curr_clocksource = &clocksource_jiffies; |
| static struct clocksource *next_clocksource; |
| static struct clocksource *clocksource_override; |
| static LIST_HEAD(clocksource_list); |
| static DEFINE_SPINLOCK(clocksource_lock); |
| static char override_name[32]; |
| static int finished_booting; |
| |
| /* clocksource_done_booting - Called near the end of core bootup |
| * |
| * Hack to avoid lots of clocksource churn at boot time. |
| * We use fs_initcall because we want this to start before |
| * device_initcall but after subsys_initcall. |
| */ |
| static int __init clocksource_done_booting(void) |
| { |
| finished_booting = 1; |
| return 0; |
| } |
| fs_initcall(clocksource_done_booting); |
| |
| #ifdef CONFIG_CLOCKSOURCE_WATCHDOG |
| static LIST_HEAD(watchdog_list); |
| static struct clocksource *watchdog; |
| static struct timer_list watchdog_timer; |
| static DEFINE_SPINLOCK(watchdog_lock); |
| static cycle_t watchdog_last; |
| static int watchdog_resumed; |
| |
| /* |
| * Interval: 0.5sec Threshold: 0.0625s |
| */ |
| #define WATCHDOG_INTERVAL (HZ >> 1) |
| #define WATCHDOG_THRESHOLD (NSEC_PER_SEC >> 4) |
| |
| static void clocksource_ratewd(struct clocksource *cs, int64_t delta) |
| { |
| if (delta > -WATCHDOG_THRESHOLD && delta < WATCHDOG_THRESHOLD) |
| return; |
| |
| printk(KERN_WARNING "Clocksource %s unstable (delta = %Ld ns)\n", |
| cs->name, delta); |
| cs->flags &= ~(CLOCK_SOURCE_VALID_FOR_HRES | CLOCK_SOURCE_WATCHDOG); |
| clocksource_change_rating(cs, 0); |
| cs->flags &= ~CLOCK_SOURCE_WATCHDOG; |
| list_del(&cs->wd_list); |
| } |
| |
| static void clocksource_watchdog(unsigned long data) |
| { |
| struct clocksource *cs, *tmp; |
| cycle_t csnow, wdnow; |
| int64_t wd_nsec, cs_nsec; |
| int resumed; |
| |
| spin_lock(&watchdog_lock); |
| |
| resumed = watchdog_resumed; |
| if (unlikely(resumed)) |
| watchdog_resumed = 0; |
| |
| wdnow = watchdog->read(); |
| wd_nsec = cyc2ns(watchdog, (wdnow - watchdog_last) & watchdog->mask); |
| watchdog_last = wdnow; |
| |
| list_for_each_entry_safe(cs, tmp, &watchdog_list, wd_list) { |
| csnow = cs->read(); |
| |
| if (unlikely(resumed)) { |
| cs->wd_last = csnow; |
| continue; |
| } |
| |
| /* Initialized ? */ |
| if (!(cs->flags & CLOCK_SOURCE_WATCHDOG)) { |
| if ((cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) && |
| (watchdog->flags & CLOCK_SOURCE_IS_CONTINUOUS)) { |
| cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES; |
| /* |
| * We just marked the clocksource as |
| * highres-capable, notify the rest of the |
| * system as well so that we transition |
| * into high-res mode: |
| */ |
| tick_clock_notify(); |
| } |
| cs->flags |= CLOCK_SOURCE_WATCHDOG; |
| cs->wd_last = csnow; |
| } else { |
| cs_nsec = cyc2ns(cs, (csnow - cs->wd_last) & cs->mask); |
| cs->wd_last = csnow; |
| /* Check the delta. Might remove from the list ! */ |
| clocksource_ratewd(cs, cs_nsec - wd_nsec); |
| } |
| } |
| |
| if (!list_empty(&watchdog_list)) { |
| __mod_timer(&watchdog_timer, |
| watchdog_timer.expires + WATCHDOG_INTERVAL); |
| } |
| spin_unlock(&watchdog_lock); |
| } |
| static void clocksource_resume_watchdog(void) |
| { |
| spin_lock(&watchdog_lock); |
| watchdog_resumed = 1; |
| spin_unlock(&watchdog_lock); |
| } |
| |
| static void clocksource_check_watchdog(struct clocksource *cs) |
| { |
| struct clocksource *cse; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&watchdog_lock, flags); |
| if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) { |
| int started = !list_empty(&watchdog_list); |
| |
| list_add(&cs->wd_list, &watchdog_list); |
| if (!started && watchdog) { |
| watchdog_last = watchdog->read(); |
| watchdog_timer.expires = jiffies + WATCHDOG_INTERVAL; |
| add_timer(&watchdog_timer); |
| } |
| } else { |
| if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) |
| cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES; |
| |
| if (!watchdog || cs->rating > watchdog->rating) { |
| if (watchdog) |
| del_timer(&watchdog_timer); |
| watchdog = cs; |
| init_timer(&watchdog_timer); |
| watchdog_timer.function = clocksource_watchdog; |
| |
| /* Reset watchdog cycles */ |
| list_for_each_entry(cse, &watchdog_list, wd_list) |
| cse->flags &= ~CLOCK_SOURCE_WATCHDOG; |
| /* Start if list is not empty */ |
| if (!list_empty(&watchdog_list)) { |
| watchdog_last = watchdog->read(); |
| watchdog_timer.expires = |
| jiffies + WATCHDOG_INTERVAL; |
| add_timer(&watchdog_timer); |
| } |
| } |
| } |
| spin_unlock_irqrestore(&watchdog_lock, flags); |
| } |
| #else |
| static void clocksource_check_watchdog(struct clocksource *cs) |
| { |
| if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) |
| cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES; |
| } |
| |
| static inline void clocksource_resume_watchdog(void) { } |
| #endif |
| |
| /** |
| * clocksource_resume - resume the clocksource(s) |
| */ |
| void clocksource_resume(void) |
| { |
| struct list_head *tmp; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&clocksource_lock, flags); |
| |
| list_for_each(tmp, &clocksource_list) { |
| struct clocksource *cs; |
| |
| cs = list_entry(tmp, struct clocksource, list); |
| if (cs->resume) |
| cs->resume(); |
| } |
| |
| clocksource_resume_watchdog(); |
| |
| spin_unlock_irqrestore(&clocksource_lock, flags); |
| } |
| |
| /** |
| * clocksource_get_next - Returns the selected clocksource |
| * |
| */ |
| struct clocksource *clocksource_get_next(void) |
| { |
| unsigned long flags; |
| |
| spin_lock_irqsave(&clocksource_lock, flags); |
| if (next_clocksource && finished_booting) { |
| curr_clocksource = next_clocksource; |
| next_clocksource = NULL; |
| } |
| spin_unlock_irqrestore(&clocksource_lock, flags); |
| |
| return curr_clocksource; |
| } |
| |
| /** |
| * select_clocksource - Selects the best registered clocksource. |
| * |
| * Private function. Must hold clocksource_lock when called. |
| * |
| * Select the clocksource with the best rating, or the clocksource, |
| * which is selected by userspace override. |
| */ |
| static struct clocksource *select_clocksource(void) |
| { |
| struct clocksource *next; |
| |
| if (list_empty(&clocksource_list)) |
| return NULL; |
| |
| if (clocksource_override) |
| next = clocksource_override; |
| else |
| next = list_entry(clocksource_list.next, struct clocksource, |
| list); |
| |
| if (next == curr_clocksource) |
| return NULL; |
| |
| return next; |
| } |
| |
| /* |
| * Enqueue the clocksource sorted by rating |
| */ |
| static int clocksource_enqueue(struct clocksource *c) |
| { |
| struct list_head *tmp, *entry = &clocksource_list; |
| |
| list_for_each(tmp, &clocksource_list) { |
| struct clocksource *cs; |
| |
| cs = list_entry(tmp, struct clocksource, list); |
| if (cs == c) |
| return -EBUSY; |
| /* Keep track of the place, where to insert */ |
| if (cs->rating >= c->rating) |
| entry = tmp; |
| } |
| list_add(&c->list, entry); |
| |
| if (strlen(c->name) == strlen(override_name) && |
| !strcmp(c->name, override_name)) |
| clocksource_override = c; |
| |
| return 0; |
| } |
| |
| /** |
| * clocksource_register - Used to install new clocksources |
| * @t: clocksource to be registered |
| * |
| * Returns -EBUSY if registration fails, zero otherwise. |
| */ |
| int clocksource_register(struct clocksource *c) |
| { |
| unsigned long flags; |
| int ret; |
| |
| spin_lock_irqsave(&clocksource_lock, flags); |
| ret = clocksource_enqueue(c); |
| if (!ret) |
| next_clocksource = select_clocksource(); |
| spin_unlock_irqrestore(&clocksource_lock, flags); |
| if (!ret) |
| clocksource_check_watchdog(c); |
| return ret; |
| } |
| EXPORT_SYMBOL(clocksource_register); |
| |
| /** |
| * clocksource_change_rating - Change the rating of a registered clocksource |
| * |
| */ |
| void clocksource_change_rating(struct clocksource *cs, int rating) |
| { |
| unsigned long flags; |
| |
| spin_lock_irqsave(&clocksource_lock, flags); |
| list_del(&cs->list); |
| cs->rating = rating; |
| clocksource_enqueue(cs); |
| next_clocksource = select_clocksource(); |
| spin_unlock_irqrestore(&clocksource_lock, flags); |
| } |
| |
| #ifdef CONFIG_SYSFS |
| /** |
| * sysfs_show_current_clocksources - sysfs interface for current clocksource |
| * @dev: unused |
| * @buf: char buffer to be filled with clocksource list |
| * |
| * Provides sysfs interface for listing current clocksource. |
| */ |
| static ssize_t |
| sysfs_show_current_clocksources(struct sys_device *dev, char *buf) |
| { |
| char *curr = buf; |
| |
| spin_lock_irq(&clocksource_lock); |
| curr += sprintf(curr, "%s ", curr_clocksource->name); |
| spin_unlock_irq(&clocksource_lock); |
| |
| curr += sprintf(curr, "\n"); |
| |
| return curr - buf; |
| } |
| |
| /** |
| * sysfs_override_clocksource - interface for manually overriding clocksource |
| * @dev: unused |
| * @buf: name of override clocksource |
| * @count: length of buffer |
| * |
| * Takes input from sysfs interface for manually overriding the default |
| * clocksource selction. |
| */ |
| static ssize_t sysfs_override_clocksource(struct sys_device *dev, |
| const char *buf, size_t count) |
| { |
| struct clocksource *ovr = NULL; |
| struct list_head *tmp; |
| size_t ret = count; |
| int len; |
| |
| /* strings from sysfs write are not 0 terminated! */ |
| if (count >= sizeof(override_name)) |
| return -EINVAL; |
| |
| /* strip of \n: */ |
| if (buf[count-1] == '\n') |
| count--; |
| |
| spin_lock_irq(&clocksource_lock); |
| |
| if (count > 0) |
| memcpy(override_name, buf, count); |
| override_name[count] = 0; |
| |
| len = strlen(override_name); |
| if (len) { |
| ovr = clocksource_override; |
| /* try to select it: */ |
| list_for_each(tmp, &clocksource_list) { |
| struct clocksource *cs; |
| |
| cs = list_entry(tmp, struct clocksource, list); |
| if (strlen(cs->name) == len && |
| !strcmp(cs->name, override_name)) |
| ovr = cs; |
| } |
| } |
| |
| /* Reselect, when the override name has changed */ |
| if (ovr != clocksource_override) { |
| clocksource_override = ovr; |
| next_clocksource = select_clocksource(); |
| } |
| |
| spin_unlock_irq(&clocksource_lock); |
| |
| return ret; |
| } |
| |
| /** |
| * sysfs_show_available_clocksources - sysfs interface for listing clocksource |
| * @dev: unused |
| * @buf: char buffer to be filled with clocksource list |
| * |
| * Provides sysfs interface for listing registered clocksources |
| */ |
| static ssize_t |
| sysfs_show_available_clocksources(struct sys_device *dev, char *buf) |
| { |
| struct list_head *tmp; |
| char *curr = buf; |
| |
| spin_lock_irq(&clocksource_lock); |
| list_for_each(tmp, &clocksource_list) { |
| struct clocksource *src; |
| |
| src = list_entry(tmp, struct clocksource, list); |
| curr += sprintf(curr, "%s ", src->name); |
| } |
| spin_unlock_irq(&clocksource_lock); |
| |
| curr += sprintf(curr, "\n"); |
| |
| return curr - buf; |
| } |
| |
| /* |
| * Sysfs setup bits: |
| */ |
| static SYSDEV_ATTR(current_clocksource, 0600, sysfs_show_current_clocksources, |
| sysfs_override_clocksource); |
| |
| static SYSDEV_ATTR(available_clocksource, 0600, |
| sysfs_show_available_clocksources, NULL); |
| |
| static struct sysdev_class clocksource_sysclass = { |
| set_kset_name("clocksource"), |
| }; |
| |
| static struct sys_device device_clocksource = { |
| .id = 0, |
| .cls = &clocksource_sysclass, |
| }; |
| |
| static int __init init_clocksource_sysfs(void) |
| { |
| int error = sysdev_class_register(&clocksource_sysclass); |
| |
| if (!error) |
| error = sysdev_register(&device_clocksource); |
| if (!error) |
| error = sysdev_create_file( |
| &device_clocksource, |
| &attr_current_clocksource); |
| if (!error) |
| error = sysdev_create_file( |
| &device_clocksource, |
| &attr_available_clocksource); |
| return error; |
| } |
| |
| device_initcall(init_clocksource_sysfs); |
| #endif /* CONFIG_SYSFS */ |
| |
| /** |
| * boot_override_clocksource - boot clock override |
| * @str: override name |
| * |
| * Takes a clocksource= boot argument and uses it |
| * as the clocksource override name. |
| */ |
| static int __init boot_override_clocksource(char* str) |
| { |
| unsigned long flags; |
| spin_lock_irqsave(&clocksource_lock, flags); |
| if (str) |
| strlcpy(override_name, str, sizeof(override_name)); |
| spin_unlock_irqrestore(&clocksource_lock, flags); |
| return 1; |
| } |
| |
| __setup("clocksource=", boot_override_clocksource); |
| |
| /** |
| * boot_override_clock - Compatibility layer for deprecated boot option |
| * @str: override name |
| * |
| * DEPRECATED! Takes a clock= boot argument and uses it |
| * as the clocksource override name |
| */ |
| static int __init boot_override_clock(char* str) |
| { |
| if (!strcmp(str, "pmtmr")) { |
| printk("Warning: clock=pmtmr is deprecated. " |
| "Use clocksource=acpi_pm.\n"); |
| return boot_override_clocksource("acpi_pm"); |
| } |
| printk("Warning! clock= boot option is deprecated. " |
| "Use clocksource=xyz\n"); |
| return boot_override_clocksource(str); |
| } |
| |
| __setup("clock=", boot_override_clock); |