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