1 files changed, 3 insertions, 133 deletions

diff --git a/arch/powerpc/kernel/time.c b/arch/powerpc/kernel/time.c
index 5adebaf47f13..ccb8759c8532 100644
--- a/arch/powerpc/kernel/time.c
+++ b/arch/powerpc/kernel/time.c
@@ -149,16 +149,6 @@ unsigned long tb_ticks_per_usec = 100; /* sane default */
 EXPORT_SYMBOL(tb_ticks_per_usec);
 unsigned long tb_ticks_per_sec;
 EXPORT_SYMBOL(tb_ticks_per_sec);        /* for cputime_t conversions */
-u64 tb_to_xs;
-unsigned tb_to_us;
-
-#define TICKLEN_SCALE   NTP_SCALE_SHIFT
-static u64 last_tick_len;       /* units are ns / 2^TICKLEN_SCALE */
-static u64 ticklen_to_xs;       /* 0.64 fraction */
-
-/* If last_tick_len corresponds to about 1/HZ seconds, then
-   last_tick_len << TICKLEN_SHIFT will be about 2^63. */
-#define TICKLEN_SHIFT   (63 - 30 - TICKLEN_SCALE + SHIFT_HZ)
 
 DEFINE_SPINLOCK(rtc_lock);
 EXPORT_SYMBOL_GPL(rtc_lock);
@@ -174,7 +164,6 @@ unsigned long ppc_proc_freq;
 EXPORT_SYMBOL(ppc_proc_freq);
 unsigned long ppc_tb_freq;
 
-static u64 tb_last_jiffy __cacheline_aligned_in_smp;
 static DEFINE_PER_CPU(u64, last_jiffy);
 
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING
@@ -446,7 +435,6 @@ EXPORT_SYMBOL(profile_pc);
 
 static int __init iSeries_tb_recal(void)
 {
-        struct div_result divres;
         unsigned long titan, tb;
 
         /* Make sure we only run on iSeries */
@@ -477,10 +465,7 @@ static int __init iSeries_tb_recal(void)
                                 tb_ticks_per_jiffy = new_tb_ticks_per_jiffy;
                                 tb_ticks_per_sec   = new_tb_ticks_per_sec;
                                 calc_cputime_factors();
-                                div128_by_32( XSEC_PER_SEC, 0, tb_ticks_per_sec, &divres );
-                                tb_to_xs = divres.result_low;
                                 vdso_data->tb_ticks_per_sec = tb_ticks_per_sec;
-                                vdso_data->tb_to_xs = tb_to_xs;
                                 setup_cputime_one_jiffy();
                         }
                         else {
@@ -643,27 +628,9 @@ void timer_interrupt(struct pt_regs * regs)
         trace_timer_interrupt_exit(regs);
 }
 
-void wakeup_decrementer(void)
-{
-        unsigned long ticks;
-
-        /*
-         * The timebase gets saved on sleep and restored on wakeup,
-         * so all we need to do is to reset the decrementer.
-         */
-        ticks = tb_ticks_since(__get_cpu_var(last_jiffy));
-        if (ticks < tb_ticks_per_jiffy)
-                ticks = tb_ticks_per_jiffy - ticks;
-        else
-                ticks = 1;
-        set_dec(ticks);
-}
-
 #ifdef CONFIG_SUSPEND
-void generic_suspend_disable_irqs(void)
+static void generic_suspend_disable_irqs(void)
 {
-        preempt_disable();
-
         /* Disable the decrementer, so that it doesn't interfere
          * with suspending.
          */
@@ -673,12 +640,9 @@ void generic_suspend_disable_irqs(void)
         set_dec(0x7fffffff);
 }
 
-void generic_suspend_enable_irqs(void)
+static void generic_suspend_enable_irqs(void)
 {
-        wakeup_decrementer();
-
         local_irq_enable();
-        preempt_enable();
 }
 
 /* Overrides the weak version in kernel/power/main.c */
@@ -698,23 +662,6 @@ void arch_suspend_enable_irqs(void)
 }
 #endif
 
-#ifdef CONFIG_SMP
-void __init smp_space_timers(unsigned int max_cpus)
-{
-        int i;
-        u64 previous_tb = per_cpu(last_jiffy, boot_cpuid);
-
-        /* make sure tb > per_cpu(last_jiffy, cpu) for all cpus always */
-        previous_tb -= tb_ticks_per_jiffy;
-
-        for_each_possible_cpu(i) {
-                if (i == boot_cpuid)
-                        continue;
-                per_cpu(last_jiffy, i) = previous_tb;
-        }
-}
-#endif
-
 /*
  * Scheduler clock - returns current time in nanosec units.
  *
@@ -1014,15 +961,13 @@ void secondary_cpu_time_init(void)
 /* This function is only called on the boot processor */
 void __init time_init(void)
 {
-        unsigned long flags;
         struct div_result res;
-        u64 scale, x;
+        u64 scale;
         unsigned shift;
 
         if (__USE_RTC()) {
                 /* 601 processor: dec counts down by 128 every 128ns */
                 ppc_tb_freq = 1000000000;
-                tb_last_jiffy = get_rtcl();
         } else {
                 /* Normal PowerPC with timebase register */
                 ppc_md.calibrate_decr();
@@ -1030,50 +975,15 @@ void __init time_init(void)
                        ppc_tb_freq / 1000000, ppc_tb_freq % 1000000);
                 printk(KERN_DEBUG "time_init: processor frequency   = %lu.%.6lu MHz\n",
                        ppc_proc_freq / 1000000, ppc_proc_freq % 1000000);
-                tb_last_jiffy = get_tb();
         }
 
         tb_ticks_per_jiffy = ppc_tb_freq / HZ;
         tb_ticks_per_sec = ppc_tb_freq;
         tb_ticks_per_usec = ppc_tb_freq / 1000000;
