arch/sh64/kernel/time.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * arch/sh64/kernel/time.c
   7  *
   8  * Copyright (C) 2000, 2001  Paolo Alberelli
   9  * Copyright (C) 2003, 2004  Paul Mundt
  10  * Copyright (C) 2003  Richard Curnow
  11  *
  12  *    Original TMU/RTC code taken from sh version.
  13  *    Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
  14  *      Some code taken from i386 version.
  15  *      Copyright (C) 1991, 1992, 1995  Linus Torvalds
  16  */
  17
  18 #include <linux/errno.h>
  19 #include <linux/rwsem.h>
  20 #include <linux/sched.h>
  21 #include <linux/kernel.h>
  22 #include <linux/param.h>
  23 #include <linux/string.h>
  24 #include <linux/mm.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/time.h>
  27 #include <linux/delay.h>
  28 #include <linux/init.h>
  29 #include <linux/profile.h>
  30 #include <linux/smp.h>
  31 #include <linux/module.h>
  32 #include <linux/bcd.h>
  33
  34 #include <asm/registers.h>       /* required by inline __asm__ stmt. */
  35
  36 #include <asm/processor.h>
  37 #include <asm/uaccess.h>
  38 #include <asm/io.h>
  39 #include <asm/irq.h>
  40 #include <asm/delay.h>
  41
  42 #include <linux/timex.h>
  43 #include <linux/irq.h>
  44 #include <asm/hardware.h>
  45
  46 #define TMU_TOCR_INIT   0x00
  47 #define TMU0_TCR_INIT   0x0020
  48 #define TMU_TSTR_INIT   1
  49 #define TMU_TSTR_OFF    0
  50
  51 /* RCR1 Bits */
  52 #define RCR1_CF         0x80    /* Carry Flag             */
  53 #define RCR1_CIE        0x10    /* Carry Interrupt Enable */
  54 #define RCR1_AIE        0x08    /* Alarm Interrupt Enable */
  55 #define RCR1_AF         0x01    /* Alarm Flag             */
  56
  57 /* RCR2 Bits */
  58 #define RCR2_PEF        0x80    /* PEriodic interrupt Flag */
  59 #define RCR2_PESMASK    0x70    /* Periodic interrupt Set  */
  60 #define RCR2_RTCEN      0x08    /* ENable RTC              */
  61 #define RCR2_ADJ        0x04    /* ADJustment (30-second)  */
  62 #define RCR2_RESET      0x02    /* Reset bit               */
  63 #define RCR2_START      0x01    /* Start bit               */
  64
  65 /* Clock, Power and Reset Controller */
  66 #define CPRC_BLOCK_OFF  0x01010000
  67 #define CPRC_BASE       PHYS_PERIPHERAL_BLOCK + CPRC_BLOCK_OFF
  68
  69 #define FRQCR           (cprc_base+0x0)
  70 #define WTCSR           (cprc_base+0x0018)
  71 #define STBCR           (cprc_base+0x0030)
  72
  73 /* Time Management Unit */
  74 #define TMU_BLOCK_OFF   0x01020000
  75 #define TMU_BASE        PHYS_PERIPHERAL_BLOCK + TMU_BLOCK_OFF
  76 #define TMU0_BASE       tmu_base + 0x8 + (0xc * 0x0)
  77 #define TMU1_BASE       tmu_base + 0x8 + (0xc * 0x1)
  78 #define TMU2_BASE       tmu_base + 0x8 + (0xc * 0x2)
  79
  80 #define TMU_TOCR        tmu_base+0x0    /* Byte access */
  81 #define TMU_TSTR        tmu_base+0x4    /* Byte access */
  82
  83 #define TMU0_TCOR       TMU0_BASE+0x0   /* Long access */
  84 #define TMU0_TCNT       TMU0_BASE+0x4   /* Long access */
  85 #define TMU0_TCR        TMU0_BASE+0x8   /* Word access */
  86
  87 /* Real Time Clock */
  88 #define RTC_BLOCK_OFF   0x01040000
  89 #define RTC_BASE        PHYS_PERIPHERAL_BLOCK + RTC_BLOCK_OFF
  90
  91 #define R64CNT          rtc_base+0x00
  92 #define RSECCNT         rtc_base+0x04
  93 #define RMINCNT         rtc_base+0x08
  94 #define RHRCNT          rtc_base+0x0c
  95 #define RWKCNT          rtc_base+0x10
  96 #define RDAYCNT         rtc_base+0x14
  97 #define RMONCNT         rtc_base+0x18
  98 #define RYRCNT          rtc_base+0x1c   /* 16bit */
  99 #define RSECAR          rtc_base+0x20
 100 #define RMINAR          rtc_base+0x24
 101 #define RHRAR           rtc_base+0x28
 102 #define RWKAR           rtc_base+0x2c
 103 #define RDAYAR          rtc_base+0x30
 104 #define RMONAR          rtc_base+0x34
 105 #define RCR1            rtc_base+0x38
 106 #define RCR2            rtc_base+0x3c
 107
 108 #define TICK_SIZE (tick_nsec / 1000)
 109
 110 extern unsigned long wall_jiffies;
 111
 112 static unsigned long tmu_base, rtc_base;
 113 unsigned long cprc_base;
 114
 115 /* Variables to allow interpolation of time of day to resolution better than a
 116  * jiffy. */
 117
 118 /* This is effectively protected by xtime_lock */
 119 static unsigned long ctc_last_interrupt;
 120 static unsigned long long usecs_per_jiffy = 1000000/HZ; /* Approximation */
 121
 122 #define CTC_JIFFY_SCALE_SHIFT 40
 123
 124 /* 2**CTC_JIFFY_SCALE_SHIFT / ctc_ticks_per_jiffy */
 125 static unsigned long long scaled_recip_ctc_ticks_per_jiffy;
 126
 127 /* Estimate number of microseconds that have elapsed since the last timer tick,
 128    by scaling the delta that has occured in the CTC register.
 129
 130    WARNING WARNING WARNING : This algorithm relies on the CTC decrementing at
 131    the CPU clock rate.  If the CPU sleeps, the CTC stops counting.  Bear this
 132    in mind if enabling SLEEP_WORKS in process.c.  In that case, this algorithm
 133    probably needs to use TMU.TCNT0 instead.  This will work even if the CPU is
 134    sleeping, though will be coarser.
 135
 136    FIXME : What if usecs_per_tick is moving around too much, e.g. if an adjtime
 137    is running or if the freq or tick arguments of adjtimex are modified after
 138    we have calibrated the scaling factor?  This will result in either a jump at
 139    the end of a tick period, or a wrap backwards at the start of the next one,
 140    if the application is reading the time of day often enough.  I think we
 141    ought to do better than this.  For this reason, usecs_per_jiffy is left
 142    separated out in the calculation below.  This allows some future hook into
 143    the adjtime-related stuff in kernel/timer.c to remove this hazard.
 144
 145 */
 146
 147 static unsigned long usecs_since_tick(void)
 148 {
 149         unsigned long long current_ctc;
 150         long ctc_ticks_since_interrupt;
 151         unsigned long long ull_ctc_ticks_since_interrupt;
 152         unsigned long result;
 153
 154         unsigned long long mul1_out;
 155         unsigned long long mul1_out_high;
 156         unsigned long long mul2_out_low, mul2_out_high;
 157
 158         /* Read CTC register */
 159         asm ("getcon cr62, %0" : "=r" (current_ctc));
 160         /* Note, the CTC counts down on each CPU clock, not up.
 161            Note(2), use long type to get correct wraparound arithmetic when
 162            the counter crosses zero. */
 163         ctc_ticks_since_interrupt = (long) ctc_last_interrupt - (long) current_ctc;
 164         ull_ctc_ticks_since_interrupt = (unsigned long long) ctc_ticks_since_interrupt;
 165
 166         /* Inline assembly to do 32x32x32->64 multiplier */
 167         asm volatile ("mulu.l %1, %2, %0" :
 168              "=r" (mul1_out) :
 169              "r" (ull_ctc_ticks_since_interrupt), "r" (usecs_per_jiffy));
 170
 171         mul1_out_high = mul1_out >> 32;
 172
 173         asm volatile ("mulu.l %1, %2, %0" :
 174              "=r" (mul2_out_low) :
 175              "r" (mul1_out), "r" (scaled_recip_ctc_ticks_per_jiffy));
 176
 177 #if 1
 178         asm volatile ("mulu.l %1, %2, %0" :
 179              "=r" (mul2_out_high) :
 180              "r" (mul1_out_high), "r" (scaled_recip_ctc_ticks_per_jiffy));
 181 #endif
 182
 183         result = (unsigned long) (((mul2_out_high << 32) + mul2_out_low) >> CTC_JIFFY_SCALE_SHIFT);
 184
 185         return result;
 186 }
 187
 188 void do_gettimeofday(struct timeval *tv)
 189 {
 190         unsigned long flags;
 191         unsigned long seq;
 192         unsigned long usec, sec;
 193
 194         do {
 195                 seq = read_seqbegin_irqsave(&xtime_lock, flags);
 196                 usec = usecs_since_tick();
 197                 {
 198                         unsigned long lost = jiffies - wall_jiffies;
 199
 200                         if (lost)
 201                                 usec += lost * (1000000 / HZ);
 202                 }
 203
 204                 sec = xtime.tv_sec;
 205                 usec += xtime.tv_nsec / 1000;
 206         } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
 207
 208         while (usec >= 1000000) {
 209                 usec -= 1000000;
 210                 sec++;
 211         }
 212
 213         tv->tv_sec = sec;
 214         tv->tv_usec = usec;
 215 }
 216
 217 int do_settimeofday(struct timespec *tv)
 218 {
 219         time_t wtm_sec, sec = tv->tv_sec;
 220         long wtm_nsec, nsec = tv->tv_nsec;
 221
 222         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
 223                 return -EINVAL;
 224
 225         write_seqlock_irq(&xtime_lock);
 226         /*
 227          * This is revolting. We need to set "xtime" correctly. However, the
 228          * value in this location is the value at the most recent update of
 229          * wall time.  Discover what correction gettimeofday() would have
 230          * made, and then undo it!
 231          */
 232         nsec -= 1000 * (usecs_since_tick() +
 233                                 (jiffies - wall_jiffies) * (1000000 / HZ));
 234
 235         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
 236         wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
 237
 238         set_normalized_timespec(&xtime, sec, nsec);
 239         set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
 240
 241         ntp_clear();
 242         write_sequnlock_irq(&xtime_lock);
 243         clock_was_set();
 244
 245         return 0;
 246 }
 247 EXPORT_SYMBOL(do_settimeofday);
 248
 249 static int set_rtc_time(unsigned long nowtime)
 250 {
 251         int retval = 0;
 252         int real_seconds, real_minutes, cmos_minutes;
 253
 254         ctrl_outb(RCR2_RESET, RCR2);  /* Reset pre-scaler & stop RTC */
 255
 256         cmos_minutes = ctrl_inb(RMINCNT);
 257         BCD_TO_BIN(cmos_minutes);
 258
 259         /*
 260          * since we're only adjusting minutes and seconds,
 261          * don't interfere with hour overflow. This avoids
 262          * messing with unknown time zones but requires your
 263          * RTC not to be off by more than 15 minutes
 264          */
 265         real_seconds = nowtime % 60;
 266         real_minutes = nowtime / 60;
 267         if (((abs(real_minutes - cmos_minutes) + 15)/30) & 1)
 268                 real_minutes += 30;     /* correct for half hour time zone */
 269         real_minutes %= 60;
 270
 271         if (abs(real_minutes - cmos_minutes) < 30) {
 272                 BIN_TO_BCD(real_seconds);
 273                 BIN_TO_BCD(real_minutes);
 274                 ctrl_outb(real_seconds, RSECCNT);
 275                 ctrl_outb(real_minutes, RMINCNT);
 276         } else {
 277                 printk(KERN_WARNING
 278                        "set_rtc_time: can't update from %d to %d\n",
 279                        cmos_minutes, real_minutes);
 280                 retval = -1;
 281         }
 282
 283         ctrl_outb(RCR2_RTCEN|RCR2_START, RCR2);  /* Start RTC */
 284
 285         return retval;
 286 }
 287
 288 /* last time the RTC clock got updated */
 289 static long last_rtc_update = 0;
 290
 291 /*
 292  * timer_interrupt() needs to keep up the real-time clock,
 293  * as well as call the "do_timer()" routine every clocktick
 294  */
 295 static inline void do_timer_interrupt(int irq, struct pt_regs *regs)
 296 {
 297         unsigned long long current_ctc;
 298         asm ("getcon cr62, %0" : "=r" (current_ctc));
 299         ctc_last_interrupt = (unsigned long) current_ctc;
 300
 301         do_timer(regs);
 302 #ifndef CONFIG_SMP
 303         update_process_times(user_mode(regs));
 304 #endif
 305         profile_tick(CPU_PROFILING, regs);
 306
 307 #ifdef CONFIG_HEARTBEAT
 308         {
 309                 extern void heartbeat(void);
 310
 311                 heartbeat();
 312         }
 313 #endif
 314
 315         /*
 316          * If we have an externally synchronized Linux clock, then update
 317          * RTC clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
 318          * called as close as possible to 500 ms before the new second starts.
 319          */
 320         if (ntp_synced() &&
 321             xtime.tv_sec > last_rtc_update + 660 &&
 322             (xtime.tv_nsec / 1000) >= 500000 - ((unsigned) TICK_SIZE) / 2 &&
 323             (xtime.tv_nsec / 1000) <= 500000 + ((unsigned) TICK_SIZE) / 2) {
 324                 if (set_rtc_time(xtime.tv_sec) == 0)
 325                         last_rtc_update = xtime.tv_sec;
 326                 else
 327                         last_rtc_update = xtime.tv_sec - 600; /* do it again in 60 s */
 328         }
 329 }
 330
 331 /*
 332  * This is the same as the above, except we _also_ save the current
 333  * Time Stamp Counter value at the time of the timer interrupt, so that
 334  * we later on can estimate the time of day more exactly.
 335  */
 336 static irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 337 {
 338         unsigned long timer_status;
 339
 340         /* Clear UNF bit */
 341         timer_status = ctrl_inw(TMU0_TCR);
 342         timer_status &= ~0x100;
 343         ctrl_outw(timer_status, TMU0_TCR);
 344
 345         /*
 346          * Here we are in the timer irq handler. We just have irqs locally
 347          * disabled but we don't know if the timer_bh is running on the other
 348          * CPU. We need to avoid to SMP race with it. NOTE: we don' t need
 349          * the irq version of write_lock because as just said we have irq
 350          * locally disabled. -arca
 351          */
 352         write_lock(&xtime_lock);
 353         do_timer_interrupt(irq, regs);
 354         write_unlock(&xtime_lock);
 355
 356         return IRQ_HANDLED;
 357 }
 358
 359 static unsigned long get_rtc_time(void)
 360 {
 361         unsigned int sec, min, hr, wk, day, mon, yr, yr100;
 362
 363  again:
 364         do {
 365                 ctrl_outb(0, RCR1);  /* Clear CF-bit */
 366                 sec = ctrl_inb(RSECCNT);
 367                 min = ctrl_inb(RMINCNT);
 368                 hr  = ctrl_inb(RHRCNT);
 369                 wk  = ctrl_inb(RWKCNT);
 370                 day = ctrl_inb(RDAYCNT);
 371                 mon = ctrl_inb(RMONCNT);
 372                 yr  = ctrl_inw(RYRCNT);
 373                 yr100 = (yr >> 8);
 374                 yr &= 0xff;
 375         } while ((ctrl_inb(RCR1) & RCR1_CF) != 0);
 376
 377         BCD_TO_BIN(yr100);
 378         BCD_TO_BIN(yr);
 379         BCD_TO_BIN(mon);
 380         BCD_TO_BIN(day);
 381         BCD_TO_BIN(hr);
 382         BCD_TO_BIN(min);
 383         BCD_TO_BIN(sec);
 384
 385         if (yr > 99 || mon < 1 || mon > 12 || day > 31 || day < 1 ||
 386             hr > 23 || min > 59 || sec > 59) {
 387                 printk(KERN_ERR
 388                        "SH RTC: invalid value, resetting to 1 Jan 2000\n");
 389                 ctrl_outb(RCR2_RESET, RCR2);  /* Reset & Stop */
 390                 ctrl_outb(0, RSECCNT);
 391                 ctrl_outb(0, RMINCNT);
 392                 ctrl_outb(0, RHRCNT);
 393                 ctrl_outb(6, RWKCNT);
 394                 ctrl_outb(1, RDAYCNT);
 395                 ctrl_outb(1, RMONCNT);
 396                 ctrl_outw(0x2000, RYRCNT);
 397                 ctrl_outb(RCR2_RTCEN|RCR2_START, RCR2);  /* Start */
 398                 goto again;
 399         }
 400
 401         return mktime(yr100 * 100 + yr, mon, day, hr, min, sec);
 402 }
 403
 404 static __init unsigned int get_cpu_hz(void)
 405 {
 406         unsigned int count;
 407         unsigned long __dummy;
 408         unsigned long ctc_val_init, ctc_val;
 409
 410         /*
 411         ** Regardless the toolchain, force the compiler to use the
 412         ** arbitrary register r3 as a clock tick counter.
 413         ** NOTE: r3 must be in accordance with sh64_rtc_interrupt()
 414         */
 415         register unsigned long long  __rtc_irq_flag __asm__ ("r3");
 416
 417         local_irq_enable();
 418         do {} while (ctrl_inb(R64CNT) != 0);
 419         ctrl_outb(RCR1_CIE, RCR1); /* Enable carry interrupt */
 420
 421         /*
 422          * r3 is arbitrary. CDC does not support "=z".
 423          */
 424         ctc_val_init = 0xffffffff;
 425         ctc_val = ctc_val_init;
 426
 427         asm volatile("gettr     tr0, %1\n\t"
 428                      "putcon    %0, " __CTC "\n\t"
 429                      "and       %2, r63, %2\n\t"
 430                      "pta       $+4, tr0\n\t"
 431                      "beq/l     %2, r63, tr0\n\t"
 432                      "ptabs     %1, tr0\n\t"
 433                      "getcon    " __CTC ", %0\n\t"
 434                 : "=r"(ctc_val), "=r" (__dummy), "=r" (__rtc_irq_flag)
 435                 : "0" (0));
 436         local_irq_disable();
 437         /*
 438          * SH-3:
 439          * CPU clock = 4 stages * loop
 440          * tst    rm,rm      if id ex
 441          * bt/s   1b            if id ex
 442          * add    #1,rd            if id ex
 443          *                            (if) pipe line stole
 444          * tst    rm,rm                  if id ex
 445          * ....
 446          *
 447          *
 448          * SH-4:
 449          * CPU clock = 6 stages * loop
 450          * I don't know why.
 451          * ....
 452          *
 453          * SH-5:
 454          * Use CTC register to count.  This approach returns the right value
 455          * even if the I-cache is disabled (e.g. whilst debugging.)
 456          *
 457          */
 458
 459         count = ctc_val_init - ctc_val; /* CTC counts down */
 460
 461 #if defined (CONFIG_SH_SIMULATOR)
 462         /*
 463          * Let's pretend we are a 5MHz SH-5 to avoid a too
 464          * little timer interval. Also to keep delay
 465          * calibration within a reasonable time.
 466          */
 467         return 5000000;
 468 #else
 469         /*
 470          * This really is count by the number of clock cycles
 471          * by the ratio between a complete R64CNT
 472          * wrap-around (128) and CUI interrupt being raised (64).
 473          */
 474         return count*2;
 475 #endif
 476 }
 477
 478 static irqreturn_t sh64_rtc_interrupt(int irq, void *dev_id,
 479                                       struct pt_regs *regs)
 480 {
 481         ctrl_outb(0, RCR1);     /* Disable Carry Interrupts */
 482         regs->regs[3] = 1;      /* Using r3 */
 483
 484         return IRQ_HANDLED;
 485 }
 486
 487 static struct irqaction irq0  = { timer_interrupt, SA_INTERRUPT, CPU_MASK_NONE, "timer", NULL, NULL};
 488 static struct irqaction irq1  = { sh64_rtc_interrupt, SA_INTERRUPT, CPU_MASK_NONE, "rtc", NULL, NULL};
 489
 490 void __init time_init(void)
 491 {
 492         unsigned int cpu_clock, master_clock, bus_clock, module_clock;
 493         unsigned long interval;
 494         unsigned long frqcr, ifc, pfc;
 495         static int ifc_table[] = { 2, 4, 6, 8, 10, 12, 16, 24 };
 496 #define bfc_table ifc_table     /* Same */
 497 #define pfc_table ifc_table     /* Same */
 498
 499         tmu_base = onchip_remap(TMU_BASE, 1024, "TMU");
 500         if (!tmu_base) {
 501                 panic("Unable to remap TMU\n");
 502         }
 503
 504         rtc_base = onchip_remap(RTC_BASE, 1024, "RTC");
 505         if (!rtc_base) {
 506                 panic("Unable to remap RTC\n");
 507         }
 508
 509         cprc_base = onchip_remap(CPRC_BASE, 1024, "CPRC");
 510         if (!cprc_base) {
 511                 panic("Unable to remap CPRC\n");
 512         }
 513
 514         xtime.tv_sec = get_rtc_time();
 515         xtime.tv_nsec = 0;
 516
 517         setup_irq(TIMER_IRQ, &irq0);
 518         setup_irq(RTC_IRQ, &irq1);
 519
 520         /* Check how fast it is.. */
 521         cpu_clock = get_cpu_hz();
 522
 523         /* Note careful order of operations to maintain reasonable precision and avoid overflow. */
 524         scaled_recip_ctc_ticks_per_jiffy = ((1ULL << CTC_JIFFY_SCALE_SHIFT) / (unsigned long long)(cpu_clock / HZ));
 525
 526         disable_irq(RTC_IRQ);
 527
 528         printk("CPU clock: %d.%02dMHz\n",
 529                (cpu_clock / 1000000), (cpu_clock % 1000000)/10000);
 530         {
 531                 unsigned short bfc;
 532                 frqcr = ctrl_inl(FRQCR);
 533                 ifc  = ifc_table[(frqcr>> 6) & 0x0007];
 534                 bfc  = bfc_table[(frqcr>> 3) & 0x0007];
 535                 pfc  = pfc_table[(frqcr>> 12) & 0x0007];
 536                 master_clock = cpu_clock * ifc;
 537                 bus_clock = master_clock/bfc;
 538         }
 539
 540         printk("Bus clock: %d.%02dMHz\n",
 541                (bus_clock/1000000), (bus_clock % 1000000)/10000);
 542         module_clock = master_clock/pfc;
 543         printk("Module clock: %d.%02dMHz\n",
 544                (module_clock/1000000), (module_clock % 1000000)/10000);
 545         interval = (module_clock/(HZ*4));
 546
 547         printk("Interval = %ld\n", interval);
 548
 549         current_cpu_data.cpu_clock    = cpu_clock;
 550         current_cpu_data.master_clock = master_clock;
 551         current_cpu_data.bus_clock    = bus_clock;
 552         current_cpu_data.module_clock = module_clock;
 553
 554         /* Start TMU0 */
 555         ctrl_outb(TMU_TSTR_OFF, TMU_TSTR);
 556         ctrl_outb(TMU_TOCR_INIT, TMU_TOCR);
 557         ctrl_outw(TMU0_TCR_INIT, TMU0_TCR);
 558         ctrl_outl(interval, TMU0_TCOR);
 559         ctrl_outl(interval, TMU0_TCNT);
 560         ctrl_outb(TMU_TSTR_INIT, TMU_TSTR);
 561 }
 562
 563 void enter_deep_standby(void)
 564 {
 565         /* Disable watchdog timer */
 566         ctrl_outl(0xa5000000, WTCSR);
 567         /* Configure deep standby on sleep */
 568         ctrl_outl(0x03, STBCR);
 569
 570 #ifdef CONFIG_SH_ALPHANUMERIC
 571         {
 572                 extern void mach_alphanum(int position, unsigned char value);
 573                 extern void mach_alphanum_brightness(int setting);
 574                 char halted[] = "Halted. ";
 575                 int i;
 576                 mach_alphanum_brightness(6); /* dimmest setting above off */
 577                 for (i=0; i<8; i++) {
 578                         mach_alphanum(i, halted[i]);
 579                 }
 580                 asm __volatile__ ("synco");
 581         }
 582 #endif
 583
 584         asm __volatile__ ("sleep");
 585         asm __volatile__ ("synci");
 586         asm __volatile__ ("nop");
 587         asm __volatile__ ("nop");
 588         asm __volatile__ ("nop");
 589         asm __volatile__ ("nop");
 590         panic("Unexpected wakeup!\n");
 591 }
 592
 593 /*
 594  * Scheduler clock - returns current time in nanosec units.
 595  */
 596 unsigned long long sched_clock(void)
 597 {
 598         return (unsigned long long)jiffies * (1000000000 / HZ);
 599 }
 600