arch/ppc/kernel/time.c

   1 /*
   2  * $Id: time.c,v 1.39 1998/12/28 10:28:51 paulus Exp $
   3  * Common time routines among all ppc machines.
   4  *
   5  * Written by Cort Dougan (cort@cs.nmt.edu) to merge
   6  * Paul Mackerras' version and mine for PReP and Pmac.
   7  * MPC8xx/MBX changes by Dan Malek (dmalek@jlc.net).
   8  *
   9  * Since the MPC8xx has a programmable interrupt timer, I decided to
  10  * use that rather than the decrementer.  Two reasons: 1.) the clock
  11  * frequency is low, causing 2.) a long wait in the timer interrupt
  12  *              while ((d = get_dec()) == dval)
  13  * loop.  The MPC8xx can be driven from a variety of input clocks,
  14  * so a number of assumptions have been made here because the kernel
  15  * parameter HZ is a constant.  We assume (correctly, today :-) that
  16  * the MPC8xx on the MBX board is driven from a 32.768 kHz crystal.
  17  * This is then divided by 4, providing a 8192 Hz clock into the PIT.
  18  * Since it is not possible to get a nice 100 Hz clock out of this, without
  19  * creating a software PLL, I have set HZ to 128.  -- Dan
  20  *
  21  * 1997-09-10   Updated NTP code according to technical memorandum Jan '96
  22  *              "A Kernel Model for Precision Timekeeping" by Dave Mills
  23  */
  24
  25 #include <linux/config.h>
  26 #include <linux/errno.h>
  27 #include <linux/sched.h>
  28 #include <linux/kernel.h>
  29 #include <linux/param.h>
  30 #include <linux/string.h>
  31 #include <linux/mm.h>
  32 #include <linux/interrupt.h>
  33 #include <linux/timex.h>
  34 #include <linux/kernel_stat.h>
  35 #include <linux/mc146818rtc.h>
  36 #include <linux/time.h>
  37 #include <linux/init.h>
  38
  39 #include <asm/segment.h>
  40 #include <asm/io.h>
  41 #include <asm/processor.h>
  42 #include <asm/nvram.h>
  43 #include <asm/cache.h>
  44 #ifdef CONFIG_MBX
  45 #include <asm/mbx.h>
  46 #endif
  47 #ifdef CONFIG_8xx
  48 #include <asm/8xx_immap.h>
  49 #endif
  50
  51 #include "time.h"
  52
  53 /* this is set to the appropriate pmac/prep/chrp func in init_IRQ() */
  54 int (*set_rtc_time)(unsigned long);
  55
  56 void smp_local_timer_interrupt(struct pt_regs *);
  57
  58 /* keep track of when we need to update the rtc */
  59 unsigned long last_rtc_update = 0;
  60
  61 /* The decrementer counts down by 128 every 128ns on a 601. */
  62 #define DECREMENTER_COUNT_601   (1000000000 / HZ)
  63 #define COUNT_PERIOD_NUM_601    1
  64 #define COUNT_PERIOD_DEN_601    1000
  65
  66 unsigned decrementer_count;     /* count value for 1e6/HZ microseconds */
  67 unsigned count_period_num;      /* 1 decrementer count equals */
  68 unsigned count_period_den;      /* count_period_num / count_period_den us */
  69
  70 /*
  71  * timer_interrupt - gets called when the decrementer overflows,
  72  * with interrupts disabled.
  73  * We set it up to overflow again in 1/HZ seconds.
  74  */
  75 void timer_interrupt(struct pt_regs * regs)
  76 {
  77         int dval, d;
  78         unsigned long cpu = smp_processor_id();
  79         /* save the HID0 in case dcache was off - see idle.c
  80          * this hack should leave for a better solution -- Cort */
  81         unsigned dcache_locked = unlock_dcache();
  82
  83         hardirq_enter(cpu);
  84 #ifdef __SMP__
  85         {
  86                 unsigned int loops = 100000000;
  87                 while (test_bit(0, &global_irq_lock)) {
  88                         if (smp_processor_id() == global_irq_holder) {
  89                                 printk("uh oh, interrupt while we hold global irq lock!\n");
  90 #ifdef CONFIG_XMON
  91                                 xmon(0);
  92 #endif
  93                                 break;
  94                         }
  95                         if (loops-- == 0) {
  96                                 printk("do_IRQ waiting for irq lock (holder=%d)\n", global_irq_holder);
  97 #ifdef CONFIG_XMON
  98                                 xmon(0);
  99 #endif
 100                         }
 101                 }
 102         }
 103 #endif /* __SMP__ */
 104
 105         while ((dval = get_dec()) < 0) {
 106                 /*
 107                  * Wait for the decrementer to change, then jump
 108                  * in and add decrementer_count to its value
 109                  * (quickly, before it changes again!)
 110                  */
 111                 while ((d = get_dec()) == dval)
 112                         ;
 113                 set_dec(d + decrementer_count);
 114                 if ( !smp_processor_id() )
 115                 {
 116                         do_timer(regs);
 117                         /*
 118                          * update the rtc when needed
 119                          */
 120                         if ( xtime.tv_sec > last_rtc_update + 660 )
 121                         {
 122                                 if (set_rtc_time(xtime.tv_sec) == 0)
 123                                         last_rtc_update = xtime.tv_sec;
 124                                 else
 125                                         last_rtc_update = xtime.tv_sec - 600; /* do it again in 60 s */
 126                         }
 127                 }
 128         }
 129 #ifdef __SMP__
 130         smp_local_timer_interrupt(regs);
 131 #endif
 132 #ifdef CONFIG_APUS
 133         {
 134                 extern void apus_heartbeat (void);
 135                 apus_heartbeat ();
 136         }
 137 #endif
 138         hardirq_exit(cpu);
 139         /* restore the HID0 in case dcache was off - see idle.c
 140          * this hack should leave for a better solution -- Cort */
 141         lock_dcache(dcache_locked);
 142 }
 143
 144 #ifdef CONFIG_MBX
 145 /* A place holder for time base interrupts, if they are ever enabled.
 146 */
 147 void timebase_interrupt(int irq, void * dev, struct pt_regs * regs)
 148 {
 149         printk("timebase_interrupt()\n");
 150 }
 151
 152 /* The RTC on the MPC8xx is an internal register.
 153  * We want to protect this during power down, so we need to unlock,
 154  * modify, and re-lock.
 155  */
 156 static int
 157 mbx_set_rtc_time(unsigned long time)
 158 {
 159         ((immap_t *)IMAP_ADDR)->im_sitk.sitk_rtck = KAPWR_KEY;
 160         ((immap_t *)IMAP_ADDR)->im_sit.sit_rtc = time;
 161         ((immap_t *)IMAP_ADDR)->im_sitk.sitk_rtck = ~KAPWR_KEY;
 162         return(0);
 163 }
 164 #endif /* CONFIG_MBX */
 165
 166 /*
 167  * This version of gettimeofday has microsecond resolution.
 168  */
 169 void do_gettimeofday(struct timeval *tv)
 170 {
 171         unsigned long flags;
 172
 173         save_flags(flags);
 174         cli();
 175         *tv = xtime;
 176         /* XXX we don't seem to have the decrementers synced properly yet */
 177 #ifndef __SMP__
 178         tv->tv_usec += (decrementer_count - get_dec())
 179             * count_period_num / count_period_den;
 180         if (tv->tv_usec >= 1000000) {
 181                 tv->tv_usec -= 1000000;
 182                 tv->tv_sec++;
 183         }
 184 #endif
 185         restore_flags(flags);
 186 }
 187
 188 void do_settimeofday(struct timeval *tv)
 189 {
 190         unsigned long flags;
 191         int frac_tick;
 192
 193         last_rtc_update = 0; /* so the rtc gets updated soon */
 194
 195         frac_tick = tv->tv_usec % (1000000 / HZ);
 196         save_flags(flags);
 197         cli();
 198         xtime.tv_sec = tv->tv_sec;
 199         xtime.tv_usec = tv->tv_usec - frac_tick;
 200         set_dec(frac_tick * count_period_den / count_period_num);
 201         time_adjust = 0;                /* stop active adjtime() */
 202         time_status |= STA_UNSYNC;
 203         time_state = TIME_ERROR;        /* p. 24, (a) */
 204         time_maxerror = NTP_PHASE_LIMIT;
 205         time_esterror = NTP_PHASE_LIMIT;
 206         restore_flags(flags);
 207 }
 208
 209
 210 __initfunc(void time_init(void))
 211 {
 212 #ifndef CONFIG_MBX
 213         if ((_get_PVR() >> 16) == 1) {
 214                 /* 601 processor: dec counts down by 128 every 128ns */
 215                 decrementer_count = DECREMENTER_COUNT_601;
 216                 count_period_num = COUNT_PERIOD_NUM_601;
 217                 count_period_den = COUNT_PERIOD_DEN_601;
 218         }
 219
 220         switch (_machine) {
 221         case _MACH_Pmac:
 222                 xtime.tv_sec = pmac_get_rtc_time();
 223                 if ( (_get_PVR() >> 16) != 1 && (!smp_processor_id()) )
 224                         pmac_calibrate_decr();
 225                 if ( !smp_processor_id() )
 226                         set_rtc_time = pmac_set_rtc_time;
 227                 break;
 228         case _MACH_chrp:
 229                 chrp_time_init();
 230                 xtime.tv_sec = chrp_get_rtc_time();
 231                 if ((_get_PVR() >> 16) != 1)
 232                         chrp_calibrate_decr();
 233                 set_rtc_time = chrp_set_rtc_time;
 234                 break;
 235         case _MACH_prep:
 236                 xtime.tv_sec = prep_get_rtc_time();
 237                 prep_calibrate_decr();
 238                 set_rtc_time = prep_set_rtc_time;
 239                 break;
 240 #ifdef CONFIG_APUS
 241         case _MACH_apus:
 242         {
 243                 xtime.tv_sec = apus_get_rtc_time();
 244                 apus_calibrate_decr();
 245                 set_rtc_time = apus_set_rtc_time;
 246                 break;
 247         }
 248 #endif
 249         }
 250         xtime.tv_usec = 0;
 251 #else /* CONFIG_MBX */
 252         mbx_calibrate_decr();
 253         set_rtc_time = mbx_set_rtc_time;
 254
 255         /* First, unlock all of the registers we are going to modify.
 256          * To protect them from corruption during power down, registers
 257          * that are maintained by keep alive power are "locked".  To
 258          * modify these registers we have to write the key value to
 259          * the key location associated with the register.
 260          */
 261         ((immap_t *)IMAP_ADDR)->im_sitk.sitk_tbscrk = KAPWR_KEY;
 262         ((immap_t *)IMAP_ADDR)->im_sitk.sitk_rtcsck = KAPWR_KEY;
 263
 264
 265         /* Disable the RTC one second and alarm interrupts.
 266         */
 267         ((immap_t *)IMAP_ADDR)->im_sit.sit_rtcsc &=
 268                                                 ~(RTCSC_SIE | RTCSC_ALE);
 269
 270         /* Enabling the decrementer also enables the timebase interrupts
 271          * (or from the other point of view, to get decrementer interrupts
 272          * we have to enable the timebase).  The decrementer interrupt
 273          * is wired into the vector table, nothing to do here for that.
 274          */
 275         ((immap_t *)IMAP_ADDR)->im_sit.sit_tbscr =
 276                                 ((mk_int_int_mask(DEC_INTERRUPT) << 8) |
 277                                          (TBSCR_TBF | TBSCR_TBE));
 278         if (request_irq(DEC_INTERRUPT, timebase_interrupt, 0, "tbint", NULL) != 0)
 279                 panic("Could not allocate timer IRQ!");
 280
 281         /* Get time from the RTC.
 282         */
 283         xtime.tv_sec = ((immap_t *)IMAP_ADDR)->im_sit.sit_rtc;
 284         xtime.tv_usec = 0;
 285
 286 #endif /* CONFIG_MBX */
 287         set_dec(decrementer_count);
 288         /* mark the rtc/on-chip timer as in sync
 289          * so we don't update right away
 290          */
 291         last_rtc_update = xtime.tv_sec;
 292 }
 293
 294 #ifndef CONFIG_MBX
 295 /*
 296  * Uses the on-board timer to calibrate the on-chip decrementer register
 297  * for prep systems.  On the pmac the OF tells us what the frequency is
 298  * but on prep we have to figure it out.
 299  * -- Cort
 300  */
 301 int calibrate_done = 0;
 302 volatile int *done_ptr = &calibrate_done;
 303 __initfunc(void prep_calibrate_decr(void))
 304 {
 305         unsigned long flags;
 306
 307         /* the Powerstack II's have trouble with the timer so
 308          * we use a default value -- Cort
 309          */
 310         if ( (_prep_type == _PREP_Motorola) &&
 311              ((inb(0x800) & 0xF0) & 0x40) )
 312         {
 313                 unsigned long freq, divisor;
 314                 static unsigned long t2 = 0;
 315
 316                 t2 = 998700000/60;
 317                 freq = t2 * 60; /* try to make freq/1e6 an integer */
 318                 divisor = 60;
 319                 printk("time_init: decrementer frequency = %lu/%lu (%luMHz)\n",
 320                        freq, divisor,t2>>20);
 321                 decrementer_count = freq / HZ / divisor;
 322                 count_period_num = divisor;
 323                 count_period_den = freq / 1000000;
 324                 return;
 325         }
 326
 327
 328         save_flags(flags);
 329
 330 #define TIMER0_COUNT 0x40
 331 #define TIMER_CONTROL 0x43
 332         /* set timer to periodic mode */
 333         outb_p(0x34,TIMER_CONTROL);/* binary, mode 2, LSB/MSB, ch 0 */
 334         /* set the clock to ~100 Hz */
 335         outb_p(LATCH & 0xff , TIMER0_COUNT);    /* LSB */
 336         outb(LATCH >> 8 , TIMER0_COUNT);        /* MSB */
 337
 338         if (request_irq(0, prep_calibrate_decr_handler, 0, "timer", NULL) != 0)
 339                 panic("Could not allocate timer IRQ!");
 340         __sti();
 341         while ( ! *done_ptr ) /* nothing */; /* wait for calibrate */
 342         restore_flags(flags);
 343         free_irq( 0, NULL);
 344 }
 345
 346 __initfunc(void prep_calibrate_decr_handler(int irq, void *dev, struct pt_regs * regs))
 347 {
 348         unsigned long freq, divisor;
 349         static unsigned long t1 = 0, t2 = 0;
 350
 351         if ( !t1 )
 352                 t1 = get_dec();
 353         else if (!t2)
 354         {
 355                 t2 = get_dec();
 356                 t2 = t1-t2;  /* decr's in 1/HZ */
 357                 t2 = t2*HZ;  /* # decrs in 1s - thus in Hz */
 358                 freq = t2 * 60; /* try to make freq/1e6 an integer */
 359                 divisor = 60;
 360                 printk("time_init: decrementer frequency = %lu/%lu (%luMHz)\n",
 361                        freq, divisor,t2>>20);
 362                 decrementer_count = freq / HZ / divisor;
 363                 count_period_num = divisor;
 364                 count_period_den = freq / 1000000;
 365                 *done_ptr = 1;
 366         }
 367 }
 368
 369 #else /* CONFIG_MBX */
 370
 371 /* The decrementer counts at the system (internal) clock frequency divided by
 372  * sixteen, or external oscillator divided by four.  Currently, we only
 373  * support the MBX, which is system clock divided by sixteen.
 374  */
 375 __initfunc(void mbx_calibrate_decr(void))
 376 {
 377         bd_t    *binfo = (bd_t *)res;
 378         int freq, fp, divisor;
 379
 380         if ((((immap_t *)IMAP_ADDR)->im_clkrst.car_sccr & 0x02000000) == 0)
 381                 printk("WARNING: Wrong decrementer source clock.\n");
 382
 383         /* The manual says the frequency is in Hz, but it is really
 384          * as MHz.  The value 'fp' is the number of decrementer ticks
 385          * per second.
 386          */
 387         fp = (binfo->bi_intfreq * 1000000) / 16;
 388         freq = fp*60;   /* try to make freq/1e6 an integer */
 389         divisor = 60;
 390         printk("time_init: decrementer frequency = %d/%d\n", freq, divisor);
 391         decrementer_count = freq / HZ / divisor;
 392         count_period_num = divisor;
 393         count_period_den = freq / 1000000;
 394 }
 395 #endif /* CONFIG_MBX */
 396
 397 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
 398  * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
 399  * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
 400  *
 401  * [For the Julian calendar (which was used in Russia before 1917,
 402  * Britain & colonies before 1752, anywhere else before 1582,
 403  * and is still in use by some communities) leave out the
 404  * -year/100+year/400 terms, and add 10.]
 405  *
 406  * This algorithm was first published by Gauss (I think).
 407  *
 408  * WARNING: this function will overflow on 2106-02-07 06:28:16 on
 409  * machines were long is 32-bit! (However, as time_t is signed, we
 410  * will already get problems at other places on 2038-01-19 03:14:08)
 411  */
 412 unsigned long mktime(unsigned int year, unsigned int mon,
 413                      unsigned int day, unsigned int hour,
 414                      unsigned int min, unsigned int sec)
 415 {
 416
 417         if (0 >= (int) (mon -= 2)) {    /* 1..12 -> 11,12,1..10 */
 418                 mon += 12;      /* Puts Feb last since it has leap day */
 419                 year -= 1;
 420         }
 421         return (((
 422                 (unsigned long)(year/4 - year/100 + year/400 + 367*mon/12 + day) +
 423                 year*365 - 719499
 424                 )*24 + hour /* now have hours */
 425                 )*60 + min /* now have minutes */
 426                 )*60 + sec; /* finally seconds */
 427 }
 428
 429 #define TICK_SIZE tick
 430 #define FEBRUARY        2
 431 #define STARTOFTIME     1970
 432 #define SECDAY          86400L
 433 #define SECYR           (SECDAY * 365)
 434 #define leapyear(year)          ((year) % 4 == 0)
 435 #define days_in_year(a)         (leapyear(a) ? 366 : 365)
 436 #define days_in_month(a)        (month_days[(a) - 1])
 437
 438 static int month_days[12] = {
 439         31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
 440 };
 441
 442 void to_tm(int tim, struct rtc_time * tm)
 443 {
 444         register int    i;
 445         register long   hms, day;
 446
 447         day = tim / SECDAY;
 448         hms = tim % SECDAY;
 449
 450         /* Hours, minutes, seconds are easy */
 451         tm->tm_hour = hms / 3600;
 452         tm->tm_min = (hms % 3600) / 60;
 453         tm->tm_sec = (hms % 3600) % 60;
 454
 455         /* Number of years in days */
 456         for (i = STARTOFTIME; day >= days_in_year(i); i++)
 457                 day -= days_in_year(i);
 458         tm->tm_year = i;
 459
 460         /* Number of months in days left */
 461         if (leapyear(tm->tm_year))
 462                 days_in_month(FEBRUARY) = 29;
 463         for (i = 1; day >= days_in_month(i); i++)
 464                 day -= days_in_month(i);
 465         days_in_month(FEBRUARY) = 28;
 466         tm->tm_mon = i;
 467
 468         /* Days are what is left over (+1) from all that. */
 469         tm->tm_mday = day + 1;
 470 }
 471
 472
 473