[mirror_ubuntu-artful-kernel.git] / kernel / time / clocksource.c

/*
 * 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 bootup
 *
 * Hack to avoid lots of clocksource churn at boot time
 */
static int __init clocksource_done_booting(void)
{
	finished_booting = 1;
	return 0;
}
late_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;
/*
 * Interval: 0.5sec Treshold: 0.0625s
 */
#define WATCHDOG_INTERVAL (HZ >> 1)
#define WATCHDOG_TRESHOLD (NSEC_PER_SEC >> 4)

static void clocksource_ratewd(struct clocksource *cs, int64_t delta)
{
	if (delta > -WATCHDOG_TRESHOLD && delta < WATCHDOG_TRESHOLD)
		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;

	spin_lock(&watchdog_lock);

	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();
		/* 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_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;
}
#endif

/**
 * 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);
Commit	Line	Data
734efb46 JS	1	/*
	2	* linux/kernel/time/clocksource.c
	3	*
	4	* This file contains the functions which manage clocksource drivers.
	5	*
	6	* Copyright (C) 2004, 2005 IBM, John Stultz (johnstul@us.ibm.com)
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	21	*
	22	* TODO WishList:
	23	* o Allow clocksource drivers to be unregistered
	24	* o get rid of clocksource_jiffies extern
	25	*/
	26
	27	#include <linux/clocksource.h>
	28	#include <linux/sysdev.h>
	29	#include <linux/init.h>
	30	#include <linux/module.h>
dc29a365	31	#include <linux/sched.h> /* for spin_unlock_irq() using preempt_count() m68k */
79bf2bb3	32	#include <linux/tick.h>
734efb46 JS	33
	34	/* XXX - Would like a better way for initializing curr_clocksource */
	35	extern struct clocksource clocksource_jiffies;
	36
	37	/*[Clocksource internal variables]---------
	38	* curr_clocksource:
	39	* currently selected clocksource. Initialized to clocksource_jiffies.
	40	* next_clocksource:
	41	* pending next selected clocksource.
	42	* clocksource_list:
	43	* linked list with the registered clocksources
	44	* clocksource_lock:
	45	* protects manipulations to curr_clocksource and next_clocksource
	46	* and the clocksource_list
	47	* override_name:
	48	* Name of the user-specified clocksource.
	49	*/
	50	static struct clocksource *curr_clocksource = &clocksource_jiffies;
	51	static struct clocksource *next_clocksource;
92c7e002	52	static struct clocksource *clocksource_override;
734efb46 JS	53	static LIST_HEAD(clocksource_list);
	54	static DEFINE_SPINLOCK(clocksource_lock);
	55	static char override_name[32];
	56	static int finished_booting;
	57
	58	/* clocksource_done_booting - Called near the end of bootup
	59	*
	60	* Hack to avoid lots of clocksource churn at boot time
	61	*/
ad596171	62	static int __init clocksource_done_booting(void)
734efb46 JS	63	{
	64	finished_booting = 1;
	65	return 0;
	66	}
734efb46 JS	67	late_initcall(clocksource_done_booting);
734efb46 JS	68
5d8b34fd TG	69	#ifdef CONFIG_CLOCKSOURCE_WATCHDOG
	70	static LIST_HEAD(watchdog_list);
	71	static struct clocksource *watchdog;
	72	static struct timer_list watchdog_timer;
	73	static DEFINE_SPINLOCK(watchdog_lock);
	74	static cycle_t watchdog_last;
	75	/*
	76	* Interval: 0.5sec Treshold: 0.0625s
	77	*/
	78	#define WATCHDOG_INTERVAL (HZ >> 1)
	79	#define WATCHDOG_TRESHOLD (NSEC_PER_SEC >> 4)
	80
	81	static void clocksource_ratewd(struct clocksource *cs, int64_t delta)
	82	{
	83	if (delta > -WATCHDOG_TRESHOLD && delta < WATCHDOG_TRESHOLD)
	84	return;
	85
	86	printk(KERN_WARNING "Clocksource %s unstable (delta = %Ld ns)\n",
	87	cs->name, delta);
	88	cs->flags &= ~(CLOCK_SOURCE_VALID_FOR_HRES \| CLOCK_SOURCE_WATCHDOG);
	89	clocksource_change_rating(cs, 0);
	90	cs->flags &= ~CLOCK_SOURCE_WATCHDOG;
	91	list_del(&cs->wd_list);
	92	}
	93
	94	static void clocksource_watchdog(unsigned long data)
	95	{
	96	struct clocksource cs, tmp;
	97	cycle_t csnow, wdnow;
	98	int64_t wd_nsec, cs_nsec;
	99
	100	spin_lock(&watchdog_lock);
	101
	102	wdnow = watchdog->read();
	103	wd_nsec = cyc2ns(watchdog, (wdnow - watchdog_last) & watchdog->mask);
	104	watchdog_last = wdnow;
	105
	106	list_for_each_entry_safe(cs, tmp, &watchdog_list, wd_list) {
	107	csnow = cs->read();
	108	/* Initialized ? */
	109	if (!(cs->flags & CLOCK_SOURCE_WATCHDOG)) {
	110	if ((cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) &&
	111	(watchdog->flags & CLOCK_SOURCE_IS_CONTINUOUS)) {
	112	cs->flags \|= CLOCK_SOURCE_VALID_FOR_HRES;
79bf2bb3 TG	113	/*
	114	* We just marked the clocksource as
	115	* highres-capable, notify the rest of the
	116	* system as well so that we transition
	117	* into high-res mode:
	118	*/
	119	tick_clock_notify();
5d8b34fd TG	120	}
	121	cs->flags \|= CLOCK_SOURCE_WATCHDOG;
	122	cs->wd_last = csnow;
	123	} else {
	124	cs_nsec = cyc2ns(cs, (csnow - cs->wd_last) & cs->mask);
	125	cs->wd_last = csnow;
	126	/* Check the delta. Might remove from the list ! */
	127	clocksource_ratewd(cs, cs_nsec - wd_nsec);
	128	}
	129	}
	130
	131	if (!list_empty(&watchdog_list)) {
	132	__mod_timer(&watchdog_timer,
	133	watchdog_timer.expires + WATCHDOG_INTERVAL);
	134	}
	135	spin_unlock(&watchdog_lock);
	136	}
	137	static void clocksource_check_watchdog(struct clocksource *cs)
	138	{
	139	struct clocksource *cse;
	140	unsigned long flags;
	141
	142	spin_lock_irqsave(&watchdog_lock, flags);
	143	if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) {
	144	int started = !list_empty(&watchdog_list);
	145
	146	list_add(&cs->wd_list, &watchdog_list);
	147	if (!started && watchdog) {
	148	watchdog_last = watchdog->read();
	149	watchdog_timer.expires = jiffies + WATCHDOG_INTERVAL;
	150	add_timer(&watchdog_timer);
	151	}
	152	} else if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) {
	153	cs->flags \|= CLOCK_SOURCE_VALID_FOR_HRES;
	154
	155	if (!watchdog \|\| cs->rating > watchdog->rating) {
	156	if (watchdog)
	157	del_timer(&watchdog_timer);
	158	watchdog = cs;
	159	init_timer(&watchdog_timer);
	160	watchdog_timer.function = clocksource_watchdog;
	161
	162	/* Reset watchdog cycles */
	163	list_for_each_entry(cse, &watchdog_list, wd_list)
	164	cse->flags &= ~CLOCK_SOURCE_WATCHDOG;
	165	/* Start if list is not empty */
	166	if (!list_empty(&watchdog_list)) {
	167	watchdog_last = watchdog->read();
	168	watchdog_timer.expires =
	169	jiffies + WATCHDOG_INTERVAL;
	170	add_timer(&watchdog_timer);
	171	}
	172	}
	173	}
	174	spin_unlock_irqrestore(&watchdog_lock, flags);
	175	}
	176	#else
	177	static void clocksource_check_watchdog(struct clocksource *cs)
	178	{
	179	if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
	180	cs->flags \|= CLOCK_SOURCE_VALID_FOR_HRES;
	181	}
	182	#endif
	183
