SAFE public projects git trees. - safe/jmp/linux-2.6/blob - arch/arm/kernel/time.c

   1 /*
   2  *  linux/arch/arm/kernel/time.c
   3  *
   4  *  Copyright (C) 1991, 1992, 1995  Linus Torvalds
   5  *  Modifications for ARM (C) 1994-2001 Russell King
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  *  This file contains the ARM-specific time handling details:
  12  *  reading the RTC at bootup, etc...
  13  *
  14  *  1994-07-02  Alan Modra
  15  *              fixed set_rtc_mmss, fixed time.year for >= 2000, new mktime
  16  *  1998-12-20  Updated NTP code according to technical memorandum Jan '96
  17  *              "A Kernel Model for Precision Timekeeping" by Dave Mills
  18  */
  19 #include <linux/module.h>
  20 #include <linux/kernel.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/time.h>
  23 #include <linux/init.h>
  24 #include <linux/smp.h>
  25 #include <linux/timex.h>
  26 #include <linux/errno.h>
  27 #include <linux/profile.h>
  28 #include <linux/sysdev.h>
  29 #include <linux/timer.h>
  30 #include <linux/irq.h>
  31
  32 #include <linux/mc146818rtc.h>
  33
  34 #include <asm/leds.h>
  35 #include <asm/thread_info.h>
  36 #include <asm/mach/time.h>
  37
  38 /*
  39  * Our system timer.
  40  */
  41 struct sys_timer *system_timer;
  42
  43 #if defined(CONFIG_RTC_DRV_CMOS) || defined(CONFIG_RTC_DRV_CMOS_MODULE)
  44 /* this needs a better home */
  45 DEFINE_SPINLOCK(rtc_lock);
  46
  47 #ifdef CONFIG_RTC_DRV_CMOS_MODULE
  48 EXPORT_SYMBOL(rtc_lock);
  49 #endif
  50 #endif  /* pc-style 'CMOS' RTC support */
  51
  52 /* change this if you have some constant time drift */
  53 #define USECS_PER_JIFFY (1000000/HZ)
  54
  55 #ifdef CONFIG_SMP
  56 unsigned long profile_pc(struct pt_regs *regs)
  57 {
  58         unsigned long fp, pc = instruction_pointer(regs);
  59
  60         if (in_lock_functions(pc)) {
  61                 fp = regs->ARM_fp;
  62                 pc = pc_pointer(((unsigned long *)fp)[-1]);
  63         }
  64
  65         return pc;
  66 }
  67 EXPORT_SYMBOL(profile_pc);
  68 #endif
  69
  70 /*
  71  * hook for setting the RTC's idea of the current time.
  72  */
  73 int (*set_rtc)(void);
  74
  75 #ifndef CONFIG_GENERIC_TIME
  76 static unsigned long dummy_gettimeoffset(void)
  77 {
  78         return 0;
  79 }
  80 #endif
  81
  82 /*
  83  * Scheduler clock - returns current time in nanosec units.
  84  * This is the default implementation.  Sub-architecture
  85  * implementations can override this.
  86  */
  87 unsigned long long __attribute__((weak)) sched_clock(void)
  88 {
  89         return (unsigned long long)jiffies * (1000000000 / HZ);
  90 }
  91
  92 /*
  93  * An implementation of printk_clock() independent from
  94  * sched_clock().  This avoids non-bootable kernels when
  95  * printk_clock is enabled.
  96  */
  97 unsigned long long printk_clock(void)
  98 {
  99         return (unsigned long long)(jiffies - INITIAL_JIFFIES) *
 100                         (1000000000 / HZ);
 101 }
 102
 103 static unsigned long next_rtc_update;
 104
 105 /*
 106  * If we have an externally synchronized linux clock, then update
 107  * CMOS clock accordingly every ~11 minutes.  set_rtc() has to be
 108  * called as close as possible to 500 ms before the new second
 109  * starts.
 110  */
 111 static inline void do_set_rtc(void)
 112 {
 113         if (!ntp_synced() || set_rtc == NULL)
 114                 return;
 115
 116         if (next_rtc_update &&
 117             time_before((unsigned long)xtime.tv_sec, next_rtc_update))
 118                 return;
 119
 120         if (xtime.tv_nsec < 500000000 - ((unsigned) tick_nsec >> 1) &&
 121             xtime.tv_nsec >= 500000000 + ((unsigned) tick_nsec >> 1))
 122                 return;
 123
 124         if (set_rtc())
 125                 /*
 126                  * rtc update failed.  Try again in 60s
 127                  */
 128                 next_rtc_update = xtime.tv_sec + 60;
 129         else
 130                 next_rtc_update = xtime.tv_sec + 660;
 131 }
 132
 133 #ifdef CONFIG_LEDS
 134
 135 static void dummy_leds_event(led_event_t evt)
 136 {
 137 }
 138
 139 void (*leds_event)(led_event_t) = dummy_leds_event;
 140
 141 struct leds_evt_name {
 142         const char      name[8];
 143         int             on;
 144         int             off;
 145 };
 146
 147 static const struct leds_evt_name evt_names[] = {
 148         { "amber", led_amber_on, led_amber_off },
 149         { "blue",  led_blue_on,  led_blue_off  },
 150         { "green", led_green_on, led_green_off },
 151         { "red",   led_red_on,   led_red_off   },
 152 };
 153
 154 static ssize_t leds_store(struct sys_device *dev, const char *buf, size_t size)
 155 {
 156         int ret = -EINVAL, len = strcspn(buf, " ");
 157
 158         if (len > 0 && buf[len] == '\0')
 159                 len--;
 160
 161         if (strncmp(buf, "claim", len) == 0) {
 162                 leds_event(led_claim);
 163                 ret = size;
 164         } else if (strncmp(buf, "release", len) == 0) {
 165                 leds_event(led_release);
 166                 ret = size;
 167         } else {
 168                 int i;
 169
 170                 for (i = 0; i < ARRAY_SIZE(evt_names); i++) {
 171                         if (strlen(evt_names[i].name) != len ||
 172                             strncmp(buf, evt_names[i].name, len) != 0)
 173                                 continue;
 174                         if (strncmp(buf+len, " on", 3) == 0) {
 175                                 leds_event(evt_names[i].on);
 176                                 ret = size;
 177                         } else if (strncmp(buf+len, " off", 4) == 0) {
 178                                 leds_event(evt_names[i].off);
 179                                 ret = size;
 180                         }
 181                         break;
 182                 }
 183         }
 184         return ret;
 185 }
 186
 187 static SYSDEV_ATTR(event, 0200, NULL, leds_store);
 188
 189 static int leds_suspend(struct sys_device *dev, pm_message_t state)
 190 {
 191         leds_event(led_stop);
 192         return 0;
 193 }
 194
 195 static int leds_resume(struct sys_device *dev)
 196 {
 197         leds_event(led_start);
 198         return 0;
 199 }
 200
 201 static int leds_shutdown(struct sys_device *dev)
 202 {
 203         leds_event(led_halted);
 204         return 0;
 205 }
 206
 207 static struct sysdev_class leds_sysclass = {
 208         set_kset_name("leds"),
 209         .shutdown       = leds_shutdown,
 210         .suspend        = leds_suspend,
 211         .resume         = leds_resume,
 212 };
 213
 214 static struct sys_device leds_device = {
 215         .id             = 0,
 216         .cls            = &leds_sysclass,
 217 };
 218
 219 static int __init leds_init(void)
 220 {
 221         int ret;
 222         ret = sysdev_class_register(&leds_sysclass);
 223         if (ret == 0)
 224                 ret = sysdev_register(&leds_device);
 225         if (ret == 0)
 226                 ret = sysdev_create_file(&leds_device, &attr_event);
 227         return ret;
 228 }
 229
 230 device_initcall(leds_init);
 231
 232 EXPORT_SYMBOL(leds_event);
 233 #endif
 234
 235 #ifdef CONFIG_LEDS_TIMER
 236 static inline void do_leds(void)
 237 {
 238         static unsigned int count = HZ/2;
 239
 240         if (--count == 0) {
 241                 count = HZ/2;
 242                 leds_event(led_timer);
 243         }
 244 }
 245 #else
 246 #define do_leds()
 247 #endif
 248
 249 #ifndef CONFIG_GENERIC_TIME
 250 void do_gettimeofday(struct timeval *tv)
 251 {
 252         unsigned long flags;
 253         unsigned long seq;
 254         unsigned long usec, sec;
 255
 256         do {
 257                 seq = read_seqbegin_irqsave(&xtime_lock, flags);
 258                 usec = system_timer->offset();
 259                 sec = xtime.tv_sec;
 260                 usec += xtime.tv_nsec / 1000;
 261         } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
 262
 263         /* usec may have gone up a lot: be safe */
 264         while (usec >= 1000000) {
 265                 usec -= 1000000;
 266                 sec++;
 267         }
 268
 269         tv->tv_sec = sec;
 270         tv->tv_usec = usec;
 271 }
 272
 273 EXPORT_SYMBOL(do_gettimeofday);
 274
 275 int do_settimeofday(struct timespec *tv)
 276 {
 277         time_t wtm_sec, sec = tv->tv_sec;
 278         long wtm_nsec, nsec = tv->tv_nsec;
 279
 280         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
 281                 return -EINVAL;
 282
 283         write_seqlock_irq(&xtime_lock);
 284         /*
 285          * This is revolting. We need to set "xtime" correctly. However, the
 286          * value in this location is the value at the most recent update of
 287          * wall time.  Discover what correction gettimeofday() would have
 288          * done, and then undo it!
 289          */
 290         nsec -= system_timer->offset() * NSEC_PER_USEC;
 291
 292         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
 293         wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
 294
 295         set_normalized_timespec(&xtime, sec, nsec);
 296         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
 297
 298         ntp_clear();
 299         write_sequnlock_irq(&xtime_lock);
 300         clock_was_set();
 301         return 0;
 302 }
 303
 304 EXPORT_SYMBOL(do_settimeofday);
 305 #endif /* !CONFIG_GENERIC_TIME */
 306
 307 /**
 308  * save_time_delta - Save the offset between system time and RTC time
 309  * @delta: pointer to timespec to store delta
 310  * @rtc: pointer to timespec for current RTC time
 311  *
 312  * Return a delta between the system time and the RTC time, such
 313  * that system time can be restored later with restore_time_delta()
 314  */
 315 void save_time_delta(struct timespec *delta, struct timespec *rtc)
 316 {
 317         set_normalized_timespec(delta,
 318                                 xtime.tv_sec - rtc->tv_sec,
 319                                 xtime.tv_nsec - rtc->tv_nsec);
 320 }
 321 EXPORT_SYMBOL(save_time_delta);
 322
 323 /**
 324  * restore_time_delta - Restore the current system time
 325  * @delta: delta returned by save_time_delta()
 326  * @rtc: pointer to timespec for current RTC time
 327  */
 328 void restore_time_delta(struct timespec *delta, struct timespec *rtc)
 329 {
 330         struct timespec ts;
 331
 332         set_normalized_timespec(&ts,
 333                                 delta->tv_sec + rtc->tv_sec,
 334                                 delta->tv_nsec + rtc->tv_nsec);
 335
 336         do_settimeofday(&ts);
 337 }
 338 EXPORT_SYMBOL(restore_time_delta);
 339
 340 /*
 341  * Kernel system timer support.
 342  */
 343 void timer_tick(void)
 344 {
 345         profile_tick(CPU_PROFILING);
 346         do_leds();
 347         do_set_rtc();
 348         do_timer(1);
 349 #ifndef CONFIG_SMP
 350         update_process_times(user_mode(get_irq_regs()));
 351 #endif
 352 }
 353
 354 #ifdef CONFIG_PM
 355 static int timer_suspend(struct sys_device *dev, pm_message_t state)
 356 {
 357         struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
 358
 359         if (timer->suspend != NULL)
 360                 timer->suspend();
 361
 362         return 0;
 363 }
 364
 365 static int timer_resume(struct sys_device *dev)
 366 {
 367         struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
 368
 369         if (timer->resume != NULL)
 370                 timer->resume();
 371
 372         return 0;
 373 }
 374 #else
 375 #define timer_suspend NULL
 376 #define timer_resume NULL
 377 #endif
 378
 379 static struct sysdev_class timer_sysclass = {
 380         set_kset_name("timer"),
 381         .suspend        = timer_suspend,
 382         .resume         = timer_resume,
 383 };
 384
 385 #ifdef CONFIG_NO_IDLE_HZ
 386 static int timer_dyn_tick_enable(void)
 387 {
 388         struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
 389         unsigned long flags;
 390         int ret = -ENODEV;
 391
 392         if (dyn_tick) {
 393                 spin_lock_irqsave(&dyn_tick->lock, flags);
 394                 ret = 0;
 395                 if (!(dyn_tick->state & DYN_TICK_ENABLED)) {
 396                         ret = dyn_tick->enable();
 397
 398                         if (ret == 0)
 399                                 dyn_tick->state |= DYN_TICK_ENABLED;
 400                 }
 401                 spin_unlock_irqrestore(&dyn_tick->lock, flags);
 402         }
 403
 404         return ret;
 405 }
 406
 407 static int timer_dyn_tick_disable(void)
 408 {
 409         struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
 410         unsigned long flags;
 411         int ret = -ENODEV;
 412
 413         if (dyn_tick) {
 414                 spin_lock_irqsave(&dyn_tick->lock, flags);
 415                 ret = 0;
 416                 if (dyn_tick->state & DYN_TICK_ENABLED) {
 417                         ret = dyn_tick->disable();
 418
 419                         if (ret == 0)
 420                                 dyn_tick->state &= ~DYN_TICK_ENABLED;
 421                 }
 422                 spin_unlock_irqrestore(&dyn_tick->lock, flags);
 423         }
 424
 425         return ret;
 426 }
 427
 428 /*
 429  * Reprogram the system timer for at least the calculated time interval.
 430  * This function should be called from the idle thread with IRQs disabled,
 431  * immediately before sleeping.
 432  */
 433 void timer_dyn_reprogram(void)
 434 {
 435         struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
 436         unsigned long next, seq, flags;
 437
 438         if (!dyn_tick)
 439                 return;
 440
 441         spin_lock_irqsave(&dyn_tick->lock, flags);
 442         if (dyn_tick->state & DYN_TICK_ENABLED) {
 443                 next = next_timer_interrupt();
 444                 do {
 445                         seq = read_seqbegin(&xtime_lock);
 446                         dyn_tick->reprogram(next - jiffies);
 447                 } while (read_seqretry(&xtime_lock, seq));
 448         }
 449         spin_unlock_irqrestore(&dyn_tick->lock, flags);
 450 }
 451
 452 static ssize_t timer_show_dyn_tick(struct sys_device *dev, char *buf)
 453 {
 454         return sprintf(buf, "%i\n",
 455                        (system_timer->dyn_tick->state & DYN_TICK_ENABLED) >> 1);
 456 }
 457
 458 static ssize_t timer_set_dyn_tick(struct sys_device *dev, const char *buf,
 459                                   size_t count)
 460 {
 461         unsigned int enable = simple_strtoul(buf, NULL, 2);
 462
 463         if (enable)
 464                 timer_dyn_tick_enable();
 465         else
 466                 timer_dyn_tick_disable();
 467
 468         return count;
 469 }
 470 static SYSDEV_ATTR(dyn_tick, 0644, timer_show_dyn_tick, timer_set_dyn_tick);
 471
 472 /*
 473  * dyntick=enable|disable
 474  */
 475 static char dyntick_str[4] __initdata = "";
 476
 477 static int __init dyntick_setup(char *str)
 478 {
 479         if (str)
 480                 strlcpy(dyntick_str, str, sizeof(dyntick_str));
 481         return 1;
 482 }
 483
 484 __setup("dyntick=", dyntick_setup);
 485 #endif
 486
 487 static int __init timer_init_sysfs(void)
 488 {
 489         int ret = sysdev_class_register(&timer_sysclass);
 490         if (ret == 0) {
 491                 system_timer->dev.cls = &timer_sysclass;
 492                 ret = sysdev_register(&system_timer->dev);
 493         }
 494
 495 #ifdef CONFIG_NO_IDLE_HZ
 496         if (ret == 0 && system_timer->dyn_tick) {
 497                 ret = sysdev_create_file(&system_timer->dev, &attr_dyn_tick);
 498
 499                 /*
 500                  * Turn on dynamic tick after calibrate delay
 501                  * for correct bogomips
 502                  */
 503                 if (ret == 0 && dyntick_str[0] == 'e')
 504                         ret = timer_dyn_tick_enable();
 505         }
 506 #endif
 507
 508         return ret;
 509 }
 510
 511 device_initcall(timer_init_sysfs);
 512
 513 void __init time_init(void)
 514 {
 515 #ifndef CONFIG_GENERIC_TIME
 516         if (system_timer->offset == NULL)
 517                 system_timer->offset = dummy_gettimeoffset;
 518 #endif
 519         system_timer->init();
 520
 521 #ifdef CONFIG_NO_IDLE_HZ
 522         if (system_timer->dyn_tick)
 523                 system_timer->dyn_tick->lock = SPIN_LOCK_UNLOCKED;
 524 #endif
 525 }
 526