[PATCH] sh: Simplistic clock framework
[linux-2.6.git] / arch / sh / kernel / time.c
1 /*
2  *  arch/sh/kernel/time.c
3  *
4  *  Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
5  *  Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
6  *  Copyright (C) 2002, 2003, 2004, 2005  Paul Mundt
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  */
12
13 #include <linux/config.h>
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/profile.h>
18 #include <asm/clock.h>
19 #include <asm/rtc.h>
20 #include <asm/timer.h>
21 #include <asm/kgdb.h>
22
23 extern unsigned long wall_jiffies;
24 struct sys_timer *sys_timer;
25
26 /* Move this somewhere more sensible.. */
27 DEFINE_SPINLOCK(rtc_lock);
28 EXPORT_SYMBOL(rtc_lock);
29
30 /* XXX: Can we initialize this in a routine somewhere?  Dreamcast doesn't want
31  * these routines anywhere... */
32 #ifdef CONFIG_SH_RTC
33 void (*rtc_get_time)(struct timespec *) = sh_rtc_gettimeofday;
34 int (*rtc_set_time)(const time_t) = sh_rtc_settimeofday;
35 #else
36 void (*rtc_get_time)(struct timespec *);
37 int (*rtc_set_time)(const time_t);
38 #endif
39
40 /*
41  * Scheduler clock - returns current time in nanosec units.
42  */
43 unsigned long long __attribute__ ((weak)) sched_clock(void)
44 {
45         return (unsigned long long)jiffies * (1000000000 / HZ);
46 }
47
48 void do_gettimeofday(struct timeval *tv)
49 {
50         unsigned long seq;
51         unsigned long usec, sec;
52         unsigned long lost;
53
54         do {
55                 seq = read_seqbegin(&xtime_lock);
56                 usec = get_timer_offset();
57
58                 lost = jiffies - wall_jiffies;
59                 if (lost)
60                         usec += lost * (1000000 / HZ);
61
62                 sec = xtime.tv_sec;
63                 usec += xtime.tv_nsec / 1000;
64         } while (read_seqretry(&xtime_lock, seq));
65
66         while (usec >= 1000000) {
67                 usec -= 1000000;
68                 sec++;
69         }
70
71         tv->tv_sec = sec;
72         tv->tv_usec = usec;
73 }
74
75 EXPORT_SYMBOL(do_gettimeofday);
76
77 int do_settimeofday(struct timespec *tv)
78 {
79         time_t wtm_sec, sec = tv->tv_sec;
80         long wtm_nsec, nsec = tv->tv_nsec;
81
82         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
83                 return -EINVAL;
84
85         write_seqlock_irq(&xtime_lock);
86         /*
87          * This is revolting. We need to set "xtime" correctly. However, the
88          * value in this location is the value at the most recent update of
89          * wall time.  Discover what correction gettimeofday() would have
90          * made, and then undo it!
91          */
92         nsec -= 1000 * (get_timer_offset() +
93                                 (jiffies - wall_jiffies) * (1000000 / HZ));
94
95         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
96         wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
97
98         set_normalized_timespec(&xtime, sec, nsec);
99         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
100
101         ntp_clear();
102         write_sequnlock_irq(&xtime_lock);
103         clock_was_set();
104
105         return 0;
106 }
107
108 EXPORT_SYMBOL(do_settimeofday);
109
110 /* last time the RTC clock got updated */
111 static long last_rtc_update;
112
113 /*
114  * handle_timer_tick() needs to keep up the real-time clock,
115  * as well as call the "do_timer()" routine every clocktick
116  */
117 void handle_timer_tick(struct pt_regs *regs)
118 {
119         do_timer(regs);
120 #ifndef CONFIG_SMP
121         update_process_times(user_mode(regs));
122 #endif
123         profile_tick(CPU_PROFILING, regs);
124
125 #ifdef CONFIG_HEARTBEAT
126         if (sh_mv.mv_heartbeat != NULL)
127                 sh_mv.mv_heartbeat();
128 #endif
129
130         /*
131          * If we have an externally synchronized Linux clock, then update
132          * RTC clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
133          * called as close as possible to 500 ms before the new second starts.
134          */
135         if (ntp_synced() &&
136             xtime.tv_sec > last_rtc_update + 660 &&
137             (xtime.tv_nsec / 1000) >= 500000 - ((unsigned) TICK_SIZE) / 2 &&
138             (xtime.tv_nsec / 1000) <= 500000 + ((unsigned) TICK_SIZE) / 2) {
139                 if (rtc_set_time(xtime.tv_sec) == 0)
140                         last_rtc_update = xtime.tv_sec;
141                 else
142                         /* do it again in 60s */
143                         last_rtc_update = xtime.tv_sec - 600;
144         }
145 }
146
147 static struct sysdev_class timer_sysclass = {
148         set_kset_name("timer"),
149 };
150
151 static int __init timer_init_sysfs(void)
152 {
153         int ret = sysdev_class_register(&timer_sysclass);
154         if (ret != 0)
155                 return ret;
156
157         sys_timer->dev.cls = &timer_sysclass;
158         return sysdev_register(&sys_timer->dev);
159 }
160
161 device_initcall(timer_init_sysfs);
162
163 void (*board_time_init)(void);
164
165 void __init time_init(void)
166 {
167         if (board_time_init)
168                 board_time_init();
169
170         clk_init();
171
172         if (rtc_get_time) {
173                 rtc_get_time(&xtime);
174         } else {
175                 xtime.tv_sec = mktime(2000, 1, 1, 0, 0, 0);
176                 xtime.tv_nsec = 0;
177         }
178
179         set_normalized_timespec(&wall_to_monotonic,
180                                 -xtime.tv_sec, -xtime.tv_nsec);
181
182         /*
183          * Find the timer to use as the system timer, it will be
184          * initialized for us.
185          */
186         sys_timer = get_sys_timer();
187         printk(KERN_INFO "Using %s for system timer\n", sys_timer->name);
188
189 #if defined(CONFIG_SH_KGDB)
190         /*
191          * Set up kgdb as requested. We do it here because the serial
192          * init uses the timer vars we just set up for figuring baud.
193          */
194         kgdb_init();
195 #endif
196 }