root/kernel/time.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. mktime
  2. time_init
  3. sys_time
  4. sys_stime
  5. do_gettimeoffset
  6. do_gettimeofday
  7. sys_gettimeofday
  8. warp_clock
  9. sys_settimeofday
  10. sys_adjtimex
  11. set_rtc_mmss

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

/* [previous][next][first][last][top][bottom][index][help] */