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