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
)) {
145 * Cycle through CPUs to check if the CPUs stay
146 * synchronized to each other.
148 int next_cpu
= next_cpu(raw_smp_processor_id(), cpu_online_map
);
150 if (next_cpu
>= NR_CPUS
)
151 next_cpu
= first_cpu(cpu_online_map
);
152 watchdog_timer
.expires
+= WATCHDOG_INTERVAL
;
153 add_timer_on(&watchdog_timer
, next_cpu
);
155 spin_unlock(&watchdog_lock
);
157 static void clocksource_resume_watchdog(void)
159 set_bit(0, &watchdog_resumed
);
162 static void clocksource_check_watchdog(struct clocksource
*cs
)
164 struct clocksource
*cse
;
167 spin_lock_irqsave(&watchdog_lock
, flags
);
168 if (cs
->flags
& CLOCK_SOURCE_MUST_VERIFY
) {
169 int started
= !list_empty(&watchdog_list
);
171 list_add(&cs
->wd_list
, &watchdog_list
);
172 if (!started
&& watchdog
) {
173 watchdog_last
= watchdog
->read();
174 watchdog_timer
.expires
= jiffies
+ WATCHDOG_INTERVAL
;
175 add_timer_on(&watchdog_timer
,
176 first_cpu(cpu_online_map
));
179 if (cs
->flags
& CLOCK_SOURCE_IS_CONTINUOUS
)
180 cs
->flags
|= CLOCK_SOURCE_VALID_FOR_HRES
;
182 if (!watchdog
|| cs
->rating
> watchdog
->rating
) {
184 del_timer(&watchdog_timer
);
186 init_timer(&watchdog_timer
);
187 watchdog_timer
.function
= clocksource_watchdog
;
189 /* Reset watchdog cycles */
190 list_for_each_entry(cse
, &watchdog_list
, wd_list
)
191 cse
->flags
&= ~CLOCK_SOURCE_WATCHDOG
;
192 /* Start if list is not empty */
193 if (!list_empty(&watchdog_list
)) {
194 watchdog_last
= watchdog
->read();
195 watchdog_timer
.expires
=
196 jiffies
+ WATCHDOG_INTERVAL
;
197 add_timer_on(&watchdog_timer
,
198 first_cpu(cpu_online_map
));
202 spin_unlock_irqrestore(&watchdog_lock
, flags
);
205 static void clocksource_check_watchdog(struct clocksource
*cs
)
207 if (cs
->flags
& CLOCK_SOURCE_IS_CONTINUOUS
)
208 cs
->flags
|= CLOCK_SOURCE_VALID_FOR_HRES
;
211 static inline void clocksource_resume_watchdog(void) { }
215 * clocksource_resume - resume the clocksource(s)
217 void clocksource_resume(void)
219 struct clocksource
*cs
;
222 spin_lock_irqsave(&clocksource_lock
, flags
);
224 list_for_each_entry(cs
, &clocksource_list
, list
) {
229 clocksource_resume_watchdog();
231 spin_unlock_irqrestore(&clocksource_lock
, flags
);
235 * clocksource_touch_watchdog - Update watchdog
237 * Update the watchdog after exception contexts such as kgdb so as not
238 * to incorrectly trip the watchdog.
241 void clocksource_touch_watchdog(void)
243 clocksource_resume_watchdog();
247 * clocksource_get_next - Returns the selected clocksource
250 struct clocksource
*clocksource_get_next(void)
254 spin_lock_irqsave(&clocksource_lock
, flags
);
255 if (next_clocksource
&& finished_booting
) {
256 curr_clocksource
= next_clocksource
;
257 next_clocksource
= NULL
;
259 spin_unlock_irqrestore(&clocksource_lock
, flags
);
261 return curr_clocksource
;
265 * select_clocksource - Selects the best registered clocksource.
267 * Private function. Must hold clocksource_lock when called.
269 * Select the clocksource with the best rating, or the clocksource,
270 * which is selected by userspace override.
272 static struct clocksource
*select_clocksource(void)
274 struct clocksource
*next
;
276 if (list_empty(&clocksource_list
))
279 if (clocksource_override
)
280 next
= clocksource_override
;
282 next
= list_entry(clocksource_list
.next
, struct clocksource
,
285 if (next
== curr_clocksource
)
292 * Enqueue the clocksource sorted by rating
294 static int clocksource_enqueue(struct clocksource
*c
)
296 struct list_head
*tmp
, *entry
= &clocksource_list
;
298 list_for_each(tmp
, &clocksource_list
) {
299 struct clocksource
*cs
;
301 cs
= list_entry(tmp
, struct clocksource
, list
);
304 /* Keep track of the place, where to insert */
305 if (cs
->rating
>= c
->rating
)
308 list_add(&c
->list
, entry
);
310 if (strlen(c
->name
) == strlen(override_name
) &&
311 !strcmp(c
->name
, override_name
))
312 clocksource_override
= c
;
318 * clocksource_register - Used to install new clocksources
319 * @t: clocksource to be registered
321 * Returns -EBUSY if registration fails, zero otherwise.
323 int clocksource_register(struct clocksource
*c
)
328 spin_lock_irqsave(&clocksource_lock
, flags
);
329 ret
= clocksource_enqueue(c
);
331 next_clocksource
= select_clocksource();
332 spin_unlock_irqrestore(&clocksource_lock
, flags
);
334 clocksource_check_watchdog(c
);
337 EXPORT_SYMBOL(clocksource_register
);
340 * clocksource_change_rating - Change the rating of a registered clocksource
343 void clocksource_change_rating(struct clocksource
*cs
, int rating
)
347 spin_lock_irqsave(&clocksource_lock
, flags
);
350 clocksource_enqueue(cs
);
351 next_clocksource
= select_clocksource();
352 spin_unlock_irqrestore(&clocksource_lock
, flags
);
356 * clocksource_unregister - remove a registered clocksource
358 void clocksource_unregister(struct clocksource
*cs
)
362 spin_lock_irqsave(&clocksource_lock
, flags
);
364 if (clocksource_override
== cs
)
365 clocksource_override
= NULL
;
366 next_clocksource
= select_clocksource();
367 spin_unlock_irqrestore(&clocksource_lock
, flags
);
372 * sysfs_show_current_clocksources - sysfs interface for current clocksource
374 * @buf: char buffer to be filled with clocksource list
376 * Provides sysfs interface for listing current clocksource.
379 sysfs_show_current_clocksources(struct sys_device
*dev
,
380 struct sysdev_attribute
*attr
, char *buf
)
384 spin_lock_irq(&clocksource_lock
);
385 count
= snprintf(buf
, PAGE_SIZE
, "%s\n", curr_clocksource
->name
);
386 spin_unlock_irq(&clocksource_lock
);
392 * sysfs_override_clocksource - interface for manually overriding clocksource
394 * @buf: name of override clocksource
395 * @count: length of buffer
397 * Takes input from sysfs interface for manually overriding the default
398 * clocksource selction.
400 static ssize_t
sysfs_override_clocksource(struct sys_device
*dev
,
401 struct sysdev_attribute
*attr
,
402 const char *buf
, size_t count
)
404 struct clocksource
*ovr
= NULL
;
408 /* strings from sysfs write are not 0 terminated! */
409 if (count
>= sizeof(override_name
))
413 if (buf
[count
-1] == '\n')
416 spin_lock_irq(&clocksource_lock
);
419 memcpy(override_name
, buf
, count
);
420 override_name
[count
] = 0;
422 len
= strlen(override_name
);
424 struct clocksource
*cs
;
426 ovr
= clocksource_override
;
427 /* try to select it: */
428 list_for_each_entry(cs
, &clocksource_list
, list
) {
429 if (strlen(cs
->name
) == len
&&
430 !strcmp(cs
->name
, override_name
))
435 /* Reselect, when the override name has changed */
436 if (ovr
!= clocksource_override
) {
437 clocksource_override
= ovr
;
438 next_clocksource
= select_clocksource();
441 spin_unlock_irq(&clocksource_lock
);
447 * sysfs_show_available_clocksources - sysfs interface for listing clocksource
449 * @buf: char buffer to be filled with clocksource list
451 * Provides sysfs interface for listing registered clocksources
454 sysfs_show_available_clocksources(struct sys_device
*dev
,
455 struct sysdev_attribute
*attr
,
458 struct clocksource
*src
;
461 spin_lock_irq(&clocksource_lock
);
462 list_for_each_entry(src
, &clocksource_list
, list
) {
463 count
+= snprintf(buf
+ count
,
464 max((ssize_t
)PAGE_SIZE
- count
, (ssize_t
)0),
467 spin_unlock_irq(&clocksource_lock
);
469 count
+= snprintf(buf
+ count
,
470 max((ssize_t
)PAGE_SIZE
- count
, (ssize_t
)0), "\n");
478 static SYSDEV_ATTR(current_clocksource
, 0644, sysfs_show_current_clocksources
,
479 sysfs_override_clocksource
);
481 static SYSDEV_ATTR(available_clocksource
, 0444,
482 sysfs_show_available_clocksources
, NULL
);
484 static struct sysdev_class clocksource_sysclass
= {
485 .name
= "clocksource",
488 static struct sys_device device_clocksource
= {
490 .cls
= &clocksource_sysclass
,
493 static int __init
init_clocksource_sysfs(void)
495 int error
= sysdev_class_register(&clocksource_sysclass
);
498 error
= sysdev_register(&device_clocksource
);
500 error
= sysdev_create_file(
502 &attr_current_clocksource
);
504 error
= sysdev_create_file(
506 &attr_available_clocksource
);
510 device_initcall(init_clocksource_sysfs
);
511 #endif /* CONFIG_SYSFS */
514 * boot_override_clocksource - boot clock override
515 * @str: override name
517 * Takes a clocksource= boot argument and uses it
518 * as the clocksource override name.
520 static int __init
boot_override_clocksource(char* str
)
523 spin_lock_irqsave(&clocksource_lock
, flags
);
525 strlcpy(override_name
, str
, sizeof(override_name
));
526 spin_unlock_irqrestore(&clocksource_lock
, flags
);
530 __setup("clocksource=", boot_override_clocksource
);
533 * boot_override_clock - Compatibility layer for deprecated boot option
534 * @str: override name
536 * DEPRECATED! Takes a clock= boot argument and uses it
537 * as the clocksource override name
539 static int __init
boot_override_clock(char* str
)
541 if (!strcmp(str
, "pmtmr")) {
542 printk("Warning: clock=pmtmr is deprecated. "
543 "Use clocksource=acpi_pm.\n");
544 return boot_override_clocksource("acpi_pm");
546 printk("Warning! clock= boot option is deprecated. "
547 "Use clocksource=xyz\n");
548 return boot_override_clocksource(str
);
551 __setup("clock=", boot_override_clock
);