2 * arch/sh/kernel/time.c
4 * Copyright (C) 1999 Tetsuya Okada & Niibe Yutaka
5 * Copyright (C) 2000 Philipp Rumpf <prumpf@tux.org>
6 * Copyright (C) 2002 - 2006 Paul Mundt
7 * Copyright (C) 2002 M. R. Brown <mrbrown@linux-sh.org>
9 * Some code taken from i386 version.
10 * Copyright (C) 1991, 1992, 1995 Linus Torvalds
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/profile.h>
16 #include <linux/timex.h>
17 #include <linux/sched.h>
18 #include <asm/clock.h>
20 #include <asm/timer.h>
23 struct sys_timer
*sys_timer
;
25 /* Move this somewhere more sensible.. */
26 DEFINE_SPINLOCK(rtc_lock
);
27 EXPORT_SYMBOL(rtc_lock
);
30 static void null_rtc_get_time(struct timespec
*tv
)
32 tv
->tv_sec
= mktime(2000, 1, 1, 0, 0, 0);
36 static int null_rtc_set_time(const time_t secs
)
41 void (*rtc_sh_get_time
)(struct timespec
*) = null_rtc_get_time
;
42 int (*rtc_sh_set_time
)(const time_t) = null_rtc_set_time
;
45 * Scheduler clock - returns current time in nanosec units.
47 unsigned long long __attribute__ ((weak
)) sched_clock(void)
49 return (unsigned long long)jiffies
* (1000000000 / HZ
);
52 #ifndef CONFIG_GENERIC_TIME
53 void do_gettimeofday(struct timeval
*tv
)
57 unsigned long usec
, sec
;
61 * Turn off IRQs when grabbing xtime_lock, so that
62 * the sys_timer get_offset code doesn't have to handle it.
64 seq
= read_seqbegin_irqsave(&xtime_lock
, flags
);
65 usec
= get_timer_offset();
67 usec
+= xtime
.tv_nsec
/ NSEC_PER_USEC
;
68 } while (read_seqretry_irqrestore(&xtime_lock
, seq
, flags
));
70 while (usec
>= 1000000) {
78 EXPORT_SYMBOL(do_gettimeofday
);
80 int do_settimeofday(struct timespec
*tv
)
82 time_t wtm_sec
, sec
= tv
->tv_sec
;
83 long wtm_nsec
, nsec
= tv
->tv_nsec
;
85 if ((unsigned long)tv
->tv_nsec
>= NSEC_PER_SEC
)
88 write_seqlock_irq(&xtime_lock
);
90 * This is revolting. We need to set "xtime" correctly. However, the
91 * value in this location is the value at the most recent update of
92 * wall time. Discover what correction gettimeofday() would have
93 * made, and then undo it!
95 nsec
-= get_timer_offset() * NSEC_PER_USEC
;
97 wtm_sec
= wall_to_monotonic
.tv_sec
+ (xtime
.tv_sec
- sec
);
98 wtm_nsec
= wall_to_monotonic
.tv_nsec
+ (xtime
.tv_nsec
- nsec
);
100 set_normalized_timespec(&xtime
, sec
, nsec
);
101 set_normalized_timespec(&wall_to_monotonic
, wtm_sec
, wtm_nsec
);
104 write_sequnlock_irq(&xtime_lock
);
109 EXPORT_SYMBOL(do_settimeofday
);
110 #endif /* !CONFIG_GENERIC_TIME */
112 /* last time the RTC clock got updated */
113 static long last_rtc_update
;
116 * handle_timer_tick() needs to keep up the real-time clock,
117 * as well as call the "do_timer()" routine every clocktick
119 void handle_timer_tick(void)
123 update_process_times(user_mode(get_irq_regs()));
126 profile_tick(CPU_PROFILING
);
128 #ifdef CONFIG_HEARTBEAT
129 if (sh_mv
.mv_heartbeat
!= NULL
)
130 sh_mv
.mv_heartbeat();
134 * If we have an externally synchronized Linux clock, then update
135 * RTC clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
136 * called as close as possible to 500 ms before the new second starts.
139 xtime
.tv_sec
> last_rtc_update
+ 660 &&
140 (xtime
.tv_nsec
/ 1000) >= 500000 - ((unsigned) TICK_SIZE
) / 2 &&
141 (xtime
.tv_nsec
/ 1000) <= 500000 + ((unsigned) TICK_SIZE
) / 2) {
142 if (rtc_sh_set_time(xtime
.tv_sec
) == 0)
143 last_rtc_update
= xtime
.tv_sec
;
145 /* do it again in 60s */
146 last_rtc_update
= xtime
.tv_sec
- 600;
151 int timer_suspend(struct sys_device
*dev
, pm_message_t state
)
153 struct sys_timer
*sys_timer
= container_of(dev
, struct sys_timer
, dev
);
155 sys_timer
->ops
->stop();
160 int timer_resume(struct sys_device
*dev
)
162 struct sys_timer
*sys_timer
= container_of(dev
, struct sys_timer
, dev
);
164 sys_timer
->ops
->start();
169 #define timer_suspend NULL
170 #define timer_resume NULL
173 static struct sysdev_class timer_sysclass
= {
174 set_kset_name("timer"),
175 .suspend
= timer_suspend
,
176 .resume
= timer_resume
,
179 #ifdef CONFIG_NO_IDLE_HZ
180 static int timer_dyn_tick_enable(void)
182 struct dyn_tick_timer
*dyn_tick
= sys_timer
->dyn_tick
;
187 spin_lock_irqsave(&dyn_tick
->lock
, flags
);
189 if (!(dyn_tick
->state
& DYN_TICK_ENABLED
)) {
190 ret
= dyn_tick
->enable();
193 dyn_tick
->state
|= DYN_TICK_ENABLED
;
195 spin_unlock_irqrestore(&dyn_tick
->lock
, flags
);
201 static int timer_dyn_tick_disable(void)
203 struct dyn_tick_timer
*dyn_tick
= sys_timer
->dyn_tick
;
208 spin_lock_irqsave(&dyn_tick
->lock
, flags
);
210 if (dyn_tick
->state
& DYN_TICK_ENABLED
) {
211 ret
= dyn_tick
->disable();
214 dyn_tick
->state
&= ~DYN_TICK_ENABLED
;
216 spin_unlock_irqrestore(&dyn_tick
->lock
, flags
);
223 * Reprogram the system timer for at least the calculated time interval.
224 * This function should be called from the idle thread with IRQs disabled,
225 * immediately before sleeping.
227 void timer_dyn_reprogram(void)
229 struct dyn_tick_timer
*dyn_tick
= sys_timer
->dyn_tick
;
230 unsigned long next
, seq
, flags
;
235 spin_lock_irqsave(&dyn_tick
->lock
, flags
);
236 if (dyn_tick
->state
& DYN_TICK_ENABLED
) {
237 next
= next_timer_interrupt();
239 seq
= read_seqbegin(&xtime_lock
);
240 dyn_tick
->reprogram(next
- jiffies
);
241 } while (read_seqretry(&xtime_lock
, seq
));
243 spin_unlock_irqrestore(&dyn_tick
->lock
, flags
);
246 static ssize_t
timer_show_dyn_tick(struct sys_device
*dev
, char *buf
)
248 return sprintf(buf
, "%i\n",
249 (sys_timer
->dyn_tick
->state
& DYN_TICK_ENABLED
) >> 1);
252 static ssize_t
timer_set_dyn_tick(struct sys_device
*dev
, const char *buf
,
255 unsigned int enable
= simple_strtoul(buf
, NULL
, 2);
258 timer_dyn_tick_enable();
260 timer_dyn_tick_disable();
264 static SYSDEV_ATTR(dyn_tick
, 0644, timer_show_dyn_tick
, timer_set_dyn_tick
);
267 * dyntick=enable|disable
269 static char dyntick_str
[4] __initdata
= "";
271 static int __init
dyntick_setup(char *str
)
274 strlcpy(dyntick_str
, str
, sizeof(dyntick_str
));
278 __setup("dyntick=", dyntick_setup
);
281 static int __init
timer_init_sysfs(void)
283 int ret
= sysdev_class_register(&timer_sysclass
);
287 sys_timer
->dev
.cls
= &timer_sysclass
;
288 ret
= sysdev_register(&sys_timer
->dev
);
290 #ifdef CONFIG_NO_IDLE_HZ
291 if (ret
== 0 && sys_timer
->dyn_tick
) {
292 ret
= sysdev_create_file(&sys_timer
->dev
, &attr_dyn_tick
);
295 * Turn on dynamic tick after calibrate delay
296 * for correct bogomips
298 if (ret
== 0 && dyntick_str
[0] == 'e')
299 ret
= timer_dyn_tick_enable();
305 device_initcall(timer_init_sysfs
);
307 void (*board_time_init
)(void);
309 void __init
time_init(void)
316 rtc_sh_get_time(&xtime
);
317 set_normalized_timespec(&wall_to_monotonic
,
318 -xtime
.tv_sec
, -xtime
.tv_nsec
);
321 * Find the timer to use as the system timer, it will be
322 * initialized for us.
324 sys_timer
= get_sys_timer();
325 printk(KERN_INFO
"Using %s for system timer\n", sys_timer
->name
);
327 #ifdef CONFIG_NO_IDLE_HZ
328 if (sys_timer
->dyn_tick
)
329 spin_lock_init(&sys_timer
->dyn_tick
->lock
);
332 #if defined(CONFIG_SH_KGDB)
334 * Set up kgdb as requested. We do it here because the serial
335 * init uses the timer vars we just set up for figuring baud.