arch/sh/kernel/time_64.c

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