Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
8c24594d | 2 | * arch/sh/kernel/time_32.c |
1da177e4 LT |
3 | * |
4 | * Copyright (C) 1999 Tetsuya Okada & Niibe Yutaka | |
5 | * Copyright (C) 2000 Philipp Rumpf <prumpf@tux.org> | |
8c24594d | 6 | * Copyright (C) 2002 - 2008 Paul Mundt |
1da177e4 LT |
7 | * Copyright (C) 2002 M. R. Brown <mrbrown@linux-sh.org> |
8 | * | |
9 | * Some code taken from i386 version. | |
10 | * Copyright (C) 1991, 1992, 1995 Linus Torvalds | |
11 | */ | |
1da177e4 | 12 | #include <linux/kernel.h> |
36ddf31b | 13 | #include <linux/module.h> |
1da177e4 | 14 | #include <linux/init.h> |
1da177e4 | 15 | #include <linux/profile.h> |
65e5d90d PM |
16 | #include <linux/timex.h> |
17 | #include <linux/sched.h> | |
57be2b48 | 18 | #include <linux/clockchips.h> |
fa43972f | 19 | #include <linux/mc146818rtc.h> /* for rtc_lock */ |
eaab8919 | 20 | #include <linux/platform_device.h> |
8c24594d | 21 | #include <linux/smp.h> |
47c8a08b | 22 | #include <linux/rtc.h> |
36ddf31b | 23 | #include <asm/clock.h> |
1da177e4 | 24 | #include <asm/rtc.h> |
36ddf31b | 25 | #include <asm/timer.h> |
1da177e4 | 26 | #include <asm/kgdb.h> |
1da177e4 | 27 | |
36ddf31b PM |
28 | struct sys_timer *sys_timer; |
29 | ||
30 | /* Move this somewhere more sensible.. */ | |
31 | DEFINE_SPINLOCK(rtc_lock); | |
32 | EXPORT_SYMBOL(rtc_lock); | |
1da177e4 | 33 | |
91550f71 PM |
34 | /* Dummy RTC ops */ |
35 | static void null_rtc_get_time(struct timespec *tv) | |
36 | { | |
37 | tv->tv_sec = mktime(2000, 1, 1, 0, 0, 0); | |
38 | tv->tv_nsec = 0; | |
39 | } | |
40 | ||
41 | static int null_rtc_set_time(const time_t secs) | |
42 | { | |
43 | return 0; | |
44 | } | |
45 | ||
46 | void (*rtc_sh_get_time)(struct timespec *) = null_rtc_get_time; | |
47 | int (*rtc_sh_set_time)(const time_t) = null_rtc_set_time; | |
1da177e4 | 48 | |
47c8a08b PM |
49 | unsigned int get_rtc_time(struct rtc_time *tm) |
50 | { | |
51 | if (rtc_sh_get_time != null_rtc_get_time) { | |
52 | struct timespec tv; | |
53 | ||
54 | rtc_sh_get_time(&tv); | |
55 | rtc_time_to_tm(tv.tv_sec, tm); | |
56 | } | |
57 | ||
58 | return RTC_24H; | |
59 | } | |
60 | EXPORT_SYMBOL(get_rtc_time); | |
61 | ||
62 | int set_rtc_time(struct rtc_time *tm) | |
63 | { | |
64 | unsigned long secs; | |
65 | ||
66 | rtc_tm_to_time(tm, &secs); | |
67 | return rtc_sh_set_time(secs); | |
68 | } | |
69 | EXPORT_SYMBOL(set_rtc_time); | |
70 | ||
45882145 | 71 | #ifndef CONFIG_GENERIC_TIME |
1da177e4 LT |
72 | void do_gettimeofday(struct timeval *tv) |
73 | { | |
e74b5680 | 74 | unsigned long flags; |
1da177e4 LT |
75 | unsigned long seq; |
76 | unsigned long usec, sec; | |
1da177e4 LT |
77 | |
78 | do { | |
e74b5680 PM |
79 | /* |
80 | * Turn off IRQs when grabbing xtime_lock, so that | |
81 | * the sys_timer get_offset code doesn't have to handle it. | |
82 | */ | |
83 | seq = read_seqbegin_irqsave(&xtime_lock, flags); | |
36ddf31b | 84 | usec = get_timer_offset(); |
1da177e4 | 85 | sec = xtime.tv_sec; |
e74b5680 PM |
86 | usec += xtime.tv_nsec / NSEC_PER_USEC; |
87 | } while (read_seqretry_irqrestore(&xtime_lock, seq, flags)); | |
1da177e4 LT |
88 | |
89 | while (usec >= 1000000) { | |
90 | usec -= 1000000; | |
91 | sec++; | |
92 | } | |
93 | ||
94 | tv->tv_sec = sec; | |
95 | tv->tv_usec = usec; | |
96 | } | |
1da177e4 LT |
97 | EXPORT_SYMBOL(do_gettimeofday); |
98 | ||
99 | int do_settimeofday(struct timespec *tv) | |
100 | { | |
101 | time_t wtm_sec, sec = tv->tv_sec; | |
102 | long wtm_nsec, nsec = tv->tv_nsec; | |
103 | ||
104 | if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC) | |
105 | return -EINVAL; | |
106 | ||
107 | write_seqlock_irq(&xtime_lock); | |
108 | /* | |
109 | * This is revolting. We need to set "xtime" correctly. However, the | |
110 | * value in this location is the value at the most recent update of | |
111 | * wall time. Discover what correction gettimeofday() would have | |
112 | * made, and then undo it! | |
113 | */ | |
e74b5680 | 114 | nsec -= get_timer_offset() * NSEC_PER_USEC; |
1da177e4 LT |
115 | |
116 | wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec); | |
117 | wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec); | |
118 | ||
119 | set_normalized_timespec(&xtime, sec, nsec); | |
120 | set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec); | |
121 | ||
b149ee22 | 122 | ntp_clear(); |
1da177e4 LT |
123 | write_sequnlock_irq(&xtime_lock); |
124 | clock_was_set(); | |
125 | ||
126 | return 0; | |
127 | } | |
1da177e4 | 128 | EXPORT_SYMBOL(do_settimeofday); |
45882145 | 129 | #endif /* !CONFIG_GENERIC_TIME */ |
1da177e4 LT |
130 | |
131 | /* last time the RTC clock got updated */ | |
132 | static long last_rtc_update; | |
133 | ||
134 | /* | |
36ddf31b | 135 | * handle_timer_tick() needs to keep up the real-time clock, |
1da177e4 LT |
136 | * as well as call the "do_timer()" routine every clocktick |
137 | */ | |
35f3c518 | 138 | void handle_timer_tick(void) |
1da177e4 | 139 | { |
35f3c518 PM |
140 | if (current->pid) |
141 | profile_tick(CPU_PROFILING); | |
1da177e4 | 142 | |
960c65e8 PZ |
143 | /* |
144 | * Here we are in the timer irq handler. We just have irqs locally | |
145 | * disabled but we don't know if the timer_bh is running on the other | |
146 | * CPU. We need to avoid to SMP race with it. NOTE: we don' t need | |
147 | * the irq version of write_lock because as just said we have irq | |
148 | * locally disabled. -arca | |
149 | */ | |
150 | write_seqlock(&xtime_lock); | |
151 | do_timer(1); | |
152 | ||
1da177e4 LT |
153 | /* |
154 | * If we have an externally synchronized Linux clock, then update | |
155 | * RTC clock accordingly every ~11 minutes. Set_rtc_mmss() has to be | |
156 | * called as close as possible to 500 ms before the new second starts. | |
157 | */ | |
b149ee22 | 158 | if (ntp_synced() && |
1da177e4 LT |
159 | xtime.tv_sec > last_rtc_update + 660 && |
160 | (xtime.tv_nsec / 1000) >= 500000 - ((unsigned) TICK_SIZE) / 2 && | |
161 | (xtime.tv_nsec / 1000) <= 500000 + ((unsigned) TICK_SIZE) / 2) { | |
af514ca7 | 162 | if (rtc_sh_set_time(xtime.tv_sec) == 0) |
1da177e4 LT |
163 | last_rtc_update = xtime.tv_sec; |
164 | else | |
36ddf31b PM |
165 | /* do it again in 60s */ |
166 | last_rtc_update = xtime.tv_sec - 600; | |
1da177e4 | 167 | } |
960c65e8 PZ |
168 | write_sequnlock(&xtime_lock); |
169 | ||
170 | #ifndef CONFIG_SMP | |
171 | update_process_times(user_mode(get_irq_regs())); | |
172 | #endif | |
1da177e4 LT |
173 | } |
174 | ||
3aa770e7 AS |
175 | #ifdef CONFIG_PM |
176 | int timer_suspend(struct sys_device *dev, pm_message_t state) | |
177 | { | |
178 | struct sys_timer *sys_timer = container_of(dev, struct sys_timer, dev); | |
179 | ||
180 | sys_timer->ops->stop(); | |
181 | ||
182 | return 0; | |
183 | } | |
184 | ||
185 | int timer_resume(struct sys_device *dev) | |
186 | { | |
187 | struct sys_timer *sys_timer = container_of(dev, struct sys_timer, dev); | |
188 | ||
189 | sys_timer->ops->start(); | |
190 | ||
191 | return 0; | |
192 | } | |
193 | #else | |
194 | #define timer_suspend NULL | |
195 | #define timer_resume NULL | |
196 | #endif | |
197 | ||
36ddf31b | 198 | static struct sysdev_class timer_sysclass = { |
af5ca3f4 | 199 | .name = "timer", |
3aa770e7 AS |
200 | .suspend = timer_suspend, |
201 | .resume = timer_resume, | |
1da177e4 LT |
202 | }; |
203 | ||
57be2b48 | 204 | static int __init timer_init_sysfs(void) |
bd156147 | 205 | { |
07821d33 MD |
206 | int ret; |
207 | ||
208 | if (!sys_timer) | |
209 | return 0; | |
210 | ||
211 | ret = sysdev_class_register(&timer_sysclass); | |
57be2b48 PM |
212 | if (ret != 0) |
213 | return ret; | |
bd156147 | 214 | |
57be2b48 PM |
215 | sys_timer->dev.cls = &timer_sysclass; |
216 | return sysdev_register(&sys_timer->dev); | |
bd156147 | 217 | } |
57be2b48 | 218 | device_initcall(timer_init_sysfs); |
bd156147 | 219 | |
57be2b48 | 220 | void (*board_time_init)(void); |
bd156147 | 221 | |
955c0778 | 222 | struct clocksource clocksource_sh = { |
57be2b48 | 223 | .name = "SuperH", |
57be2b48 | 224 | }; |
bd156147 | 225 | |
57be2b48 PM |
226 | #ifdef CONFIG_GENERIC_TIME |
227 | unsigned long long sched_clock(void) | |
bd156147 | 228 | { |
955c0778 MD |
229 | unsigned long long cycles; |
230 | ||
231 | /* jiffies based sched_clock if no clocksource is installed */ | |
232 | if (!clocksource_sh.rating) | |
233 | return (unsigned long long)jiffies * (NSEC_PER_SEC / HZ); | |
234 | ||
8e19608e | 235 | cycles = clocksource_sh.read(&clocksource_sh); |
955c0778 | 236 | return cyc2ns(&clocksource_sh, cycles); |
bd156147 | 237 | } |
bd156147 PM |
238 | #endif |
239 | ||
1da177e4 LT |
240 | void __init time_init(void) |
241 | { | |
1da177e4 LT |
242 | if (board_time_init) |
243 | board_time_init(); | |
244 | ||
36ddf31b | 245 | clk_init(); |
1da177e4 | 246 | |
91550f71 PM |
247 | rtc_sh_get_time(&xtime); |
248 | set_normalized_timespec(&wall_to_monotonic, | |
249 | -xtime.tv_sec, -xtime.tv_nsec); | |
1da177e4 | 250 | |
53c01d2d PM |
251 | #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST |
252 | local_timer_setup(smp_processor_id()); | |
253 | #endif | |
254 | ||
eaab8919 MD |
255 | /* |
256 | * Make sure all compiled-in early timers register themselves. | |
257 | * Run probe() for one "earlytimer" device. | |
258 | */ | |
259 | early_platform_driver_register_all("earlytimer"); | |
260 | if (early_platform_driver_probe("earlytimer", 1, 0)) | |
261 | return; | |
262 | ||
1da177e4 | 263 | /* |
36ddf31b PM |
264 | * Find the timer to use as the system timer, it will be |
265 | * initialized for us. | |
1da177e4 | 266 | */ |
36ddf31b | 267 | sys_timer = get_sys_timer(); |
07821d33 MD |
268 | if (unlikely(!sys_timer)) |
269 | panic("System timer missing.\n"); | |
270 | ||
36ddf31b | 271 | printk(KERN_INFO "Using %s for system timer\n", sys_timer->name); |
1da177e4 | 272 | } |