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 - 2006 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 #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> 19 #include <asm/rtc.h> 20 #include <asm/timer.h> 21 #include <asm/kgdb.h> 22 23 struct sys_timer *sys_timer; 24 25 /* Move this somewhere more sensible.. */ 26 DEFINE_SPINLOCK(rtc_lock); 27 EXPORT_SYMBOL(rtc_lock); 28 29 /* Dummy RTC ops */ 30 static void null_rtc_get_time(struct timespec *tv) 31 { 32 tv->tv_sec = mktime(2000, 1, 1, 0, 0, 0); 33 tv->tv_nsec = 0; 34 } 35 36 static int null_rtc_set_time(const time_t secs) 37 { 38 return 0; 39 } 40 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; 43 44 /* 45 * Scheduler clock - returns current time in nanosec units. 46 */ 47 unsigned long long __attribute__ ((weak)) sched_clock(void) 48 { 49 return (unsigned long long)jiffies * (1000000000 / HZ); 50 } 51 52 #ifndef CONFIG_GENERIC_TIME 53 void do_gettimeofday(struct timeval *tv) 54 { 55 unsigned long flags; 56 unsigned long seq; 57 unsigned long usec, sec; 58 59 do { 60 /* 61 * Turn off IRQs when grabbing xtime_lock, so that 62 * the sys_timer get_offset code doesn't have to handle it. 63 */ 64 seq = read_seqbegin_irqsave(&xtime_lock, flags); 65 usec = get_timer_offset(); 66 sec = xtime.tv_sec; 67 usec += xtime.tv_nsec / NSEC_PER_USEC; 68 } while (read_seqretry_irqrestore(&xtime_lock, seq, flags)); 69 70 while (usec >= 1000000) { 71 usec -= 1000000; 72 sec++; 73 } 74 75 tv->tv_sec = sec; 76 tv->tv_usec = usec; 77 } 78 EXPORT_SYMBOL(do_gettimeofday); 79 80 int do_settimeofday(struct timespec *tv) 81 { 82 time_t wtm_sec, sec = tv->tv_sec; 83 long wtm_nsec, nsec = tv->tv_nsec; 84 85 if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC) 86 return -EINVAL; 87 88 write_seqlock_irq(&xtime_lock); 89 /* 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! 94 */ 95 nsec -= get_timer_offset() * NSEC_PER_USEC; 96 97 wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec); 98 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec); 99 100 set_normalized_timespec(&xtime, sec, nsec); 101 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec); 102 103 ntp_clear(); 104 write_sequnlock_irq(&xtime_lock); 105 clock_was_set(); 106 107 return 0; 108 } 109 EXPORT_SYMBOL(do_settimeofday); 110 #endif /* !CONFIG_GENERIC_TIME */ 111 112 /* last time the RTC clock got updated */ 113 static long last_rtc_update; 114 115 /* 116 * handle_timer_tick() needs to keep up the real-time clock, 117 * as well as call the "do_timer()" routine every clocktick 118 */ 119 void handle_timer_tick(void) 120 { 121 do_timer(1); 122 #ifndef CONFIG_SMP 123 update_process_times(user_mode(get_irq_regs())); 124 #endif 125 if (current->pid) 126 profile_tick(CPU_PROFILING); 127 128 #ifdef CONFIG_HEARTBEAT 129 if (sh_mv.mv_heartbeat != NULL) 130 sh_mv.mv_heartbeat(); 131 #endif 132 133 /* 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. 137 */ 138 if (ntp_synced() && 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; 144 else 145 /* do it again in 60s */ 146 last_rtc_update = xtime.tv_sec - 600; 147 } 148 } 149 150 #ifdef CONFIG_PM 151 int timer_suspend(struct sys_device *dev, pm_message_t state) 152 { 153 struct sys_timer *sys_timer = container_of(dev, struct sys_timer, dev); 154 155 sys_timer->ops->stop(); 156 157 return 0; 158 } 159 160 int timer_resume(struct sys_device *dev) 161 { 162 struct sys_timer *sys_timer = container_of(dev, struct sys_timer, dev); 163 164 sys_timer->ops->start(); 165 166 return 0; 167 } 168 #else 169 #define timer_suspend NULL 170 #define timer_resume NULL 171 #endif 172 173 static struct sysdev_class timer_sysclass = { 174 set_kset_name("timer"), 175 .suspend = timer_suspend, 176 .resume = timer_resume, 177 }; 178 179 #ifdef CONFIG_NO_IDLE_HZ 180 static int timer_dyn_tick_enable(void) 181 { 182 struct dyn_tick_timer *dyn_tick = sys_timer->dyn_tick; 183 unsigned long flags; 184 int ret = -ENODEV; 185 186 if (dyn_tick) { 187 spin_lock_irqsave(&dyn_tick->lock, flags); 188 ret = 0; 189 if (!(dyn_tick->state & DYN_TICK_ENABLED)) { 190 ret = dyn_tick->enable(); 191 192 if (ret == 0) 193 dyn_tick->state |= DYN_TICK_ENABLED; 194 } 195 spin_unlock_irqrestore(&dyn_tick->lock, flags); 196 } 197 198 return ret; 199 } 200 201 static int timer_dyn_tick_disable(void) 202 { 203 struct dyn_tick_timer *dyn_tick = sys_timer->dyn_tick; 204 unsigned long flags; 205 int ret = -ENODEV; 206 207 if (dyn_tick) { 208 spin_lock_irqsave(&dyn_tick->lock, flags); 209 ret = 0; 210 if (dyn_tick->state & DYN_TICK_ENABLED) { 211 ret = dyn_tick->disable(); 212 213 if (ret == 0) 214 dyn_tick->state &= ~DYN_TICK_ENABLED; 215 } 216 spin_unlock_irqrestore(&dyn_tick->lock, flags); 217 } 218 219 return ret; 220 } 221 222 /* 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. 226 */ 227 void timer_dyn_reprogram(void) 228 { 229 struct dyn_tick_timer *dyn_tick = sys_timer->dyn_tick; 230 unsigned long next, seq, flags; 231 232 if (!dyn_tick) 233 return; 234 235 spin_lock_irqsave(&dyn_tick->lock, flags); 236 if (dyn_tick->state & DYN_TICK_ENABLED) { 237 next = next_timer_interrupt(); 238 do { 239 seq = read_seqbegin(&xtime_lock); 240 dyn_tick->reprogram(next - jiffies); 241 } while (read_seqretry(&xtime_lock, seq)); 242 } 243 spin_unlock_irqrestore(&dyn_tick->lock, flags); 244 } 245 246 static ssize_t timer_show_dyn_tick(struct sys_device *dev, char *buf) 247 { 248 return sprintf(buf, "%i\n", 249 (sys_timer->dyn_tick->state & DYN_TICK_ENABLED) >> 1); 250 } 251 252 static ssize_t timer_set_dyn_tick(struct sys_device *dev, const char *buf, 253 size_t count) 254 { 255 unsigned int enable = simple_strtoul(buf, NULL, 2); 256 257 if (enable) 258 timer_dyn_tick_enable(); 259 else 260 timer_dyn_tick_disable(); 261 262 return count; 263 } 264 static SYSDEV_ATTR(dyn_tick, 0644, timer_show_dyn_tick, timer_set_dyn_tick); 265 266 /* 267 * dyntick=enable|disable 268 */ 269 static char dyntick_str[4] __initdata = ""; 270 271 static int __init dyntick_setup(char *str) 272 { 273 if (str) 274 strlcpy(dyntick_str, str, sizeof(dyntick_str)); 275 return 1; 276 } 277 278 __setup("dyntick=", dyntick_setup); 279 #endif 280 281 static int __init timer_init_sysfs(void) 282 { 283 int ret = sysdev_class_register(&timer_sysclass); 284 if (ret != 0) 285 return ret; 286 287 sys_timer->dev.cls = &timer_sysclass; 288 ret = sysdev_register(&sys_timer->dev); 289 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); 293 294 /* 295 * Turn on dynamic tick after calibrate delay 296 * for correct bogomips 297 */ 298 if (ret == 0 && dyntick_str[0] == 'e') 299 ret = timer_dyn_tick_enable(); 300 } 301 #endif 302 303 return ret; 304 } 305 device_initcall(timer_init_sysfs); 306 307 void (*board_time_init)(void); 308 309 void __init time_init(void) 310 { 311 if (board_time_init) 312 board_time_init(); 313 314 clk_init(); 315 316 rtc_sh_get_time(&xtime); 317 set_normalized_timespec(&wall_to_monotonic, 318 -xtime.tv_sec, -xtime.tv_nsec); 319 320 /* 321 * Find the timer to use as the system timer, it will be 322 * initialized for us. 323 */ 324 sys_timer = get_sys_timer(); 325 printk(KERN_INFO "Using %s for system timer\n", sys_timer->name); 326 327 #ifdef CONFIG_NO_IDLE_HZ 328 if (sys_timer->dyn_tick) 329 spin_lock_init(&sys_timer->dyn_tick->lock); 330 #endif 331 332 #if defined(CONFIG_SH_KGDB) 333 /* 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. 336 */ 337 kgdb_init(); 338 #endif 339 } 340