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 #ifndef CONFIG_GENERIC_TIME 45 void do_gettimeofday(struct timeval *tv) 46 { 47 unsigned long flags; 48 unsigned long seq; 49 unsigned long usec, sec; 50 51 do { 52 /* 53 * Turn off IRQs when grabbing xtime_lock, so that 54 * the sys_timer get_offset code doesn't have to handle it. 55 */ 56 seq = read_seqbegin_irqsave(&xtime_lock, flags); 57 usec = get_timer_offset(); 58 sec = xtime.tv_sec; 59 usec += xtime.tv_nsec / NSEC_PER_USEC; 60 } while (read_seqretry_irqrestore(&xtime_lock, seq, flags)); 61 62 while (usec >= 1000000) { 63 usec -= 1000000; 64 sec++; 65 } 66 67 tv->tv_sec = sec; 68 tv->tv_usec = usec; 69 } 70 EXPORT_SYMBOL(do_gettimeofday); 71 72 int do_settimeofday(struct timespec *tv) 73 { 74 time_t wtm_sec, sec = tv->tv_sec; 75 long wtm_nsec, nsec = tv->tv_nsec; 76 77 if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC) 78 return -EINVAL; 79 80 write_seqlock_irq(&xtime_lock); 81 /* 82 * This is revolting. We need to set "xtime" correctly. However, the 83 * value in this location is the value at the most recent update of 84 * wall time. Discover what correction gettimeofday() would have 85 * made, and then undo it! 86 */ 87 nsec -= get_timer_offset() * NSEC_PER_USEC; 88 89 wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec); 90 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec); 91 92 set_normalized_timespec(&xtime, sec, nsec); 93 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec); 94 95 ntp_clear(); 96 write_sequnlock_irq(&xtime_lock); 97 clock_was_set(); 98 99 return 0; 100 } 101 EXPORT_SYMBOL(do_settimeofday); 102 #endif /* !CONFIG_GENERIC_TIME */ 103 104 /* last time the RTC clock got updated */ 105 static long last_rtc_update; 106 107 /* 108 * handle_timer_tick() needs to keep up the real-time clock, 109 * as well as call the "do_timer()" routine every clocktick 110 */ 111 void handle_timer_tick(void) 112 { 113 do_timer(1); 114 #ifndef CONFIG_SMP 115 update_process_times(user_mode(get_irq_regs())); 116 #endif 117 if (current->pid) 118 profile_tick(CPU_PROFILING); 119 120 #ifdef CONFIG_HEARTBEAT 121 if (sh_mv.mv_heartbeat != NULL) 122 sh_mv.mv_heartbeat(); 123 #endif 124 125 /* 126 * If we have an externally synchronized Linux clock, then update 127 * RTC clock accordingly every ~11 minutes. Set_rtc_mmss() has to be 128 * called as close as possible to 500 ms before the new second starts. 129 */ 130 if (ntp_synced() && 131 xtime.tv_sec > last_rtc_update + 660 && 132 (xtime.tv_nsec / 1000) >= 500000 - ((unsigned) TICK_SIZE) / 2 && 133 (xtime.tv_nsec / 1000) <= 500000 + ((unsigned) TICK_SIZE) / 2) { 134 if (rtc_sh_set_time(xtime.tv_sec) == 0) 135 last_rtc_update = xtime.tv_sec; 136 else 137 /* do it again in 60s */ 138 last_rtc_update = xtime.tv_sec - 600; 139 } 140 } 141 142 #ifdef CONFIG_PM 143 int timer_suspend(struct sys_device *dev, pm_message_t state) 144 { 145 struct sys_timer *sys_timer = container_of(dev, struct sys_timer, dev); 146 147 sys_timer->ops->stop(); 148 149 return 0; 150 } 151 152 int timer_resume(struct sys_device *dev) 153 { 154 struct sys_timer *sys_timer = container_of(dev, struct sys_timer, dev); 155 156 sys_timer->ops->start(); 157 158 return 0; 159 } 160 #else 161 #define timer_suspend NULL 162 #define timer_resume NULL 163 #endif 164 165 static struct sysdev_class timer_sysclass = { 166 set_kset_name("timer"), 167 .suspend = timer_suspend, 168 .resume = timer_resume, 169 }; 170 171 #ifdef CONFIG_NO_IDLE_HZ 172 static int timer_dyn_tick_enable(void) 173 { 174 struct dyn_tick_timer *dyn_tick = sys_timer->dyn_tick; 175 unsigned long flags; 176 int ret = -ENODEV; 177 178 if (dyn_tick) { 179 spin_lock_irqsave(&dyn_tick->lock, flags); 180 ret = 0; 181 if (!(dyn_tick->state & DYN_TICK_ENABLED)) { 182 ret = dyn_tick->enable(); 183 184 if (ret == 0) 185 dyn_tick->state |= DYN_TICK_ENABLED; 186 } 187 spin_unlock_irqrestore(&dyn_tick->lock, flags); 188 } 189 190 return ret; 191 } 192 193 static int timer_dyn_tick_disable(void) 194 { 195 struct dyn_tick_timer *dyn_tick = sys_timer->dyn_tick; 196 unsigned long flags; 197 int ret = -ENODEV; 198 199 if (dyn_tick) { 200 spin_lock_irqsave(&dyn_tick->lock, flags); 201 ret = 0; 202 if (dyn_tick->state & DYN_TICK_ENABLED) { 203 ret = dyn_tick->disable(); 204 205 if (ret == 0) 206 dyn_tick->state &= ~DYN_TICK_ENABLED; 207 } 208 spin_unlock_irqrestore(&dyn_tick->lock, flags); 209 } 210 211 return ret; 212 } 213 214 /* 215 * Reprogram the system timer for at least the calculated time interval. 216 * This function should be called from the idle thread with IRQs disabled, 217 * immediately before sleeping. 218 */ 219 void timer_dyn_reprogram(void) 220 { 221 struct dyn_tick_timer *dyn_tick = sys_timer->dyn_tick; 222 unsigned long next, seq, flags; 223 224 if (!dyn_tick) 225 return; 226 227 spin_lock_irqsave(&dyn_tick->lock, flags); 228 if (dyn_tick->state & DYN_TICK_ENABLED) { 229 next = next_timer_interrupt(); 230 do { 231 seq = read_seqbegin(&xtime_lock); 232 dyn_tick->reprogram(next - jiffies); 233 } while (read_seqretry(&xtime_lock, seq)); 234 } 235 spin_unlock_irqrestore(&dyn_tick->lock, flags); 236 } 237 238 static ssize_t timer_show_dyn_tick(struct sys_device *dev, char *buf) 239 { 240 return sprintf(buf, "%i\n", 241 (sys_timer->dyn_tick->state & DYN_TICK_ENABLED) >> 1); 242 } 243 244 static ssize_t timer_set_dyn_tick(struct sys_device *dev, const char *buf, 245 size_t count) 246 { 247 unsigned int enable = simple_strtoul(buf, NULL, 2); 248 249 if (enable) 250 timer_dyn_tick_enable(); 251 else 252 timer_dyn_tick_disable(); 253 254 return count; 255 } 256 static SYSDEV_ATTR(dyn_tick, 0644, timer_show_dyn_tick, timer_set_dyn_tick); 257 258 /* 259 * dyntick=enable|disable 260 */ 261 static char dyntick_str[4] __initdata = ""; 262 263 static int __init dyntick_setup(char *str) 264 { 265 if (str) 266 strlcpy(dyntick_str, str, sizeof(dyntick_str)); 267 return 1; 268 } 269 270 __setup("dyntick=", dyntick_setup); 271 #endif 272 273 static int __init timer_init_sysfs(void) 274 { 275 int ret = sysdev_class_register(&timer_sysclass); 276 if (ret != 0) 277 return ret; 278 279 sys_timer->dev.cls = &timer_sysclass; 280 ret = sysdev_register(&sys_timer->dev); 281 282 #ifdef CONFIG_NO_IDLE_HZ 283 if (ret == 0 && sys_timer->dyn_tick) { 284 ret = sysdev_create_file(&sys_timer->dev, &attr_dyn_tick); 285 286 /* 287 * Turn on dynamic tick after calibrate delay 288 * for correct bogomips 289 */ 290 if (ret == 0 && dyntick_str[0] == 'e') 291 ret = timer_dyn_tick_enable(); 292 } 293 #endif 294 295 return ret; 296 } 297 device_initcall(timer_init_sysfs); 298 299 void (*board_time_init)(void); 300 301 void __init time_init(void) 302 { 303 if (board_time_init) 304 board_time_init(); 305 306 clk_init(); 307 308 rtc_sh_get_time(&xtime); 309 set_normalized_timespec(&wall_to_monotonic, 310 -xtime.tv_sec, -xtime.tv_nsec); 311 312 /* 313 * Find the timer to use as the system timer, it will be 314 * initialized for us. 315 */ 316 sys_timer = get_sys_timer(); 317 printk(KERN_INFO "Using %s for system timer\n", sys_timer->name); 318 319 #ifdef CONFIG_NO_IDLE_HZ 320 if (sys_timer->dyn_tick) 321 spin_lock_init(&sys_timer->dyn_tick->lock); 322 #endif 323 324 #if defined(CONFIG_SH_KGDB) 325 /* 326 * Set up kgdb as requested. We do it here because the serial 327 * init uses the timer vars we just set up for figuring baud. 328 */ 329 kgdb_init(); 330 #endif 331 } 332