clocksource.c: use init_timer_deferrable for clocksource_watchdog
[linux-2.6] / 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  *   o get rid of clocksource_jiffies extern
25  */
26
27 #include <linux/clocksource.h>
28 #include <linux/sysdev.h>
29 #include <linux/init.h>
30 #include <linux/module.h>
31 #include <linux/sched.h> /* for spin_unlock_irq() using preempt_count() m68k */
32 #include <linux/tick.h>
33
34 /* XXX - Would like a better way for initializing curr_clocksource */
35 extern struct clocksource clocksource_jiffies;
36
37 /*[Clocksource internal variables]---------
38  * curr_clocksource:
39  *      currently selected clocksource. Initialized to clocksource_jiffies.
40  * next_clocksource:
41  *      pending next selected clocksource.
42  * clocksource_list:
43  *      linked list with the registered clocksources
44  * clocksource_lock:
45  *      protects manipulations to curr_clocksource and next_clocksource
46  *      and the clocksource_list
47  * override_name:
48  *      Name of the user-specified clocksource.
49  */
50 static struct clocksource *curr_clocksource = &clocksource_jiffies;
51 static struct clocksource *next_clocksource;
52 static struct clocksource *clocksource_override;
53 static LIST_HEAD(clocksource_list);
54 static DEFINE_SPINLOCK(clocksource_lock);
55 static char override_name[32];
56 static int finished_booting;
57
58 /* clocksource_done_booting - Called near the end of core bootup
59  *
60  * Hack to avoid lots of clocksource churn at boot time.
61  * We use fs_initcall because we want this to start before
62  * device_initcall but after subsys_initcall.
63  */
64 static int __init clocksource_done_booting(void)
65 {
66         finished_booting = 1;
67         return 0;
68 }
69 fs_initcall(clocksource_done_booting);
70
71 #ifdef CONFIG_CLOCKSOURCE_WATCHDOG
72 static LIST_HEAD(watchdog_list);
73 static struct clocksource *watchdog;
74 static struct timer_list watchdog_timer;
75 static DEFINE_SPINLOCK(watchdog_lock);
76 static cycle_t watchdog_last;
77 static unsigned long watchdog_resumed;
78
79 /*
80  * Interval: 0.5sec Threshold: 0.0625s
81  */
82 #define WATCHDOG_INTERVAL (HZ >> 1)
83 #define WATCHDOG_THRESHOLD (NSEC_PER_SEC >> 4)
84
85 static void clocksource_ratewd(struct clocksource *cs, int64_t delta)
86 {
87         if (delta > -WATCHDOG_THRESHOLD && delta < WATCHDOG_THRESHOLD)
88                 return;
89
90         printk(KERN_WARNING "Clocksource %s unstable (delta = %Ld ns)\n",
91                cs->name, delta);
92         cs->flags &= ~(CLOCK_SOURCE_VALID_FOR_HRES | CLOCK_SOURCE_WATCHDOG);
93         clocksource_change_rating(cs, 0);
94         cs->flags &= ~CLOCK_SOURCE_WATCHDOG;
95         list_del(&cs->wd_list);
96 }
97
98 static void clocksource_watchdog(unsigned long data)
99 {
100         struct clocksource *cs, *tmp;
101         cycle_t csnow, wdnow;
102         int64_t wd_nsec, cs_nsec;
103         int resumed;
104
105         spin_lock(&watchdog_lock);
106
107         resumed = test_and_clear_bit(0, &watchdog_resumed);
108
109         wdnow = watchdog->read();
110         wd_nsec = cyc2ns(watchdog, (wdnow - watchdog_last) & watchdog->mask);
111         watchdog_last = wdnow;
112
113         list_for_each_entry_safe(cs, tmp, &watchdog_list, wd_list) {
114                 csnow = cs->read();
115
116                 if (unlikely(resumed)) {
117                         cs->wd_last = csnow;
118                         continue;
119                 }
120
121                 /* Initialized ? */
122                 if (!(cs->flags & CLOCK_SOURCE_WATCHDOG)) {
123                         if ((cs->flags & CLOCK_SOURCE_IS_CONTINUOUS) &&
124                             (watchdog->flags & CLOCK_SOURCE_IS_CONTINUOUS)) {
125                                 cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
126                                 /*
127                                  * We just marked the clocksource as
128                                  * highres-capable, notify the rest of the
129                                  * system as well so that we transition
130                                  * into high-res mode:
131                                  */
132                                 tick_clock_notify();
133                         }
134                         cs->flags |= CLOCK_SOURCE_WATCHDOG;
135                         cs->wd_last = csnow;
136                 } else {
137                         cs_nsec = cyc2ns(cs, (csnow - cs->wd_last) & cs->mask);
138                         cs->wd_last = csnow;
139                         /* Check the delta. Might remove from the list ! */
140                         clocksource_ratewd(cs, cs_nsec - wd_nsec);
141                 }
142         }
143
144         if (!list_empty(&watchdog_list)) {
145                 __mod_timer(&watchdog_timer,
146                             watchdog_timer.expires + WATCHDOG_INTERVAL);
147         }
148         spin_unlock(&watchdog_lock);
149 }
150 static void clocksource_resume_watchdog(void)
151 {
152         set_bit(0, &watchdog_resumed);
153 }
154
155 static void clocksource_check_watchdog(struct clocksource *cs)
156 {
157         struct clocksource *cse;
158         unsigned long flags;
159
160         spin_lock_irqsave(&watchdog_lock, flags);
161         if (cs->flags & CLOCK_SOURCE_MUST_VERIFY) {
162                 int started = !list_empty(&watchdog_list);
163
164                 list_add(&cs->wd_list, &watchdog_list);
165                 if (!started && watchdog) {
166                         watchdog_last = watchdog->read();
167                         watchdog_timer.expires = jiffies + WATCHDOG_INTERVAL;
168                         add_timer(&watchdog_timer);
169                 }
170         } else {
171                 if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
172                         cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
173
174                 if (!watchdog || cs->rating > watchdog->rating) {
175                         if (watchdog)
176                                 del_timer(&watchdog_timer);
177                         watchdog = cs;
178                         init_timer_deferrable(&watchdog_timer);
179                         watchdog_timer.function = clocksource_watchdog;
180
181                         /* Reset watchdog cycles */
182                         list_for_each_entry(cse, &watchdog_list, wd_list)
183                                 cse->flags &= ~CLOCK_SOURCE_WATCHDOG;
184                         /* Start if list is not empty */
185                         if (!list_empty(&watchdog_list)) {
186                                 watchdog_last = watchdog->read();
187                                 watchdog_timer.expires =
188                                         jiffies + WATCHDOG_INTERVAL;
189                                 add_timer(&watchdog_timer);
190                         }
191                 }
192         }
193         spin_unlock_irqrestore(&watchdog_lock, flags);
194 }
195 #else
196 static void clocksource_check_watchdog(struct clocksource *cs)
197 {
198         if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
199                 cs->flags |= CLOCK_SOURCE_VALID_FOR_HRES;
200 }
201
202 static inline void clocksource_resume_watchdog(void) { }
203 #endif
204
205 /**
206  * clocksource_resume - resume the clocksource(s)
207  */
208 void clocksource_resume(void)
209 {
210         struct clocksource *cs;
211         unsigned long flags;
212
213         spin_lock_irqsave(&clocksource_lock, flags);
214
215         list_for_each_entry(cs, &clocksource_list, list) {
216                 if (cs->resume)
217                         cs->resume();
218         }
219
220         clocksource_resume_watchdog();
221
222         spin_unlock_irqrestore(&clocksource_lock, flags);
223 }
224
225 /**
226  * clocksource_get_next - Returns the selected clocksource
227  *
228  */
229 struct clocksource *clocksource_get_next(void)
230 {
231         unsigned long flags;
232
233         spin_lock_irqsave(&clocksource_lock, flags);
234         if (next_clocksource && finished_booting) {
235                 curr_clocksource = next_clocksource;
236                 next_clocksource = NULL;
237         }
238         spin_unlock_irqrestore(&clocksource_lock, flags);
239
240         return curr_clocksource;
241 }
242
243 /**
244  * select_clocksource - Selects the best registered clocksource.
245  *
246  * Private function. Must hold clocksource_lock when called.
247  *
248  * Select the clocksource with the best rating, or the clocksource,
249  * which is selected by userspace override.
250  */
251 static struct clocksource *select_clocksource(void)
252 {
253         struct clocksource *next;
254
255         if (list_empty(&clocksource_list))
256                 return NULL;
257
258         if (clocksource_override)
259                 next = clocksource_override;
260         else
261                 next = list_entry(clocksource_list.next, struct clocksource,
262                                   list);
263
264         if (next == curr_clocksource)
265                 return NULL;
266
267         return next;
268 }
269
270 /*
271  * Enqueue the clocksource sorted by rating
272  */
273 static int clocksource_enqueue(struct clocksource *c)
274 {
275         struct list_head *tmp, *entry = &clocksource_list;
276
277         list_for_each(tmp, &clocksource_list) {
278                 struct clocksource *cs;
279
280                 cs = list_entry(tmp, struct clocksource, list);
281                 if (cs == c)
282                         return -EBUSY;
283                 /* Keep track of the place, where to insert */
284                 if (cs->rating >= c->rating)
285                         entry = tmp;
286         }
287         list_add(&c->list, entry);
288
289         if (strlen(c->name) == strlen(override_name) &&
290             !strcmp(c->name, override_name))
291                 clocksource_override = c;
292
293         return 0;
294 }
295
296 /**
297  * clocksource_register - Used to install new clocksources
298  * @t:          clocksource to be registered
299  *
300  * Returns -EBUSY if registration fails, zero otherwise.
301  */
302 int clocksource_register(struct clocksource *c)
303 {
304         unsigned long flags;
305         int ret;
306
307         spin_lock_irqsave(&clocksource_lock, flags);
308         ret = clocksource_enqueue(c);
309         if (!ret)
310                 next_clocksource = select_clocksource();
311         spin_unlock_irqrestore(&clocksource_lock, flags);
312         if (!ret)
313                 clocksource_check_watchdog(c);
314         return ret;
315 }
316 EXPORT_SYMBOL(clocksource_register);
317
318 /**
319  * clocksource_change_rating - Change the rating of a registered clocksource
320  *
321  */
322 void clocksource_change_rating(struct clocksource *cs, int rating)
323 {
324         unsigned long flags;
325
326         spin_lock_irqsave(&clocksource_lock, flags);
327         list_del(&cs->list);
328         cs->rating = rating;
329         clocksource_enqueue(cs);
330         next_clocksource = select_clocksource();
331         spin_unlock_irqrestore(&clocksource_lock, flags);
332 }
333
334 #ifdef CONFIG_SYSFS
335 /**
336  * sysfs_show_current_clocksources - sysfs interface for current clocksource
337  * @dev:        unused
338  * @buf:        char buffer to be filled with clocksource list
339  *
340  * Provides sysfs interface for listing current clocksource.
341  */
342 static ssize_t
343 sysfs_show_current_clocksources(struct sys_device *dev, char *buf)
344 {
345         char *curr = buf;
346
347         spin_lock_irq(&clocksource_lock);
348         curr += sprintf(curr, "%s ", curr_clocksource->name);
349         spin_unlock_irq(&clocksource_lock);
350
351         curr += sprintf(curr, "\n");
352
353         return curr - buf;
354 }
355
356 /**
357  * sysfs_override_clocksource - interface for manually overriding clocksource
358  * @dev:        unused
359  * @buf:        name of override clocksource
360  * @count:      length of buffer
361  *
362  * Takes input from sysfs interface for manually overriding the default
363  * clocksource selction.
364  */
365 static ssize_t sysfs_override_clocksource(struct sys_device *dev,
366                                           const char *buf, size_t count)
367 {
368         struct clocksource *ovr = NULL;
369         size_t ret = count;
370         int len;
371
372         /* strings from sysfs write are not 0 terminated! */
373         if (count >= sizeof(override_name))
374                 return -EINVAL;
375
376         /* strip of \n: */
377         if (buf[count-1] == '\n')
378                 count--;
379
380         spin_lock_irq(&clocksource_lock);
381
382         if (count > 0)
383                 memcpy(override_name, buf, count);
384         override_name[count] = 0;
385
386         len = strlen(override_name);
387         if (len) {
388                 struct clocksource *cs;
389
390                 ovr = clocksource_override;
391                 /* try to select it: */
392                 list_for_each_entry(cs, &clocksource_list, list) {
393                         if (strlen(cs->name) == len &&
394                             !strcmp(cs->name, override_name))
395                                 ovr = cs;
396                 }
397         }
398
399         /* Reselect, when the override name has changed */
400         if (ovr != clocksource_override) {
401                 clocksource_override = ovr;
402                 next_clocksource = select_clocksource();
403         }
404
405         spin_unlock_irq(&clocksource_lock);
406
407         return ret;
408 }
409
410 /**
411  * sysfs_show_available_clocksources - sysfs interface for listing clocksource
412  * @dev:        unused
413  * @buf:        char buffer to be filled with clocksource list
414  *
415  * Provides sysfs interface for listing registered clocksources
416  */
417 static ssize_t
418 sysfs_show_available_clocksources(struct sys_device *dev, char *buf)
419 {
420         struct clocksource *src;
421         char *curr = buf;
422
423         spin_lock_irq(&clocksource_lock);
424         list_for_each_entry(src, &clocksource_list, list) {
425                 curr += sprintf(curr, "%s ", src->name);
426         }
427         spin_unlock_irq(&clocksource_lock);
428
429         curr += sprintf(curr, "\n");
430
431         return curr - buf;
432 }
433
434 /*
435  * Sysfs setup bits:
436  */
437 static SYSDEV_ATTR(current_clocksource, 0600, sysfs_show_current_clocksources,
438                    sysfs_override_clocksource);
439
440 static SYSDEV_ATTR(available_clocksource, 0600,
441                    sysfs_show_available_clocksources, NULL);
442
443 static struct sysdev_class clocksource_sysclass = {
444         .name = "clocksource",
445 };
446
447 static struct sys_device device_clocksource = {
448         .id     = 0,
449         .cls    = &clocksource_sysclass,
450 };
451
452 static int __init init_clocksource_sysfs(void)
453 {
454         int error = sysdev_class_register(&clocksource_sysclass);
455
456         if (!error)
457                 error = sysdev_register(&device_clocksource);
458         if (!error)
459                 error = sysdev_create_file(
460                                 &device_clocksource,
461                                 &attr_current_clocksource);
462         if (!error)
463                 error = sysdev_create_file(
464                                 &device_clocksource,
465                                 &attr_available_clocksource);
466         return error;
467 }
468
469 device_initcall(init_clocksource_sysfs);
470 #endif /* CONFIG_SYSFS */
471
472 /**
473  * boot_override_clocksource - boot clock override
474  * @str:        override name
475  *
476  * Takes a clocksource= boot argument and uses it
477  * as the clocksource override name.
478  */
479 static int __init boot_override_clocksource(char* str)
480 {
481         unsigned long flags;
482         spin_lock_irqsave(&clocksource_lock, flags);
483         if (str)
484                 strlcpy(override_name, str, sizeof(override_name));
485         spin_unlock_irqrestore(&clocksource_lock, flags);
486         return 1;
487 }
488
489 __setup("clocksource=", boot_override_clocksource);
490
491 /**
492  * boot_override_clock - Compatibility layer for deprecated boot option
493  * @str:        override name
494  *
495  * DEPRECATED! Takes a clock= boot argument and uses it
496  * as the clocksource override name
497  */
498 static int __init boot_override_clock(char* str)
499 {
500         if (!strcmp(str, "pmtmr")) {
501                 printk("Warning: clock=pmtmr is deprecated. "
502                         "Use clocksource=acpi_pm.\n");
503                 return boot_override_clocksource("acpi_pm");
504         }
505         printk("Warning! clock= boot option is deprecated. "
506                 "Use clocksource=xyz\n");
507         return boot_override_clocksource(str);
508 }
509
510 __setup("clock=", boot_override_clock);