Redo Kernel NTP PLL support, kernel side.

This code is mostly taken from the 1.1 port (which was in turn taken from
Dave Mills's kern.tar.Z example).  A few significant differences:

1) ntp_gettime() is now a MIB variable rather than a system call.  A few
fiddles are done in libc to make it behave the same.

2) mono_time does not participate in the PLL adjustments.

3) A new interface has been defined (in <machine/clock.h>) for doing
possibly machine-dependent things around the time of the clock update.
This is used in Pentium kernels to disable interrupts, set `time', and
reset the CPU cycle counter as quickly as possible to avoid jitter in
microtime().  Measurements show an apparent resolution of a bit more than
8.14usec, which is reasonable given system-call overhead.

20 files changed, 2129 insertions, 154 deletions

diff --git a/sys/amd64/amd64/tsc.c b/sys/amd64/amd64/tsc.c
index 88942db..b762442 100644
--- a/sys/amd64/amd64/tsc.c
+++ b/sys/amd64/amd64/tsc.c
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  *	from: @(#)clock.c	7.2 (Berkeley) 5/12/91
- *	$Id: clock.c,v 1.16 1994/08/18 22:34:50 wollman Exp $
+ *	$Id: clock.c,v 1.17 1994/09/14 23:09:06 ache Exp $
  */
 
 /*
@@ -79,27 +79,6 @@ void
 clkintr(frame)
 	struct clockframe frame;
 {
-#ifdef I586_CPU
-	/*
-	 * This resets the CPU cycle counter to zero, to make our
-	 * job easier in microtime().  Some fancy ifdefs could speed
-	 * this up for Pentium-only kernels.
-	 * We want this to be done as close as possible to the actual
-	 * timer incrementing in hardclock(), because there is a window
-	 * between the two where the value is no longer valid.  Experimentation
-	 * may reveal a good precompensation to apply in microtime().
-	 */
-	if(pentium_mhz) {
-		__asm __volatile("movl $0x10,%%ecx\n"
-				 "xorl %%eax,%%eax\n"
-				 "movl %%eax,%%edx\n"
-				 ".byte 0x0f, 0x30\n"
-				 "#%0%1"
-				 : "=m"(frame)	/* no outputs */
-				 : "b"(&frame) /* fake input */
-				 : "ax", "cx", "dx");
-	}
-#endif
 	hardclock(&frame);
 }
 
diff --git a/sys/amd64/include/clock.h b/sys/amd64/include/clock.h
new file mode 100644
index 0000000..b7420e4
--- /dev/null
+++ b/sys/amd64/include/clock.h
@@ -0,0 +1,49 @@
+/*
+ * Kernel interface to machine-dependent clock driver.
+ * Garrett Wollman, September 1994.
+ * This file is in the public domain.
+ */
+
+#ifndef _MACHINE_CLOCK_H_
+#define _MACHINE_CLOCK_H_ 1
+
+extern int pentium_mhz;
+
+#ifdef I586_CPU
+	/*
+	 * This resets the CPU cycle counter to zero, to make our
+	 * job easier in microtime().  Some fancy ifdefs could speed
+	 * this up for Pentium-only kernels.
+	 * We want this to be done as close as possible to the actual
+	 * timer incrementing in hardclock(), because there is a window
+	 * between the two where the value is no longer valid.  Experimentation
+	 * may reveal a good precompensation to apply in microtime().
+	 */
+#define CPU_CLOCKUPDATE(otime, ntime) \
+	do { \
+	if(pentium_mhz) { \
+		__asm __volatile("cli\n" \
+				 "movl (%2),%%eax\n" \
+				 "movl %%eax,(%1)\n" \
+				 "movl 4(%2),%%eax\n" \
+				 "movl %%eax,4(%1)\n" \
+				 "movl $0x10,%%ecx\n" \
+				 "xorl %%eax,%%eax\n" \
+				 "movl %%eax,%%edx\n" \
+				 ".byte 0x0f, 0x30\n" \
+				 "sti\n" \
+				 "#%0%1%2" \
+				 : "=m"(*otime)	/* no outputs */ \
+				 : "c"(otime), "b"(ntime) /* fake input */ \
+				 : "ax", "cx", "dx"); \
+	} else { \
+		*(otime) = *(ntime); \
+	} \
+	} while(0)
+
+#else
+#define CPU_CLOCKUPDATE(otime, ntime) \
+		(*(otime) = *(ntime))
+#endif
+
+#endif /* _MACHINE_CLOCK_H_ */
diff --git a/sys/amd64/isa/clock.c b/sys/amd64/isa/clock.c
index 88942db..b762442 100644
--- a/sys/amd64/isa/clock.c
+++ b/sys/amd64/isa/clock.c
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  *	from: @(#)clock.c	7.2 (Berkeley) 5/12/91
- *	$Id: clock.c,v 1.16 1994/08/18 22:34:50 wollman Exp $
+ *	$Id: clock.c,v 1.17 1994/09/14 23:09:06 ache Exp $
  */
 
 /*
@@ -79,27 +79,6 @@ void
 clkintr(frame)
 	struct clockframe frame;
 {
-#ifdef I586_CPU
-	/*
-	 * This resets the CPU cycle counter to zero, to make our
-	 * job easier in microtime().  Some fancy ifdefs could speed
-	 * this up for Pentium-only kernels.
-	 * We want this to be done as close as possible to the actual
-	 * timer incrementing in hardclock(), because there is a window
-	 * between the two where the value is no longer valid.  Experimentation
-	 * may reveal a good precompensation to apply in microtime().
-	 */
-	if(pentium_mhz) {
-		__asm __volatile("movl $0x10,%%ecx\n"
-				 "xorl %%eax,%%eax\n"
-				 "movl %%eax,%%edx\n"
-				 ".byte 0x0f, 0x30\n"
-				 "#%0%1"
-				 : "=m"(frame)	/* no outputs */
-				 : "b"(&frame) /* fake input */
-				 : "ax", "cx", "dx");
-	}
-#endif
 	hardclock(&frame);
 }
 
diff --git a/sys/conf/files b/sys/conf/files
index e32c95b..f314a1b 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -49,6 +49,7 @@ kern/kern_ktrace.c	standard
 kern/kern_lockf.c	standard
 kern/kern_lkm.c		optional lkm
 kern/kern_malloc.c	standard
+kern/kern_ntptime.c	standard
 kern/kern_physio.c	standard
 kern/kern_proc.c	standard
 kern/kern_prot.c	standard
diff --git a/sys/i386/i386/tsc.c b/sys/i386/i386/tsc.c
index 88942db..b762442 100644
--- a/sys/i386/i386/tsc.c
+++ b/sys/i386/i386/tsc.c
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  *	from: @(#)clock.c	7.2 (Berkeley) 5/12/91
- *	$Id: clock.c,v 1.16 1994/08/18 22:34:50 wollman Exp $
+ *	$Id: clock.c,v 1.17 1994/09/14 23:09:06 ache Exp $
  */
 
 /*
@@ -79,27 +79,6 @@ void
 clkintr(frame)
 	struct clockframe frame;
 {
-#ifdef I586_CPU
-	/*
-	 * This resets the CPU cycle counter to zero, to make our
-	 * job easier in microtime().  Some fancy ifdefs could speed
-	 * this up for Pentium-only kernels.
-	 * We want this to be done as close as possible to the actual
-	 * timer incrementing in hardclock(), because there is a window
-	 * between the two where the value is no longer valid.  Experimentation
-	 * may reveal a good precompensation to apply in microtime().
-	 */
-	if(pentium_mhz) {
-		__asm __volatile("movl $0x10,%%ecx\n"
-				 "xorl %%eax,%%eax\n"
-				 "movl %%eax,%%edx\n"
-				 ".byte 0x0f, 0x30\n"
-				 "#%0%1"
-				 : "=m"(frame)	/* no outputs */
-				 : "b"(&frame) /* fake input */
-				 : "ax", "cx", "dx");
-	}
-#endif
 	hardclock(&frame);
 }
 
diff --git a/sys/i386/include/clock.h b/sys/i386/include/clock.h
new file mode 100644
index 0000000..b7420e4
--- /dev/null
+++ b/sys/i386/include/clock.h
@@ -0,0 +1,49 @@
+/*
+ * Kernel interface to machine-dependent clock driver.
+ * Garrett Wollman, September 1994.
+ * This file is in the public domain.
+ */
+
+#ifndef _MACHINE_CLOCK_H_
+#define _MACHINE_CLOCK_H_ 1
+
+extern int pentium_mhz;
+
+#ifdef I586_CPU
+	/*
+	 * This resets the CPU cycle counter to zero, to make our
+	 * job easier in microtime().  Some fancy ifdefs could speed
+	 * this up for Pentium-only kernels.
+	 * We want this to be done as close as possible to the actual
+	 * timer incrementing in hardclock(), because there is a window
+	 * between the two where the value is no longer valid.  Experimentation
+	 * may reveal a good precompensation to apply in microtime().
+	 */
+#define CPU_CLOCKUPDATE(otime, ntime) \
+	do { \
+	if(pentium_mhz) { \
+		__asm __volatile("cli\n" \
+				 "movl (%2),%%eax\n" \
+				 "movl %%eax,(%1)\n" \
+				 "movl 4(%2),%%eax\n" \
+				 "movl %%eax,4(%1)\n" \
+				 "movl $0x10,%%ecx\n" \
+				 "xorl %%eax,%%eax\n" \
+				 "movl %%eax,%%edx\n" \
+				 ".byte 0x0f, 0x30\n" \
+				 "sti\n" \
+				 "#%0%1%2" \
+				 : "=m"(*otime)	/* no outputs */ \
+				 : "c"(otime), "b"(ntime) /* fake input */ \
+				 : "ax", "cx", "dx"); \
+	} else { \
+		*(otime) = *(ntime); \
+	} \
+	} while(0)
+
+#else
+#define CPU_CLOCKUPDATE(otime, ntime) \
+		(*(otime) = *(ntime))
+#endif
+
+#endif /* _MACHINE_CLOCK_H_ */
diff --git a/sys/i386/isa/clock.c b/sys/i386/isa/clock.c
index 88942db..b762442 100644
--- a/sys/i386/isa/clock.c
+++ b/sys/i386/isa/clock.c
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  *	from: @(#)clock.c	7.2 (Berkeley) 5/12/91
- *	$Id: clock.c,v 1.16 1994/08/18 22:34:50 wollman Exp $
+ *	$Id: clock.c,v 1.17 1994/09/14 23:09:06 ache Exp $
  */
 
 /*
@@ -79,27 +79,6 @@ void
 clkintr(frame)
 	struct clockframe frame;
 {
-#ifdef I586_CPU
-	/*
-	 * This resets the CPU cycle counter to zero, to make our
-	 * job easier in microtime().  Some fancy ifdefs could speed
-	 * this up for Pentium-only kernels.
-	 * We want this to be done as close as possible to the actual
-	 * timer incrementing in hardclock(), because there is a window
-	 * between the two where the value is no longer valid.  Experimentation
-	 * may reveal a good precompensation to apply in microtime().
-	 */
-	if(pentium_mhz) {
-		__asm __volatile("movl $0x10,%%ecx\n"
-				 "xorl %%eax,%%eax\n"
-				 "movl %%eax,%%edx\n"
-				 ".byte 0x0f, 0x30\n"
-				 "#%0%1"
-				 : "=m"(frame)	/* no outputs */
-				 : "b"(&frame) /* fake input */
-				 : "ax", "cx", "dx");
-	}
-#endif
 	hardclock(&frame);
 }
 
diff --git a/sys/isa/atrtc.c b/sys/isa/atrtc.c
index 88942db..b762442 100644
--- a/sys/isa/atrtc.c
+++ b/sys/isa/atrtc.c
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  *	from: @(#)clock.c	7.2 (Berkeley) 5/12/91
- *	$Id: clock.c,v 1.16 1994/08/18 22:34:50 wollman Exp $
+ *	$Id: clock.c,v 1.17 1994/09/14 23:09:06 ache Exp $
  */
 
 /*
@@ -79,27 +79,6 @@ void
 clkintr(frame)
 	struct clockframe frame;
 {
-#ifdef I586_CPU
-	/*
-	 * This resets the CPU cycle counter to zero, to make our
-	 * job easier in microtime().  Some fancy ifdefs could speed
-	 * this up for Pentium-only kernels.
-	 * We want this to be done as close as possible to the actual
-	 * timer incrementing in hardclock(), because there is a window
-	 * between the two where the value is no longer valid.  Experimentation
-	 * may reveal a good precompensation to apply in microtime().
-	 */
-	if(pentium_mhz) {
-		__asm __volatile("movl $0x10,%%ecx\n"
-				 "xorl %%eax,%%eax\n"
-				 "movl %%eax,%%edx\n"
-				 ".byte 0x0f, 0x30\n"
-				 "#%0%1"
-				 : "=m"(frame)	/* no outputs */
-				 : "b"(&frame) /* fake input */
-				 : "ax", "cx", "dx");
-	}
-#endif
 	hardclock(&frame);
 }
 
diff --git a/sys/kern/init_sysent.c b/sys/kern/init_sysent.c
index a7f7988..19219ab 100644
--- a/sys/kern/init_sysent.c
+++ b/sys/kern/init_sysent.c
@@ -2,7 +2,7 @@
  * System call switch table.
  *
  * DO NOT EDIT-- this file is automatically generated.
- * created from	$Id: syscalls.master,v 1.7 1994/09/13 00:48:19 wollman Exp $
+ * created from	$Id: syscalls.master,v 1.8 1994/09/13 14:46:54 dfr Exp $
  */
 
 #include <sys/param.h>
@@ -473,7 +473,7 @@ struct sysent sysent[] = {
 	{ 0, nosys },			/* 172 = nosys */
 	{ 0, nosys },			/* 173 = nosys */
 	{ 0, nosys },			/* 174 = nosys */
-	{ 1, nosys },			/* 175 = ntp_gettime */
+	{ 0, nosys },			/* 175 = nosys */
 	{ 1, nosys },			/* 176 = ntp_adjtime */
 	{ 0, nosys },			/* 177 = nosys */
 	{ 0, nosys },			/* 178 = nosys */
diff --git a/sys/kern/kern_clock.c b/sys/kern/kern_clock.c
index 788e279..6b3f85f 100644
--- a/sys/kern/kern_clock.c
+++ b/sys/kern/kern_clock.c
@@ -36,9 +36,26 @@
  * SUCH DAMAGE.
  *
  *	@(#)kern_clock.c	8.5 (Berkeley) 1/21/94
- * $Id: kern_clock.c,v 1.4 1994/08/18 22:34:58 wollman Exp $
+ * $Id: kern_clock.c,v 1.5 1994/08/27 16:14:26 davidg Exp $
  */
 
+/* Portions of this software are covered by the following: */
+/******************************************************************************
+ *                                                                            *
+ * Copyright (c) David L. Mills 1993, 1994                                    *
+ *                                                                            *
+ * Permission to use, copy, modify, and distribute this software and its      *
+ * documentation for any purpose and without fee is hereby granted, provided  *
+ * that the above copyright notice appears in all copies and that both the    *
+ * copyright notice and this permission notice appear in supporting           *
+ * documentation, and that the name University of Delaware not be used in     *
+ * advertising or publicity pertaining to distribution of the software        *
+ * without specific, written prior permission.  The University of Delaware    *
+ * makes no representations about the suitability this software for any       *
+ * purpose.  It is provided "as is" without express or implied warranty.      *
+ *                                                                            *
+ *****************************************************************************/
+
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/dkstat.h>
@@ -46,9 +63,11 @@
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/resourcevar.h>
+#include <sys/timex.h>
 #include <vm/vm.h>
 
 #include <machine/cpu.h>
+#include <machine/clock.h>
 
 #ifdef GPROF
 #include <sys/gmon.h>
@@ -128,6 +147,238 @@ volatile struct	timeval time;
 volatile struct	timeval mono_time;
 
 /*
+ * Phase-lock loop (PLL) definitions
+ *
+ * The following variables are read and set by the ntp_adjtime() system
+ * call.
+ *
+ * time_state shows the state of the system clock, with values defined
+ * in the timex.h header file.
+ *
+ * time_status shows the status of the system clock, with bits defined
+ * in the timex.h header file.
+ *
+ * time_offset is used by the PLL to adjust the system time in small
+ * increments.
+ *
+ * time_constant determines the bandwidth or "stiffness" of the PLL.
+ *
+ * time_tolerance determines maximum frequency error or tolerance of the
+ * CPU clock oscillator and is a property of the architecture; however,
+ * in principle it could change as result of the presence of external
+ * discipline signals, for instance.
+ *
+ * time_precision is usually equal to the kernel tick variable; however,
+ * in cases where a precision clock counter or external clock is
+ * available, the resolution can be much less than this and depend on
+ * whether the external clock is working or not.
+ *
+ * time_maxerror is initialized by a ntp_adjtime() call and increased by
+ * the kernel once each second to reflect the maximum error
+ * bound growth.
+ *
+ * time_esterror is set and read by the ntp_adjtime() call, but
+ * otherwise not used by the kernel.
+ */
+int time_status = STA_UNSYNC;	/* clock status bits */
+int time_state = TIME_OK;	/* clock state */
+long time_offset = 0;		/* time offset (us) */
+long time_constant = 0;		/* pll time constant */
+long time_tolerance = MAXFREQ;	/* frequency tolerance (scaled ppm) */
+long time_precision = 1;	/* clock precision (us) */
+long time_maxerror = MAXPHASE;	/* maximum error (us) */
+long time_esterror = MAXPHASE;	/* estimated error (us) */
+
+/*
+ * The following variables establish the state of the PLL and the
+ * residual time and frequency offset of the local clock. The scale
+ * factors are defined in the timex.h header file.
+ *
+ * time_phase and time_freq are the phase increment and the frequency
+ * increment, respectively, of the kernel time variable at each tick of
+ * the clock.
+ *
+ * time_freq is set via ntp_adjtime() from a value stored in a file when
+ * the synchronization daemon is first started. Its value is retrieved
+ * via ntp_adjtime() and written to the file about once per hour by the
+ * daemon.
+ *
+ * time_adj is the adjustment added to the value of tick at each timer
+ * interrupt and is recomputed at each timer interrupt.
+ *
+ * time_reftime is the second's portion of the system time on the last
+ * call to ntp_adjtime(). It is used to adjust the time_freq variable
+ * and to increase the time_maxerror as the time since last update
+ * increases.
+ */
+long time_phase = 0;		/* phase offset (scaled us) */
+long time_freq = 0;		/* frequency offset (scaled ppm) */
+long time_adj = 0;		/* tick adjust (scaled 1 / hz) */
+long time_reftime = 0;		/* time at last adjustment (s) */
+
+#ifdef PPS_SYNC
+/*
+ * The following variables are used only if the if the kernel PPS
+ * discipline code is configured (PPS_SYNC). The scale factors are
+ * defined in the timex.h header file.
+ *
+ * pps_time contains the time at each calibration interval, as read by
+ * microtime().
+ *
+ * pps_offset is the time offset produced by the time median filter
+ * pps_tf[], while pps_jitter is the dispersion measured by this
+ * filter.
+ *
+ * pps_freq is the frequency offset produced by the frequency median
+ * filter pps_ff[], while pps_stabil is the dispersion measured by
+ * this filter.
+ *
+ * pps_usec is latched from a high resolution counter or external clock
+ * at pps_time. Here we want the hardware counter contents only, not the
+ * contents plus the time_tv.usec as usual.
+ *
+ * pps_valid counts the number of seconds since the last PPS update. It
+ * is used as a watchdog timer to disable the PPS discipline should the
+ * PPS signal be lost.
+ *
+ * pps_glitch counts the number of seconds since the beginning of an
+ * offset burst more than tick/2 from current nominal offset. It is used
+ * mainly to suppress error bursts due to priority conflicts between the
+ * PPS interrupt and timer interrupt.
+ *
+ * pps_count counts the seconds of the calibration interval, the
+ * duration of which is pps_shift in powers of two.
+ *
+ * pps_intcnt counts the calibration intervals for use in the interval-
+ * adaptation algorithm. It's just too complicated for words.
+ */
+struct timeval pps_time;	/* kernel time at last interval */
+long pps_offset = 0;		/* pps time offset (us) */
+long pps_jitter = MAXTIME;	/* pps time dispersion (jitter) (us) */
+long pps_tf[] = {0, 0, 0};	/* pps time offset median filter (us) */
+long pps_freq = 0;		/* frequency offset (scaled ppm) */
+long pps_stabil = MAXFREQ;	/* frequency dispersion (scaled ppm) */
+long pps_ff[] = {0, 0, 0};	/* frequency offset median filter */
+long pps_usec = 0;		/* microsec counter at last interval */
+long pps_valid = PPS_VALID;	/* pps signal watchdog counter */
+int pps_glitch = 0;		/* pps signal glitch counter */
+int pps_count = 0;		/* calibration interval counter (s) */
+int pps_shift = PPS_SHIFT;	/* interval duration (s) (shift) */
+int pps_intcnt = 0;		/* intervals at current duration */
+
+/*
+ * PPS signal quality monitors
+ *
+ * pps_jitcnt counts the seconds that have been discarded because the
+ * jitter measured by the time median filter exceeds the limit MAXTIME
+ * (100 us).
+ *
+ * pps_calcnt counts the frequency calibration intervals, which are
+ * variable from 4 s to 256 s.
+ *
+ * pps_errcnt counts the calibration intervals which have been discarded
+ * because the wander exceeds the limit MAXFREQ (100 ppm) or where the
+ * calibration interval jitter exceeds two ticks.
+ *
+ * pps_stbcnt counts the calibration intervals that have been discarded
+ * because the frequency wander exceeds the limit MAXFREQ / 4 (25 us).
+ */
+long pps_jitcnt = 0;		/* jitter limit exceeded */
+long pps_calcnt = 0;		/* calibration intervals */
+long pps_errcnt = 0;		/* calibration errors */
+long pps_stbcnt = 0;		/* stability limit exceeded */
+#endif /* PPS_SYNC */
+
+/* XXX none of this stuff works under FreeBSD */
+#ifdef EXT_CLOCK
+/*
+ * External clock definitions
+ *
+ * The following definitions and declarations are used only if an
+ * external clock (HIGHBALL or TPRO) is configured on the system.
+ */
+#define CLOCK_INTERVAL 30	/* CPU clock update interval (s) */
+
+/*
+ * The clock_count variable is set to CLOCK_INTERVAL at each PPS
+ * interrupt and decremented once each second.
+ */
+int clock_count = 0;		/* CPU clock counter */
+
+#ifdef HIGHBALL
+/*
+ * The clock_offset and clock_cpu variables are used by the HIGHBALL
+ * interface. The clock_offset variable defines the offset between
+ * system time and the HIGBALL counters. The clock_cpu variable contains
+ * the offset between the system clock and the HIGHBALL clock for use in
+ * disciplining the kernel time variable.
+ */
+extern struct timeval clock_offset; /* Highball clock offset */
+long clock_cpu = 0;		/* CPU clock adjust */
+#endif /* HIGHBALL */
+#endif /* EXT_CLOCK */
+
+/*
+ * hardupdate() - local clock update
+ *
+ * This routine is called by ntp_adjtime() to update the local clock
+ * phase and frequency. This is used to implement an adaptive-parameter,
+ * first-order, type-II phase-lock loop. The code computes new time and
+ * frequency offsets each time it is called. The hardclock() routine
+ * amortizes these offsets at each tick interrupt. If the kernel PPS
+ * discipline code is configured (PPS_SYNC), the PPS signal itself
+ * determines the new time offset, instead of the calling argument.
+ * Presumably, calls to ntp_adjtime() occur only when the caller
+ * believes the local clock is valid within some bound (+-128 ms with
+ * NTP). If the caller's time is far different than the PPS time, an
+ * argument will ensue, and it's not clear who will lose.
+ *
+ * For default SHIFT_UPDATE = 12, the offset is limited to +-512 ms, the
+ * maximum interval between updates is 4096 s and the maximum frequency
+ * offset is +-31.25 ms/s.
+ *
+ * Note: splclock() is in effect.
+ */
+void
+hardupdate(offset)
+	long offset;
+{
+	long ltemp, mtemp;
+
+	if (!(time_status & STA_PLL) && !(time_status & STA_PPSTIME))
+		return;
+	ltemp = offset;
+#ifdef PPS_SYNC
+	if (time_status & STA_PPSTIME && time_status & STA_PPSSIGNAL)
+		ltemp = pps_offset;
+#endif /* PPS_SYNC */
+	if (ltemp > MAXPHASE)
+		time_offset = MAXPHASE << SHIFT_UPDATE;
+	else if (ltemp < -MAXPHASE)
+		time_offset = -(MAXPHASE << SHIFT_UPDATE);
+	else
+		time_offset = ltemp << SHIFT_UPDATE;
+	mtemp = time.tv_sec - time_reftime;
+	time_reftime = time.tv_sec;
+	if (mtemp > MAXSEC)
+		mtemp = 0;
+
+	/* ugly multiply should be replaced */
+	if (ltemp < 0)
+		time_freq -= (-ltemp * mtemp) >> (time_constant +
+		    time_constant + SHIFT_KF - SHIFT_USEC);
+	else
+		time_freq += (ltemp * mtemp) >> (time_constant +
+		    time_constant + SHIFT_KF - SHIFT_USEC);
+	if (time_freq > time_tolerance)
+		time_freq = time_tolerance;
+	else if (time_freq < -time_tolerance)
+		time_freq = -time_tolerance;
+}
+
+
+
+/*
  * Initialize clock frequencies and start both clocks running.
  */
 void
@@ -207,18 +458,164 @@ hardclock(frame)
 		statclock(frame);
 
 	/*
-	 * Increment the time-of-day.  The increment is just ``tick'' unless
-	 * we are still adjusting the clock; see adjtime().
+	 * Increment the time-of-day.  
 	 */
 	ticks++;
-	if (timedelta == 0)
-		delta = tick;
-	else {
-		delta = tick + tickdelta;
-		timedelta -= tickdelta;
+	{
+		int time_update;
+		struct timeval newtime = time;
+		long ltemp;
+
+		if (timedelta == 0) {
+		  time_update = tick;
+		} else {
+			if (timedelta < 0) {
+				time_update = tick - tickdelta;
+				timedelta += tickdelta;
+			} else {
+				time_update = tick + tickdelta;
+				timedelta -= tickdelta;
+			}
+		}
+		BUMPTIME(&mono_time, time_update);
+
+		/*
+		 * Compute the phase adjustment. If the low-order bits
+		 * (time_phase) of the update overflow, bump the high-order bits
+		 * (time_update).
+		 */
+		time_phase += time_adj;
+		if (time_phase <= -FINEUSEC) {
+		  ltemp = -time_phase >> SHIFT_SCALE;
+		  time_phase += ltemp << SHIFT_SCALE;
+		  time_update -= ltemp;
+		}
+		else if (time_phase >= FINEUSEC) {
+		  ltemp = time_phase >> SHIFT_SCALE;
+		  time_phase -= ltemp << SHIFT_SCALE;
+		  time_update += ltemp;
+		}
+
+		newtime.tv_usec += time_update;
+		/*
+		 * On rollover of the second the phase adjustment to be used for
+		 * the next second is calculated. Also, the maximum error is
+		 * increased by the tolerance. If the PPS frequency discipline
+		 * code is present, the phase is increased to compensate for the
+		 * CPU clock oscillator frequency error.
+		 *
+		 * With SHIFT_SCALE = 23, the maximum frequency adjustment is
+		 * +-256 us per tick, or 25.6 ms/s at a clock frequency of 100
+		 * Hz. The time contribution is shifted right a minimum of two
+		 * bits, while the frequency contribution is a right shift.
+		 * Thus, overflow is prevented if the frequency contribution is
+		 * limited to half the maximum or 15.625 ms/s.
+		 */
+		if (newtime.tv_usec >= 1000000) {
+		  newtime.tv_usec -= 1000000;
+		  newtime.tv_sec++;
+		  time_maxerror += time_tolerance >> SHIFT_USEC;
+		  if (time_offset < 0) {
+		    ltemp = -time_offset >>
+		      (SHIFT_KG + time_constant);
+		    time_offset += ltemp;
+		    time_adj = -ltemp <<
+		      (SHIFT_SCALE - SHIFT_HZ - SHIFT_UPDATE);
+		  } else {
+		    ltemp = time_offset >>
+		      (SHIFT_KG + time_constant);
+		    time_offset -= ltemp;
+		    time_adj = ltemp <<
+		      (SHIFT_SCALE - SHIFT_HZ - SHIFT_UPDATE);
+		  }
+#ifdef PPS_SYNC
+		  /*
+		   * Gnaw on the watchdog counter and update the frequency
+		   * computed by the pll and the PPS signal.
+		   */
+		  pps_valid++;
+		  if (pps_valid == PPS_VALID) {
+		    pps_jitter = MAXTIME;
+		    pps_stabil = MAXFREQ;
+		    time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
+				     STA_PPSWANDER | STA_PPSERROR);
+		  }
+		  ltemp = time_freq + pps_freq;
+#else
+		  ltemp = time_freq;
+#endif /* PPS_SYNC */
+		  if (ltemp < 0)
+		    time_adj -= -ltemp >>
+		      (SHIFT_USEC + SHIFT_HZ - SHIFT_SCALE);
+		  else
+		    time_adj += ltemp >>
+		      (SHIFT_USEC + SHIFT_HZ - SHIFT_SCALE);
+
+		  /*
+		   * When the CPU clock oscillator frequency is not a
+		   * power of two in Hz, the SHIFT_HZ is only an
+		   * approximate scale factor. In the SunOS kernel, this
+		   * results in a PLL gain factor of 1/1.28 = 0.78 what it
+		   * should be. In the following code the overall gain is
+		   * increased by a factor of 1.25, which results in a
+		   * residual error less than 3 percent.
+		   */
+		  /* Same thing applies for FreeBSD --GAW */
+		  if (hz == 100) {
+		    if (time_adj < 0)
+		      time_adj -= -time_adj >> 2;
+		    else
+		      time_adj += time_adj >> 2;
+		  }
+
+		  /* XXX - this is really bogus, but can't be fixed until
+		     xntpd's idea of the system clock is fixed to know how
+		     the user wants leap seconds handled; in the mean time,
+		     we assume that users of NTP are running without proper
+		     leap second support (this is now the default anyway) */
+		  /*
+		   * 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 (newtime.tv_sec % 86400 == 0) {
+		      newtime.tv_sec--;
+		      time_state = TIME_OOP;
+		    }
+		    break;
+
+		  case TIME_DEL:
+		    if ((newtime.tv_sec + 1) % 86400 == 0) {
+		      newtime.tv_sec++;
+		      time_state = TIME_WAIT;
+		    }
+		    break;
+		    
+		  case TIME_OOP:
+		    time_state = TIME_WAIT;
+		    break;
+		    
+		  case TIME_WAIT:
+		    if (!(time_status & (STA_INS | STA_DEL)))
+		      time_state = TIME_OK;
+		  }
+		}
+		CPU_CLOCKUPDATE(&time, &newtime);
 	}
-	BUMPTIME(&time, delta);
-	BUMPTIME(&mono_time, delta);
 
 	/*
 	 * Process callouts at a very low cpu priority, so we don't keep the
@@ -563,3 +960,171 @@ sysctl_clockrate(where, sizep)
 	clkinfo.stathz = stathz ? stathz : hz;
 	return (sysctl_rdstruct(where, sizep, NULL, &clkinfo, sizeof(clkinfo)));
 }
+
+/*#ifdef PPS_SYNC*/
+#if 0
+/* This code is completely bogus; if anybody ever wants to use it, get
+ * the current version from Dave Mills. */
+
+/*
+ * hardpps() - discipline CPU clock oscillator to external pps signal
+ *
+ * This routine is called at each PPS interrupt in order to discipline
+ * the CPU clock oscillator to the PPS signal. It integrates successive
+ * phase differences between the two oscillators and calculates the
+ * frequency offset. This is used in hardclock() to discipline the CPU
+ * clock oscillator so that intrinsic frequency error is cancelled out.
+ * The code requires the caller to capture the time and hardware
+ * counter value at the designated PPS signal transition.
+ */
+void
+hardpps(tvp, usec)
+	struct timeval *tvp;		/* time at PPS */
+	long usec;			/* hardware counter at PPS */
+{
+	long u_usec, v_usec, bigtick;
+	long cal_sec, cal_usec;
+
+	/*
+	 * During the calibration interval adjust the starting time when
+	 * the tick overflows. At the end of the interval compute the
+	 * duration of the interval and the difference of the hardware
+	 * counters at the beginning and end of the interval. This code
+	 * is deliciously complicated by the fact valid differences may
+	 * exceed the value of tick when using long calibration
+	 * intervals and small ticks. Note that the counter can be
+	 * greater than tick if caught at just the wrong instant, but
+	 * the values returned and used here are correct.
+	 */
+	bigtick = (long)tick << SHIFT_USEC;
+	pps_usec -= ntp_pll.ybar;
+	if (pps_usec >= bigtick)
+		pps_usec -= bigtick;
+	if (pps_usec < 0)
+		pps_usec += bigtick;
+	pps_time.tv_sec++;
+	pps_count++;
+	if (pps_count < (1 << pps_shift))
+		return;
+	pps_count = 0;
+	ntp_pll.calcnt++;
+	u_usec = usec << SHIFT_USEC;
+	v_usec = pps_usec - u_usec;
+	if (v_usec >= bigtick >> 1)
+		v_usec -= bigtick;
+	if (v_usec < -(bigtick >> 1))
+		v_usec += bigtick;
+	if (v_usec < 0)
+		v_usec = -(-v_usec >> ntp_pll.shift);
+	else
+		v_usec = v_usec >> ntp_pll.shift;
+	pps_usec = u_usec;
+	cal_sec = tvp->tv_sec;
+	cal_usec = tvp->tv_usec;
+	cal_sec -= pps_time.tv_sec;
+	cal_usec -= pps_time.tv_usec;
+	if (cal_usec < 0) {
+		cal_usec += 1000000;
+		cal_sec--;
+	}
+	pps_time = *tvp;
+
+	/*
+	 * Check for lost interrupts, noise, excessive jitter and
+	 * excessive frequency error. The number of timer ticks during
+	 * the interval may vary +-1 tick. Add to this a margin of one
+	 * tick for the PPS signal jitter and maximum frequency
+	 * deviation. If the limits are exceeded, the calibration
+	 * interval is reset to the minimum and we start over.
+	 */
+	u_usec = (long)tick << 1;
+	if (!((cal_sec == -1 && cal_usec > (1000000 - u_usec))
+	    || (cal_sec == 0 && cal_usec < u_usec))
+	    || v_usec > ntp_pll.tolerance || v_usec < -ntp_pll.tolerance) {
+		ntp_pll.jitcnt++;
+		ntp_pll.shift = NTP_PLL.SHIFT;
+		pps_dispinc = PPS_DISPINC;
+		ntp_pll.intcnt = 0;
+		return;
+	}
+
+	/*
+	 * A three-stage median filter is used to help deglitch the pps
+	 * signal. The median sample becomes the offset estimate; the
+	 * difference between the other two samples becomes the
+	 * dispersion estimate.
+	 */
+	pps_mf[2] = pps_mf[1];
+	pps_mf[1] = pps_mf[0];
+	pps_mf[0] = v_usec;
+	if (pps_mf[0] > pps_mf[1]) {
+		if (pps_mf[1] > pps_mf[2]) {
+			u_usec = pps_mf[1];		/* 0 1 2 */
+			v_usec = pps_mf[0] - pps_mf[2];
+		} else if (pps_mf[2] > pps_mf[0]) {
+			u_usec = pps_mf[0];		/* 2 0 1 */
+			v_usec = pps_mf[2] - pps_mf[1];
+		} else {
+			u_usec = pps_mf[2];		/* 0 2 1 */
+			v_usec = pps_mf[0] - pps_mf[1];
+		}
+	} else {
+		if (pps_mf[1] < pps_mf[2]) {
+			u_usec = pps_mf[1];		/* 2 1 0 */
+			v_usec = pps_mf[2] - pps_mf[0];
+		} else  if (pps_mf[2] < pps_mf[0]) {
+			u_usec = pps_mf[0];		/* 1 0 2 */
+			v_usec = pps_mf[1] - pps_mf[2];
+		} else {
+			u_usec = pps_mf[2];		/* 1 2 0 */
+			v_usec = pps_mf[1] - pps_mf[0];
+		}
+	}
+
+	/*
+	 * Here the dispersion average is updated. If it is less than
+	 * the threshold pps_dispmax, the frequency average is updated
+	 * as well, but clamped to the tolerance.
+	 */
+	v_usec = (v_usec >> 1) - ntp_pll.disp;
+	if (v_usec < 0)
+		ntp_pll.disp -= -v_usec >> PPS_AVG;
+	else
+		ntp_pll.disp += v_usec >> PPS_AVG;
+	if (ntp_pll.disp > pps_dispmax) {
+		ntp_pll.discnt++;
+		return;
+	}
+	if (u_usec < 0) {
+		ntp_pll.ybar -= -u_usec >> PPS_AVG;
+		if (ntp_pll.ybar < -ntp_pll.tolerance)
+			ntp_pll.ybar = -ntp_pll.tolerance;
+		u_usec = -u_usec;
+	} else {
+		ntp_pll.ybar += u_usec >> PPS_AVG;
+		if (ntp_pll.ybar > ntp_pll.tolerance)
+			ntp_pll.ybar = ntp_pll.tolerance;
+	}
+
+	/*
+	 * Here the calibration interval is adjusted. If the maximum
+	 * time difference is greater than tick/4, reduce the interval
+	 * by half. If this is not the case for four consecutive
+	 * intervals, double the interval.
+	 */
+	if (u_usec << ntp_pll.shift > bigtick >> 2) {
+		ntp_pll.intcnt = 0;
+		if (ntp_pll.shift > NTP_PLL.SHIFT) {
+			ntp_pll.shift--;
+			pps_dispinc <<= 1;
+		}
+	} else if (ntp_pll.intcnt >= 4) {
+		ntp_pll.intcnt = 0;
+		if (ntp_pll.shift < NTP_PLL.SHIFTMAX) {
+			ntp_pll.shift++;
+			pps_dispinc >>= 1;
+		}
+	} else
+		ntp_pll.intcnt++;
+}
+#endif /* PPS_SYNC */
diff --git a/sys/kern/kern_ntptime.c b/sys/kern/kern_ntptime.c
new file mode 100644
index 0000000..9d4c1b9
--- /dev/null
+++ b/sys/kern/kern_ntptime.c
@@ -0,0 +1,269 @@
+/******************************************************************************
+ *                                                                            *
+ * Copyright (c) David L. Mills 1993, 1994                                    *
+ *                                                                            *
+ * Permission to use, copy, modify, and distribute this software and its      *
+ * documentation for any purpose and without fee is hereby granted, provided  *
+ * that the above copyright notice appears in all copies and that both the    *
+ * copyright notice and this permission notice appear in supporting           *
+ * documentation, and that the name University of Delaware not be used in     *
+ * advertising or publicity pertaining to distribution of the software        *
+ * without specific, written prior permission.  The University of Delaware    *
+ * makes no representations about the suitability this software for any       *
+ * purpose.  It is provided "as is" without express or implied warranty.      *
+ *                                                                            *
+ ******************************************************************************/
+
+/*
+ * Modification history kern_ntptime.c
+ *
+ * 24 Mar 94	David L. Mills
+ *	Revised syscall interface to include new variables for PPS
+ *	time discipline.
+ *
+ * 14 Feb 94	David L. Mills
+ *	Added code for external clock
+ *
+ * 28 Nov 93	David L. Mills
+ *	Revised frequency scaling to conform with adjusted parameters
+ *
+ * 17 Sep 93	David L. Mills
+ *	Created file
+ */
+/*
+ * ntp_gettime(), ntp_adjtime() - precision time interface for SunOS
+ * 4.1.1 and 4.1.3
+ *
+ * These routines consitute the Network Time Protocol (NTP) interfaces
+ * for user and daemon application programs. The ntp_gettime() routine
+ * provides the time, maximum error (synch distance) and estimated error
+ * (dispersion) to client user application programs. The ntp_adjtime()
+ * routine is used by the NTP daemon to adjust the system clock to an
+ * externally derived time. The time offset and related variables set by
+ * this routine are used by hardclock() to adjust the phase and
+ * frequency of the phase-lock loop which controls the system clock.
+ */
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/proc.h>
+#include <sys/timex.h>
+#include <sys/sysctl.h>
+
+/*
+ * The following variables are used by the hardclock() routine in the
+ * kern_clock.c module and are described in that module. 
+ */
+extern struct timeval time;	/* kernel time variable */
+extern int time_state;		/* clock state */
+extern int time_status;		/* clock status bits */
+extern long time_offset;	/* time adjustment (us) */
+extern long time_freq;		/* frequency offset (scaled ppm) */
+extern long time_maxerror;	/* maximum error (us) */
+extern long time_esterror;	/* estimated error (us) */
+extern long time_constant;	/* pll time constant */
+extern long time_precision;	/* clock precision (us) */
+extern long time_tolerance;	/* frequency tolerance (scaled ppm) */
+
+#ifdef PPS_SYNC
+/*
+ * The following variables are used only if the PPS signal discipline
+ * is configured in the kernel.
+ */
+extern int pps_shift;		/* interval duration (s) (shift) */
+extern long pps_freq;		/* pps frequency offset (scaled ppm) */
+extern long pps_jitter;		/* pps jitter (us) */
+extern long pps_stabil;		/* pps stability (scaled ppm) */
+extern long pps_jitcnt;		/* jitter limit exceeded */
+extern long pps_calcnt;		/* calibration intervals */
+extern long pps_errcnt;		/* calibration errors */
+extern long pps_stbcnt;		/* stability limit exceeded */
+#endif /* PPS_SYNC */
+
+int
+ntp_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp,
+	   void *newp, size_t newlen, struct proc *p)
+{
+	struct timeval atv;
+	struct ntptimeval ntv;
+	int s;
+
+	/* All names at this level are terminal. */
+	if (namelen != 1) {
+		return ENOTDIR;
+	}
+
+	if (name[0] != NTP_PLL_GETTIME) {
+		return EOPNOTSUPP;
+	}
+
+	s = splclock();
+#ifdef EXT_CLOCK
+	/*
+	 * The microtime() external clock routine returns a
+	 * status code. If less than zero, we declare an error
+	 * in the clock status word and return the kernel
+	 * (software) time variable. While there are other
+	 * places that call microtime(), this is the only place
+	 * that matters from an application point of view.
+	 */
+	if (microtime(&atv) < 0) {
+		time_status |= STA_CLOCKERR;
+		ntv.time = time;
+	} else {
+		time_status &= ~STA_CLOCKERR;
+	}
+#else /* EXT_CLOCK */
+	microtime(&atv);
+#endif /* EXT_CLOCK */
+	ntv.time = atv;
+	ntv.maxerror = time_maxerror;
+	ntv.esterror = time_esterror;
+	splx(s);
+	
+	ntv.time_state = time_state;
+
+	/*
+	 * Status word error decode. If any of these conditions
+	 * occur, an error is returned, instead of the status
+	 * word. Most applications will care only about the fact
+	 * the system clock may not be trusted, not about the
+	 * details.
+	 *
+	 * Hardware or software error
+	 */
+	if (time_status & (STA_UNSYNC | STA_CLOCKERR)) {
+		ntv.time_state = TIME_ERROR;
+	}
+
+	/*
+	 * PPS signal lost when either time or frequency
+	 * synchronization requested
+	 */
+	if (time_status & (STA_PPSFREQ | STA_PPSTIME) &&
+	    !(time_status & STA_PPSSIGNAL)) {
+		ntv.time_state = TIME_ERROR;
+	}
+
+	/*
+	 * PPS jitter exceeded when time synchronization
+	 * requested
+	 */
+	if (time_status & STA_PPSTIME &&
+	    time_status & STA_PPSJITTER) {
+		ntv.time_state = TIME_ERROR;
+	}
+
+	/*
+	 * PPS wander exceeded or calibration error when
+	 * frequency synchronization requested
+	 */
+	if (time_status & STA_PPSFREQ &&
+	    time_status & (STA_PPSWANDER | STA_PPSERROR)) {
+		ntv.time_state = TIME_ERROR;
+	}
+	return(sysctl_rdstruct(oldp, oldlenp, newp, &ntv, sizeof ntv));
+}
+
+/*
+ * ntp_adjtime() - NTP daemon application interface
+ */
+struct ntp_adjtime_args {
+  struct timex *tp;
+};
+
+int
+ntp_adjtime(struct proc *p, struct ntp_adjtime_args *uap, int *retval)
+{
+	struct timex ntv;
+	int modes;
+	int s;
+	int error;
+
+	error = copyin((caddr_t)uap->tp, (caddr_t)&ntv, sizeof(ntv));
+	if (error)
+		return error;
+
+	/*
+	 * Update selected clock variables - only the superuser can
+	 * change anything. Note that there is no error checking here on
+	 * the assumption the superuser should know what it is doing.
+	 */
+	modes = ntv.modes;
+	if ((modes != 0)
+	    && (error = suser(p->p_cred->pc_ucred, &p->p_acflag)))
+		return error;
+
+	s = splclock();
+	if (modes & MOD_FREQUENCY)
+#ifdef PPS_SYNC
+		time_freq = ntv.freq - pps_freq;
+#else /* PPS_SYNC */
+		time_freq = ntv.freq;
+#endif /* PPS_SYNC */
+	if (modes & MOD_MAXERROR)
+		time_maxerror = ntv.maxerror;
+	if (modes & MOD_ESTERROR)
+		time_esterror = ntv.esterror;
+	if (modes & MOD_STATUS) {
+		time_status &= STA_RONLY;
+		time_status |= ntv.status & ~STA_RONLY;
+	}
+	if (modes & MOD_TIMECONST)
+		time_constant = ntv.constant;
+	if (modes & MOD_OFFSET)
+		hardupdate(ntv.offset);
+
+	/*
+	 * Retrieve all clock variables
+	 */
+	if (time_offset < 0)
+		ntv.offset = -(-time_offset >> SHIFT_UPDATE);
+	else
+		ntv.offset = time_offset >> SHIFT_UPDATE;
+#ifdef PPS_SYNC
+	ntv.freq = time_freq + pps_freq;
+#else /* PPS_SYNC */
+	ntv.freq = time_freq;
+#endif /* PPS_SYNC */
+	ntv.maxerror = time_maxerror;
+	ntv.esterror = time_esterror;
+	ntv.status = time_status;
+	ntv.constant = time_constant;
+	ntv.precision = time_precision;
+	ntv.tolerance = time_tolerance;
+#ifdef PPS_SYNC
+	ntv.shift = pps_shift;
+	ntv.ppsfreq = pps_freq;
+	ntv.jitter = pps_jitter >> PPS_AVG;
+	ntv.stabil = pps_stabil;
+	ntv.calcnt = pps_calcnt;
+	ntv.errcnt = pps_errcnt;
+	ntv.jitcnt = pps_jitcnt;
+	ntv.stbcnt = pps_stbcnt;
+#endif /* PPS_SYNC */
+	(void)splx(s);
+
+	error = copyout((caddr_t)&ntv, (caddr_t)uap->tp, sizeof(ntv));
+	if (!error) {
+		/*
+		 * Status word error decode. See comments in
+		 * ntp_gettime() routine.
+		 */
+		retval[0] = time_state;
+		if (time_status & (STA_UNSYNC | STA_CLOCKERR))
+			retval[0] = TIME_ERROR;
+		if (time_status & (STA_PPSFREQ | STA_PPSTIME) &&
+		    !(time_status & STA_PPSSIGNAL))
+			retval[0] = TIME_ERROR;
+		if (time_status & STA_PPSTIME &&
+		    time_status & STA_PPSJITTER)
+			retval[0] = TIME_ERROR;
+		if (time_status & STA_PPSFREQ &&
+		    time_status & (STA_PPSWANDER | STA_PPSERROR))
+			retval[0] = TIME_ERROR;
+	}
+	return error;
+}
+
+
diff --git a/sys/kern/kern_sysctl.c b/sys/kern/kern_sysctl.c
index 9911879..457734d 100644
--- a/sys/kern/kern_sysctl.c
+++ b/sys/kern/kern_sysctl.c
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  *	@(#)kern_sysctl.c	8.4 (Berkeley) 4/14/94
- * $Id: kern_sysctl.c,v 1.10 1994/09/14 23:21:00 ache Exp $
+ * $Id: kern_sysctl.c,v 1.11 1994/09/16 00:53:58 ache Exp $
  */
 
 /*
@@ -64,6 +64,7 @@ extern sysctlfn vm_sysctl;
 extern sysctlfn fs_sysctl;
 extern sysctlfn net_sysctl;
 extern sysctlfn cpu_sysctl;
+extern sysctlfn ntp_sysctl;
 
 /*
  * Locking and stats
@@ -201,7 +202,8 @@ kern_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
 	extern char ostype[], osrelease[];
 
 	/* all sysctl names at this level are terminal */
-	if (namelen != 1 && !(name[0] == KERN_PROC || name[0] == KERN_PROF))
+	if (namelen != 1 && !(name[0] == KERN_PROC || name[0] == KERN_PROF
+			      || name[0] == KERN_NTP_PLL))
 		return (ENOTDIR);		/* overloaded */
 
 	switch (name[0]) {
@@ -289,6 +291,9 @@ kern_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
 #else
 		return (sysctl_rdint(oldp, oldlenp, newp, 0));
 #endif
+	case KERN_NTP_PLL:
+		return (ntp_sysctl(name + 1, namelen - 1, oldp, oldlenp,
+				   newp, newlen, p));
 	default:
 		return (EOPNOTSUPP);
 	}
diff --git a/sys/kern/kern_tc.c b/sys/kern/kern_tc.c
index 788e279..6b3f85f 100644
--- a/sys/kern/kern_tc.c
+++ b/sys/kern/kern_tc.c
@@ -36,9 +36,26 @@
  * SUCH DAMAGE.
  *
  *	@(#)kern_clock.c	8.5 (Berkeley) 1/21/94
- * $Id: kern_clock.c,v 1.4 1994/08/18 22:34:58 wollman Exp $
+ * $Id: kern_clock.c,v 1.5 1994/08/27 16:14:26 davidg Exp $
  */
 
+/* Portions of this software are covered by the following: */
+/******************************************************************************
+ *                                                                            *
+ * Copyright (c) David L. Mills 1993, 1994                                    *
+ *                                                                            *
+ * Permission to use, copy, modify, and distribute this software and its      *
+ * documentation for any purpose and without fee is hereby granted, provided  *
+ * that the above copyright notice appears in all copies and that both the    *
+ * copyright notice and this permission notice appear in supporting           *
+ * documentation, and that the name University of Delaware not be used in     *
+ * advertising or publicity pertaining to distribution of the software        *
+ * without specific, written prior permission.  The University of Delaware    *
+ * makes no representations about the suitability this software for any       *
+ * purpose.  It is provided "as is" without express or implied warranty.      *
+ *                                                                            *
+ *****************************************************************************/
+
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/dkstat.h>
@@ -46,9 +63,11 @@
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/resourcevar.h>
+#include <sys/timex.h>
 #include <vm/vm.h>
 
 #include <machine/cpu.h>
+#include <machine/clock.h>
 
 #ifdef GPROF
 #include <sys/gmon.h>
@@ -128,6 +147,238 @@ volatile struct	timeval time;
 volatile struct	timeval mono_time;
 
 /*
+ * Phase-lock loop (PLL) definitions
+ *
+ * The following variables are read and set by the ntp_adjtime() system
+ * call.
+ *
+ * time_state shows the state of the system clock, with values defined
+ * in the timex.h header file.
+ *
+ * time_status shows the status of the system clock, with bits defined
+ * in the timex.h header file.
+ *
+ * time_offset is used by the PLL to adjust the system time in small
+ * increments.
+ *
+ * time_constant determines the bandwidth or "stiffness" of the PLL.
+ *
+ * time_tolerance determines maximum frequency error or tolerance of the
+ * CPU clock oscillator and is a property of the architecture; however,
+ * in principle it could change as result of the presence of external
+ * discipline signals, for instance.
+ *
+ * time_precision is usually equal to the kernel tick variable; however,
+ * in cases where a precision clock counter or external clock is
+ * available, the resolution can be much less than this and depend on
+ * whether the external clock is working or not.
+ *
+ * time_maxerror is initialized by a ntp_adjtime() call and increased by
+ * the kernel once each second to reflect the maximum error
+ * bound growth.
+ *
+ * time_esterror is set and read by the ntp_adjtime() call, but
+ * otherwise not used by the kernel.
+ */
+int time_status = STA_UNSYNC;	/* clock status bits */
+int time_state = TIME_OK;	/* clock state */
+long time_offset = 0;		/* time offset (us) */
+long time_constant = 0;		/* pll time constant */
+long time_tolerance = MAXFREQ;	/* frequency tolerance (scaled ppm) */
+long time_precision = 1;	/* clock precision (us) */
+long time_maxerror = MAXPHASE;	/* maximum error (us) */
+long time_esterror = MAXPHASE;	/* estimated error (us) */
+
+/*
+ * The following variables establish the state of the PLL and the
+ * residual time and frequency offset of the local clock. The scale
+ * factors are defined in the timex.h header file.
+ *
+ * time_phase and time_freq are the phase increment and the frequency
+ * increment, respectively, of the kernel time variable at each tick of
+ * the clock.
+ *
+ * time_freq is set via ntp_adjtime() from a value stored in a file when
+ * the synchronization daemon is first started. Its value is retrieved
+ * via ntp_adjtime() and written to the file about once per hour by the
+ * daemon.
+ *
+ * time_adj is the adjustment added to the value of tick at each timer
+ * interrupt and is recomputed at each timer interrupt.
+ *
+ * time_reftime is the second's portion of the system time on the last
+ * call to ntp_adjtime(). It is used to adjust the time_freq variable
+ * and to increase the time_maxerror as the time since last update
+ * increases.
+ */
+long time_phase = 0;		/* phase offset (scaled us) */
+long time_freq = 0;		/* frequency offset (scaled ppm) */
+long time_adj = 0;		/* tick adjust (scaled 1 / hz) */
+long time_reftime = 0;		/* time at last adjustment (s) */
+
+#ifdef PPS_SYNC
+/*
+ * The following variables are used only if the if the kernel PPS
+ * discipline code is configured (PPS_SYNC). The scale factors are
+ * defined in the timex.h header file.
+ *
+ * pps_time contains the time at each calibration interval, as read by
+ * microtime().
+ *
+ * pps_offset is the time offset produced by the time median filter
+ * pps_tf[], while pps_jitter is the dispersion measured by this
+ * filter.
+ *
+ * pps_freq is the frequency offset produced by the frequency median
+ * filter pps_ff[], while pps_stabil is the dispersion measured by
+ * this filter.
+ *
+ * pps_usec is latched from a high resolution counter or external clock
+ * at pps_time. Here we want the hardware counter contents only, not the
+ * contents plus the time_tv.usec as usual.
+ *
+ * pps_valid counts the number of seconds since the last PPS update. It
+ * is used as a watchdog timer to disable the PPS discipline should the
+ * PPS signal be lost.
+ *
+ * pps_glitch counts the number of seconds since the beginning of an
+ * offset burst more than tick/2 from current nominal offset. It is used
+ * mainly to suppress error bursts due to priority conflicts between the
+ * PPS interrupt and timer interrupt.
+ *
+ * pps_count counts the seconds of the calibration interval, the
+ * duration of which is pps_shift in powers of two.
+ *
+ * pps_intcnt counts the calibration intervals for use in the interval-
+ * adaptation algorithm. It's just too complicated for words.
+ */
+struct timeval pps_time;	/* kernel time at last interval */
+long pps_offset = 0;		/* pps time offset (us) */
+long pps_jitter = MAXTIME;	/* pps time dispersion (jitter) (us) */
+long pps_tf[] = {0, 0, 0};	/* pps time offset median filter (us) */
+long pps_freq = 0;		/* frequency offset (scaled ppm) */
+long pps_stabil = MAXFREQ;	/* frequency dispersion (scaled ppm) */
+long pps_ff[] = {0, 0, 0};	/* frequency offset median filter */
+long pps_usec = 0;		/* microsec counter at last interval */
+long pps_valid = PPS_VALID;	/* pps signal watchdog counter */
+int pps_glitch = 0;		/* pps signal glitch counter */
+int pps_count = 0;		/* calibration interval counter (s) */
+int pps_shift = PPS_SHIFT;	/* interval duration (s) (shift) */
+int pps_intcnt = 0;		/* intervals at current duration */
+
+/*
+ * PPS signal quality monitors
+ *
+ * pps_jitcnt counts the seconds that have been discarded because the
+ * jitter measured by the time median filter exceeds the limit MAXTIME
+ * (100 us).
+ *
+ * pps_calcnt counts the frequency calibration intervals, which are
+ * variable from 4 s to 256 s.
+ *
+ * pps_errcnt counts the calibration intervals which have been discarded
+ * because the wander exceeds the limit MAXFREQ (100 ppm) or where the
+ * calibration interval jitter exceeds two ticks.
+ *
+ * pps_stbcnt counts the calibration intervals that have been discarded
+ * because the frequency wander exceeds the limit MAXFREQ / 4 (25 us).
+ */
+long pps_jitcnt = 0;		/* jitter limit exceeded */
+long pps_calcnt = 0;		/* calibration intervals */
+long pps_errcnt = 0;		/* calibration errors */
+long pps_stbcnt = 0;		/* stability limit exceeded */
+#endif /* PPS_SYNC */
+
+/* XXX none of this stuff works under FreeBSD */
+#ifdef EXT_CLOCK
+/*
+ * External clock definitions
+ *
+ * The following definitions and declarations are used only if an
+ * external clock (HIGHBALL or TPRO) is configured on the system.
+ */
+#define CLOCK_INTERVAL 30	/* CPU clock update interval (s) */
+
+/*
+ * The clock_count variable is set to CLOCK_INTERVAL at each PPS
+ * interrupt and decremented once each second.
+ */
+int clock_count = 0;		/* CPU clock counter */
+
+#ifdef HIGHBALL
+/*
+ * The clock_offset and clock_cpu variables are used by the HIGHBALL
+ * interface. The clock_offset variable defines the offset between
+ * system time and the HIGBALL counters. The clock_cpu variable contains
+ * the offset between the system clock and the HIGHBALL clock for use in
+ * disciplining the kernel time variable.
+ */
+extern struct timeval clock_offset; /* Highball clock offset */
+long clock_cpu = 0;		/* CPU clock adjust */
+#endif /* HIGHBALL */
+#endif /* EXT_CLOCK */
+
+/*
+ * hardupdate() - local clock update
+ *
+ * This routine is called by ntp_adjtime() to update the local clock
+ * phase and frequency. This is used to implement an adaptive-parameter,
+ * first-order, type-II phase-lock loop. The code computes new time and
+ * frequency offsets each time it is called. The hardclock() routine
+ * amortizes these offsets at each tick interrupt. If the kernel PPS
+ * discipline code is configured (PPS_SYNC), the PPS signal itself
+ * determines the new time offset, instead of the calling argument.
+ * Presumably, calls to ntp_adjtime() occur only when the caller
+ * believes the local clock is valid within some bound (+-128 ms with
+ * NTP). If the caller's time is far different than the PPS time, an
+ * argument will ensue, and it's not clear who will lose.
+ *
+ * For default SHIFT_UPDATE = 12, the offset is limited to +-512 ms, the
+ * maximum interval between updates is 4096 s and the maximum frequency
+ * offset is +-31.25 ms/s.
+ *
+ * Note: splclock() is in effect.
+ */
+void
+hardupdate(offset)
+	long offset;
+{
+	long ltemp, mtemp;
+
+	if (!(time_status & STA_PLL) && !(time_status & STA_PPSTIME))
+		return;
+	ltemp = offset;
+#ifdef PPS_SYNC
+	if (time_status & STA_PPSTIME && time_status & STA_PPSSIGNAL)
+		ltemp = pps_offset;
+#endif /* PPS_SYNC */
+	if (ltemp > MAXPHASE)
+		time_offset = MAXPHASE << SHIFT_UPDATE;
+	else if (ltemp < -MAXPHASE)
+		time_offset = -(MAXPHASE << SHIFT_UPDATE);
+	else
+		time_offset = ltemp << SHIFT_UPDATE;
+	mtemp = time.tv_sec - time_reftime;
+	time_reftime = time.tv_sec;
+	if (mtemp > MAXSEC)
+		mtemp = 0;
+
+	/* ugly multiply should be replaced */
+	if (ltemp < 0)
+		time_freq -= (-ltemp * mtemp) >> (time_constant +
+		    time_constant + SHIFT_KF - SHIFT_USEC);
+	else
+		time_freq += (ltemp * mtemp) >> (time_constant +
+		    time_constant + SHIFT_KF - SHIFT_USEC);
+	if (time_freq > time_tolerance)
+		time_freq = time_tolerance;
+	else if (time_freq < -time_tolerance)
+		time_freq = -time_tolerance;
+}
+
+
+
+/*
  * Initialize clock frequencies and start both clocks running.
  */
 void
@@ -207,18 +458,164 @@ hardclock(frame)
 		statclock(frame);
 
 	/*
-	 * Increment the time-of-day.  The increment is just ``tick'' unless
-	 * we are still adjusting the clock; see adjtime().
+	 * Increment the time-of-day.  
 	 */
 	ticks++;
-	if (timedelta == 0)
-		delta = tick;
-	else {
-		delta = tick + tickdelta;
-		timedelta -= tickdelta;
+	{
+		int time_update;
+		struct timeval newtime = time;
+		long ltemp;
+
+		if (timedelta == 0) {
+		  time_update = tick;
+		} else {
+			if (timedelta < 0) {
+				time_update = tick - tickdelta;
+				timedelta += tickdelta;
+			} else {
+				time_update = tick + tickdelta;
+				timedelta -= tickdelta;
+			}
+		}
+		BUMPTIME(&mono_time, time_update);
+
+		/*
+		 * Compute the phase adjustment. If the low-order bits
+		 * (time_phase) of the update overflow, bump the high-order bits
+		 * (time_update).
+		 */
+		time_phase += time_adj;
+		if (time_phase <= -FINEUSEC) {
+		  ltemp = -time_phase >> SHIFT_SCALE;
+		  time_phase += ltemp << SHIFT_SCALE;
+		  time_update -= ltemp;
+		}
+		else if (time_phase >= FINEUSEC) {
+		  ltemp = time_phase >> SHIFT_SCALE;
+		  time_phase -= ltemp << SHIFT_SCALE;
+		  time_update += ltemp;
+		}
+
+		newtime.tv_usec += time_update;
+		/*
+		 * On rollover of the second the phase adjustment to be used for
+		 * the next second is calculated. Also, the maximum error is
+		 * increased by the tolerance. If the PPS frequency discipline
+		 * code is present, the phase is increased to compensate for the
+		 * CPU clock oscillator frequency error.
+		 *
+		 * With SHIFT_SCALE = 23, the maximum frequency adjustment is
+		 * +-256 us per tick, or 25.6 ms/s at a clock frequency of 100
+		 * Hz. The time contribution is shifted right a minimum of two
+		 * bits, while the frequency contribution is a right shift.
+		 * Thus, overflow is prevented if the frequency contribution is
+		 * limited to half the maximum or 15.625 ms/s.
+		 */
+		if (newtime.tv_usec >= 1000000) {
+		  newtime.tv_usec -= 1000000;
+		  newtime.tv_sec++;
+		  time_maxerror += time_tolerance >> SHIFT_USEC;
+		  if (time_offset < 0) {
+		    ltemp = -time_offset >>
+		      (SHIFT_KG + time_constant);
+		    time_offset += ltemp;
+		    time_adj = -ltemp <<
+		      (SHIFT_SCALE - SHIFT_HZ - SHIFT_UPDATE);
+		  } else {
+		    ltemp = time_offset >>
+		      (SHIFT_KG + time_constant);
+		    time_offset -= ltemp;
+		    time_adj = ltemp <<
+		      (SHIFT_SCALE - SHIFT_HZ - SHIFT_UPDATE);
+		  }
+#ifdef PPS_SYNC
+		  /*
+		   * Gnaw on the watchdog counter and update the frequency
+		   * computed by the pll and the PPS signal.
+		   */
+		  pps_valid++;
+		  if (pps_valid == PPS_VALID) {
+		    pps_jitter = MAXTIME;
+		    pps_stabil = MAXFREQ;
+		    time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
+				     STA_PPSWANDER | STA_PPSERROR);
+		  }
+		  ltemp = time_freq + pps_freq;
+#else
+		  ltemp = time_freq;
+#endif /* PPS_SYNC */
+		  if (ltemp < 0)
+		    time_adj -= -ltemp >>
+		      (SHIFT_USEC + SHIFT_HZ - SHIFT_SCALE);
+		  else
+		    time_adj += ltemp >>
+		      (SHIFT_USEC + SHIFT_HZ - SHIFT_SCALE);
+
+		  /*
+		   * When the CPU clock oscillator frequency is not a
+		   * power of two in Hz, the SHIFT_HZ is only an
+		   * approximate scale factor. In the SunOS kernel, this
+		   * results in a PLL gain factor of 1/1.28 = 0.78 what it
+		   * should be. In the following code the overall gain is
+		   * increased by a factor of 1.25, which results in a
+		   * residual error less than 3 percent.
+		   */
+		  /* Same thing applies for FreeBSD --GAW */
+		  if (hz == 100) {
+		    if (time_adj < 0)
+		      time_adj -= -time_adj >> 2;
+		    else
+		      time_adj += time_adj >> 2;
+		  }
+
+		  /* XXX - this is really bogus, but can't be fixed until
+		     xntpd's idea of the system clock is fixed to know how
+		     the user wants leap seconds handled; in the mean time,
+		     we assume that users of NTP are running without proper
+		     leap second support (this is now the default anyway) */
+		  /*
+		   * 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 (newtime.tv_sec % 86400 == 0) {
+		      newtime.tv_sec--;
+		      time_state = TIME_OOP;
+		    }
+		    break;
+
+		  case TIME_DEL:
+		    if ((newtime.tv_sec + 1) % 86400 == 0) {
+		      newtime.tv_sec++;
+		      time_state = TIME_WAIT;
+		    }
+		    break;
+		    
+		  case TIME_OOP:
+		    time_state = TIME_WAIT;
+		    break;
+		    
+		  case TIME_WAIT:
+		    if (!(time_status & (STA_INS | STA_DEL)))
+		      time_state = TIME_OK;
+		  }
+		}
+		CPU_CLOCKUPDATE(&time, &newtime);
 	}
-	BUMPTIME(&time, delta);
-	BUMPTIME(&mono_time, delta);
 
 	/*
 	 * Process callouts at a very low cpu priority, so we don't keep the
@@ -563,3 +960,171 @@ sysctl_clockrate(where, sizep)
 	clkinfo.stathz = stathz ? stathz : hz;
 	return (sysctl_rdstruct(where, sizep, NULL, &clkinfo, sizeof(clkinfo)));
 }
+
+/*#ifdef PPS_SYNC*/
+#if 0
+/* This code is completely bogus; if anybody ever wants to use it, get
+ * the current version from Dave Mills. */
+
+/*
+ * hardpps() - discipline CPU clock oscillator to external pps signal
+ *
+ * This routine is called at each PPS interrupt in order to discipline
+ * the CPU clock oscillator to the PPS signal. It integrates successive
+ * phase differences between the two oscillators and calculates the
+ * frequency offset. This is used in hardclock() to discipline the CPU
+ * clock oscillator so that intrinsic frequency error is cancelled out.
+ * The code requires the caller to capture the time and hardware
+ * counter value at the designated PPS signal transition.
+ */
+void
+hardpps(tvp, usec)
+	struct timeval *tvp;		/* time at PPS */
+	long usec;			/* hardware counter at PPS */
+{
+	long u_usec, v_usec, bigtick;
+	long cal_sec, cal_usec;
+
+	/*
+	 * During the calibration interval adjust the starting time when
+	 * the tick overflows. At the end of the interval compute the
+	 * duration of the interval and the difference of the hardware
+	 * counters at the beginning and end of the interval. This code
+	 * is deliciously complicated by the fact valid differences may
+	 * exceed the value of tick when using long calibration
+	 * intervals and small ticks. Note that the counter can be
+	 * greater than tick if caught at just the wrong instant, but
+	 * the values returned and used here are correct.
+	 */
+	bigtick = (long)tick << SHIFT_USEC;
+	pps_usec -= ntp_pll.ybar;
+	if (pps_usec >= bigtick)
+		pps_usec -= bigtick;
+	if (pps_usec < 0)
+		pps_usec += bigtick;
+	pps_time.tv_sec++;
+	pps_count++;
+	if (pps_count < (1 << pps_shift))
+		return;
+	pps_count = 0;
+	ntp_pll.calcnt++;
+	u_usec = usec << SHIFT_USEC;
+	v_usec = pps_usec - u_usec;
+	if (v_usec >= bigtick >> 1)
+		v_usec -= bigtick;
+	if (v_usec < -(bigtick >> 1))
+		v_usec += bigtick;
+	if (v_usec < 0)
+		v_usec = -(-v_usec >> ntp_pll.shift);
+	else
+		v_usec = v_usec >> ntp_pll.shift;
+	pps_usec = u_usec;
+	cal_sec = tvp->tv_sec;
+	cal_usec = tvp->tv_usec;
+	cal_sec -= pps_time.tv_sec;
+	cal_usec -= pps_time.tv_usec;
+	if (cal_usec < 0) {
+		cal_usec += 1000000;
+		cal_sec--;
+	}
+	pps_time = *tvp;
+
+	/*
+	 * Check for lost interrupts, noise, excessive jitter and
+	 * excessive frequency error. The number of timer ticks during
+	 * the interval may vary +-1 tick. Add to this a margin of one
+	 * tick for the PPS signal jitter and maximum frequency
+	 * deviation. If the limits are exceeded, the calibration
+	 * interval is reset to the minimum and we start over.
+	 */
+	u_usec = (long)tick << 1;
+	if (!((cal_sec == -1 && cal_usec > (1000000 - u_usec))
+	    || (cal_sec == 0 && cal_usec < u_usec))
+	    || v_usec > ntp_pll.tolerance || v_usec < -ntp_pll.tolerance) {
+		ntp_pll.jitcnt++;
+		ntp_pll.shift = NTP_PLL.SHIFT;
+		pps_dispinc = PPS_DISPINC;
+		ntp_pll.intcnt = 0;
+		return;
+	}
+
+	/*
+	 * A three-stage median filter is used to help deglitch the pps
+	 * signal. The median sample becomes the offset estimate; the
+	 * difference between the other two samples becomes the
+	 * dispersion estimate.
+	 */
+	pps_mf[2] = pps_mf[1];
+	pps_mf[1] = pps_mf[0];
+	pps_mf[0] = v_usec;
+	if (pps_mf[0] > pps_mf[1]) {
+		if (pps_mf[1] > pps_mf[2]) {
+			u_usec = pps_mf[1];		/* 0 1 2 */
+			v_usec = pps_mf[0] - pps_mf[2];
+		} else if (pps_mf[2] > pps_mf[0]) {
+			u_usec = pps_mf[0];		/* 2 0 1 */
+			v_usec = pps_mf[2] - pps_mf[1];
+		} else {
+			u_usec = pps_mf[2];		/* 0 2 1 */
+			v_usec = pps_mf[0] - pps_mf[1];
+		}
+	} else {
+		if (pps_mf[1] < pps_mf[2]) {
+			u_usec = pps_mf[1];		/* 2 1 0 */
+			v_usec = pps_mf[2] - pps_mf[0];
+		} else  if (pps_mf[2] < pps_mf[0]) {
+			u_usec = pps_mf[0];		/* 1 0 2 */
+			v_usec = pps_mf[1] - pps_mf[2];
+		} else {
+			u_usec = pps_mf[2];		/* 1 2 0 */
+			v_usec = pps_mf[1] - pps_mf[0];
+		}
+	}
+
+	/*
+	 * Here the dispersion average is updated. If it is less than
+	 * the threshold pps_dispmax, the frequency average is updated
+	 * as well, but clamped to the tolerance.
+	 */
+	v_usec = (v_usec >> 1) - ntp_pll.disp;
+	if (v_usec < 0)
+		ntp_pll.disp -= -v_usec >> PPS_AVG;
+	else
+		ntp_pll.disp += v_usec >> PPS_AVG;
+	if (ntp_pll.disp > pps_dispmax) {
+		ntp_pll.discnt++;
+		return;
+	}
+	if (u_usec < 0) {
+		ntp_pll.ybar -= -u_usec >> PPS_AVG;
+		if (ntp_pll.ybar < -ntp_pll.tolerance)
+			ntp_pll.ybar = -ntp_pll.tolerance;
+		u_usec = -u_usec;
+	} else {
+		ntp_pll.ybar += u_usec >> PPS_AVG;
+		if (ntp_pll.ybar > ntp_pll.tolerance)
+			ntp_pll.ybar = ntp_pll.tolerance;
+	}
+
+	/*
+	 * Here the calibration interval is adjusted. If the maximum
+	 * time difference is greater than tick/4, reduce the interval
+	 * by half. If this is not the case for four consecutive
+	 * intervals, double the interval.
+	 */
+	if (u_usec << ntp_pll.shift > bigtick >> 2) {
+		ntp_pll.intcnt = 0;
+		if (ntp_pll.shift > NTP_PLL.SHIFT) {
+			ntp_pll.shift--;
+			pps_dispinc <<= 1;
+		}
+	} else if (ntp_pll.intcnt >= 4) {
+		ntp_pll.intcnt = 0;
+		if (ntp_pll.shift < NTP_PLL.SHIFTMAX) {
+			ntp_pll.shift++;
+			pps_dispinc >>= 1;
+		}
+	} else
+		ntp_pll.intcnt++;
+}
+#endif /* PPS_SYNC */
diff --git a/sys/kern/kern_timeout.c b/sys/kern/kern_timeout.c
index 788e279..6b3f85f 100644
--- a/sys/kern/kern_timeout.c
+++ b/sys/kern/kern_timeout.c
@@ -36,9 +36,26 @@
  * SUCH DAMAGE.
  *
  *	@(#)kern_clock.c	8.5 (Berkeley) 1/21/94
- * $Id: kern_clock.c,v 1.4 1994/08/18 22:34:58 wollman Exp $
+ * $Id: kern_clock.c,v 1.5 1994/08/27 16:14:26 davidg Exp $
  */
 
+/* Portions of this software are covered by the following: */
+/******************************************************************************
+ *                                                                            *
+ * Copyright (c) David L. Mills 1993, 1994                                    *
+ *                                                                            *
+ * Permission to use, copy, modify, and distribute this software and its      *
+ * documentation for any purpose and without fee is hereby granted, provided  *
+ * that the above copyright notice appears in all copies and that both the    *
+ * copyright notice and this permission notice appear in supporting           *
+ * documentation, and that the name University of Delaware not be used in     *
+ * advertising or publicity pertaining to distribution of the software        *
+ * without specific, written prior permission.  The University of Delaware    *
+ * makes no representations about the suitability this software for any       *
+ * purpose.  It is provided "as is" without express or implied warranty.      *
+ *                                                                            *
+ *****************************************************************************/
+
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/dkstat.h>
@@ -46,9 +63,11 @@
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/resourcevar.h>
+#include <sys/timex.h>
 #include <vm/vm.h>
 
 #include <machine/cpu.h>
+#include <machine/clock.h>
 
 #ifdef GPROF
 #include <sys/gmon.h>
@@ -128,6 +147,238 @@ volatile struct	timeval time;
 volatile struct	timeval mono_time;
 
 /*
+ * Phase-lock loop (PLL) definitions
+ *
+ * The following variables are read and set by the ntp_adjtime() system
+ * call.
+ *
+ * time_state shows the state of the system clock, with values defined
+ * in the timex.h header file.
+ *
+ * time_status shows the status of the system clock, with bits defined
+ * in the timex.h header file.
+ *
+ * time_offset is used by the PLL to adjust the system time in small
+ * increments.
+ *
+ * time_constant determines the bandwidth or "stiffness" of the PLL.
+ *
+ * time_tolerance determines maximum frequency error or tolerance of the
+ * CPU clock oscillator and is a property of the architecture; however,
+ * in principle it could change as result of the presence of external
+ * discipline signals, for instance.
+ *
+ * time_precision is usually equal to the kernel tick variable; however,
+ * in cases where a precision clock counter or external clock is
+ * available, the resolution can be much less than this and depend on
+ * whether the external clock is working or not.
+ *
+ * time_maxerror is initialized by a ntp_adjtime() call and increased by
+ * the kernel once each second to reflect the maximum error
+ * bound growth.
+ *
+ * time_esterror is set and read by the ntp_adjtime() call, but
+ * otherwise not used by the kernel.
+ */
+int time_status = STA_UNSYNC;	/* clock status bits */
+int time_state = TIME_OK;	/* clock state */
+long time_offset = 0;		/* time offset (us) */
+long time_constant = 0;		/* pll time constant */
+long time_tolerance = MAXFREQ;	/* frequency tolerance (scaled ppm) */
+long time_precision = 1;	/* clock precision (us) */
+long time_maxerror = MAXPHASE;	/* maximum error (us) */
+long time_esterror = MAXPHASE;	/* estimated error (us) */
+
+/*
+ * The following variables establish the state of the PLL and the
+ * residual time and frequency offset of the local clock. The scale
+ * factors are defined in the timex.h header file.
+ *
+ * time_phase and time_freq are the phase increment and the frequency
+ * increment, respectively, of the kernel time variable at each tick of
+ * the clock.
+ *
+ * time_freq is set via ntp_adjtime() from a value stored in a file when
+ * the synchronization daemon is first started. Its value is retrieved
+ * via ntp_adjtime() and written to the file about once per hour by the
+ * daemon.
+ *
+ * time_adj is the adjustment added to the value of tick at each timer
+ * interrupt and is recomputed at each timer interrupt.
+ *
+ * time_reftime is the second's portion of the system time on the last
+ * call to ntp_adjtime(). It is used to adjust the time_freq variable
+ * and to increase the time_maxerror as the time since last update
+ * increases.
+ */
+long time_phase = 0;		/* phase offset (scaled us) */
+long time_freq = 0;		/* frequency offset (scaled ppm) */
+long time_adj = 0;		/* tick adjust (scaled 1 / hz) */
+long time_reftime = 0;		/* time at last adjustment (s) */
+
+#ifdef PPS_SYNC
+/*
+ * The following variables are used only if the if the kernel PPS
+ * discipline code is configured (PPS_SYNC). The scale factors are
+ * defined in the timex.h header file.
+ *
+ * pps_time contains the time at each calibration interval, as read by
+ * microtime().
+ *
+ * pps_offset is the time offset produced by the time median filter
+ * pps_tf[], while pps_jitter is the dispersion measured by this
+ * filter.
+ *
+ * pps_freq is the frequency offset produced by the frequency median
+ * filter pps_ff[], while pps_stabil is the dispersion measured by
+ * this filter.
+ *
+ * pps_usec is latched from a high resolution counter or external clock
+ * at pps_time. Here we want the hardware counter contents only, not the
+ * contents plus the time_tv.usec as usual.
+ *
+ * pps_valid counts the number of seconds since the last PPS update. It
+ * is used as a watchdog timer to disable the PPS discipline should the
+ * PPS signal be lost.
+ *
+ * pps_glitch counts the number of seconds since the beginning of an
+ * offset burst more than tick/2 from current nominal offset. It is used
+ * mainly to suppress error bursts due to priority conflicts between the
+ * PPS interrupt and timer interrupt.
+ *
+ * pps_count counts the seconds of the calibration interval, the
+ * duration of which is pps_shift in powers of two.
+ *
+ * pps_intcnt counts the calibration intervals for use in the interval-
+ * adaptation algorithm. It's just too complicated for words.
+ */
+struct timeval pps_time;	/* kernel time at last interval */
+long pps_offset = 0;		/* pps time offset (us) */
+long pps_jitter = MAXTIME;	/* pps time dispersion (jitter) (us) */
+long pps_tf[] = {0, 0, 0};	/* pps time offset median filter (us) */
+long pps_freq = 0;		/* frequency offset (scaled ppm) */
+long pps_stabil = MAXFREQ;	/* frequency dispersion (scaled ppm) */
+long pps_ff[] = {0, 0, 0};	/* frequency offset median filter */
+long pps_usec = 0;		/* microsec counter at last interval */
+long pps_valid = PPS_VALID;	/* pps signal watchdog counter */
+int pps_glitch = 0;		/* pps signal glitch counter */
+int pps_count = 0;		/* calibration interval counter (s) */
+int pps_shift = PPS_SHIFT;	/* interval duration (s) (shift) */
+int pps_intcnt = 0;		/* intervals at current duration */
+
+/*
+ * PPS signal quality monitors
+ *
+ * pps_jitcnt counts the seconds that have been discarded because the
+ * jitter measured by the time median filter exceeds the limit MAXTIME
+ * (100 us).
+ *
+ * pps_calcnt counts the frequency calibration intervals, which are
+ * variable from 4 s to 256 s.
+ *
+ * pps_errcnt counts the calibration intervals which have been discarded
+ * because the wander exceeds the limit MAXFREQ (100 ppm) or where the
+ * calibration interval jitter exceeds two ticks.
+ *
+ * pps_stbcnt counts the calibration intervals that have been discarded
+ * because the frequency wander exceeds the limit MAXFREQ / 4 (25 us).
+ */
+long pps_jitcnt = 0;		/* jitter limit exceeded */
+long pps_calcnt = 0;		/* calibration intervals */
+long pps_errcnt = 0;		/* calibration errors */
+long pps_stbcnt = 0;		/* stability limit exceeded */
+#endif /* PPS_SYNC */
+
+/* XXX none of this stuff works under FreeBSD */
+#ifdef EXT_CLOCK
+/*
+ * External clock definitions
+ *
+ * The following definitions and declarations are used only if an
+ * external clock (HIGHBALL or TPRO) is configured on the system.
+ */
+#define CLOCK_INTERVAL 30	/* CPU clock update interval (s) */
+
+/*
+ * The clock_count variable is set to CLOCK_INTERVAL at each PPS
+ * interrupt and decremented once each second.
+ */
+int clock_count = 0;		/* CPU clock counter */
+
+#ifdef HIGHBALL
+/*
+ * The clock_offset and clock_cpu variables are used by the HIGHBALL
+ * interface. The clock_offset variable defines the offset between
+ * system time and the HIGBALL counters. The clock_cpu variable contains
+ * the offset between the system clock and the HIGHBALL clock for use in
+ * disciplining the kernel time variable.
+ */
+extern struct timeval clock_offset; /* Highball clock offset */
+long clock_cpu = 0;		/* CPU clock adjust */
+#endif /* HIGHBALL */
+#endif /* EXT_CLOCK */
+
+/*
+ * hardupdate() - local clock update
+ *
+ * This routine is called by ntp_adjtime() to update the local clock
+ * phase and frequency. This is used to implement an adaptive-parameter,
+ * first-order, type-II phase-lock loop. The code computes new time and
+ * frequency offsets each time it is called. The hardclock() routine
+ * amortizes these offsets at each tick interrupt. If the kernel PPS
+ * discipline code is configured (PPS_SYNC), the PPS signal itself
+ * determines the new time offset, instead of the calling argument.
+ * Presumably, calls to ntp_adjtime() occur only when the caller
+ * believes the local clock is valid within some bound (+-128 ms with
+ * NTP). If the caller's time is far different than the PPS time, an
+ * argument will ensue, and it's not clear who will lose.
+ *
+ * For default SHIFT_UPDATE = 12, the offset is limited to +-512 ms, the
+ * maximum interval between updates is 4096 s and the maximum frequency
+ * offset is +-31.25 ms/s.
+ *
+ * Note: splclock() is in effect.
+ */
+void
+hardupdate(offset)
+	long offset;
+{
+	long ltemp, mtemp;
+
+	if (!(time_status & STA_PLL) && !(time_status & STA_PPSTIME))
+		return;
+	ltemp = offset;
+#ifdef PPS_SYNC
+	if (time_status & STA_PPSTIME && time_status & STA_PPSSIGNAL)
+		ltemp = pps_offset;
+#endif /* PPS_SYNC */
+	if (ltemp > MAXPHASE)
+		time_offset = MAXPHASE << SHIFT_UPDATE;
+	else if (ltemp < -MAXPHASE)
+		time_offset = -(MAXPHASE << SHIFT_UPDATE);
+	else
+		time_offset = ltemp << SHIFT_UPDATE;
+	mtemp = time.tv_sec - time_reftime;
+	time_reftime = time.tv_sec;
+	if (mtemp > MAXSEC)
+		mtemp = 0;
+
+	/* ugly multiply should be replaced */
+	if (ltemp < 0)
+		time_freq -= (-ltemp * mtemp) >> (time_constant +
+		    time_constant + SHIFT_KF - SHIFT_USEC);
+	else
+		time_freq += (ltemp * mtemp) >> (time_constant +
+		    time_constant + SHIFT_KF - SHIFT_USEC);
+	if (time_freq > time_tolerance)
+		time_freq = time_tolerance;
+	else if (time_freq < -time_tolerance)
+		time_freq = -time_tolerance;
+}
+
+
+
+/*
  * Initialize clock frequencies and start both clocks running.
  */
 void
@@ -207,18 +458,164 @@ hardclock(frame)
 		statclock(frame);
 
 	/*
-	 * Increment the time-of-day.  The increment is just ``tick'' unless
-	 * we are still adjusting the clock; see adjtime().
+	 * Increment the time-of-day.  
 	 */
 	ticks++;
-	if (timedelta == 0)
-		delta = tick;
-	else {
-		delta = tick + tickdelta;
-		timedelta -= tickdelta;
+	{
+		int time_update;
+		struct timeval newtime = time;
+		long ltemp;
+
+		if (timedelta == 0) {
+		  time_update = tick;
+		} else {
+			if (timedelta < 0) {
+				time_update = tick - tickdelta;
+				timedelta += tickdelta;
+			} else {
+				time_update = tick + tickdelta;
+				timedelta -= tickdelta;
+			}
+		}
+		BUMPTIME(&mono_time, time_update);
+
+		/*
+		 * Compute the phase adjustment. If the low-order bits
+		 * (time_phase) of the update overflow, bump the high-order bits
+		 * (time_update).
+		 */
+		time_phase += time_adj;
+		if (time_phase <= -FINEUSEC) {
+		  ltemp = -time_phase >> SHIFT_SCALE;
+		  time_phase += ltemp << SHIFT_SCALE;
+		  time_update -= ltemp;
+		}
+		else if (time_phase >= FINEUSEC) {
+		  ltemp = time_phase >> SHIFT_SCALE;
+		  time_phase -= ltemp << SHIFT_SCALE;
+		  time_update += ltemp;
+		}
+
+		newtime.tv_usec += time_update;
+		/*
+		 * On rollover of the second the phase adjustment to be used for
+		 * the next second is calculated. Also, the maximum error is
+		 * increased by the tolerance. If the PPS frequency discipline
+		 * code is present, the phase is increased to compensate for the
+		 * CPU clock oscillator frequency error.
+		 *
+		 * With SHIFT_SCALE = 23, the maximum frequency adjustment is
+		 * +-256 us per tick, or 25.6 ms/s at a clock frequency of 100
+		 * Hz. The time contribution is shifted right a minimum of two
+		 * bits, while the frequency contribution is a right shift.
+		 * Thus, overflow is prevented if the frequency contribution is
+		 * limited to half the maximum or 15.625 ms/s.
+		 */
+		if (newtime.tv_usec >= 1000000) {
+		  newtime.tv_usec -= 1000000;
+		  newtime.tv_sec++;
+		  time_maxerror += time_tolerance >> SHIFT_USEC;
+		  if (time_offset < 0) {
+		    ltemp = -time_offset >>
+		      (SHIFT_KG + time_constant);
+		    time_offset += ltemp;
+		    time_adj = -ltemp <<
+		      (SHIFT_SCALE - SHIFT_HZ - SHIFT_UPDATE);
+		  } else {
+		    ltemp = time_offset >>
+		      (SHIFT_KG + time_constant);
+		    time_offset -= ltemp;
+		    time_adj = ltemp <<
+		      (SHIFT_SCALE - SHIFT_HZ - SHIFT_UPDATE);
+		  }
+#ifdef PPS_SYNC
+		  /*
+		   * Gnaw on the watchdog counter and update the frequency
+		   * computed by the pll and the PPS signal.
+		   */
+		  pps_valid++;
+		  if (pps_valid == PPS_VALID) {
+		    pps_jitter = MAXTIME;
+		    pps_stabil = MAXFREQ;
+		    time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
+				     STA_PPSWANDER | STA_PPSERROR);
+		  }
+		  ltemp = time_freq + pps_freq;
+#else
+		  ltemp = time_freq;
+#endif /* PPS_SYNC */
+		  if (ltemp < 0)
+		    time_adj -= -ltemp >>
+		      (SHIFT_USEC + SHIFT_HZ - SHIFT_SCALE);
+		  else
+		    time_adj += ltemp >>
+		      (SHIFT_USEC + SHIFT_HZ - SHIFT_SCALE);
+
+		  /*
+		   * When the CPU clock oscillator frequency is not a
+		   * power of two in Hz, the SHIFT_HZ is only an
+		   * approximate scale factor. In the SunOS kernel, this
+		   * results in a PLL gain factor of 1/1.28 = 0.78 what it
+		   * should be. In the following code the overall gain is
+		   * increased by a factor of 1.25, which results in a
+		   * residual error less than 3 percent.
+		   */
+		  /* Same thing applies for FreeBSD --GAW */
+		  if (hz == 100) {
+		    if (time_adj < 0)
+		      time_adj -= -time_adj >> 2;
+		    else
+		      time_adj += time_adj >> 2;
+		  }
+
+		  /* XXX - this is really bogus, but can't be fixed until
+		     xntpd's idea of the system clock is fixed to know how
+		     the user wants leap seconds handled; in the mean time,
+		     we assume that users of NTP are running without proper
+		     leap second support (this is now the default anyway) */
+		  /*
+		   * 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 (newtime.tv_sec % 86400 == 0) {
+		      newtime.tv_sec--;
+		      time_state = TIME_OOP;
+		    }
+		    break;
+
+		  case TIME_DEL:
+		    if ((newtime.tv_sec + 1) % 86400 == 0) {
+		      newtime.tv_sec++;
+		      time_state = TIME_WAIT;
+		    }
+		    break;
+		    
+		  case TIME_OOP:
+		    time_state = TIME_WAIT;
+		    break;
+		    
+		  case TIME_WAIT:
+		    if (!(time_status & (STA_INS | STA_DEL)))
+		      time_state = TIME_OK;
+		  }
+		}
+		CPU_CLOCKUPDATE(&time, &newtime);
 	}
-	BUMPTIME(&time, delta);
-	BUMPTIME(&mono_time, delta);
 
 	/*
 	 * Process callouts at a very low cpu priority, so we don't keep the
@@ -563,3 +960,171 @@ sysctl_clockrate(where, sizep)
 	clkinfo.stathz = stathz ? stathz : hz;
 	return (sysctl_rdstruct(where, sizep, NULL, &clkinfo, sizeof(clkinfo)));
 }
+
+/*#ifdef PPS_SYNC*/
+#if 0
+/* This code is completely bogus; if anybody ever wants to use it, get
+ * the current version from Dave Mills. */
+
+/*
+ * hardpps() - discipline CPU clock oscillator to external pps signal
+ *
+ * This routine is called at each PPS interrupt in order to discipline
+ * the CPU clock oscillator to the PPS signal. It integrates successive
+ * phase differences between the two oscillators and calculates the
+ * frequency offset. This is used in hardclock() to discipline the CPU
+ * clock oscillator so that intrinsic frequency error is cancelled out.
+ * The code requires the caller to capture the time and hardware
+ * counter value at the designated PPS signal transition.
+ */
+void
+hardpps(tvp, usec)
+	struct timeval *tvp;		/* time at PPS */
+	long usec;			/* hardware counter at PPS */
+{
+	long u_usec, v_usec, bigtick;
+	long cal_sec, cal_usec;
+
+	/*
+	 * During the calibration interval adjust the starting time when
+	 * the tick overflows. At the end of the interval compute the
+	 * duration of the interval and the difference of the hardware
+	 * counters at the beginning and end of the interval. This code
+	 * is deliciously complicated by the fact valid differences may
+	 * exceed the value of tick when using long calibration
+	 * intervals and small ticks. Note that the counter can be
+	 * greater than tick if caught at just the wrong instant, but
+	 * the values returned and used here are correct.
+	 */
+	bigtick = (long)tick << SHIFT_USEC;
+	pps_usec -= ntp_pll.ybar;
+	if (pps_usec >= bigtick)
+		pps_usec -= bigtick;
+	if (pps_usec < 0)
+		pps_usec += bigtick;
+	pps_time.tv_sec++;
+	pps_count++;
+	if (pps_count < (1 << pps_shift))
+		return;
+	pps_count = 0;
+	ntp_pll.calcnt++;
+	u_usec = usec << SHIFT_USEC;
+	v_usec = pps_usec - u_usec;
+	if (v_usec >= bigtick >> 1)
+		v_usec -= bigtick;
+	if (v_usec < -(bigtick >> 1))
+		v_usec += bigtick;
+	if (v_usec < 0)
+		v_usec = -(-v_usec >> ntp_pll.shift);
+	else
+		v_usec = v_usec >> ntp_pll.shift;
+	pps_usec = u_usec;
+	cal_sec = tvp->tv_sec;
+	cal_usec = tvp->tv_usec;
+	cal_sec -= pps_time.tv_sec;
+	cal_usec -= pps_time.tv_usec;
+	if (cal_usec < 0) {
+		cal_usec += 1000000;
+		cal_sec--;
+	}
+	pps_time = *tvp;
+
+	/*
+	 * Check for lost interrupts, noise, excessive jitter and
+	 * excessive frequency error. The number of timer ticks during
+	 * the interval may vary +-1 tick. Add to this a margin of one
+	 * tick for the PPS signal jitter and maximum frequency
+	 * deviation. If the limits are exceeded, the calibration
+	 * interval is reset to the minimum and we start over.
+	 */
+	u_usec = (long)tick << 1;
+	if (!((cal_sec == -1 && cal_usec > (1000000 - u_usec))
+	    || (cal_sec == 0 && cal_usec < u_usec))
+	    || v_usec > ntp_pll.tolerance || v_usec < -ntp_pll.tolerance) {
+		ntp_pll.jitcnt++;
+		ntp_pll.shift = NTP_PLL.SHIFT;
+		pps_dispinc = PPS_DISPINC;
+		ntp_pll.intcnt = 0;
+		return;
+	}
+
+	/*
+	 * A three-stage median filter is used to help deglitch the pps
+	 * signal. The median sample becomes the offset estimate; the
+	 * difference between the other two samples becomes the
+	 * dispersion estimate.
+	 */
+	pps_mf[2] = pps_mf[1];
+	pps_mf[1] = pps_mf[0];
+	pps_mf[0] = v_usec;
+	if (pps_mf[0] > pps_mf[1]) {
+		if (pps_mf[1] > pps_mf[2]) {
+			u_usec = pps_mf[1];		/* 0 1 2 */
+			v_usec = pps_mf[0] - pps_mf[2];
+		} else if (pps_mf[2] > pps_mf[0]) {
+			u_usec = pps_mf[0];		/* 2 0 1 */
+			v_usec = pps_mf[2] - pps_mf[1];
+		} else {
+			u_usec = pps_mf[2];		/* 0 2 1 */
+			v_usec = pps_mf[0] - pps_mf[1];
+		}
+	} else {
+		if (pps_mf[1] < pps_mf[2]) {
+			u_usec = pps_mf[1];		/* 2 1 0 */
+			v_usec = pps_mf[2] - pps_mf[0];
+		} else  if (pps_mf[2] < pps_mf[0]) {
+			u_usec = pps_mf[0];		/* 1 0 2 */
+			v_usec = pps_mf[1] - pps_mf[2];
+		} else {
+			u_usec = pps_mf[2];		/* 1 2 0 */
+			v_usec = pps_mf[1] - pps_mf[0];
+		}
+	}
+
+	/*
+	 * Here the dispersion average is updated. If it is less than
+	 * the threshold pps_dispmax, the frequency average is updated
+	 * as well, but clamped to the tolerance.
+	 */
+	v_usec = (v_usec >> 1) - ntp_pll.disp;
+	if (v_usec < 0)
+		ntp_pll.disp -= -v_usec >> PPS_AVG;
+	else
+		ntp_pll.disp += v_usec >> PPS_AVG;
+	if (ntp_pll.disp > pps_dispmax) {
+		ntp_pll.discnt++;
+		return;
+	}
+	if (u_usec < 0) {
+		ntp_pll.ybar -= -u_usec >> PPS_AVG;
+		if (ntp_pll.ybar < -ntp_pll.tolerance)
+			ntp_pll.ybar = -ntp_pll.tolerance;
+		u_usec = -u_usec;
+	} else {
+		ntp_pll.ybar += u_usec >> PPS_AVG;
+		if (ntp_pll.ybar > ntp_pll.tolerance)
+			ntp_pll.ybar = ntp_pll.tolerance;
+	}
+
+	/*
+	 * Here the calibration interval is adjusted. If the maximum
+	 * time difference is greater than tick/4, reduce the interval
+	 * by half. If this is not the case for four consecutive
+	 * intervals, double the interval.
+	 */
+	if (u_usec << ntp_pll.shift > bigtick >> 2) {
+		ntp_pll.intcnt = 0;
+		if (ntp_pll.shift > NTP_PLL.SHIFT) {
+			ntp_pll.shift--;
+			pps_dispinc <<= 1;
+		}
+	} else if (ntp_pll.intcnt >= 4) {
+		ntp_pll.intcnt = 0;
+		if (ntp_pll.shift < NTP_PLL.SHIFTMAX) {
+			ntp_pll.shift++;
+			pps_dispinc >>= 1;
+		}
+	} else
+		ntp_pll.intcnt++;
+}
+#endif /* PPS_SYNC */
diff --git a/sys/kern/syscalls.c b/sys/kern/syscalls.c
index 9050b01..edf4b58 100644
--- a/sys/kern/syscalls.c
+++ b/sys/kern/syscalls.c
@@ -2,7 +2,7 @@
  * System call names.
  *
  * DO NOT EDIT-- this file is automatically generated.
- * created from	$Id: syscalls.master,v 1.7 1994/09/13 00:48:19 wollman Exp $
+ * created from	$Id: syscalls.master,v 1.8 1994/09/13 14:46:54 dfr Exp $
  */
 
 char *syscallnames[] = {
@@ -213,7 +213,7 @@ char *syscallnames[] = {
 	"#172",			/* 172 = nosys */
 	"#173",			/* 173 = nosys */
 	"#174",			/* 174 = nosys */
-	"ntp_gettime",			/* 175 = ntp_gettime */
+	"#175",			/* 175 = nosys */
 	"ntp_adjtime",			/* 176 = ntp_adjtime */
 	"#177",			/* 177 = nosys */
 	"#178",			/* 178 = nosys */
diff --git a/sys/kern/syscalls.master b/sys/kern/syscalls.master
index c00bcd1..d9fd50e 100644
--- a/sys/kern/syscalls.master
+++ b/sys/kern/syscalls.master
@@ -1,4 +1,4 @@
-	$Id: syscalls.master,v 1.7 1994/09/13 00:48:19 wollman Exp $
+	$Id: syscalls.master,v 1.8 1994/09/13 14:46:54 dfr Exp $
 ;	from: @(#)syscalls.master	8.2 (Berkeley) 1/13/94
 ;
 ; System call name/number master file.
@@ -240,7 +240,7 @@
 172	UNIMPL	0 NOHIDE nosys
 173	UNIMPL	0 NOHIDE nosys
 174	UNIMPL	0 NOHIDE nosys
-175	STD	1 BSD	nosys ntp_gettime
+175	UNIMPL	0 NOHIDE nosys
 176	STD	1 BSD	nosys ntp_adjtime
 177	UNIMPL	0 NOHIDE nosys
 178	UNIMPL	0 NOHIDE nosys
diff --git a/sys/sys/syscall-hide.h b/sys/sys/syscall-hide.h
index 92aea01..66912df 100644
--- a/sys/sys/syscall-hide.h
+++ b/sys/sys/syscall-hide.h
@@ -2,7 +2,7 @@
  * System call hiders.
  *
  * DO NOT EDIT-- this file is automatically generated.
- * created from	$Id: syscalls.master,v 1.7 1994/09/13 00:48:19 wollman Exp $
+ * created from	$Id: syscalls.master,v 1.8 1994/09/13 14:46:54 dfr Exp $
  */
 
 HIDE_POSIX(fork)
@@ -189,7 +189,6 @@ HIDE_BSD(shmsys)
 HIDE_BSD(nosys)
 #endif
 HIDE_BSD(nosys)
-HIDE_BSD(nosys)
 HIDE_POSIX(setgid)
 HIDE_BSD(setegid)
 HIDE_BSD(seteuid)
diff --git a/sys/sys/syscall.h b/sys/sys/syscall.h
index 7b43d43..fd409d2 100644
--- a/sys/sys/syscall.h
+++ b/sys/sys/syscall.h
@@ -2,7 +2,7 @@
  * System call numbers.
  *
  * DO NOT EDIT-- this file is automatically generated.
- * created from	$Id: syscalls.master,v 1.7 1994/09/13 00:48:19 wollman Exp $
+ * created from	$Id: syscalls.master,v 1.8 1994/09/13 14:46:54 dfr Exp $
  */
 
 #define	SYS_syscall	0
@@ -168,7 +168,6 @@
 #define	SYS_semsys	169
 #define	SYS_msgsys	170
 #define	SYS_shmsys	171
-#define	SYS_ntp_gettime	175
 #define	SYS_ntp_adjtime	176
 #define	SYS_setgid	181
 #define	SYS_setegid	182
diff --git a/sys/sys/sysctl.h b/sys/sys/sysctl.h
index a16e44e..1fd75d6 100644
--- a/sys/sys/sysctl.h
+++ b/sys/sys/sysctl.h
@@ -34,7 +34,7 @@
  * SUCH DAMAGE.
  *
  *	@(#)sysctl.h	8.1 (Berkeley) 6/2/93
- * $Id: sysctl.h,v 1.8 1994/09/16 00:50:02 ache Exp $
+ * $Id: sysctl.h,v 1.9 1994/09/16 01:09:42 ache Exp $
  */
 
 #ifndef _SYS_SYSCTL_H_
@@ -131,7 +131,8 @@ struct ctlname {
 #define KERN_DOMAINNAME		22	/* string: YP domain name */
 #define KERN_UPDATEINTERVAL	23	/* int: update process sleep time */
 #define KERN_OSRELDATE		24	/* int: OS release date */
-#define KERN_MAXID		25	/* number of valid kern	ids */
+#define KERN_NTP_PLL		25	/* node: NTP PLL control */
+#define KERN_MAXID              26      /* number of valid kern ids */
 
 #define CTL_KERN_NAMES { \
 	{ 0, 0 }, \
@@ -159,6 +160,7 @@ struct ctlname {
 	{ "domainname", CTLTYPE_STRING }, \
 	{ "update", CTLTYPE_INT }, \
 	{ "osreldate", CTLTYPE_INT }, \
+        { "ntp_pll", CTLTYPE_NODE }, \
 }
 
 /* 
diff --git a/sys/sys/timex.h b/sys/sys/timex.h
index 8390ced..e3bdc66 100644
--- a/sys/sys/timex.h
+++ b/sys/sys/timex.h
@@ -242,6 +242,7 @@ struct ntptimeval {
 	struct timeval time;	/* current time (ro) */
 	long maxerror;		/* maximum error (us) (ro) */
 	long esterror;		/* estimated error (us) (ro) */
+	int time_state;		/* what ntp_gettime returns */
 };
 
 /*
@@ -276,6 +277,17 @@ struct timex {
 };
 #ifdef __FreeBSD__
 
+/*
+ * sysctl identifiers underneath kern.ntp_pll
+ */
+#define NTP_PLL_GETTIME	1	/* used by ntp_gettime() */
+#define NTP_PLL_MAXID	2	/* number of valid ids */
+
+#define NTP_PLL_NAMES { \
+			  { 0, 0 }, \
+			  { "gettime", CTLTYPE_STRUCT }, \
+		      }
+
 #ifndef KERNEL
 #include <sys/cdefs.h>