Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Common time routines among all ppc machines. | |
3 | * | |
4 | * Written by Cort Dougan (cort@cs.nmt.edu) to merge | |
5 | * Paul Mackerras' version and mine for PReP and Pmac. | |
6 | * MPC8xx/MBX changes by Dan Malek (dmalek@jlc.net). | |
7 | * | |
8 | * First round of bugfixes by Gabriel Paubert (paubert@iram.es) | |
9 | * to make clock more stable (2.4.0-test5). The only thing | |
10 | * that this code assumes is that the timebases have been synchronized | |
11 | * by firmware on SMP and are never stopped (never do sleep | |
12 | * on SMP then, nap and doze are OK). | |
13 | * | |
14 | * TODO (not necessarily in this file): | |
15 | * - improve precision and reproducibility of timebase frequency | |
16 | * measurement at boot time. | |
17 | * - get rid of xtime_lock for gettimeofday (generic kernel problem | |
18 | * to be implemented on all architectures for SMP scalability and | |
19 | * eventually implementing gettimeofday without entering the kernel). | |
20 | * - put all time/clock related variables in a single structure | |
21 | * to minimize number of cache lines touched by gettimeofday() | |
22 | * - for astronomical applications: add a new function to get | |
23 | * non ambiguous timestamps even around leap seconds. This needs | |
24 | * a new timestamp format and a good name. | |
25 | * | |
26 | * | |
27 | * The following comment is partially obsolete (at least the long wait | |
28 | * is no more a valid reason): | |
29 | * Since the MPC8xx has a programmable interrupt timer, I decided to | |
30 | * use that rather than the decrementer. Two reasons: 1.) the clock | |
31 | * frequency is low, causing 2.) a long wait in the timer interrupt | |
32 | * while ((d = get_dec()) == dval) | |
33 | * loop. The MPC8xx can be driven from a variety of input clocks, | |
34 | * so a number of assumptions have been made here because the kernel | |
35 | * parameter HZ is a constant. We assume (correctly, today :-) that | |
36 | * the MPC8xx on the MBX board is driven from a 32.768 kHz crystal. | |
37 | * This is then divided by 4, providing a 8192 Hz clock into the PIT. | |
38 | * Since it is not possible to get a nice 100 Hz clock out of this, without | |
39 | * creating a software PLL, I have set HZ to 128. -- Dan | |
40 | * | |
41 | * 1997-09-10 Updated NTP code according to technical memorandum Jan '96 | |
42 | * "A Kernel Model for Precision Timekeeping" by Dave Mills | |
43 | */ | |
44 | ||
1da177e4 LT |
45 | #include <linux/errno.h> |
46 | #include <linux/sched.h> | |
47 | #include <linux/kernel.h> | |
48 | #include <linux/param.h> | |
49 | #include <linux/string.h> | |
50 | #include <linux/mm.h> | |
51 | #include <linux/module.h> | |
52 | #include <linux/interrupt.h> | |
53 | #include <linux/timex.h> | |
54 | #include <linux/kernel_stat.h> | |
55 | #include <linux/mc146818rtc.h> | |
56 | #include <linux/time.h> | |
57 | #include <linux/init.h> | |
58 | #include <linux/profile.h> | |
59 | ||
1da177e4 LT |
60 | #include <asm/io.h> |
61 | #include <asm/nvram.h> | |
62 | #include <asm/cache.h> | |
63 | #include <asm/8xx_immap.h> | |
64 | #include <asm/machdep.h> | |
7d2bd30f | 65 | #include <asm/irq_regs.h> |
1da177e4 LT |
66 | |
67 | #include <asm/time.h> | |
68 | ||
1da177e4 LT |
69 | unsigned long disarm_decr[NR_CPUS]; |
70 | ||
71 | extern struct timezone sys_tz; | |
72 | ||
73 | /* keep track of when we need to update the rtc */ | |
74 | time_t last_rtc_update; | |
75 | ||
76 | /* The decrementer counts down by 128 every 128ns on a 601. */ | |
77 | #define DECREMENTER_COUNT_601 (1000000000 / HZ) | |
78 | ||
79 | unsigned tb_ticks_per_jiffy; | |
80 | unsigned tb_to_us; | |
81 | unsigned tb_last_stamp; | |
82 | unsigned long tb_to_ns_scale; | |
83 | ||
f326d22b | 84 | /* used for timezone offset */ |
85 | static long timezone_offset; | |
86 | ||
1da177e4 LT |
87 | DEFINE_SPINLOCK(rtc_lock); |
88 | ||
89 | EXPORT_SYMBOL(rtc_lock); | |
90 | ||
91 | /* Timer interrupt helper function */ | |
92 | static inline int tb_delta(unsigned *jiffy_stamp) { | |
93 | int delta; | |
94 | if (__USE_RTC()) { | |
95 | delta = get_rtcl(); | |
96 | if (delta < *jiffy_stamp) *jiffy_stamp -= 1000000000; | |
97 | delta -= *jiffy_stamp; | |
98 | } else { | |
99 | delta = get_tbl() - *jiffy_stamp; | |
100 | } | |
101 | return delta; | |
102 | } | |
103 | ||
104 | #ifdef CONFIG_SMP | |
105 | unsigned long profile_pc(struct pt_regs *regs) | |
106 | { | |
107 | unsigned long pc = instruction_pointer(regs); | |
108 | ||
109 | if (in_lock_functions(pc)) | |
110 | return regs->link; | |
111 | ||
112 | return pc; | |
113 | } | |
114 | EXPORT_SYMBOL(profile_pc); | |
115 | #endif | |
116 | ||
f2783c15 PM |
117 | void wakeup_decrementer(void) |
118 | { | |
119 | set_dec(tb_ticks_per_jiffy); | |
120 | /* No currently-supported powerbook has a 601, | |
121 | * so use get_tbl, not native | |
122 | */ | |
123 | last_jiffy_stamp(0) = tb_last_stamp = get_tbl(); | |
124 | } | |
125 | ||
1da177e4 LT |
126 | /* |
127 | * timer_interrupt - gets called when the decrementer overflows, | |
128 | * with interrupts disabled. | |
129 | * We set it up to overflow again in 1/HZ seconds. | |
130 | */ | |
131 | void timer_interrupt(struct pt_regs * regs) | |
132 | { | |
7d2bd30f | 133 | struct pt_regs *old_regs; |
1da177e4 LT |
134 | int next_dec; |
135 | unsigned long cpu = smp_processor_id(); | |
136 | unsigned jiffy_stamp = last_jiffy_stamp(cpu); | |
137 | extern void do_IRQ(struct pt_regs *); | |
138 | ||
139 | if (atomic_read(&ppc_n_lost_interrupts) != 0) | |
140 | do_IRQ(regs); | |
141 | ||
7d2bd30f | 142 | old_regs = set_irq_regs(regs); |
1da177e4 LT |
143 | irq_enter(); |
144 | ||
145 | while ((next_dec = tb_ticks_per_jiffy - tb_delta(&jiffy_stamp)) <= 0) { | |
146 | jiffy_stamp += tb_ticks_per_jiffy; | |
147 | ||
3211be5c | 148 | profile_tick(CPU_PROFILING); |
1da177e4 LT |
149 | update_process_times(user_mode(regs)); |
150 | ||
151 | if (smp_processor_id()) | |
152 | continue; | |
153 | ||
154 | /* We are in an interrupt, no need to save/restore flags */ | |
155 | write_seqlock(&xtime_lock); | |
156 | tb_last_stamp = jiffy_stamp; | |
3171a030 | 157 | do_timer(1); |
1da177e4 LT |
158 | |
159 | /* | |
160 | * update the rtc when needed, this should be performed on the | |
161 | * right fraction of a second. Half or full second ? | |
162 | * Full second works on mk48t59 clocks, others need testing. | |
163 | * Note that this update is basically only used through | |
164 | * the adjtimex system calls. Setting the HW clock in | |
165 | * any other way is a /dev/rtc and userland business. | |
166 | * This is still wrong by -0.5/+1.5 jiffies because of the | |
167 | * timer interrupt resolution and possible delay, but here we | |
168 | * hit a quantization limit which can only be solved by higher | |
169 | * resolution timers and decoupling time management from timer | |
170 | * interrupts. This is also wrong on the clocks | |
171 | * which require being written at the half second boundary. | |
172 | * We should have an rtc call that only sets the minutes and | |
173 | * seconds like on Intel to avoid problems with non UTC clocks. | |
174 | */ | |
b149ee22 | 175 | if ( ppc_md.set_rtc_time && ntp_synced() && |
1da177e4 | 176 | xtime.tv_sec - last_rtc_update >= 659 && |
8ef38609 | 177 | abs((xtime.tv_nsec / 1000) - (1000000-1000000/HZ)) < 500000/HZ) { |
f326d22b | 178 | if (ppc_md.set_rtc_time(xtime.tv_sec+1 + timezone_offset) == 0) |
1da177e4 LT |
179 | last_rtc_update = xtime.tv_sec+1; |
180 | else | |
181 | /* Try again one minute later */ | |
182 | last_rtc_update += 60; | |
183 | } | |
184 | write_sequnlock(&xtime_lock); | |
185 | } | |
186 | if ( !disarm_decr[smp_processor_id()] ) | |
187 | set_dec(next_dec); | |
188 | last_jiffy_stamp(cpu) = jiffy_stamp; | |
189 | ||
190 | if (ppc_md.heartbeat && !ppc_md.heartbeat_count--) | |
191 | ppc_md.heartbeat(); | |
192 | ||
193 | irq_exit(); | |
7d2bd30f | 194 | set_irq_regs(old_regs); |
1da177e4 LT |
195 | } |
196 | ||
197 | /* | |
198 | * This version of gettimeofday has microsecond resolution. | |
199 | */ | |
200 | void do_gettimeofday(struct timeval *tv) | |
201 | { | |
202 | unsigned long flags; | |
203 | unsigned long seq; | |
8ef38609 | 204 | unsigned delta, usec, sec; |
1da177e4 LT |
205 | |
206 | do { | |
207 | seq = read_seqbegin_irqsave(&xtime_lock, flags); | |
208 | sec = xtime.tv_sec; | |
209 | usec = (xtime.tv_nsec / 1000); | |
210 | delta = tb_ticks_since(tb_last_stamp); | |
211 | #ifdef CONFIG_SMP | |
212 | /* As long as timebases are not in sync, gettimeofday can only | |
213 | * have jiffy resolution on SMP. | |
214 | */ | |
215 | if (!smp_tb_synchronized) | |
216 | delta = 0; | |
217 | #endif /* CONFIG_SMP */ | |
1da177e4 LT |
218 | } while (read_seqretry_irqrestore(&xtime_lock, seq, flags)); |
219 | ||
8ef38609 | 220 | usec += mulhwu(tb_to_us, delta); |
1da177e4 LT |
221 | while (usec >= 1000000) { |
222 | sec++; | |
223 | usec -= 1000000; | |
224 | } | |
225 | tv->tv_sec = sec; | |
226 | tv->tv_usec = usec; | |
227 | } | |
228 | ||
229 | EXPORT_SYMBOL(do_gettimeofday); | |
230 | ||
231 | int do_settimeofday(struct timespec *tv) | |
232 | { | |
233 | time_t wtm_sec, new_sec = tv->tv_sec; | |
234 | long wtm_nsec, new_nsec = tv->tv_nsec; | |
235 | unsigned long flags; | |
236 | int tb_delta; | |
237 | ||
238 | if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC) | |
239 | return -EINVAL; | |
240 | ||
241 | write_seqlock_irqsave(&xtime_lock, flags); | |
242 | /* Updating the RTC is not the job of this code. If the time is | |
243 | * stepped under NTP, the RTC will be update after STA_UNSYNC | |
244 | * is cleared. Tool like clock/hwclock either copy the RTC | |
245 | * to the system time, in which case there is no point in writing | |
246 | * to the RTC again, or write to the RTC but then they don't call | |
247 | * settimeofday to perform this operation. Note also that | |
248 | * we don't touch the decrementer since: | |
249 | * a) it would lose timer interrupt synchronization on SMP | |
250 | * (if it is working one day) | |
251 | * b) it could make one jiffy spuriously shorter or longer | |
252 | * which would introduce another source of uncertainty potentially | |
253 | * harmful to relatively short timers. | |
254 | */ | |
255 | ||
256 | /* This works perfectly on SMP only if the tb are in sync but | |
257 | * guarantees an error < 1 jiffy even if they are off by eons, | |
258 | * still reasonable when gettimeofday resolution is 1 jiffy. | |
259 | */ | |
260 | tb_delta = tb_ticks_since(last_jiffy_stamp(smp_processor_id())); | |
1da177e4 LT |
261 | |
262 | new_nsec -= 1000 * mulhwu(tb_to_us, tb_delta); | |
263 | ||
264 | wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - new_sec); | |
265 | wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - new_nsec); | |
266 | ||
267 | set_normalized_timespec(&xtime, new_sec, new_nsec); | |
268 | set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec); | |
269 | ||
270 | /* In case of a large backwards jump in time with NTP, we want the | |
271 | * clock to be updated as soon as the PLL is again in lock. | |
272 | */ | |
273 | last_rtc_update = new_sec - 658; | |
274 | ||
b149ee22 | 275 | ntp_clear(); |
1da177e4 LT |
276 | write_sequnlock_irqrestore(&xtime_lock, flags); |
277 | clock_was_set(); | |
278 | return 0; | |
279 | } | |
280 | ||
281 | EXPORT_SYMBOL(do_settimeofday); | |
282 | ||
283 | /* This function is only called on the boot processor */ | |
284 | void __init time_init(void) | |
285 | { | |
286 | time_t sec, old_sec; | |
287 | unsigned old_stamp, stamp, elapsed; | |
288 | ||
289 | if (ppc_md.time_init != NULL) | |
f326d22b | 290 | timezone_offset = ppc_md.time_init(); |
1da177e4 LT |
291 | |
292 | if (__USE_RTC()) { | |
293 | /* 601 processor: dec counts down by 128 every 128ns */ | |
294 | tb_ticks_per_jiffy = DECREMENTER_COUNT_601; | |
295 | /* mulhwu_scale_factor(1000000000, 1000000) is 0x418937 */ | |
296 | tb_to_us = 0x418937; | |
297 | } else { | |
298 | ppc_md.calibrate_decr(); | |
299 | tb_to_ns_scale = mulhwu(tb_to_us, 1000 << 10); | |
300 | } | |
301 | ||
302 | /* Now that the decrementer is calibrated, it can be used in case the | |
303 | * clock is stuck, but the fact that we have to handle the 601 | |
304 | * makes things more complex. Repeatedly read the RTC until the | |
305 | * next second boundary to try to achieve some precision. If there | |
306 | * is no RTC, we still need to set tb_last_stamp and | |
307 | * last_jiffy_stamp(cpu 0) to the current stamp. | |
308 | */ | |
309 | stamp = get_native_tbl(); | |
310 | if (ppc_md.get_rtc_time) { | |
311 | sec = ppc_md.get_rtc_time(); | |
312 | elapsed = 0; | |
313 | do { | |
314 | old_stamp = stamp; | |
315 | old_sec = sec; | |
316 | stamp = get_native_tbl(); | |
317 | if (__USE_RTC() && stamp < old_stamp) | |
318 | old_stamp -= 1000000000; | |
319 | elapsed += stamp - old_stamp; | |
320 | sec = ppc_md.get_rtc_time(); | |
321 | } while ( sec == old_sec && elapsed < 2*HZ*tb_ticks_per_jiffy); | |
322 | if (sec==old_sec) | |
323 | printk("Warning: real time clock seems stuck!\n"); | |
324 | xtime.tv_sec = sec; | |
325 | xtime.tv_nsec = 0; | |
326 | /* No update now, we just read the time from the RTC ! */ | |
327 | last_rtc_update = xtime.tv_sec; | |
328 | } | |
329 | last_jiffy_stamp(0) = tb_last_stamp = stamp; | |
330 | ||
331 | /* Not exact, but the timer interrupt takes care of this */ | |
332 | set_dec(tb_ticks_per_jiffy); | |
333 | ||
334 | /* If platform provided a timezone (pmac), we correct the time */ | |
f326d22b | 335 | if (timezone_offset) { |
336 | sys_tz.tz_minuteswest = -timezone_offset / 60; | |
1da177e4 | 337 | sys_tz.tz_dsttime = 0; |
f326d22b | 338 | xtime.tv_sec -= timezone_offset; |
1da177e4 LT |
339 | } |
340 | set_normalized_timespec(&wall_to_monotonic, | |
341 | -xtime.tv_sec, -xtime.tv_nsec); | |
342 | } | |
343 | ||
344 | #define FEBRUARY 2 | |
345 | #define STARTOFTIME 1970 | |
346 | #define SECDAY 86400L | |
347 | #define SECYR (SECDAY * 365) | |
348 | ||
349 | /* | |
350 | * Note: this is wrong for 2100, but our signed 32-bit time_t will | |
351 | * have overflowed long before that, so who cares. -- paulus | |
352 | */ | |
353 | #define leapyear(year) ((year) % 4 == 0) | |
354 | #define days_in_year(a) (leapyear(a) ? 366 : 365) | |
355 | #define days_in_month(a) (month_days[(a) - 1]) | |
356 | ||
357 | static int month_days[12] = { | |
358 | 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 | |
359 | }; | |
360 | ||
361 | void to_tm(int tim, struct rtc_time * tm) | |
362 | { | |
363 | register int i; | |
364 | register long hms, day, gday; | |
365 | ||
366 | gday = day = tim / SECDAY; | |
367 | hms = tim % SECDAY; | |
368 | ||
369 | /* Hours, minutes, seconds are easy */ | |
370 | tm->tm_hour = hms / 3600; | |
371 | tm->tm_min = (hms % 3600) / 60; | |
372 | tm->tm_sec = (hms % 3600) % 60; | |
373 | ||
374 | /* Number of years in days */ | |
375 | for (i = STARTOFTIME; day >= days_in_year(i); i++) | |
376 | day -= days_in_year(i); | |
377 | tm->tm_year = i; | |
378 | ||
379 | /* Number of months in days left */ | |
380 | if (leapyear(tm->tm_year)) | |
381 | days_in_month(FEBRUARY) = 29; | |
382 | for (i = 1; day >= days_in_month(i); i++) | |
383 | day -= days_in_month(i); | |
384 | days_in_month(FEBRUARY) = 28; | |
385 | tm->tm_mon = i; | |
386 | ||
387 | /* Days are what is left over (+1) from all that. */ | |
388 | tm->tm_mday = day + 1; | |
389 | ||
390 | /* | |
391 | * Determine the day of week. Jan. 1, 1970 was a Thursday. | |
392 | */ | |
393 | tm->tm_wday = (gday + 4) % 7; | |
394 | } | |
395 | ||
396 | /* Auxiliary function to compute scaling factors */ | |
397 | /* Actually the choice of a timebase running at 1/4 the of the bus | |
398 | * frequency giving resolution of a few tens of nanoseconds is quite nice. | |
399 | * It makes this computation very precise (27-28 bits typically) which | |
400 | * is optimistic considering the stability of most processor clock | |
401 | * oscillators and the precision with which the timebase frequency | |
402 | * is measured but does not harm. | |
403 | */ | |
404 | unsigned mulhwu_scale_factor(unsigned inscale, unsigned outscale) { | |
405 | unsigned mlt=0, tmp, err; | |
406 | /* No concern for performance, it's done once: use a stupid | |
407 | * but safe and compact method to find the multiplier. | |
408 | */ | |
409 | for (tmp = 1U<<31; tmp != 0; tmp >>= 1) { | |
410 | if (mulhwu(inscale, mlt|tmp) < outscale) mlt|=tmp; | |
411 | } | |
412 | /* We might still be off by 1 for the best approximation. | |
413 | * A side effect of this is that if outscale is too large | |
414 | * the returned value will be zero. | |
415 | * Many corner cases have been checked and seem to work, | |
416 | * some might have been forgotten in the test however. | |
417 | */ | |
418 | err = inscale*(mlt+1); | |
419 | if (err <= inscale/2) mlt++; | |
420 | return mlt; | |
421 | } | |
422 | ||
423 | unsigned long long sched_clock(void) | |
424 | { | |
425 | unsigned long lo, hi, hi2; | |
426 | unsigned long long tb; | |
427 | ||
428 | if (!__USE_RTC()) { | |
429 | do { | |
430 | hi = get_tbu(); | |
431 | lo = get_tbl(); | |
432 | hi2 = get_tbu(); | |
433 | } while (hi2 != hi); | |
434 | tb = ((unsigned long long) hi << 32) | lo; | |
435 | tb = (tb * tb_to_ns_scale) >> 10; | |
436 | } else { | |
437 | do { | |
438 | hi = get_rtcu(); | |
439 | lo = get_rtcl(); | |
440 | hi2 = get_rtcu(); | |
441 | } while (hi2 != hi); | |
442 | tb = ((unsigned long long) hi) * 1000000000 + lo; | |
443 | } | |
444 | return tb; | |
445 | } |