734efb46	184	/**
a2752549	185	* clocksource_get_next - Returns the selected clocksource
734efb46 JS	186	*
734efb46 JS	187	*/
a2752549	188	struct clocksource *clocksource_get_next(void)
734efb46 JS	189	{
	190	unsigned long flags;
	191
	192	spin_lock_irqsave(&clocksource_lock, flags);
	193	if (next_clocksource && finished_booting) {
	194	curr_clocksource = next_clocksource;
	195	next_clocksource = NULL;
	196	}
	197	spin_unlock_irqrestore(&clocksource_lock, flags);
	198
	199	return curr_clocksource;
	200	}
	201
	202	/**
92c7e002	203	* select_clocksource - Selects the best registered clocksource.
734efb46 JS	204	*
	205	* Private function. Must hold clocksource_lock when called.
	206	*
92c7e002 TG	207	* Select the clocksource with the best rating, or the clocksource,
92c7e002 TG	208	* which is selected by userspace override.
734efb46 JS	209	*/
	210	static struct clocksource *select_clocksource(void)
	211	{
5d8b34fd TG	212	struct clocksource *next;
5d8b34fd TG	213
92c7e002 TG	214	if (list_empty(&clocksource_list))
92c7e002 TG	215	return NULL;
734efb46	216
92c7e002	217	if (clocksource_override)
5d8b34fd TG	218	next = clocksource_override;
	219	else
	220	next = list_entry(clocksource_list.next, struct clocksource,
	221	list);
734efb46	222
5d8b34fd TG	223	if (next == curr_clocksource)
	224	return NULL;
	225
	226	return next;
734efb46 JS	227	}
734efb46 JS	228
92c7e002 TG	229	/*
92c7e002 TG	230	* Enqueue the clocksource sorted by rating
734efb46	231	*/
92c7e002	232	static int clocksource_enqueue(struct clocksource *c)
734efb46	233	{
92c7e002	234	struct list_head tmp, entry = &clocksource_list;
734efb46 JS	235
734efb46 JS	236	list_for_each(tmp, &clocksource_list) {
92c7e002 TG	237	struct clocksource *cs;
	238
	239	cs = list_entry(tmp, struct clocksource, list);
	240	if (cs == c)
	241	return -EBUSY;
	242	/* Keep track of the place, where to insert */
	243	if (cs->rating >= c->rating)
	244	entry = tmp;
734efb46	245	}
92c7e002 TG	246	list_add(&c->list, entry);
	247
	248	if (strlen(c->name) == strlen(override_name) &&
	249	!strcmp(c->name, override_name))
	250	clocksource_override = c;
734efb46 JS	251
	252	return 0;
	253	}
	254
	255	/**
a2752549	256	* clocksource_register - Used to install new clocksources
734efb46 JS	257	* @t: clocksource to be registered
	258	*
	259	* Returns -EBUSY if registration fails, zero otherwise.
	260	*/
