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"
36 void timecounter_init(struct timecounter *tc,
37 const struct cyclecounter *cc,
41 tc->cycle_last = cc->read(cc);
42 tc->nsec = start_tstamp;
44 EXPORT_SYMBOL_GPL(timecounter_init);
47 * timecounter_read_delta - get nanoseconds since last call of this function
48 * @tc: Pointer to time counter
50 * When the underlying cycle counter runs over, this will be handled
51 * correctly as long as it does not run over more than once between
54 * The first call to this function for a new time counter initializes
55 * the time tracking and returns an undefined result.
57 static u64 timecounter_read_delta(struct timecounter *tc)
59 cycle_t cycle_now, cycle_delta;
62 /* read cycle counter: */
63 cycle_now = tc->cc->read(tc->cc);
65 /* calculate the delta since the last timecounter_read_delta(): */
66 cycle_delta = (cycle_now - tc->cycle_last) & tc->cc->mask;
68 /* convert to nanoseconds: */
69 ns_offset = cyclecounter_cyc2ns(tc->cc, cycle_delta);
71 /* update time stamp of timecounter_read_delta() call: */
72 tc->cycle_last = cycle_now;
77 u64 timecounter_read(struct timecounter *tc)
81 /* increment time by nanoseconds since last call */
82 nsec = timecounter_read_delta(tc);
88 EXPORT_SYMBOL_GPL(timecounter_read);
90 u64 timecounter_cyc2time(struct timecounter *tc,
93 u64 cycle_delta = (cycle_tstamp - tc->cycle_last) & tc->cc->mask;
97 * Instead of always treating cycle_tstamp as more recent
98 * than tc->cycle_last, detect when it is too far in the
99 * future and treat it as old time stamp instead.
101 if (cycle_delta > tc->cc->mask / 2) {
102 cycle_delta = (tc->cycle_last - cycle_tstamp) & tc->cc->mask;
103 nsec = tc->nsec - cyclecounter_cyc2ns(tc->cc, cycle_delta);
105 nsec = cyclecounter_cyc2ns(tc->cc, cycle_delta) + tc->nsec;
110 EXPORT_SYMBOL_GPL(timecounter_cyc2time);
113 * clocks_calc_mult_shift - calculate mult/shift factors for scaled math of clocks
114 * @mult: pointer to mult variable
115 * @shift: pointer to shift variable
116 * @from: frequency to convert from
117 * @to: frequency to convert to
118 * @maxsec: guaranteed runtime conversion range in seconds
120 * The function evaluates the shift/mult pair for the scaled math
121 * operations of clocksources and clockevents.
123 * @to and @from are frequency values in HZ. For clock sources @to is
124 * NSEC_PER_SEC == 1GHz and @from is the counter frequency. For clock
125 * event @to is the counter frequency and @from is NSEC_PER_SEC.
127 * The @maxsec conversion range argument controls the time frame in
128 * seconds which must be covered by the runtime conversion with the
129 * calculated mult and shift factors. This guarantees that no 64bit
130 * overflow happens when the input value of the conversion is
131 * multiplied with the calculated mult factor. Larger ranges may
132 * reduce the conversion accuracy by chosing smaller mult and shift
136 clocks_calc_mult_shift(u32 *mult, u32 *shift, u32 from, u32 to, u32 maxsec)
142 * Calculate the shift factor which is limiting the conversion
145 tmp = ((u64)maxsec * from) >> 32;
152 * Find the conversion shift/mult pair which has the best
153 * accuracy and fits the maxsec conversion range:
155 for (sft = 32; sft > 0; sft--) {
156 tmp = (u64) to << sft;
159 if ((tmp >> sftacc) == 0)
166 /*[Clocksource internal variables]---------
168 * currently selected clocksource.
170 * linked list with the registered clocksources
172 * protects manipulations to curr_clocksource and the clocksource_list
174 * Name of the user-specified clocksource.
176 static struct clocksource *curr_clocksource;
177 static LIST_HEAD(clocksource_list);
178 static DEFINE_MUTEX(clocksource_mutex);
179 static char override_name[CS_NAME_LEN];
180 static int finished_booting;
182 #ifdef CONFIG_CLOCKSOURCE_WATCHDOG
183 static void clocksource_watchdog_work(struct work_struct *work);
185 static LIST_HEAD(watchdog_list);
186 static struct clocksource *watchdog;
187 static struct timer_list watchdog_timer;
188 static DECLARE_WORK(watchdog_work, clocksource_watchdog_work);
189 static DEFINE_SPINLOCK(watchdog_lock);
190 static int watchdog_running;
191 static atomic_t watchdog_reset_pending;
193 static int clocksource_watchdog_kthread(void *data);
194 static void __clocksource_change_rating(struct clocksource *cs, int rating);
197 * Interval: 0.5sec Threshold: 0.0625s
199 #define WATCHDOG_INTERVAL (HZ >> 1)
200 #define WATCHDOG_THRESHOLD (NSEC_PER_SEC >> 4)
202 static void clocksource_watchdog_work(struct work_struct *work)
205 * If kthread_run fails the next watchdog scan over the
206 * watchdog_list will find the unstable clock again.
208 kthread_run(clocksource_watchdog_kthread, NULL, "kwatchdog");
211 static void __clocksource_unstable(struct clocksource *cs)
213 cs->flags &= ~(CLOCK_SOURCE_VALID_FOR_HRES | CLOCK_SOURCE_WATCHDOG);
214 cs->flags |= CLOCK_SOURCE_UNSTABLE;
215 if (finished_booting)
216 schedule_work(&watchdog_work);
219 static void clocksource_unstable(struct clocksource *cs, int64_t delta)
221 printk(KERN_WARNING "Clocksource %s unstable (delta = %Ld ns)\n",
223 __clocksource_unstable(cs);
227 * clocksource_mark_unstable - mark clocksource unstable via watchdog
228 * @cs: clocksource to be marked unstable
230 * This function is called instead of clocksource_change_rating from
231 * cpu hotplug code to avoid a deadlock between the clocksource mutex
232 * and the cpu hotplug mutex. It defers the update of the clocksource
233 * to the watchdog thread.
235 void clocksource_mark_unstable(struct clocksource *cs)
239 spin_lock_irqsave(&watchdog_lock, flags);
240 if (!(cs->flags & CLOCK_SOURCE_UNSTABLE)) {
241 if (list_empty(&cs->wd_list))
242 list_add(&cs->wd_list, &watchdog_list);
243 __clocksource_unstable(cs);
245 spin_unlock_irqrestore(&watchdog_lock, flags);
248 static void clocksource_watchdog(unsigned long data)
250 struct clocksource *cs;
251 cycle_t csnow, wdnow;
252 int64_t wd_nsec, cs_nsec;
253 int next_cpu, reset_pending;
255 spin_lock(&watchdog_lock);
256 if (!watchdog_running)
259 reset_pending = atomic_read(&watchdog_reset_pending);
261 list_for_each_entry(cs, &watchdog_list, wd_list) {
263 /* Clocksource already marked unstable? */
264 if (cs->flags & CLOCK_SOURCE_UNSTABLE) {
265 if (finished_booting)
266 schedule_work(&watchdog_work);
271 csnow = cs->read(cs);
272 wdnow = watchdog->read(watchdog);
275 /* Clocksource initialized ? */
276 if (!(cs->flags & CLOCK_SOURCE_WATCHDOG) ||
277 atomic_read(&watchdog_reset_pending)) {
278 cs->flags |= CLOCK_SOURCE_WATCHDOG;
284 wd_nsec = clocksource_cyc2ns((wdnow - cs->wd_last) & watchdog->mask,
285 watchdog->mult, watchdog->shift);
287 cs_nsec = clocksource_cyc2ns((csnow - cs->cs_last) &
288 cs->mask, cs->mult, cs->shift);
292 if (atomic_read(&watchdog_reset_pending))
295 /* Check the deviation from the watchdog clocksource. */
296 if ((abs(cs_nsec - wd_nsec) > WATCHDOG_THRESHOLD)) {
297 clocksource_unstable(cs, cs_nsec - wd_nsec);
301 if (!(cs->flags & CLOCK_SOURCE_VALID_FOR_HRES) &&
302 (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) &&
303 (watchdog->flags & CLOCK_SOURCE_IS_CONTINUOUS)) {
304 cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
306 * We just marked the clocksource as highres-capable,
307 * notify the rest of the system as well so that we
308 * transition into high-res mode:
315 * We only clear the watchdog_reset_pending, when we did a
316 * full cycle through all clocksources.
319 atomic_dec(&watchdog_reset_pending);
322 * Cycle through CPUs to check if the CPUs stay synchronized
325 next_cpu = cpumask_next(raw_smp_processor_id(), cpu_online_mask);
326 if (next_cpu >= nr_cpu_ids)
327 next_cpu = cpumask_first(cpu_online_mask);
328 watchdog_timer.expires += WATCHDOG_INTERVAL;
329 add_timer_on(&watchdog_timer, next_cpu);
331 spin_unlock(&watchdog_lock);
334 static inline void clocksource_start_watchdog(void)
336 if (watchdog_running || !watchdog || list_empty(&watchdog_list))
338 init_timer(&watchdog_timer);
339 watchdog_timer.function = clocksource_watchdog;
340 watchdog_timer.expires = jiffies + WATCHDOG_INTERVAL;
341 add_timer_on(&watchdog_timer, cpumask_first(cpu_online_mask));
342 watchdog_running = 1;
345 static inline void clocksource_stop_watchdog(void)
347 if (!watchdog_running || (watchdog && !list_empty(&watchdog_list)))
349 del_timer(&watchdog_timer);
350 watchdog_running = 0;
353 static inline void clocksource_reset_watchdog(void)
355 struct clocksource *cs;
357 list_for_each_entry(cs, &watchdog_list, wd_list)
358 cs->flags &= ~CLOCK_SOURCE_WATCHDOG;
361 static void clocksource_resume_watchdog(void)
363 atomic_inc(&watchdog_reset_pending);
366 static void clocksource_enqueue_watchdog(struct clocksource *cs)
370 spin_lock_irqsave(&watchdog_lock, flags);
371 if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) {
372 /* cs is a clocksource to be watched. */
373 list_add(&cs->wd_list, &watchdog_list);
374 cs->flags &= ~CLOCK_SOURCE_WATCHDOG;
376 /* cs is a watchdog. */
377 if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
378 cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
379 /* Pick the best watchdog. */
380 if (!watchdog || cs->rating > watchdog->rating) {
382 /* Reset watchdog cycles */
383 clocksource_reset_watchdog();
386 /* Check if the watchdog timer needs to be started. */
387 clocksource_start_watchdog();
388 spin_unlock_irqrestore(&watchdog_lock, flags);
391 static void clocksource_dequeue_watchdog(struct clocksource *cs)
395 spin_lock_irqsave(&watchdog_lock, flags);
396 if (cs != watchdog) {
397 if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) {
398 /* cs is a watched clocksource. */
399 list_del_init(&cs->wd_list);
400 /* Check if the watchdog timer needs to be stopped. */
401 clocksource_stop_watchdog();
404 spin_unlock_irqrestore(&watchdog_lock, flags);
407 static int clocksource_watchdog_kthread(void *data)
409 struct clocksource *cs, *tmp;
413 mutex_lock(&clocksource_mutex);
414 spin_lock_irqsave(&watchdog_lock, flags);
415 list_for_each_entry_safe(cs, tmp, &watchdog_list, wd_list)
416 if (cs->flags & CLOCK_SOURCE_UNSTABLE) {
417 list_del_init(&cs->wd_list);
418 list_add(&cs->wd_list, &unstable);
420 /* Check if the watchdog timer needs to be stopped. */
421 clocksource_stop_watchdog();
422 spin_unlock_irqrestore(&watchdog_lock, flags);
424 /* Needs to be done outside of watchdog lock */
425 list_for_each_entry_safe(cs, tmp, &unstable, wd_list) {
426 list_del_init(&cs->wd_list);
427 __clocksource_change_rating(cs, 0);
429 mutex_unlock(&clocksource_mutex);
433 static bool clocksource_is_watchdog(struct clocksource *cs)
435 return cs == watchdog;
438 #else /* CONFIG_CLOCKSOURCE_WATCHDOG */
440 static void clocksource_enqueue_watchdog(struct clocksource *cs)
442 if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
443 cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
446 static inline void clocksource_dequeue_watchdog(struct clocksource *cs) { }
447 static inline void clocksource_resume_watchdog(void) { }
448 static inline int clocksource_watchdog_kthread(void *data) { return 0; }
449 static bool clocksource_is_watchdog(struct clocksource *cs) { return false; }
451 #endif /* CONFIG_CLOCKSOURCE_WATCHDOG */
454 * clocksource_suspend - suspend the clocksource(s)
456 void clocksource_suspend(void)
458 struct clocksource *cs;
460 list_for_each_entry_reverse(cs, &clocksource_list, list)
466 * clocksource_resume - resume the clocksource(s)
468 void clocksource_resume(void)
470 struct clocksource *cs;
472 list_for_each_entry(cs, &clocksource_list, list)
476 clocksource_resume_watchdog();
480 * clocksource_touch_watchdog - Update watchdog
482 * Update the watchdog after exception contexts such as kgdb so as not
483 * to incorrectly trip the watchdog. This might fail when the kernel
484 * was stopped in code which holds watchdog_lock.
486 void clocksource_touch_watchdog(void)
488 clocksource_resume_watchdog();
492 * clocksource_max_adjustment- Returns max adjustment amount
493 * @cs: Pointer to clocksource
496 static u32 clocksource_max_adjustment(struct clocksource *cs)
500 * We won't try to correct for more than 11% adjustments (110,000 ppm),
502 ret = (u64)cs->mult * 11;
508 * clocksource_max_deferment - Returns max time the clocksource can be deferred
509 * @cs: Pointer to clocksource
512 static u64 clocksource_max_deferment(struct clocksource *cs)
514 u64 max_nsecs, max_cycles;
517 * Calculate the maximum number of cycles that we can pass to the
518 * cyc2ns function without overflowing a 64-bit signed result. The
519 * maximum number of cycles is equal to ULLONG_MAX/(cs->mult+cs->maxadj)
520 * which is equivalent to the below.
521 * max_cycles < (2^63)/(cs->mult + cs->maxadj)
522 * max_cycles < 2^(log2((2^63)/(cs->mult + cs->maxadj)))
523 * max_cycles < 2^(log2(2^63) - log2(cs->mult + cs->maxadj))
524 * max_cycles < 2^(63 - log2(cs->mult + cs->maxadj))
525 * max_cycles < 1 << (63 - log2(cs->mult + cs->maxadj))
526 * Please note that we add 1 to the result of the log2 to account for
527 * any rounding errors, ensure the above inequality is satisfied and
528 * no overflow will occur.
530 max_cycles = 1ULL << (63 - (ilog2(cs->mult + cs->maxadj) + 1));
533 * The actual maximum number of cycles we can defer the clocksource is
534 * determined by the minimum of max_cycles and cs->mask.
535 * Note: Here we subtract the maxadj to make sure we don't sleep for
536 * too long if there's a large negative adjustment.
538 max_cycles = min_t(u64, max_cycles, (u64) cs->mask);
539 max_nsecs = clocksource_cyc2ns(max_cycles, cs->mult - cs->maxadj,
543 * To ensure that the clocksource does not wrap whilst we are idle,
544 * limit the time the clocksource can be deferred by 12.5%. Please
545 * note a margin of 12.5% is used because this can be computed with
546 * a shift, versus say 10% which would require division.
548 return max_nsecs - (max_nsecs >> 3);
551 #ifndef CONFIG_ARCH_USES_GETTIMEOFFSET
553 static struct clocksource *clocksource_find_best(bool oneshot, bool skipcur)
555 struct clocksource *cs;
557 if (!finished_booting || list_empty(&clocksource_list))
561 * We pick the clocksource with the highest rating. If oneshot
562 * mode is active, we pick the highres valid clocksource with
565 list_for_each_entry(cs, &clocksource_list, list) {
566 if (skipcur && cs == curr_clocksource)
568 if (oneshot && !(cs->flags & CLOCK_SOURCE_VALID_FOR_HRES))
575 static void __clocksource_select(bool skipcur)
577 bool oneshot = tick_oneshot_mode_active();
578 struct clocksource *best, *cs;
580 /* Find the best suitable clocksource */
581 best = clocksource_find_best(oneshot, skipcur);
585 /* Check for the override clocksource. */
586 list_for_each_entry(cs, &clocksource_list, list) {
587 if (skipcur && cs == curr_clocksource)
589 if (strcmp(cs->name, override_name) != 0)
592 * Check to make sure we don't switch to a non-highres
593 * capable clocksource if the tick code is in oneshot
594 * mode (highres or nohz)
596 if (!(cs->flags & CLOCK_SOURCE_VALID_FOR_HRES) && oneshot) {
597 /* Override clocksource cannot be used. */
598 printk(KERN_WARNING "Override clocksource %s is not "
599 "HRT compatible. Cannot switch while in "
600 "HRT/NOHZ mode\n", cs->name);
601 override_name[0] = 0;
603 /* Override clocksource can be used. */
608 if (curr_clocksource != best && !timekeeping_notify(best)) {
609 pr_info("Switched to clocksource %s\n", best->name);
610 curr_clocksource = best;
615 * clocksource_select - Select the best clocksource available
617 * Private function. Must hold clocksource_mutex when called.
619 * Select the clocksource with the best rating, or the clocksource,
620 * which is selected by userspace override.
622 static void clocksource_select(void)
624 return __clocksource_select(false);
627 static void clocksource_select_fallback(void)
629 return __clocksource_select(true);
632 #else /* !CONFIG_ARCH_USES_GETTIMEOFFSET */
634 static inline void clocksource_select(void) { }
639 * clocksource_done_booting - Called near the end of core bootup
641 * Hack to avoid lots of clocksource churn at boot time.
642 * We use fs_initcall because we want this to start before
643 * device_initcall but after subsys_initcall.
645 static int __init clocksource_done_booting(void)
647 mutex_lock(&clocksource_mutex);
648 curr_clocksource = clocksource_default_clock();
649 mutex_unlock(&clocksource_mutex);
651 finished_booting = 1;
654 * Run the watchdog first to eliminate unstable clock sources
656 clocksource_watchdog_kthread(NULL);
658 mutex_lock(&clocksource_mutex);
659 clocksource_select();
660 mutex_unlock(&clocksource_mutex);
663 fs_initcall(clocksource_done_booting);
666 * Enqueue the clocksource sorted by rating
668 static void clocksource_enqueue(struct clocksource *cs)
670 struct list_head *entry = &clocksource_list;
671 struct clocksource *tmp;
673 list_for_each_entry(tmp, &clocksource_list, list)
674 /* Keep track of the place, where to insert */
675 if (tmp->rating >= cs->rating)
677 list_add(&cs->list, entry);
681 * __clocksource_updatefreq_scale - Used update clocksource with new freq
682 * @cs: clocksource to be registered
683 * @scale: Scale factor multiplied against freq to get clocksource hz
684 * @freq: clocksource frequency (cycles per second) divided by scale
686 * This should only be called from the clocksource->enable() method.
688 * This *SHOULD NOT* be called directly! Please use the
689 * clocksource_updatefreq_hz() or clocksource_updatefreq_khz helper functions.
691 void __clocksource_updatefreq_scale(struct clocksource *cs, u32 scale, u32 freq)
695 * Calc the maximum number of seconds which we can run before
696 * wrapping around. For clocksources which have a mask > 32bit
697 * we need to limit the max sleep time to have a good
698 * conversion precision. 10 minutes is still a reasonable
699 * amount. That results in a shift value of 24 for a
700 * clocksource with mask >= 40bit and f >= 4GHz. That maps to
701 * ~ 0.06ppm granularity for NTP. We apply the same 12.5%
702 * margin as we do in clocksource_max_deferment()
704 sec = (cs->mask - (cs->mask >> 3));
709 else if (sec > 600 && cs->mask > UINT_MAX)
712 clocks_calc_mult_shift(&cs->mult, &cs->shift, freq,
713 NSEC_PER_SEC / scale, sec * scale);
716 * for clocksources that have large mults, to avoid overflow.
717 * Since mult may be adjusted by ntp, add an safety extra margin
720 cs->maxadj = clocksource_max_adjustment(cs);
721 while ((cs->mult + cs->maxadj < cs->mult)
722 || (cs->mult - cs->maxadj > cs->mult)) {
725 cs->maxadj = clocksource_max_adjustment(cs);
728 cs->max_idle_ns = clocksource_max_deferment(cs);
730 EXPORT_SYMBOL_GPL(__clocksource_updatefreq_scale);
733 * __clocksource_register_scale - Used to install new clocksources
734 * @cs: clocksource to be registered
735 * @scale: Scale factor multiplied against freq to get clocksource hz
736 * @freq: clocksource frequency (cycles per second) divided by scale
738 * Returns -EBUSY if registration fails, zero otherwise.
740 * This *SHOULD NOT* be called directly! Please use the
741 * clocksource_register_hz() or clocksource_register_khz helper functions.
743 int __clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq)
746 /* Initialize mult/shift and max_idle_ns */
747 __clocksource_updatefreq_scale(cs, scale, freq);
749 /* Add clocksource to the clcoksource list */
750 mutex_lock(&clocksource_mutex);
751 clocksource_enqueue(cs);
752 clocksource_enqueue_watchdog(cs);
753 clocksource_select();
754 mutex_unlock(&clocksource_mutex);
757 EXPORT_SYMBOL_GPL(__clocksource_register_scale);
761 * clocksource_register - Used to install new clocksources
762 * @cs: clocksource to be registered
764 * Returns -EBUSY if registration fails, zero otherwise.
766 int clocksource_register(struct clocksource *cs)
768 /* calculate max adjustment for given mult/shift */
769 cs->maxadj = clocksource_max_adjustment(cs);
770 WARN_ONCE(cs->mult + cs->maxadj < cs->mult,
771 "Clocksource %s might overflow on 11%% adjustment\n",
774 /* calculate max idle time permitted for this clocksource */
775 cs->max_idle_ns = clocksource_max_deferment(cs);
777 mutex_lock(&clocksource_mutex);
778 clocksource_enqueue(cs);
779 clocksource_enqueue_watchdog(cs);
780 clocksource_select();
781 mutex_unlock(&clocksource_mutex);
784 EXPORT_SYMBOL(clocksource_register);
786 static void __clocksource_change_rating(struct clocksource *cs, int rating)
790 clocksource_enqueue(cs);
791 clocksource_select();
795 * clocksource_change_rating - Change the rating of a registered clocksource
796 * @cs: clocksource to be changed
797 * @rating: new rating
799 void clocksource_change_rating(struct clocksource *cs, int rating)
801 mutex_lock(&clocksource_mutex);
802 __clocksource_change_rating(cs, rating);
803 mutex_unlock(&clocksource_mutex);
805 EXPORT_SYMBOL(clocksource_change_rating);
808 * Unbind clocksource @cs. Called with clocksource_mutex held
810 static int clocksource_unbind(struct clocksource *cs)
813 * I really can't convince myself to support this on hardware
814 * designed by lobotomized monkeys.
816 if (clocksource_is_watchdog(cs))
819 if (cs == curr_clocksource) {
820 /* Select and try to install a replacement clock source */
821 clocksource_select_fallback();
822 if (curr_clocksource == cs)
825 clocksource_dequeue_watchdog(cs);
826 list_del_init(&cs->list);
831 * clocksource_unregister - remove a registered clocksource
832 * @cs: clocksource to be unregistered
834 int clocksource_unregister(struct clocksource *cs)
838 mutex_lock(&clocksource_mutex);
839 if (!list_empty(&cs->list))
840 ret = clocksource_unbind(cs);
841 mutex_unlock(&clocksource_mutex);
844 EXPORT_SYMBOL(clocksource_unregister);
848 * sysfs_show_current_clocksources - sysfs interface for current clocksource
851 * @buf: char buffer to be filled with clocksource list
853 * Provides sysfs interface for listing current clocksource.
856 sysfs_show_current_clocksources(struct device *dev,
857 struct device_attribute *attr, char *buf)
861 mutex_lock(&clocksource_mutex);
862 count = snprintf(buf, PAGE_SIZE, "%s\n", curr_clocksource->name);
863 mutex_unlock(&clocksource_mutex);
868 size_t sysfs_get_uname(const char *buf, char *dst, size_t cnt)
872 /* strings from sysfs write are not 0 terminated! */
873 if (!cnt || cnt >= CS_NAME_LEN)
877 if (buf[cnt-1] == '\n')
880 memcpy(dst, buf, cnt);
886 * sysfs_override_clocksource - interface for manually overriding clocksource
889 * @buf: name of override clocksource
890 * @count: length of buffer
892 * Takes input from sysfs interface for manually overriding the default
893 * clocksource selection.
895 static ssize_t sysfs_override_clocksource(struct device *dev,
896 struct device_attribute *attr,
897 const char *buf, size_t count)
901 mutex_lock(&clocksource_mutex);
903 ret = sysfs_get_uname(buf, override_name, count);
905 clocksource_select();
907 mutex_unlock(&clocksource_mutex);
913 * sysfs_unbind_current_clocksource - interface for manually unbinding clocksource
917 * @count: length of buffer
919 * Takes input from sysfs interface for manually unbinding a clocksource.
921 static ssize_t sysfs_unbind_clocksource(struct device *dev,
922 struct device_attribute *attr,
923 const char *buf, size_t count)
925 struct clocksource *cs;
926 char name[CS_NAME_LEN];
929 ret = sysfs_get_uname(buf, name, count);
934 mutex_lock(&clocksource_mutex);
935 list_for_each_entry(cs, &clocksource_list, list) {
936 if (strcmp(cs->name, name))
938 ret = clocksource_unbind(cs);
941 mutex_unlock(&clocksource_mutex);
943 return ret ? ret : count;
947 * sysfs_show_available_clocksources - sysfs interface for listing clocksource
950 * @buf: char buffer to be filled with clocksource list
952 * Provides sysfs interface for listing registered clocksources
955 sysfs_show_available_clocksources(struct device *dev,
956 struct device_attribute *attr,
959 struct clocksource *src;
962 mutex_lock(&clocksource_mutex);
963 list_for_each_entry(src, &clocksource_list, list) {
965 * Don't show non-HRES clocksource if the tick code is
966 * in one shot mode (highres=on or nohz=on)
968 if (!tick_oneshot_mode_active() ||
969 (src->flags & CLOCK_SOURCE_VALID_FOR_HRES))
970 count += snprintf(buf + count,
971 max((ssize_t)PAGE_SIZE - count, (ssize_t)0),
974 mutex_unlock(&clocksource_mutex);
976 count += snprintf(buf + count,
977 max((ssize_t)PAGE_SIZE - count, (ssize_t)0), "\n");
985 static DEVICE_ATTR(current_clocksource, 0644, sysfs_show_current_clocksources,
986 sysfs_override_clocksource);
988 static DEVICE_ATTR(unbind_clocksource, 0200, NULL, sysfs_unbind_clocksource);
990 static DEVICE_ATTR(available_clocksource, 0444,
991 sysfs_show_available_clocksources, NULL);
993 static struct bus_type clocksource_subsys = {
994 .name = "clocksource",
995 .dev_name = "clocksource",
998 static struct device device_clocksource = {
1000 .bus = &clocksource_subsys,
1003 static int __init init_clocksource_sysfs(void)
1005 int error = subsys_system_register(&clocksource_subsys, NULL);
1008 error = device_register(&device_clocksource);
1010 error = device_create_file(
1011 &device_clocksource,
1012 &dev_attr_current_clocksource);
1014 error = device_create_file(&device_clocksource,
1015 &dev_attr_unbind_clocksource);
1017 error = device_create_file(
1018 &device_clocksource,
1019 &dev_attr_available_clocksource);
1023 device_initcall(init_clocksource_sysfs);
1024 #endif /* CONFIG_SYSFS */
1027 * boot_override_clocksource - boot clock override
1028 * @str: override name
1030 * Takes a clocksource= boot argument and uses it
1031 * as the clocksource override name.
1033 static int __init boot_override_clocksource(char* str)
1035 mutex_lock(&clocksource_mutex);
1037 strlcpy(override_name, str, sizeof(override_name));
1038 mutex_unlock(&clocksource_mutex);
1042 __setup("clocksource=", boot_override_clocksource);
1045 * boot_override_clock - Compatibility layer for deprecated boot option
1046 * @str: override name
1048 * DEPRECATED! Takes a clock= boot argument and uses it
1049 * as the clocksource override name
1051 static int __init boot_override_clock(char* str)
1053 if (!strcmp(str, "pmtmr")) {
1054 printk("Warning: clock=pmtmr is deprecated. "
1055 "Use clocksource=acpi_pm.\n");
1056 return boot_override_clocksource("acpi_pm");
1058 printk("Warning! clock= boot option is deprecated. "
1059 "Use clocksource=xyz\n");
1060 return boot_override_clocksource(str);
1063 __setup("clock=", boot_override_clock);