xref: /openbmc/linux/kernel/time/clocksource.c (revision a1e58bbd) 
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>
31 #include <linux/sched.h> /* for spin_unlock_irq() using preempt_count() m68k */
32 #include <linux/tick.h>
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;
52 static struct clocksource *clocksource_override;
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 core bootup
59  *
60  * Hack to avoid lots of clocksource churn at boot time.
61  * We use fs_initcall because we want this to start before
62  * device_initcall but after subsys_initcall.
63  */
64 static int __init clocksource_done_booting(void)
65 {
66 	finished_booting = 1;
67 	return 0;
68 }
69 fs_initcall(clocksource_done_booting);
70 
71 #ifdef CONFIG_CLOCKSOURCE_WATCHDOG
72 static LIST_HEAD(watchdog_list);
73 static struct clocksource *watchdog;
74 static struct timer_list watchdog_timer;
75 static DEFINE_SPINLOCK(watchdog_lock);
76 static cycle_t watchdog_last;
77 static unsigned long watchdog_resumed;
78 
79 /*
80  * Interval: 0.5sec Threshold: 0.0625s
81  */
82 #define WATCHDOG_INTERVAL (HZ >> 1)
83 #define WATCHDOG_THRESHOLD (NSEC_PER_SEC >> 4)
84 
85 static void clocksource_ratewd(struct clocksource *cs, int64_t delta)
86 {
87 	if (delta > -WATCHDOG_THRESHOLD && delta < WATCHDOG_THRESHOLD)
88 		return;
89 
90 	printk(KERN_WARNING "Clocksource %s unstable (delta = %Ld ns)\n",
91 	       cs->name, delta);
92 	cs->flags &= ~(CLOCK_SOURCE_VALID_FOR_HRES | CLOCK_SOURCE_WATCHDOG);
93 	clocksource_change_rating(cs, 0);
94 	list_del(&cs->wd_list);
95 }
96 
97 static void clocksource_watchdog(unsigned long data)
98 {
99 	struct clocksource *cs, *tmp;
100 	cycle_t csnow, wdnow;
101 	int64_t wd_nsec, cs_nsec;
102 	int resumed;
103 
104 	spin_lock(&watchdog_lock);
105 
106 	resumed = test_and_clear_bit(0, &watchdog_resumed);
107 
108 	wdnow = watchdog->read();
109 	wd_nsec = cyc2ns(watchdog, (wdnow - watchdog_last) & watchdog->mask);
110 	watchdog_last = wdnow;
111 
112 	list_for_each_entry_safe(cs, tmp, &watchdog_list, wd_list) {
113 		csnow = cs->read();
114 
115 		if (unlikely(resumed)) {
116 			cs->wd_last = csnow;
117 			continue;
118 		}
119 
120 		/* Initialized ? */
121 		if (!(cs->flags & CLOCK_SOURCE_WATCHDOG)) {
122 			if ((cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) &&
123 			    (watchdog->flags & CLOCK_SOURCE_IS_CONTINUOUS)) {
124 				cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
125 				/*
126 				 * We just marked the clocksource as
127 				 * highres-capable, notify the rest of the
128 				 * system as well so that we transition
129 				 * into high-res mode:
130 				 */
131 				tick_clock_notify();
132 			}
133 			cs->flags |= CLOCK_SOURCE_WATCHDOG;
134 			cs->wd_last = csnow;
135 		} else {
136 			cs_nsec = cyc2ns(cs, (csnow - cs->wd_last) & cs->mask);
137 			cs->wd_last = csnow;
138 			/* Check the delta. Might remove from the list ! */
139 			clocksource_ratewd(cs, cs_nsec - wd_nsec);
140 		}
141 	}
142 
143 	if (!list_empty(&watchdog_list)) {
144 		__mod_timer(&watchdog_timer,
145 			    watchdog_timer.expires + WATCHDOG_INTERVAL);
146 	}
147 	spin_unlock(&watchdog_lock);
148 }
149 static void clocksource_resume_watchdog(void)
150 {
151 	set_bit(0, &watchdog_resumed);
152 }
153 
154 static void clocksource_check_watchdog(struct clocksource *cs)
155 {
156 	struct clocksource *cse;
157 	unsigned long flags;
158 
159 	spin_lock_irqsave(&watchdog_lock, flags);
160 	if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) {
161 		int started = !list_empty(&watchdog_list);
162 
163 		list_add(&cs->wd_list, &watchdog_list);
164 		if (!started && watchdog) {
165 			watchdog_last = watchdog->read();
166 			watchdog_timer.expires = jiffies + WATCHDOG_INTERVAL;
167 			add_timer(&watchdog_timer);
168 		}
169 	} else {
170 		if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
171 			cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
172 
173 		if (!watchdog || cs->rating > watchdog->rating) {
174 			if (watchdog)
175 				del_timer(&watchdog_timer);
176 			watchdog = cs;
177 			init_timer(&watchdog_timer);
178 			watchdog_timer.function = clocksource_watchdog;
179 
180 			/* Reset watchdog cycles */
181 			list_for_each_entry(cse, &watchdog_list, wd_list)
182 				cse->flags &= ~CLOCK_SOURCE_WATCHDOG;
183 			/* Start if list is not empty */
184 			if (!list_empty(&watchdog_list)) {
185 				watchdog_last = watchdog->read();
186 				watchdog_timer.expires =
187 					jiffies + WATCHDOG_INTERVAL;
188 				add_timer(&watchdog_timer);
189 			}
190 		}
191 	}
192 	spin_unlock_irqrestore(&watchdog_lock, flags);
193 }
194 #else
195 static void clocksource_check_watchdog(struct clocksource *cs)
196 {
197 	if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
198 		cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
199 }
200 
201 static inline void clocksource_resume_watchdog(void) { }
202 #endif
203 
204 /**
205  * clocksource_resume - resume the clocksource(s)
206  */
207 void clocksource_resume(void)
208 {
209 	struct clocksource *cs;
210 	unsigned long flags;
211 
212 	spin_lock_irqsave(&clocksource_lock, flags);
213 
214 	list_for_each_entry(cs, &clocksource_list, list) {
215 		if (cs->resume)
216 			cs->resume();
217 	}
218 
219 	clocksource_resume_watchdog();
220 
221 	spin_unlock_irqrestore(&clocksource_lock, flags);
222 }
223 
224 /**
225  * clocksource_get_next - Returns the selected clocksource
226  *
227  */
228 struct clocksource *clocksource_get_next(void)
229 {
230 	unsigned long flags;
231 
232 	spin_lock_irqsave(&clocksource_lock, flags);
233 	if (next_clocksource && finished_booting) {
234 		curr_clocksource = next_clocksource;
235 		next_clocksource = NULL;
236 	}
237 	spin_unlock_irqrestore(&clocksource_lock, flags);
238 
239 	return curr_clocksource;
240 }
241 
242 /**
243  * select_clocksource - Selects the best registered clocksource.
244  *
245  * Private function. Must hold clocksource_lock when called.
246  *
247  * Select the clocksource with the best rating, or the clocksource,
248  * which is selected by userspace override.
249  */
250 static struct clocksource *select_clocksource(void)
251 {
252 	struct clocksource *next;
253 
254 	if (list_empty(&clocksource_list))
255 		return NULL;
256 
257 	if (clocksource_override)
258 		next = clocksource_override;
259 	else
260 		next = list_entry(clocksource_list.next, struct clocksource,
261 				  list);
262 
263 	if (next == curr_clocksource)
264 		return NULL;
265 
266 	return next;
267 }
268 
269 /*
270  * Enqueue the clocksource sorted by rating
271  */
272 static int clocksource_enqueue(struct clocksource *c)
273 {
274 	struct list_head *tmp, *entry = &clocksource_list;
275 
276 	list_for_each(tmp, &clocksource_list) {
277 		struct clocksource *cs;
278 
279 		cs = list_entry(tmp, struct clocksource, list);
280 		if (cs == c)
281 			return -EBUSY;
282 		/* Keep track of the place, where to insert */
283 		if (cs->rating >= c->rating)
284 			entry = tmp;
285 	}
286 	list_add(&c->list, entry);
287 
288 	if (strlen(c->name) == strlen(override_name) &&
289 	    !strcmp(c->name, override_name))
290 		clocksource_override = c;
291 
292 	return 0;
293 }
294 
295 /**
296  * clocksource_register - Used to install new clocksources
297  * @t:		clocksource to be registered
298  *
299  * Returns -EBUSY if registration fails, zero otherwise.
300  */
301 int clocksource_register(struct clocksource *c)
302 {
303 	unsigned long flags;
304 	int ret;
305 
306 	spin_lock_irqsave(&clocksource_lock, flags);
307 	ret = clocksource_enqueue(c);
308 	if (!ret)
309 		next_clocksource = select_clocksource();
310 	spin_unlock_irqrestore(&clocksource_lock, flags);
311 	if (!ret)
312 		clocksource_check_watchdog(c);
313 	return ret;
314 }
315 EXPORT_SYMBOL(clocksource_register);
316 
317 /**
318  * clocksource_change_rating - Change the rating of a registered clocksource
319  *
320  */
321 void clocksource_change_rating(struct clocksource *cs, int rating)
322 {
323 	unsigned long flags;
324 
325 	spin_lock_irqsave(&clocksource_lock, flags);
326 	list_del(&cs->list);
327 	cs->rating = rating;
328 	clocksource_enqueue(cs);
329 	next_clocksource = select_clocksource();
330 	spin_unlock_irqrestore(&clocksource_lock, flags);
331 }
332 
333 /**
334  * clocksource_unregister - remove a registered clocksource
335  */
336 void clocksource_unregister(struct clocksource *cs)
337 {
338 	unsigned long flags;
339 
340 	spin_lock_irqsave(&clocksource_lock, flags);
341 	list_del(&cs->list);
342 	if (clocksource_override == cs)
343 		clocksource_override = NULL;
344 	next_clocksource = select_clocksource();
345 	spin_unlock_irqrestore(&clocksource_lock, flags);
346 }
347 
348 #ifdef CONFIG_SYSFS
349 /**
350  * sysfs_show_current_clocksources - sysfs interface for current clocksource
351  * @dev:	unused
352  * @buf:	char buffer to be filled with clocksource list
353  *
354  * Provides sysfs interface for listing current clocksource.
355  */
356 static ssize_t
357 sysfs_show_current_clocksources(struct sys_device *dev, char *buf)
358 {
359 	ssize_t count = 0;
360 
361 	spin_lock_irq(&clocksource_lock);
362 	count = snprintf(buf, PAGE_SIZE, "%s\n", curr_clocksource->name);
363 	spin_unlock_irq(&clocksource_lock);
364 
365 	return count;
366 }
367 
368 /**
369  * sysfs_override_clocksource - interface for manually overriding clocksource
370  * @dev:	unused
371  * @buf:	name of override clocksource
372  * @count:	length of buffer
373  *
374  * Takes input from sysfs interface for manually overriding the default
375  * clocksource selction.
376  */
377 static ssize_t sysfs_override_clocksource(struct sys_device *dev,
378 					  const char *buf, size_t count)
379 {
380 	struct clocksource *ovr = NULL;
381 	size_t ret = count;
382 	int len;
383 
384 	/* strings from sysfs write are not 0 terminated! */
385 	if (count >= sizeof(override_name))
386 		return -EINVAL;
387 
388 	/* strip of \n: */
389 	if (buf[count-1] == '\n')
390 		count--;
391 
392 	spin_lock_irq(&clocksource_lock);
393 
394 	if (count > 0)
395 		memcpy(override_name, buf, count);
396 	override_name[count] = 0;
397 
398 	len = strlen(override_name);
399 	if (len) {
400 		struct clocksource *cs;
401 
402 		ovr = clocksource_override;
403 		/* try to select it: */
404 		list_for_each_entry(cs, &clocksource_list, list) {
405 			if (strlen(cs->name) == len &&
406 			    !strcmp(cs->name, override_name))
407 				ovr = cs;
408 		}
409 	}
410 
411 	/* Reselect, when the override name has changed */
412 	if (ovr != clocksource_override) {
413 		clocksource_override = ovr;
414 		next_clocksource = select_clocksource();
415 	}
416 
417 	spin_unlock_irq(&clocksource_lock);
418 
419 	return ret;
420 }
421 
422 /**
423  * sysfs_show_available_clocksources - sysfs interface for listing clocksource
424  * @dev:	unused
425  * @buf:	char buffer to be filled with clocksource list
426  *
427  * Provides sysfs interface for listing registered clocksources
428  */
429 static ssize_t
430 sysfs_show_available_clocksources(struct sys_device *dev, char *buf)
431 {
432 	struct clocksource *src;
433 	ssize_t count = 0;
434 
435 	spin_lock_irq(&clocksource_lock);
436 	list_for_each_entry(src, &clocksource_list, list) {
437 		count += snprintf(buf + count,
438 				  max((ssize_t)PAGE_SIZE - count, (ssize_t)0),
439 				  "%s ", src->name);
440 	}
441 	spin_unlock_irq(&clocksource_lock);
442 
443 	count += snprintf(buf + count,
444 			  max((ssize_t)PAGE_SIZE - count, (ssize_t)0), "\n");
445 
446 	return count;
447 }
448 
449 /*
450  * Sysfs setup bits:
451  */
452 static SYSDEV_ATTR(current_clocksource, 0600, sysfs_show_current_clocksources,
453 		   sysfs_override_clocksource);
454 
455 static SYSDEV_ATTR(available_clocksource, 0600,
456 		   sysfs_show_available_clocksources, NULL);
457 
458 static struct sysdev_class clocksource_sysclass = {
459 	.name = "clocksource",
460 };
461 
462 static struct sys_device device_clocksource = {
463 	.id	= 0,
464 	.cls	= &clocksource_sysclass,
465 };
466 
467 static int __init init_clocksource_sysfs(void)
468 {
469 	int error = sysdev_class_register(&clocksource_sysclass);
470 
471 	if (!error)
472 		error = sysdev_register(&device_clocksource);
473 	if (!error)
474 		error = sysdev_create_file(
475 				&device_clocksource,
476 				&attr_current_clocksource);
477 	if (!error)
478 		error = sysdev_create_file(
479 				&device_clocksource,
480 				&attr_available_clocksource);
481 	return error;
482 }
483 
484 device_initcall(init_clocksource_sysfs);
485 #endif /* CONFIG_SYSFS */
486 
487 /**
488  * boot_override_clocksource - boot clock override
489  * @str:	override name
490  *
491  * Takes a clocksource= boot argument and uses it
492  * as the clocksource override name.
493  */
494 static int __init boot_override_clocksource(char* str)
495 {
496 	unsigned long flags;
497 	spin_lock_irqsave(&clocksource_lock, flags);
498 	if (str)
499 		strlcpy(override_name, str, sizeof(override_name));
500 	spin_unlock_irqrestore(&clocksource_lock, flags);
501 	return 1;
502 }
503 
504 __setup("clocksource=", boot_override_clocksource);
505 
506 /**
507  * boot_override_clock - Compatibility layer for deprecated boot option
508  * @str:	override name
509  *
510  * DEPRECATED! Takes a clock= boot argument and uses it
511  * as the clocksource override name
512  */
513 static int __init boot_override_clock(char* str)
514 {
515 	if (!strcmp(str, "pmtmr")) {
516 		printk("Warning: clock=pmtmr is deprecated. "
517 			"Use clocksource=acpi_pm.\n");
518 		return boot_override_clocksource("acpi_pm");
519 	}
520 	printk("Warning! clock= boot option is deprecated. "
521 		"Use clocksource=xyz\n");
522 	return boot_override_clocksource(str);
523 }
524 
525 __setup("clock=", boot_override_clock);
526