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 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         do_timer(1);
 329 #ifndef CONFIG_SMP
 330         update_process_times(user_mode(get_irq_regs()));
 331 #endif
 332 }
 333 #endif
 334
 335 #if defined(CONFIG_PM) && !defined(CONFIG_GENERIC_CLOCKEVENTS)
 336 static int timer_suspend(struct sys_device *dev, pm_message_t state)
 337 {
 338         struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
 339
 340         if (timer->suspend != NULL)
 341                 timer->suspend();
 342
 343         return 0;
 344 }
 345
 346 static int timer_resume(struct sys_device *dev)
 347 {
 348         struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
 349
 350         if (timer->resume != NULL)
 351                 timer->resume();
 352
 353         return 0;
 354 }
 355 #else
 356 #define timer_suspend NULL
 357 #define timer_resume NULL
 358 #endif
 359
 360 static struct sysdev_class timer_sysclass = {
 361         .name           = "timer",
 362         .suspend        = timer_suspend,
 363         .resume         = timer_resume,
 364 };
 365
 366 #ifdef CONFIG_NO_IDLE_HZ
 367 static int timer_dyn_tick_enable(void)
 368 {
 369         struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
 370         unsigned long flags;
 371         int ret = -ENODEV;
 372
 373         if (dyn_tick) {
 374                 spin_lock_irqsave(&dyn_tick->lock, flags);
 375                 ret = 0;
 376                 if (!(dyn_tick->state & DYN_TICK_ENABLED)) {
 377                         ret = dyn_tick->enable();
 378
 379                         if (ret == 0)
 380                                 dyn_tick->state |= DYN_TICK_ENABLED;
 381                 }
 382                 spin_unlock_irqrestore(&dyn_tick->lock, flags);
 383         }
 384
 385         return ret;
 386 }
 387
 388 static int timer_dyn_tick_disable(void)
 389 {
 390         struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
 391         unsigned long flags;
 392         int ret = -ENODEV;
 393
 394         if (dyn_tick) {
 395                 spin_lock_irqsave(&dyn_tick->lock, flags);
 396                 ret = 0;
 397                 if (dyn_tick->state & DYN_TICK_ENABLED) {
 398                         ret = dyn_tick->disable();
 399
 400                         if (ret == 0)
 401                                 dyn_tick->state &= ~DYN_TICK_ENABLED;
 402                 }
 403                 spin_unlock_irqrestore(&dyn_tick->lock, flags);
 404         }
 405
 406         return ret;
 407 }
 408
 409 /*
 410  * Reprogram the system timer for at least the calculated time interval.
 411  * This function should be called from the idle thread with IRQs disabled,
 412  * immediately before sleeping.
 413  */
 414 void timer_dyn_reprogram(void)
 415 {
 416         struct dyn_tick_timer *dyn_tick = system_timer->dyn_tick;
 417         unsigned long next, seq, flags;
 418
 419         if (!dyn_tick)
 420                 return;
 421
 422         spin_lock_irqsave(&dyn_tick->lock, flags);
 423         if (dyn_tick->state & DYN_TICK_ENABLED) {
 424                 next = next_timer_interrupt();
 425                 do {
 426                         seq = read_seqbegin(&xtime_lock);
 427                         dyn_tick->reprogram(next - jiffies);
 428                 } while (read_seqretry(&xtime_lock, seq));
 429         }
 430         spin_unlock_irqrestore(&dyn_tick->lock, flags);
 431 }
 432
 433 static ssize_t timer_show_dyn_tick(struct sys_device *dev, char *buf)
 434 {
 435         return sprintf(buf, "%i\n",
 436                        (system_timer->dyn_tick->state & DYN_TICK_ENABLED) >> 1);
 437 }
 438
 439 static ssize_t timer_set_dyn_tick(struct sys_device *dev, const char *buf,
 440                                   size_t count)
 441 {
 442         unsigned int enable = simple_strtoul(buf, NULL, 2);
 443
 444         if (enable)
 445                 timer_dyn_tick_enable();
 446         else
 447                 timer_dyn_tick_disable();
 448
 449         return count;
 450 }
 451 static SYSDEV_ATTR(dyn_tick, 0644, timer_show_dyn_tick, timer_set_dyn_tick);
 452
 453 /*
 454  * dyntick=enable|disable
 455  */
 456 static char dyntick_str[4] __initdata = "";
 457
 458 static int __init dyntick_setup(char *str)
 459 {
 460         if (str)
 461                 strlcpy(dyntick_str, str, sizeof(dyntick_str));
 462         return 1;
 463 }
 464
 465 __setup("dyntick=", dyntick_setup);
 466 #endif
 467
 468 static int __init timer_init_sysfs(void)
 469 {
 470         int ret = sysdev_class_register(&timer_sysclass);
 471         if (ret == 0) {
 472                 system_timer->dev.cls = &timer_sysclass;
 473                 ret = sysdev_register(&system_timer->dev);
 474         }
 475
 476 #ifdef CONFIG_NO_IDLE_HZ
 477         if (ret == 0 && system_timer->dyn_tick) {
 478                 ret = sysdev_create_file(&system_timer->dev, &attr_dyn_tick);
 479
 480                 /*
 481                  * Turn on dynamic tick after calibrate delay
 482                  * for correct bogomips
 483                  */
 484                 if (ret == 0 && dyntick_str[0] == 'e')
 485                         ret = timer_dyn_tick_enable();
 486         }
 487 #endif
 488
 489         return ret;
 490 }
 491
 492 device_initcall(timer_init_sysfs);
 493
 494 void __init time_init(void)
 495 {
 496 #ifndef CONFIG_GENERIC_TIME
 497         if (system_timer->offset == NULL)
 498                 system_timer->offset = dummy_gettimeoffset;
 499 #endif
 500         system_timer->init();
 501
 502 #ifdef CONFIG_NO_IDLE_HZ
 503         if (system_timer->dyn_tick)
 504                 spin_lock_init(&system_timer->dyn_tick->lock);
 505 #endif
 506 }
 507