]>
Commit | Line | Data |
---|---|---|
21783c97 | 1 | /* $Id: time.c,v 1.18 2005/03/04 08:16:17 starvik Exp $ |
1da177e4 LT |
2 | * |
3 | * linux/arch/cris/kernel/time.c | |
4 | * | |
5 | * Copyright (C) 1991, 1992, 1995 Linus Torvalds | |
6 | * Copyright (C) 1999, 2000, 2001 Axis Communications AB | |
7 | * | |
8 | * 1994-07-02 Alan Modra | |
9 | * fixed set_rtc_mmss, fixed time.year for >= 2000, new mktime | |
10 | * 1995-03-26 Markus Kuhn | |
11 | * fixed 500 ms bug at call to set_rtc_mmss, fixed DS12887 | |
12 | * precision CMOS clock update | |
13 | * 1996-05-03 Ingo Molnar | |
14 | * fixed time warps in do_[slow|fast]_gettimeoffset() | |
15 | * 1997-09-10 Updated NTP code according to technical memorandum Jan '96 | |
16 | * "A Kernel Model for Precision Timekeeping" by Dave Mills | |
17 | * | |
18 | * Linux/CRIS specific code: | |
19 | * | |
20 | * Authors: Bjorn Wesen | |
21 | * Johan Adolfsson | |
22 | * | |
23 | */ | |
24 | ||
25 | #include <asm/rtc.h> | |
26 | #include <linux/errno.h> | |
27 | #include <linux/module.h> | |
28 | #include <linux/param.h> | |
29 | #include <linux/jiffies.h> | |
30 | #include <linux/bcd.h> | |
31 | #include <linux/timex.h> | |
32 | #include <linux/init.h> | |
21783c97 | 33 | #include <linux/profile.h> |
1da177e4 | 34 | |
1da177e4 LT |
35 | int have_rtc; /* used to remember if we have an RTC or not */; |
36 | ||
37 | #define TICK_SIZE tick | |
38 | ||
39 | extern unsigned long wall_jiffies; | |
40 | extern unsigned long loops_per_jiffy; /* init/main.c */ | |
41 | unsigned long loops_per_usec; | |
42 | ||
43 | extern unsigned long do_slow_gettimeoffset(void); | |
44 | static unsigned long (*do_gettimeoffset)(void) = do_slow_gettimeoffset; | |
45 | ||
46 | /* | |
47 | * This version of gettimeofday has near microsecond resolution. | |
48 | * | |
49 | * Note: Division is quite slow on CRIS and do_gettimeofday is called | |
50 | * rather often. Maybe we should do some kind of approximation here | |
51 | * (a naive approximation would be to divide by 1024). | |
52 | */ | |
53 | void do_gettimeofday(struct timeval *tv) | |
54 | { | |
55 | unsigned long flags; | |
56 | signed long usec, sec; | |
57 | local_irq_save(flags); | |
58 | local_irq_disable(); | |
59 | usec = do_gettimeoffset(); | |
60 | { | |
61 | unsigned long lost = jiffies - wall_jiffies; | |
62 | if (lost) | |
63 | usec += lost * (1000000 / HZ); | |
64 | } | |
65 | ||
66 | /* | |
67 | * If time_adjust is negative then NTP is slowing the clock | |
68 | * so make sure not to go into next possible interval. | |
69 | * Better to lose some accuracy than have time go backwards.. | |
70 | */ | |
71 | if (unlikely(time_adjust < 0) && usec > tickadj) | |
72 | usec = tickadj; | |
73 | ||
74 | sec = xtime.tv_sec; | |
75 | usec += xtime.tv_nsec / 1000; | |
76 | local_irq_restore(flags); | |
77 | ||
78 | while (usec >= 1000000) { | |
79 | usec -= 1000000; | |
80 | sec++; | |
81 | } | |
82 | ||
83 | tv->tv_sec = sec; | |
84 | tv->tv_usec = usec; | |
85 | } | |
86 | ||
87 | EXPORT_SYMBOL(do_gettimeofday); | |
88 | ||
89 | int do_settimeofday(struct timespec *tv) | |
90 | { | |
91 | time_t wtm_sec, sec = tv->tv_sec; | |
92 | long wtm_nsec, nsec = tv->tv_nsec; | |
93 | ||
94 | if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC) | |
95 | return -EINVAL; | |
96 | ||
97 | write_seqlock_irq(&xtime_lock); | |
98 | /* | |
99 | * This is revolting. We need to set "xtime" correctly. However, the | |
100 | * value in this location is the value at the most recent update of | |
101 | * wall time. Discover what correction gettimeofday() would have | |
102 | * made, and then undo it! | |
103 | */ | |
104 | nsec -= do_gettimeoffset() * NSEC_PER_USEC; | |
105 | nsec -= (jiffies - wall_jiffies) * TICK_NSEC; | |
106 | ||
107 | wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec); | |
108 | wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec); | |
109 | ||
110 | set_normalized_timespec(&xtime, sec, nsec); | |
111 | set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec); | |
112 | ||
b149ee22 | 113 | ntp_clear(); |
1da177e4 LT |
114 | write_sequnlock_irq(&xtime_lock); |
115 | clock_was_set(); | |
116 | return 0; | |
117 | } | |
118 | ||
119 | EXPORT_SYMBOL(do_settimeofday); | |
120 | ||
121 | ||
122 | /* | |
123 | * BUG: This routine does not handle hour overflow properly; it just | |
124 | * sets the minutes. Usually you'll only notice that after reboot! | |
125 | */ | |
126 | ||
127 | int set_rtc_mmss(unsigned long nowtime) | |
128 | { | |
129 | int retval = 0; | |
130 | int real_seconds, real_minutes, cmos_minutes; | |
131 | ||
132 | printk(KERN_DEBUG "set_rtc_mmss(%lu)\n", nowtime); | |
133 | ||
134 | if(!have_rtc) | |
135 | return 0; | |
136 | ||
137 | cmos_minutes = CMOS_READ(RTC_MINUTES); | |
138 | BCD_TO_BIN(cmos_minutes); | |
139 | ||
140 | /* | |
141 | * since we're only adjusting minutes and seconds, | |
142 | * don't interfere with hour overflow. This avoids | |
143 | * messing with unknown time zones but requires your | |
144 | * RTC not to be off by more than 15 minutes | |
145 | */ | |
146 | real_seconds = nowtime % 60; | |
147 | real_minutes = nowtime / 60; | |
148 | if (((abs(real_minutes - cmos_minutes) + 15)/30) & 1) | |
149 | real_minutes += 30; /* correct for half hour time zone */ | |
150 | real_minutes %= 60; | |
151 | ||
152 | if (abs(real_minutes - cmos_minutes) < 30) { | |
153 | BIN_TO_BCD(real_seconds); | |
154 | BIN_TO_BCD(real_minutes); | |
155 | CMOS_WRITE(real_seconds,RTC_SECONDS); | |
156 | CMOS_WRITE(real_minutes,RTC_MINUTES); | |
157 | } else { | |
158 | printk(KERN_WARNING | |
159 | "set_rtc_mmss: can't update from %d to %d\n", | |
160 | cmos_minutes, real_minutes); | |
161 | retval = -1; | |
162 | } | |
163 | ||
164 | return retval; | |
165 | } | |
166 | ||
167 | /* grab the time from the RTC chip */ | |
168 | ||
169 | unsigned long | |
170 | get_cmos_time(void) | |
171 | { | |
172 | unsigned int year, mon, day, hour, min, sec; | |
173 | ||
174 | sec = CMOS_READ(RTC_SECONDS); | |
175 | min = CMOS_READ(RTC_MINUTES); | |
176 | hour = CMOS_READ(RTC_HOURS); | |
177 | day = CMOS_READ(RTC_DAY_OF_MONTH); | |
178 | mon = CMOS_READ(RTC_MONTH); | |
179 | year = CMOS_READ(RTC_YEAR); | |
180 | ||
181 | printk(KERN_DEBUG | |
182 | "rtc: sec 0x%x min 0x%x hour 0x%x day 0x%x mon 0x%x year 0x%x\n", | |
183 | sec, min, hour, day, mon, year); | |
184 | ||
185 | BCD_TO_BIN(sec); | |
186 | BCD_TO_BIN(min); | |
187 | BCD_TO_BIN(hour); | |
188 | BCD_TO_BIN(day); | |
189 | BCD_TO_BIN(mon); | |
190 | BCD_TO_BIN(year); | |
191 | ||
192 | if ((year += 1900) < 1970) | |
193 | year += 100; | |
194 | ||
195 | return mktime(year, mon, day, hour, min, sec); | |
196 | } | |
197 | ||
198 | /* update xtime from the CMOS settings. used when /dev/rtc gets a SET_TIME. | |
199 | * TODO: this doesn't reset the fancy NTP phase stuff as do_settimeofday does. | |
200 | */ | |
201 | ||
202 | void | |
203 | update_xtime_from_cmos(void) | |
204 | { | |
205 | if(have_rtc) { | |
206 | xtime.tv_sec = get_cmos_time(); | |
207 | xtime.tv_nsec = 0; | |
208 | } | |
209 | } | |
210 | ||
21783c97 MS |
211 | extern void cris_profile_sample(struct pt_regs* regs); |
212 | ||
213 | void | |
214 | cris_do_profile(struct pt_regs* regs) | |
215 | { | |
216 | ||
217 | #if CONFIG_SYSTEM_PROFILER | |
218 | cris_profile_sample(regs); | |
219 | #endif | |
220 | ||
221 | #if CONFIG_PROFILING | |
222 | profile_tick(CPU_PROFILING, regs); | |
223 | #endif | |
224 | } | |
225 | ||
1da177e4 LT |
226 | /* |
227 | * Scheduler clock - returns current time in nanosec units. | |
228 | */ | |
229 | unsigned long long sched_clock(void) | |
230 | { | |
231 | return (unsigned long long)jiffies * (1000000000 / HZ); | |
232 | } | |
233 | ||
234 | static int | |
235 | __init init_udelay(void) | |
236 | { | |
237 | loops_per_usec = (loops_per_jiffy * HZ) / 1000000; | |
238 | return 0; | |
239 | } | |
240 | ||
241 | __initcall(init_udelay); |