[PATCH] ntp: add ntp_update_frequency

This introduces ntp_update_frequency() and deinlines ntp_clear() (as it's not
performance critical).  ntp_update_frequency() calculates the base tick length
using tick_usec and adds a base adjustment, in case the frequency doesn't
divide evenly by HZ.

Signed-off-by: Roman Zippel <zippel@linux-m68k.org>
Cc: john stultz <johnstul@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/include/linux/timex.h b/include/linux/timex.h
index 2a21485bf18331f62af57fdac1a9969b0ad4935d..b589c8218bb9c84b17c71de3c61d663cda6e8c44 100644 (file)
--- a/include/linux/timex.h
+++ b/include/linux/timex.h
@@ -219,18 +219,8 @@ extern long time_reftime;  /* time at last adjustment (s) */
 extern long time_adjust;       /* The amount of adjtime left */
 extern long time_next_adjust;  /* Value for time_adjust at next tick */
 
-/**
- * ntp_clear - Clears the NTP state variables
- *
- * Must be called while holding a write on the xtime_lock
- */
-static inline void ntp_clear(void)
-{
-       time_adjust = 0;                /* stop active adjtime() */
-       time_status |= STA_UNSYNC;
-       time_maxerror = NTP_PHASE_LIMIT;
-       time_esterror = NTP_PHASE_LIMIT;
-}
+extern void ntp_clear(void);
+extern void ntp_update_frequency(void);
 
 /**
  * ntp_synced - Returns 1 if the NTP status is not UNSYNC

diff --git a/kernel/time/ntp.c b/kernel/time/ntp.c
index 8ccce15b4b23b23b5c5fb9dd64ce0d03fb364177..77137bec2aeacd171cee83c85ae5ec8e9c0559f1 100644 (file)
--- a/kernel/time/ntp.c
+++ b/kernel/time/ntp.c
@@ -15,6 +15,13 @@
 #include <asm/div64.h>
 #include <asm/timex.h>
 
+/*
+ * Timekeeping variables
+ */
+unsigned long tick_usec = TICK_USEC;           /* USER_HZ period (usec) */
+unsigned long tick_nsec;                       /* ACTHZ period (nsec) */
+static u64 tick_length, tick_length_base;
+
 /* Don't completely fail for HZ > 500.  */
 int tickadj = 500/HZ ? : 1;            /* microsecs */
 
@@ -37,6 +44,36 @@ long time_reftime;                   /* time at last adjustment (s)  */
 long time_adjust;
 long time_next_adjust;
 
+/**
+ * ntp_clear - Clears the NTP state variables
+ *
+ * Must be called while holding a write on the xtime_lock
+ */
+void ntp_clear(void)
+{
+       time_adjust = 0;                /* stop active adjtime() */
+       time_status |= STA_UNSYNC;
+       time_maxerror = NTP_PHASE_LIMIT;
+       time_esterror = NTP_PHASE_LIMIT;
+
+       ntp_update_frequency();
+
+       tick_length = tick_length_base;
+}
+
+#define CLOCK_TICK_OVERFLOW    (LATCH * HZ - CLOCK_TICK_RATE)
+#define CLOCK_TICK_ADJUST      (((s64)CLOCK_TICK_OVERFLOW * NSEC_PER_SEC) / (s64)CLOCK_TICK_RATE)
+
+void ntp_update_frequency(void)
+{
+       tick_length_base = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ) << TICK_LENGTH_SHIFT;
+       tick_length_base += (s64)CLOCK_TICK_ADJUST << TICK_LENGTH_SHIFT;
+
+       do_div(tick_length_base, HZ);
+
+       tick_nsec = tick_length_base >> TICK_LENGTH_SHIFT;
+}
+
 /*
  * this routine handles the overflow of the microsecond field
  *
@@ -151,6 +188,7 @@ void second_overflow(void)
         */
        time_adj += shift_right(time_adj, 6) + shift_right(time_adj, 7);
 #endif
+       tick_length = tick_length_base;
 }
 
 /*
@@ -204,14 +242,13 @@ void update_ntp_one_tick(void)
  */
 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 = tick_length;
+       ret += (u64)(adjtime_adjustment() * 1000) << TICK_LENGTH_SHIFT;
        ret += (s64)time_adj << (TICK_LENGTH_SHIFT - (SHIFT_SCALE - 10));
 
        return ret;
@@ -351,10 +388,11 @@ int do_adjtimex(struct timex *txc)
                    time_freq = max(time_freq, -time_tolerance);
                } /* STA_PLL */
            } /* txc->modes & ADJ_OFFSET */
-           if (txc->modes & ADJ_TICK) {
+           if (txc->modes & ADJ_TICK)
                tick_usec = txc->tick;
-               tick_nsec = TICK_USEC_TO_NSEC(tick_usec);
-           }
+
+           if (txc->modes & ADJ_TICK)
+                   ntp_update_frequency();
        } /* txc->modes */
 leave: if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0)
                result = TIME_ERROR;

diff --git a/kernel/timer.c b/kernel/timer.c
index 5fccc7cbf3b4b750c689b95ef54a5e4b6d4cfcb0..78d3fa10fcd6136f70540a82bcdbcb8c35bcde69 100644 (file)
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -562,12 +562,6 @@ found:
 
 /******************************************************************/
 
-/*
- * Timekeeping variables
- */
-unsigned long tick_usec = TICK_USEC;           /* USER_HZ period (usec) */
-unsigned long tick_nsec = TICK_NSEC;           /* ACTHZ period (nsec) */
-
 /* 
  * The current time 
  * wall_to_monotonic is what we need to add to xtime (or xtime corrected 
@@ -757,10 +751,13 @@ void __init timekeeping_init(void)
        unsigned long flags;
 
        write_seqlock_irqsave(&xtime_lock, flags);
+
+       ntp_clear();
+
        clock = clocksource_get_next();
        clocksource_calculate_interval(clock, tick_nsec);
        clock->cycle_last = clocksource_read(clock);
-       ntp_clear();
+
        write_sequnlock_irqrestore(&xtime_lock, flags);
 }