• Home
  • History
  • Annotate
  • Line#
  • Navigate
  • Raw
  • Download
  • only in /netgear-R7000-V1.0.7.12_1.2.5/components/opensource/linux/linux-2.6.36/kernel/time/
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
34void 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}
42EXPORT_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 */
55static 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
75u64 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}
86EXPORT_SYMBOL_GPL(timecounter_read);
87
88u64 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}
108EXPORT_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 */
133void
134clocks_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 */
173static struct clocksource *curr_clocksource;
174static LIST_HEAD(clocksource_list);
175static DEFINE_MUTEX(clocksource_mutex);
176static char override_name[32];
177static int finished_booting;
178
179#ifdef CONFIG_CLOCKSOURCE_WATCHDOG
180static void clocksource_watchdog_work(struct work_struct *work);
181
182static LIST_HEAD(watchdog_list);
183static struct clocksource *watchdog;
184static struct timer_list watchdog_timer;
185static DECLARE_WORK(watchdog_work, clocksource_watchdog_work);
186static DEFINE_SPINLOCK(watchdog_lock);
187static cycle_t watchdog_last;
188static int watchdog_running;
189
190static int clocksource_watchdog_kthread(void *data);
191static 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
199static 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
208static 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
216static 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 */
232void 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
245static 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);
310out:
311	spin_unlock(&watchdog_lock);
312}
313
314static 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
326static 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
334static 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
342static void clocksource_resume_watchdog(void)
343{
344	unsigned long flags;
345
346	/*
347	 * We use trylock here to avoid a potential dead lock when
348	 * kgdb calls this code after the kernel has been stopped with
349	 * watchdog_lock held. When watchdog_lock is held we just
350	 * return and accept, that the watchdog might trigger and mark
351	 * the monitored clock source (usually TSC) unstable.
352	 *
353	 * This does not affect the other caller clocksource_resume()
354	 * because at this point the kernel is UP, interrupts are
355	 * disabled and nothing can hold watchdog_lock.
356	 */
357	if (!spin_trylock_irqsave(&watchdog_lock, flags))
358		return;
359	clocksource_reset_watchdog();
360	spin_unlock_irqrestore(&watchdog_lock, flags);
361}
362
363static void clocksource_enqueue_watchdog(struct clocksource *cs)
364{
365	unsigned long flags;
366
367	spin_lock_irqsave(&watchdog_lock, flags);
368	if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) {
369		/* cs is a clocksource to be watched. */
370		list_add(&cs->wd_list, &watchdog_list);
371		cs->flags &= ~CLOCK_SOURCE_WATCHDOG;
372	} else {
373		/* cs is a watchdog. */
374		if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
375			cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
376		/* Pick the best watchdog. */
377		if (!watchdog || cs->rating > watchdog->rating) {
378			watchdog = cs;
379			/* Reset watchdog cycles */
380			clocksource_reset_watchdog();
381		}
382	}
383	/* Check if the watchdog timer needs to be started. */
384	clocksource_start_watchdog();
385	spin_unlock_irqrestore(&watchdog_lock, flags);
386}
387
388static void clocksource_dequeue_watchdog(struct clocksource *cs)
389{
390	struct clocksource *tmp;
391	unsigned long flags;
392
393	spin_lock_irqsave(&watchdog_lock, flags);
394	if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) {
395		/* cs is a watched clocksource. */
396		list_del_init(&cs->wd_list);
397	} else if (cs == watchdog) {
398		/* Reset watchdog cycles */
399		clocksource_reset_watchdog();
400		/* Current watchdog is removed. Find an alternative. */
401		watchdog = NULL;
402		list_for_each_entry(tmp, &clocksource_list, list) {
403			if (tmp == cs || tmp->flags & CLOCK_SOURCE_MUST_VERIFY)
404				continue;
405			if (!watchdog || tmp->rating > watchdog->rating)
406				watchdog = tmp;
407		}
408	}
409	cs->flags &= ~CLOCK_SOURCE_WATCHDOG;
410	/* Check if the watchdog timer needs to be stopped. */
411	clocksource_stop_watchdog();
412	spin_unlock_irqrestore(&watchdog_lock, flags);
413}
414
415static int clocksource_watchdog_kthread(void *data)
416{
417	struct clocksource *cs, *tmp;
418	unsigned long flags;
419	LIST_HEAD(unstable);
420
421	mutex_lock(&clocksource_mutex);
422	spin_lock_irqsave(&watchdog_lock, flags);
423	list_for_each_entry_safe(cs, tmp, &watchdog_list, wd_list)
424		if (cs->flags & CLOCK_SOURCE_UNSTABLE) {
425			list_del_init(&cs->wd_list);
426			list_add(&cs->wd_list, &unstable);
427		}
428	/* Check if the watchdog timer needs to be stopped. */
429	clocksource_stop_watchdog();
430	spin_unlock_irqrestore(&watchdog_lock, flags);
431
432	/* Needs to be done outside of watchdog lock */
433	list_for_each_entry_safe(cs, tmp, &unstable, wd_list) {
434		list_del_init(&cs->wd_list);
435		__clocksource_change_rating(cs, 0);
436	}
437	mutex_unlock(&clocksource_mutex);
438	return 0;
439}
440
441#else /* CONFIG_CLOCKSOURCE_WATCHDOG */
442
443static void clocksource_enqueue_watchdog(struct clocksource *cs)
444{
445	if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
446		cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
447}
448
449static inline void clocksource_dequeue_watchdog(struct clocksource *cs) { }
450static inline void clocksource_resume_watchdog(void) { }
451static inline int clocksource_watchdog_kthread(void *data) { return 0; }
452
453#endif /* CONFIG_CLOCKSOURCE_WATCHDOG */
454
455/**
456 * clocksource_suspend - suspend the clocksource(s)
457 */
458void clocksource_suspend(void)
459{
460	struct clocksource *cs;
461
462	list_for_each_entry_reverse(cs, &clocksource_list, list)
463		if (cs->suspend)
464			cs->suspend(cs);
465}
466
467/**
468 * clocksource_resume - resume the clocksource(s)
469 */
470void clocksource_resume(void)
471{
472	struct clocksource *cs;
473
474	list_for_each_entry(cs, &clocksource_list, list)
475		if (cs->resume)
476			cs->resume(cs);
477
478	clocksource_resume_watchdog();
479}
480
481/**
482 * clocksource_touch_watchdog - Update watchdog
483 *
484 * Update the watchdog after exception contexts such as kgdb so as not
485 * to incorrectly trip the watchdog. This might fail when the kernel
486 * was stopped in code which holds watchdog_lock.
487 */
488void clocksource_touch_watchdog(void)
489{
490	clocksource_resume_watchdog();
491}
492
493/**
494 * clocksource_max_deferment - Returns max time the clocksource can be deferred
495 * @cs:         Pointer to clocksource
496 *
497 */
498static u64 clocksource_max_deferment(struct clocksource *cs)
499{
500	u64 max_nsecs, max_cycles;
501
502	/*
503	 * Calculate the maximum number of cycles that we can pass to the
504	 * cyc2ns function without overflowing a 64-bit signed result. The
505	 * maximum number of cycles is equal to ULLONG_MAX/cs->mult which
506	 * is equivalent to the below.
507	 * max_cycles < (2^63)/cs->mult
508	 * max_cycles < 2^(log2((2^63)/cs->mult))
509	 * max_cycles < 2^(log2(2^63) - log2(cs->mult))
510	 * max_cycles < 2^(63 - log2(cs->mult))
511	 * max_cycles < 1 << (63 - log2(cs->mult))
512	 * Please note that we add 1 to the result of the log2 to account for
513	 * any rounding errors, ensure the above inequality is satisfied and
514	 * no overflow will occur.
515	 */
516	max_cycles = 1ULL << (63 - (ilog2(cs->mult) + 1));
517
518	/*
519	 * The actual maximum number of cycles we can defer the clocksource is
520	 * determined by the minimum of max_cycles and cs->mask.
521	 */
522	max_cycles = min_t(u64, max_cycles, (u64) cs->mask);
523	max_nsecs = clocksource_cyc2ns(max_cycles, cs->mult, cs->shift);
524
525	/*
526	 * To ensure that the clocksource does not wrap whilst we are idle,
527	 * limit the time the clocksource can be deferred by 12.5%. Please
528	 * note a margin of 12.5% is used because this can be computed with
529	 * a shift, versus say 10% which would require division.
530	 */
531	return max_nsecs - (max_nsecs >> 5);
532}
533
534#ifndef CONFIG_ARCH_USES_GETTIMEOFFSET
535
536/**
537 * clocksource_select - Select the best clocksource available
538 *
539 * Private function. Must hold clocksource_mutex when called.
540 *
541 * Select the clocksource with the best rating, or the clocksource,
542 * which is selected by userspace override.
543 */
544static void clocksource_select(void)
545{
546	struct clocksource *best, *cs;
547
548	if (!finished_booting || list_empty(&clocksource_list))
549		return;
550	/* First clocksource on the list has the best rating. */
551	best = list_first_entry(&clocksource_list, struct clocksource, list);
552	/* Check for the override clocksource. */
553	list_for_each_entry(cs, &clocksource_list, list) {
554		if (strcmp(cs->name, override_name) != 0)
555			continue;
556		/*
557		 * Check to make sure we don't switch to a non-highres
558		 * capable clocksource if the tick code is in oneshot
559		 * mode (highres or nohz)
560		 */
561		if (!(cs->flags & CLOCK_SOURCE_VALID_FOR_HRES) &&
562		    tick_oneshot_mode_active()) {
563			/* Override clocksource cannot be used. */
564			printk(KERN_WARNING "Override clocksource %s is not "
565			       "HRT compatible. Cannot switch while in "
566			       "HRT/NOHZ mode\n", cs->name);
567			override_name[0] = 0;
568		} else
569			/* Override clocksource can be used. */
570			best = cs;
571		break;
572	}
573	if (curr_clocksource != best) {
574		printk(KERN_INFO "Switching to clocksource %s\n", best->name);
575		curr_clocksource = best;
576		timekeeping_notify(curr_clocksource);
577	}
578}
579
580#else /* !CONFIG_ARCH_USES_GETTIMEOFFSET */
581
582static inline void clocksource_select(void) { }
583
584#endif
585
586/*
587 * clocksource_done_booting - Called near the end of core bootup
588 *
589 * Hack to avoid lots of clocksource churn at boot time.
590 * We use fs_initcall because we want this to start before
591 * device_initcall but after subsys_initcall.
592 */
593static int __init clocksource_done_booting(void)
594{
595	mutex_lock(&clocksource_mutex);
596	curr_clocksource = clocksource_default_clock();
597	mutex_unlock(&clocksource_mutex);
598
599	finished_booting = 1;
600
601	/*
602	 * Run the watchdog first to eliminate unstable clock sources
603	 */
604	clocksource_watchdog_kthread(NULL);
605
606	mutex_lock(&clocksource_mutex);
607	clocksource_select();
608	mutex_unlock(&clocksource_mutex);
609	return 0;
610}
611fs_initcall(clocksource_done_booting);
612
613/*
614 * Enqueue the clocksource sorted by rating
615 */
616static void clocksource_enqueue(struct clocksource *cs)
617{
618	struct list_head *entry = &clocksource_list;
619	struct clocksource *tmp;
620
621	list_for_each_entry(tmp, &clocksource_list, list)
622		/* Keep track of the place, where to insert */
623		if (tmp->rating >= cs->rating)
624			entry = &tmp->list;
625	list_add(&cs->list, entry);
626}
627
628
629/*
630 * Maximum time we expect to go between ticks. This includes idle
631 * tickless time. It provides the trade off between selecting a
632 * mult/shift pair that is very precise but can only handle a short
633 * period of time, vs. a mult/shift pair that can handle long periods
634 * of time but isn't as precise.
635 *
636 * This is a subsystem constant, and actual hardware limitations
637 * may override it (ie: clocksources that wrap every 3 seconds).
638 */
639#define MAX_UPDATE_LENGTH 5 /* Seconds */
640
641/**
642 * __clocksource_updatefreq_scale - Used update clocksource with new freq
643 * @t:		clocksource to be registered
644 * @scale:	Scale factor multiplied against freq to get clocksource hz
645 * @freq:	clocksource frequency (cycles per second) divided by scale
646 *
647 * This should only be called from the clocksource->enable() method.
648 *
649 * This *SHOULD NOT* be called directly! Please use the
650 * clocksource_updatefreq_hz() or clocksource_updatefreq_khz helper functions.
651 */
652void __clocksource_updatefreq_scale(struct clocksource *cs, u32 scale, u32 freq)
653{
654	/*
655	 * Ideally we want to use  some of the limits used in
656	 * clocksource_max_deferment, to provide a more informed
657	 * MAX_UPDATE_LENGTH. But for now this just gets the
658	 * register interface working properly.
659	 */
660	clocks_calc_mult_shift(&cs->mult, &cs->shift, freq,
661				      NSEC_PER_SEC/scale,
662				      MAX_UPDATE_LENGTH*scale);
663	cs->max_idle_ns = clocksource_max_deferment(cs);
664}
665EXPORT_SYMBOL_GPL(__clocksource_updatefreq_scale);
666
667/**
668 * __clocksource_register_scale - Used to install new clocksources
669 * @t:		clocksource to be registered
670 * @scale:	Scale factor multiplied against freq to get clocksource hz
671 * @freq:	clocksource frequency (cycles per second) divided by scale
672 *
673 * Returns -EBUSY if registration fails, zero otherwise.
674 *
675 * This *SHOULD NOT* be called directly! Please use the
676 * clocksource_register_hz() or clocksource_register_khz helper functions.
677 */
678int __clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq)
679{
680
681	/* Intialize mult/shift and max_idle_ns */
682	__clocksource_updatefreq_scale(cs, scale, freq);
683
684	/* Add clocksource to the clcoksource list */
685	mutex_lock(&clocksource_mutex);
686	clocksource_enqueue(cs);
687	clocksource_select();
688	clocksource_enqueue_watchdog(cs);
689	mutex_unlock(&clocksource_mutex);
690	return 0;
691}
692EXPORT_SYMBOL_GPL(__clocksource_register_scale);
693
694
695/**
696 * clocksource_register - Used to install new clocksources
697 * @t:		clocksource to be registered
698 *
699 * Returns -EBUSY if registration fails, zero otherwise.
700 */
701int clocksource_register(struct clocksource *cs)
702{
703	/* calculate max idle time permitted for this clocksource */
704	cs->max_idle_ns = clocksource_max_deferment(cs);
705
706	mutex_lock(&clocksource_mutex);
707	clocksource_enqueue(cs);
708	clocksource_select();
709	clocksource_enqueue_watchdog(cs);
710	mutex_unlock(&clocksource_mutex);
711	return 0;
712}
713EXPORT_SYMBOL(clocksource_register);
714
715static void __clocksource_change_rating(struct clocksource *cs, int rating)
716{
717	list_del(&cs->list);
718	cs->rating = rating;
719	clocksource_enqueue(cs);
720	clocksource_select();
721}
722
723/**
724 * clocksource_change_rating - Change the rating of a registered clocksource
725 */
726void clocksource_change_rating(struct clocksource *cs, int rating)
727{
728	mutex_lock(&clocksource_mutex);
729	__clocksource_change_rating(cs, rating);
730	mutex_unlock(&clocksource_mutex);
731}
732EXPORT_SYMBOL(clocksource_change_rating);
733
734/**
735 * clocksource_unregister - remove a registered clocksource
736 */
737void clocksource_unregister(struct clocksource *cs)
738{
739	mutex_lock(&clocksource_mutex);
740	clocksource_dequeue_watchdog(cs);
741	list_del(&cs->list);
742	clocksource_select();
743	mutex_unlock(&clocksource_mutex);
744}
745EXPORT_SYMBOL(clocksource_unregister);
746
747#ifdef CONFIG_SYSFS
748/**
749 * sysfs_show_current_clocksources - sysfs interface for current clocksource
750 * @dev:	unused
751 * @buf:	char buffer to be filled with clocksource list
752 *
753 * Provides sysfs interface for listing current clocksource.
754 */
755static ssize_t
756sysfs_show_current_clocksources(struct sys_device *dev,
757				struct sysdev_attribute *attr, char *buf)
758{
759	ssize_t count = 0;
760
761	mutex_lock(&clocksource_mutex);
762	count = snprintf(buf, PAGE_SIZE, "%s\n", curr_clocksource->name);
763	mutex_unlock(&clocksource_mutex);
764
765	return count;
766}
767
768/**
769 * sysfs_override_clocksource - interface for manually overriding clocksource
770 * @dev:	unused
771 * @buf:	name of override clocksource
772 * @count:	length of buffer
773 *
774 * Takes input from sysfs interface for manually overriding the default
775 * clocksource selection.
776 */
777static ssize_t sysfs_override_clocksource(struct sys_device *dev,
778					  struct sysdev_attribute *attr,
779					  const char *buf, size_t count)
780{
781	size_t ret = count;
782
783	/* strings from sysfs write are not 0 terminated! */
784	if (count >= sizeof(override_name))
785		return -EINVAL;
786
787	/* strip of \n: */
788	if (buf[count-1] == '\n')
789		count--;
790
791	mutex_lock(&clocksource_mutex);
792
793	if (count > 0)
794		memcpy(override_name, buf, count);
795	override_name[count] = 0;
796	clocksource_select();
797
798	mutex_unlock(&clocksource_mutex);
799
800	return ret;
801}
802
803/**
804 * sysfs_show_available_clocksources - sysfs interface for listing clocksource
805 * @dev:	unused
806 * @buf:	char buffer to be filled with clocksource list
807 *
808 * Provides sysfs interface for listing registered clocksources
809 */
810static ssize_t
811sysfs_show_available_clocksources(struct sys_device *dev,
812				  struct sysdev_attribute *attr,
813				  char *buf)
814{
815	struct clocksource *src;
816	ssize_t count = 0;
817
818	mutex_lock(&clocksource_mutex);
819	list_for_each_entry(src, &clocksource_list, list) {
820		/*
821		 * Don't show non-HRES clocksource if the tick code is
822		 * in one shot mode (highres=on or nohz=on)
823		 */
824		if (!tick_oneshot_mode_active() ||
825		    (src->flags & CLOCK_SOURCE_VALID_FOR_HRES))
826			count += snprintf(buf + count,
827				  max((ssize_t)PAGE_SIZE - count, (ssize_t)0),
828				  "%s ", src->name);
829	}
830	mutex_unlock(&clocksource_mutex);
831
832	count += snprintf(buf + count,
833			  max((ssize_t)PAGE_SIZE - count, (ssize_t)0), "\n");
834
835	return count;
836}
837
838/*
839 * Sysfs setup bits:
840 */
841static SYSDEV_ATTR(current_clocksource, 0644, sysfs_show_current_clocksources,
842		   sysfs_override_clocksource);
843
844static SYSDEV_ATTR(available_clocksource, 0444,
845		   sysfs_show_available_clocksources, NULL);
846
847static struct sysdev_class clocksource_sysclass = {
848	.name = "clocksource",
849};
850
851static struct sys_device device_clocksource = {
852	.id	= 0,
853	.cls	= &clocksource_sysclass,
854};
855
856static int __init init_clocksource_sysfs(void)
857{
858	int error = sysdev_class_register(&clocksource_sysclass);
859
860	if (!error)
861		error = sysdev_register(&device_clocksource);
862	if (!error)
863		error = sysdev_create_file(
864				&device_clocksource,
865				&attr_current_clocksource);
866	if (!error)
867		error = sysdev_create_file(
868				&device_clocksource,
869				&attr_available_clocksource);
870	return error;
871}
872
873device_initcall(init_clocksource_sysfs);
874#endif /* CONFIG_SYSFS */
875
876/**
877 * boot_override_clocksource - boot clock override
878 * @str:	override name
879 *
880 * Takes a clocksource= boot argument and uses it
881 * as the clocksource override name.
882 */
883static int __init boot_override_clocksource(char* str)
884{
885	mutex_lock(&clocksource_mutex);
886	if (str)
887		strlcpy(override_name, str, sizeof(override_name));
888	mutex_unlock(&clocksource_mutex);
889	return 1;
890}
891
892__setup("clocksource=", boot_override_clocksource);
893
894/**
895 * boot_override_clock - Compatibility layer for deprecated boot option
896 * @str:	override name
897 *
898 * DEPRECATED! Takes a clock= boot argument and uses it
899 * as the clocksource override name
900 */
901static int __init boot_override_clock(char* str)
902{
903	if (!strcmp(str, "pmtmr")) {
904		printk("Warning: clock=pmtmr is deprecated. "
905			"Use clocksource=acpi_pm.\n");
906		return boot_override_clocksource("acpi_pm");
907	}
908	printk("Warning! clock= boot option is deprecated. "
909		"Use clocksource=xyz\n");
910	return boot_override_clocksource(str);
911}
912
913__setup("clock=", boot_override_clock);
914