Merge git://oss.sgi.com:8090/oss/git/xfs-2.6
[linux-2.6] / arch / arm / kernel / time.c
1 /*
2  *  linux/arch/arm/kernel/time.c
3  *
4  *  Copyright (C) 1991, 1992, 1995  Linus Torvalds
5  *  Modifications for ARM (C) 1994-2001 Russell King
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  *
11  *  This file contains the ARM-specific time handling details:
12  *  reading the RTC at bootup, etc...
13  *
14  *  1994-07-02  Alan Modra
15  *              fixed set_rtc_mmss, fixed time.year for >= 2000, new mktime
16  *  1998-12-20  Updated NTP code according to technical memorandum Jan '96
17  *              "A Kernel Model for Precision Timekeeping" by Dave Mills
18  */
19 #include <linux/config.h>
20 #include <linux/module.h>
21 #include <linux/kernel.h>
22 #include <linux/interrupt.h>
23 #include <linux/time.h>
24 #include <linux/init.h>
25 #include <linux/smp.h>
26 #include <linux/timex.h>
27 #include <linux/errno.h>
28 #include <linux/profile.h>
29 #include <linux/sysdev.h>
30 #include <linux/timer.h>
31
32 #include <asm/leds.h>
33 #include <asm/thread_info.h>
34 #include <asm/mach/time.h>
35
36 /*
37  * Our system timer.
38  */
39 struct sys_timer *system_timer;
40
41 extern unsigned long wall_jiffies;
42
43 /* this needs a better home */
44 DEFINE_SPINLOCK(rtc_lock);
45
46 #ifdef CONFIG_SA1100_RTC_MODULE
47 EXPORT_SYMBOL(rtc_lock);
48 #endif
49
50 /* change this if you have some constant time drift */
51 #define USECS_PER_JIFFY (1000000/HZ)
52
53 #ifdef CONFIG_SMP
54 unsigned long profile_pc(struct pt_regs *regs)
55 {
56         unsigned long fp, pc = instruction_pointer(regs);
57
58         if (in_lock_functions(pc)) {
59                 fp = regs->ARM_fp;
60                 pc = pc_pointer(((unsigned long *)fp)[-1]);
61         }
62
63         return pc;
64 }
65 EXPORT_SYMBOL(profile_pc);
66 #endif
67
68 /*
69  * hook for setting the RTC's idea of the current time.
70  */
71 int (*set_rtc)(void);
72
73 static unsigned long dummy_gettimeoffset(void)
74 {
75         return 0;
76 }
77
78 /*
79  * Scheduler clock - returns current time in nanosec units.
80  * This is the default implementation.  Sub-architecture
81  * implementations can override this.
82  */
83 unsigned long long __attribute__((weak)) sched_clock(void)
84 {
85         return (unsigned long long)jiffies * (1000000000 / HZ);
86 }
87
88 static unsigned long next_rtc_update;
89
90 /*
91  * If we have an externally synchronized linux clock, then update
92  * CMOS clock accordingly every ~11 minutes.  set_rtc() has to be
93  * called as close as possible to 500 ms before the new second
94  * starts.
95  */
96 static inline void do_set_rtc(void)
97 {
98         if (!ntp_synced() || set_rtc == NULL)
99                 return;
100
101         if (next_rtc_update &&
102             time_before((unsigned long)xtime.tv_sec, next_rtc_update))
103                 return;
104
105         if (xtime.tv_nsec < 500000000 - ((unsigned) tick_nsec >> 1) &&
106             xtime.tv_nsec >= 500000000 + ((unsigned) tick_nsec >> 1))
107                 return;
108
109         if (set_rtc())
110                 /*
111                  * rtc update failed.  Try again in 60s
112                  */
113                 next_rtc_update = xtime.tv_sec + 60;
114         else
115                 next_rtc_update = xtime.tv_sec + 660;
116 }
117
118 #ifdef CONFIG_LEDS
119
120 static void dummy_leds_event(led_event_t evt)
121 {
122 }
123
124 void (*leds_event)(led_event_t) = dummy_leds_event;
125
126 struct leds_evt_name {
127         const char      name[8];
128         int             on;
129         int             off;
130 };
131
132 static const struct leds_evt_name evt_names[] = {
133         { "amber", led_amber_on, led_amber_off },
134         { "blue",  led_blue_on,  led_blue_off  },
135         { "green", led_green_on, led_green_off },
136         { "red",   led_red_on,   led_red_off   },
137 };
138
139 static ssize_t leds_store(struct sys_device *dev, const char *buf, size_t size)
140 {
141         int ret = -EINVAL, len = strcspn(buf, " ");
142
143         if (len > 0 && buf[len] == '\0')
144                 len--;
145
146         if (strncmp(buf, "claim", len) == 0) {
147                 leds_event(led_claim);
148                 ret = size;
149         } else if (strncmp(buf, "release", len) == 0) {
150                 leds_event(led_release);
151                 ret = size;
152         } else {
153                 int i;
154
155                 for (i = 0; i < ARRAY_SIZE(evt_names); i++) {
156                         if (strlen(evt_names[i].name) != len ||
157                             strncmp(buf, evt_names[i].name, len) != 0)
158                                 continue;
159                         if (strncmp(buf+len, " on", 3) == 0) {
160                                 leds_event(evt_names[i].on);
161                                 ret = size;
162                         } else if (strncmp(buf+len, " off", 4) == 0) {
163                                 leds_event(evt_names[i].off);
164                                 ret = size;
165                         }
166                         break;
167                 }
168         }
169         return ret;
170 }
171
172 static SYSDEV_ATTR(event, 0200, NULL, leds_store);
173
174 static int leds_suspend(struct sys_device *dev, pm_message_t state)
175 {
176         leds_event(led_stop);
177         return 0;
178 }
179
180 static int leds_resume(struct sys_device *dev)
181 {
182         leds_event(led_start);
183         return 0;
184 }
185
186 static int leds_shutdown(struct sys_device *dev)
187 {
188         leds_event(led_halted);
189         return 0;
190 }
191
192 static struct sysdev_class leds_sysclass = {
193         set_kset_name("leds"),
194         .shutdown       = leds_shutdown,
195         .suspend        = leds_suspend,
196         .resume         = leds_resume,
197 };
198
199 static struct sys_device leds_device = {
200         .id             = 0,
201         .cls            = &leds_sysclass,
202 };
203
204 static int __init leds_init(void)
205 {
206         int ret;
207         ret = sysdev_class_register(&leds_sysclass);
208         if (ret == 0)
209                 ret = sysdev_register(&leds_device);
210         if (ret == 0)
211                 ret = sysdev_create_file(&leds_device, &attr_event);
212         return ret;
213 }
214
215 device_initcall(leds_init);
216
217 EXPORT_SYMBOL(leds_event);
218 #endif
219
220 #ifdef CONFIG_LEDS_TIMER
221 static inline void do_leds(void)
222 {
223         static unsigned int count = 50;
224
225         if (--count == 0) {
226                 count = 50;
227                 leds_event(led_timer);
228         }
229 }
230 #else
231 #define do_leds()
232 #endif
233
234 void do_gettimeofday(struct timeval *tv)
235 {
236         unsigned long flags;
237         unsigned long seq;
238         unsigned long usec, sec, lost;
239
240         do {
241                 seq = read_seqbegin_irqsave(&xtime_lock, flags);
242                 usec = system_timer->offset();
243
244                 lost = jiffies - wall_jiffies;
245                 if (lost)
246                         usec += lost * USECS_PER_JIFFY;
247
248                 sec = xtime.tv_sec;
249                 usec += xtime.tv_nsec / 1000;
250         } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
251
252         /* usec may have gone up a lot: be safe */
253         while (usec >= 1000000) {
254                 usec -= 1000000;
255                 sec++;
256         }
257
258         tv->tv_sec = sec;
259         tv->tv_usec = usec;
260 }
261
262 EXPORT_SYMBOL(do_gettimeofday);
263
264 int do_settimeofday(struct timespec *tv)
265 {
266         time_t wtm_sec, sec = tv->tv_sec;
267         long wtm_nsec, nsec = tv->tv_nsec;
268
269         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
270                 return -EINVAL;
271
272         write_seqlock_irq(&xtime_lock);
273         /*
274          * This is revolting. We need to set "xtime" correctly. However, the
275          * value in this location is the value at the most recent update of
276          * wall time.  Discover what correction gettimeofday() would have
277          * done, and then undo it!
278          */
279         nsec -= system_timer->offset() * NSEC_PER_USEC;
280         nsec -= (jiffies - wall_jiffies) * TICK_NSEC;
281
282         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
283         wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
284
285         set_normalized_timespec(&xtime, sec, nsec);
286         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
287
288         ntp_clear();
289         write_sequnlock_irq(&xtime_lock);
290         clock_was_set();
291         return 0;
292 }
293
294 EXPORT_SYMBOL(do_settimeofday);
295
296 /**
297  * save_time_delta - Save the offset between system time and RTC time
298  * @delta: pointer to timespec to store delta
299  * @rtc: pointer to timespec for current RTC time
300  *
301  * Return a delta between the system time and the RTC time, such
302  * that system time can be restored later with restore_time_delta()
303  */
304 void save_time_delta(struct timespec *delta, struct timespec *rtc)
305 {
306         set_normalized_timespec(delta,
307                                 xtime.tv_sec - rtc->tv_sec,
308                                 xtime.tv_nsec - rtc->tv_nsec);
309 }
310 EXPORT_SYMBOL(save_time_delta);
311
312 /**
313  * restore_time_delta - Restore the current system time
314  * @delta: delta returned by save_time_delta()
315  * @rtc: pointer to timespec for current RTC time
316  */
317 void restore_time_delta(struct timespec *delta, struct timespec *rtc)
318 {
319         struct timespec ts;
320
321         set_normalized_timespec(&ts,
322                                 delta->tv_sec + rtc->tv_sec,
323                                 delta->tv_nsec + rtc->tv_nsec);
324
325         do_settimeofday(&ts);
326 }
327 EXPORT_SYMBOL(restore_time_delta);
328
329 /*
330  * Kernel system timer support.
331  */
332 void timer_tick(struct pt_regs *regs)
333 {
334         profile_tick(CPU_PROFILING, regs);
335         do_leds();
336         do_set_rtc();
337         do_timer(regs);
338 #ifndef CONFIG_SMP
339         update_process_times(user_mode(regs));
340 #endif
341 }
342
343 #ifdef CONFIG_PM
344 static int timer_suspend(struct sys_device *dev, pm_message_t state)
345 {
346         struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
347
348         if (timer->suspend != NULL)
349                 timer->suspend();
350
351         return 0;
352 }
353
354 static int timer_resume(struct sys_device *dev)
355 {
356         struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
357
358         if (timer->resume != NULL)
359                 timer->resume();
360
361         return 0;
362 }
363 #else
364 #define timer_suspend NULL
365 #define timer_resume NULL
366 #endif
367
368 static struct sysdev_class timer_sysclass = {
369         set_kset_name("timer"),
370         .suspend        = timer_suspend,
371         .resume         = timer_resume,
372 };
373
374 #ifdef CONFIG_NO_IDLE_HZ
375 static int timer_dyn_tick_enable(void)
376 {
377         struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
378         unsigned long flags;
379         int ret = -ENODEV;
380
381         if (dyn_tick) {
382                 write_seqlock_irqsave(&xtime_lock, flags);
383                 ret = 0;
384                 if (!(dyn_tick->state & DYN_TICK_ENABLED)) {
385                         ret = dyn_tick->enable();
386
387                         if (ret == 0)
388                                 dyn_tick->state |= DYN_TICK_ENABLED;
389                 }
390                 write_sequnlock_irqrestore(&xtime_lock, flags);
391         }
392
393         return ret;
394 }
395
396 static int timer_dyn_tick_disable(void)
397 {
398         struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
399         unsigned long flags;
400         int ret = -ENODEV;
401
402         if (dyn_tick) {
403                 write_seqlock_irqsave(&xtime_lock, flags);
404                 ret = 0;
405                 if (dyn_tick->state & DYN_TICK_ENABLED) {
406                         ret = dyn_tick->disable();
407
408                         if (ret == 0)
409                                 dyn_tick->state &= ~DYN_TICK_ENABLED;
410                 }
411                 write_sequnlock_irqrestore(&xtime_lock, flags);
412         }
413
414         return ret;
415 }
416
417 /*
418  * Reprogram the system timer for at least the calculated time interval.
419  * This function should be called from the idle thread with IRQs disabled,
420  * immediately before sleeping.
421  */
422 void timer_dyn_reprogram(void)
423 {
424         struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
425         unsigned long next, seq;
426
427         if (dyn_tick && (dyn_tick->state & DYN_TICK_ENABLED)) {
428                 next = next_timer_interrupt();
429                 do {
430                         seq = read_seqbegin(&xtime_lock);
431                         dyn_tick->reprogram(next_timer_interrupt() - jiffies);
432                 } while (read_seqretry(&xtime_lock, seq));
433         }
434 }
435
436 static ssize_t timer_show_dyn_tick(struct sys_device *dev, char *buf)
437 {
438         return sprintf(buf, "%i\n",
439                        (system_timer->dyn_tick->state & DYN_TICK_ENABLED) >> 1);
440 }
441
442 static ssize_t timer_set_dyn_tick(struct sys_device *dev, const char *buf,
443                                   size_t count)
444 {
445         unsigned int enable = simple_strtoul(buf, NULL, 2);
446
447         if (enable)
448                 timer_dyn_tick_enable();
449         else
450                 timer_dyn_tick_disable();
451
452         return count;
453 }
454 static SYSDEV_ATTR(dyn_tick, 0644, timer_show_dyn_tick, timer_set_dyn_tick);
455
456 /*
457  * dyntick=enable|disable
458  */
459 static char dyntick_str[4] __initdata = "";
460
461 static int __init dyntick_setup(char *str)
462 {
463         if (str)
464                 strlcpy(dyntick_str, str, sizeof(dyntick_str));
465         return 1;
466 }
467
468 __setup("dyntick=", dyntick_setup);
469 #endif
470
471 static int __init timer_init_sysfs(void)
472 {
473         int ret = sysdev_class_register(&timer_sysclass);
474         if (ret == 0) {
475                 system_timer->dev.cls = &timer_sysclass;
476                 ret = sysdev_register(&system_timer->dev);
477         }
478
479 #ifdef CONFIG_NO_IDLE_HZ
480         if (ret == 0 && system_timer->dyn_tick) {
481                 ret = sysdev_create_file(&system_timer->dev, &attr_dyn_tick);
482
483                 /*
484                  * Turn on dynamic tick after calibrate delay
485                  * for correct bogomips
486                  */
487                 if (ret == 0 && dyntick_str[0] == 'e')
488                         ret = timer_dyn_tick_enable();
489         }
490 #endif
491
492         return ret;
493 }
494
495 device_initcall(timer_init_sysfs);
496
497 void __init time_init(void)
498 {
499         if (system_timer->offset == NULL)
500                 system_timer->offset = dummy_gettimeoffset;
501         system_timer->init();
502 }
503