aboutsummaryrefslogtreecommitdiffstats
path: root/arch/arm26/kernel/time.c
diff options
context:
space:
mode:
Diffstat (limited to 'arch/arm26/kernel/time.c')
-rw-r--r--arch/arm26/kernel/time.c210
1 files changed, 0 insertions, 210 deletions
diff --git a/arch/arm26/kernel/time.c b/arch/arm26/kernel/time.c
deleted file mode 100644
index 0f1d57fbd3d7..000000000000
--- a/arch/arm26/kernel/time.c
+++ /dev/null
@@ -1,210 +0,0 @@
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/module.h>
22#include <linux/kernel.h>
23#include <linux/interrupt.h>
24#include <linux/time.h>
25#include <linux/init.h>
26#include <linux/smp.h>
27#include <linux/timex.h>
28#include <linux/errno.h>
29#include <linux/profile.h>
30
31#include <asm/hardware.h>
32#include <asm/io.h>
33#include <asm/irq.h>
34#include <asm/ioc.h>
35
36/* this needs a better home */
37DEFINE_SPINLOCK(rtc_lock);
38
39/* change this if you have some constant time drift */
40#define USECS_PER_JIFFY (1000000/HZ)
41
42static int dummy_set_rtc(void)
43{
44 return 0;
45}
46
47/*
48 * hook for setting the RTC's idea of the current time.
49 */
50int (*set_rtc)(void) = dummy_set_rtc;
51
52/*
53 * Get time offset based on IOCs timer.
54 * FIXME - if this is called with interrutps off, why the shennanigans
55 * below ?
56 */
57static unsigned long gettimeoffset(void)
58{
59 unsigned int count1, count2, status;
60 long offset;
61
62 ioc_writeb (0, IOC_T0LATCH);
63 barrier ();
64 count1 = ioc_readb(IOC_T0CNTL) | (ioc_readb(IOC_T0CNTH) << 8);
65 barrier ();
66 status = ioc_readb(IOC_IRQREQA);
67 barrier ();
68 ioc_writeb (0, IOC_T0LATCH);
69 barrier ();
70 count2 = ioc_readb(IOC_T0CNTL) | (ioc_readb(IOC_T0CNTH) << 8);
71
72 offset = count2;
73 if (count2 < count1) {
74 /*
75 * We have not had an interrupt between reading count1
76 * and count2.
77 */
78 if (status & (1 << 5))
79 offset -= LATCH;
80 } else if (count2 > count1) {
81 /*
82 * We have just had another interrupt between reading
83 * count1 and count2.
84 */
85 offset -= LATCH;
86 }
87
88 offset = (LATCH - offset) * (tick_nsec / 1000);
89 return (offset + LATCH/2) / LATCH;
90}
91
92static unsigned long next_rtc_update;
93
94/*
95 * If we have an externally synchronized linux clock, then update
96 * CMOS clock accordingly every ~11 minutes. set_rtc() has to be
97 * called as close as possible to 500 ms before the new second
98 * starts.
99 */
100static inline void do_set_rtc(void)
101{
102 if (!ntp_synced() || set_rtc == NULL)
103 return;
104
105//FIXME - timespec.tv_sec is a time_t not unsigned long
106 if (next_rtc_update &&
107 time_before((unsigned long)xtime.tv_sec, next_rtc_update))
108 return;
109
110 if (xtime.tv_nsec < 500000000 - ((unsigned) tick_nsec >> 1) &&
111 xtime.tv_nsec >= 500000000 + ((unsigned) tick_nsec >> 1))
112 return;
113
114 if (set_rtc())
115 /*
116 * rtc update failed. Try again in 60s
117 */
118 next_rtc_update = xtime.tv_sec + 60;
119 else
120 next_rtc_update = xtime.tv_sec + 660;
121}
122
123#define do_leds()
124
125void do_gettimeofday(struct timeval *tv)
126{
127 unsigned long flags;
128 unsigned long seq;
129 unsigned long usec, sec;
130
131 do {
132 seq = read_seqbegin_irqsave(&xtime_lock, flags);
133 usec = gettimeoffset();
134 sec = xtime.tv_sec;
135 usec += xtime.tv_nsec / 1000;
136 } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
137
138 /* usec may have gone up a lot: be safe */
139 while (usec >= 1000000) {
140 usec -= 1000000;
141 sec++;
142 }
143
144 tv->tv_sec = sec;
145 tv->tv_usec = usec;
146}
147
148EXPORT_SYMBOL(do_gettimeofday);
149
150int do_settimeofday(struct timespec *tv)
151{
152 if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
153 return -EINVAL;
154
155 write_seqlock_irq(&xtime_lock);
156 /*
157 * This is revolting. We need to set "xtime" correctly. However, the
158 * value in this location is the value at the most recent update of
159 * wall time. Discover what correction gettimeofday() would have
160 * done, and then undo it!
161 */
162 tv->tv_nsec -= 1000 * gettimeoffset();
163
164 while (tv->tv_nsec < 0) {
165 tv->tv_nsec += NSEC_PER_SEC;
166 tv->tv_sec--;
167 }
168
169 xtime.tv_sec = tv->tv_sec;
170 xtime.tv_nsec = tv->tv_nsec;
171 ntp_clear();
172 write_sequnlock_irq(&xtime_lock);
173 clock_was_set();
174 return 0;
175}
176
177EXPORT_SYMBOL(do_settimeofday);
178
179static irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
180{
181 do_timer(1);
182#ifndef CONFIG_SMP
183 update_process_times(user_mode(regs));
184#endif
185 do_set_rtc(); //FIME - EVERY timer IRQ?
186 profile_tick(CPU_PROFILING, regs);
187 return IRQ_HANDLED; //FIXME - is this right?
188}
189
190static struct irqaction timer_irq = {
191 .name = "timer",
192 .flags = IRQF_DISABLED,
193 .handler = timer_interrupt,
194};
195
196extern void ioctime_init(void);
197
198/*
199 * Set up timer interrupt.
200 */
201void __init time_init(void)
202{
203 ioc_writeb(LATCH & 255, IOC_T0LTCHL);
204 ioc_writeb(LATCH >> 8, IOC_T0LTCHH);
205 ioc_writeb(0, IOC_T0GO);
206
207
208 setup_irq(IRQ_TIMER, &timer_irq);
209}
210
generated by cgit v1.2.2 (git 2.25.0) at 2025-11-02 09:49:36 -0500