bd246660902c95b0345dfafd6afc9e0eaaf31057
[linux-2.6.git] / kernel / time / clocksource.c
1 /*
2  * linux/kernel/time/clocksource.c
3  *
4  * This file contains the functions which manage clocksource drivers.
5  *
6  * Copyright (C) 2004, 2005 IBM, John Stultz (johnstul@us.ibm.com)
7  *
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.
12  *
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.
17  *
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.
21  *
22  * TODO WishList:
23  *   o Allow clocksource drivers to be unregistered
24  */
25
26 #include <linux/clocksource.h>
27 #include <linux/sysdev.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>
33
34 void timecounter_init(struct timecounter *tc,
35                       const struct cyclecounter *cc,
36                       u64 start_tstamp)
37 {
38         tc->cc = cc;
39         tc->cycle_last = cc->read(cc);
40         tc->nsec = start_tstamp;
41 }
42 EXPORT_SYMBOL_GPL(timecounter_init);
43
44 /**
45  * timecounter_read_delta - get nanoseconds since last call of this function
46  * @tc:         Pointer to time counter
47  *
48  * When the underlying cycle counter runs over, this will be handled
49  * correctly as long as it does not run over more than once between
50  * calls.
51  *
52  * The first call to this function for a new time counter initializes
53  * the time tracking and returns an undefined result.
54  */
55 static u64 timecounter_read_delta(struct timecounter *tc)
56 {
57         cycle_t cycle_now, cycle_delta;
58         u64 ns_offset;
59
60         /* read cycle counter: */
61         cycle_now = tc->cc->read(tc->cc);
62
63         /* calculate the delta since the last timecounter_read_delta(): */
64         cycle_delta = (cycle_now - tc->cycle_last) & tc->cc->mask;
65
66         /* convert to nanoseconds: */
67         ns_offset = cyclecounter_cyc2ns(tc->cc, cycle_delta);
68
69         /* update time stamp of timecounter_read_delta() call: */
70         tc->cycle_last = cycle_now;
71
72         return ns_offset;
73 }
74
75 u64 timecounter_read(struct timecounter *tc)
76 {
77         u64 nsec;
78
79         /* increment time by nanoseconds since last call */
80         nsec = timecounter_read_delta(tc);
81         nsec += tc->nsec;
82         tc->nsec = nsec;
83
84         return nsec;
85 }
86 EXPORT_SYMBOL_GPL(timecounter_read);
87
88 u64 timecounter_cyc2time(struct timecounter *tc,
89                          cycle_t cycle_tstamp)
90 {
91         u64 cycle_delta = (cycle_tstamp - tc->cycle_last) & tc->cc->mask;
92         u64 nsec;
93
94         /*
95          * Instead of always treating cycle_tstamp as more recent
96          * than tc->cycle_last, detect when it is too far in the
97          * future and treat it as old time stamp instead.
98          */
99         if (cycle_delta > tc->cc->mask / 2) {
100                 cycle_delta = (tc->cycle_last - cycle_tstamp) & tc->cc->mask;
101                 nsec = tc->nsec - cyclecounter_cyc2ns(tc->cc, cycle_delta);
102         } else {
103                 nsec = cyclecounter_cyc2ns(tc->cc, cycle_delta) + tc->nsec;
104         }
105
106         return nsec;
107 }
108 EXPORT_SYMBOL_GPL(timecounter_cyc2time);
109
110 /**
111  * clocks_calc_mult_shift - calculate mult/shift factors for scaled math of clocks
112  * @mult:       pointer to mult variable
113  * @shift:      pointer to shift variable
114  * @from:       frequency to convert from
115  * @to:         frequency to convert to
116  * @minsec:     guaranteed runtime conversion range in seconds
117  *
118  * The function evaluates the shift/mult pair for the scaled math
119  * operations of clocksources and clockevents.
120  *
121  * @to and @from are frequency values in HZ. For clock sources @to is
122  * NSEC_PER_SEC == 1GHz and @from is the counter frequency. For clock
123  * event @to is the counter frequency and @from is NSEC_PER_SEC.
124  *
125  * The @minsec conversion range argument controls the time frame in
126  * seconds which must be covered by the runtime conversion with the
127  * calculated mult and shift factors. This guarantees that no 64bit
128  * overflow happens when the input value of the conversion is
129  * multiplied with the calculated mult factor. Larger ranges may
130  * reduce the conversion accuracy by chosing smaller mult and shift
131  * factors.
132  */
133 void
134 clocks_calc_mult_shift(u32 *mult, u32 *shift, u32 from, u32 to, u32 minsec)
135 {
136         u64 tmp;
137         u32 sft, sftacc= 32;
138
139         /*
140          * Calculate the shift factor which is limiting the conversion
141          * range:
142          */
143         tmp = ((u64)minsec * from) >> 32;
144         while (tmp) {
145                 tmp >>=1;
146                 sftacc--;
147         }
148
149         /*
150          * Find the conversion shift/mult pair which has the best
151          * accuracy and fits the maxsec conversion range:
152          */
153         for (sft = 32; sft > 0; sft--) {
154                 tmp = (u64) to << sft;
155                 do_div(tmp, from);
156                 if ((tmp >> sftacc) == 0)
157                         break;
158         }
159         *mult = tmp;
160         *shift = sft;
161 }
162
163 /*[Clocksource internal variables]---------
164  * curr_clocksource:
165  *      currently selected clocksource.
166  * clocksource_list:
167  *      linked list with the registered clocksources
168  * clocksource_mutex:
169  *      protects manipulations to curr_clocksource and the clocksource_list
170  * override_name:
171  *      Name of the user-specified clocksource.
172  */
173 static struct clocksource *curr_clocksource;
174 static LIST_HEAD(clocksource_list);
175 static DEFINE_MUTEX(clocksource_mutex);
176 static char override_name[32];
177 static int finished_booting;
178
179 #ifdef CONFIG_CLOCKSOURCE_WATCHDOG
180 static void clocksource_watchdog_work(struct work_struct *work);
181
182 static LIST_HEAD(watchdog_list);
183 static struct clocksource *watchdog;
184 static struct timer_list watchdog_timer;
185 static DECLARE_WORK(watchdog_work, clocksource_watchdog_work);
186 static DEFINE_SPINLOCK(watchdog_lock);
187 static cycle_t watchdog_last;
188 static int watchdog_running;
189
190 static int clocksource_watchdog_kthread(void *data);
191 static void __clocksource_change_rating(struct clocksource *cs, int rating);
192
193 /*
194  * Interval: 0.5sec Threshold: 0.0625s
195  */
196 #define WATCHDOG_INTERVAL (HZ >> 1)
197 #define WATCHDOG_THRESHOLD (NSEC_PER_SEC >> 4)
198
199 static void clocksource_watchdog_work(struct work_struct *work)
200 {
201         /*
202          * If kthread_run fails the next watchdog scan over the
203          * watchdog_list will find the unstable clock again.
204          */
205         kthread_run(clocksource_watchdog_kthread, NULL, "kwatchdog");
206 }
207
208 static void __clocksource_unstable(struct clocksource *cs)
209 {
210         cs->flags &= ~(CLOCK_SOURCE_VALID_FOR_HRES | CLOCK_SOURCE_WATCHDOG);
211         cs->flags |= CLOCK_SOURCE_UNSTABLE;
212         if (finished_booting)
213                 schedule_work(&watchdog_work);
214 }
215
216 static void clocksource_unstable(struct clocksource *cs, int64_t delta)
217 {
218         printk(KERN_WARNING "Clocksource %s unstable (delta = %Ld ns)\n",
219                cs->name, delta);
220         __clocksource_unstable(cs);
221 }
222
223 /**
224  * clocksource_mark_unstable - mark clocksource unstable via watchdog
225  * @cs:         clocksource to be marked unstable
226  *
227  * This function is called instead of clocksource_change_rating from
228  * cpu hotplug code to avoid a deadlock between the clocksource mutex
229  * and the cpu hotplug mutex. It defers the update of the clocksource
230  * to the watchdog thread.
231  */
232 void clocksource_mark_unstable(struct clocksource *cs)
233 {
234         unsigned long flags;
235
236         spin_lock_irqsave(&watchdog_lock, flags);
237         if (!(cs->flags & CLOCK_SOURCE_UNSTABLE)) {
238                 if (list_empty(&cs->wd_list))
239                         list_add(&cs->wd_list, &watchdog_list);
240                 __clocksource_unstable(cs);
241         }
242         spin_unlock_irqrestore(&watchdog_lock, flags);
243 }
244
245 static void clocksource_watchdog(unsigned long data)
246 {
247         struct clocksource *cs;
248         cycle_t csnow, wdnow;
249         int64_t wd_nsec, cs_nsec;
250         int next_cpu;
251
252         spin_lock(&watchdog_lock);
253         if (!watchdog_running)
254                 goto out;
255
256         wdnow = watchdog->read(watchdog);
257         wd_nsec = clocksource_cyc2ns((wdnow - watchdog_last) & watchdog->mask,
258                                      watchdog->mult, watchdog->shift);
259         watchdog_last = wdnow;
260
261         list_for_each_entry(cs, &watchdog_list, wd_list) {
262
263                 /* Clocksource already marked unstable? */
264                 if (cs->flags & CLOCK_SOURCE_UNSTABLE) {
265                         if (finished_booting)
266                                 schedule_work(&watchdog_work);
267                         continue;
268                 }
269
270                 csnow = cs->read(cs);
271
272                 /* Clocksource initialized ? */
273                 if (!(cs->flags & CLOCK_SOURCE_WATCHDOG)) {
274                         cs->flags |= CLOCK_SOURCE_WATCHDOG;
275                         cs->wd_last = csnow;
276                         continue;
277                 }
278
279                 /* Check the deviation from the watchdog clocksource. */
280                 cs_nsec = clocksource_cyc2ns((csnow - cs->wd_last) &
281                                              cs->mask, cs->mult, cs->shift);
282                 cs->wd_last = csnow;
283                 if (abs(cs_nsec - wd_nsec) > WATCHDOG_THRESHOLD) {
284                         clocksource_unstable(cs, cs_nsec - wd_nsec);
285                         continue;
286                 }
287
288                 if (!(cs->flags & CLOCK_SOURCE_VALID_FOR_HRES) &&
289                     (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) &&
290                     (watchdog->flags & CLOCK_SOURCE_IS_CONTINUOUS)) {
291                         cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
292                         /*
293                          * We just marked the clocksource as highres-capable,
294                          * notify the rest of the system as well so that we
295                          * transition into high-res mode:
296                          */
297                         tick_clock_notify();
298                 }
299         }
300
301         /*
302          * Cycle through CPUs to check if the CPUs stay synchronized
303          * to each other.
304          */
305         next_cpu = cpumask_next(raw_smp_processor_id(), cpu_online_mask);
306         if (next_cpu >= nr_cpu_ids)
307                 next_cpu = cpumask_first(cpu_online_mask);
308         watchdog_timer.expires += WATCHDOG_INTERVAL;
309         add_timer_on(&watchdog_timer, next_cpu);
310 out:
311         spin_unlock(&watchdog_lock);
312 }
313
314 static inline void clocksource_start_watchdog(void)
315 {
316         if (watchdog_running || !watchdog || list_empty(&watchdog_list))
317                 return;
318         init_timer(&watchdog_timer);
319         watchdog_timer.function = clocksource_watchdog;
320         watchdog_last = watchdog->read(watchdog);
321         watchdog_timer.expires = jiffies + WATCHDOG_INTERVAL;
322         add_timer_on(&watchdog_timer, cpumask_first(cpu_online_mask));
323         watchdog_running = 1;
324 }
325
326 static inline void clocksource_stop_watchdog(void)
327 {
328         if (!watchdog_running || (watchdog && !list_empty(&watchdog_list)))
329                 return;
330         del_timer(&watchdog_timer);
331         watchdog_running = 0;
332 }
333
334 static inline void clocksource_reset_watchdog(void)
335 {
336         struct clocksource *cs;
337
338         list_for_each_entry(cs, &watchdog_list, wd_list)
339                 cs->flags &= ~CLOCK_SOURCE_WATCHDOG;
340 }
341
342 static void clocksource_resume_watchdog(void)
343 {
344         unsigned long flags;
345
346         spin_lock_irqsave(&watchdog_lock, flags);
347         clocksource_reset_watchdog();
348         spin_unlock_irqrestore(&watchdog_lock, flags);
349 }
350
351 static void clocksource_enqueue_watchdog(struct clocksource *cs)
352 {
353         unsigned long flags;
354
355         spin_lock_irqsave(&watchdog_lock, flags);
356         if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) {
357                 /* cs is a clocksource to be watched. */
358                 list_add(&cs->wd_list, &watchdog_list);
359                 cs->flags &= ~CLOCK_SOURCE_WATCHDOG;
360         } else {
361                 /* cs is a watchdog. */
362                 if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
363                         cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
364                 /* Pick the best watchdog. */
365                 if (!watchdog || cs->rating > watchdog->rating) {
366                         watchdog = cs;
367                         /* Reset watchdog cycles */
368                         clocksource_reset_watchdog();
369                 }
370         }
371         /* Check if the watchdog timer needs to be started. */
372         clocksource_start_watchdog();
373         spin_unlock_irqrestore(&watchdog_lock, flags);
374 }
375
376 static void clocksource_dequeue_watchdog(struct clocksource *cs)
377 {
378         struct clocksource *tmp;
379         unsigned long flags;
380
381         spin_lock_irqsave(&watchdog_lock, flags);
382         if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) {
383                 /* cs is a watched clocksource. */
384                 list_del_init(&cs->wd_list);
385         } else if (cs == watchdog) {
386                 /* Reset watchdog cycles */
387                 clocksource_reset_watchdog();
388                 /* Current watchdog is removed. Find an alternative. */
389                 watchdog = NULL;
390                 list_for_each_entry(tmp, &clocksource_list, list) {
391                         if (tmp == cs || tmp->flags & CLOCK_SOURCE_MUST_VERIFY)
392                                 continue;
393                         if (!watchdog || tmp->rating > watchdog->rating)
394                                 watchdog = tmp;
395                 }
396         }
397         cs->flags &= ~CLOCK_SOURCE_WATCHDOG;
398         /* Check if the watchdog timer needs to be stopped. */
399         clocksource_stop_watchdog();
400         spin_unlock_irqrestore(&watchdog_lock, flags);
401 }
402
403 static int clocksource_watchdog_kthread(void *data)
404 {
405         struct clocksource *cs, *tmp;
406         unsigned long flags;
407         LIST_HEAD(unstable);
408
409         mutex_lock(&clocksource_mutex);
410         spin_lock_irqsave(&watchdog_lock, flags);
411         list_for_each_entry_safe(cs, tmp, &watchdog_list, wd_list)
412                 if (cs->flags & CLOCK_SOURCE_UNSTABLE) {
413                         list_del_init(&cs->wd_list);
414                         list_add(&cs->wd_list, &unstable);
415                 }
416         /* Check if the watchdog timer needs to be stopped. */
417         clocksource_stop_watchdog();
418         spin_unlock_irqrestore(&watchdog_lock, flags);
419
420         /* Needs to be done outside of watchdog lock */
421         list_for_each_entry_safe(cs, tmp, &unstable, wd_list) {
422                 list_del_init(&cs->wd_list);
423                 __clocksource_change_rating(cs, 0);
424         }
425         mutex_unlock(&clocksource_mutex);
426         return 0;
427 }
428
429 #else /* CONFIG_CLOCKSOURCE_WATCHDOG */
430
431 static void clocksource_enqueue_watchdog(struct clocksource *cs)
432 {
433         if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
434                 cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
435 }
436
437 static inline void clocksource_dequeue_watchdog(struct clocksource *cs) { }
438 static inline void clocksource_resume_watchdog(void) { }
439 static inline int clocksource_watchdog_kthread(void *data) { return 0; }
440
441 #endif /* CONFIG_CLOCKSOURCE_WATCHDOG */
442
443 /**
444  * clocksource_suspend - suspend the clocksource(s)
445  */
446 void clocksource_suspend(void)
447 {
448         struct clocksource *cs;
449
450         list_for_each_entry_reverse(cs, &clocksource_list, list)
451                 if (cs->suspend)
452                         cs->suspend(cs);
453 }
454
455 /**
456  * clocksource_resume - resume the clocksource(s)
457  */
458 void clocksource_resume(void)
459 {
460         struct clocksource *cs;
461
462         list_for_each_entry(cs, &clocksource_list, list)
463                 if (cs->resume)
464                         cs->resume(cs);
465
466         clocksource_resume_watchdog();
467 }
468
469 /**
470  * clocksource_touch_watchdog - Update watchdog
471  *
472  * Update the watchdog after exception contexts such as kgdb so as not
473  * to incorrectly trip the watchdog.
474  *
475  */
476 void clocksource_touch_watchdog(void)
477 {
478         clocksource_resume_watchdog();
479 }
480
481 /**
482  * clocksource_max_deferment - Returns max time the clocksource can be deferred
483  * @cs:         Pointer to clocksource
484  *
485  */
486 static u64 clocksource_max_deferment(struct clocksource *cs)
487 {
488         u64 max_nsecs, max_cycles;
489
490         /*
491          * Calculate the maximum number of cycles that we can pass to the
492          * cyc2ns function without overflowing a 64-bit signed result. The
493          * maximum number of cycles is equal to ULLONG_MAX/cs->mult which
494          * is equivalent to the below.
495          * max_cycles < (2^63)/cs->mult
496          * max_cycles < 2^(log2((2^63)/cs->mult))
497          * max_cycles < 2^(log2(2^63) - log2(cs->mult))
498          * max_cycles < 2^(63 - log2(cs->mult))
499          * max_cycles < 1 << (63 - log2(cs->mult))
500          * Please note that we add 1 to the result of the log2 to account for
501          * any rounding errors, ensure the above inequality is satisfied and
502          * no overflow will occur.
503          */
504         max_cycles = 1ULL << (63 - (ilog2(cs->mult) + 1));
505
506         /*
507          * The actual maximum number of cycles we can defer the clocksource is
508          * determined by the minimum of max_cycles and cs->mask.
509          */
510         max_cycles = min_t(u64, max_cycles, (u64) cs->mask);
511         max_nsecs = clocksource_cyc2ns(max_cycles, cs->mult, cs->shift);
512
513         /*
514          * To ensure that the clocksource does not wrap whilst we are idle,
515          * limit the time the clocksource can be deferred by 12.5%. Please
516          * note a margin of 12.5% is used because this can be computed with
517          * a shift, versus say 10% which would require division.
518          */
519         return max_nsecs - (max_nsecs >> 5);
520 }
521
522 #ifdef CONFIG_GENERIC_TIME
523
524 /**
525  * clocksource_select - Select the best clocksource available
526  *
527  * Private function. Must hold clocksource_mutex when called.
528  *
529  * Select the clocksource with the best rating, or the clocksource,
530  * which is selected by userspace override.
531  */
532 static void clocksource_select(void)
533 {
534         struct clocksource *best, *cs;
535
536         if (!finished_booting || list_empty(&clocksource_list))
537                 return;
538         /* First clocksource on the list has the best rating. */
539         best = list_first_entry(&clocksource_list, struct clocksource, list);
540         /* Check for the override clocksource. */
541         list_for_each_entry(cs, &clocksource_list, list) {
542                 if (strcmp(cs->name, override_name) != 0)
543                         continue;
544                 /*
545                  * Check to make sure we don't switch to a non-highres
546                  * capable clocksource if the tick code is in oneshot
547                  * mode (highres or nohz)
548                  */
549                 if (!(cs->flags & CLOCK_SOURCE_VALID_FOR_HRES) &&
550                     tick_oneshot_mode_active()) {
551                         /* Override clocksource cannot be used. */
552                         printk(KERN_WARNING "Override clocksource %s is not "
553                                "HRT compatible. Cannot switch while in "
554                                "HRT/NOHZ mode\n", cs->name);
555                         override_name[0] = 0;
556                 } else
557                         /* Override clocksource can be used. */
558                         best = cs;
559                 break;
560         }
561         if (curr_clocksource != best) {
562                 printk(KERN_INFO "Switching to clocksource %s\n", best->name);
563                 curr_clocksource = best;
564                 timekeeping_notify(curr_clocksource);
565         }
566 }
567
568 #else /* CONFIG_GENERIC_TIME */
569
570 static inline void clocksource_select(void) { }
571
572 #endif
573
574 /*
575  * clocksource_done_booting - Called near the end of core bootup
576  *
577  * Hack to avoid lots of clocksource churn at boot time.
578  * We use fs_initcall because we want this to start before
579  * device_initcall but after subsys_initcall.
580  */
581 static int __init clocksource_done_booting(void)
582 {
583         finished_booting = 1;
584
585         /*
586          * Run the watchdog first to eliminate unstable clock sources
587          */
588         clocksource_watchdog_kthread(NULL);
589
590         mutex_lock(&clocksource_mutex);
591         clocksource_select();
592         mutex_unlock(&clocksource_mutex);
593         return 0;
594 }
595 fs_initcall(clocksource_done_booting);
596
597 /*
598  * Enqueue the clocksource sorted by rating
599  */
600 static void clocksource_enqueue(struct clocksource *cs)
601 {
602         struct list_head *entry = &clocksource_list;
603         struct clocksource *tmp;
604
605         list_for_each_entry(tmp, &clocksource_list, list)
606                 /* Keep track of the place, where to insert */
607                 if (tmp->rating >= cs->rating)
608                         entry = &tmp->list;
609         list_add(&cs->list, entry);
610 }
611
612 /**
613  * clocksource_register - Used to install new clocksources
614  * @t:          clocksource to be registered
615  *
616  * Returns -EBUSY if registration fails, zero otherwise.
617  */
618 int clocksource_register(struct clocksource *cs)
619 {
620         /* calculate max idle time permitted for this clocksource */
621         cs->max_idle_ns = clocksource_max_deferment(cs);
622
623         mutex_lock(&clocksource_mutex);
624         clocksource_enqueue(cs);
625         clocksource_select();
626         clocksource_enqueue_watchdog(cs);
627         mutex_unlock(&clocksource_mutex);
628         return 0;
629 }
630 EXPORT_SYMBOL(clocksource_register);
631
632 static void __clocksource_change_rating(struct clocksource *cs, int rating)
633 {
634         list_del(&cs->list);
635         cs->rating = rating;
636         clocksource_enqueue(cs);
637         clocksource_select();
638 }
639
640 /**
641  * clocksource_change_rating - Change the rating of a registered clocksource
642  */
643 void clocksource_change_rating(struct clocksource *cs, int rating)
644 {
645         mutex_lock(&clocksource_mutex);
646         __clocksource_change_rating(cs, rating);
647         mutex_unlock(&clocksource_mutex);
648 }
649 EXPORT_SYMBOL(clocksource_change_rating);
650
651 /**
652  * clocksource_unregister - remove a registered clocksource
653  */
654 void clocksource_unregister(struct clocksource *cs)
655 {
656         mutex_lock(&clocksource_mutex);
657         clocksource_dequeue_watchdog(cs);
658         list_del(&cs->list);
659         clocksource_select();
660         mutex_unlock(&clocksource_mutex);
661 }
662 EXPORT_SYMBOL(clocksource_unregister);
663
664 #ifdef CONFIG_SYSFS
665 /**
666  * sysfs_show_current_clocksources - sysfs interface for current clocksource
667  * @dev:        unused
668  * @buf:        char buffer to be filled with clocksource list
669  *
670  * Provides sysfs interface for listing current clocksource.
671  */
672 static ssize_t
673 sysfs_show_current_clocksources(struct sys_device *dev,
674                                 struct sysdev_attribute *attr, char *buf)
675 {
676         ssize_t count = 0;
677
678         mutex_lock(&clocksource_mutex);
679         count = snprintf(buf, PAGE_SIZE, "%s\n", curr_clocksource->name);
680         mutex_unlock(&clocksource_mutex);
681
682         return count;
683 }
684
685 /**
686  * sysfs_override_clocksource - interface for manually overriding clocksource
687  * @dev:        unused
688  * @buf:        name of override clocksource
689  * @count:      length of buffer
690  *
691  * Takes input from sysfs interface for manually overriding the default
692  * clocksource selection.
693  */
694 static ssize_t sysfs_override_clocksource(struct sys_device *dev,
695                                           struct sysdev_attribute *attr,
696                                           const char *buf, size_t count)
697 {
698         size_t ret = count;
699
700         /* strings from sysfs write are not 0 terminated! */
701         if (count >= sizeof(override_name))
702                 return -EINVAL;
703
704         /* strip of \n: */
705         if (buf[count-1] == '\n')
706                 count--;
707
708         mutex_lock(&clocksource_mutex);
709
710         if (count > 0)
711                 memcpy(override_name, buf, count);
712         override_name[count] = 0;
713         clocksource_select();
714
715         mutex_unlock(&clocksource_mutex);
716
717         return ret;
718 }
719
720 /**
721  * sysfs_show_available_clocksources - sysfs interface for listing clocksource
722  * @dev:        unused
723  * @buf:        char buffer to be filled with clocksource list
724  *
725  * Provides sysfs interface for listing registered clocksources
726  */
727 static ssize_t
728 sysfs_show_available_clocksources(struct sys_device *dev,
729                                   struct sysdev_attribute *attr,
730                                   char *buf)
731 {
732         struct clocksource *src;
733         ssize_t count = 0;
734
735         mutex_lock(&clocksource_mutex);
736         list_for_each_entry(src, &clocksource_list, list) {
737                 /*
738                  * Don't show non-HRES clocksource if the tick code is
739                  * in one shot mode (highres=on or nohz=on)
740                  */
741                 if (!tick_oneshot_mode_active() ||
742                     (src->flags & CLOCK_SOURCE_VALID_FOR_HRES))
743                         count += snprintf(buf + count,
744                                   max((ssize_t)PAGE_SIZE - count, (ssize_t)0),
745                                   "%s ", src->name);
746         }
747         mutex_unlock(&clocksource_mutex);
748
749         count += snprintf(buf + count,
750                           max((ssize_t)PAGE_SIZE - count, (ssize_t)0), "\n");
751
752         return count;
753 }
754
755 /*
756  * Sysfs setup bits:
757  */
758 static SYSDEV_ATTR(current_clocksource, 0644, sysfs_show_current_clocksources,
759                    sysfs_override_clocksource);
760
761 static SYSDEV_ATTR(available_clocksource, 0444,
762                    sysfs_show_available_clocksources, NULL);
763
764 static struct sysdev_class clocksource_sysclass = {
765         .name = "clocksource",
766 };
767
768 static struct sys_device device_clocksource = {
769         .id     = 0,
770         .cls    = &clocksource_sysclass,
771 };
772
773 static int __init init_clocksource_sysfs(void)
774 {
775         int error = sysdev_class_register(&clocksource_sysclass);
776
777         if (!error)
778                 error = sysdev_register(&device_clocksource);
779         if (!error)
780                 error = sysdev_create_file(
781                                 &device_clocksource,
782                                 &attr_current_clocksource);
783         if (!error)
784                 error = sysdev_create_file(
785                                 &device_clocksource,
786                                 &attr_available_clocksource);
787         return error;
788 }
789
790 device_initcall(init_clocksource_sysfs);
791 #endif /* CONFIG_SYSFS */
792
793 /**
794  * boot_override_clocksource - boot clock override
795  * @str:        override name
796  *
797  * Takes a clocksource= boot argument and uses it
798  * as the clocksource override name.
799  */
800 static int __init boot_override_clocksource(char* str)
801 {
802         mutex_lock(&clocksource_mutex);
803         if (str)
804                 strlcpy(override_name, str, sizeof(override_name));
805         mutex_unlock(&clocksource_mutex);
806         return 1;
807 }
808
809 __setup("clocksource=", boot_override_clocksource);
810
811 /**
812  * boot_override_clock - Compatibility layer for deprecated boot option
813  * @str:        override name
814  *
815  * DEPRECATED! Takes a clock= boot argument and uses it
816  * as the clocksource override name
817  */
818 static int __init boot_override_clock(char* str)
819 {
820         if (!strcmp(str, "pmtmr")) {
821                 printk("Warning: clock=pmtmr is deprecated. "
822                         "Use clocksource=acpi_pm.\n");
823                 return boot_override_clocksource("acpi_pm");
824         }
825         printk("Warning! clock= boot option is deprecated. "
826                 "Use clocksource=xyz\n");
827         return boot_override_clocksource(str);
828 }
829
830 __setup("clock=", boot_override_clock);