]> git.karo-electronics.de Git - karo-tx-linux.git/blob - kernel/time/clocksource.c
clocksource: Mostly kill clocksource_register()
[karo-tx-linux.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/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>
33
34 #include "tick-internal.h"
35 #include "timekeeping_internal.h"
36
37 /**
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
44  *
45  * The function evaluates the shift/mult pair for the scaled math
46  * operations of clocksources and clockevents.
47  *
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.
51  *
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
58  * factors.
59  */
60 void
61 clocks_calc_mult_shift(u32 *mult, u32 *shift, u32 from, u32 to, u32 maxsec)
62 {
63         u64 tmp;
64         u32 sft, sftacc= 32;
65
66         /*
67          * Calculate the shift factor which is limiting the conversion
68          * range:
69          */
70         tmp = ((u64)maxsec * from) >> 32;
71         while (tmp) {
72                 tmp >>=1;
73                 sftacc--;
74         }
75
76         /*
77          * Find the conversion shift/mult pair which has the best
78          * accuracy and fits the maxsec conversion range:
79          */
80         for (sft = 32; sft > 0; sft--) {
81                 tmp = (u64) to << sft;
82                 tmp += from / 2;
83                 do_div(tmp, from);
84                 if ((tmp >> sftacc) == 0)
85                         break;
86         }
87         *mult = tmp;
88         *shift = sft;
89 }
90
91 /*[Clocksource internal variables]---------
92  * curr_clocksource:
93  *      currently selected clocksource.
94  * clocksource_list:
95  *      linked list with the registered clocksources
96  * clocksource_mutex:
97  *      protects manipulations to curr_clocksource and the clocksource_list
98  * override_name:
99  *      Name of the user-specified clocksource.
100  */
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;
106
107 #ifdef CONFIG_CLOCKSOURCE_WATCHDOG
108 static void clocksource_watchdog_work(struct work_struct *work);
109 static void clocksource_select(void);
110
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;
118
119 static int clocksource_watchdog_kthread(void *data);
120 static void __clocksource_change_rating(struct clocksource *cs, int rating);
121
122 /*
123  * Interval: 0.5sec Threshold: 0.0625s
124  */
125 #define WATCHDOG_INTERVAL (HZ >> 1)
126 #define WATCHDOG_THRESHOLD (NSEC_PER_SEC >> 4)
127
128 static void clocksource_watchdog_work(struct work_struct *work)
129 {
130         /*
131          * If kthread_run fails the next watchdog scan over the
132          * watchdog_list will find the unstable clock again.
133          */
134         kthread_run(clocksource_watchdog_kthread, NULL, "kwatchdog");
135 }
136
137 static void __clocksource_unstable(struct clocksource *cs)
138 {
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);
143 }
144
145 /**
146  * clocksource_mark_unstable - mark clocksource unstable via watchdog
147  * @cs:         clocksource to be marked unstable
148  *
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.
153  */
154 void clocksource_mark_unstable(struct clocksource *cs)
155 {
156         unsigned long flags;
157
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);
163         }
164         spin_unlock_irqrestore(&watchdog_lock, flags);
165 }
166
167 static void clocksource_watchdog(unsigned long data)
168 {
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;
173
174         spin_lock(&watchdog_lock);
175         if (!watchdog_running)
176                 goto out;
177
178         reset_pending = atomic_read(&watchdog_reset_pending);
179
180         list_for_each_entry(cs, &watchdog_list, wd_list) {
181
182                 /* Clocksource already marked unstable? */
183                 if (cs->flags & CLOCK_SOURCE_UNSTABLE) {
184                         if (finished_booting)
185                                 schedule_work(&watchdog_work);
186                         continue;
187                 }
188
189                 local_irq_disable();
190                 csnow = cs->read(cs);
191                 wdnow = watchdog->read(watchdog);
192                 local_irq_enable();
193
194                 /* Clocksource initialized ? */
195                 if (!(cs->flags & CLOCK_SOURCE_WATCHDOG) ||
196                     atomic_read(&watchdog_reset_pending)) {
197                         cs->flags |= CLOCK_SOURCE_WATCHDOG;
198                         cs->wd_last = wdnow;
199                         cs->cs_last = csnow;
200                         continue;
201                 }
202
203                 delta = clocksource_delta(wdnow, cs->wd_last, watchdog->mask);
204                 wd_nsec = clocksource_cyc2ns(delta, watchdog->mult,
205                                              watchdog->shift);
206
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;
211                 cs->cs_last = csnow;
212                 cs->wd_last = wdnow;
213
214                 if (atomic_read(&watchdog_reset_pending))
215                         continue;
216
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);
225                         continue;
226                 }
227
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;
233
234                         /*
235                          * clocksource_done_booting() will sort it if
236                          * finished_booting is not set yet.
237                          */
238                         if (!finished_booting)
239                                 continue;
240
241                         /*
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
247                          * that change.
248                          */
249                         if (cs != curr_clocksource) {
250                                 cs->flags |= CLOCK_SOURCE_RESELECT;
251                                 schedule_work(&watchdog_work);
252                         } else {
253                                 tick_clock_notify();
254                         }
255                 }
256         }
257
258         /*
259          * We only clear the watchdog_reset_pending, when we did a
260          * full cycle through all clocksources.
261          */
262         if (reset_pending)
263                 atomic_dec(&watchdog_reset_pending);
264
265         /*
266          * Cycle through CPUs to check if the CPUs stay synchronized
267          * to each other.
268          */
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);
274 out:
275         spin_unlock(&watchdog_lock);
276 }
277
278 static inline void clocksource_start_watchdog(void)
279 {
280         if (watchdog_running || !watchdog || list_empty(&watchdog_list))
281                 return;
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;
287 }
288
289 static inline void clocksource_stop_watchdog(void)
290 {
291         if (!watchdog_running || (watchdog && !list_empty(&watchdog_list)))
292                 return;
293         del_timer(&watchdog_timer);
294         watchdog_running = 0;
295 }
296
297 static inline void clocksource_reset_watchdog(void)
298 {
299         struct clocksource *cs;
300
301         list_for_each_entry(cs, &watchdog_list, wd_list)
302                 cs->flags &= ~CLOCK_SOURCE_WATCHDOG;
303 }
304
305 static void clocksource_resume_watchdog(void)
306 {
307         atomic_inc(&watchdog_reset_pending);
308 }
309
310 static void clocksource_enqueue_watchdog(struct clocksource *cs)
311 {
312         unsigned long flags;
313
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;
319         } else {
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) {
325                         watchdog = cs;
326                         /* Reset watchdog cycles */
327                         clocksource_reset_watchdog();
328                 }
329         }
330         /* Check if the watchdog timer needs to be started. */
331         clocksource_start_watchdog();
332         spin_unlock_irqrestore(&watchdog_lock, flags);
333 }
334
335 static void clocksource_dequeue_watchdog(struct clocksource *cs)
336 {
337         unsigned long flags;
338
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();
346                 }
347         }
348         spin_unlock_irqrestore(&watchdog_lock, flags);
349 }
350
351 static int __clocksource_watchdog_kthread(void)
352 {
353         struct clocksource *cs, *tmp;
354         unsigned long flags;
355         LIST_HEAD(unstable);
356         int select = 0;
357
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);
363                         select = 1;
364                 }
365                 if (cs->flags & CLOCK_SOURCE_RESELECT) {
366                         cs->flags &= ~CLOCK_SOURCE_RESELECT;
367                         select = 1;
368                 }
369         }
370         /* Check if the watchdog timer needs to be stopped. */
371         clocksource_stop_watchdog();
372         spin_unlock_irqrestore(&watchdog_lock, flags);
373
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);
378         }
379         return select;
380 }
381
382 static int clocksource_watchdog_kthread(void *data)
383 {
384         mutex_lock(&clocksource_mutex);
385         if (__clocksource_watchdog_kthread())
386                 clocksource_select();
387         mutex_unlock(&clocksource_mutex);
388         return 0;
389 }
390
391 static bool clocksource_is_watchdog(struct clocksource *cs)
392 {
393         return cs == watchdog;
394 }
395
396 #else /* CONFIG_CLOCKSOURCE_WATCHDOG */
397
398 static void clocksource_enqueue_watchdog(struct clocksource *cs)
399 {
400         if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
401                 cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
402 }
403
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) { }
409
410 #endif /* CONFIG_CLOCKSOURCE_WATCHDOG */
411
412 /**
413  * clocksource_suspend - suspend the clocksource(s)
414  */
415 void clocksource_suspend(void)
416 {
417         struct clocksource *cs;
418
419         list_for_each_entry_reverse(cs, &clocksource_list, list)
420                 if (cs->suspend)
421                         cs->suspend(cs);
422 }
423
424 /**
425  * clocksource_resume - resume the clocksource(s)
426  */
427 void clocksource_resume(void)
428 {
429         struct clocksource *cs;
430
431         list_for_each_entry(cs, &clocksource_list, list)
432                 if (cs->resume)
433                         cs->resume(cs);
434
435         clocksource_resume_watchdog();
436 }
437
438 /**
439  * clocksource_touch_watchdog - Update watchdog
440  *
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.
444  */
445 void clocksource_touch_watchdog(void)
446 {
447         clocksource_resume_watchdog();
448 }
449
450 /**
451  * clocksource_max_adjustment- Returns max adjustment amount
452  * @cs:         Pointer to clocksource
453  *
454  */
455 static u32 clocksource_max_adjustment(struct clocksource *cs)
456 {
457         u64 ret;
458         /*
459          * We won't try to correct for more than 11% adjustments (110,000 ppm),
460          */
461         ret = (u64)cs->mult * 11;
462         do_div(ret,100);
463         return (u32)ret;
464 }
465
466 /**
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
473  *              any safety margin)
474  *
475  * NOTE: This function includes a safety margin of 50%, so that bad clock values
476  * can be detected.
477  */
478 u64 clocks_calc_max_nsecs(u32 mult, u32 shift, u32 maxadj, u64 mask, u64 *max_cyc)
479 {
480         u64 max_nsecs, max_cycles;
481
482         /*
483          * Calculate the maximum number of cycles that we can pass to the
484          * cyc2ns() function without overflowing a 64-bit result.
485          */
486         max_cycles = ULLONG_MAX;
487         do_div(max_cycles, mult+maxadj);
488
489         /*
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.
494          */
495         max_cycles = min(max_cycles, mask);
496         max_nsecs = clocksource_cyc2ns(max_cycles, mult - maxadj, shift);
497
498         /* return the max_cycles value as well if requested */
499         if (max_cyc)
500                 *max_cyc = max_cycles;
501
502         /* Return 50% of the actual maximum, so we can detect bad values */
503         max_nsecs >>= 1;
504
505         return max_nsecs;
506 }
507
508 /**
509  * clocksource_update_max_deferment - Updates the clocksource max_idle_ns & max_cycles
510  * @cs:         Pointer to clocksource to be updated
511  *
512  */
513 static inline void clocksource_update_max_deferment(struct clocksource *cs)
514 {
515         cs->max_idle_ns = clocks_calc_max_nsecs(cs->mult, cs->shift,
516                                                 cs->maxadj, cs->mask,
517                                                 &cs->max_cycles);
518 }
519
520 #ifndef CONFIG_ARCH_USES_GETTIMEOFFSET
521
522 static struct clocksource *clocksource_find_best(bool oneshot, bool skipcur)
523 {
524         struct clocksource *cs;
525
526         if (!finished_booting || list_empty(&clocksource_list))
527                 return NULL;
528
529         /*
530          * We pick the clocksource with the highest rating. If oneshot
531          * mode is active, we pick the highres valid clocksource with
532          * the best rating.
533          */
534         list_for_each_entry(cs, &clocksource_list, list) {
535                 if (skipcur && cs == curr_clocksource)
536                         continue;
537                 if (oneshot && !(cs->flags & CLOCK_SOURCE_VALID_FOR_HRES))
538                         continue;
539                 return cs;
540         }
541         return NULL;
542 }
543
544 static void __clocksource_select(bool skipcur)
545 {
546         bool oneshot = tick_oneshot_mode_active();
547         struct clocksource *best, *cs;
548
549         /* Find the best suitable clocksource */
550         best = clocksource_find_best(oneshot, skipcur);
551         if (!best)
552                 return;
553
554         /* Check for the override clocksource. */
555         list_for_each_entry(cs, &clocksource_list, list) {
556                 if (skipcur && cs == curr_clocksource)
557                         continue;
558                 if (strcmp(cs->name, override_name) != 0)
559                         continue;
560                 /*
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)
564                  */
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;
571                 } else
572                         /* Override clocksource can be used. */
573                         best = cs;
574                 break;
575         }
576
577         if (curr_clocksource != best && !timekeeping_notify(best)) {
578                 pr_info("Switched to clocksource %s\n", best->name);
579                 curr_clocksource = best;
580         }
581 }
582
583 /**
584  * clocksource_select - Select the best clocksource available
585  *
586  * Private function. Must hold clocksource_mutex when called.
587  *
588  * Select the clocksource with the best rating, or the clocksource,
589  * which is selected by userspace override.
590  */
591 static void clocksource_select(void)
592 {
593         return __clocksource_select(false);
594 }
595
596 static void clocksource_select_fallback(void)
597 {
598         return __clocksource_select(true);
599 }
600
601 #else /* !CONFIG_ARCH_USES_GETTIMEOFFSET */
602
603 static inline void clocksource_select(void) { }
604 static inline void clocksource_select_fallback(void) { }
605
606 #endif
607
608 /*
609  * clocksource_done_booting - Called near the end of core bootup
610  *
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.
614  */
615 static int __init clocksource_done_booting(void)
616 {
617         mutex_lock(&clocksource_mutex);
618         curr_clocksource = clocksource_default_clock();
619         finished_booting = 1;
620         /*
621          * Run the watchdog first to eliminate unstable clock sources
622          */
623         __clocksource_watchdog_kthread();
624         clocksource_select();
625         mutex_unlock(&clocksource_mutex);
626         return 0;
627 }
628 fs_initcall(clocksource_done_booting);
629
630 /*
631  * Enqueue the clocksource sorted by rating
632  */
633 static void clocksource_enqueue(struct clocksource *cs)
634 {
635         struct list_head *entry = &clocksource_list;
636         struct clocksource *tmp;
637
638         list_for_each_entry(tmp, &clocksource_list, list)
639                 /* Keep track of the place, where to insert */
640                 if (tmp->rating >= cs->rating)
641                         entry = &tmp->list;
642         list_add(&cs->list, entry);
643 }
644
645 /**
646  * __clocksource_updatefreq_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
650  *
651  * This should only be called from the clocksource->enable() method.
652  *
653  * This *SHOULD NOT* be called directly! Please use the
654  * clocksource_updatefreq_hz() or clocksource_updatefreq_khz helper functions.
655  */
656 void __clocksource_updatefreq_scale(struct clocksource *cs, u32 scale, u32 freq)
657 {
658         u64 sec;
659
660         /*
661          * Default clocksources are *special* and self-define their mult/shift.
662          * But, you're not special, so you should specify a freq value.
663          */
664         if (freq) {
665                 /*
666                  * Calc the maximum number of seconds which we can run before
667                  * wrapping around. For clocksources which have a mask > 32-bit
668                  * we need to limit the max sleep time to have a good
669                  * conversion precision. 10 minutes is still a reasonable
670                  * amount. That results in a shift value of 24 for a
671                  * clocksource with mask >= 40-bit and f >= 4GHz. That maps to
672                  * ~ 0.06ppm granularity for NTP.
673                  */
674                 sec = cs->mask;
675                 do_div(sec, freq);
676                 do_div(sec, scale);
677                 if (!sec)
678                         sec = 1;
679                 else if (sec > 600 && cs->mask > UINT_MAX)
680                         sec = 600;
681
682                 clocks_calc_mult_shift(&cs->mult, &cs->shift, freq,
683                                        NSEC_PER_SEC / scale, sec * scale);
684         }
685         /*
686          * Ensure clocksources that have large 'mult' values don't overflow
687          * when adjusted.
688          */
689         cs->maxadj = clocksource_max_adjustment(cs);
690         while (freq && ((cs->mult + cs->maxadj < cs->mult)
691                 || (cs->mult - cs->maxadj > cs->mult))) {
692                 cs->mult >>= 1;
693                 cs->shift--;
694                 cs->maxadj = clocksource_max_adjustment(cs);
695         }
696
697         /*
698          * Only warn for *special* clocksources that self-define
699          * their mult/shift values and don't specify a freq.
700          */
701         WARN_ONCE(cs->mult + cs->maxadj < cs->mult,
702                 "timekeeping: Clocksource %s might overflow on 11%% adjustment\n",
703                 cs->name);
704
705         clocksource_update_max_deferment(cs);
706 }
707 EXPORT_SYMBOL_GPL(__clocksource_updatefreq_scale);
708
709 /**
710  * __clocksource_register_scale - Used to install new clocksources
711  * @cs:         clocksource to be registered
712  * @scale:      Scale factor multiplied against freq to get clocksource hz
713  * @freq:       clocksource frequency (cycles per second) divided by scale
714  *
715  * Returns -EBUSY if registration fails, zero otherwise.
716  *
717  * This *SHOULD NOT* be called directly! Please use the
718  * clocksource_register_hz() or clocksource_register_khz helper functions.
719  */
720 int __clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq)
721 {
722
723         /* Initialize mult/shift and max_idle_ns */
724         __clocksource_updatefreq_scale(cs, scale, freq);
725
726         /* Add clocksource to the clocksource list */
727         mutex_lock(&clocksource_mutex);
728         clocksource_enqueue(cs);
729         clocksource_enqueue_watchdog(cs);
730         clocksource_select();
731         mutex_unlock(&clocksource_mutex);
732         return 0;
733 }
734 EXPORT_SYMBOL_GPL(__clocksource_register_scale);
735
736 static void __clocksource_change_rating(struct clocksource *cs, int rating)
737 {
738         list_del(&cs->list);
739         cs->rating = rating;
740         clocksource_enqueue(cs);
741 }
742
743 /**
744  * clocksource_change_rating - Change the rating of a registered clocksource
745  * @cs:         clocksource to be changed
746  * @rating:     new rating
747  */
748 void clocksource_change_rating(struct clocksource *cs, int rating)
749 {
750         mutex_lock(&clocksource_mutex);
751         __clocksource_change_rating(cs, rating);
752         clocksource_select();
753         mutex_unlock(&clocksource_mutex);
754 }
755 EXPORT_SYMBOL(clocksource_change_rating);
756
757 /*
758  * Unbind clocksource @cs. Called with clocksource_mutex held
759  */
760 static int clocksource_unbind(struct clocksource *cs)
761 {
762         /*
763          * I really can't convince myself to support this on hardware
764          * designed by lobotomized monkeys.
765          */
766         if (clocksource_is_watchdog(cs))
767                 return -EBUSY;
768
769         if (cs == curr_clocksource) {
770                 /* Select and try to install a replacement clock source */
771                 clocksource_select_fallback();
772                 if (curr_clocksource == cs)
773                         return -EBUSY;
774         }
775         clocksource_dequeue_watchdog(cs);
776         list_del_init(&cs->list);
777         return 0;
778 }
779
780 /**
781  * clocksource_unregister - remove a registered clocksource
782  * @cs: clocksource to be unregistered
783  */
784 int clocksource_unregister(struct clocksource *cs)
785 {
786         int ret = 0;
787
788         mutex_lock(&clocksource_mutex);
789         if (!list_empty(&cs->list))
790                 ret = clocksource_unbind(cs);
791         mutex_unlock(&clocksource_mutex);
792         return ret;
793 }
794 EXPORT_SYMBOL(clocksource_unregister);
795
796 #ifdef CONFIG_SYSFS
797 /**
798  * sysfs_show_current_clocksources - sysfs interface for current clocksource
799  * @dev:        unused
800  * @attr:       unused
801  * @buf:        char buffer to be filled with clocksource list
802  *
803  * Provides sysfs interface for listing current clocksource.
804  */
805 static ssize_t
806 sysfs_show_current_clocksources(struct device *dev,
807                                 struct device_attribute *attr, char *buf)
808 {
809         ssize_t count = 0;
810
811         mutex_lock(&clocksource_mutex);
812         count = snprintf(buf, PAGE_SIZE, "%s\n", curr_clocksource->name);
813         mutex_unlock(&clocksource_mutex);
814
815         return count;
816 }
817
818 ssize_t sysfs_get_uname(const char *buf, char *dst, size_t cnt)
819 {
820         size_t ret = cnt;
821
822         /* strings from sysfs write are not 0 terminated! */
823         if (!cnt || cnt >= CS_NAME_LEN)
824                 return -EINVAL;
825
826         /* strip of \n: */
827         if (buf[cnt-1] == '\n')
828                 cnt--;
829         if (cnt > 0)
830                 memcpy(dst, buf, cnt);
831         dst[cnt] = 0;
832         return ret;
833 }
834
835 /**
836  * sysfs_override_clocksource - interface for manually overriding clocksource
837  * @dev:        unused
838  * @attr:       unused
839  * @buf:        name of override clocksource
840  * @count:      length of buffer
841  *
842  * Takes input from sysfs interface for manually overriding the default
843  * clocksource selection.
844  */
845 static ssize_t sysfs_override_clocksource(struct device *dev,
846                                           struct device_attribute *attr,
847                                           const char *buf, size_t count)
848 {
849         ssize_t ret;
850
851         mutex_lock(&clocksource_mutex);
852
853         ret = sysfs_get_uname(buf, override_name, count);
854         if (ret >= 0)
855                 clocksource_select();
856
857         mutex_unlock(&clocksource_mutex);
858
859         return ret;
860 }
861
862 /**
863  * sysfs_unbind_current_clocksource - interface for manually unbinding clocksource
864  * @dev:        unused
865  * @attr:       unused
866  * @buf:        unused
867  * @count:      length of buffer
868  *
869  * Takes input from sysfs interface for manually unbinding a clocksource.
870  */
871 static ssize_t sysfs_unbind_clocksource(struct device *dev,
872                                         struct device_attribute *attr,
873                                         const char *buf, size_t count)
874 {
875         struct clocksource *cs;
876         char name[CS_NAME_LEN];
877         ssize_t ret;
878
879         ret = sysfs_get_uname(buf, name, count);
880         if (ret < 0)
881                 return ret;
882
883         ret = -ENODEV;
884         mutex_lock(&clocksource_mutex);
885         list_for_each_entry(cs, &clocksource_list, list) {
886                 if (strcmp(cs->name, name))
887                         continue;
888                 ret = clocksource_unbind(cs);
889                 break;
890         }
891         mutex_unlock(&clocksource_mutex);
892
893         return ret ? ret : count;
894 }
895
896 /**
897  * sysfs_show_available_clocksources - sysfs interface for listing clocksource
898  * @dev:        unused
899  * @attr:       unused
900  * @buf:        char buffer to be filled with clocksource list
901  *
902  * Provides sysfs interface for listing registered clocksources
903  */
904 static ssize_t
905 sysfs_show_available_clocksources(struct device *dev,
906                                   struct device_attribute *attr,
907                                   char *buf)
908 {
909         struct clocksource *src;
910         ssize_t count = 0;
911
912         mutex_lock(&clocksource_mutex);
913         list_for_each_entry(src, &clocksource_list, list) {
914                 /*
915                  * Don't show non-HRES clocksource if the tick code is
916                  * in one shot mode (highres=on or nohz=on)
917                  */
918                 if (!tick_oneshot_mode_active() ||
919                     (src->flags & CLOCK_SOURCE_VALID_FOR_HRES))
920                         count += snprintf(buf + count,
921                                   max((ssize_t)PAGE_SIZE - count, (ssize_t)0),
922                                   "%s ", src->name);
923         }
924         mutex_unlock(&clocksource_mutex);
925
926         count += snprintf(buf + count,
927                           max((ssize_t)PAGE_SIZE - count, (ssize_t)0), "\n");
928
929         return count;
930 }
931
932 /*
933  * Sysfs setup bits:
934  */
935 static DEVICE_ATTR(current_clocksource, 0644, sysfs_show_current_clocksources,
936                    sysfs_override_clocksource);
937
938 static DEVICE_ATTR(unbind_clocksource, 0200, NULL, sysfs_unbind_clocksource);
939
940 static DEVICE_ATTR(available_clocksource, 0444,
941                    sysfs_show_available_clocksources, NULL);
942
943 static struct bus_type clocksource_subsys = {
944         .name = "clocksource",
945         .dev_name = "clocksource",
946 };
947
948 static struct device device_clocksource = {
949         .id     = 0,
950         .bus    = &clocksource_subsys,
951 };
952
953 static int __init init_clocksource_sysfs(void)
954 {
955         int error = subsys_system_register(&clocksource_subsys, NULL);
956
957         if (!error)
958                 error = device_register(&device_clocksource);
959         if (!error)
960                 error = device_create_file(
961                                 &device_clocksource,
962                                 &dev_attr_current_clocksource);
963         if (!error)
964                 error = device_create_file(&device_clocksource,
965                                            &dev_attr_unbind_clocksource);
966         if (!error)
967                 error = device_create_file(
968                                 &device_clocksource,
969                                 &dev_attr_available_clocksource);
970         return error;
971 }
972
973 device_initcall(init_clocksource_sysfs);
974 #endif /* CONFIG_SYSFS */
975
976 /**
977  * boot_override_clocksource - boot clock override
978  * @str:        override name
979  *
980  * Takes a clocksource= boot argument and uses it
981  * as the clocksource override name.
982  */
983 static int __init boot_override_clocksource(char* str)
984 {
985         mutex_lock(&clocksource_mutex);
986         if (str)
987                 strlcpy(override_name, str, sizeof(override_name));
988         mutex_unlock(&clocksource_mutex);
989         return 1;
990 }
991
992 __setup("clocksource=", boot_override_clocksource);
993
994 /**
995  * boot_override_clock - Compatibility layer for deprecated boot option
996  * @str:        override name
997  *
998  * DEPRECATED! Takes a clock= boot argument and uses it
999  * as the clocksource override name
1000  */
1001 static int __init boot_override_clock(char* str)
1002 {
1003         if (!strcmp(str, "pmtmr")) {
1004                 printk("Warning: clock=pmtmr is deprecated. "
1005                         "Use clocksource=acpi_pm.\n");
1006                 return boot_override_clocksource("acpi_pm");
1007         }
1008         printk("Warning! clock= boot option is deprecated. "
1009                 "Use clocksource=xyz\n");
1010         return boot_override_clocksource(str);
1011 }
1012
1013 __setup("clock=", boot_override_clock);