[PATCH] jiffies_64 cleanup
[linux-3.10.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/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/hardware.h>
33 #include <asm/io.h>
34 #include <asm/irq.h>
35 #include <asm/leds.h>
36 #include <asm/thread_info.h>
37 #include <asm/mach/time.h>
38
39 /*
40  * Our system timer.
41  */
42 struct sys_timer *system_timer;
43
44 extern unsigned long wall_jiffies;
45
46 /* this needs a better home */
47 DEFINE_SPINLOCK(rtc_lock);
48
49 #ifdef CONFIG_SA1100_RTC_MODULE
50 EXPORT_SYMBOL(rtc_lock);
51 #endif
52
53 /* change this if you have some constant time drift */
54 #define USECS_PER_JIFFY (1000000/HZ)
55
56 #ifdef CONFIG_SMP
57 unsigned long profile_pc(struct pt_regs *regs)
58 {
59         unsigned long fp, pc = instruction_pointer(regs);
60
61         if (in_lock_functions(pc)) {
62                 fp = regs->ARM_fp;
63                 pc = pc_pointer(((unsigned long *)fp)[-1]);
64         }
65
66         return pc;
67 }
68 EXPORT_SYMBOL(profile_pc);
69 #endif
70
71 /*
72  * hook for setting the RTC's idea of the current time.
73  */
74 int (*set_rtc)(void);
75
76 static unsigned long dummy_gettimeoffset(void)
77 {
78         return 0;
79 }
80
81 /*
82  * Scheduler clock - returns current time in nanosec units.
83  * This is the default implementation.  Sub-architecture
84  * implementations can override this.
85  */
86 unsigned long long __attribute__((weak)) sched_clock(void)
87 {
88         return (unsigned long long)jiffies * (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 = 50;
227
228         if (--count == 0) {
229                 count = 50;
230                 leds_event(led_timer);
231         }
232 }
233 #else
234 #define do_leds()
235 #endif
236
237 void do_gettimeofday(struct timeval *tv)
238 {
239         unsigned long flags;
240         unsigned long seq;
241         unsigned long usec, sec, lost;
242
243         do {
244                 seq = read_seqbegin_irqsave(&xtime_lock, flags);
245                 usec = system_timer->offset();
246
247                 lost = jiffies - wall_jiffies;
248                 if (lost)
249                         usec += lost * USECS_PER_JIFFY;
250
251                 sec = xtime.tv_sec;
252                 usec += xtime.tv_nsec / 1000;
253         } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
254
255         /* usec may have gone up a lot: be safe */
256         while (usec >= 1000000) {
257                 usec -= 1000000;
258                 sec++;
259         }
260
261         tv->tv_sec = sec;
262         tv->tv_usec = usec;
263 }
264
265 EXPORT_SYMBOL(do_gettimeofday);
266
267 int do_settimeofday(struct timespec *tv)
268 {
269         time_t wtm_sec, sec = tv->tv_sec;
270         long wtm_nsec, nsec = tv->tv_nsec;
271
272         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
273                 return -EINVAL;
274
275         write_seqlock_irq(&xtime_lock);
276         /*
277          * This is revolting. We need to set "xtime" correctly. However, the
278          * value in this location is the value at the most recent update of
279          * wall time.  Discover what correction gettimeofday() would have
280          * done, and then undo it!
281          */
282         nsec -= system_timer->offset() * NSEC_PER_USEC;
283         nsec -= (jiffies - wall_jiffies) * TICK_NSEC;
284
285         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
286         wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
287
288         set_normalized_timespec(&xtime, sec, nsec);
289         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
290
291         ntp_clear();
292         write_sequnlock_irq(&xtime_lock);
293         clock_was_set();
294         return 0;
295 }
296
297 EXPORT_SYMBOL(do_settimeofday);
298
299 /**
300  * save_time_delta - Save the offset between system time and RTC time
301  * @delta: pointer to timespec to store delta
302  * @rtc: pointer to timespec for current RTC time
303  *
304  * Return a delta between the system time and the RTC time, such
305  * that system time can be restored later with restore_time_delta()
306  */
307 void save_time_delta(struct timespec *delta, struct timespec *rtc)
308 {
309         set_normalized_timespec(delta,
310                                 xtime.tv_sec - rtc->tv_sec,
311                                 xtime.tv_nsec - rtc->tv_nsec);
312 }
313 EXPORT_SYMBOL(save_time_delta);
314
315 /**
316  * restore_time_delta - Restore the current system time
317  * @delta: delta returned by save_time_delta()
318  * @rtc: pointer to timespec for current RTC time
319  */
320 void restore_time_delta(struct timespec *delta, struct timespec *rtc)
321 {
322         struct timespec ts;
323
324         set_normalized_timespec(&ts,
325                                 delta->tv_sec + rtc->tv_sec,
326                                 delta->tv_nsec + rtc->tv_nsec);
327
328         do_settimeofday(&ts);
329 }
330 EXPORT_SYMBOL(restore_time_delta);
331
332 /*
333  * Kernel system timer support.
334  */
335 void timer_tick(struct pt_regs *regs)
336 {
337         profile_tick(CPU_PROFILING, regs);
338         do_leds();
339         do_set_rtc();
340         do_timer(regs);
341 #ifndef CONFIG_SMP
342         update_process_times(user_mode(regs));
343 #endif
344 }
345
346 #ifdef CONFIG_PM
347 static int timer_suspend(struct sys_device *dev, pm_message_t state)
348 {
349         struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
350
351         if (timer->suspend != NULL)
352                 timer->suspend();
353
354         return 0;
355 }
356
357 static int timer_resume(struct sys_device *dev)
358 {
359         struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
360
361         if (timer->resume != NULL)
362                 timer->resume();
363
364         return 0;
365 }
366 #else
367 #define timer_suspend NULL
368 #define timer_resume NULL
369 #endif
370
371 static struct sysdev_class timer_sysclass = {
372         set_kset_name("timer"),
373         .suspend        = timer_suspend,
374         .resume         = timer_resume,
375 };
376
377 #ifdef CONFIG_NO_IDLE_HZ
378 static int timer_dyn_tick_enable(void)
379 {
380         struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
381         unsigned long flags;
382         int ret = -ENODEV;
383
384         if (dyn_tick) {
385                 write_seqlock_irqsave(&xtime_lock, flags);
386                 ret = 0;
387                 if (!(dyn_tick->state & DYN_TICK_ENABLED)) {
388                         ret = dyn_tick->enable();
389
390                         if (ret == 0)
391                                 dyn_tick->state |= DYN_TICK_ENABLED;
392                 }
393                 write_sequnlock_irqrestore(&xtime_lock, flags);
394         }
395
396         return ret;
397 }
398
399 static int timer_dyn_tick_disable(void)
400 {
401         struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
402         unsigned long flags;
403         int ret = -ENODEV;
404
405         if (dyn_tick) {
406                 write_seqlock_irqsave(&xtime_lock, flags);
407                 ret = 0;
408                 if (dyn_tick->state & DYN_TICK_ENABLED) {
409                         ret = dyn_tick->disable();
410
411                         if (ret == 0)
412                                 dyn_tick->state &= ~DYN_TICK_ENABLED;
413                 }
414                 write_sequnlock_irqrestore(&xtime_lock, flags);
415         }
416
417         return ret;
418 }
419
420 /*
421  * Reprogram the system timer for at least the calculated time interval.
422  * This function should be called from the idle thread with IRQs disabled,
423  * immediately before sleeping.
424  */
425 void timer_dyn_reprogram(void)
426 {
427         struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
428
429         if (dyn_tick) {
430                 write_seqlock(&xtime_lock);
431                 if (dyn_tick->state & DYN_TICK_ENABLED)
432                         dyn_tick->reprogram(next_timer_interrupt() - jiffies);
433                 write_sequnlock(&xtime_lock);
434         }
435 }
436
437 static ssize_t timer_show_dyn_tick(struct sys_device *dev, char *buf)
438 {
439         return sprintf(buf, "%i\n",
440                        (system_timer->dyn_tick->state & DYN_TICK_ENABLED) >> 1);
441 }
442
443 static ssize_t timer_set_dyn_tick(struct sys_device *dev, const char *buf,
444                                   size_t count)
445 {
446         unsigned int enable = simple_strtoul(buf, NULL, 2);
447
448         if (enable)
449                 timer_dyn_tick_enable();
450         else
451                 timer_dyn_tick_disable();
452
453         return count;
454 }
455 static SYSDEV_ATTR(dyn_tick, 0644, timer_show_dyn_tick, timer_set_dyn_tick);
456
457 /*
458  * dyntick=enable|disable
459  */
460 static char dyntick_str[4] __initdata = "";
461
462 static int __init dyntick_setup(char *str)
463 {
464         if (str)
465                 strlcpy(dyntick_str, str, sizeof(dyntick_str));
466         return 1;
467 }
468
469 __setup("dyntick=", dyntick_setup);
470 #endif
471
472 static int __init timer_init_sysfs(void)
473 {
474         int ret = sysdev_class_register(&timer_sysclass);
475         if (ret == 0) {
476                 system_timer->dev.cls = &timer_sysclass;
477                 ret = sysdev_register(&system_timer->dev);
478         }
479
480 #ifdef CONFIG_NO_IDLE_HZ
481         if (ret == 0 && system_timer->dyn_tick) {
482                 ret = sysdev_create_file(&system_timer->dev, &attr_dyn_tick);
483
484                 /*
485                  * Turn on dynamic tick after calibrate delay
486                  * for correct bogomips
487                  */
488                 if (ret == 0 && dyntick_str[0] == 'e')
489                         ret = timer_dyn_tick_enable();
490         }
491 #endif
492
493         return ret;
494 }
495
496 device_initcall(timer_init_sysfs);
497
498 void __init time_init(void)
499 {
500         if (system_timer->offset == NULL)
501                 system_timer->offset = dummy_gettimeoffset;
502         system_timer->init();
503 }
504