1 files changed, 1 insertions, 210 deletions

diff --git a/kernel/timer.c b/kernel/timer.c
index 4f55622b0d3..5fccc7cbf3b 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -41,12 +41,6 @@
 #include <asm/timex.h>
 #include <asm/io.h>
 
-#ifdef CONFIG_TIME_INTERPOLATION
-static void time_interpolator_update(long delta_nsec);
-#else
-#define time_interpolator_update(x)
-#endif
-
 u64 jiffies_64 __cacheline_aligned_in_smp = INITIAL_JIFFIES;
 
 EXPORT_SYMBOL(jiffies_64);
@@ -587,209 +581,6 @@ struct timespec wall_to_monotonic __attribute__ ((aligned (16)));
 
 EXPORT_SYMBOL(xtime);
 
-/* Don't completely fail for HZ > 500.  */
-int tickadj = 500/HZ ? : 1;             /* microsecs */
-
-
-/*
- * phase-lock loop variables
- */
-/* TIME_ERROR prevents overwriting the CMOS clock */
-int time_state = TIME_OK;               /* clock synchronization status */
-int time_status = STA_UNSYNC;           /* clock status bits            */
-long time_offset;                       /* time adjustment (us)         */
-long time_constant = 2;                 /* pll time constant            */
-long time_tolerance = MAXFREQ;          /* frequency tolerance (ppm)    */
-long time_precision = 1;                /* clock precision (us)         */
-long time_maxerror = NTP_PHASE_LIMIT;   /* maximum error (us)           */
-long time_esterror = NTP_PHASE_LIMIT;   /* estimated error (us)         */
-long time_freq = (((NSEC_PER_SEC + HZ/2) % HZ - HZ/2) << SHIFT_USEC) / NSEC_PER_USEC;
-                                        /* frequency offset (scaled ppm)*/
-static long time_adj;                   /* tick adjust (scaled 1 / HZ)  */
-long time_reftime;                      /* time at last adjustment (s)  */
-long time_adjust;
-long time_next_adjust;
-
-/*
- * this routine handles the overflow of the microsecond field
- *
- * The tricky bits of code to handle the accurate clock support
- * were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame.
- * They were originally developed for SUN and DEC kernels.
- * All the kudos should go to Dave for this stuff.
- *
- */
-static void second_overflow(void)
-{
-        long ltemp;
-
-        /* Bump the maxerror field */
-        time_maxerror += time_tolerance >> SHIFT_USEC;
-        if (time_maxerror > NTP_PHASE_LIMIT) {
-                time_maxerror = NTP_PHASE_LIMIT;
-                time_status |= STA_UNSYNC;
-        }
-
-        /*
-         * Leap second processing. If in leap-insert state at the end of the
-         * day, the system clock is set back one second; if in leap-delete
-         * state, the system clock is set ahead one second. The microtime()
-         * routine or external clock driver will insure that reported time is
-         * always monotonic. The ugly divides should be replaced.
-         */
-        switch (time_state) {
-        case TIME_OK:
-                if (time_status & STA_INS)
-                        time_state = TIME_INS;
-                else if (time_status & STA_DEL)
-                        time_state = TIME_DEL;
-                break;
-        case TIME_INS:
-                if (xtime.tv_sec % 86400 == 0) {
-                        xtime.tv_sec--;
-                        wall_to_monotonic.tv_sec++;
-                        /*
-                         * The timer interpolator will make time change
-                         * gradually instead of an immediate jump by one second
-                         */
-                        time_interpolator_update(-NSEC_PER_SEC);
-                        time_state = TIME_OOP;
-                        clock_was_set();
-                        printk(KERN_NOTICE "Clock: inserting leap second "
-                                        "23:59:60 UTC\n");
-                }
-                break;
-        case TIME_DEL:
-                if ((xtime.tv_sec + 1) % 86400 == 0) {
-                        xtime.tv_sec++;
-                        wall_to_monotonic.tv_sec--;
-                        /*
-                         * Use of time interpolator for a gradual change of
-                         * time
-                         */
-                        time_interpolator_update(NSEC_PER_SEC);
-                        time_state = TIME_WAIT;
-                        clock_was_set();
-                        printk(KERN_NOTICE "Clock: deleting leap second "
-                                        "23:59:59 UTC\n");
-                }
-                break;
-        case TIME_OOP:
-                time_state = TIME_WAIT;
-                break;
-        case TIME_WAIT:
-                if (!(time_status & (STA_INS | STA_DEL)))
-                time_state = TIME_OK;
-        }
-
-        /*
-         * Compute the phase adjustment for the next second. In PLL mode, the
-         * offset is reduced by a fixed factor times the time constant. In FLL
-         * mode the offset is used directly. In either mode, the maximum phase
-         * adjustment for each second is clamped so as to spread the adjustment
-         * over not more than the number of seconds between updates.
-         */
-        ltemp = time_offset;
-        if (!(time_status & STA_FLL))
-                ltemp = shift_right(ltemp, SHIFT_KG + time_constant);
-        ltemp = min(ltemp, (MAXPHASE / MINSEC) << SHIFT_UPDATE);
-        ltemp = max(ltemp, -(MAXPHASE / MINSEC) << SHIFT_UPDATE);
-        time_offset -= ltemp;
-        time_adj = ltemp << (SHIFT_SCALE - SHIFT_HZ - SHIFT_UPDATE);
-
-        /*
-         * Compute the frequency estimate and additional phase adjustment due
-         * to frequency error for the next second.
-         */
-        ltemp = time_freq;
-        time_adj += shift_right(ltemp,(SHIFT_USEC + SHIFT_HZ - SHIFT_SCALE));
-
-#if HZ == 100
-        /*
-         * Compensate for (HZ==100) != (1 << SHIFT_HZ).  Add 25% and 3.125% to
-         * get 128.125; => only 0.125% error (p. 14)
-         */
-        time_adj += shift_right(time_adj, 2) + shift_right(time_adj, 5);
-#endif
-#if HZ == 250
-        /*
-         * Compensate for (HZ==250) != (1 << SHIFT_HZ).  Add 1.5625% and
-         * 0.78125% to get 255.85938; => only 0.05% error (p. 14)
-         */
-        time_adj += shift_right(time_adj, 6) + shift_right(time_adj, 7);
-#endif
-#if HZ == 1000
-        /*
-         * Compensate for (HZ==1000) != (1 << SHIFT_HZ).  Add 1.5625% and
-         * 0.78125% to get 1023.4375; => only 0.05% error (p. 14)
-         */
-        time_adj += shift_right(time_adj, 6) + shift_right(time_adj, 7);
-#endif
-}
-
-/*
- * Returns how many microseconds we need to add to xtime this tick
- * in doing an adjustment requested with adjtime.
- */
-static long adjtime_adjustment(void)
-{
-        long time_adjust_step;
-
-        time_adjust_step = time_adjust;
-        if (time_adjust_step) {
-                /*
-                 * We are doing an adjtime thing.  Prepare time_adjust_step to
-                 * be within bounds.  Note that a positive time_adjust means we
-                 * want the clock to run faster.
-                 *
-                 * Limit the amount of the step to be in the range
-                 * -tickadj .. +tickadj
-                 */
-                time_adjust_step = min(time_adjust_step, (long)tickadj);
-                time_adjust_step = max(time_adjust_step, (long)-tickadj);
-        }
-        return time_adjust_step;
-}
-
-/* in the NTP reference this is called "hardclock()" */
-static void update_ntp_one_tick(void)
-{
-        long time_adjust_step;
-
-        time_adjust_step = adjtime_adjustment();
-        if (time_adjust_step)
-                /* Reduce by this step the amount of time left  */
-                time_adjust -= time_adjust_step;
-
-        /* Changes by adjtime() do not take effect till next tick. */
-        if (time_next_adjust != 0) {
-                time_adjust = time_next_adjust;
-                time_next_adjust = 0;
-        }
-}
-
-/*
- * Return how long ticks are at the moment, that is, how much time
- * update_wall_time_one_tick will add to xtime next time we call it
- * (assuming no calls to do_adjtimex in the meantime).
- * The return value is in fixed-point nanoseconds shifted by the
- * specified number of bits to the right of the binary point.
- * This function has no side-effects.
- */
-u64 current_tick_length(void)
-{
-        long delta_nsec;
-        u64 ret;
-
-        /* calculate the finest interval NTP will allow.
-         *    ie: nanosecond value shifted by (SHIFT_SCALE - 10)
-         */
-        delta_nsec = tick_nsec + adjtime_adjustment() * 1000;
-        ret = (u64)delta_nsec << TICK_LENGTH_SHIFT;
-        ret += (s64)time_adj << (TICK_LENGTH_SHIFT - (SHIFT_SCALE - 10));
-
-        return ret;
-}
 
 /* XXX - all of this timekeeping code should be later moved to time.c */
 #include <linux/clocksource.h>
@@ -1775,7 +1566,7 @@ unsigned long time_interpolator_get_offset(void)
 #define INTERPOLATOR_ADJUST 65536
 #define INTERPOLATOR_MAX_SKIP 10*INTERPOLATOR_ADJUST
 
-static void time_interpolator_update(long delta_nsec)
+void time_interpolator_update(long delta_nsec)
 {
         u64 counter;
         unsigned long offset;