Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | */ | |
1da177e4 LT |
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> | |
d43c36dc | 24 | #include <linux/sched.h> |
1da177e4 LT |
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> | |
e317c8cc | 31 | #include <linux/irq.h> |
1da177e4 | 32 | |
9ca3f07b BD |
33 | #include <linux/mc146818rtc.h> |
34 | ||
1da177e4 LT |
35 | #include <asm/leds.h> |
36 | #include <asm/thread_info.h> | |
2d7c11bf | 37 | #include <asm/stacktrace.h> |
1da177e4 LT |
38 | #include <asm/mach/time.h> |
39 | ||
1da177e4 LT |
40 | /* |
41 | * Our system timer. | |
42 | */ | |
43 | struct sys_timer *system_timer; | |
44 | ||
9dd34948 | 45 | #if defined(CONFIG_RTC_DRV_CMOS) || defined(CONFIG_RTC_DRV_CMOS_MODULE) |
1da177e4 LT |
46 | /* this needs a better home */ |
47 | DEFINE_SPINLOCK(rtc_lock); | |
48 | ||
9dd34948 | 49 | #ifdef CONFIG_RTC_DRV_CMOS_MODULE |
1da177e4 LT |
50 | EXPORT_SYMBOL(rtc_lock); |
51 | #endif | |
9dd34948 | 52 | #endif /* pc-style 'CMOS' RTC support */ |
1da177e4 LT |
53 | |
54 | /* change this if you have some constant time drift */ | |
55 | #define USECS_PER_JIFFY (1000000/HZ) | |
56 | ||
57 | #ifdef CONFIG_SMP | |
58 | unsigned long profile_pc(struct pt_regs *regs) | |
59 | { | |
2d7c11bf | 60 | struct stackframe frame; |
1da177e4 | 61 | |
2d7c11bf CM |
62 | if (!in_lock_functions(regs->ARM_pc)) |
63 | return regs->ARM_pc; | |
1da177e4 | 64 | |
2d7c11bf CM |
65 | frame.fp = regs->ARM_fp; |
66 | frame.sp = regs->ARM_sp; | |
67 | frame.lr = regs->ARM_lr; | |
68 | frame.pc = regs->ARM_pc; | |
69 | do { | |
70 | int ret = unwind_frame(&frame); | |
71 | if (ret < 0) | |
72 | return 0; | |
73 | } while (in_lock_functions(frame.pc)); | |
74 | ||
75 | return frame.pc; | |
1da177e4 LT |
76 | } |
77 | EXPORT_SYMBOL(profile_pc); | |
78 | #endif | |
79 | ||
80 | /* | |
81 | * hook for setting the RTC's idea of the current time. | |
82 | */ | |
83 | int (*set_rtc)(void); | |
84 | ||
746140c7 | 85 | #ifndef CONFIG_GENERIC_TIME |
1da177e4 LT |
86 | static unsigned long dummy_gettimeoffset(void) |
87 | { | |
88 | return 0; | |
89 | } | |
746140c7 | 90 | #endif |
1da177e4 | 91 | |
1da177e4 LT |
92 | static unsigned long next_rtc_update; |
93 | ||
94 | /* | |
95 | * If we have an externally synchronized linux clock, then update | |
96 | * CMOS clock accordingly every ~11 minutes. set_rtc() has to be | |
97 | * called as close as possible to 500 ms before the new second | |
98 | * starts. | |
99 | */ | |
100 | static inline void do_set_rtc(void) | |
101 | { | |
b149ee22 | 102 | if (!ntp_synced() || set_rtc == NULL) |
1da177e4 LT |
103 | return; |
104 | ||
105 | if (next_rtc_update && | |
106 | time_before((unsigned long)xtime.tv_sec, next_rtc_update)) | |
107 | return; | |
108 | ||
109 | if (xtime.tv_nsec < 500000000 - ((unsigned) tick_nsec >> 1) && | |
110 | xtime.tv_nsec >= 500000000 + ((unsigned) tick_nsec >> 1)) | |
111 | return; | |
112 | ||
113 | if (set_rtc()) | |
114 | /* | |
115 | * rtc update failed. Try again in 60s | |
116 | */ | |
117 | next_rtc_update = xtime.tv_sec + 60; | |
118 | else | |
119 | next_rtc_update = xtime.tv_sec + 660; | |
120 | } | |
121 | ||
122 | #ifdef CONFIG_LEDS | |
123 | ||
124 | static void dummy_leds_event(led_event_t evt) | |
125 | { | |
126 | } | |
127 | ||
128 | void (*leds_event)(led_event_t) = dummy_leds_event; | |
129 | ||
130 | struct leds_evt_name { | |
131 | const char name[8]; | |
132 | int on; | |
133 | int off; | |
134 | }; | |
135 | ||
136 | static const struct leds_evt_name evt_names[] = { | |
137 | { "amber", led_amber_on, led_amber_off }, | |
138 | { "blue", led_blue_on, led_blue_off }, | |
139 | { "green", led_green_on, led_green_off }, | |
140 | { "red", led_red_on, led_red_off }, | |
141 | }; | |
142 | ||
4a0b2b4d AK |
143 | static ssize_t leds_store(struct sys_device *dev, |
144 | struct sysdev_attribute *attr, | |
145 | const char *buf, size_t size) | |
1da177e4 LT |
146 | { |
147 | int ret = -EINVAL, len = strcspn(buf, " "); | |
148 | ||
149 | if (len > 0 && buf[len] == '\0') | |
150 | len--; | |
151 | ||
152 | if (strncmp(buf, "claim", len) == 0) { | |
153 | leds_event(led_claim); | |
154 | ret = size; | |
155 | } else if (strncmp(buf, "release", len) == 0) { | |
156 | leds_event(led_release); | |
157 | ret = size; | |
158 | } else { | |
159 | int i; | |
160 | ||
161 | for (i = 0; i < ARRAY_SIZE(evt_names); i++) { | |
162 | if (strlen(evt_names[i].name) != len || | |
163 | strncmp(buf, evt_names[i].name, len) != 0) | |
164 | continue; | |
165 | if (strncmp(buf+len, " on", 3) == 0) { | |
166 | leds_event(evt_names[i].on); | |
167 | ret = size; | |
168 | } else if (strncmp(buf+len, " off", 4) == 0) { | |
169 | leds_event(evt_names[i].off); | |
170 | ret = size; | |
171 | } | |
172 | break; | |
173 | } | |
174 | } | |
175 | return ret; | |
176 | } | |
177 | ||
178 | static SYSDEV_ATTR(event, 0200, NULL, leds_store); | |
179 | ||
180 | static int leds_suspend(struct sys_device *dev, pm_message_t state) | |
181 | { | |
182 | leds_event(led_stop); | |
183 | return 0; | |
184 | } | |
185 | ||
186 | static int leds_resume(struct sys_device *dev) | |
187 | { | |
188 | leds_event(led_start); | |
189 | return 0; | |
190 | } | |
191 | ||
192 | static int leds_shutdown(struct sys_device *dev) | |
193 | { | |
194 | leds_event(led_halted); | |
195 | return 0; | |
196 | } | |
197 | ||
198 | static struct sysdev_class leds_sysclass = { | |
af5ca3f4 | 199 | .name = "leds", |
1da177e4 LT |
200 | .shutdown = leds_shutdown, |
201 | .suspend = leds_suspend, | |
202 | .resume = leds_resume, | |
203 | }; | |
204 | ||
205 | static struct sys_device leds_device = { | |
206 | .id = 0, | |
207 | .cls = &leds_sysclass, | |
208 | }; | |
209 | ||
210 | static int __init leds_init(void) | |
211 | { | |
212 | int ret; | |
213 | ret = sysdev_class_register(&leds_sysclass); | |
214 | if (ret == 0) | |
215 | ret = sysdev_register(&leds_device); | |
216 | if (ret == 0) | |
217 | ret = sysdev_create_file(&leds_device, &attr_event); | |
218 | return ret; | |
219 | } | |
220 | ||
221 | device_initcall(leds_init); | |
222 | ||
223 | EXPORT_SYMBOL(leds_event); | |
224 | #endif | |
225 | ||
226 | #ifdef CONFIG_LEDS_TIMER | |
227 | static inline void do_leds(void) | |
228 | { | |
6d15cb42 | 229 | static unsigned int count = HZ/2; |
1da177e4 LT |
230 | |
231 | if (--count == 0) { | |
6d15cb42 | 232 | count = HZ/2; |
1da177e4 LT |
233 | leds_event(led_timer); |
234 | } | |
235 | } | |
236 | #else | |
237 | #define do_leds() | |
238 | #endif | |
239 | ||
746140c7 | 240 | #ifndef CONFIG_GENERIC_TIME |
1da177e4 LT |
241 | void do_gettimeofday(struct timeval *tv) |
242 | { | |
243 | unsigned long flags; | |
244 | unsigned long seq; | |
8ef38609 | 245 | unsigned long usec, sec; |
1da177e4 LT |
246 | |
247 | do { | |
248 | seq = read_seqbegin_irqsave(&xtime_lock, flags); | |
249 | usec = system_timer->offset(); | |
1da177e4 LT |
250 | sec = xtime.tv_sec; |
251 | usec += xtime.tv_nsec / 1000; | |
252 | } while (read_seqretry_irqrestore(&xtime_lock, seq, flags)); | |
253 | ||
254 | /* usec may have gone up a lot: be safe */ | |
255 | while (usec >= 1000000) { | |
256 | usec -= 1000000; | |
257 | sec++; | |
258 | } | |
259 | ||
260 | tv->tv_sec = sec; | |
261 | tv->tv_usec = usec; | |
262 | } | |
263 | ||
264 | EXPORT_SYMBOL(do_gettimeofday); | |
265 | ||
266 | int do_settimeofday(struct timespec *tv) | |
267 | { | |
268 | time_t wtm_sec, sec = tv->tv_sec; | |
269 | long wtm_nsec, nsec = tv->tv_nsec; | |
270 | ||
271 | if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC) | |
272 | return -EINVAL; | |
273 | ||
274 | write_seqlock_irq(&xtime_lock); | |
275 | /* | |
276 | * This is revolting. We need to set "xtime" correctly. However, the | |
277 | * value in this location is the value at the most recent update of | |
278 | * wall time. Discover what correction gettimeofday() would have | |
279 | * done, and then undo it! | |
280 | */ | |
281 | nsec -= system_timer->offset() * NSEC_PER_USEC; | |
1da177e4 LT |
282 | |
283 | wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec); | |
284 | wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec); | |
285 | ||
286 | set_normalized_timespec(&xtime, sec, nsec); | |
287 | set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec); | |
288 | ||
b149ee22 | 289 | ntp_clear(); |
1da177e4 LT |
290 | write_sequnlock_irq(&xtime_lock); |
291 | clock_was_set(); | |
292 | return 0; | |
293 | } | |
294 | ||
295 | EXPORT_SYMBOL(do_settimeofday); | |
746140c7 | 296 | #endif /* !CONFIG_GENERIC_TIME */ |
1da177e4 LT |
297 | |
298 | /** | |
299 | * save_time_delta - Save the offset between system time and RTC time | |
300 | * @delta: pointer to timespec to store delta | |
301 | * @rtc: pointer to timespec for current RTC time | |
302 | * | |
303 | * Return a delta between the system time and the RTC time, such | |
304 | * that system time can be restored later with restore_time_delta() | |
305 | */ | |
306 | void save_time_delta(struct timespec *delta, struct timespec *rtc) | |
307 | { | |
308 | set_normalized_timespec(delta, | |
309 | xtime.tv_sec - rtc->tv_sec, | |
310 | xtime.tv_nsec - rtc->tv_nsec); | |
311 | } | |
312 | EXPORT_SYMBOL(save_time_delta); | |
313 | ||
314 | /** | |
315 | * restore_time_delta - Restore the current system time | |
316 | * @delta: delta returned by save_time_delta() | |
317 | * @rtc: pointer to timespec for current RTC time | |
318 | */ | |
319 | void restore_time_delta(struct timespec *delta, struct timespec *rtc) | |
320 | { | |
321 | struct timespec ts; | |
322 | ||
323 | set_normalized_timespec(&ts, | |
324 | delta->tv_sec + rtc->tv_sec, | |
325 | delta->tv_nsec + rtc->tv_nsec); | |
326 | ||
327 | do_settimeofday(&ts); | |
328 | } | |
329 | EXPORT_SYMBOL(restore_time_delta); | |
330 | ||
9e4559dd | 331 | #ifndef CONFIG_GENERIC_CLOCKEVENTS |
1da177e4 LT |
332 | /* |
333 | * Kernel system timer support. | |
334 | */ | |
0cd61b68 | 335 | void timer_tick(void) |
1da177e4 | 336 | { |
e317c8cc | 337 | profile_tick(CPU_PROFILING); |
1da177e4 LT |
338 | do_leds(); |
339 | do_set_rtc(); | |
193c3cc1 | 340 | write_seqlock(&xtime_lock); |
3171a030 | 341 | do_timer(1); |
193c3cc1 | 342 | write_sequnlock(&xtime_lock); |
1da177e4 | 343 | #ifndef CONFIG_SMP |
c97d4869 | 344 | update_process_times(user_mode(get_irq_regs())); |
1da177e4 LT |
345 | #endif |
346 | } | |
9e4559dd | 347 | #endif |
1da177e4 | 348 | |
9e4559dd | 349 | #if defined(CONFIG_PM) && !defined(CONFIG_GENERIC_CLOCKEVENTS) |
1da177e4 LT |
350 | static int timer_suspend(struct sys_device *dev, pm_message_t state) |
351 | { | |
352 | struct sys_timer *timer = container_of(dev, struct sys_timer, dev); | |
353 | ||
354 | if (timer->suspend != NULL) | |
355 | timer->suspend(); | |
356 | ||
357 | return 0; | |
358 | } | |
359 | ||
360 | static int timer_resume(struct sys_device *dev) | |
361 | { | |
362 | struct sys_timer *timer = container_of(dev, struct sys_timer, dev); | |
363 | ||
364 | if (timer->resume != NULL) | |
365 | timer->resume(); | |
366 | ||
367 | return 0; | |
368 | } | |
369 | #else | |
370 | #define timer_suspend NULL | |
371 | #define timer_resume NULL | |
372 | #endif | |
373 | ||
374 | static struct sysdev_class timer_sysclass = { | |
af5ca3f4 | 375 | .name = "timer", |
1da177e4 LT |
376 | .suspend = timer_suspend, |
377 | .resume = timer_resume, | |
378 | }; | |
379 | ||
380 | static int __init timer_init_sysfs(void) | |
381 | { | |
382 | int ret = sysdev_class_register(&timer_sysclass); | |
383 | if (ret == 0) { | |
384 | system_timer->dev.cls = &timer_sysclass; | |
385 | ret = sysdev_register(&system_timer->dev); | |
386 | } | |
8749af68 | 387 | |
1da177e4 LT |
388 | return ret; |
389 | } | |
390 | ||
391 | device_initcall(timer_init_sysfs); | |
392 | ||
393 | void __init time_init(void) | |
394 | { | |
746140c7 | 395 | #ifndef CONFIG_GENERIC_TIME |
1da177e4 LT |
396 | if (system_timer->offset == NULL) |
397 | system_timer->offset = dummy_gettimeoffset; | |
746140c7 | 398 | #endif |
1da177e4 LT |
399 | system_timer->init(); |
400 | } | |
401 |