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 #include <linux/module.h>
  15 #include <linux/kernel.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/time.h>
  18 #include <linux/init.h>
  19 #include <linux/sched.h>
  20 #include <linux/smp.h>
  21 #include <linux/timex.h>
  22 #include <linux/errno.h>
  23 #include <linux/profile.h>
  24 #include <linux/sysdev.h>
  25 #include <linux/timer.h>
  26 #include <linux/irq.h>
  27
  28 #include <linux/mc146818rtc.h>
  29
  30 #include <asm/leds.h>
  31 #include <asm/thread_info.h>
  32 #include <asm/stacktrace.h>
  33 #include <asm/mach/time.h>
  34
  35 /*
  36  * Our system timer.
  37  */
  38 struct sys_timer *system_timer;
  39
  40 #if defined(CONFIG_RTC_DRV_CMOS) || defined(CONFIG_RTC_DRV_CMOS_MODULE)
  41 /* this needs a better home */
  42 DEFINE_SPINLOCK(rtc_lock);
  43
  44 #ifdef CONFIG_RTC_DRV_CMOS_MODULE
  45 EXPORT_SYMBOL(rtc_lock);
  46 #endif
  47 #endif  /* pc-style 'CMOS' RTC support */
  48
  49 /* change this if you have some constant time drift */
  50 #define USECS_PER_JIFFY (1000000/HZ)
  51
  52 #ifdef CONFIG_SMP
  53 unsigned long profile_pc(struct pt_regs *regs)
  54 {
  55         struct stackframe frame;
  56
  57         if (!in_lock_functions(regs->ARM_pc))
  58                 return regs->ARM_pc;
  59
  60         frame.fp = regs->ARM_fp;
  61         frame.sp = regs->ARM_sp;
  62         frame.lr = regs->ARM_lr;
  63         frame.pc = regs->ARM_pc;
  64         do {
  65                 int ret = unwind_frame(&frame);
  66                 if (ret < 0)
  67                         return 0;
  68         } while (in_lock_functions(frame.pc));
  69
  70         return frame.pc;
  71 }
  72 EXPORT_SYMBOL(profile_pc);
  73 #endif
  74
  75 #ifndef CONFIG_GENERIC_TIME
  76 static unsigned long dummy_gettimeoffset(void)
  77 {
  78         return 0;
  79 }
  80 #endif
  81
  82 #ifdef CONFIG_LEDS
  83
  84 static void dummy_leds_event(led_event_t evt)
  85 {
  86 }
  87
  88 void (*leds_event)(led_event_t) = dummy_leds_event;
  89
  90 struct leds_evt_name {
  91         const char      name[8];
  92         int             on;
  93         int             off;
  94 };
  95
  96 static const struct leds_evt_name evt_names[] = {
  97         { "amber", led_amber_on, led_amber_off },
  98         { "blue",  led_blue_on,  led_blue_off  },
  99         { "green", led_green_on, led_green_off },
 100         { "red",   led_red_on,   led_red_off   },
 101 };
 102
 103 static ssize_t leds_store(struct sys_device *dev,
 104                         struct sysdev_attribute *attr,
 105                         const char *buf, size_t size)
 106 {
 107         int ret = -EINVAL, len = strcspn(buf, " ");
 108
 109         if (len > 0 && buf[len] == '\0')
 110                 len--;
 111
 112         if (strncmp(buf, "claim", len) == 0) {
 113                 leds_event(led_claim);
 114                 ret = size;
 115         } else if (strncmp(buf, "release", len) == 0) {
 116                 leds_event(led_release);
 117                 ret = size;
 118         } else {
 119                 int i;
 120
 121                 for (i = 0; i < ARRAY_SIZE(evt_names); i++) {
 122                         if (strlen(evt_names[i].name) != len ||
 123                             strncmp(buf, evt_names[i].name, len) != 0)
 124                                 continue;
 125                         if (strncmp(buf+len, " on", 3) == 0) {
 126                                 leds_event(evt_names[i].on);
 127                                 ret = size;
 128                         } else if (strncmp(buf+len, " off", 4) == 0) {
 129                                 leds_event(evt_names[i].off);
 130                                 ret = size;
 131                         }
 132                         break;
 133                 }
 134         }
 135         return ret;
 136 }
 137
 138 static SYSDEV_ATTR(event, 0200, NULL, leds_store);
 139
 140 static int leds_suspend(struct sys_device *dev, pm_message_t state)
 141 {
 142         leds_event(led_stop);
 143         return 0;
 144 }
 145
 146 static int leds_resume(struct sys_device *dev)
 147 {
 148         leds_event(led_start);
 149         return 0;
 150 }
 151
 152 static int leds_shutdown(struct sys_device *dev)
 153 {
 154         leds_event(led_halted);
 155         return 0;
 156 }
 157
 158 static struct sysdev_class leds_sysclass = {
 159         .name           = "leds",
 160         .shutdown       = leds_shutdown,
 161         .suspend        = leds_suspend,
 162         .resume         = leds_resume,
 163 };
 164
 165 static struct sys_device leds_device = {
 166         .id             = 0,
 167         .cls            = &leds_sysclass,
 168 };
 169
 170 static int __init leds_init(void)
 171 {
 172         int ret;
 173         ret = sysdev_class_register(&leds_sysclass);
 174         if (ret == 0)
 175                 ret = sysdev_register(&leds_device);
 176         if (ret == 0)
 177                 ret = sysdev_create_file(&leds_device, &attr_event);
 178         return ret;
 179 }
 180
 181 device_initcall(leds_init);
 182
 183 EXPORT_SYMBOL(leds_event);
 184 #endif
 185
 186 #ifdef CONFIG_LEDS_TIMER
 187 static inline void do_leds(void)
 188 {
 189         static unsigned int count = HZ/2;
 190
 191         if (--count == 0) {
 192                 count = HZ/2;
 193                 leds_event(led_timer);
 194         }
 195 }
 196 #else
 197 #define do_leds()
 198 #endif
 199
 200 #ifndef CONFIG_GENERIC_TIME
 201 void do_gettimeofday(struct timeval *tv)
 202 {
 203         unsigned long flags;
 204         unsigned long seq;
 205         unsigned long usec, sec;
 206
 207         do {
 208                 seq = read_seqbegin_irqsave(&xtime_lock, flags);
 209                 usec = system_timer->offset();
 210                 sec = xtime.tv_sec;
 211                 usec += xtime.tv_nsec / 1000;
 212         } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
 213
 214         /* usec may have gone up a lot: be safe */
 215         while (usec >= 1000000) {
 216                 usec -= 1000000;
 217                 sec++;
 218         }
 219
 220         tv->tv_sec = sec;
 221         tv->tv_usec = usec;
 222 }
 223
 224 EXPORT_SYMBOL(do_gettimeofday);
 225
 226 int do_settimeofday(struct timespec *tv)
 227 {
 228         time_t wtm_sec, sec = tv->tv_sec;
 229         long wtm_nsec, nsec = tv->tv_nsec;
 230
 231         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
 232                 return -EINVAL;
 233
 234         write_seqlock_irq(&xtime_lock);
 235         /*
 236          * This is revolting. We need to set "xtime" correctly. However, the
 237          * value in this location is the value at the most recent update of
 238          * wall time.  Discover what correction gettimeofday() would have
 239          * done, and then undo it!
 240          */
 241         nsec -= system_timer->offset() * NSEC_PER_USEC;
 242
 243         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
 244         wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
 245
 246         set_normalized_timespec(&xtime, sec, nsec);
 247         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
 248
 249         ntp_clear();
 250         write_sequnlock_irq(&xtime_lock);
 251         clock_was_set();
 252         return 0;
 253 }
 254
 255 EXPORT_SYMBOL(do_settimeofday);
 256 #endif /* !CONFIG_GENERIC_TIME */
 257
 258 #ifndef CONFIG_GENERIC_CLOCKEVENTS
 259 /*
 260  * Kernel system timer support.
 261  */
 262 void timer_tick(void)
 263 {
 264         profile_tick(CPU_PROFILING);
 265         do_leds();
 266         write_seqlock(&xtime_lock);
 267         do_timer(1);
 268         write_sequnlock(&xtime_lock);
 269 #ifndef CONFIG_SMP
 270         update_process_times(user_mode(get_irq_regs()));
 271 #endif
 272 }
 273 #endif
 274
 275 #if defined(CONFIG_PM) && !defined(CONFIG_GENERIC_CLOCKEVENTS)
 276 static int timer_suspend(struct sys_device *dev, pm_message_t state)
 277 {
 278         struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
 279
 280         if (timer->suspend != NULL)
 281                 timer->suspend();
 282
 283         return 0;
 284 }
 285
 286 static int timer_resume(struct sys_device *dev)
 287 {
 288         struct sys_timer *timer = container_of(dev, struct sys_timer, dev);
 289
 290         if (timer->resume != NULL)
 291                 timer->resume();
 292
 293         return 0;
 294 }
 295 #else
 296 #define timer_suspend NULL
 297 #define timer_resume NULL
 298 #endif
 299
 300 static struct sysdev_class timer_sysclass = {
 301         .name           = "timer",
 302         .suspend        = timer_suspend,
 303         .resume         = timer_resume,
 304 };
 305
 306 static int __init timer_init_sysfs(void)
 307 {
 308         int ret = sysdev_class_register(&timer_sysclass);
 309         if (ret == 0) {
 310                 system_timer->dev.cls = &timer_sysclass;
 311                 ret = sysdev_register(&system_timer->dev);
 312         }
 313
 314         return ret;
 315 }
 316
 317 device_initcall(timer_init_sysfs);
 318
 319 void __init time_init(void)
 320 {
 321 #ifndef CONFIG_GENERIC_TIME
 322         if (system_timer->offset == NULL)
 323                 system_timer->offset = dummy_gettimeoffset;
 324 #endif
 325         system_timer->init();
 326 }
 327