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
  30 #include <asm/hardware.h>
  31 #include <asm/io.h>
  32 #include <asm/irq.h>
  33 #include <asm/leds.h>
  34
  35 u64 jiffies_64;
  36
  37 extern rwlock_t xtime_lock;
  38 extern unsigned long wall_jiffies;
  39
  40 /* this needs a better home */
  41 spinlock_t rtc_lock = SPIN_LOCK_UNLOCKED;
  42
  43 #ifdef CONFIG_SA1100_RTC_MODULE
  44 EXPORT_SYMBOL(rtc_lock);
  45 #endif
  46
  47 /* change this if you have some constant time drift */
  48 #define USECS_PER_JIFFY (1000000/HZ)
  49
  50 #ifndef BCD_TO_BIN
  51 #define BCD_TO_BIN(val) ((val)=((val)&15) + ((val)>>4)*10)
  52 #endif
  53
  54 #ifndef BIN_TO_BCD
  55 #define BIN_TO_BCD(val) ((val)=(((val)/10)<<4) + (val)%10)
  56 #endif
  57
  58 static int dummy_set_rtc(void)
  59 {
  60         return 0;
  61 }
  62
  63 /*
  64  * hook for setting the RTC's idea of the current time.
  65  */
  66 int (*set_rtc)(void) = dummy_set_rtc;
  67
  68 static unsigned long dummy_gettimeoffset(void)
  69 {
  70         return 0;
  71 }
  72
  73 /*
  74  * hook for getting the time offset.  Note that it is
  75  * always called with interrupts disabled.
  76  */
  77 unsigned long (*gettimeoffset)(void) = dummy_gettimeoffset;
  78
  79 /*
  80  * Handle kernel profile stuff...
  81  */
  82 static inline void do_profile(struct pt_regs *regs)
  83 {
  84         if (!user_mode(regs) &&
  85             prof_buffer &&
  86             current->pid) {
  87                 unsigned long pc = instruction_pointer(regs);
  88                 extern int _stext;
  89
  90                 pc -= (unsigned long)&_stext;
  91
  92                 pc >>= prof_shift;
  93
  94                 if (pc >= prof_len)
  95                         pc = prof_len - 1;
  96
  97                 prof_buffer[pc] += 1;
  98         }
  99 }
 100
 101 static long next_rtc_update;
 102
 103 /*
 104  * If we have an externally synchronized linux clock, then update
 105  * CMOS clock accordingly every ~11 minutes.  set_rtc() has to be
 106  * called as close as possible to 500 ms before the new second
 107  * starts.
 108  */
 109 static inline void do_set_rtc(void)
 110 {
 111         if (time_status & STA_UNSYNC || set_rtc == NULL)
 112                 return;
 113
 114         if (next_rtc_update &&
 115             time_before(xtime.tv_sec, next_rtc_update))
 116                 return;
 117
 118         if (xtime.tv_nsec < 500000000 - ((unsigned) tick_nsec >> 1) &&
 119             xtime.tv_nsec >= 500000000 + ((unsigned) tick_nsec >> 1))
 120                 return;
 121
 122         if (set_rtc())
 123                 /*
 124                  * rtc update failed.  Try again in 60s
 125                  */
 126                 next_rtc_update = xtime.tv_sec + 60;
 127         else
 128                 next_rtc_update = xtime.tv_sec + 660;
 129 }
 130
 131 #ifdef CONFIG_LEDS
 132
 133 static void dummy_leds_event(led_event_t evt)
 134 {
 135 }
 136
 137 void (*leds_event)(led_event_t) = dummy_leds_event;
 138
 139 EXPORT_SYMBOL(leds_event);
 140 #endif
 141
 142 #ifdef CONFIG_LEDS_TIMER
 143 static void do_leds(void)
 144 {
 145         static unsigned int count = 50;
 146
 147         if (--count == 0) {
 148                 count = 50;
 149                 leds_event(led_timer);
 150         }
 151 }
 152 #else
 153 #define do_leds()
 154 #endif
 155
 156 void do_gettimeofday(struct timeval *tv)
 157 {
 158         unsigned long flags;
 159         unsigned long usec, sec, lost;
 160
 161         read_lock_irqsave(&xtime_lock, flags);
 162         usec = gettimeoffset();
 163
 164         lost = jiffies - wall_jiffies;
 165         if (lost)
 166                 usec += lost * USECS_PER_JIFFY;
 167
 168         sec = xtime.tv_sec;
 169         usec += xtime.tv_nsec / 1000;
 170         read_unlock_irqrestore(&xtime_lock, flags);
 171
 172         /* usec may have gone up a lot: be safe */
 173         while (usec >= 1000000) {
 174                 usec -= 1000000;
 175                 sec++;
 176         }
 177
 178         tv->tv_sec = sec;
 179         tv->tv_usec = usec;
 180 }
 181
 182 void do_settimeofday(struct timeval *tv)
 183 {
 184         write_lock_irq(&xtime_lock);
 185         /*
 186          * This is revolting. We need to set "xtime" correctly. However, the
 187          * value in this location is the value at the most recent update of
 188          * wall time.  Discover what correction gettimeofday() would have
 189          * done, and then undo it!
 190          */
 191         tv->tv_usec -= gettimeoffset();
 192         tv->tv_usec -= (jiffies - wall_jiffies) * USECS_PER_JIFFY;
 193
 194         while (tv->tv_usec < 0) {
 195                 tv->tv_usec += 1000000;
 196                 tv->tv_sec--;
 197         }
 198
 199         xtime.tv_sec = tv->tv_sec;
 200         xtime.tv_nsec = tv->tv_usec * 1000;
 201         time_adjust = 0;                /* stop active adjtime() */
 202         time_status |= STA_UNSYNC;
 203         time_maxerror = NTP_PHASE_LIMIT;
 204         time_esterror = NTP_PHASE_LIMIT;
 205         write_unlock_irq(&xtime_lock);
 206 }
 207
 208 static struct irqaction timer_irq = {
 209         .name   = "timer",
 210 };
 211
 212 /*
 213  * Include architecture specific code
 214  */
 215 #include <asm/arch/time.h>