blob: 4cdc4a0bd02d6ebe94038e5f5fcd80da2b945324 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#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>
Frederik Deweerdte317c8c2006-10-06 18:58:24 +000030#include <linux/irq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
Ben Dooks9ca3f072006-12-24 01:36:35 +010032#include <linux/mc146818rtc.h>
33
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <asm/leds.h>
35#include <asm/thread_info.h>
Catalin Marinas2d7c11b2009-02-11 13:07:53 +010036#include <asm/stacktrace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <asm/mach/time.h>
38
Linus Torvalds1da177e2005-04-16 15:20:36 -070039/*
40 * Our system timer.
41 */
42struct sys_timer *system_timer;
43
David Brownell9dd34942007-01-17 22:11:27 +010044#if defined(CONFIG_RTC_DRV_CMOS) || defined(CONFIG_RTC_DRV_CMOS_MODULE)
Linus Torvalds1da177e2005-04-16 15:20:36 -070045/* this needs a better home */
46DEFINE_SPINLOCK(rtc_lock);
47
David Brownell9dd34942007-01-17 22:11:27 +010048#ifdef CONFIG_RTC_DRV_CMOS_MODULE
Linus Torvalds1da177e2005-04-16 15:20:36 -070049EXPORT_SYMBOL(rtc_lock);
50#endif
David Brownell9dd34942007-01-17 22:11:27 +010051#endif /* pc-style 'CMOS' RTC support */
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
53/* change this if you have some constant time drift */
54#define USECS_PER_JIFFY (1000000/HZ)
55
56#ifdef CONFIG_SMP
57unsigned long profile_pc(struct pt_regs *regs)
58{
Catalin Marinas2d7c11b2009-02-11 13:07:53 +010059 struct stackframe frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Catalin Marinas2d7c11b2009-02-11 13:07:53 +010061 if (!in_lock_functions(regs->ARM_pc))
62 return regs->ARM_pc;
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
Catalin Marinas2d7c11b2009-02-11 13:07:53 +010064 frame.fp = regs->ARM_fp;
65 frame.sp = regs->ARM_sp;
66 frame.lr = regs->ARM_lr;
67 frame.pc = regs->ARM_pc;
68 do {
69 int ret = unwind_frame(&frame);
70 if (ret < 0)
71 return 0;
72 } while (in_lock_functions(frame.pc));
73
74 return frame.pc;
Linus Torvalds1da177e2005-04-16 15:20:36 -070075}
76EXPORT_SYMBOL(profile_pc);
77#endif
78
79/*
80 * hook for setting the RTC's idea of the current time.
81 */
82int (*set_rtc)(void);
83
Kevin Hilman746140c2006-09-22 00:16:30 +010084#ifndef CONFIG_GENERIC_TIME
Linus Torvalds1da177e2005-04-16 15:20:36 -070085static unsigned long dummy_gettimeoffset(void)
86{
87 return 0;
88}
Kevin Hilman746140c2006-09-22 00:16:30 +010089#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
Linus Torvalds1da177e2005-04-16 15:20:36 -070091static 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 */
99static inline void do_set_rtc(void)
100{
john stultzb149ee22005-09-06 15:17:46 -0700101 if (!ntp_synced() || set_rtc == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 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
123static void dummy_leds_event(led_event_t evt)
124{
125}
126
127void (*leds_event)(led_event_t) = dummy_leds_event;
128
129struct leds_evt_name {
130 const char name[8];
131 int on;
132 int off;
133};
134
135static 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
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200142static ssize_t leds_store(struct sys_device *dev,
143 struct sysdev_attribute *attr,
144 const char *buf, size_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145{
146 int ret = -EINVAL, len = strcspn(buf, " ");
147
148 if (len > 0 && buf[len] == '\0')
149 len--;
150
151 if (strncmp(buf, "claim", len) == 0) {
152 leds_event(led_claim);
153 ret = size;
154 } else if (strncmp(buf, "release", len) == 0) {
155 leds_event(led_release);
156 ret = size;
157 } else {
158 int i;
159
160 for (i = 0; i < ARRAY_SIZE(evt_names); i++) {
161 if (strlen(evt_names[i].name) != len ||
162 strncmp(buf, evt_names[i].name, len) != 0)
163 continue;
164 if (strncmp(buf+len, " on", 3) == 0) {
165 leds_event(evt_names[i].on);
166 ret = size;
167 } else if (strncmp(buf+len, " off", 4) == 0) {
168 leds_event(evt_names[i].off);
169 ret = size;
170 }
171 break;
172 }
173 }
174 return ret;
175}
176
177static SYSDEV_ATTR(event, 0200, NULL, leds_store);
178
179static int leds_suspend(struct sys_device *dev, pm_message_t state)
180{
181 leds_event(led_stop);
182 return 0;
183}
184
185static int leds_resume(struct sys_device *dev)
186{
187 leds_event(led_start);
188 return 0;
189}
190
191static int leds_shutdown(struct sys_device *dev)
192{
193 leds_event(led_halted);
194 return 0;
195}
196
197static struct sysdev_class leds_sysclass = {
Kay Sieversaf5ca3f2007-12-20 02:09:39 +0100198 .name = "leds",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 .shutdown = leds_shutdown,
200 .suspend = leds_suspend,
201 .resume = leds_resume,
202};
203
204static struct sys_device leds_device = {
205 .id = 0,
206 .cls = &leds_sysclass,
207};
208
209static int __init leds_init(void)
210{
211 int ret;
212 ret = sysdev_class_register(&leds_sysclass);
213 if (ret == 0)
214 ret = sysdev_register(&leds_device);
215 if (ret == 0)
216 ret = sysdev_create_file(&leds_device, &attr_event);
217 return ret;
218}
219
220device_initcall(leds_init);
221
222EXPORT_SYMBOL(leds_event);
223#endif
224
225#ifdef CONFIG_LEDS_TIMER
226static inline void do_leds(void)
227{
David Brownell6d15cb42006-11-06 19:29:16 +0100228 static unsigned int count = HZ/2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
230 if (--count == 0) {
David Brownell6d15cb42006-11-06 19:29:16 +0100231 count = HZ/2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 leds_event(led_timer);
233 }
234}
235#else
236#define do_leds()
237#endif
238
Kevin Hilman746140c2006-09-22 00:16:30 +0100239#ifndef CONFIG_GENERIC_TIME
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240void do_gettimeofday(struct timeval *tv)
241{
242 unsigned long flags;
243 unsigned long seq;
Atsushi Nemoto8ef38602006-09-30 23:28:31 -0700244 unsigned long usec, sec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245
246 do {
247 seq = read_seqbegin_irqsave(&xtime_lock, flags);
248 usec = system_timer->offset();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 sec = xtime.tv_sec;
250 usec += xtime.tv_nsec / 1000;
251 } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
252
253 /* usec may have gone up a lot: be safe */
254 while (usec >= 1000000) {
255 usec -= 1000000;
256 sec++;
257 }
258
259 tv->tv_sec = sec;
260 tv->tv_usec = usec;
261}
262
263EXPORT_SYMBOL(do_gettimeofday);
264
265int do_settimeofday(struct timespec *tv)
266{
267 time_t wtm_sec, sec = tv->tv_sec;
268 long wtm_nsec, nsec = tv->tv_nsec;
269
270 if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
271 return -EINVAL;
272
273 write_seqlock_irq(&xtime_lock);
274 /*
275 * This is revolting. We need to set "xtime" correctly. However, the
276 * value in this location is the value at the most recent update of
277 * wall time. Discover what correction gettimeofday() would have
278 * done, and then undo it!
279 */
280 nsec -= system_timer->offset() * NSEC_PER_USEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
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
john stultzb149ee22005-09-06 15:17:46 -0700288 ntp_clear();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 write_sequnlock_irq(&xtime_lock);
290 clock_was_set();
291 return 0;
292}
293
294EXPORT_SYMBOL(do_settimeofday);
Kevin Hilman746140c2006-09-22 00:16:30 +0100295#endif /* !CONFIG_GENERIC_TIME */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296
297/**
298 * save_time_delta - Save the offset between system time and RTC time
299 * @delta: pointer to timespec to store delta
300 * @rtc: pointer to timespec for current RTC time
301 *
302 * Return a delta between the system time and the RTC time, such
303 * that system time can be restored later with restore_time_delta()
304 */
305void save_time_delta(struct timespec *delta, struct timespec *rtc)
306{
307 set_normalized_timespec(delta,
308 xtime.tv_sec - rtc->tv_sec,
309 xtime.tv_nsec - rtc->tv_nsec);
310}
311EXPORT_SYMBOL(save_time_delta);
312
313/**
314 * restore_time_delta - Restore the current system time
315 * @delta: delta returned by save_time_delta()
316 * @rtc: pointer to timespec for current RTC time
317 */
318void restore_time_delta(struct timespec *delta, struct timespec *rtc)
319{
320 struct timespec ts;
321
322 set_normalized_timespec(&ts,
323 delta->tv_sec + rtc->tv_sec,
324 delta->tv_nsec + rtc->tv_nsec);
325
326 do_settimeofday(&ts);
327}
328EXPORT_SYMBOL(restore_time_delta);
329
Kevin Hilman9e4559d2007-03-14 17:33:24 +0100330#ifndef CONFIG_GENERIC_CLOCKEVENTS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331/*
332 * Kernel system timer support.
333 */
Linus Torvalds0cd61b62006-10-06 10:53:39 -0700334void timer_tick(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335{
Frederik Deweerdte317c8c2006-10-06 18:58:24 +0000336 profile_tick(CPU_PROFILING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 do_leds();
338 do_set_rtc();
Russell King193c3cc2008-01-28 10:16:37 +0000339 write_seqlock(&xtime_lock);
Atsushi Nemoto3171a032006-09-29 02:00:32 -0700340 do_timer(1);
Russell King193c3cc2008-01-28 10:16:37 +0000341 write_sequnlock(&xtime_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342#ifndef CONFIG_SMP
Russell Kingc97d4862006-10-25 13:59:16 +0100343 update_process_times(user_mode(get_irq_regs()));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344#endif
345}
Kevin Hilman9e4559d2007-03-14 17:33:24 +0100346#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
Kevin Hilman9e4559d2007-03-14 17:33:24 +0100348#if defined(CONFIG_PM) && !defined(CONFIG_GENERIC_CLOCKEVENTS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349static int timer_suspend(struct sys_device *dev, pm_message_t state)
350{
351 struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
352
353 if (timer->suspend != NULL)
354 timer->suspend();
355
356 return 0;
357}
358
359static int timer_resume(struct sys_device *dev)
360{
361 struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
362
363 if (timer->resume != NULL)
364 timer->resume();
365
366 return 0;
367}
368#else
369#define timer_suspend NULL
370#define timer_resume NULL
371#endif
372
373static struct sysdev_class timer_sysclass = {
Kay Sieversaf5ca3f2007-12-20 02:09:39 +0100374 .name = "timer",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 .suspend = timer_suspend,
376 .resume = timer_resume,
377};
378
379static int __init timer_init_sysfs(void)
380{
381 int ret = sysdev_class_register(&timer_sysclass);
382 if (ret == 0) {
383 system_timer->dev.cls = &timer_sysclass;
384 ret = sysdev_register(&system_timer->dev);
385 }
Russell King8749af62005-06-25 19:39:45 +0100386
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 return ret;
388}
389
390device_initcall(timer_init_sysfs);
391
392void __init time_init(void)
393{
Kevin Hilman746140c2006-09-22 00:16:30 +0100394#ifndef CONFIG_GENERIC_TIME
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 if (system_timer->offset == NULL)
396 system_timer->offset = dummy_gettimeoffset;
Kevin Hilman746140c2006-09-22 00:16:30 +0100397#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 system_timer->init();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399}
400