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