git.oblomov.eu Git - 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 static unsigned long next_rtc_update;
  83
  84 /*
  85  * If we have an externally synchronized linux clock, then update
  86  * CMOS clock accordingly every ~11 minutes.  set_rtc() has to be
  87  * called as close as possible to 500 ms before the new second
  88  * starts.
  89  */
  90 static inline void do_set_rtc(void)
  91 {
  92         if (!ntp_synced() || set_rtc == NULL)
  93                 return;
  94
  95         if (next_rtc_update &&
  96             time_before((unsigned long)xtime.tv_sec, next_rtc_update))
  97                 return;
  98
  99         if (xtime.tv_nsec < 500000000 - ((unsigned) tick_nsec >> 1) &&
 100             xtime.tv_nsec >= 500000000 + ((unsigned) tick_nsec >> 1))
 101                 return;
 102
 103         if (set_rtc())
 104                 /*
 105                  * rtc update failed.  Try again in 60s
 106                  */
 107                 next_rtc_update = xtime.tv_sec + 60;
 108         else
 109                 next_rtc_update = xtime.tv_sec + 660;
 110 }
 111
 112 #ifdef CONFIG_LEDS
 113
 114 static void dummy_leds_event(led_event_t evt)
 115 {
 116 }
 117
 118 void (*leds_event)(led_event_t) = dummy_leds_event;
 119
 120 struct leds_evt_name {
 121         const char      name[8];
 122         int             on;
 123         int             off;
 124 };
 125
 126 static const struct leds_evt_name evt_names[] = {
 127         { "amber", led_amber_on, led_amber_off },
 128         { "blue",  led_blue_on,  led_blue_off  },
 129         { "green", led_green_on, led_green_off },
 130         { "red",   led_red_on,   led_red_off   },
 131 };
 132
 133 static ssize_t leds_store(struct sys_device *dev, const char *buf, size_t size)
 134 {
 135         int ret = -EINVAL, len = strcspn(buf, " ");
 136
 137         if (len > 0 && buf[len] == '\0')
 138                 len--;
 139
 140         if (strncmp(buf, "claim", len) == 0) {
 141                 leds_event(led_claim);
 142                 ret = size;
 143         } else if (strncmp(buf, "release", len) == 0) {
 144                 leds_event(led_release);
 145                 ret = size;
 146         } else {
 147                 int i;
 148
 149                 for (i = 0; i < ARRAY_SIZE(evt_names); i++) {
 150                         if (strlen(evt_names[i].name) != len ||
 151                             strncmp(buf, evt_names[i].name, len) != 0)
 152                                 continue;
 153                         if (strncmp(buf+len, " on", 3) == 0) {
 154                                 leds_event(evt_names[i].on);
 155                                 ret = size;
 156                         } else if (strncmp(buf+len, " off", 4) == 0) {
 157                                 leds_event(evt_names[i].off);
 158                                 ret = size;
 159                         }
 160                         break;
 161                 }
 162         }
 163         return ret;
 164 }
 165
 166 static SYSDEV_ATTR(event, 0200, NULL, leds_store);
 167
 168 static int leds_suspend(struct sys_device *dev, pm_message_t state)
 169 {
 170         leds_event(led_stop);
 171         return 0;
 172 }
 173
 174 static int leds_resume(struct sys_device *dev)
 175 {
 176         leds_event(led_start);
 177         return 0;
 178 }
 179
 180 static int leds_shutdown(struct sys_device *dev)
 181 {
 182         leds_event(led_halted);
 183         return 0;
 184 }
 185
 186 static struct sysdev_class leds_sysclass = {
 187         .name           = "leds",
 188         .shutdown       = leds_shutdown,
 189         .suspend        = leds_suspend,
 190         .resume         = leds_resume,
 191 };
 192
 193 static struct sys_device leds_device = {
 194         .id             = 0,
 195         .cls            = &leds_sysclass,
 196 };
 197
 198 static int __init leds_init(void)
 199 {
 200         int ret;
 201         ret = sysdev_class_register(&leds_sysclass);
 202         if (ret == 0)
 203                 ret = sysdev_register(&leds_device);
 204         if (ret == 0)
 205                 ret = sysdev_create_file(&leds_device, &attr_event);
 206         return ret;
 207 }
 208
 209 device_initcall(leds_init);
 210
 211 EXPORT_SYMBOL(leds_event);
 212 #endif
 213
 214 #ifdef CONFIG_LEDS_TIMER
 215 static inline void do_leds(void)
 216 {
 217         static unsigned int count = HZ/2;
 218
 219         if (--count == 0) {
 220                 count = HZ/2;
 221                 leds_event(led_timer);
 222         }
 223 }
 224 #else
 225 #define do_leds()
 226 #endif
 227
 228 #ifndef CONFIG_GENERIC_TIME
 229 void do_gettimeofday(struct timeval *tv)
 230 {
 231         unsigned long flags;
 232         unsigned long seq;
 233         unsigned long usec, sec;
 234
 235         do {
 236                 seq = read_seqbegin_irqsave(&xtime_lock, flags);
 237                 usec = system_timer->offset();
 238                 sec = xtime.tv_sec;
 239                 usec += xtime.tv_nsec / 1000;
 240         } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
 241
 242         /* usec may have gone up a lot: be safe */
 243         while (usec >= 1000000) {
 244                 usec -= 1000000;
 245                 sec++;
 246         }
 247
 248         tv->tv_sec = sec;
 249         tv->tv_usec = usec;
 250 }
 251
 252 EXPORT_SYMBOL(do_gettimeofday);
 253
 254 int do_settimeofday(struct timespec *tv)
 255 {
 256         time_t wtm_sec, sec = tv->tv_sec;
 257         long wtm_nsec, nsec = tv->tv_nsec;
 258
 259         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
 260                 return -EINVAL;
 261
 262         write_seqlock_irq(&xtime_lock);
 263         /*
 264          * This is revolting. We need to set "xtime" correctly. However, the
 265          * value in this location is the value at the most recent update of
 266          * wall time.  Discover what correction gettimeofday() would have
 267          * done, and then undo it!
 268          */
 269         nsec -= system_timer->offset() * NSEC_PER_USEC;
 270
 271         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
 272         wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
 273
 274         set_normalized_timespec(&xtime, sec, nsec);
 275         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
 276
 277         ntp_clear();
 278         write_sequnlock_irq(&xtime_lock);
 279         clock_was_set();
 280         return 0;
 281 }
 282
 283 EXPORT_SYMBOL(do_settimeofday);
 284 #endif /* !CONFIG_GENERIC_TIME */
 285
 286 /**
 287  * save_time_delta - Save the offset between system time and RTC time
 288  * @delta: pointer to timespec to store delta
 289  * @rtc: pointer to timespec for current RTC time
 290  *
 291  * Return a delta between the system time and the RTC time, such
 292  * that system time can be restored later with restore_time_delta()
 293  */
 294 void save_time_delta(struct timespec *delta, struct timespec *rtc)
 295 {
 296         set_normalized_timespec(delta,
 297                                 xtime.tv_sec - rtc->tv_sec,
 298                                 xtime.tv_nsec - rtc->tv_nsec);
 299 }
 300 EXPORT_SYMBOL(save_time_delta);
 301
 302 /**
 303  * restore_time_delta - Restore the current system time
 304  * @delta: delta returned by save_time_delta()
 305  * @rtc: pointer to timespec for current RTC time
 306  */
 307 void restore_time_delta(struct timespec *delta, struct timespec *rtc)
 308 {
 309         struct timespec ts;
 310
 311         set_normalized_timespec(&ts,
 312                                 delta->tv_sec + rtc->tv_sec,
 313                                 delta->tv_nsec + rtc->tv_nsec);
 314
 315         do_settimeofday(&ts);
 316 }
 317 EXPORT_SYMBOL(restore_time_delta);
 318
 319 #ifndef CONFIG_GENERIC_CLOCKEVENTS
 320 /*
 321  * Kernel system timer support.
 322  */
 323 void timer_tick(void)
 324 {
 325         profile_tick(CPU_PROFILING);
 326         do_leds();
 327         do_set_rtc();
 328         write_seqlock(&xtime_lock);
 329         do_timer(1);
 330         write_sequnlock(&xtime_lock);
 331 #ifndef CONFIG_SMP
 332         update_process_times(user_mode(get_irq_regs()));
 333 #endif
 334 }
 335 #endif
 336
 337 #if defined(CONFIG_PM) && !defined(CONFIG_GENERIC_CLOCKEVENTS)
 338 static int timer_suspend(struct sys_device *dev, pm_message_t state)
 339 {
 340         struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
 341
 342         if (timer->suspend != NULL)
 343                 timer->suspend();
 344
 345         return 0;
 346 }
 347
 348 static int timer_resume(struct sys_device *dev)
 349 {
 350         struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
 351
 352         if (timer->resume != NULL)
 353                 timer->resume();
 354
 355         return 0;
 356 }
 357 #else
 358 #define timer_suspend NULL
 359 #define timer_resume NULL
 360 #endif
 361
 362 static struct sysdev_class timer_sysclass = {
 363         .name           = "timer",
 364         .suspend        = timer_suspend,
 365         .resume         = timer_resume,
 366 };
 367
 368 #ifdef CONFIG_NO_IDLE_HZ
 369 static int timer_dyn_tick_enable(void)
 370 {
 371         struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
 372         unsigned long flags;
 373         int ret = -ENODEV;
 374
 375         if (dyn_tick) {
 376                 spin_lock_irqsave(&dyn_tick->lock, flags);
 377                 ret = 0;
 378                 if (!(dyn_tick->state & DYN_TICK_ENABLED)) {
 379                         ret = dyn_tick->enable();
 380
 381                         if (ret == 0)
 382                                 dyn_tick->state |= DYN_TICK_ENABLED;
 383                 }
 384                 spin_unlock_irqrestore(&dyn_tick->lock, flags);
 385         }
 386
 387         return ret;
 388 }
 389
 390 static int timer_dyn_tick_disable(void)
 391 {
 392         struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
 393         unsigned long flags;
 394         int ret = -ENODEV;
 395
 396         if (dyn_tick) {
 397                 spin_lock_irqsave(&dyn_tick->lock, flags);
 398                 ret = 0;
 399                 if (dyn_tick->state & DYN_TICK_ENABLED) {
 400                         ret = dyn_tick->disable();
 401
 402                         if (ret == 0)
 403                                 dyn_tick->state &= ~DYN_TICK_ENABLED;
 404                 }
 405                 spin_unlock_irqrestore(&dyn_tick->lock, flags);
 406         }
 407
 408         return ret;
 409 }
 410
 411 /*
 412  * Reprogram the system timer for at least the calculated time interval.
 413  * This function should be called from the idle thread with IRQs disabled,
 414  * immediately before sleeping.
 415  */
 416 void timer_dyn_reprogram(void)
 417 {
 418         struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
 419         unsigned long next, seq, flags;
 420
 421         if (!dyn_tick)
 422                 return;
 423
 424         spin_lock_irqsave(&dyn_tick->lock, flags);
 425         if (dyn_tick->state & DYN_TICK_ENABLED) {
 426                 next = next_timer_interrupt();
 427                 do {
 428                         seq = read_seqbegin(&xtime_lock);
 429                         dyn_tick->reprogram(next - jiffies);
 430                 } while (read_seqretry(&xtime_lock, seq));
 431         }
 432         spin_unlock_irqrestore(&dyn_tick->lock, flags);
 433 }
 434
 435 static ssize_t timer_show_dyn_tick(struct sys_device *dev, char *buf)
 436 {
 437         return sprintf(buf, "%i\n",
 438                        (system_timer->dyn_tick->state & DYN_TICK_ENABLED) >> 1);
 439 }
 440
 441 static ssize_t timer_set_dyn_tick(struct sys_device *dev, const char *buf,
 442                                   size_t count)
 443 {
 444         unsigned int enable = simple_strtoul(buf, NULL, 2);
 445
 446         if (enable)
 447                 timer_dyn_tick_enable();
 448         else
 449                 timer_dyn_tick_disable();
 450
 451         return count;
 452 }
 453 static SYSDEV_ATTR(dyn_tick, 0644, timer_show_dyn_tick, timer_set_dyn_tick);
 454
 455 /*
 456  * dyntick=enable|disable
 457  */
 458 static char dyntick_str[4] __initdata = "";
 459
 460 static int __init dyntick_setup(char *str)
 461 {
 462         if (str)
 463                 strlcpy(dyntick_str, str, sizeof(dyntick_str));
 464         return 1;
 465 }
 466
 467 __setup("dyntick=", dyntick_setup);
 468 #endif
 469
 470 static int __init timer_init_sysfs(void)
 471 {
 472         int ret = sysdev_class_register(&timer_sysclass);
 473         if (ret == 0) {
 474                 system_timer->dev.cls = &timer_sysclass;
 475                 ret = sysdev_register(&system_timer->dev);
 476         }
 477
 478 #ifdef CONFIG_NO_IDLE_HZ
 479         if (ret == 0 && system_timer->dyn_tick) {
 480                 ret = sysdev_create_file(&system_timer->dev, &attr_dyn_tick);
 481
 482                 /*
 483                  * Turn on dynamic tick after calibrate delay
 484                  * for correct bogomips
 485                  */
 486                 if (ret == 0 && dyntick_str[0] == 'e')
 487                         ret = timer_dyn_tick_enable();
 488         }
 489 #endif
 490
 491         return ret;
 492 }
 493
 494 device_initcall(timer_init_sysfs);
 495
 496 void __init time_init(void)
 497 {
 498 #ifndef CONFIG_GENERIC_TIME
 499         if (system_timer->offset == NULL)
 500                 system_timer->offset = dummy_gettimeoffset;
 501 #endif
 502         system_timer->init();
 503
 504 #ifdef CONFIG_NO_IDLE_HZ
 505         if (system_timer->dyn_tick)
 506                 spin_lock_init(&system_timer->dyn_tick->lock);
 507 #endif
 508 }
 509