2 * linux/kernel/time/clocksource.c
4 * This file contains the functions which manage clocksource drivers.
6 * Copyright (C) 2004, 2005 IBM, John Stultz (johnstul@us.ibm.com)
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.
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.
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.
23 * o Allow clocksource drivers to be unregistered
24 * o get rid of clocksource_jiffies extern
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>
34 /* XXX - Would like a better way for initializing curr_clocksource */
35 extern struct clocksource clocksource_jiffies
;
37 /*[Clocksource internal variables]---------
39 * currently selected clocksource. Initialized to clocksource_jiffies.
41 * pending next selected clocksource.
43 * linked list with the registered clocksources
45 * protects manipulations to curr_clocksource and next_clocksource
46 * and the clocksource_list
48 * Name of the user-specified clocksource.
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
;
58 /* clocksource_done_booting - Called near the end of core bootup
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.
64 static int __init
clocksource_done_booting(void)
69 fs_initcall(clocksource_done_booting
);
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
;
80 * Interval: 0.5sec Threshold: 0.0625s
82 #define WATCHDOG_INTERVAL (HZ >> 1)
83 #define WATCHDOG_THRESHOLD (NSEC_PER_SEC >> 4)
85 static void clocksource_ratewd(struct clocksource
*cs
, int64_t delta
)
87 if (delta
> -WATCHDOG_THRESHOLD
&& delta
< WATCHDOG_THRESHOLD
)
90 printk(KERN_WARNING
"Clocksource %s unstable (delta = %Ld ns)\n",
92 cs
->flags
&= ~(CLOCK_SOURCE_VALID_FOR_HRES
| CLOCK_SOURCE_WATCHDOG
);
93 clocksource_change_rating(cs
, 0);
94 list_del(&cs
->wd_list
);
97 static void clocksource_watchdog(unsigned long data
)
99 struct clocksource
*cs
, *tmp
;
100 cycle_t csnow
, wdnow
;
101 int64_t wd_nsec
, cs_nsec
;
104 spin_lock(&watchdog_lock
);
106 resumed
= test_and_clear_bit(0, &watchdog_resumed
);
108 wdnow
= watchdog
->read();
109 wd_nsec
= cyc2ns(watchdog
, (wdnow
- watchdog_last
) & watchdog
->mask
);
110 watchdog_last
= wdnow
;
112 list_for_each_entry_safe(cs
, tmp
, &watchdog_list
, wd_list
) {
115 if (unlikely(resumed
)) {
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
;
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:
133 cs
->flags
|= CLOCK_SOURCE_WATCHDOG
;
136 cs_nsec
= cyc2ns(cs
, (csnow
- cs
->wd_last
) & cs
->mask
);
138 /* Check the delta. Might remove from the list ! */
139 clocksource_ratewd(cs
, cs_nsec
- wd_nsec
);
143 if (!list_empty(&watchdog_list
)) {
144 __mod_timer(&watchdog_timer
,
145 watchdog_timer
.expires
+ WATCHDOG_INTERVAL
);
147 spin_unlock(&watchdog_lock
);
149 static void clocksource_resume_watchdog(void)
151 set_bit(0, &watchdog_resumed
);
154 static void clocksource_check_watchdog(struct clocksource
*cs
)
156 struct clocksource
*cse
;
159 spin_lock_irqsave(&watchdog_lock
, flags
);
160 if (cs
->flags
& CLOCK_SOURCE_MUST_VERIFY
) {
161 int started
= !list_empty(&watchdog_list
);
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
);
170 if (cs
->flags
& CLOCK_SOURCE_IS_CONTINUOUS
)
171 cs
->flags
|= CLOCK_SOURCE_VALID_FOR_HRES
;
173 if (!watchdog
|| cs
->rating
> watchdog
->rating
) {
175 del_timer(&watchdog_timer
);
177 init_timer_deferrable(&watchdog_timer
);
178 watchdog_timer
.function
= clocksource_watchdog
;
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
);
192 spin_unlock_irqrestore(&watchdog_lock
, flags
);
195 static void clocksource_check_watchdog(struct clocksource
*cs
)
197 if (cs
->flags
& CLOCK_SOURCE_IS_CONTINUOUS
)
198 cs
->flags
|= CLOCK_SOURCE_VALID_FOR_HRES
;
201 static inline void clocksource_resume_watchdog(void) { }
205 * clocksource_resume - resume the clocksource(s)
207 void clocksource_resume(void)
209 struct clocksource
*cs
;
212 spin_lock_irqsave(&clocksource_lock
, flags
);
214 list_for_each_entry(cs
, &clocksource_list
, list
) {
219 clocksource_resume_watchdog();
221 spin_unlock_irqrestore(&clocksource_lock
, flags
);
225 * clocksource_get_next - Returns the selected clocksource
228 struct clocksource
*clocksource_get_next(void)
232 spin_lock_irqsave(&clocksource_lock
, flags
);
233 if (next_clocksource
&& finished_booting
) {
234 curr_clocksource
= next_clocksource
;
235 next_clocksource
= NULL
;
237 spin_unlock_irqrestore(&clocksource_lock
, flags
);
239 return curr_clocksource
;
243 * select_clocksource - Selects the best registered clocksource.
245 * Private function. Must hold clocksource_lock when called.
247 * Select the clocksource with the best rating, or the clocksource,
248 * which is selected by userspace override.
250 static struct clocksource
*select_clocksource(void)
252 struct clocksource
*next
;
254 if (list_empty(&clocksource_list
))
257 if (clocksource_override
)
258 next
= clocksource_override
;
260 next
= list_entry(clocksource_list
.next
, struct clocksource
,
263 if (next
== curr_clocksource
)
270 * Enqueue the clocksource sorted by rating
272 static int clocksource_enqueue(struct clocksource
*c
)
274 struct list_head
*tmp
, *entry
= &clocksource_list
;
276 list_for_each(tmp
, &clocksource_list
) {
277 struct clocksource
*cs
;
279 cs
= list_entry(tmp
, struct clocksource
, list
);
282 /* Keep track of the place, where to insert */
283 if (cs
->rating
>= c
->rating
)
286 list_add(&c
->list
, entry
);
288 if (strlen(c
->name
) == strlen(override_name
) &&
289 !strcmp(c
->name
, override_name
))
290 clocksource_override
= c
;
296 * clocksource_register - Used to install new clocksources
297 * @t: clocksource to be registered
299 * Returns -EBUSY if registration fails, zero otherwise.
301 int clocksource_register(struct clocksource
*c
)
306 spin_lock_irqsave(&clocksource_lock
, flags
);
307 ret
= clocksource_enqueue(c
);
309 next_clocksource
= select_clocksource();
310 spin_unlock_irqrestore(&clocksource_lock
, flags
);
312 clocksource_check_watchdog(c
);
315 EXPORT_SYMBOL(clocksource_register
);
318 * clocksource_change_rating - Change the rating of a registered clocksource
321 void clocksource_change_rating(struct clocksource
*cs
, int rating
)
325 spin_lock_irqsave(&clocksource_lock
, flags
);
328 clocksource_enqueue(cs
);
329 next_clocksource
= select_clocksource();
330 spin_unlock_irqrestore(&clocksource_lock
, flags
);
334 * clocksource_unregister - remove a registered clocksource
336 void clocksource_unregister(struct clocksource
*cs
)
340 spin_lock_irqsave(&clocksource_lock
, flags
);
342 if (clocksource_override
== cs
)
343 clocksource_override
= NULL
;
344 next_clocksource
= select_clocksource();
345 spin_unlock_irqrestore(&clocksource_lock
, flags
);
350 * sysfs_show_current_clocksources - sysfs interface for current clocksource
352 * @buf: char buffer to be filled with clocksource list
354 * Provides sysfs interface for listing current clocksource.
357 sysfs_show_current_clocksources(struct sys_device
*dev
, char *buf
)
361 spin_lock_irq(&clocksource_lock
);
362 count
= snprintf(buf
, PAGE_SIZE
, "%s\n", curr_clocksource
->name
);
363 spin_unlock_irq(&clocksource_lock
);
369 * sysfs_override_clocksource - interface for manually overriding clocksource
371 * @buf: name of override clocksource
372 * @count: length of buffer
374 * Takes input from sysfs interface for manually overriding the default
375 * clocksource selction.
377 static ssize_t
sysfs_override_clocksource(struct sys_device
*dev
,
378 const char *buf
, size_t count
)
380 struct clocksource
*ovr
= NULL
;
384 /* strings from sysfs write are not 0 terminated! */
385 if (count
>= sizeof(override_name
))
389 if (buf
[count
-1] == '\n')
392 spin_lock_irq(&clocksource_lock
);
395 memcpy(override_name
, buf
, count
);
396 override_name
[count
] = 0;
398 len
= strlen(override_name
);
400 struct clocksource
*cs
;
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
))
411 /* Reselect, when the override name has changed */
412 if (ovr
!= clocksource_override
) {
413 clocksource_override
= ovr
;
414 next_clocksource
= select_clocksource();
417 spin_unlock_irq(&clocksource_lock
);
423 * sysfs_show_available_clocksources - sysfs interface for listing clocksource
425 * @buf: char buffer to be filled with clocksource list
427 * Provides sysfs interface for listing registered clocksources
430 sysfs_show_available_clocksources(struct sys_device
*dev
, char *buf
)
432 struct clocksource
*src
;
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),
441 spin_unlock_irq(&clocksource_lock
);
443 count
+= snprintf(buf
+ count
,
444 max((ssize_t
)PAGE_SIZE
- count
, (ssize_t
)0), "\n");
452 static SYSDEV_ATTR(current_clocksource
, 0600, sysfs_show_current_clocksources
,
453 sysfs_override_clocksource
);
455 static SYSDEV_ATTR(available_clocksource
, 0600,
456 sysfs_show_available_clocksources
, NULL
);
458 static struct sysdev_class clocksource_sysclass
= {
459 .name
= "clocksource",
462 static struct sys_device device_clocksource
= {
464 .cls
= &clocksource_sysclass
,
467 static int __init
init_clocksource_sysfs(void)
469 int error
= sysdev_class_register(&clocksource_sysclass
);
472 error
= sysdev_register(&device_clocksource
);
474 error
= sysdev_create_file(
476 &attr_current_clocksource
);
478 error
= sysdev_create_file(
480 &attr_available_clocksource
);
484 device_initcall(init_clocksource_sysfs
);
485 #endif /* CONFIG_SYSFS */
488 * boot_override_clocksource - boot clock override
489 * @str: override name
491 * Takes a clocksource= boot argument and uses it
492 * as the clocksource override name.
494 static int __init
boot_override_clocksource(char* str
)
497 spin_lock_irqsave(&clocksource_lock
, flags
);
499 strlcpy(override_name
, str
, sizeof(override_name
));
500 spin_unlock_irqrestore(&clocksource_lock
, flags
);
504 __setup("clocksource=", boot_override_clocksource
);
507 * boot_override_clock - Compatibility layer for deprecated boot option
508 * @str: override name
510 * DEPRECATED! Takes a clock= boot argument and uses it
511 * as the clocksource override name
513 static int __init
boot_override_clock(char* str
)
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");
520 printk("Warning! clock= boot option is deprecated. "
521 "Use clocksource=xyz\n");
522 return boot_override_clocksource(str
);
525 __setup("clock=", boot_override_clock
);