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

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