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/config.h>
  20 #include <linux/module.h>
  21 #include <linux/kernel.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/time.h>
  24 #include <linux/init.h>
  25 #include <linux/smp.h>
  26 #include <linux/timex.h>
  27 #include <linux/errno.h>
  28 #include <linux/profile.h>
  29 #include <linux/sysdev.h>
  30 #include <linux/timer.h>
  31
  32 #include <asm/hardware.h>
  33 #include <asm/io.h>
  34 #include <asm/irq.h>
  35 #include <asm/leds.h>
  36 #include <asm/thread_info.h>
  37 #include <asm/mach/time.h>
  38
  39 u64 jiffies_64 = INITIAL_JIFFIES;
  40
  41 EXPORT_SYMBOL(jiffies_64);
  42
  43 extern unsigned long wall_jiffies;
  44
  45 /* this needs a better home */
  46 spinlock_t rtc_lock = SPIN_LOCK_UNLOCKED;
  47
  48 #ifdef CONFIG_SA1100_RTC_MODULE
  49 EXPORT_SYMBOL(rtc_lock);
  50 #endif
  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 = thread_saved_fp(current);
  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 static unsigned long dummy_gettimeoffset(void)
  76 {
  77         return 0;
  78 }
  79
  80 /*
  81  * hook for getting the time offset.  Note that it is
  82  * always called with interrupts disabled.
  83  */
  84 unsigned long (*gettimeoffset)(void) = dummy_gettimeoffset;
  85
  86 /*
  87  * Scheduler clock - returns current time in nanosec units.
  88  * This is the default implementation.  Sub-architecture
  89  * implementations can override this.
  90  */
  91 unsigned long long __attribute__((weak)) sched_clock(void)
  92 {
  93         return (unsigned long long)jiffies * (1000000000 / HZ);
  94 }
  95
  96 static unsigned long next_rtc_update;
  97
  98 /*
  99  * If we have an externally synchronized linux clock, then update
 100  * CMOS clock accordingly every ~11 minutes.  set_rtc() has to be
 101  * called as close as possible to 500 ms before the new second
 102  * starts.
 103  */
 104 static inline void do_set_rtc(void)
 105 {
 106         if (time_status & STA_UNSYNC || set_rtc == NULL)
 107                 return;
 108
 109         if (next_rtc_update &&
 110             time_before((unsigned long)xtime.tv_sec, next_rtc_update))
 111                 return;
 112
 113         if (xtime.tv_nsec < 500000000 - ((unsigned) tick_nsec >> 1) &&
 114             xtime.tv_nsec >= 500000000 + ((unsigned) tick_nsec >> 1))
 115                 return;
 116
 117         if (set_rtc())
 118                 /*
 119                  * rtc update failed.  Try again in 60s
 120                  */
 121                 next_rtc_update = xtime.tv_sec + 60;
 122         else
 123                 next_rtc_update = xtime.tv_sec + 660;
 124 }
 125
 126 #ifdef CONFIG_LEDS
 127
 128 static void dummy_leds_event(led_event_t evt)
 129 {
 130 }
 131
 132 void (*leds_event)(led_event_t) = dummy_leds_event;
 133
 134 struct leds_evt_name {
 135         const char      name[8];
 136         int             on;
 137         int             off;
 138 };
 139
 140 static const struct leds_evt_name evt_names[] = {
 141         { "amber", led_amber_on, led_amber_off },
 142         { "blue",  led_blue_on,  led_blue_off  },
 143         { "green", led_green_on, led_green_off },
 144         { "red",   led_red_on,   led_red_off   },
 145 };
 146
 147 static ssize_t leds_store(struct sys_device *dev, const char *buf, size_t size)
 148 {
 149         int ret = -EINVAL, len = strcspn(buf, " ");
 150
 151         if (len > 0 && buf[len] == '\0')
 152                 len--;
 153
 154         if (strncmp(buf, "claim", len) == 0) {
 155                 leds_event(led_claim);
 156                 ret = size;
 157         } else if (strncmp(buf, "release", len) == 0) {
 158                 leds_event(led_release);
 159                 ret = size;
 160         } else {
 161                 int i;
 162
 163                 for (i = 0; i < ARRAY_SIZE(evt_names); i++) {
 164                         if (strlen(evt_names[i].name) != len ||
 165                             strncmp(buf, evt_names[i].name, len) != 0)
 166                                 continue;
 167                         if (strncmp(buf+len, " on", 3) == 0) {
 168                                 leds_event(evt_names[i].on);
 169                                 ret = size;
 170                         } else if (strncmp(buf+len, " off", 4) == 0) {
 171                                 leds_event(evt_names[i].off);
 172                                 ret = size;
 173                         }
 174                         break;
 175                 }
 176         }
 177         return ret;
 178 }
 179
 180 static SYSDEV_ATTR(event, 0200, NULL, leds_store);
 181
 182 static int leds_suspend(struct sys_device *dev, u32 state)
 183 {
 184         leds_event(led_stop);
 185         return 0;
 186 }
 187
 188 static int leds_resume(struct sys_device *dev)
 189 {
 190         leds_event(led_start);
 191         return 0;
 192 }
 193
 194 static int leds_shutdown(struct sys_device *dev)
 195 {
 196         leds_event(led_halted);
 197         return 0;
 198 }
 199
 200 static struct sysdev_class leds_sysclass = {
 201         set_kset_name("leds"),
 202         .shutdown       = leds_shutdown,
 203         .suspend        = leds_suspend,
 204         .resume         = leds_resume,
 205 };
 206
 207 static struct sys_device leds_device = {
 208         .id             = 0,
 209         .cls            = &leds_sysclass,
 210 };
 211
 212 static int __init leds_init(void)
 213 {
 214         int ret;
 215         ret = sysdev_class_register(&leds_sysclass);
 216         if (ret == 0)
 217                 ret = sysdev_register(&leds_device);
 218         if (ret == 0)
 219                 ret = sysdev_create_file(&leds_device, &attr_event);
 220         return ret;
 221 }
 222
 223 device_initcall(leds_init);
 224
 225 EXPORT_SYMBOL(leds_event);
 226 #endif
 227
 228 #ifdef CONFIG_LEDS_TIMER
 229 static inline void do_leds(void)
 230 {
 231         static unsigned int count = 50;
 232
 233         if (--count == 0) {
 234                 count = 50;
 235                 leds_event(led_timer);
 236         }
 237 }
 238 #else
 239 #define do_leds()
 240 #endif
 241
 242 void do_gettimeofday(struct timeval *tv)
 243 {
 244         unsigned long flags;
 245         unsigned long seq;
 246         unsigned long usec, sec, lost;
 247
 248         do {
 249                 seq = read_seqbegin_irqsave(&xtime_lock, flags);
 250                 usec = gettimeoffset();
 251
 252                 lost = jiffies - wall_jiffies;
 253                 if (lost)
 254                         usec += lost * USECS_PER_JIFFY;
 255
 256                 sec = xtime.tv_sec;
 257                 usec += xtime.tv_nsec / 1000;
 258         } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
 259
 260         /* usec may have gone up a lot: be safe */
 261         while (usec >= 1000000) {
 262                 usec -= 1000000;
 263                 sec++;
 264         }
 265
 266         tv->tv_sec = sec;
 267         tv->tv_usec = usec;
 268 }
 269
 270 EXPORT_SYMBOL(do_gettimeofday);
 271
 272 int do_settimeofday(struct timespec *tv)
 273 {
 274         time_t wtm_sec, sec = tv->tv_sec;
 275         long wtm_nsec, nsec = tv->tv_nsec;
 276
 277         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
 278                 return -EINVAL;
 279
 280         write_seqlock_irq(&xtime_lock);
 281         /*
 282          * This is revolting. We need to set "xtime" correctly. However, the
 283          * value in this location is the value at the most recent update of
 284          * wall time.  Discover what correction gettimeofday() would have
 285          * done, and then undo it!
 286          */
 287         nsec -= gettimeoffset() * NSEC_PER_USEC;
 288         nsec -= (jiffies - wall_jiffies) * TICK_NSEC;
 289
 290         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
 291         wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
 292
 293         set_normalized_timespec(&xtime, sec, nsec);
 294         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
 295
 296         time_adjust = 0;                /* stop active adjtime() */
 297         time_status |= STA_UNSYNC;
 298         time_maxerror = NTP_PHASE_LIMIT;
 299         time_esterror = NTP_PHASE_LIMIT;
 300         write_sequnlock_irq(&xtime_lock);
 301         clock_was_set();
 302         return 0;
 303 }
 304
 305 EXPORT_SYMBOL(do_settimeofday);
 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 void timer_tick(struct pt_regs *regs)
 341 {
 342         profile_tick(CPU_PROFILING, regs);
 343         do_leds();
 344         do_set_rtc();
 345         do_timer(regs);
 346 }
 347
 348 void (*init_arch_time)(void);
 349
 350 void __init time_init(void)
 351 {
 352         init_arch_time();
 353 }
 354