[PATCH] sh: Simplistic clock framework

This adds a relatively simplistic clock framework for sh.  The initial goal
behind this is to clean up the arch/sh/kernel/time.c mess and to get the CPU
subtype-specific frequency setting and calculation code moved somewhere more
sensible.

This only deals with the core clocks at the moment, though it's trivial for
other drivers to define their own clocks as desired.

Signed-off-by: Paul Mundt <lethal@linux-sh.org>
Cc: john stultz <johnstul@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

1 files changed, 32 insertions, 486 deletions

diff --git a/arch/sh/kernel/time.c b/arch/sh/kernel/time.c
index 671b876416bf..314a275c04e0 100644
--- a/arch/sh/kernel/time.c
+++ b/arch/sh/kernel/time.c
@@ -3,7 +3,7 @@
  *
  *  Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
  *  Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
- *  Copyright (C) 2002, 2003, 2004  Paul Mundt
+ *  Copyright (C) 2002, 2003, 2004, 2005  Paul Mundt
  *  Copyright (C) 2002  M. R. Brown  <mrbrown@linux-sh.org>
  *
  *  Some code taken from i386 version.
@@ -11,50 +11,21 @@
  */
 
 #include <linux/config.h>
-#include <linux/errno.h>
-#include <linux/module.h>
-#include <linux/sched.h>
 #include <linux/kernel.h>
-#include <linux/param.h>
-#include <linux/string.h>
-#include <linux/mm.h>
-#include <linux/interrupt.h>
-#include <linux/time.h>
-#include <linux/delay.h>
+#include <linux/module.h>
 #include <linux/init.h>
-#include <linux/smp.h>
 #include <linux/profile.h>
-
-#include <asm/processor.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/delay.h>
-#include <asm/machvec.h>
+#include <asm/clock.h>
 #include <asm/rtc.h>
-#include <asm/freq.h>
-#include <asm/cpu/timer.h>
-#ifdef CONFIG_SH_KGDB
+#include <asm/timer.h>
 #include <asm/kgdb.h>
-#endif
-
-#include <linux/timex.h>
-#include <linux/irq.h>
-
-#define TMU_TOCR_INIT   0x00
-#define TMU0_TCR_INIT   0x0020
-#define TMU_TSTR_INIT   1
-
-#define TMU0_TCR_CALIB  0x0000
-
-#ifdef CONFIG_CPU_SUBTYPE_ST40STB1
-#define CLOCKGEN_MEMCLKCR 0xbb040038
-#define MEMCLKCR_RATIO_MASK 0x7
-#endif /* CONFIG_CPU_SUBTYPE_ST40STB1 */
 
 extern unsigned long wall_jiffies;
-#define TICK_SIZE (tick_nsec / 1000)
-DEFINE_SPINLOCK(tmu0_lock);
+struct sys_timer *sys_timer;
+
+/* Move this somewhere more sensible.. */
+DEFINE_SPINLOCK(rtc_lock);
+EXPORT_SYMBOL(rtc_lock);
 
 /* XXX: Can we initialize this in a routine somewhere?  Dreamcast doesn't want
  * these routines anywhere... */
@@ -66,98 +37,14 @@ void (*rtc_get_time)(struct timespec *);
 int (*rtc_set_time)(const time_t);
 #endif
 
