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
);
145 static void clocksource_unstable(struct clocksource
*cs
, int64_t delta
)
147 printk(KERN_WARNING
"Clocksource %s unstable (delta = %Ld ns)\n",
149 __clocksource_unstable(cs
);
153 * clocksource_mark_unstable - mark clocksource unstable via watchdog
154 * @cs: clocksource to be marked unstable
156 * This function is called instead of clocksource_change_rating from
157 * cpu hotplug code to avoid a deadlock between the clocksource mutex
158 * and the cpu hotplug mutex. It defers the update of the clocksource
159 * to the watchdog thread.
161 void clocksource_mark_unstable(struct clocksource
*cs
)
165 spin_lock_irqsave(&watchdog_lock
, flags
);
166 if (!(cs
->flags
& CLOCK_SOURCE_UNSTABLE
)) {
167 if (list_empty(&cs
->wd_list
))
168 list_add(&cs
->wd_list
, &watchdog_list
);
169 __clocksource_unstable(cs
);
171 spin_unlock_irqrestore(&watchdog_lock
, flags
);
174 static void clocksource_watchdog(unsigned long data
)
176 struct clocksource
*cs
;
177 cycle_t csnow
, wdnow
, delta
;
178 int64_t wd_nsec
, cs_nsec
;
179 int next_cpu
, reset_pending
;
181 spin_lock(&watchdog_lock
);
182 if (!watchdog_running
)
185 reset_pending
= atomic_read(&watchdog_reset_pending
);
187 list_for_each_entry(cs
, &watchdog_list
, wd_list
) {
189 /* Clocksource already marked unstable? */
190 if (cs
->flags
& CLOCK_SOURCE_UNSTABLE
) {
191 if (finished_booting
)
192 schedule_work(&watchdog_work
);
197 csnow
= cs
->read(cs
);
198 wdnow
= watchdog
->read(watchdog
);
201 /* Clocksource initialized ? */
202 if (!(cs
->flags
& CLOCK_SOURCE_WATCHDOG
) ||
203 atomic_read(&watchdog_reset_pending
)) {
204 cs
->flags
|= CLOCK_SOURCE_WATCHDOG
;
210 delta
= clocksource_delta(wdnow
, cs
->wd_last
, watchdog
->mask
);
211 wd_nsec
= clocksource_cyc2ns(delta
, watchdog
->mult
,
214 delta
= clocksource_delta(csnow
, cs
->cs_last
, cs
->mask
);
215 cs_nsec
= clocksource_cyc2ns(delta
, cs
->mult
, cs
->shift
);
219 if (atomic_read(&watchdog_reset_pending
))
222 /* Check the deviation from the watchdog clocksource. */
223 if ((abs(cs_nsec
- wd_nsec
) > WATCHDOG_THRESHOLD
)) {
224 clocksource_unstable(cs
, cs_nsec
- wd_nsec
);
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
473 u64
clocks_calc_max_nsecs(u32 mult
, u32 shift
, u32 maxadj
, u64 mask
)
475 u64 max_nsecs
, max_cycles
;
478 * Calculate the maximum number of cycles that we can pass to the
479 * cyc2ns function without overflowing a 64-bit signed result. The
480 * maximum number of cycles is equal to ULLONG_MAX/(mult+maxadj)
481 * which is equivalent to the below.
482 * max_cycles < (2^63)/(mult + maxadj)
483 * max_cycles < 2^(log2((2^63)/(mult + maxadj)))
484 * max_cycles < 2^(log2(2^63) - log2(mult + maxadj))
485 * max_cycles < 2^(63 - log2(mult + maxadj))
486 * max_cycles < 1 << (63 - log2(mult + maxadj))
487 * Please note that we add 1 to the result of the log2 to account for
488 * any rounding errors, ensure the above inequality is satisfied and
489 * no overflow will occur.
491 max_cycles
= 1ULL << (63 - (ilog2(mult
+ maxadj
) + 1));
494 * The actual maximum number of cycles we can defer the clocksource is
495 * determined by the minimum of max_cycles and mask.
496 * Note: Here we subtract the maxadj to make sure we don't sleep for
497 * too long if there's a large negative adjustment.
499 max_cycles
= min(max_cycles
, mask
);
500 max_nsecs
= clocksource_cyc2ns(max_cycles
, mult
- maxadj
, shift
);
506 * clocksource_max_deferment - Returns max time the clocksource can be deferred
507 * @cs: Pointer to clocksource
510 static u64
clocksource_max_deferment(struct clocksource
*cs
)
514 max_nsecs
= clocks_calc_max_nsecs(cs
->mult
, cs
->shift
, cs
->maxadj
,
517 * To ensure that the clocksource does not wrap whilst we are idle,
518 * limit the time the clocksource can be deferred by 12.5%. Please
519 * note a margin of 12.5% is used because this can be computed with
520 * a shift, versus say 10% which would require division.
522 return max_nsecs
- (max_nsecs
>> 3);
525 #ifndef CONFIG_ARCH_USES_GETTIMEOFFSET
527 static struct clocksource
*clocksource_find_best(bool oneshot
, bool skipcur
)
529 struct clocksource
*cs
;
531 if (!finished_booting
|| list_empty(&clocksource_list
))
535 * We pick the clocksource with the highest rating. If oneshot
536 * mode is active, we pick the highres valid clocksource with
539 list_for_each_entry(cs
, &clocksource_list
, list
) {
540 if (skipcur
&& cs
== curr_clocksource
)
542 if (oneshot
&& !(cs
->flags
& CLOCK_SOURCE_VALID_FOR_HRES
))
549 static void __clocksource_select(bool skipcur
)
551 bool oneshot
= tick_oneshot_mode_active();
552 struct clocksource
*best
, *cs
;
554 /* Find the best suitable clocksource */
555 best
= clocksource_find_best(oneshot
, skipcur
);
559 /* Check for the override clocksource. */
560 list_for_each_entry(cs
, &clocksource_list
, list
) {
561 if (skipcur
&& cs
== curr_clocksource
)
563 if (strcmp(cs
->name
, override_name
) != 0)
566 * Check to make sure we don't switch to a non-highres
567 * capable clocksource if the tick code is in oneshot
568 * mode (highres or nohz)
570 if (!(cs
->flags
& CLOCK_SOURCE_VALID_FOR_HRES
) && oneshot
) {
571 /* Override clocksource cannot be used. */
572 printk(KERN_WARNING
"Override clocksource %s is not "
573 "HRT compatible. Cannot switch while in "
574 "HRT/NOHZ mode\n", cs
->name
);
575 override_name
[0] = 0;
577 /* Override clocksource can be used. */
582 if (curr_clocksource
!= best
&& !timekeeping_notify(best
)) {
583 pr_info("Switched to clocksource %s\n", best
->name
);
584 curr_clocksource
= best
;
589 * clocksource_select - Select the best clocksource available
591 * Private function. Must hold clocksource_mutex when called.
593 * Select the clocksource with the best rating, or the clocksource,
594 * which is selected by userspace override.
596 static void clocksource_select(void)
598 return __clocksource_select(false);
601 static void clocksource_select_fallback(void)
603 return __clocksource_select(true);
606 #else /* !CONFIG_ARCH_USES_GETTIMEOFFSET */
608 static inline void clocksource_select(void) { }
609 static inline void clocksource_select_fallback(void) { }
614 * clocksource_done_booting - Called near the end of core bootup
616 * Hack to avoid lots of clocksource churn at boot time.
617 * We use fs_initcall because we want this to start before
618 * device_initcall but after subsys_initcall.
620 static int __init
clocksource_done_booting(void)
622 mutex_lock(&clocksource_mutex
);
623 curr_clocksource
= clocksource_default_clock();
624 finished_booting
= 1;
626 * Run the watchdog first to eliminate unstable clock sources
628 __clocksource_watchdog_kthread();
629 clocksource_select();
630 mutex_unlock(&clocksource_mutex
);
633 fs_initcall(clocksource_done_booting
);
636 * Enqueue the clocksource sorted by rating
638 static void clocksource_enqueue(struct clocksource
*cs
)
640 struct list_head
*entry
= &clocksource_list
;
641 struct clocksource
*tmp
;
643 list_for_each_entry(tmp
, &clocksource_list
, list
)
644 /* Keep track of the place, where to insert */
645 if (tmp
->rating
>= cs
->rating
)
647 list_add(&cs
->list
, entry
);
651 * __clocksource_updatefreq_scale - Used update clocksource with new freq
652 * @cs: clocksource to be registered
653 * @scale: Scale factor multiplied against freq to get clocksource hz
654 * @freq: clocksource frequency (cycles per second) divided by scale
656 * This should only be called from the clocksource->enable() method.
658 * This *SHOULD NOT* be called directly! Please use the
659 * clocksource_updatefreq_hz() or clocksource_updatefreq_khz helper functions.
661 void __clocksource_updatefreq_scale(struct clocksource
*cs
, u32 scale
, u32 freq
)
665 * Calc the maximum number of seconds which we can run before
666 * wrapping around. For clocksources which have a mask > 32bit
667 * we need to limit the max sleep time to have a good
668 * conversion precision. 10 minutes is still a reasonable
669 * amount. That results in a shift value of 24 for a
670 * clocksource with mask >= 40bit and f >= 4GHz. That maps to
671 * ~ 0.06ppm granularity for NTP. We apply the same 12.5%
672 * margin as we do in clocksource_max_deferment()
674 sec
= (cs
->mask
- (cs
->mask
>> 3));
679 else if (sec
> 600 && cs
->mask
> UINT_MAX
)
682 clocks_calc_mult_shift(&cs
->mult
, &cs
->shift
, freq
,
683 NSEC_PER_SEC
/ scale
, sec
* scale
);
686 * for clocksources that have large mults, to avoid overflow.
687 * Since mult may be adjusted by ntp, add an safety extra margin
690 cs
->maxadj
= clocksource_max_adjustment(cs
);
691 while ((cs
->mult
+ cs
->maxadj
< cs
->mult
)
692 || (cs
->mult
- cs
->maxadj
> cs
->mult
)) {
695 cs
->maxadj
= clocksource_max_adjustment(cs
);
698 cs
->max_idle_ns
= clocksource_max_deferment(cs
);
700 EXPORT_SYMBOL_GPL(__clocksource_updatefreq_scale
);
703 * __clocksource_register_scale - Used to install new clocksources
704 * @cs: clocksource to be registered
705 * @scale: Scale factor multiplied against freq to get clocksource hz
706 * @freq: clocksource frequency (cycles per second) divided by scale
708 * Returns -EBUSY if registration fails, zero otherwise.
710 * This *SHOULD NOT* be called directly! Please use the
711 * clocksource_register_hz() or clocksource_register_khz helper functions.
713 int __clocksource_register_scale(struct clocksource
*cs
, u32 scale
, u32 freq
)
716 /* Initialize mult/shift and max_idle_ns */
717 __clocksource_updatefreq_scale(cs
, scale
, freq
);
719 /* Add clocksource to the clocksource list */
720 mutex_lock(&clocksource_mutex
);
721 clocksource_enqueue(cs
);
722 clocksource_enqueue_watchdog(cs
);
723 clocksource_select();
724 mutex_unlock(&clocksource_mutex
);
727 EXPORT_SYMBOL_GPL(__clocksource_register_scale
);
731 * clocksource_register - Used to install new clocksources
732 * @cs: clocksource to be registered
734 * Returns -EBUSY if registration fails, zero otherwise.
736 int clocksource_register(struct clocksource
*cs
)
738 /* calculate max adjustment for given mult/shift */
739 cs
->maxadj
= clocksource_max_adjustment(cs
);
740 WARN_ONCE(cs
->mult
+ cs
->maxadj
< cs
->mult
,
741 "Clocksource %s might overflow on 11%% adjustment\n",
744 /* calculate max idle time permitted for this clocksource */
745 cs
->max_idle_ns
= clocksource_max_deferment(cs
);
747 mutex_lock(&clocksource_mutex
);
748 clocksource_enqueue(cs
);
749 clocksource_enqueue_watchdog(cs
);
750 clocksource_select();
751 mutex_unlock(&clocksource_mutex
);
754 EXPORT_SYMBOL(clocksource_register
);
756 static void __clocksource_change_rating(struct clocksource
*cs
, int rating
)
760 clocksource_enqueue(cs
);
764 * clocksource_change_rating - Change the rating of a registered clocksource
765 * @cs: clocksource to be changed
766 * @rating: new rating
768 void clocksource_change_rating(struct clocksource
*cs
, int rating
)
770 mutex_lock(&clocksource_mutex
);
771 __clocksource_change_rating(cs
, rating
);
772 clocksource_select();
773 mutex_unlock(&clocksource_mutex
);
775 EXPORT_SYMBOL(clocksource_change_rating
);
778 * Unbind clocksource @cs. Called with clocksource_mutex held
780 static int clocksource_unbind(struct clocksource
*cs
)
783 * I really can't convince myself to support this on hardware
784 * designed by lobotomized monkeys.
786 if (clocksource_is_watchdog(cs
))
789 if (cs
== curr_clocksource
) {
790 /* Select and try to install a replacement clock source */
791 clocksource_select_fallback();
792 if (curr_clocksource
== cs
)
795 clocksource_dequeue_watchdog(cs
);
796 list_del_init(&cs
->list
);
801 * clocksource_unregister - remove a registered clocksource
802 * @cs: clocksource to be unregistered
804 int clocksource_unregister(struct clocksource
*cs
)
808 mutex_lock(&clocksource_mutex
);
809 if (!list_empty(&cs
->list
))
810 ret
= clocksource_unbind(cs
);
811 mutex_unlock(&clocksource_mutex
);
814 EXPORT_SYMBOL(clocksource_unregister
);
818 * sysfs_show_current_clocksources - sysfs interface for current clocksource
821 * @buf: char buffer to be filled with clocksource list
823 * Provides sysfs interface for listing current clocksource.
826 sysfs_show_current_clocksources(struct device
*dev
,
827 struct device_attribute
*attr
, char *buf
)
831 mutex_lock(&clocksource_mutex
);
832 count
= snprintf(buf
, PAGE_SIZE
, "%s\n", curr_clocksource
->name
);
833 mutex_unlock(&clocksource_mutex
);
838 ssize_t
sysfs_get_uname(const char *buf
, char *dst
, size_t cnt
)
842 /* strings from sysfs write are not 0 terminated! */
843 if (!cnt
|| cnt
>= CS_NAME_LEN
)
847 if (buf
[cnt
-1] == '\n')
850 memcpy(dst
, buf
, cnt
);
856 * sysfs_override_clocksource - interface for manually overriding clocksource
859 * @buf: name of override clocksource
860 * @count: length of buffer
862 * Takes input from sysfs interface for manually overriding the default
863 * clocksource selection.
865 static ssize_t
sysfs_override_clocksource(struct device
*dev
,
866 struct device_attribute
*attr
,
867 const char *buf
, size_t count
)
871 mutex_lock(&clocksource_mutex
);
873 ret
= sysfs_get_uname(buf
, override_name
, count
);
875 clocksource_select();
877 mutex_unlock(&clocksource_mutex
);
883 * sysfs_unbind_current_clocksource - interface for manually unbinding clocksource
887 * @count: length of buffer
889 * Takes input from sysfs interface for manually unbinding a clocksource.
891 static ssize_t
sysfs_unbind_clocksource(struct device
*dev
,
892 struct device_attribute
*attr
,
893 const char *buf
, size_t count
)
895 struct clocksource
*cs
;
896 char name
[CS_NAME_LEN
];
899 ret
= sysfs_get_uname(buf
, name
, count
);
904 mutex_lock(&clocksource_mutex
);
905 list_for_each_entry(cs
, &clocksource_list
, list
) {
906 if (strcmp(cs
->name
, name
))
908 ret
= clocksource_unbind(cs
);
911 mutex_unlock(&clocksource_mutex
);
913 return ret
? ret
: count
;
917 * sysfs_show_available_clocksources - sysfs interface for listing clocksource
920 * @buf: char buffer to be filled with clocksource list
922 * Provides sysfs interface for listing registered clocksources
925 sysfs_show_available_clocksources(struct device
*dev
,
926 struct device_attribute
*attr
,
929 struct clocksource
*src
;
932 mutex_lock(&clocksource_mutex
);
933 list_for_each_entry(src
, &clocksource_list
, list
) {
935 * Don't show non-HRES clocksource if the tick code is
936 * in one shot mode (highres=on or nohz=on)
938 if (!tick_oneshot_mode_active() ||
939 (src
->flags
& CLOCK_SOURCE_VALID_FOR_HRES
))
940 count
+= snprintf(buf
+ count
,
941 max((ssize_t
)PAGE_SIZE
- count
, (ssize_t
)0),
944 mutex_unlock(&clocksource_mutex
);
946 count
+= snprintf(buf
+ count
,
947 max((ssize_t
)PAGE_SIZE
- count
, (ssize_t
)0), "\n");
955 static DEVICE_ATTR(current_clocksource
, 0644, sysfs_show_current_clocksources
,
956 sysfs_override_clocksource
);
958 static DEVICE_ATTR(unbind_clocksource
, 0200, NULL
, sysfs_unbind_clocksource
);
960 static DEVICE_ATTR(available_clocksource
, 0444,
961 sysfs_show_available_clocksources
, NULL
);
963 static struct bus_type clocksource_subsys
= {
964 .name
= "clocksource",
965 .dev_name
= "clocksource",
968 static struct device device_clocksource
= {
970 .bus
= &clocksource_subsys
,
973 static int __init
init_clocksource_sysfs(void)
975 int error
= subsys_system_register(&clocksource_subsys
, NULL
);
978 error
= device_register(&device_clocksource
);
980 error
= device_create_file(
982 &dev_attr_current_clocksource
);
984 error
= device_create_file(&device_clocksource
,
985 &dev_attr_unbind_clocksource
);
987 error
= device_create_file(
989 &dev_attr_available_clocksource
);
993 device_initcall(init_clocksource_sysfs
);
994 #endif /* CONFIG_SYSFS */
997 * boot_override_clocksource - boot clock override
998 * @str: override name
1000 * Takes a clocksource= boot argument and uses it
1001 * as the clocksource override name.
1003 static int __init
boot_override_clocksource(char* str
)
1005 mutex_lock(&clocksource_mutex
);
1007 strlcpy(override_name
, str
, sizeof(override_name
));
1008 mutex_unlock(&clocksource_mutex
);
1012 __setup("clocksource=", boot_override_clocksource
);
1015 * boot_override_clock - Compatibility layer for deprecated boot option
1016 * @str: override name
1018 * DEPRECATED! Takes a clock= boot argument and uses it
1019 * as the clocksource override name
1021 static int __init
boot_override_clock(char* str
)
1023 if (!strcmp(str
, "pmtmr")) {
1024 printk("Warning: clock=pmtmr is deprecated. "
1025 "Use clocksource=acpi_pm.\n");
1026 return boot_override_clocksource("acpi_pm");
1028 printk("Warning! clock= boot option is deprecated. "
1029 "Use clocksource=xyz\n");
1030 return boot_override_clocksource(str
);
1033 __setup("clock=", boot_override_clock
);