a2752549	261	int clocksource_register(struct clocksource *c)
734efb46	262	{
734efb46	263	unsigned long flags;
5d8b34fd	264	int ret;
734efb46 JS	265
734efb46 JS	266	spin_lock_irqsave(&clocksource_lock, flags);
92c7e002 TG	267	ret = clocksource_enqueue(c);
92c7e002 TG	268	if (!ret)
734efb46	269	next_clocksource = select_clocksource();
734efb46	270	spin_unlock_irqrestore(&clocksource_lock, flags);
5d8b34fd TG	271	if (!ret)
5d8b34fd TG	272	clocksource_check_watchdog(c);
734efb46 JS	273	return ret;
734efb46 JS	274	}
a2752549	275	EXPORT_SYMBOL(clocksource_register);
734efb46 JS	276
734efb46 JS	277	/**
92c7e002	278	* clocksource_change_rating - Change the rating of a registered clocksource
734efb46	279	*
734efb46	280	*/
92c7e002	281	void clocksource_change_rating(struct clocksource *cs, int rating)
734efb46 JS	282	{
	283	unsigned long flags;
	284
	285	spin_lock_irqsave(&clocksource_lock, flags);
92c7e002	286	list_del(&cs->list);
5d8b34fd	287	cs->rating = rating;
92c7e002	288	clocksource_enqueue(cs);
734efb46 JS	289	next_clocksource = select_clocksource();
	290	spin_unlock_irqrestore(&clocksource_lock, flags);
	291	}
	292
