Linux-2.6.12-rc2
[linux-2.6.git] / arch / arm26 / kernel / time.c
1 /*
2  *  linux/arch/arm26/kernel/time.c
3  *
4  *  Copyright (C) 1991, 1992, 1995  Linus Torvalds
5  *  Modifications for ARM (C) 1994-2001 Russell King
6  *  Mods for ARM26 (C) 2003 Ian Molton
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  *
12  *  This file contains the ARM-specific time handling details:
13  *  reading the RTC at bootup, etc...
14  *
15  *  1994-07-02  Alan Modra
16  *              fixed set_rtc_mmss, fixed time.year for >= 2000, new mktime
17  *  1998-12-20  Updated NTP code according to technical memorandum Jan '96
18  *              "A Kernel Model for Precision Timekeeping" by Dave Mills
19  */
20
21 #include <linux/config.h>
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/interrupt.h>
25 #include <linux/time.h>
26 #include <linux/init.h>
27 #include <linux/smp.h>
28 #include <linux/timex.h>
29 #include <linux/errno.h>
30 #include <linux/profile.h>
31
32 #include <asm/hardware.h>
33 #include <asm/io.h>
34 #include <asm/irq.h>
35 #include <asm/ioc.h>
36
37 u64 jiffies_64 = INITIAL_JIFFIES;
38
39 EXPORT_SYMBOL(jiffies_64);
40
41 extern unsigned long wall_jiffies;
42
43 /* this needs a better home */
44 DEFINE_SPINLOCK(rtc_lock);
45
46 /* change this if you have some constant time drift */
47 #define USECS_PER_JIFFY (1000000/HZ)
48
49 static int dummy_set_rtc(void)
50 {
51         return 0;
52 }
53
54 /*
55  * hook for setting the RTC's idea of the current time.
56  */
57 int (*set_rtc)(void) = dummy_set_rtc;
58
59 /*
60  * Get time offset based on IOCs timer.
61  * FIXME - if this is called with interrutps off, why the shennanigans
62  * below ?
63  */
64 static unsigned long gettimeoffset(void)
65 {
66         unsigned int count1, count2, status;
67         long offset;
68
69         ioc_writeb (0, IOC_T0LATCH);
70         barrier ();
71         count1 = ioc_readb(IOC_T0CNTL) | (ioc_readb(IOC_T0CNTH) << 8);
72         barrier ();
73         status = ioc_readb(IOC_IRQREQA);
74         barrier ();
75         ioc_writeb (0, IOC_T0LATCH);
76         barrier ();
77         count2 = ioc_readb(IOC_T0CNTL) | (ioc_readb(IOC_T0CNTH) << 8);
78
79         offset = count2;
80         if (count2 < count1) {
81                 /*
82                  * We have not had an interrupt between reading count1
83                  * and count2.
84                  */
85                 if (status & (1 << 5))
86                         offset -= LATCH;
87         } else if (count2 > count1) {
88                 /*
89                  * We have just had another interrupt between reading
90                  * count1 and count2.
91                  */
92                 offset -= LATCH;
93         }
94
95         offset = (LATCH - offset) * (tick_nsec / 1000);
96         return (offset + LATCH/2) / LATCH;
97 }
98
99 /*
100  * Scheduler clock - returns current time in nanosec units.
101  */
102 unsigned long long sched_clock(void)
103 {
104         return (unsigned long long)jiffies * (1000000000 / HZ);
105 }
106
107 static unsigned long next_rtc_update;
108
109 /*
110  * If we have an externally synchronized linux clock, then update
111  * CMOS clock accordingly every ~11 minutes.  set_rtc() has to be
112  * called as close as possible to 500 ms before the new second
113  * starts.
114  */
115 static inline void do_set_rtc(void)
116 {
117         if (time_status & STA_UNSYNC || set_rtc == NULL)
118                 return;
119
120 //FIXME - timespec.tv_sec is a time_t not unsigned long
121         if (next_rtc_update &&
122             time_before((unsigned long)xtime.tv_sec, next_rtc_update))
123                 return;
124
125         if (xtime.tv_nsec < 500000000 - ((unsigned) tick_nsec >> 1) &&
126             xtime.tv_nsec >= 500000000 + ((unsigned) tick_nsec >> 1))
127                 return;
128
129         if (set_rtc())
130                 /*
131                  * rtc update failed.  Try again in 60s
132                  */
133                 next_rtc_update = xtime.tv_sec + 60;
134         else
135                 next_rtc_update = xtime.tv_sec + 660;
136 }
137
138 #define do_leds()
139
140 void do_gettimeofday(struct timeval *tv)
141 {
142         unsigned long flags;
143         unsigned long seq;
144         unsigned long usec, sec, lost;
145
146         do {
147                 seq = read_seqbegin_irqsave(&xtime_lock, flags);
148                 usec = gettimeoffset();
149
150                 lost = jiffies - wall_jiffies;
151                 if (lost)
152                         usec += lost * USECS_PER_JIFFY;
153
154                 sec = xtime.tv_sec;
155                 usec += xtime.tv_nsec / 1000;
156         } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
157
158         /* usec may have gone up a lot: be safe */
159         while (usec >= 1000000) {
160                 usec -= 1000000;
161                 sec++;
162         }
163
164         tv->tv_sec = sec;
165         tv->tv_usec = usec;
166 }
167
168 EXPORT_SYMBOL(do_gettimeofday);
169
170 int do_settimeofday(struct timespec *tv)
171 {
172         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
173                 return -EINVAL;
174
175         write_seqlock_irq(&xtime_lock);
176         /*
177          * This is revolting. We need to set "xtime" correctly. However, the
178          * value in this location is the value at the most recent update of
179          * wall time.  Discover what correction gettimeofday() would have
180          * done, and then undo it!
181          */
182         tv->tv_nsec -= 1000 * (gettimeoffset() +
183                         (jiffies - wall_jiffies) * USECS_PER_JIFFY);
184
185         while (tv->tv_nsec < 0) {
186                 tv->tv_nsec += NSEC_PER_SEC;
187                 tv->tv_sec--;
188         }
189
190         xtime.tv_sec = tv->tv_sec;
191         xtime.tv_nsec = tv->tv_nsec;
192         time_adjust = 0;                /* stop active adjtime() */
193         time_status |= STA_UNSYNC;
194         time_maxerror = NTP_PHASE_LIMIT;
195         time_esterror = NTP_PHASE_LIMIT;
196         write_sequnlock_irq(&xtime_lock);
197         clock_was_set();
198         return 0;
199 }
200
201 EXPORT_SYMBOL(do_settimeofday);
202
203 static irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
204 {
205         do_timer(regs);
206 #ifndef CONFIG_SMP
207         update_process_times(user_mode(regs));
208 #endif
209         do_set_rtc(); //FIME - EVERY timer IRQ?
210         profile_tick(CPU_PROFILING, regs);
211         return IRQ_HANDLED; //FIXME - is this right?
212 }
213
214 static struct irqaction timer_irq = {
215         .name   = "timer",
216         .flags  = SA_INTERRUPT,
217         .handler = timer_interrupt,
218 };
219
220 extern void ioctime_init(void);
221
222 /*
223  * Set up timer interrupt.
224  */
225 void __init time_init(void)
226 {
227         ioc_writeb(LATCH & 255, IOC_T0LTCHL);
228         ioc_writeb(LATCH >> 8, IOC_T0LTCHH);
229         ioc_writeb(0, IOC_T0GO);
230
231
232         setup_irq(IRQ_TIMER, &timer_irq);
233 }
234