Remove obsolete #include <linux/config.h>
[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/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
31 #include <asm/leds.h>
32 #include <asm/thread_info.h>
33 #include <asm/mach/time.h>
34
35 /*
36  * Our system timer.
37  */
38 struct sys_timer *system_timer;
39
40 extern unsigned long wall_jiffies;
41
42 /* this needs a better home */
43 DEFINE_SPINLOCK(rtc_lock);
44
45 #ifdef CONFIG_SA1100_RTC_MODULE
46 EXPORT_SYMBOL(rtc_lock);
47 #endif
48
49 /* change this if you have some constant time drift */
50 #define USECS_PER_JIFFY (1000000/HZ)
51
52 #ifdef CONFIG_SMP
53 unsigned long profile_pc(struct pt_regs *regs)
54 {
55         unsigned long fp, pc = instruction_pointer(regs);
56
57         if (in_lock_functions(pc)) {
58                 fp = regs->ARM_fp;
59                 pc = pc_pointer(((unsigned long *)fp)[-1]);
60         }
61
62         return pc;
63 }
64 EXPORT_SYMBOL(profile_pc);
65 #endif
66
67 /*
68  * hook for setting the RTC's idea of the current time.
69  */
70 int (*set_rtc)(void);
71
72 static unsigned long dummy_gettimeoffset(void)
73 {
74         return 0;
75 }
76
77 /*
78  * Scheduler clock - returns current time in nanosec units.
79  * This is the default implementation.  Sub-architecture
80  * implementations can override this.
81  */
82 unsigned long long __attribute__((weak)) sched_clock(void)
83 {
84         return (unsigned long long)jiffies * (1000000000 / HZ);
85 }
86
87 static unsigned long next_rtc_update;
88
89 /*
90  * If we have an externally synchronized linux clock, then update
91  * CMOS clock accordingly every ~11 minutes.  set_rtc() has to be
92  * called as close as possible to 500 ms before the new second
93  * starts.
94  */
95 static inline void do_set_rtc(void)
96 {
97         if (!ntp_synced() || set_rtc == NULL)
98                 return;
99
100         if (next_rtc_update &&
101             time_before((unsigned long)xtime.tv_sec, next_rtc_update))
102                 return;
103
104         if (xtime.tv_nsec < 500000000 - ((unsigned) tick_nsec >> 1) &&
105             xtime.tv_nsec >= 500000000 + ((unsigned) tick_nsec >> 1))
106                 return;
107
108         if (set_rtc())
109                 /*
110                  * rtc update failed.  Try again in 60s
111                  */
112                 next_rtc_update = xtime.tv_sec + 60;
113         else
114                 next_rtc_update = xtime.tv_sec + 660;
115 }
116
117 #ifdef CONFIG_LEDS
118
119 static void dummy_leds_event(led_event_t evt)
120 {
121 }
122
123 void (*leds_event)(led_event_t) = dummy_leds_event;
124
125 struct leds_evt_name {
126         const char      name[8];
127         int             on;
128         int             off;
129 };
130
131 static const struct leds_evt_name evt_names[] = {
132         { "amber", led_amber_on, led_amber_off },
133         { "blue",  led_blue_on,  led_blue_off  },
134         { "green", led_green_on, led_green_off },
135         { "red",   led_red_on,   led_red_off   },
136 };
137
138 static ssize_t leds_store(struct sys_device *dev, const char *buf, size_t size)
139 {
140         int ret = -EINVAL, len = strcspn(buf, " ");
141
142         if (len > 0 && buf[len] == '\0')
143                 len--;
144
145         if (strncmp(buf, "claim", len) == 0) {
146                 leds_event(led_claim);
147                 ret = size;
148         } else if (strncmp(buf, "release", len) == 0) {
149                 leds_event(led_release);
150                 ret = size;
151         } else {
152                 int i;
153
154                 for (i = 0; i < ARRAY_SIZE(evt_names); i++) {
155                         if (strlen(evt_names[i].name) != len ||
156                             strncmp(buf, evt_names[i].name, len) != 0)
157                                 continue;
158                         if (strncmp(buf+len, " on", 3) == 0) {
159                                 leds_event(evt_names[i].on);
160                                 ret = size;
161                         } else if (strncmp(buf+len, " off", 4) == 0) {
162                                 leds_event(evt_names[i].off);
163                                 ret = size;
164                         }
165                         break;
166                 }
167         }
168         return ret;
169 }
170
171 static SYSDEV_ATTR(event, 0200, NULL, leds_store);
172
173 static int leds_suspend(struct sys_device *dev, pm_message_t state)
174 {
175         leds_event(led_stop);
176         return 0;
177 }
178
179 static int leds_resume(struct sys_device *dev)
180 {
181         leds_event(led_start);
182         return 0;
183 }
184
185 static int leds_shutdown(struct sys_device *dev)
186 {
187         leds_event(led_halted);
188         return 0;
189 }
190
191 static struct sysdev_class leds_sysclass = {
192         set_kset_name("leds"),
193         .shutdown       = leds_shutdown,
194         .suspend        = leds_suspend,
195         .resume         = leds_resume,
196 };
197
198 static struct sys_device leds_device = {
199         .id             = 0,
200         .cls            = &leds_sysclass,
201 };
202
203 static int __init leds_init(void)
204 {
205         int ret;
206         ret = sysdev_class_register(&leds_sysclass);
207         if (ret == 0)
208                 ret = sysdev_register(&leds_device);
209         if (ret == 0)
210                 ret = sysdev_create_file(&leds_device, &attr_event);
211         return ret;
212 }
213
214 device_initcall(leds_init);
215
216 EXPORT_SYMBOL(leds_event);
217 #endif
218
219 #ifdef CONFIG_LEDS_TIMER
220 static inline void do_leds(void)
221 {
222         static unsigned int count = 50;
223
224         if (--count == 0) {
225                 count = 50;
226                 leds_event(led_timer);
227         }
228 }
229 #else
230 #define do_leds()
231 #endif
232
233 void do_gettimeofday(struct timeval *tv)
234 {
235         unsigned long flags;
236         unsigned long seq;
237         unsigned long usec, sec, lost;
238
239         do {
240                 seq = read_seqbegin_irqsave(&xtime_lock, flags);
241                 usec = system_timer->offset();
242
243                 lost = jiffies - wall_jiffies;
244                 if (lost)
245                         usec += lost * USECS_PER_JIFFY;
246
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         nsec -= (jiffies - wall_jiffies) * TICK_NSEC;
280
281         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
282         wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
283
284         set_normalized_timespec(&xtime, sec, nsec);
285         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
286
287         ntp_clear();
288         write_sequnlock_irq(&xtime_lock);
289         clock_was_set();
290         return 0;
291 }
292
293 EXPORT_SYMBOL(do_settimeofday);
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(struct pt_regs *regs)
332 {
333         profile_tick(CPU_PROFILING, regs);
334         do_leds();
335         do_set_rtc();
336         do_timer(regs);
337 #ifndef CONFIG_SMP
338         update_process_times(user_mode(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         if (system_timer->offset == NULL)
504                 system_timer->offset = dummy_gettimeoffset;
505         system_timer->init();
506
507 #ifdef CONFIG_NO_IDLE_HZ
508         if (system_timer->dyn_tick)
509                 system_timer->dyn_tick->lock = SPIN_LOCK_UNLOCKED;
510 #endif
511 }
512