2b013700	293	#ifdef CONFIG_SYSFS
734efb46 JS	294	/**
	295	* sysfs_show_current_clocksources - sysfs interface for current clocksource
	296	* @dev: unused
	297	* @buf: char buffer to be filled with clocksource list
	298	*
	299	* Provides sysfs interface for listing current clocksource.
	300	*/
	301	static ssize_t
	302	sysfs_show_current_clocksources(struct sys_device dev, char buf)
	303	{
	304	char *curr = buf;
	305
	306	spin_lock_irq(&clocksource_lock);
	307	curr += sprintf(curr, "%s ", curr_clocksource->name);
	308	spin_unlock_irq(&clocksource_lock);
	309
	310	curr += sprintf(curr, "\n");
	311
	312	return curr - buf;
	313	}
	314
	315	/**
	316	* sysfs_override_clocksource - interface for manually overriding clocksource
	317	* @dev: unused
	318	* @buf: name of override clocksource
	319	* @count: length of buffer
	320	*
	321	* Takes input from sysfs interface for manually overriding the default
	322	* clocksource selction.
	323	*/
	324	static ssize_t sysfs_override_clocksource(struct sys_device *dev,
	325	const char *buf, size_t count)
	326	{
92c7e002 TG	327	struct clocksource *ovr = NULL;
92c7e002 TG	328	struct list_head *tmp;
734efb46	329	size_t ret = count;
92c7e002 TG	330	int len;
92c7e002 TG	331
734efb46 JS	332	/* strings from sysfs write are not 0 terminated! */
	333	if (count >= sizeof(override_name))
	334	return -EINVAL;
	335
	336	/* strip of \n: */
	337	if (buf[count-1] == '\n')
	338	count--;
734efb46 JS	339
	340	spin_lock_irq(&clocksource_lock);
	341
92c7e002 TG	342	if (count > 0)
92c7e002 TG	343	memcpy(override_name, buf, count);
734efb46 JS	344	override_name[count] = 0;
734efb46 JS	345
92c7e002 TG	346	len = strlen(override_name);
	347	if (len) {
	348	ovr = clocksource_override;
	349	/* try to select it: */
	350	list_for_each(tmp, &clocksource_list) {
	351	struct clocksource *cs;
	352
	353	cs = list_entry(tmp, struct clocksource, list);
	354	if (strlen(cs->name) == len &&
	355	!strcmp(cs->name, override_name))
	356	ovr = cs;
	357	}
	358	}
	359
	360	/* Reselect, when the override name has changed */
	361	if (ovr != clocksource_override) {
	362	clocksource_override = ovr;
	363	next_clocksource = select_clocksource();
	364	}
734efb46 JS	365
	366	spin_unlock_irq(&clocksource_lock);
	367
	368	return ret;
	369	}
	370
	371	/**
	372	* sysfs_show_available_clocksources - sysfs interface for listing clocksource
	373	* @dev: unused
	374	* @buf: char buffer to be filled with clocksource list
	375	*
	376	* Provides sysfs interface for listing registered clocksources
	377	*/
	378	static ssize_t
	379	sysfs_show_available_clocksources(struct sys_device dev, char buf)
	380	{
	381	struct list_head *tmp;
	382	char *curr = buf;
	383
	384	spin_lock_irq(&clocksource_lock);
	385	list_for_each(tmp, &clocksource_list) {
	386	struct clocksource *src;
	387
	388	src = list_entry(tmp, struct clocksource, list);
	389	curr += sprintf(curr, "%s ", src->name);
	390	}
	391	spin_unlock_irq(&clocksource_lock);
	392
	393	curr += sprintf(curr, "\n");
	394
	395	return curr - buf;
	396	}
	397
	398	/*
	399	* Sysfs setup bits:
	400	*/
	401	static SYSDEV_ATTR(current_clocksource, 0600, sysfs_show_current_clocksources,
f5f1a24a	402	sysfs_override_clocksource);
734efb46 JS	403
734efb46 JS	404	static SYSDEV_ATTR(available_clocksource, 0600,
f5f1a24a	405	sysfs_show_available_clocksources, NULL);
734efb46 JS	406
	407	static struct sysdev_class clocksource_sysclass = {
	408	set_kset_name("clocksource"),
	409	};
	410
	411	static struct sys_device device_clocksource = {
	412	.id = 0,
	413	.cls = &clocksource_sysclass,
	414	};
	415
ad596171	416	static int __init init_clocksource_sysfs(void)
734efb46 JS	417	{
	418	int error = sysdev_class_register(&clocksource_sysclass);
	419
	420	if (!error)
	421	error = sysdev_register(&device_clocksource);
	422	if (!error)
	423	error = sysdev_create_file(
	424	&device_clocksource,
	425	&attr_current_clocksource);
	426	if (!error)
	427	error = sysdev_create_file(
	428	&device_clocksource,
	429	&attr_available_clocksource);
	430	return error;
	431	}
	432
	433	device_initcall(init_clocksource_sysfs);
2b013700	434	#endif /* CONFIG_SYSFS */
734efb46 JS	435
	436	/**
	437	* boot_override_clocksource - boot clock override
	438	* @str: override name
	439	*
	440	* Takes a clocksource= boot argument and uses it
	441	* as the clocksource override name.
	442	*/
	443	static int __init boot_override_clocksource(char* str)
	444	{
	445	unsigned long flags;
	446	spin_lock_irqsave(&clocksource_lock, flags);
	447	if (str)
	448	strlcpy(override_name, str, sizeof(override_name));
	449	spin_unlock_irqrestore(&clocksource_lock, flags);
	450	return 1;
	451	}
	452
	453	__setup("clocksource=", boot_override_clocksource);
	454
	455	/**
	456	* boot_override_clock - Compatibility layer for deprecated boot option
	457	* @str: override name
	458	*
	459	* DEPRECATED! Takes a clock= boot argument and uses it
	460	* as the clocksource override name
	461	*/
	462	static int __init boot_override_clock(char* str)
	463	{
5d0cf410 JS	464	if (!strcmp(str, "pmtmr")) {
	465	printk("Warning: clock=pmtmr is deprecated. "
	466	"Use clocksource=acpi_pm.\n");
	467	return boot_override_clocksource("acpi_pm");
	468	}
	469	printk("Warning! clock= boot option is deprecated. "
	470	"Use clocksource=xyz\n");
734efb46 JS	471	return boot_override_clocksource(str);
	472	}
	473
	474	__setup("clock=", boot_override_clock);