fedora core 6 1.2949 + vserver 2.2.0

[linux-2.6.git] / arch / sh / kernel / timers / timer-tmu.c

diff --git a/arch/sh/kernel/timers/timer-tmu.c b/arch/sh/kernel/timers/timer-tmu.c
index 96a64cb..e060e71 100644 (file)
--- a/arch/sh/kernel/timers/timer-tmu.c
+++ b/arch/sh/kernel/timers/timer-tmu.c
@@ -17,7 +17,6 @@
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/interrupt.h>
-#include <linux/spinlock.h>
 #include <linux/seqlock.h>
 #include <asm/timer.h>
 #include <asm/rtc.h>
@@ -31,13 +30,9 @@
 
 #define TMU0_TCR_CALIB 0x0000
 
-static DEFINE_SPINLOCK(tmu0_lock);
-
 static unsigned long tmu_timer_get_offset(void)
 {
        int count;
-       unsigned long flags;
-
        static int count_p = 0x7fffffff;    /* for the first call after boot */
        static unsigned long jiffies_p = 0;
 
@@ -46,7 +41,6 @@ static unsigned long tmu_timer_get_offset(void)
         */
        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 */
 
@@ -72,7 +66,6 @@ static unsigned long tmu_timer_get_offset(void)
                jiffies_p = jiffies_t;
 
        count_p = count;
-       spin_unlock_irqrestore(&tmu0_lock, flags);
 
        count = ((LATCH-1) - count) * TICK_SIZE;
        count = (count + LATCH/2) / LATCH;
@@ -80,8 +73,7 @@ static unsigned long tmu_timer_get_offset(void)
        return count;
 }
 
-static irqreturn_t tmu_timer_interrupt(int irq, void *dev_id,
-                                      struct pt_regs *regs)
+static irqreturn_t tmu_timer_interrupt(int irq, void *dummy)
 {
        unsigned long timer_status;
 
@@ -98,7 +90,7 @@ static irqreturn_t tmu_timer_interrupt(int irq, void *dev_id,
         * locally disabled. -arca
         */
        write_seqlock(&xtime_lock);
-       handle_timer_tick(regs);
+       handle_timer_tick();
        write_sequnlock(&xtime_lock);
 
        return IRQ_HANDLED;
@@ -107,64 +99,10 @@ static irqreturn_t tmu_timer_interrupt(int irq, void *dev_id,
 static struct irqaction tmu_irq = {
        .name           = "timer",
        .handler        = tmu_timer_interrupt,
-       .flags          = SA_INTERRUPT,
+       .flags          = IRQF_DISABLED | IRQF_TIMER,
        .mask           = CPU_MASK_NONE,
 };
 
-/*
- * Hah!  We'll see if this works (switching from usecs to nsecs).
- */
-static unsigned long tmu_timer_get_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) && !defined(CONFIG_CPU_SUBTYPE_SH7760)
-       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;
-}
-
 static void tmu_clk_init(struct clk *clk)
 {
        u8 divisor = TMU0_TCR_INIT & 0x7;
@@ -188,16 +126,28 @@ static struct clk tmu0_clk = {
        .ops            = &tmu_clk_ops,
 };
 
+static int tmu_timer_start(void)
+{
+       ctrl_outb(TMU_TSTR_INIT, TMU_TSTR);
+       return 0;
+}
+
+static int tmu_timer_stop(void)
+{
+       ctrl_outb(0, TMU_TSTR);
+       return 0;
+}
+
 static int tmu_timer_init(void)
 {
        unsigned long interval;
 
-       setup_irq(TIMER_IRQ, &tmu_irq);
+       setup_irq(CONFIG_SH_TIMER_IRQ, &tmu_irq);
 
-       tmu0_clk.parent = clk_get("module_clk");
+       tmu0_clk.parent = clk_get(NULL, "module_clk");
 
        /* Start TMU0 */
-       ctrl_outb(0, TMU_TSTR);
+       tmu_timer_stop();
 #if !defined(CONFIG_CPU_SUBTYPE_SH7300) && !defined(CONFIG_CPU_SUBTYPE_SH7760)
        ctrl_outb(TMU_TOCR_INIT, TMU_TOCR);
 #endif
@@ -211,19 +161,21 @@ static int tmu_timer_init(void)
        ctrl_outl(interval, TMU0_TCOR);
        ctrl_outl(interval, TMU0_TCNT);
 
-       ctrl_outb(TMU_TSTR_INIT, TMU_TSTR);
+       tmu_timer_start();
 
        return 0;
 }
 
 struct sys_timer_ops tmu_timer_ops = {
        .init           = tmu_timer_init,
-       .get_frequency  = tmu_timer_get_frequency,
+       .start          = tmu_timer_start,
+       .stop           = tmu_timer_stop,
+#ifndef CONFIG_GENERIC_TIME
        .get_offset     = tmu_timer_get_offset,
+#endif
 };
 
 struct sys_timer tmu_timer = {
        .name   = "tmu",
        .ops    = &tmu_timer_ops,
 };
-