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 #include <asm/clock.h>
  43
  44 #define TMU_TOCR_INIT   0x00
  45 #define TMU0_TCR_INIT   0x0020
  46 #define TMU_TSTR_INIT   1
  47 #define TMU_TSTR_OFF    0
  48
  49 /* Real Time Clock */
  50 #define RTC_BLOCK_OFF   0x01040000
  51 #define RTC_BASE        PHYS_PERIPHERAL_BLOCK + RTC_BLOCK_OFF
  52 #define RTC_RCR1_CIE    0x10    /* Carry Interrupt Enable */
  53 #define RTC_RCR1        (rtc_base + 0x38)
  54
  55 /* Time Management Unit */
  56 #define TMU_BLOCK_OFF   0x01020000
  57 #define TMU_BASE        PHYS_PERIPHERAL_BLOCK + TMU_BLOCK_OFF
  58 #define TMU0_BASE       tmu_base + 0x8 + (0xc * 0x0)
  59 #define TMU1_BASE       tmu_base + 0x8 + (0xc * 0x1)
  60 #define TMU2_BASE       tmu_base + 0x8 + (0xc * 0x2)
  61
  62 #define TMU_TOCR        tmu_base+0x0    /* Byte access */
  63 #define TMU_TSTR        tmu_base+0x4    /* Byte access */
  64
  65 #define TMU0_TCOR       TMU0_BASE+0x0   /* Long access */
  66 #define TMU0_TCNT       TMU0_BASE+0x4   /* Long access */
  67 #define TMU0_TCR        TMU0_BASE+0x8   /* Word access */
  68
  69 #define TICK_SIZE (tick_nsec / 1000)
  70
  71 static unsigned long tmu_base, rtc_base;
  72 unsigned long cprc_base;
  73
  74 /* Variables to allow interpolation of time of day to resolution better than a
  75  * jiffy. */
  76
  77 /* This is effectively protected by xtime_lock */
  78 static unsigned long ctc_last_interrupt;
  79 static unsigned long long usecs_per_jiffy = 1000000/HZ; /* Approximation */
  80
  81 #define CTC_JIFFY_SCALE_SHIFT 40
  82
  83 /* 2**CTC_JIFFY_SCALE_SHIFT / ctc_ticks_per_jiffy */
  84 static unsigned long long scaled_recip_ctc_ticks_per_jiffy;
  85
  86 /* Estimate number of microseconds that have elapsed since the last timer tick,
  87    by scaling the delta that has occurred in the CTC register.
  88
  89    WARNING WARNING WARNING : This algorithm relies on the CTC decrementing at
  90    the CPU clock rate.  If the CPU sleeps, the CTC stops counting.  Bear this
  91    in mind if enabling SLEEP_WORKS in process.c.  In that case, this algorithm
  92    probably needs to use TMU.TCNT0 instead.  This will work even if the CPU is
  93    sleeping, though will be coarser.
  94
  95    FIXME : What if usecs_per_tick is moving around too much, e.g. if an adjtime
  96    is running or if the freq or tick arguments of adjtimex are modified after
  97    we have calibrated the scaling factor?  This will result in either a jump at
  98    the end of a tick period, or a wrap backwards at the start of the next one,
  99    if the application is reading the time of day often enough.  I think we
 100    ought to do better than this.  For this reason, usecs_per_jiffy is left
 101    separated out in the calculation below.  This allows some future hook into
 102    the adjtime-related stuff in kernel/timer.c to remove this hazard.
 103
 104 */
 105
 106 static unsigned long usecs_since_tick(void)
 107 {
 108         unsigned long long current_ctc;
 109         long ctc_ticks_since_interrupt;
 110         unsigned long long ull_ctc_ticks_since_interrupt;
 111         unsigned long result;
 112
 113         unsigned long long mul1_out;
 114         unsigned long long mul1_out_high;
 115         unsigned long long mul2_out_low, mul2_out_high;
 116
 117         /* Read CTC register */
 118         asm ("getcon cr62, %0" : "=r" (current_ctc));
 119         /* Note, the CTC counts down on each CPU clock, not up.
 120            Note(2), use long type to get correct wraparound arithmetic when
 121            the counter crosses zero. */
 122         ctc_ticks_since_interrupt = (long) ctc_last_interrupt - (long) current_ctc;
 123         ull_ctc_ticks_since_interrupt = (unsigned long long) ctc_ticks_since_interrupt;
 124
 125         /* Inline assembly to do 32x32x32->64 multiplier */
 126         asm volatile ("mulu.l %1, %2, %0" :
 127              "=r" (mul1_out) :
 128              "r" (ull_ctc_ticks_since_interrupt), "r" (usecs_per_jiffy));
 129
 130         mul1_out_high = mul1_out >> 32;
 131
 132         asm volatile ("mulu.l %1, %2, %0" :
 133              "=r" (mul2_out_low) :
 134              "r" (mul1_out), "r" (scaled_recip_ctc_ticks_per_jiffy));
 135
 136 #if 1
 137         asm volatile ("mulu.l %1, %2, %0" :
 138              "=r" (mul2_out_high) :
 139              "r" (mul1_out_high), "r" (scaled_recip_ctc_ticks_per_jiffy));
 140 #endif
 141
 142         result = (unsigned long) (((mul2_out_high << 32) + mul2_out_low) >> CTC_JIFFY_SCALE_SHIFT);
 143
 144         return result;
 145 }
 146
 147 u32 arch_gettimeoffset(void)
 148 {
 149         return usecs_since_tick() * 1000;
 150 }
 151
 152 /* Dummy RTC ops */
 153 static void null_rtc_get_time(struct timespec *tv)
 154 {
 155         tv->tv_sec = mktime(2000, 1, 1, 0, 0, 0);
 156         tv->tv_nsec = 0;
 157 }
 158
 159 static int null_rtc_set_time(const time_t secs)
 160 {
 161         return 0;
 162 }
 163
 164 void (*rtc_sh_get_time)(struct timespec *) = null_rtc_get_time;
 165 int (*rtc_sh_set_time)(const time_t) = null_rtc_set_time;
 166
 167 /* last time the RTC clock got updated */
 168 static long last_rtc_update;
 169
 170 /*
 171  * timer_interrupt() needs to keep up the real-time clock,
 172  * as well as call the "do_timer()" routine every clocktick
 173  */
 174 static inline void do_timer_interrupt(void)
 175 {
 176         unsigned long long current_ctc;
 177
 178         if (current->pid)
 179                 profile_tick(CPU_PROFILING);
 180
 181         /*
 182          * Here we are in the timer irq handler. We just have irqs locally
 183          * disabled but we don't know if the timer_bh is running on the other
 184          * CPU. We need to avoid to SMP race with it. NOTE: we don' t need
 185          * the irq version of write_lock because as just said we have irq
 186          * locally disabled. -arca
 187          */
 188         write_seqlock(&xtime_lock);
 189         asm ("getcon cr62, %0" : "=r" (current_ctc));
 190         ctc_last_interrupt = (unsigned long) current_ctc;
 191
 192         do_timer(1);
 193
 194         /*
 195          * If we have an externally synchronized Linux clock, then update
 196          * RTC clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
 197          * called as close as possible to 500 ms before the new second starts.
 198          */
 199         if (ntp_synced() &&
 200             xtime.tv_sec > last_rtc_update + 660 &&
 201             (xtime.tv_nsec / 1000) >= 500000 - ((unsigned) TICK_SIZE) / 2 &&
 202             (xtime.tv_nsec / 1000) <= 500000 + ((unsigned) TICK_SIZE) / 2) {
 203                 if (rtc_sh_set_time(xtime.tv_sec) == 0)
 204                         last_rtc_update = xtime.tv_sec;
 205                 else
 206                         /* do it again in 60 s */
 207                         last_rtc_update = xtime.tv_sec - 600;
 208         }
 209         write_sequnlock(&xtime_lock);
 210
 211 #ifndef CONFIG_SMP
 212         update_process_times(user_mode(get_irq_regs()));
 213 #endif
 214 }
 215
 216 /*
 217  * This is the same as the above, except we _also_ save the current
 218  * Time Stamp Counter value at the time of the timer interrupt, so that
 219  * we later on can estimate the time of day more exactly.
 220  */
 221 static irqreturn_t timer_interrupt(int irq, void *dev_id)
 222 {
 223         unsigned long timer_status;
 224
 225         /* Clear UNF bit */
 226         timer_status = ctrl_inw(TMU0_TCR);
 227         timer_status &= ~0x100;
 228         ctrl_outw(timer_status, TMU0_TCR);
 229
 230         do_timer_interrupt();
 231
 232         return IRQ_HANDLED;
 233 }
 234
 235 static struct irqaction irq0  = {
 236         .handler = timer_interrupt,
 237         .flags = IRQF_DISABLED,
 238         .name = "timer",
 239 };
 240
 241 void __init time_init(void)
 242 {
 243         unsigned long interval;
 244         struct clk *clk;
 245
 246         tmu_base = (unsigned long)ioremap_nocache(TMU_BASE, 1024);
 247         if (!tmu_base) {
 248                 panic("Unable to remap TMU\n");
 249         }
 250
 251         rtc_base = (unsigned long)ioremap_nocache(RTC_BASE, 1024);
 252         if (!rtc_base) {
 253                 panic("Unable to remap RTC\n");
 254         }
 255
 256         clk = clk_get(NULL, "cpu_clk");
 257         scaled_recip_ctc_ticks_per_jiffy = ((1ULL << CTC_JIFFY_SCALE_SHIFT) /
 258                         (unsigned long long)(clk_get_rate(clk) / HZ));
 259
 260         rtc_sh_get_time(&xtime);
 261
 262         setup_irq(TIMER_IRQ, &irq0);
 263
 264         clk = clk_get(NULL, "module_clk");
 265         interval = (clk_get_rate(clk)/(HZ*4));
 266
 267         printk("Interval = %ld\n", interval);
 268
 269         /* Start TMU0 */
 270         ctrl_outb(TMU_TSTR_OFF, TMU_TSTR);
 271         ctrl_outb(TMU_TOCR_INIT, TMU_TOCR);
 272         ctrl_outw(TMU0_TCR_INIT, TMU0_TCR);
 273         ctrl_outl(interval, TMU0_TCOR);
 274         ctrl_outl(interval, TMU0_TCNT);
 275         ctrl_outb(TMU_TSTR_INIT, TMU_TSTR);
 276 }
 277
 278 static struct resource rtc_resources[] = {
 279         [0] = {
 280                 /* RTC base, filled in by rtc_init */
 281                 .flags  = IORESOURCE_IO,
 282         },
 283         [1] = {
 284                 /* Period IRQ */
 285                 .start  = IRQ_PRI,
 286                 .flags  = IORESOURCE_IRQ,
 287         },
 288         [2] = {
 289                 /* Carry IRQ */
 290                 .start  = IRQ_CUI,
 291                 .flags  = IORESOURCE_IRQ,
 292         },
 293         [3] = {
 294                 /* Alarm IRQ */
 295                 .start  = IRQ_ATI,
 296                 .flags  = IORESOURCE_IRQ,
 297         },
 298 };
 299
 300 static struct platform_device rtc_device = {
 301         .name           = "sh-rtc",
 302         .id             = -1,
 303         .num_resources  = ARRAY_SIZE(rtc_resources),
 304         .resource       = rtc_resources,
 305 };
 306
 307 static int __init rtc_init(void)
 308 {
 309         rtc_resources[0].start  = rtc_base;
 310         rtc_resources[0].end    = rtc_resources[0].start + 0x58 - 1;
 311
 312         return platform_device_register(&rtc_device);
 313 }
 314 device_initcall(rtc_init);