[PATCH] NTP: Move all the NTP related code to ntp.c
[linux-2.6.git] / kernel / timer.c
index 4f55622b0d38462ad59b28322d31ebeee8a0c40c..5fccc7cbf3b4b750c689b95ef54a5e4b6d4cfcb0 100644 (file)
 #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;