-        tb_to_us = mulhwu_scale_factor(ppc_tb_freq, 1000000);
         calc_cputime_factors();
         setup_cputime_one_jiffy();
 
         /*
-         * Calculate the length of each tick in ns.  It will not be
-         * exactly 1e9/HZ unless ppc_tb_freq is divisible by HZ.
-         * We compute 1e9 * tb_ticks_per_jiffy / ppc_tb_freq,
-         * rounded up.
-         */
-        x = (u64) NSEC_PER_SEC * tb_ticks_per_jiffy + ppc_tb_freq - 1;
-        do_div(x, ppc_tb_freq);
-        tick_nsec = x;
-        last_tick_len = x << TICKLEN_SCALE;
-
-        /*
-         * Compute ticklen_to_xs, which is a factor which gets multiplied
-         * by (last_tick_len << TICKLEN_SHIFT) to get a tb_to_xs value.
-         * It is computed as:
-         * ticklen_to_xs = 2^N / (tb_ticks_per_jiffy * 1e9)
-         * where N = 64 + 20 - TICKLEN_SCALE - TICKLEN_SHIFT
-         * which turns out to be N = 51 - SHIFT_HZ.
-         * This gives the result as a 0.64 fixed-point fraction.
-         * That value is reduced by an offset amounting to 1 xsec per
-         * 2^31 timebase ticks to avoid problems with time going backwards
-         * by 1 xsec when we do timer_recalc_offset due to losing the
-         * fractional xsec.  That offset is equal to ppc_tb_freq/2^51
-         * since there are 2^20 xsec in a second.
-         */
-        div128_by_32((1ULL << 51) - ppc_tb_freq, 0,
-                     tb_ticks_per_jiffy << SHIFT_HZ, &res);
-        div128_by_32(res.result_high, res.result_low, NSEC_PER_SEC, &res);
-        ticklen_to_xs = res.result_low;
-
-        /* Compute tb_to_xs from tick_nsec */
-        tb_to_xs = mulhdu(last_tick_len << TICKLEN_SHIFT, ticklen_to_xs);
-
-        /*
          * Compute scale factor for sched_clock.
          * The calibrate_decr() function has set tb_ticks_per_sec,
          * which is the timebase frequency.
@@ -1094,21 +1004,14 @@ void __init time_init(void)
         /* Save the current timebase to pretty up CONFIG_PRINTK_TIME */
         boot_tb = get_tb_or_rtc();
 
-        write_seqlock_irqsave(&xtime_lock, flags);
-
         /* If platform provided a timezone (pmac), we correct the time */
         if (timezone_offset) {
                 sys_tz.tz_minuteswest = -timezone_offset / 60;
                 sys_tz.tz_dsttime = 0;
         }
 
-        vdso_data->tb_orig_stamp = tb_last_jiffy;
         vdso_data->tb_update_count = 0;
         vdso_data->tb_ticks_per_sec = tb_ticks_per_sec;
-        vdso_data->stamp_xsec = (u64) xtime.tv_sec * XSEC_PER_SEC;
-        vdso_data->tb_to_xs = tb_to_xs;
-
-        write_sequnlock_irqrestore(&xtime_lock, flags);
 
         /* Start the decrementer on CPUs that have manual control
          * such as BookE
@@ -1202,39 +1105,6 @@ void to_tm(int tim, struct rtc_time * tm)
         GregorianDay(tm);
 }
 
-/* Auxiliary function to compute scaling factors */
-/* Actually the choice of a timebase running at 1/4 the of the bus
- * frequency giving resolution of a few tens of nanoseconds is quite nice.
- * It makes this computation very precise (27-28 bits typically) which
- * is optimistic considering the stability of most processor clock
- * oscillators and the precision with which the timebase frequency
- * is measured but does not harm.
- */
-unsigned mulhwu_scale_factor(unsigned inscale, unsigned outscale)
-{
-        unsigned mlt=0, tmp, err;
-        /* No concern for performance, it's done once: use a stupid
-         * but safe and compact method to find the multiplier.
-         */
-  
-        for (tmp = 1U<<31; tmp != 0; tmp >>= 1) {
-                if (mulhwu(inscale, mlt|tmp) < outscale)
-                        mlt |= tmp;
-        }
-  
-        /* We might still be off by 1 for the best approximation.
-         * A side effect of this is that if outscale is too large
-         * the returned value will be zero.
-         * Many corner cases have been checked and seem to work,
-         * some might have been forgotten in the test however.
-         */
-  
-        err = inscale * (mlt+1);
-        if (err <= inscale/2)
-                mlt++;
-        return mlt;
-}
-
 /*
  * Divide a 128-bit dividend by a 32-bit divisor, leaving a 128 bit
  * result.