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
26 #include <linux/device.h>
27 #include <linux/clocksource.h>
28 #include <linux/init.h>
29 #include <linux/module.h>
30 #include <linux/sched.h> /* for spin_unlock_irq() using preempt_count() m68k */
31 #include <linux/tick.h>
32 #include <linux/kthread.h>
34 #include "tick-internal.h"
35 #include "timekeeping_internal.h"
38 * clocks_calc_mult_shift - calculate mult/shift factors for scaled math of clocks
39 * @mult: pointer to mult variable
40 * @shift: pointer to shift variable
41 * @from: frequency to convert from
42 * @to: frequency to convert to
43 * @maxsec: guaranteed runtime conversion range in seconds
45 * The function evaluates the shift/mult pair for the scaled math
46 * operations of clocksources and clockevents.
48 * @to and @from are frequency values in HZ. For clock sources @to is
49 * NSEC_PER_SEC == 1GHz and @from is the counter frequency. For clock
50 * event @to is the counter frequency and @from is NSEC_PER_SEC.
52 * The @maxsec conversion range argument controls the time frame in
53 * seconds which must be covered by the runtime conversion with the
54 * calculated mult and shift factors. This guarantees that no 64bit
55 * overflow happens when the input value of the conversion is
56 * multiplied with the calculated mult factor. Larger ranges may
57 * reduce the conversion accuracy by chosing smaller mult and shift
61 clocks_calc_mult_shift(u32
*mult
, u32
*shift
, u32 from
, u32 to
, u32 maxsec
)
67 * Calculate the shift factor which is limiting the conversion
70 tmp
= ((u64
)maxsec
* from
) >> 32;
77 * Find the conversion shift/mult pair which has the best
78 * accuracy and fits the maxsec conversion range:
80 for (sft
= 32; sft
> 0; sft
--) {
81 tmp
= (u64
) to
<< sft
;
84 if ((tmp
>> sftacc
) == 0)
91 /*[Clocksource internal variables]---------
93 * currently selected clocksource.
95 * linked list with the registered clocksources
97 * protects manipulations to curr_clocksource and the clocksource_list
99 * Name of the user-specified clocksource.
101 static struct clocksource
*curr_clocksource
;
102 static LIST_HEAD(clocksource_list
);
103 static DEFINE_MUTEX(clocksource_mutex
);
104 static char override_name
[CS_NAME_LEN
];
105 static int finished_booting
;
107 #ifdef CONFIG_CLOCKSOURCE_WATCHDOG
108 static void clocksource_watchdog_work(struct work_struct
*work
);
109 static void clocksource_select(void);
111 static LIST_HEAD(watchdog_list
);
112 static struct clocksource
*watchdog
;
113 static struct timer_list watchdog_timer
;
114 static DECLARE_WORK(watchdog_work
, clocksource_watchdog_work
);
115 static DEFINE_SPINLOCK(watchdog_lock
);
116 static int watchdog_running
;
117 static atomic_t watchdog_reset_pending
;
119 static int clocksource_watchdog_kthread(void *data
);
120 static void __clocksource_change_rating(struct clocksource
*cs
, int rating
);
123 * Interval: 0.5sec Threshold: 0.0625s
125 #define WATCHDOG_INTERVAL (HZ >> 1)
126 #define WATCHDOG_THRESHOLD (NSEC_PER_SEC >> 4)
128 static void clocksource_watchdog_work(struct work_struct
*work
)
131 * If kthread_run fails the next watchdog scan over the
132 * watchdog_list will find the unstable clock again.
134 kthread_run(clocksource_watchdog_kthread
, NULL
, "kwatchdog");
137 static void __clocksource_unstable(struct clocksource
*cs
)
139 cs
->flags
&= ~(CLOCK_SOURCE_VALID_FOR_HRES
| CLOCK_SOURCE_WATCHDOG
);
140 cs
->flags
|= CLOCK_SOURCE_UNSTABLE
;
141 if (finished_booting
)
142 schedule_work(&watchdog_work
);
146 * clocksource_mark_unstable - mark clocksource unstable via watchdog
147 * @cs: clocksource to be marked unstable
149 * This function is called instead of clocksource_change_rating from
150 * cpu hotplug code to avoid a deadlock between the clocksource mutex
151 * and the cpu hotplug mutex. It defers the update of the clocksource
152 * to the watchdog thread.
154 void clocksource_mark_unstable(struct clocksource
*cs
)
158 spin_lock_irqsave(&watchdog_lock
, flags
);
159 if (!(cs
->flags
& CLOCK_SOURCE_UNSTABLE
)) {
160 if (list_empty(&cs
->wd_list
))
161 list_add(&cs
->wd_list
, &watchdog_list
);
162 __clocksource_unstable(cs
);
164 spin_unlock_irqrestore(&watchdog_lock
, flags
);
167 static void clocksource_watchdog(unsigned long data
)
169 struct clocksource
*cs
;
170 cycle_t csnow
, wdnow
, cslast
, wdlast
, delta
;
171 int64_t wd_nsec
, cs_nsec
;
172 int next_cpu
, reset_pending
;
174 spin_lock(&watchdog_lock
);
175 if (!watchdog_running
)
178 reset_pending
= atomic_read(&watchdog_reset_pending
);
180 list_for_each_entry(cs
, &watchdog_list
, wd_list
) {
182 /* Clocksource already marked unstable? */
183 if (cs
->flags
& CLOCK_SOURCE_UNSTABLE
) {
184 if (finished_booting
)
185 schedule_work(&watchdog_work
);
190 csnow
= cs
->read(cs
);
191 wdnow
= watchdog
->read(watchdog
);
194 /* Clocksource initialized ? */
195 if (!(cs
->flags
& CLOCK_SOURCE_WATCHDOG
) ||
196 atomic_read(&watchdog_reset_pending
)) {
197 cs
->flags
|= CLOCK_SOURCE_WATCHDOG
;
203 delta
= clocksource_delta(wdnow
, cs
->wd_last
, watchdog
->mask
);
204 wd_nsec
= clocksource_cyc2ns(delta
, watchdog
->mult
,
207 delta
= clocksource_delta(csnow
, cs
->cs_last
, cs
->mask
);
208 cs_nsec
= clocksource_cyc2ns(delta
, cs
->mult
, cs
->shift
);
209 wdlast
= cs
->wd_last
; /* save these in case we print them */
210 cslast
= cs
->cs_last
;
214 if (atomic_read(&watchdog_reset_pending
))
217 /* Check the deviation from the watchdog clocksource. */
218 if ((abs(cs_nsec
- wd_nsec
) > WATCHDOG_THRESHOLD
)) {
219 pr_warn("timekeeping watchdog: Marking clocksource '%s' as unstable, because the skew is too large:\n", cs
->name
);
220 pr_warn(" '%s' wd_now: %llx wd_last: %llx mask: %llx\n",
221 watchdog
->name
, wdnow
, wdlast
, watchdog
->mask
);
222 pr_warn(" '%s' cs_now: %llx cs_last: %llx mask: %llx\n",
223 cs
->name
, csnow
, cslast
, cs
->mask
);
224 __clocksource_unstable(cs
);
228 if (!(cs
->flags
& CLOCK_SOURCE_VALID_FOR_HRES
) &&
229 (cs
->flags
& CLOCK_SOURCE_IS_CONTINUOUS
) &&
230 (watchdog
->flags
& CLOCK_SOURCE_IS_CONTINUOUS
)) {
231 /* Mark it valid for high-res. */
232 cs
->flags
|= CLOCK_SOURCE_VALID_FOR_HRES
;
235 * clocksource_done_booting() will sort it if
236 * finished_booting is not set yet.
238 if (!finished_booting
)
242 * If this is not the current clocksource let
243 * the watchdog thread reselect it. Due to the
244 * change to high res this clocksource might
245 * be preferred now. If it is the current
246 * clocksource let the tick code know about
249 if (cs
!= curr_clocksource
) {
250 cs
->flags
|= CLOCK_SOURCE_RESELECT
;
251 schedule_work(&watchdog_work
);
259 * We only clear the watchdog_reset_pending, when we did a
260 * full cycle through all clocksources.
263 atomic_dec(&watchdog_reset_pending
);
266 * Cycle through CPUs to check if the CPUs stay synchronized
269 next_cpu
= cpumask_next(raw_smp_processor_id(), cpu_online_mask
);
270 if (next_cpu
>= nr_cpu_ids
)
271 next_cpu
= cpumask_first(cpu_online_mask
);
272 watchdog_timer
.expires
+= WATCHDOG_INTERVAL
;
273 add_timer_on(&watchdog_timer
, next_cpu
);
275 spin_unlock(&watchdog_lock
);
278 static inline void clocksource_start_watchdog(void)
280 if (watchdog_running
|| !watchdog
|| list_empty(&watchdog_list
))
282 init_timer(&watchdog_timer
);
283 watchdog_timer
.function
= clocksource_watchdog
;
284 watchdog_timer
.expires
= jiffies
+ WATCHDOG_INTERVAL
;
285 add_timer_on(&watchdog_timer
, cpumask_first(cpu_online_mask
));
286 watchdog_running
= 1;
289 static inline void clocksource_stop_watchdog(void)
291 if (!watchdog_running
|| (watchdog
&& !list_empty(&watchdog_list
)))
293 del_timer(&watchdog_timer
);
294 watchdog_running
= 0;
297 static inline void clocksource_reset_watchdog(void)
299 struct clocksource
*cs
;
301 list_for_each_entry(cs
, &watchdog_list
, wd_list
)
302 cs
->flags
&= ~CLOCK_SOURCE_WATCHDOG
;
305 static void clocksource_resume_watchdog(void)
307 atomic_inc(&watchdog_reset_pending
);
310 static void clocksource_enqueue_watchdog(struct clocksource
*cs
)
314 spin_lock_irqsave(&watchdog_lock
, flags
);
315 if (cs
->flags
& CLOCK_SOURCE_MUST_VERIFY
) {
316 /* cs is a clocksource to be watched. */
317 list_add(&cs
->wd_list
, &watchdog_list
);
318 cs
->flags
&= ~CLOCK_SOURCE_WATCHDOG
;
320 /* cs is a watchdog. */
321 if (cs
->flags
& CLOCK_SOURCE_IS_CONTINUOUS
)
322 cs
->flags
|= CLOCK_SOURCE_VALID_FOR_HRES
;
323 /* Pick the best watchdog. */
324 if (!watchdog
|| cs
->rating
> watchdog
->rating
) {
326 /* Reset watchdog cycles */
327 clocksource_reset_watchdog();
330 /* Check if the watchdog timer needs to be started. */
331 clocksource_start_watchdog();
332 spin_unlock_irqrestore(&watchdog_lock
, flags
);
335 static void clocksource_dequeue_watchdog(struct clocksource
*cs
)
339 spin_lock_irqsave(&watchdog_lock
, flags
);
340 if (cs
!= watchdog
) {
341 if (cs
->flags
& CLOCK_SOURCE_MUST_VERIFY
) {
342 /* cs is a watched clocksource. */
343 list_del_init(&cs
->wd_list
);
344 /* Check if the watchdog timer needs to be stopped. */
345 clocksource_stop_watchdog();
348 spin_unlock_irqrestore(&watchdog_lock
, flags
);
351 static int __clocksource_watchdog_kthread(void)
353 struct clocksource
*cs
, *tmp
;
358 spin_lock_irqsave(&watchdog_lock
, flags
);
359 list_for_each_entry_safe(cs
, tmp
, &watchdog_list
, wd_list
) {
360 if (cs
->flags
& CLOCK_SOURCE_UNSTABLE
) {
361 list_del_init(&cs
->wd_list
);
362 list_add(&cs
->wd_list
, &unstable
);
365 if (cs
->flags
& CLOCK_SOURCE_RESELECT
) {
366 cs
->flags
&= ~CLOCK_SOURCE_RESELECT
;
370 /* Check if the watchdog timer needs to be stopped. */
371 clocksource_stop_watchdog();
372 spin_unlock_irqrestore(&watchdog_lock
, flags
);
374 /* Needs to be done outside of watchdog lock */
375 list_for_each_entry_safe(cs
, tmp
, &unstable
, wd_list
) {
376 list_del_init(&cs
->wd_list
);
377 __clocksource_change_rating(cs
, 0);
382 static int clocksource_watchdog_kthread(void *data
)
384 mutex_lock(&clocksource_mutex
);
385 if (__clocksource_watchdog_kthread())
386 clocksource_select();
387 mutex_unlock(&clocksource_mutex
);
391 static bool clocksource_is_watchdog(struct clocksource
*cs
)
393 return cs
== watchdog
;
396 #else /* CONFIG_CLOCKSOURCE_WATCHDOG */
398 static void clocksource_enqueue_watchdog(struct clocksource
*cs
)
400 if (cs
->flags
& CLOCK_SOURCE_IS_CONTINUOUS
)
401 cs
->flags
|= CLOCK_SOURCE_VALID_FOR_HRES
;
404 static inline void clocksource_dequeue_watchdog(struct clocksource
*cs
) { }
405 static inline void clocksource_resume_watchdog(void) { }
406 static inline int __clocksource_watchdog_kthread(void) { return 0; }
407 static bool clocksource_is_watchdog(struct clocksource
*cs
) { return false; }
408 void clocksource_mark_unstable(struct clocksource
*cs
) { }
410 #endif /* CONFIG_CLOCKSOURCE_WATCHDOG */
413 * clocksource_suspend - suspend the clocksource(s)
415 void clocksource_suspend(void)
417 struct clocksource
*cs
;
419 list_for_each_entry_reverse(cs
, &clocksource_list
, list
)
425 * clocksource_resume - resume the clocksource(s)
427 void clocksource_resume(void)
429 struct clocksource
*cs
;
431 list_for_each_entry(cs
, &clocksource_list
, list
)
435 clocksource_resume_watchdog();
439 * clocksource_touch_watchdog - Update watchdog
441 * Update the watchdog after exception contexts such as kgdb so as not
442 * to incorrectly trip the watchdog. This might fail when the kernel
443 * was stopped in code which holds watchdog_lock.
445 void clocksource_touch_watchdog(void)
447 clocksource_resume_watchdog();
451 * clocksource_max_adjustment- Returns max adjustment amount
452 * @cs: Pointer to clocksource
455 static u32
clocksource_max_adjustment(struct clocksource
*cs
)
459 * We won't try to correct for more than 11% adjustments (110,000 ppm),
461 ret
= (u64
)cs
->mult
* 11;
467 * clocks_calc_max_nsecs - Returns maximum nanoseconds that can be converted
468 * @mult: cycle to nanosecond multiplier
469 * @shift: cycle to nanosecond divisor (power of two)
470 * @maxadj: maximum adjustment value to mult (~11%)
471 * @mask: bitmask for two's complement subtraction of non 64 bit counters
472 * @max_cyc: maximum cycle value before potential overflow (does not include
475 * NOTE: This function includes a safety margin of 50%, so that bad clock values
478 u64
clocks_calc_max_nsecs(u32 mult
, u32 shift
, u32 maxadj
, u64 mask
, u64
*max_cyc
)
480 u64 max_nsecs
, max_cycles
;
483 * Calculate the maximum number of cycles that we can pass to the
484 * cyc2ns() function without overflowing a 64-bit result.
486 max_cycles
= ULLONG_MAX
;
487 do_div(max_cycles
, mult
+maxadj
);
490 * The actual maximum number of cycles we can defer the clocksource is
491 * determined by the minimum of max_cycles and mask.
492 * Note: Here we subtract the maxadj to make sure we don't sleep for
493 * too long if there's a large negative adjustment.
495 max_cycles
= min(max_cycles
, mask
);
496 max_nsecs
= clocksource_cyc2ns(max_cycles
, mult
- maxadj
, shift
);
498 /* return the max_cycles value as well if requested */
500 *max_cyc
= max_cycles
;
502 /* Return 50% of the actual maximum, so we can detect bad values */
509 * clocksource_update_max_deferment - Updates the clocksource max_idle_ns & max_cycles
510 * @cs: Pointer to clocksource to be updated
513 static inline void clocksource_update_max_deferment(struct clocksource
*cs
)
515 cs
->max_idle_ns
= clocks_calc_max_nsecs(cs
->mult
, cs
->shift
,
516 cs
->maxadj
, cs
->mask
,
520 #ifndef CONFIG_ARCH_USES_GETTIMEOFFSET
522 static struct clocksource
*clocksource_find_best(bool oneshot
, bool skipcur
)
524 struct clocksource
*cs
;
526 if (!finished_booting
|| list_empty(&clocksource_list
))
530 * We pick the clocksource with the highest rating. If oneshot
531 * mode is active, we pick the highres valid clocksource with
534 list_for_each_entry(cs
, &clocksource_list
, list
) {
535 if (skipcur
&& cs
== curr_clocksource
)
537 if (oneshot
&& !(cs
->flags
& CLOCK_SOURCE_VALID_FOR_HRES
))
544 static void __clocksource_select(bool skipcur
)
546 bool oneshot
= tick_oneshot_mode_active();
547 struct clocksource
*best
, *cs
;
549 /* Find the best suitable clocksource */
550 best
= clocksource_find_best(oneshot
, skipcur
);
554 /* Check for the override clocksource. */
555 list_for_each_entry(cs
, &clocksource_list
, list
) {
556 if (skipcur
&& cs
== curr_clocksource
)
558 if (strcmp(cs
->name
, override_name
) != 0)
561 * Check to make sure we don't switch to a non-highres
562 * capable clocksource if the tick code is in oneshot
563 * mode (highres or nohz)
565 if (!(cs
->flags
& CLOCK_SOURCE_VALID_FOR_HRES
) && oneshot
) {
566 /* Override clocksource cannot be used. */
567 printk(KERN_WARNING
"Override clocksource %s is not "
568 "HRT compatible. Cannot switch while in "
569 "HRT/NOHZ mode\n", cs
->name
);
570 override_name
[0] = 0;
572 /* Override clocksource can be used. */
577 if (curr_clocksource
!= best
&& !timekeeping_notify(best
)) {
578 pr_info("Switched to clocksource %s\n", best
->name
);
579 curr_clocksource
= best
;
584 * clocksource_select - Select the best clocksource available
586 * Private function. Must hold clocksource_mutex when called.
588 * Select the clocksource with the best rating, or the clocksource,
589 * which is selected by userspace override.
591 static void clocksource_select(void)
593 return __clocksource_select(false);
596 static void clocksource_select_fallback(void)
598 return __clocksource_select(true);
601 #else /* !CONFIG_ARCH_USES_GETTIMEOFFSET */
603 static inline void clocksource_select(void) { }
604 static inline void clocksource_select_fallback(void) { }
609 * clocksource_done_booting - Called near the end of core bootup
611 * Hack to avoid lots of clocksource churn at boot time.
612 * We use fs_initcall because we want this to start before
613 * device_initcall but after subsys_initcall.
615 static int __init
clocksource_done_booting(void)
617 mutex_lock(&clocksource_mutex
);
618 curr_clocksource
= clocksource_default_clock();
619 finished_booting
= 1;
621 * Run the watchdog first to eliminate unstable clock sources
623 __clocksource_watchdog_kthread();
624 clocksource_select();
625 mutex_unlock(&clocksource_mutex
);
628 fs_initcall(clocksource_done_booting
);
631 * Enqueue the clocksource sorted by rating
633 static void clocksource_enqueue(struct clocksource
*cs
)
635 struct list_head
*entry
= &clocksource_list
;
636 struct clocksource
*tmp
;
638 list_for_each_entry(tmp
, &clocksource_list
, list
)
639 /* Keep track of the place, where to insert */
640 if (tmp
->rating
>= cs
->rating
)
642 list_add(&cs
->list
, entry
);
646 * __clocksource_update_freq_scale - Used update clocksource with new freq
647 * @cs: clocksource to be registered
648 * @scale: Scale factor multiplied against freq to get clocksource hz
649 * @freq: clocksource frequency (cycles per second) divided by scale
651 * This should only be called from the clocksource->enable() method.
653 * This *SHOULD NOT* be called directly! Please use the
654 * __clocksource_update_freq_hz() or __clocksource_update_freq_khz() helper
657 void __clocksource_update_freq_scale(struct clocksource
*cs
, u32 scale
, u32 freq
)
662 * Default clocksources are *special* and self-define their mult/shift.
663 * But, you're not special, so you should specify a freq value.
667 * Calc the maximum number of seconds which we can run before
668 * wrapping around. For clocksources which have a mask > 32-bit
669 * we need to limit the max sleep time to have a good
670 * conversion precision. 10 minutes is still a reasonable
671 * amount. That results in a shift value of 24 for a
672 * clocksource with mask >= 40-bit and f >= 4GHz. That maps to
673 * ~ 0.06ppm granularity for NTP.
680 else if (sec
> 600 && cs
->mask
> UINT_MAX
)
683 clocks_calc_mult_shift(&cs
->mult
, &cs
->shift
, freq
,
684 NSEC_PER_SEC
/ scale
, sec
* scale
);
687 * Ensure clocksources that have large 'mult' values don't overflow
690 cs
->maxadj
= clocksource_max_adjustment(cs
);
691 while (freq
&& ((cs
->mult
+ cs
->maxadj
< cs
->mult
)
692 || (cs
->mult
- cs
->maxadj
> cs
->mult
))) {
695 cs
->maxadj
= clocksource_max_adjustment(cs
);
699 * Only warn for *special* clocksources that self-define
700 * their mult/shift values and don't specify a freq.
702 WARN_ONCE(cs
->mult
+ cs
->maxadj
< cs
->mult
,
703 "timekeeping: Clocksource %s might overflow on 11%% adjustment\n",
706 clocksource_update_max_deferment(cs
);
708 pr_info("clocksource %s: mask: 0x%llx max_cycles: 0x%llx, max_idle_ns: %lld ns\n",
709 cs
->name
, cs
->mask
, cs
->max_cycles
, cs
->max_idle_ns
);
711 EXPORT_SYMBOL_GPL(__clocksource_update_freq_scale
);
714 * __clocksource_register_scale - Used to install new clocksources
715 * @cs: clocksource to be registered
716 * @scale: Scale factor multiplied against freq to get clocksource hz
717 * @freq: clocksource frequency (cycles per second) divided by scale
719 * Returns -EBUSY if registration fails, zero otherwise.
721 * This *SHOULD NOT* be called directly! Please use the
722 * clocksource_register_hz() or clocksource_register_khz helper functions.
724 int __clocksource_register_scale(struct clocksource
*cs
, u32 scale
, u32 freq
)
727 /* Initialize mult/shift and max_idle_ns */
728 __clocksource_update_freq_scale(cs
, scale
, freq
);
730 /* Add clocksource to the clocksource list */
731 mutex_lock(&clocksource_mutex
);
732 clocksource_enqueue(cs
);
733 clocksource_enqueue_watchdog(cs
);
734 clocksource_select();
735 mutex_unlock(&clocksource_mutex
);
738 EXPORT_SYMBOL_GPL(__clocksource_register_scale
);
740 static void __clocksource_change_rating(struct clocksource
*cs
, int rating
)
744 clocksource_enqueue(cs
);
748 * clocksource_change_rating - Change the rating of a registered clocksource
749 * @cs: clocksource to be changed
750 * @rating: new rating
752 void clocksource_change_rating(struct clocksource
*cs
, int rating
)
754 mutex_lock(&clocksource_mutex
);
755 __clocksource_change_rating(cs
, rating
);
756 clocksource_select();
757 mutex_unlock(&clocksource_mutex
);
759 EXPORT_SYMBOL(clocksource_change_rating
);
762 * Unbind clocksource @cs. Called with clocksource_mutex held
764 static int clocksource_unbind(struct clocksource
*cs
)
767 * I really can't convince myself to support this on hardware
768 * designed by lobotomized monkeys.
770 if (clocksource_is_watchdog(cs
))
773 if (cs
== curr_clocksource
) {
774 /* Select and try to install a replacement clock source */
775 clocksource_select_fallback();
776 if (curr_clocksource
== cs
)
779 clocksource_dequeue_watchdog(cs
);
780 list_del_init(&cs
->list
);
785 * clocksource_unregister - remove a registered clocksource
786 * @cs: clocksource to be unregistered
788 int clocksource_unregister(struct clocksource
*cs
)
792 mutex_lock(&clocksource_mutex
);
793 if (!list_empty(&cs
->list
))
794 ret
= clocksource_unbind(cs
);
795 mutex_unlock(&clocksource_mutex
);
798 EXPORT_SYMBOL(clocksource_unregister
);
802 * sysfs_show_current_clocksources - sysfs interface for current clocksource
805 * @buf: char buffer to be filled with clocksource list
807 * Provides sysfs interface for listing current clocksource.
810 sysfs_show_current_clocksources(struct device
*dev
,
811 struct device_attribute
*attr
, char *buf
)
815 mutex_lock(&clocksource_mutex
);
816 count
= snprintf(buf
, PAGE_SIZE
, "%s\n", curr_clocksource
->name
);
817 mutex_unlock(&clocksource_mutex
);
822 ssize_t
sysfs_get_uname(const char *buf
, char *dst
, size_t cnt
)
826 /* strings from sysfs write are not 0 terminated! */
827 if (!cnt
|| cnt
>= CS_NAME_LEN
)
831 if (buf
[cnt
-1] == '\n')
834 memcpy(dst
, buf
, cnt
);
840 * sysfs_override_clocksource - interface for manually overriding clocksource
843 * @buf: name of override clocksource
844 * @count: length of buffer
846 * Takes input from sysfs interface for manually overriding the default
847 * clocksource selection.
849 static ssize_t
sysfs_override_clocksource(struct device
*dev
,
850 struct device_attribute
*attr
,
851 const char *buf
, size_t count
)
855 mutex_lock(&clocksource_mutex
);
857 ret
= sysfs_get_uname(buf
, override_name
, count
);
859 clocksource_select();
861 mutex_unlock(&clocksource_mutex
);
867 * sysfs_unbind_current_clocksource - interface for manually unbinding clocksource
871 * @count: length of buffer
873 * Takes input from sysfs interface for manually unbinding a clocksource.
875 static ssize_t
sysfs_unbind_clocksource(struct device
*dev
,
876 struct device_attribute
*attr
,
877 const char *buf
, size_t count
)
879 struct clocksource
*cs
;
880 char name
[CS_NAME_LEN
];
883 ret
= sysfs_get_uname(buf
, name
, count
);
888 mutex_lock(&clocksource_mutex
);
889 list_for_each_entry(cs
, &clocksource_list
, list
) {
890 if (strcmp(cs
->name
, name
))
892 ret
= clocksource_unbind(cs
);
895 mutex_unlock(&clocksource_mutex
);
897 return ret
? ret
: count
;
901 * sysfs_show_available_clocksources - sysfs interface for listing clocksource
904 * @buf: char buffer to be filled with clocksource list
906 * Provides sysfs interface for listing registered clocksources
909 sysfs_show_available_clocksources(struct device
*dev
,
910 struct device_attribute
*attr
,
913 struct clocksource
*src
;
916 mutex_lock(&clocksource_mutex
);
917 list_for_each_entry(src
, &clocksource_list
, list
) {
919 * Don't show non-HRES clocksource if the tick code is
920 * in one shot mode (highres=on or nohz=on)
922 if (!tick_oneshot_mode_active() ||
923 (src
->flags
& CLOCK_SOURCE_VALID_FOR_HRES
))
924 count
+= snprintf(buf
+ count
,
925 max((ssize_t
)PAGE_SIZE
- count
, (ssize_t
)0),
928 mutex_unlock(&clocksource_mutex
);
930 count
+= snprintf(buf
+ count
,
931 max((ssize_t
)PAGE_SIZE
- count
, (ssize_t
)0), "\n");
939 static DEVICE_ATTR(current_clocksource
, 0644, sysfs_show_current_clocksources
,
940 sysfs_override_clocksource
);
942 static DEVICE_ATTR(unbind_clocksource
, 0200, NULL
, sysfs_unbind_clocksource
);
944 static DEVICE_ATTR(available_clocksource
, 0444,
945 sysfs_show_available_clocksources
, NULL
);
947 static struct bus_type clocksource_subsys
= {
948 .name
= "clocksource",
949 .dev_name
= "clocksource",
952 static struct device device_clocksource
= {
954 .bus
= &clocksource_subsys
,
957 static int __init
init_clocksource_sysfs(void)
959 int error
= subsys_system_register(&clocksource_subsys
, NULL
);
962 error
= device_register(&device_clocksource
);
964 error
= device_create_file(
966 &dev_attr_current_clocksource
);
968 error
= device_create_file(&device_clocksource
,
969 &dev_attr_unbind_clocksource
);
971 error
= device_create_file(
973 &dev_attr_available_clocksource
);
977 device_initcall(init_clocksource_sysfs
);
978 #endif /* CONFIG_SYSFS */
981 * boot_override_clocksource - boot clock override
982 * @str: override name
984 * Takes a clocksource= boot argument and uses it
985 * as the clocksource override name.
987 static int __init
boot_override_clocksource(char* str
)
989 mutex_lock(&clocksource_mutex
);
991 strlcpy(override_name
, str
, sizeof(override_name
));
992 mutex_unlock(&clocksource_mutex
);
996 __setup("clocksource=", boot_override_clocksource
);
999 * boot_override_clock - Compatibility layer for deprecated boot option
1000 * @str: override name
1002 * DEPRECATED! Takes a clock= boot argument and uses it
1003 * as the clocksource override name
1005 static int __init
boot_override_clock(char* str
)
1007 if (!strcmp(str
, "pmtmr")) {
1008 printk("Warning: clock=pmtmr is deprecated. "
1009 "Use clocksource=acpi_pm.\n");
1010 return boot_override_clocksource("acpi_pm");
1012 printk("Warning! clock= boot option is deprecated. "
1013 "Use clocksource=xyz\n");
1014 return boot_override_clocksource(str
);
1017 __setup("clock=", boot_override_clock
);