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>
33 #include <linux/hrtimer.h>
35 void timecounter_init(struct timecounter
*tc
,
36 const struct cyclecounter
*cc
,
40 tc
->cycle_last
= cc
->read(cc
);
41 tc
->nsec
= start_tstamp
;
43 EXPORT_SYMBOL(timecounter_init
);
46 * timecounter_read_delta - get nanoseconds since last call of this function
47 * @tc: Pointer to time counter
49 * When the underlying cycle counter runs over, this will be handled
50 * correctly as long as it does not run over more than once between
53 * The first call to this function for a new time counter initializes
54 * the time tracking and returns an undefined result.
56 static u64
timecounter_read_delta(struct timecounter
*tc
)
58 cycle_t cycle_now
, cycle_delta
;
61 /* read cycle counter: */
62 cycle_now
= tc
->cc
->read(tc
->cc
);
64 /* calculate the delta since the last timecounter_read_delta(): */
65 cycle_delta
= (cycle_now
- tc
->cycle_last
) & tc
->cc
->mask
;
67 /* convert to nanoseconds: */
68 ns_offset
= cyclecounter_cyc2ns(tc
->cc
, cycle_delta
);
70 /* update time stamp of timecounter_read_delta() call: */
71 tc
->cycle_last
= cycle_now
;
76 u64
timecounter_read(struct timecounter
*tc
)
80 /* increment time by nanoseconds since last call */
81 nsec
= timecounter_read_delta(tc
);
87 EXPORT_SYMBOL(timecounter_read
);
89 u64
timecounter_cyc2time(struct timecounter
*tc
,
92 u64 cycle_delta
= (cycle_tstamp
- tc
->cycle_last
) & tc
->cc
->mask
;
96 * Instead of always treating cycle_tstamp as more recent
97 * than tc->cycle_last, detect when it is too far in the
98 * future and treat it as old time stamp instead.
100 if (cycle_delta
> tc
->cc
->mask
/ 2) {
101 cycle_delta
= (tc
->cycle_last
- cycle_tstamp
) & tc
->cc
->mask
;
102 nsec
= tc
->nsec
- cyclecounter_cyc2ns(tc
->cc
, cycle_delta
);
104 nsec
= cyclecounter_cyc2ns(tc
->cc
, cycle_delta
) + tc
->nsec
;
109 EXPORT_SYMBOL(timecounter_cyc2time
);
111 /* XXX - Would like a better way for initializing curr_clocksource */
112 extern struct clocksource clocksource_jiffies
;
114 /*[Clocksource internal variables]---------
116 * currently selected clocksource. Initialized to clocksource_jiffies.
118 * pending next selected clocksource.
120 * linked list with the registered clocksources
122 * protects manipulations to curr_clocksource and next_clocksource
123 * and the clocksource_list
125 * Name of the user-specified clocksource.
127 static struct clocksource
*curr_clocksource
= &clocksource_jiffies
;
128 static struct clocksource
*next_clocksource
;
129 static struct clocksource
*clocksource_override
;
130 static LIST_HEAD(clocksource_list
);
131 static DEFINE_SPINLOCK(clocksource_lock
);
132 static char override_name
[32];
133 static int finished_booting
;
135 /* clocksource_done_booting - Called near the end of core bootup
137 * Hack to avoid lots of clocksource churn at boot time.
138 * We use fs_initcall because we want this to start before
139 * device_initcall but after subsys_initcall.
141 static int __init
clocksource_done_booting(void)
143 finished_booting
= 1;
146 fs_initcall(clocksource_done_booting
);
148 #ifdef CONFIG_CLOCKSOURCE_WATCHDOG
149 static LIST_HEAD(watchdog_list
);
150 static struct clocksource
*watchdog
;
151 static struct timer_list watchdog_timer
;
152 static DEFINE_SPINLOCK(watchdog_lock
);
153 static cycle_t watchdog_last
;
154 static unsigned long watchdog_resumed
;
157 * Interval: 0.5sec Threshold: 0.0625s
159 #define WATCHDOG_INTERVAL (HZ >> 1)
160 #define WATCHDOG_THRESHOLD (NSEC_PER_SEC >> 4)
162 static void clocksource_ratewd(struct clocksource
*cs
, int64_t delta
)
164 if (delta
> -WATCHDOG_THRESHOLD
&& delta
< WATCHDOG_THRESHOLD
)
167 printk(KERN_WARNING
"Clocksource %s unstable (delta = %Ld ns)\n",
169 cs
->flags
&= ~(CLOCK_SOURCE_VALID_FOR_HRES
| CLOCK_SOURCE_WATCHDOG
);
170 clocksource_change_rating(cs
, 0);
171 list_del(&cs
->wd_list
);
174 static void clocksource_watchdog(unsigned long data
)
176 struct clocksource
*cs
, *tmp
;
177 cycle_t csnow
, wdnow
;
178 int64_t wd_nsec
, cs_nsec
;
181 spin_lock(&watchdog_lock
);
183 resumed
= test_and_clear_bit(0, &watchdog_resumed
);
185 wdnow
= watchdog
->read(watchdog
);
186 wd_nsec
= cyc2ns(watchdog
, (wdnow
- watchdog_last
) & watchdog
->mask
);
187 watchdog_last
= wdnow
;
189 list_for_each_entry_safe(cs
, tmp
, &watchdog_list
, wd_list
) {
190 csnow
= cs
->read(cs
);
192 if (unlikely(resumed
)) {
198 if (!(cs
->flags
& CLOCK_SOURCE_WATCHDOG
)) {
199 if ((cs
->flags
& CLOCK_SOURCE_IS_CONTINUOUS
) &&
200 (watchdog
->flags
& CLOCK_SOURCE_IS_CONTINUOUS
)) {
201 cs
->flags
|= CLOCK_SOURCE_VALID_FOR_HRES
;
203 * We just marked the clocksource as
204 * highres-capable, notify the rest of the
205 * system as well so that we transition
206 * into high-res mode:
210 cs
->flags
|= CLOCK_SOURCE_WATCHDOG
;
213 cs_nsec
= cyc2ns(cs
, (csnow
- cs
->wd_last
) & cs
->mask
);
215 /* Check the delta. Might remove from the list ! */
216 clocksource_ratewd(cs
, cs_nsec
- wd_nsec
);
220 if (!list_empty(&watchdog_list
)) {
222 * Cycle through CPUs to check if the CPUs stay
223 * synchronized to each other.
225 int next_cpu
= cpumask_next(raw_smp_processor_id(),
228 if (next_cpu
>= nr_cpu_ids
)
229 next_cpu
= cpumask_first(cpu_online_mask
);
230 watchdog_timer
.expires
+= WATCHDOG_INTERVAL
;
231 add_timer_on(&watchdog_timer
, next_cpu
);
233 spin_unlock(&watchdog_lock
);
235 static void clocksource_resume_watchdog(void)
237 set_bit(0, &watchdog_resumed
);
240 static void clocksource_check_watchdog(struct clocksource
*cs
)
242 struct clocksource
*cse
;
245 spin_lock_irqsave(&watchdog_lock
, flags
);
246 if (cs
->flags
& CLOCK_SOURCE_MUST_VERIFY
) {
247 int started
= !list_empty(&watchdog_list
);
249 list_add(&cs
->wd_list
, &watchdog_list
);
250 if (!started
&& watchdog
) {
251 watchdog_last
= watchdog
->read(watchdog
);
252 watchdog_timer
.expires
= jiffies
+ WATCHDOG_INTERVAL
;
253 add_timer_on(&watchdog_timer
,
254 cpumask_first(cpu_online_mask
));
257 if (cs
->flags
& CLOCK_SOURCE_IS_CONTINUOUS
)
258 cs
->flags
|= CLOCK_SOURCE_VALID_FOR_HRES
;
260 if (!watchdog
|| cs
->rating
> watchdog
->rating
) {
262 del_timer(&watchdog_timer
);
264 init_timer(&watchdog_timer
);
265 watchdog_timer
.function
= clocksource_watchdog
;
267 /* Reset watchdog cycles */
268 list_for_each_entry(cse
, &watchdog_list
, wd_list
)
269 cse
->flags
&= ~CLOCK_SOURCE_WATCHDOG
;
270 /* Start if list is not empty */
271 if (!list_empty(&watchdog_list
)) {
272 watchdog_last
= watchdog
->read(watchdog
);
273 watchdog_timer
.expires
=
274 jiffies
+ WATCHDOG_INTERVAL
;
275 add_timer_on(&watchdog_timer
,
276 cpumask_first(cpu_online_mask
));
280 spin_unlock_irqrestore(&watchdog_lock
, flags
);
283 static void clocksource_check_watchdog(struct clocksource
*cs
)
285 if (cs
->flags
& CLOCK_SOURCE_IS_CONTINUOUS
)
286 cs
->flags
|= CLOCK_SOURCE_VALID_FOR_HRES
;
289 static inline void clocksource_resume_watchdog(void) { }
293 * clocksource_resume - resume the clocksource(s)
295 void clocksource_resume(void)
297 struct clocksource
*cs
;
300 spin_lock_irqsave(&clocksource_lock
, flags
);
302 list_for_each_entry(cs
, &clocksource_list
, list
) {
307 clocksource_resume_watchdog();
309 spin_unlock_irqrestore(&clocksource_lock
, flags
);
313 * clocksource_touch_watchdog - Update watchdog
315 * Update the watchdog after exception contexts such as kgdb so as not
316 * to incorrectly trip the watchdog.
319 void clocksource_touch_watchdog(void)
321 clocksource_resume_watchdog();
325 * clocksource_get_next - Returns the selected clocksource
328 struct clocksource
*clocksource_get_next(void)
332 spin_lock_irqsave(&clocksource_lock
, flags
);
333 if (next_clocksource
&& finished_booting
) {
334 curr_clocksource
= next_clocksource
;
335 next_clocksource
= NULL
;
337 spin_unlock_irqrestore(&clocksource_lock
, flags
);
339 return curr_clocksource
;
343 * select_clocksource - Selects the best registered clocksource.
345 * Private function. Must hold clocksource_lock when called.
347 * Select the clocksource with the best rating, or the clocksource,
348 * which is selected by userspace override.
350 static struct clocksource
*select_clocksource(void)
352 struct clocksource
*next
;
354 if (list_empty(&clocksource_list
))
357 if (clocksource_override
)
358 next
= clocksource_override
;
360 next
= list_entry(clocksource_list
.next
, struct clocksource
,
363 if (next
== curr_clocksource
)
370 * Enqueue the clocksource sorted by rating
372 static int clocksource_enqueue(struct clocksource
*c
)
374 struct list_head
*tmp
, *entry
= &clocksource_list
;
376 list_for_each(tmp
, &clocksource_list
) {
377 struct clocksource
*cs
;
379 cs
= list_entry(tmp
, struct clocksource
, list
);
382 /* Keep track of the place, where to insert */
383 if (cs
->rating
>= c
->rating
)
386 list_add(&c
->list
, entry
);
388 if (strlen(c
->name
) == strlen(override_name
) &&
389 !strcmp(c
->name
, override_name
))
390 clocksource_override
= c
;
396 * clocksource_register - Used to install new clocksources
397 * @t: clocksource to be registered
399 * Returns -EBUSY if registration fails, zero otherwise.
401 int clocksource_register(struct clocksource
*c
)
406 spin_lock_irqsave(&clocksource_lock
, flags
);
407 ret
= clocksource_enqueue(c
);
409 next_clocksource
= select_clocksource();
410 spin_unlock_irqrestore(&clocksource_lock
, flags
);
412 clocksource_check_watchdog(c
);
415 EXPORT_SYMBOL(clocksource_register
);
418 * clocksource_change_rating - Change the rating of a registered clocksource
421 void clocksource_change_rating(struct clocksource
*cs
, int rating
)
425 spin_lock_irqsave(&clocksource_lock
, flags
);
428 clocksource_enqueue(cs
);
429 next_clocksource
= select_clocksource();
430 spin_unlock_irqrestore(&clocksource_lock
, flags
);
434 * clocksource_unregister - remove a registered clocksource
436 void clocksource_unregister(struct clocksource
*cs
)
440 spin_lock_irqsave(&clocksource_lock
, flags
);
442 if (clocksource_override
== cs
)
443 clocksource_override
= NULL
;
444 next_clocksource
= select_clocksource();
445 spin_unlock_irqrestore(&clocksource_lock
, flags
);
450 * sysfs_show_current_clocksources - sysfs interface for current clocksource
452 * @buf: char buffer to be filled with clocksource list
454 * Provides sysfs interface for listing current clocksource.
457 sysfs_show_current_clocksources(struct sys_device
*dev
,
458 struct sysdev_attribute
*attr
, char *buf
)
462 spin_lock_irq(&clocksource_lock
);
463 count
= snprintf(buf
, PAGE_SIZE
, "%s\n", curr_clocksource
->name
);
464 spin_unlock_irq(&clocksource_lock
);
470 * sysfs_override_clocksource - interface for manually overriding clocksource
472 * @buf: name of override clocksource
473 * @count: length of buffer
475 * Takes input from sysfs interface for manually overriding the default
476 * clocksource selction.
478 static ssize_t
sysfs_override_clocksource(struct sys_device
*dev
,
479 struct sysdev_attribute
*attr
,
480 const char *buf
, size_t count
)
482 struct clocksource
*ovr
= NULL
;
486 /* strings from sysfs write are not 0 terminated! */
487 if (count
>= sizeof(override_name
))
491 if (buf
[count
-1] == '\n')
494 spin_lock_irq(&clocksource_lock
);
497 memcpy(override_name
, buf
, count
);
498 override_name
[count
] = 0;
500 len
= strlen(override_name
);
502 struct clocksource
*cs
;
504 ovr
= clocksource_override
;
505 /* try to select it: */
506 list_for_each_entry(cs
, &clocksource_list
, list
) {
507 if (strlen(cs
->name
) == len
&&
508 !strcmp(cs
->name
, override_name
))
514 * Check to make sure we don't switch to a non-HRT usable
515 * clocksource if HRT is enabled and running
517 if (hrtimer_hres_active() &&
518 !(ovr
->flags
& CLOCK_SOURCE_VALID_FOR_HRES
)) {
519 printk(KERN_WARNING
"%s clocksource is not HRT compatible. "
520 "Cannot switch while in HRT mode\n", ovr
->name
);
522 override_name
[0] = 0;
525 /* Reselect, when the override name has changed */
526 if (ovr
!= clocksource_override
) {
527 clocksource_override
= ovr
;
528 next_clocksource
= select_clocksource();
531 spin_unlock_irq(&clocksource_lock
);
537 * sysfs_show_available_clocksources - sysfs interface for listing clocksource
539 * @buf: char buffer to be filled with clocksource list
541 * Provides sysfs interface for listing registered clocksources
544 sysfs_show_available_clocksources(struct sys_device
*dev
,
545 struct sysdev_attribute
*attr
,
548 struct clocksource
*src
;
551 spin_lock_irq(&clocksource_lock
);
552 list_for_each_entry(src
, &clocksource_list
, list
) {
553 /* Don't show non-HRES clocksource if HRES is enabled */
554 if (!hrtimer_hres_active() ||
555 (src
->flags
& CLOCK_SOURCE_VALID_FOR_HRES
))
556 count
+= snprintf(buf
+ count
,
557 max((ssize_t
)PAGE_SIZE
- count
, (ssize_t
)0),
560 spin_unlock_irq(&clocksource_lock
);
562 count
+= snprintf(buf
+ count
,
563 max((ssize_t
)PAGE_SIZE
- count
, (ssize_t
)0), "\n");
571 static SYSDEV_ATTR(current_clocksource
, 0644, sysfs_show_current_clocksources
,
572 sysfs_override_clocksource
);
574 static SYSDEV_ATTR(available_clocksource
, 0444,
575 sysfs_show_available_clocksources
, NULL
);
577 static struct sysdev_class clocksource_sysclass
= {
578 .name
= "clocksource",
581 static struct sys_device device_clocksource
= {
583 .cls
= &clocksource_sysclass
,
586 static int __init
init_clocksource_sysfs(void)
588 int error
= sysdev_class_register(&clocksource_sysclass
);
591 error
= sysdev_register(&device_clocksource
);
593 error
= sysdev_create_file(
595 &attr_current_clocksource
);
597 error
= sysdev_create_file(
599 &attr_available_clocksource
);
603 device_initcall(init_clocksource_sysfs
);
604 #endif /* CONFIG_SYSFS */
607 * boot_override_clocksource - boot clock override
608 * @str: override name
610 * Takes a clocksource= boot argument and uses it
611 * as the clocksource override name.
613 static int __init
boot_override_clocksource(char* str
)
616 spin_lock_irqsave(&clocksource_lock
, flags
);
618 strlcpy(override_name
, str
, sizeof(override_name
));
619 spin_unlock_irqrestore(&clocksource_lock
, flags
);
623 __setup("clocksource=", boot_override_clocksource
);
626 * boot_override_clock - Compatibility layer for deprecated boot option
627 * @str: override name
629 * DEPRECATED! Takes a clock= boot argument and uses it
630 * as the clocksource override name
632 static int __init
boot_override_clock(char* str
)
634 if (!strcmp(str
, "pmtmr")) {
635 printk("Warning: clock=pmtmr is deprecated. "
636 "Use clocksource=acpi_pm.\n");
637 return boot_override_clocksource("acpi_pm");
639 printk("Warning! clock= boot option is deprecated. "
640 "Use clocksource=xyz\n");
641 return boot_override_clocksource(str
);
644 __setup("clock=", boot_override_clock
);