1 /* 2 * linux/kernel/time.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 * 6 * This file contains the interface functions for the various 7 * time related system calls: time, stime, gettimeofday, settimeofday, 8 * adjtime 9 */ 10 /* 11 * Modification history kernel/time.c 12 * 13 * 1993-09-02 Philip Gladstone 14 * Created file with time related functions from sched.c and adjtimex() 15 * 1993-10-08 Torsten Duwe 16 * adjtime interface update and CMOS clock write code 17 * 1994-07-02 Alan Modra 18 * fixed set_rtc_mmss, fixed time.year for >= 2000, new mktime 19 * 1995-03-26 Markus Kuhn 20 * fixed 500 ms bug at call to set_rtc_mmss, fixed DS12887 21 * precision CMOS clock update 22 * 23 * to do: adjtimex() has to be updated to recent (1994-12-13) revision 24 * of David Mill's kernel clock model. For more information, check 25 * <ftp://louie.udel.edu/pub/ntp/kernel.tar.Z>. 26 */ 27
28 #include <linux/errno.h>
29 #include <linux/sched.h>
30 #include <linux/kernel.h>
31 #include <linux/param.h>
32 #include <linux/string.h>
33 #include <linux/mm.h>
34
35 #include <asm/segment.h>
36 #include <asm/io.h>
37
38 #include <linux/mc146818rtc.h>
39 #include <linux/timex.h>
40
41 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00. 42 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59 43 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59. 44 * 45 * [For the Julian calendar (which was used in Russia before 1917, 46 * Britain & colonies before 1752, anywhere else before 1582, 47 * and is still in use by some communities) leave out the 48 * -year/100+year/400 terms, and add 10.] 49 * 50 * This algorithm was first published by Gauss (I think). 51 * 52 * WARNING: this function will overflow on 2106-02-07 06:28:16 on 53 * machines were long is 32-bit! (However, as time_t is signed, we 54 * will already get problems at other places on 2038-01-19 03:14:08) 55 */ 56 staticinlineunsignedlongmktime(unsignedintyear, unsignedintmon,
/* */ 57 unsignedintday, unsignedinthour,
58 unsignedintmin, unsignedintsec)
59 { 60 if (0 >= (int) (mon -= 2)) {/* 1..12 -> 11,12,1..10 */ 61 mon += 12; /* Puts Feb last since it has leap day */ 62 year -= 1;
63 } 64 return (((
65 (unsignedlong)(year/4 - year/100 + year/400 + 367*mon/12 + day) +
66 year*365 - 719499
67 )*24 + hour/* now have hours */ 68 )*60 + min/* now have minutes */ 69 )*60 + sec; /* finally seconds */ 70 } 71
72 voidtime_init(void)
/* */ 73 { 74 unsignedintyear, mon, day, hour, min, sec;
75 inti;
76
77 /* The Linux interpretation of the CMOS clock register contents: 78 * When the Update-In-Progress (UIP) flag goes from 1 to 0, the 79 * RTC registers show the second which has precisely just started. 80 * Let's hope other operating systems interpret the RTC the same way. 81 */ 82 /* read RTC exactly on falling edge of update flag */ 83 for (i = 0 ; i < 1000000 ; i++) /* may take up to 1 second... */ 84 if (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP)
85 break;
86 for (i = 0 ; i < 1000000 ; i++) /* must try at least 2.228 ms */ 87 if (!(CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP))
88 break;
89 do{/* Isn't this overkill ? UIP above should guarantee consistency */ 90 sec = CMOS_READ(RTC_SECONDS);
91 min = CMOS_READ(RTC_MINUTES);
92 hour = CMOS_READ(RTC_HOURS);
93 day = CMOS_READ(RTC_DAY_OF_MONTH);
94 mon = CMOS_READ(RTC_MONTH);
95 year = CMOS_READ(RTC_YEAR);
96 }while (sec != CMOS_READ(RTC_SECONDS));
97 if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
98 { 99 BCD_TO_BIN(sec);
100 BCD_TO_BIN(min);
101 BCD_TO_BIN(hour);
102 BCD_TO_BIN(day);
103 BCD_TO_BIN(mon);
104 BCD_TO_BIN(year);
105 } 106 if ((year += 1900) < 1970)
107 year += 100;
108 xtime.tv_sec = mktime(year, mon, day, hour, min, sec);
109 xtime.tv_usec = 0;
110 } 111
112 /* 113 * The timezone where the local system is located. Used as a default by some 114 * programs who obtain this value by using gettimeofday. 115 */ 116 structtimezonesys_tz = { 0, 0};
117
118 asmlinkageint sys_time(long * tloc)
/* */ 119 { 120 inti, error;
121
122 i = CURRENT_TIME;
123 if (tloc) { 124 error = verify_area(VERIFY_WRITE, tloc, 4);
125 if (error)
126 returnerror;
127 put_fs_long(i,(unsignedlong *)tloc);
128 } 129 returni;
130 } 131
132 asmlinkageint sys_stime(unsignedlong * tptr)
/* */ 133 { 134 interror;
135 unsignedlongvalue;
136
137 if (!suser())
138 return -EPERM;
139 error = verify_area(VERIFY_READ, tptr, sizeof(*tptr));
140 if (error)
141 returnerror;
142 value = get_fs_long(tptr);
143 cli();
144 xtime.tv_sec = value;
145 xtime.tv_usec = 0;
146 time_status = TIME_BAD;
147 time_maxerror = 0x70000000;
148 time_esterror = 0x70000000;
149 sti();
150 return 0;
151 } 152
153 /* This function must be called with interrupts disabled 154 * It was inspired by Steve McCanne's microtime-i386 for BSD. -- jrs 155 * 156 * However, the pc-audio speaker driver changes the divisor so that 157 * it gets interrupted rather more often - it loads 64 into the 158 * counter rather than 11932! This has an adverse impact on 159 * do_gettimeoffset() -- it stops working! What is also not 160 * good is that the interval that our timer function gets called 161 * is no longer 10.0002 ms, but 9.9767 ms. To get around this 162 * would require using a different timing source. Maybe someone 163 * could use the RTC - I know that this can interrupt at frequencies 164 * ranging from 8192Hz to 2Hz. If I had the energy, I'd somehow fix 165 * it so that at startup, the timer code in sched.c would select 166 * using either the RTC or the 8253 timer. The decision would be 167 * based on whether there was any other device around that needed 168 * to trample on the 8253. I'd set up the RTC to interrupt at 1024 Hz, 169 * and then do some jiggery to have a version of do_timer that 170 * advanced the clock by 1/1024 s. Every time that reached over 1/100 171 * of a second, then do all the old code. If the time was kept correct 172 * then do_gettimeoffset could just return 0 - there is no low order 173 * divider that can be accessed. 174 * 175 * Ideally, you would be able to use the RTC for the speaker driver, 176 * but it appears that the speaker driver really needs interrupt more 177 * often than every 120 us or so. 178 * 179 * Anyway, this needs more thought.... pjsg (1993-08-28) 180 * 181 * If you are really that interested, you should be reading 182 * comp.protocols.time.ntp! 183 */ 184
185 #defineTICK_SIZEtick 186
187 staticinlineunsignedlongdo_gettimeoffset(void)
/* */ 188 { 189 intcount;
190 unsignedlongoffset = 0;
191
192 /* timer count may underflow right here */ 193 outb_p(0x00, 0x43); /* latch the count ASAP */ 194 count = inb_p(0x40); /* read the latched count */ 195 count |= inb(0x40) << 8;
196 /* we know probability of underflow is always MUCH less than 1% */ 197 if (count > (LATCH - LATCH/100)) { 198 /* check for pending timer interrupt */ 199 outb_p(0x0a, 0x20);
200 if (inb(0x20) & 1)
201 offset = TICK_SIZE;
202 } 203 count = ((LATCH-1) - count) * TICK_SIZE;
204 count = (count + LATCH/2) / LATCH;
205 returnoffset + count;
206 } 207
208 /* 209 * This version of gettimeofday has near microsecond resolution. 210 */ 211 voiddo_gettimeofday(structtimeval *tv)
/* */ 212 { 213 unsignedlongflags;
214
215 save_flags(flags);
216 cli();
217 *tv = xtime;
218 #ifdefined (__i386__) || defined (__mips__)
219 tv->tv_usec += do_gettimeoffset();
220 if (tv->tv_usec >= 1000000) { 221 tv->tv_usec -= 1000000;
222 tv->tv_sec++;
223 } 224 #endif/* !defined (__i386__) && !defined (__mips__) */ 225 restore_flags(flags);
226 } 227
228 asmlinkageint sys_gettimeofday(structtimeval *tv, structtimezone *tz)
/* */ 229 { 230 interror;
231
232 if (tv) { 233 structtimevalktv;
234 error = verify_area(VERIFY_WRITE, tv, sizeof *tv);
235 if (error)
236 returnerror;
237 do_gettimeofday(&ktv);
238 memcpy_tofs(tv, &ktv, sizeof(ktv));
239 } 240 if (tz) { 241 error = verify_area(VERIFY_WRITE, tz, sizeof *tz);
242 if (error)
243 returnerror;
244 memcpy_tofs(tz, &sys_tz, sizeof(sys_tz));
245 } 246 return 0;
247 } 248
249 /* 250 * Adjust the time obtained from the CMOS to be UTC time instead of 251 * local time. 252 * 253 * This is ugly, but preferable to the alternatives. Otherwise we 254 * would either need to write a program to do it in /etc/rc (and risk 255 * confusion if the program gets run more than once; it would also be 256 * hard to make the program warp the clock precisely n hours) or 257 * compile in the timezone information into the kernel. Bad, bad.... 258 * 259 * - TYT, 1992-01-01 260 * 261 * The best thing to do is to keep the CMOS clock in universal time (UTC) 262 * as real UNIX machines always do it. This avoids all headaches about 263 * daylight saving times and warping kernel clocks. 264 */ 265 inlinestaticvoidwarp_clock(void)
/* */ 266 { 267 cli();
268 xtime.tv_sec += sys_tz.tz_minuteswest * 60;
269 sti();
270 } 271
272 /* 273 * In case for some reason the CMOS clock has not already been running 274 * in UTC, but in some local time: The first time we set the timezone, 275 * we will warp the clock so that it is ticking UTC time instead of 276 * local time. Presumably, if someone is setting the timezone then we 277 * are running in an environment where the programs understand about 278 * timezones. This should be done at boot time in the /etc/rc script, 279 * as soon as possible, so that the clock can be set right. Otherwise, 280 * various programs will get confused when the clock gets warped. 281 */ 282 asmlinkageint sys_settimeofday(structtimeval *tv, structtimezone *tz)
/* */ 283 { 284 staticintfirsttime = 1;
285 structtimevalnew_tv;
286 structtimezonenew_tz;
287
288 if (!suser())
289 return -EPERM;
290 if (tv) { 291 interror = verify_area(VERIFY_READ, tv, sizeof(*tv));
292 if (error)
293 returnerror;
294 memcpy_fromfs(&new_tv, tv, sizeof(*tv));
295 } 296 if (tz) { 297 interror = verify_area(VERIFY_READ, tz, sizeof(*tz));
298 if (error)
299 returnerror;
300 memcpy_fromfs(&new_tz, tz, sizeof(*tz));
301 } 302 if (tz) { 303 sys_tz = new_tz;
304 if (firsttime) { 305 firsttime = 0;
306 if (!tv)
307 warp_clock();
308 } 309 } 310 if (tv) { 311 cli();
312 /* This is revolting. We need to set the xtime.tv_usec 313 * correctly. However, the value in this location is 314 * is value at the last tick. 315 * Discover what correction gettimeofday 316 * would have done, and then undo it! 317 */ 318 new_tv.tv_usec -= do_gettimeoffset();
319
320 if (new_tv.tv_usec < 0) { 321 new_tv.tv_usec += 1000000;
322 new_tv.tv_sec--;
323 } 324
325 xtime = new_tv;
326 time_status = TIME_BAD;
327 time_maxerror = 0x70000000;
328 time_esterror = 0x70000000;
329 sti();
330 } 331 return 0;
332 } 333
334 /* adjtimex mainly allows reading (and writing, if superuser) of 335 * kernel time-keeping variables. used by xntpd. 336 */ 337 asmlinkageint sys_adjtimex(structtimex *txc_p)
/* */ 338 { 339 longltemp, mtemp, save_adjust;
340 interror;
341
342 /* Local copy of parameter */ 343 structtimextxc;
344
345 error = verify_area(VERIFY_WRITE, txc_p, sizeof(structtimex));
346 if (error)
347 returnerror;
348
349 /* Copy the user data space into the kernel copy 350 * structure. But bear in mind that the structures 351 * may change 352 */ 353 memcpy_fromfs(&txc, txc_p, sizeof(structtimex));
354
355 /* In order to modify anything, you gotta be super-user! */ 356 if (txc.mode && !suser())
357 return -EPERM;
358
359 /* Now we validate the data before disabling interrupts 360 */ 361
362 if (txc.mode != ADJ_OFFSET_SINGLESHOT && (txc.mode & ADJ_OFFSET))
363 /* Microsec field limited to -131000 .. 131000 usecs */ 364 if (txc.offset <= -(1 << (31 - SHIFT_UPDATE))
365 || txc.offset >= (1 << (31 - SHIFT_UPDATE)))
366 return -EINVAL;
367
368 /* time_status must be in a fairly small range */ 369 if (txc.mode & ADJ_STATUS)
370 if (txc.status < TIME_OK || txc.status > TIME_BAD)
371 return -EINVAL;
372
373 /* if the quartz is off by more than 10% something is VERY wrong ! */ 374 if (txc.mode & ADJ_TICK)
375 if (txc.tick < 900000/HZ || txc.tick > 1100000/HZ)
376 return -EINVAL;
377
378 cli();
379
380 /* Save for later - semantics of adjtime is to return old value */ 381 save_adjust = time_adjust;
382
383 /* If there are input parameters, then process them */ 384 if (txc.mode)
385 { 386 if (time_status == TIME_BAD)
387 time_status = TIME_OK;
388
389 if (txc.mode & ADJ_STATUS)
390 time_status = txc.status;
391
392 if (txc.mode & ADJ_FREQUENCY)
393 time_freq = txc.frequency << (SHIFT_KF - 16);
394
395 if (txc.mode & ADJ_MAXERROR)
396 time_maxerror = txc.maxerror;
397
398 if (txc.mode & ADJ_ESTERROR)
399 time_esterror = txc.esterror;
400
401 if (txc.mode & ADJ_TIMECONST)
402 time_constant = txc.time_constant;
403
404 if (txc.mode & ADJ_OFFSET)
405 if (txc.mode == ADJ_OFFSET_SINGLESHOT)
406 { 407 time_adjust = txc.offset;
408 } 409 else/* XXX should give an error if other bits set */ 410 { 411 time_offset = txc.offset << SHIFT_UPDATE;
412 mtemp = xtime.tv_sec - time_reftime;
413 time_reftime = xtime.tv_sec;
414 if (mtemp > (MAXSEC+2) || mtemp < 0)
415 mtemp = 0;
416
417 if (txc.offset < 0)
418 time_freq -= (-txc.offset * mtemp) >>
419 (time_constant + time_constant);
420 else 421 time_freq += (txc.offset * mtemp) >>
422 (time_constant + time_constant);
423
424 ltemp = time_tolerance << SHIFT_KF;
425
426 if (time_freq > ltemp)
427 time_freq = ltemp;
428 elseif (time_freq < -ltemp)
429 time_freq = -ltemp;
430 } 431 if (txc.mode & ADJ_TICK)
432 tick = txc.tick;
433
434 } 435 txc.offset = save_adjust;
436 txc.frequency = ((time_freq+1) >> (SHIFT_KF - 16));
437 txc.maxerror = time_maxerror;
438 txc.esterror = time_esterror;
439 txc.status = time_status;
440 txc.time_constant = time_constant;
441 txc.precision = time_precision;
442 txc.tolerance = time_tolerance;
443 txc.time = xtime;
444 txc.tick = tick;
445
446 sti();
447
448 memcpy_tofs(txc_p, &txc, sizeof(structtimex));
449 returntime_status;
450 } 451
452 /* 453 * In order to set the CMOS clock precisely, set_rtc_mmss has to be 454 * called 500 ms after the second nowtime has started, because when 455 * nowtime is written into the registers of the CMOS clock, it will 456 * jump to the next second precisely 500 ms later. Check the Motorola 457 * MC146818A or Dallas DS12887 data sheet for details. 458 */ 459 intset_rtc_mmss(unsignedlongnowtime)
/* */ 460 { 461 intretval = 0;
462 intreal_seconds, real_minutes, cmos_minutes;
463 unsignedcharsave_control, save_freq_select;
464
465 save_control = CMOS_READ(RTC_CONTROL); /* tell the clock it's being set */ 466 CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
467
468 save_freq_select = CMOS_READ(RTC_FREQ_SELECT); /* stop and reset prescaler */ 469 CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
470
471 cmos_minutes = CMOS_READ(RTC_MINUTES);
472 if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
473 BCD_TO_BIN(cmos_minutes);
474
475 /* since we're only adjusting minutes and seconds, 476 * don't interfere with hour overflow. This avoids 477 * messing with unknown time zones but requires your 478 * RTC not to be off by more than 15 minutes 479 */ 480 real_seconds = nowtime % 60;
481 real_minutes = nowtime / 60;
482 if (((abs(real_minutes - cmos_minutes) + 15)/30) & 1)
483 real_minutes += 30; /* correct for half hour time zone */ 484 real_minutes %= 60;
485
486 if (abs(real_minutes - cmos_minutes) < 30)
487 { 488 if (!(save_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
489 { 490 BIN_TO_BCD(real_seconds);
491 BIN_TO_BCD(real_minutes);
492 } 493 CMOS_WRITE(real_seconds,RTC_SECONDS);
494 CMOS_WRITE(real_minutes,RTC_MINUTES);
495 } 496 else 497 retval = -1;
498
499 /* The following flags have to be released exactly in this order, 500 * otherwise the DS12887 (popular MC146818A clone with integrated 501 * battery and quartz) will not reset the oscillator and will not 502 * update precisely 500 ms later. You won't find this mentioned in 503 * the Dallas Semiconductor data sheets, but who believes data 504 * sheets anyway ... -- Markus Kuhn 505 */ 506 CMOS_WRITE(save_control, RTC_CONTROL);
507 CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
508
509 returnretval;
510 }