-#if defined(CONFIG_CPU_SUBTYPE_SH7300)
-static int md_table[] = { 1, 2, 3, 4, 6, 8, 12 };
-#endif
-#if defined(CONFIG_CPU_SH3)
-static int stc_multipliers[] = { 1, 2, 3, 4, 6, 1, 1, 1 };
-static int stc_values[]      = { 0, 1, 4, 2, 5, 0, 0, 0 };
-#define bfc_divisors stc_multipliers
-#define bfc_values stc_values
-static int ifc_divisors[]    = { 1, 2, 3, 4, 1, 1, 1, 1 };
-static int ifc_values[]      = { 0, 1, 4, 2, 0, 0, 0, 0 };
-static int pfc_divisors[]    = { 1, 2, 3, 4, 6, 1, 1, 1 };
-static int pfc_values[]      = { 0, 1, 4, 2, 5, 0, 0, 0 };
-#elif defined(CONFIG_CPU_SH4)
-#if defined(CONFIG_CPU_SUBTYPE_SH73180)
-static int ifc_divisors[] = { 1, 2, 3, 4, 6, 8, 12, 16 };
-static int ifc_values[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
-#define bfc_divisors ifc_divisors       /* Same */
-#define bfc_values ifc_values
-#define pfc_divisors ifc_divisors       /* Same */
-#define pfc_values ifc_values
-#else
-static int ifc_divisors[] = { 1, 2, 3, 4, 6, 8, 1, 1 };
-static int ifc_values[]   = { 0, 1, 2, 3, 0, 4, 0, 5 };
-#define bfc_divisors ifc_divisors       /* Same */
-#define bfc_values ifc_values
-static int pfc_divisors[] = { 2, 3, 4, 6, 8, 2, 2, 2 };
-static int pfc_values[]   = { 0, 0, 1, 2, 0, 3, 0, 4 };
-#endif
-#else
-#error "Unknown ifc/bfc/pfc/stc values for this processor"
-#endif
-
 /*
  * Scheduler clock - returns current time in nanosec units.
  */
-unsigned long long sched_clock(void)
+unsigned long long __attribute__ ((weak)) sched_clock(void)
 {
         return (unsigned long long)jiffies * (1000000000 / HZ);
 }
 
-static unsigned long do_gettimeoffset(void)
-{
-        int count;
-        unsigned long flags;
-
-        static int count_p = 0x7fffffff;    /* for the first call after boot */
-        static unsigned long jiffies_p = 0;
-
-        /*
-         * cache volatile jiffies temporarily; we have IRQs turned off.
-         */
-        unsigned long jiffies_t;
-
-        spin_lock_irqsave(&tmu0_lock, flags);
-        /* timer count may underflow right here */
-        count = ctrl_inl(TMU0_TCNT);    /* read the latched count */
-
-        jiffies_t = jiffies;
-
-        /*
-         * avoiding timer inconsistencies (they are rare, but they happen)...
-         * there is one kind of problem that must be avoided here:
-         *  1. the timer counter underflows
-         */
-
-        if( jiffies_t == jiffies_p ) {
-                if( count > count_p ) {
-                        /* the nutcase */
-
-                        if(ctrl_inw(TMU0_TCR) & 0x100) { /* Check UNF bit */
-                                /*
-                                 * We cannot detect lost timer interrupts ...
-                                 * well, that's why we call them lost, don't we? :)
-                                 * [hmm, on the Pentium and Alpha we can ... sort of]
-                                 */
-                                count -= LATCH;
-                        } else {
-                                printk("do_slow_gettimeoffset(): hardware timer problem?\n");
-                        }
-                }
-        } else
-                jiffies_p = jiffies_t;
-
-        count_p = count;
-        spin_unlock_irqrestore(&tmu0_lock, flags);
-
-        count = ((LATCH-1) - count) * TICK_SIZE;
-        count = (count + LATCH/2) / LATCH;
-
-        return count;
-}
-
 void do_gettimeofday(struct timeval *tv)
 {
         unsigned long seq;
@@ -166,7 +53,7 @@ void do_gettimeofday(struct timeval *tv)
 
         do {
                 seq = read_seqbegin(&xtime_lock);
-                usec = do_gettimeoffset();
+                usec = get_timer_offset();
 
                 lost = jiffies - wall_jiffies;
                 if (lost)
@@ -202,7 +89,7 @@ int do_settimeofday(struct timespec *tv)
          * wall time.  Discover what correction gettimeofday() would have
          * made, and then undo it!
          */
-        nsec -= 1000 * (do_gettimeoffset() +
+        nsec -= 1000 * (get_timer_offset() +
                                 (jiffies - wall_jiffies) * (1000000 / HZ));
 
         wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
@@ -224,10 +111,10 @@ EXPORT_SYMBOL(do_settimeofday);
 static long last_rtc_update;
 
 /*
- * timer_interrupt() needs to keep up the real-time clock,
+ * handle_timer_tick() needs to keep up the real-time clock,
  * as well as call the "do_timer()" routine every clocktick
  */
-static inline void do_timer_interrupt(int irq, struct pt_regs *regs)
+void handle_timer_tick(struct pt_regs *regs)
 {
         do_timer(regs);
 #ifndef CONFIG_SMP
@@ -252,337 +139,35 @@ static inline void do_timer_interrupt(int irq, struct pt_regs *regs)
                 if (rtc_set_time(xtime.tv_sec) == 0)
                         last_rtc_update = xtime.tv_sec;
                 else
-                        last_rtc_update = xtime.tv_sec - 600; /* do it again in 60 s */
+                        /* do it again in 60s */
+                        last_rtc_update = xtime.tv_sec - 600;
         }
 }
 
-/*
- * This is the same as the above, except we _also_ save the current
- * Time Stamp Counter value at the time of the timer interrupt, so that
- * we later on can estimate the time of day more exactly.
- */
-static irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        unsigned long timer_status;
-
-        /* Clear UNF bit */
-        timer_status = ctrl_inw(TMU0_TCR);
-        timer_status &= ~0x100;
-        ctrl_outw(timer_status, TMU0_TCR);
-
-        /*
-         * Here we are in the timer irq handler. We just have irqs locally
-         * disabled but we don't know if the timer_bh is running on the other
-         * CPU. We need to avoid to SMP race with it. NOTE: we don' t need
-         * the irq version of write_lock because as just said we have irq
-         * locally disabled. -arca
-         */
-        write_seqlock(&xtime_lock);
-        do_timer_interrupt(irq, regs);
-        write_sequnlock(&xtime_lock);
-
-        return IRQ_HANDLED;
-}
-
-/*
- * Hah!  We'll see if this works (switching from usecs to nsecs).
- */
-static unsigned int __init get_timer_frequency(void)
-{
-        u32 freq;
-        struct timespec ts1, ts2;
-        unsigned long diff_nsec;
-        unsigned long factor;
-
-        /* Setup the timer:  We don't want to generate interrupts, just
-         * have it count down at its natural rate.
-         */
-        ctrl_outb(0, TMU_TSTR);
-#if !defined(CONFIG_CPU_SUBTYPE_SH7300)
-        ctrl_outb(TMU_TOCR_INIT, TMU_TOCR);
-#endif
-        ctrl_outw(TMU0_TCR_CALIB, TMU0_TCR);
-        ctrl_outl(0xffffffff, TMU0_TCOR);
-        ctrl_outl(0xffffffff, TMU0_TCNT);
-
-        rtc_get_time(&ts2);
-
-        do {
-                rtc_get_time(&ts1);
-        } while (ts1.tv_nsec == ts2.tv_nsec && ts1.tv_sec == ts2.tv_sec);
-
-        /* actually start the timer */
-        ctrl_outb(TMU_TSTR_INIT, TMU_TSTR);
-
-        do {
-                rtc_get_time(&ts2);
-        } while (ts1.tv_nsec == ts2.tv_nsec && ts1.tv_sec == ts2.tv_sec);
-
-        freq = 0xffffffff - ctrl_inl(TMU0_TCNT);
-        if (ts2.tv_nsec < ts1.tv_nsec) {
-                ts2.tv_nsec += 1000000000;
-                ts2.tv_sec--;
-        }
-
-        diff_nsec = (ts2.tv_sec - ts1.tv_sec) * 1000000000 + (ts2.tv_nsec - ts1.tv_nsec);
-
-        /* this should work well if the RTC has a precision of n Hz, where
-         * n is an integer.  I don't think we have to worry about the other
-         * cases. */
-        factor = (1000000000 + diff_nsec/2) / diff_nsec;
-
-        if (factor * diff_nsec > 1100000000 ||
-            factor * diff_nsec <  900000000)
-                panic("weird RTC (diff_nsec %ld)", diff_nsec);
-
-        return freq * factor;
-}
-
-void (*board_time_init)(void);
-void (*board_timer_setup)(struct irqaction *irq);
-
-static unsigned int sh_pclk_freq __initdata = CONFIG_SH_PCLK_FREQ;
-
-static int __init sh_pclk_setup(char *str)
-{
-        unsigned int freq;
-
-        if (get_option(&str, &freq))
-                sh_pclk_freq = freq;
-
-        return 1;
-}
-__setup("sh_pclk=", sh_pclk_setup);
-
-static struct irqaction irq0  = { timer_interrupt, SA_INTERRUPT, CPU_MASK_NONE, "timer", NULL, NULL};
-
-void get_current_frequency_divisors(unsigned int *ifc, unsigned int *bfc, unsigned int *pfc)
-{
-        unsigned int frqcr = ctrl_inw(FRQCR);
-
-#if defined(CONFIG_CPU_SH3)
-#if defined(CONFIG_CPU_SUBTYPE_SH7300)
-        *ifc = md_table[((frqcr & 0x0070) >> 4)];
-        *bfc = md_table[((frqcr & 0x0700) >> 8)];
-        *pfc = md_table[frqcr & 0x0007];
-#elif defined(CONFIG_CPU_SUBTYPE_SH7705)
-        *bfc = stc_multipliers[(frqcr & 0x0300) >> 8];
-        *ifc = ifc_divisors[(frqcr & 0x0030) >> 4];
-        *pfc = pfc_divisors[frqcr & 0x0003];
-#else
-        unsigned int tmp;
-
-        tmp  = (frqcr & 0x8000) >> 13;
-        tmp |= (frqcr & 0x0030) >>  4;
-        *bfc = stc_multipliers[tmp];
-        tmp  = (frqcr & 0x4000)  >> 12;
-        tmp |= (frqcr & 0x000c) >> 2;
-        *ifc = ifc_divisors[tmp];
-        tmp  = (frqcr & 0x2000) >> 11;
-        tmp |= frqcr & 0x0003;
-        *pfc = pfc_divisors[tmp];
-#endif
-#elif defined(CONFIG_CPU_SH4)
-#if defined(CONFIG_CPU_SUBTYPE_SH73180)
-        *ifc = ifc_divisors[(frqcr>> 20) & 0x0007];
-        *bfc = bfc_divisors[(frqcr>> 12) & 0x0007];
-        *pfc = pfc_divisors[frqcr & 0x0007];
-#else
-        *ifc = ifc_divisors[(frqcr >> 6) & 0x0007];
-        *bfc = bfc_divisors[(frqcr >> 3) & 0x0007];
-        *pfc = pfc_divisors[frqcr & 0x0007];
-#endif
-#endif
-}
-
-/*
- * This bit of ugliness builds up accessor routines to get at both
- * the divisors and the physical values.
- */
-#define _FREQ_TABLE(x) \
-        unsigned int get_##x##_divisor(unsigned int value)      \
-                { return x##_divisors[value]; }                 \
-                                                                \
-        unsigned int get_##x##_value(unsigned int divisor)      \
-                { return x##_values[(divisor - 1)]; }
-
-_FREQ_TABLE(ifc);
-_FREQ_TABLE(bfc);
-_FREQ_TABLE(pfc);
-
-#ifdef CONFIG_CPU_SUBTYPE_ST40STB1
-
-/*
- * The ST40 divisors are totally different so we set the cpu data
- * clocks using a different algorithm
- *
- * I've just plugged this from the 2.4 code
- *      - Alex Bennee <kernel-hacker@bennee.com>
- */
-#define CCN_PVR_CHIP_SHIFT 24
-#define CCN_PVR_CHIP_MASK  0xff
-#define CCN_PVR_CHIP_ST40STB1 0x4
-
-
-struct frqcr_data {
-        unsigned short frqcr;
-
-        struct {
-                unsigned char multiplier;
-                unsigned char divisor;
-        } factor[3];
-};
-
-static struct frqcr_data st40_frqcr_table[] = {
-        { 0x000, {{1,1}, {1,1}, {1,2}}},
-        { 0x002, {{1,1}, {1,1}, {1,4}}},
-        { 0x004, {{1,1}, {1,1}, {1,8}}},
-        { 0x008, {{1,1}, {1,2}, {1,2}}},
-        { 0x00A, {{1,1}, {1,2}, {1,4}}},
-        { 0x00C, {{1,1}, {1,2}, {1,8}}},
-        { 0x011, {{1,1}, {2,3}, {1,6}}},
-        { 0x013, {{1,1}, {2,3}, {1,3}}},
-        { 0x01A, {{1,1}, {1,2}, {1,4}}},
-        { 0x01C, {{1,1}, {1,2}, {1,8}}},
-        { 0x023, {{1,1}, {2,3}, {1,3}}},
-        { 0x02C, {{1,1}, {1,2}, {1,8}}},
-        { 0x048, {{1,2}, {1,2}, {1,4}}},
-        { 0x04A, {{1,2}, {1,2}, {1,6}}},
-        { 0x04C, {{1,2}, {1,2}, {1,8}}},
-        { 0x05A, {{1,2}, {1,3}, {1,6}}},
-        { 0x05C, {{1,2}, {1,3}, {1,6}}},
-        { 0x063, {{1,2}, {1,4}, {1,4}}},
-        { 0x06C, {{1,2}, {1,4}, {1,8}}},
-        { 0x091, {{1,3}, {1,3}, {1,6}}},
-        { 0x093, {{1,3}, {1,3}, {1,6}}},
-        { 0x0A3, {{1,3}, {1,6}, {1,6}}},
-        { 0x0DA, {{1,4}, {1,4}, {1,8}}},
-        { 0x0DC, {{1,4}, {1,4}, {1,8}}},
-        { 0x0EC, {{1,4}, {1,8}, {1,8}}},
-        { 0x123, {{1,4}, {1,4}, {1,8}}},
-        { 0x16C, {{1,4}, {1,8}, {1,8}}},
+static struct sysdev_class timer_sysclass = {
+        set_kset_name("timer"),
 };
 
-struct memclk_data {
-        unsigned char multiplier;
-        unsigned char divisor;
-};
-
-static struct memclk_data st40_memclk_table[8] = {
-        {1,1},  // 000
-        {1,2},  // 001
-        {1,3},  // 010
-        {2,3},  // 011
-        {1,4},  // 100
-        {1,6},  // 101
-        {1,8},  // 110
-        {1,8}   // 111
-};
-
-static void st40_specific_time_init(unsigned int module_clock, unsigned short frqcr)
+static int __init timer_init_sysfs(void)
 {
-        unsigned int cpu_clock, master_clock, bus_clock, memory_clock;
-        struct frqcr_data *d;
-        int a;
-        unsigned long memclkcr;
-        struct memclk_data *e;
+        int ret = sysdev_class_register(&timer_sysclass);
+        if (ret != 0)
+                return ret;
 
-        for (a = 0; a < ARRAY_SIZE(st40_frqcr_table); a++) {
-                d = &st40_frqcr_table[a];
-
-                if (d->frqcr == (frqcr & 0x1ff))
-                        break;
-        }
+        sys_timer->dev.cls = &timer_sysclass;
+        return sysdev_register(&sys_timer->dev);
+}
 
-        if (a == ARRAY_SIZE(st40_frqcr_table)) {
-                d = st40_frqcr_table;
+device_initcall(timer_init_sysfs);
 
-                printk("ERROR: Unrecognised FRQCR value (0x%x), "
-                       "using default multipliers\n", frqcr);
-        }
-
-        memclkcr = ctrl_inl(CLOCKGEN_MEMCLKCR);
-        e = &st40_memclk_table[memclkcr & MEMCLKCR_RATIO_MASK];
-
-        printk(KERN_INFO "Clock multipliers: CPU: %d/%d Bus: %d/%d "
-               "Mem: %d/%d Periph: %d/%d\n",
-               d->factor[0].multiplier, d->factor[0].divisor,
-               d->factor[1].multiplier, d->factor[1].divisor,
-               e->multiplier,           e->divisor,
-               d->factor[2].multiplier, d->factor[2].divisor);
-
-        master_clock = module_clock * d->factor[2].divisor
-                                    / d->factor[2].multiplier;
-        bus_clock    = master_clock * d->factor[1].multiplier
-                                    / d->factor[1].divisor;
-        memory_clock = master_clock * e->multiplier
-                                    / e->divisor;
-        cpu_clock    = master_clock * d->factor[0].multiplier
-                                    / d->factor[0].divisor;
-
-        current_cpu_data.cpu_clock    = cpu_clock;
-        current_cpu_data.master_clock = master_clock;
-        current_cpu_data.bus_clock    = bus_clock;
-        current_cpu_data.memory_clock = memory_clock;
-        current_cpu_data.module_clock = module_clock;
-}
-#endif
+void (*board_time_init)(void);
 
 void __init time_init(void)
 {
-        unsigned int timer_freq = 0;
-        unsigned int ifc, pfc, bfc;
-        unsigned long interval;
-#ifdef CONFIG_CPU_SUBTYPE_ST40STB1
-        unsigned long pvr;
-        unsigned short frqcr;
-#endif
-
         if (board_time_init)
                 board_time_init();
 
-        /*
-         * If we don't have an RTC (such as with the SH7300), don't attempt to
-         * probe the timer frequency. Rely on an either hardcoded peripheral
-         * clock value, or on the sh_pclk command line option. Note that we
-         * still need to have CONFIG_SH_PCLK_FREQ set in order for things like
-         * CLOCK_TICK_RATE to be sane.
-         */
-        current_cpu_data.module_clock = sh_pclk_freq;
-
-#ifdef CONFIG_SH_PCLK_CALC
-        /* XXX: Switch this over to a more generic test. */
-        {
-                unsigned int freq;
-
-                /*
-                 * If we've specified a peripheral clock frequency, and we have
-                 * an RTC, compare it against the autodetected value. Complain
-                 * if there's a mismatch.
-                 */
-                timer_freq = get_timer_frequency();
-                freq = timer_freq * 4;
-
-                if (sh_pclk_freq && (sh_pclk_freq/100*99 > freq || sh_pclk_freq/100*101 < freq)) {
-                        printk(KERN_NOTICE "Calculated peripheral clock value "
-                               "%d differs from sh_pclk value %d, fixing..\n",
-                               freq, sh_pclk_freq);
-                        current_cpu_data.module_clock = freq;
-                }
-        }
-#endif
-
-#ifdef CONFIG_CPU_SUBTYPE_ST40STB1
-        /* XXX: Update ST40 code to use board_time_init() */
-        pvr = ctrl_inl(CCN_PVR);
-        frqcr = ctrl_inw(FRQCR);
-        printk("time.c ST40 Probe: PVR %08lx, FRQCR %04hx\n", pvr, frqcr);
-
-        if (((pvr >> CCN_PVR_CHIP_SHIFT) & CCN_PVR_CHIP_MASK) == CCN_PVR_CHIP_ST40STB1)
-                st40_specific_time_init(current_cpu_data.module_clock, frqcr);
-        else
-#endif
-                get_current_frequency_divisors(&ifc, &bfc, &pfc);
+        clk_init();
 
         if (rtc_get_time) {
                 rtc_get_time(&xtime);
@@ -594,51 +179,12 @@ void __init time_init(void)
         set_normalized_timespec(&wall_to_monotonic,
                                 -xtime.tv_sec, -xtime.tv_nsec);
 
-        if (board_timer_setup) {
-                board_timer_setup(&irq0);
-        } else {
-                setup_irq(TIMER_IRQ, &irq0);
-        }
-
         /*
-         * for ST40 chips the current_cpu_data should already be set
-         * so not having valid pfc/bfc/ifc shouldn't be a problem
+         * Find the timer to use as the system timer, it will be
+         * initialized for us.
          */
-        if (!current_cpu_data.master_clock)
-                current_cpu_data.master_clock = current_cpu_data.module_clock * pfc;
-        if (!current_cpu_data.bus_clock)
-                current_cpu_data.bus_clock = current_cpu_data.master_clock / bfc;
-        if (!current_cpu_data.cpu_clock)
-                current_cpu_data.cpu_clock = current_cpu_data.master_clock / ifc;
-
-        printk("CPU clock: %d.%02dMHz\n",
-               (current_cpu_data.cpu_clock / 1000000),
-               (current_cpu_data.cpu_clock % 1000000)/10000);
-        printk("Bus clock: %d.%02dMHz\n",
-               (current_cpu_data.bus_clock / 1000000),
-               (current_cpu_data.bus_clock % 1000000)/10000);
-#ifdef CONFIG_CPU_SUBTYPE_ST40STB1
-        printk("Memory clock: %d.%02dMHz\n",
-               (current_cpu_data.memory_clock / 1000000),
-               (current_cpu_data.memory_clock % 1000000)/10000);
-#endif
-        printk("Module clock: %d.%02dMHz\n",
-               (current_cpu_data.module_clock / 1000000),
-               (current_cpu_data.module_clock % 1000000)/10000);
-
-        interval = (current_cpu_data.module_clock/4 + HZ/2) / HZ;
-
-        printk("Interval = %ld\n", interval);
-
-        /* Start TMU0 */
-        ctrl_outb(0, TMU_TSTR);
-#if !defined(CONFIG_CPU_SUBTYPE_SH7300)
-        ctrl_outb(TMU_TOCR_INIT, TMU_TOCR);
-#endif
-        ctrl_outw(TMU0_TCR_INIT, TMU0_TCR);
-        ctrl_outl(interval, TMU0_TCOR);
-        ctrl_outl(interval, TMU0_TCNT);
-        ctrl_outb(TMU_TSTR_INIT, TMU_TSTR);
+        sys_timer = get_sys_timer();
+        printk(KERN_INFO "Using %s for system timer\n", sys_timer->name);
 
 #if defined(CONFIG_SH_KGDB)
         /*