timecounter: Import from FreeBSD

Update #2271.

cpukit/score/include/sys/_ffcounter.h

@@ -0,0 +1,42 @@
+/*-
+ * Copyright (c) 2011 The University of Melbourne
+ * All rights reserved.
+ *
+ * This software was developed by Julien Ridoux at the University of Melbourne
+ * under sponsorship from the FreeBSD Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD r277406 2015-01-20T03:54:30Z$
+ */
+
+#ifndef _SYS__FFCOUNTER_H_
+#define _SYS__FFCOUNTER_H_
+
+/*
+ * The feed-forward clock counter. The fundamental element of a feed-forward
+ * clock is a wide monotonically increasing counter that accumulates at the same
+ * rate as the selected timecounter.
+ */
+typedef uint64_t ffcounter;
+
+#endif /* _SYS__FFCOUNTER_H_ */

cpukit/score/include/sys/timeffc.h

@@ -0,0 +1,389 @@
+/*-
+ * Copyright (c) 2011 The University of Melbourne
+ * All rights reserved.
+ *
+ * This software was developed by Julien Ridoux at the University of Melbourne
+ * under sponsorship from the FreeBSD Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD r277406 2015-01-20T03:54:30Z$
+ */
+
+#ifndef _SYS_TIMEFF_H_
+#define _SYS_TIMEFF_H_
+
+#include <sys/_ffcounter.h>
+
+/*
+ * Feed-forward clock estimate
+ * Holds time mark as a ffcounter and conversion to bintime based on current
+ * timecounter period and offset estimate passed by the synchronization daemon.
+ * Provides time of last daemon update, clock status and bound on error.
+ */
+struct ffclock_estimate {
+	struct bintime	update_time;	/* Time of last estimates update. */
+	ffcounter	update_ffcount;	/* Counter value at last update. */
+	ffcounter	leapsec_next;	/* Counter value of next leap second. */
+	uint64_t	period;		/* Estimate of counter period. */
+	uint32_t	errb_abs;	/* Bound on absolute clock error [ns]. */
+	uint32_t	errb_rate;	/* Bound on counter rate error [ps/s]. */
+	uint32_t	status;		/* Clock status. */
+	int16_t		leapsec_total;	/* All leap seconds seen so far. */
+	int8_t		leapsec;	/* Next leap second (in {-1,0,1}). */
+};
+
+#if __BSD_VISIBLE
+#ifdef _KERNEL
+
+/* Define the kern.sysclock sysctl tree. */
+SYSCTL_DECL(_kern_sysclock);
+
+/* Define the kern.sysclock.ffclock sysctl tree. */
+SYSCTL_DECL(_kern_sysclock_ffclock);
+
+/*
+ * Index into the sysclocks array for obtaining the ASCII name of a particular
+ * sysclock.
+ */
+#define	SYSCLOCK_FBCK	0
+#define	SYSCLOCK_FFWD	1
+extern int sysclock_active;
+
+/*
+ * Parameters of counter characterisation required by feed-forward algorithms.
+ */
+#define	FFCLOCK_SKM_SCALE	1024
+
+/*
+ * Feed-forward clock status
+ */
+#define	FFCLOCK_STA_UNSYNC	1
+#define	FFCLOCK_STA_WARMUP	2
+
+/*
+ * Flags for use by sysclock_snap2bintime() and various ffclock_ functions to
+ * control how the timecounter hardware is read and how the hardware snapshot is
+ * converted into absolute time.
+ * {FB|FF}CLOCK_FAST:	Do not read the hardware counter, instead using the
+ *			value at last tick. The time returned has a resolution
+ *			of the kernel tick timer (1/hz [s]).
+ * FFCLOCK_LERP:	Linear interpolation of ffclock time to guarantee
+ *			monotonic time.
+ * FFCLOCK_LEAPSEC:	Include leap seconds.
+ * {FB|FF}CLOCK_UPTIME:	Time stamp should be relative to system boot, not epoch.
+ */
+#define	FFCLOCK_FAST		0x00000001
+#define	FFCLOCK_LERP		0x00000002
+#define	FFCLOCK_LEAPSEC		0x00000004
+#define	FFCLOCK_UPTIME		0x00000008
+#define	FFCLOCK_MASK		0x0000ffff
+
+#define	FBCLOCK_FAST		0x00010000 /* Currently unused. */
+#define	FBCLOCK_UPTIME		0x00020000
+#define	FBCLOCK_MASK		0xffff0000
+
+/*
+ * Feedback clock specific info structure. The feedback clock's estimation of
+ * clock error is an absolute figure determined by the NTP algorithm. The status
+ * is determined by the userland daemon.
+ */
+struct fbclock_info {
+	struct bintime		error;
+	struct bintime		tick_time;
+	uint64_t		th_scale;
+	int			status;
+};
+
+/*
+ * Feed-forward clock specific info structure. The feed-forward clock's
+ * estimation of clock error is an upper bound, which although potentially
+ * looser than the feedback clock equivalent, is much more reliable. The status
+ * is determined by the userland daemon.
+ */
+struct ffclock_info {
+	struct bintime		error;
+	struct bintime		tick_time;
+	struct bintime		tick_time_lerp;
+	uint64_t		period;
+	uint64_t		period_lerp;
+	int			leapsec_adjustment;
+	int			status;
+};
+
+/*
+ * Snapshot of system clocks and related information. Holds time read from each
+ * clock based on a single read of the active hardware timecounter, as well as
+ * respective clock information such as error estimates and the ffcounter value
+ * at the time of the read.
+ */
+struct sysclock_snap {
+	struct fbclock_info	fb_info;
+	struct ffclock_info	ff_info;
+	ffcounter		ffcount;
+	unsigned int		delta;
+	int			sysclock_active;
+};
+
+/* Take a snapshot of the system clocks and related information. */
+void sysclock_getsnapshot(struct sysclock_snap *clock_snap, int fast);
+
+/* Convert a timestamp from the selected system clock into bintime. */
+int sysclock_snap2bintime(struct sysclock_snap *cs, struct bintime *bt,
+    int whichclock, uint32_t flags);
+
+/* Resets feed-forward clock from RTC */
+void ffclock_reset_clock(struct timespec *ts);
+
+/*
+ * Return the current value of the feed-forward clock counter. Essential to
+ * measure time interval in counter units. If a fast timecounter is used by the
+ * system, may also allow fast but accurate timestamping.
+ */
+void ffclock_read_counter(ffcounter *ffcount);
+
+/*
+ * Retrieve feed-forward counter value and time of last kernel tick. This
+ * accepts the FFCLOCK_LERP flag.
+ */
+void ffclock_last_tick(ffcounter *ffcount, struct bintime *bt, uint32_t flags);
+
+/*
+ * Low level routines to convert a counter timestamp into absolute time and a
+ * counter timestamp interval into an interval in seconds. The absolute time
+ * conversion accepts the FFCLOCK_LERP flag.
+ */
+void ffclock_convert_abs(ffcounter ffcount, struct bintime *bt, uint32_t flags);
+void ffclock_convert_diff(ffcounter ffdelta, struct bintime *bt);
+
+/*
+ * Feed-forward clock routines.
+ *
+ * These functions rely on the timecounters and ffclock_estimates stored in
+ * fftimehands. Note that the error_bound parameter is not the error of the
+ * clock but an upper bound on the error of the absolute time or time interval
+ * returned.
+ *
+ * ffclock_abstime(): retrieves current time as counter value and convert this
+ *     timestamp in seconds. The value (in seconds) of the converted timestamp
+ *     depends on the flags passed: for a given counter value, different
+ *     conversions are possible. Different clock models can be selected by
+ *     combining flags (for example (FFCLOCK_LERP|FFCLOCK_UPTIME) produces
+ *     linearly interpolated uptime).
+ * ffclock_difftime(): computes a time interval in seconds based on an interval
+ *     measured in ffcounter units. This should be the preferred way to measure
+ *     small time intervals very accurately.
+ */
+void ffclock_abstime(ffcounter *ffcount, struct bintime *bt,
+    struct bintime *error_bound, uint32_t flags);
+void ffclock_difftime(ffcounter ffdelta, struct bintime *bt,
+    struct bintime *error_bound);
+
+/*
+ * Wrapper routines to return current absolute time using the feed-forward
+ * clock. These functions are named after those defined in <sys/time.h>, which
+ * contains a description of the original ones.
+ */
+void ffclock_bintime(struct bintime *bt);
+void ffclock_nanotime(struct timespec *tsp);
+void ffclock_microtime(struct timeval *tvp);
+
+void ffclock_getbintime(struct bintime *bt);
+void ffclock_getnanotime(struct timespec *tsp);
+void ffclock_getmicrotime(struct timeval *tvp);
+
+void ffclock_binuptime(struct bintime *bt);
+void ffclock_nanouptime(struct timespec *tsp);
+void ffclock_microuptime(struct timeval *tvp);
+
+void ffclock_getbinuptime(struct bintime *bt);
+void ffclock_getnanouptime(struct timespec *tsp);
+void ffclock_getmicrouptime(struct timeval *tvp);
+
+/*
+ * Wrapper routines to convert a time interval specified in ffcounter units into
+ * seconds using the current feed-forward clock estimates.
+ */
+void ffclock_bindifftime(ffcounter ffdelta, struct bintime *bt);
+void ffclock_nanodifftime(ffcounter ffdelta, struct timespec *tsp);
+void ffclock_microdifftime(ffcounter ffdelta, struct timeval *tvp);
+
+/*
+ * When FFCLOCK is enabled in the kernel, [get]{bin,nano,micro}[up]time() become
+ * wrappers around equivalent feedback or feed-forward functions. Provide access
+ * outside of kern_tc.c to the feedback clock equivalent functions for
+ * specialised use i.e. these are not for general consumption.
+ */
+void fbclock_bintime(struct bintime *bt);
+void fbclock_nanotime(struct timespec *tsp);
+void fbclock_microtime(struct timeval *tvp);
+
+void fbclock_getbintime(struct bintime *bt);
+void fbclock_getnanotime(struct timespec *tsp);
+void fbclock_getmicrotime(struct timeval *tvp);
+
+void fbclock_binuptime(struct bintime *bt);
+void fbclock_nanouptime(struct timespec *tsp);
+void fbclock_microuptime(struct timeval *tvp);
+
+void fbclock_getbinuptime(struct bintime *bt);
+void fbclock_getnanouptime(struct timespec *tsp);
+void fbclock_getmicrouptime(struct timeval *tvp);
+
+/*
+ * Public system clock wrapper API which allows consumers to select which clock
+ * to obtain time from, independent of the current default system clock. These
+ * wrappers should be used instead of directly calling the underlying fbclock_
+ * or ffclock_ functions.
+ */
+static inline void
+bintime_fromclock(struct bintime *bt, int whichclock)
+{
+
+	if (whichclock == SYSCLOCK_FFWD)
+		ffclock_bintime(bt);
+	else
+		fbclock_bintime(bt);
+}
+
+static inline void
+nanotime_fromclock(struct timespec *tsp, int whichclock)
+{
+
+	if (whichclock == SYSCLOCK_FFWD)
+		ffclock_nanotime(tsp);
+	else
+		fbclock_nanotime(tsp);
+}
+
+static inline void
+microtime_fromclock(struct timeval *tvp, int whichclock)
+{
+
+	if (whichclock == SYSCLOCK_FFWD)
+		ffclock_microtime(tvp);
+	else
+		fbclock_microtime(tvp);
+}
+
+static inline void
+getbintime_fromclock(struct bintime *bt, int whichclock)
+{
+
+	if (whichclock == SYSCLOCK_FFWD)
+		ffclock_getbintime(bt);
+	else
+		fbclock_getbintime(bt);
+}
+
+static inline void
+getnanotime_fromclock(struct timespec *tsp, int whichclock)
+{
+
+	if (whichclock == SYSCLOCK_FFWD)
+		ffclock_getnanotime(tsp);
+	else
+		fbclock_getnanotime(tsp);
+}
+
+static inline void
+getmicrotime_fromclock(struct timeval *tvp, int whichclock)
+{
+
+	if (whichclock == SYSCLOCK_FFWD)
+		ffclock_getmicrotime(tvp);
+	else
+		fbclock_getmicrotime(tvp);
+}
+
+static inline void
+binuptime_fromclock(struct bintime *bt, int whichclock)
+{
+
+	if (whichclock == SYSCLOCK_FFWD)
+		ffclock_binuptime(bt);
+	else
+		fbclock_binuptime(bt);
+}
+
+static inline void
+nanouptime_fromclock(struct timespec *tsp, int whichclock)
+{
+
+	if (whichclock == SYSCLOCK_FFWD)
+		ffclock_nanouptime(tsp);
+	else
+		fbclock_nanouptime(tsp);
+}
+
+static inline void
+microuptime_fromclock(struct timeval *tvp, int whichclock)
+{
+
+	if (whichclock == SYSCLOCK_FFWD)
+		ffclock_microuptime(tvp);
+	else
+		fbclock_microuptime(tvp);
+}
+
+static inline void
+getbinuptime_fromclock(struct bintime *bt, int whichclock)
+{
+
+	if (whichclock == SYSCLOCK_FFWD)
+		ffclock_getbinuptime(bt);
+	else
+		fbclock_getbinuptime(bt);
+}
+
+static inline void
+getnanouptime_fromclock(struct timespec *tsp, int whichclock)
+{
+
+	if (whichclock == SYSCLOCK_FFWD)
+		ffclock_getnanouptime(tsp);
+	else
+		fbclock_getnanouptime(tsp);
+}
+
+static inline void
+getmicrouptime_fromclock(struct timeval *tvp, int whichclock)
+{
+
+	if (whichclock == SYSCLOCK_FFWD)
+		ffclock_getmicrouptime(tvp);
+	else
+		fbclock_getmicrouptime(tvp);
+}
+
+#else /* !_KERNEL */
+
+/* Feed-Forward Clock system calls. */
+__BEGIN_DECLS
+int ffclock_getcounter(ffcounter *ffcount);
+int ffclock_getestimate(struct ffclock_estimate *cest);
+int ffclock_setestimate(struct ffclock_estimate *cest);
+__END_DECLS
+
+#endif /* _KERNEL */
+#endif /* __BSD_VISIBLE */
+#endif /* _SYS_TIMEFF_H_ */

cpukit/score/include/sys/timepps.h

@@ -0,0 +1,249 @@
+/*-
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <phk@FreeBSD.org> wrote this file.  As long as you retain this notice you
+ * can do whatever you want with this stuff. If we meet some day, and you think
+ * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
+ * ----------------------------------------------------------------------------
+ *
+ * Copyright (c) 2011 The FreeBSD Foundation
+ * All rights reserved.
+ *
+ * Portions of this software were developed by Julien Ridoux at the University
+ * of Melbourne under sponsorship from the FreeBSD Foundation.
+ *
+ * $FreeBSD r277406 2015-01-20T03:54:30Z$
+ *
+ * The is a FreeBSD version of the RFC 2783 API for Pulse Per Second 
+ * timing interfaces.  
+ */
+
+#ifndef _SYS_TIMEPPS_H_
+#define _SYS_TIMEPPS_H_
+
+#include <sys/_ffcounter.h>
+#include <sys/ioccom.h>
+#include <sys/time.h>
+
+#define PPS_API_VERS_1	1
+
+typedef int pps_handle_t;	
+
+typedef unsigned pps_seq_t;
+
+typedef struct ntp_fp {
+	unsigned int	integral;
+	unsigned int	fractional;
+} ntp_fp_t;
+
+typedef union pps_timeu {
+	struct timespec	tspec;
+	ntp_fp_t	ntpfp;
+	unsigned long	longpad[3];
+} pps_timeu_t;
+
+typedef struct {
+	pps_seq_t	assert_sequence;	/* assert event seq # */
+	pps_seq_t	clear_sequence;		/* clear event seq # */
+	pps_timeu_t	assert_tu;
+	pps_timeu_t	clear_tu;
+	int		current_mode;		/* current mode bits */
+} pps_info_t;
+
+typedef struct {
+	pps_seq_t	assert_sequence;	/* assert event seq # */
+	pps_seq_t	clear_sequence;		/* clear event seq # */
+	pps_timeu_t	assert_tu;
+	pps_timeu_t	clear_tu;
+	ffcounter	assert_ffcount;		/* ffcounter on assert event */
+	ffcounter	clear_ffcount;		/* ffcounter on clear event */
+	int		current_mode;		/* current mode bits */
+} pps_info_ffc_t;
+
+#define assert_timestamp        assert_tu.tspec
+#define clear_timestamp         clear_tu.tspec
+
+#define assert_timestamp_ntpfp  assert_tu.ntpfp
+#define clear_timestamp_ntpfp   clear_tu.ntpfp
+
+typedef struct {
+	int api_version;			/* API version # */
+	int mode;				/* mode bits */
+	pps_timeu_t assert_off_tu;
+	pps_timeu_t clear_off_tu;
+} pps_params_t;
+
+#define assert_offset   assert_off_tu.tspec
+#define clear_offset    clear_off_tu.tspec
+
+#define assert_offset_ntpfp     assert_off_tu.ntpfp
+#define clear_offset_ntpfp      clear_off_tu.ntpfp
+
+
+#define PPS_CAPTUREASSERT	0x01
+#define PPS_CAPTURECLEAR	0x02
+#define PPS_CAPTUREBOTH		0x03
+
+#define PPS_OFFSETASSERT	0x10
+#define PPS_OFFSETCLEAR		0x20
+
+#define PPS_ECHOASSERT		0x40
+#define PPS_ECHOCLEAR		0x80
+
+#define PPS_CANWAIT		0x100
+#define PPS_CANPOLL		0x200
+
+#define PPS_TSFMT_TSPEC		0x1000
+#define PPS_TSFMT_NTPFP		0x2000
+
+#define	PPS_TSCLK_FBCK		0x10000
+#define	PPS_TSCLK_FFWD		0x20000
+#define	PPS_TSCLK_MASK		0x30000
+
+#define PPS_KC_HARDPPS		0
+#define PPS_KC_HARDPPS_PLL	1
+#define PPS_KC_HARDPPS_FLL	2
+
+struct pps_fetch_args {
+	int tsformat;
+	pps_info_t	pps_info_buf;
+	struct timespec	timeout;
+};
+
+struct pps_fetch_ffc_args {
+	int		tsformat;
+	pps_info_ffc_t	pps_info_buf_ffc;
+	struct timespec	timeout;
+};
+
+struct pps_kcbind_args {
+	int kernel_consumer;
+	int edge;
+	int tsformat;
+};
+
+#define PPS_IOC_CREATE		_IO('1', 1)
+#define PPS_IOC_DESTROY		_IO('1', 2)
+#define PPS_IOC_SETPARAMS	_IOW('1', 3, pps_params_t)
+#define PPS_IOC_GETPARAMS	_IOR('1', 4, pps_params_t)
+#define PPS_IOC_GETCAP		_IOR('1', 5, int)
+#define PPS_IOC_FETCH		_IOWR('1', 6, struct pps_fetch_args)
+#define PPS_IOC_KCBIND		_IOW('1', 7, struct pps_kcbind_args)
+#define	PPS_IOC_FETCH_FFCOUNTER	_IOWR('1', 8, struct pps_fetch_ffc_args)
+
+#ifdef _KERNEL
+
+struct pps_state {
+	/* Capture information. */
+	struct timehands *capth;
+	struct fftimehands *capffth;
+	unsigned	capgen;
+	unsigned	capcount;
+
+	/* State information. */
+	pps_params_t	ppsparam;
+	pps_info_t	ppsinfo;
+	pps_info_ffc_t	ppsinfo_ffc;
+	int		kcmode;
+	int		ppscap;
+	struct timecounter *ppstc;
+	unsigned	ppscount[3];
+};
+
+void pps_capture(struct pps_state *pps);
+void pps_event(struct pps_state *pps, int event);
+void pps_init(struct pps_state *pps);
+int pps_ioctl(unsigned long cmd, caddr_t data, struct pps_state *pps);
+void hardpps(struct timespec *tsp, long nsec);
+
+#else /* !_KERNEL */
+
+static __inline int
+time_pps_create(int filedes, pps_handle_t *handle)
+{
+	int error;
+
+	*handle = -1;
+	error = ioctl(filedes, PPS_IOC_CREATE, 0);
+	if (error < 0) 
+		return (-1);
+	*handle = filedes;
+	return (0);
+}
+
+static __inline int
+time_pps_destroy(pps_handle_t handle)
+{
+	return (ioctl(handle, PPS_IOC_DESTROY, 0));
+}
+
+static __inline int
+time_pps_setparams(pps_handle_t handle, const pps_params_t *ppsparams)
+{
+	return (ioctl(handle, PPS_IOC_SETPARAMS, ppsparams));
+}
+
+static __inline int
+time_pps_getparams(pps_handle_t handle, pps_params_t *ppsparams)
+{
+	return (ioctl(handle, PPS_IOC_GETPARAMS, ppsparams));
+}
+
+static __inline int 
+time_pps_getcap(pps_handle_t handle, int *mode)
+{
+	return (ioctl(handle, PPS_IOC_GETCAP, mode));
+}
+
+static __inline int
+time_pps_fetch(pps_handle_t handle, const int tsformat,
+	pps_info_t *ppsinfobuf, const struct timespec *timeout)
+{
+	int error;
+	struct pps_fetch_args arg;
+
+	arg.tsformat = tsformat;
+	if (timeout == NULL) {
+		arg.timeout.tv_sec = -1;
+		arg.timeout.tv_nsec = -1;
+	} else
+		arg.timeout = *timeout;
+	error = ioctl(handle, PPS_IOC_FETCH, &arg);
+	*ppsinfobuf = arg.pps_info_buf;
+	return (error);
+}
+
+static __inline int
+time_pps_fetch_ffc(pps_handle_t handle, const int tsformat,
+	pps_info_ffc_t *ppsinfobuf, const struct timespec *timeout)
+{
+	struct pps_fetch_ffc_args arg;
+	int error;
+
+	arg.tsformat = tsformat;
+	if (timeout == NULL) {
+		arg.timeout.tv_sec = -1;
+		arg.timeout.tv_nsec = -1;
+	} else {
+		arg.timeout = *timeout;
+	}
+	error = ioctl(handle, PPS_IOC_FETCH_FFCOUNTER, &arg);
+	*ppsinfobuf = arg.pps_info_buf_ffc;
+	return (error);
+}
+
+static __inline int
+time_pps_kcbind(pps_handle_t handle, const int kernel_consumer,
+	const int edge, const int tsformat)
+{
+	struct pps_kcbind_args arg;
+
+	arg.kernel_consumer = kernel_consumer;
+	arg.edge = edge;
+	arg.tsformat = tsformat;
+	return (ioctl(handle, PPS_IOC_KCBIND, &arg));
+}
+
+#endif /* KERNEL */
+
+#endif /* !_SYS_TIMEPPS_H_ */

cpukit/score/include/sys/timetc.h

@@ -0,0 +1,89 @@
+/*-
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <phk@FreeBSD.ORG> wrote this file.  As long as you retain this notice you
+ * can do whatever you want with this stuff. If we meet some day, and you think
+ * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
+ * ----------------------------------------------------------------------------
+ *
+ * $FreeBSD r277406 2015-01-20T03:54:30Z$
+ */
+
+#ifndef _SYS_TIMETC_H_
+#define	_SYS_TIMETC_H_
+
+#ifndef _KERNEL
+#error "no user-serviceable parts inside"
+#endif
+
+/*-
+ * `struct timecounter' is the interface between the hardware which implements
+ * a timecounter and the MI code which uses this to keep track of time.
+ *
+ * A timecounter is a binary counter which has two properties:
+ *    * it runs at a fixed, known frequency.
+ *    * it has sufficient bits to not roll over in less than approximately
+ *      max(2 msec, 2/HZ seconds).  (The value 2 here is really 1 + delta,
+ *      for some indeterminate value of delta.)
+ */
+
+struct timecounter;
+typedef u_int timecounter_get_t(struct timecounter *);
+typedef void timecounter_pps_t(struct timecounter *);
+
+struct timecounter {
+	timecounter_get_t	*tc_get_timecount;
+		/*
+		 * This function reads the counter.  It is not required to
+		 * mask any unimplemented bits out, as long as they are
+		 * constant.
+		 */
+	timecounter_pps_t	*tc_poll_pps;
+		/*
+		 * This function is optional.  It will be called whenever the
+		 * timecounter is rewound, and is intended to check for PPS
+		 * events.  Normal hardware does not need it but timecounters
+		 * which latch PPS in hardware (like sys/pci/xrpu.c) do.
+		 */
+	u_int 			tc_counter_mask;
+		/* This mask should mask off any unimplemented bits. */
+	uint64_t		tc_frequency;
+		/* Frequency of the counter in Hz. */
+	char			*tc_name;
+		/* Name of the timecounter. */
+	int			tc_quality;
+		/*
+		 * Used to determine if this timecounter is better than
+		 * another timecounter higher means better.  Negative
+		 * means "only use at explicit request".
+		 */
+	u_int			tc_flags;
+#define	TC_FLAGS_C2STOP		1	/* Timer dies in C2+. */
+#define	TC_FLAGS_SUSPEND_SAFE	2	/*
+					 * Timer functional across
+					 * suspend/resume.
+					 */
+
+	void			*tc_priv;
+		/* Pointer to the timecounter's private parts. */
+	struct timecounter	*tc_next;
+		/* Pointer to the next timecounter. */
+};
+
+extern struct timecounter *timecounter;
+extern int tc_min_ticktock_freq; /*
+				  * Minimal tc_ticktock() call frequency,
+				  * required to handle counter wraps.
+				  */
+
+u_int64_t tc_getfrequency(void);
+void	tc_init(struct timecounter *tc);
+void	tc_setclock(struct timespec *ts);
+void	tc_ticktock(int cnt);
+void	cpu_tick_calibration(void);
+
+#ifdef SYSCTL_DECL
+SYSCTL_DECL(_kern_timecounter);
+#endif
+
+#endif /* !_SYS_TIMETC_H_ */

cpukit/score/include/sys/timex.h

@@ -0,0 +1,171 @@
+/*-
+ ***********************************************************************
+ *								       *
+ * Copyright (c) David L. Mills 1993-2001			       *
+ * Copyright (c) Poul-Henning Kamp 2000-2001                           *
+ *								       *
+ * 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.							       *
+ *								       *
+ ***********************************************************************
+ *
+ * $FreeBSD r277406 2015-01-20T03:54:30Z$
+ *
+ * This header file defines the Network Time Protocol (NTP) interfaces
+ * for user and daemon application programs.
+ *
+ * This file was originally created 17 Sep 93 by David L. Mills, Professor
+ * of University of Delaware, building on work which had already been ongoing
+ * for a decade and a half at that point in time.
+ *
+ * In 2000 the APIs got a upgrade from microseconds to nanoseconds,
+ * a joint work between Poul-Henning Kamp and David L. Mills.
+ *
+ */
+
+#ifndef _SYS_TIMEX_H_
+#define _SYS_TIMEX_H_ 1
+
+#define NTP_API		4		/* NTP API version */
+
+#ifdef __FreeBSD__
+#include <sys/_timespec.h>
+#endif /* __FreeBSD__ */
+
+/*
+ * The following defines establish the performance envelope of the
+ * kernel discipline loop. Phase or frequency errors greater than
+ * NAXPHASE or MAXFREQ are clamped to these maxima. For update intervals
+ * less than MINSEC, the loop always operates in PLL mode; while, for
+ * update intervals greater than MAXSEC, the loop always operates in FLL
+ * mode. Between these two limits the operating mode is selected by the
+ * STA_FLL bit in the status word.
+ */
+
+#define MAXPHASE	500000000L	/* max phase error (ns) */
+#define MAXFREQ		500000L		/* max freq error (ns/s) */
+#define MINSEC		256		/* min FLL update interval (s) */
+#define MAXSEC		2048		/* max PLL update interval (s) */
+#define NANOSECOND	1000000000L	/* nanoseconds in one second */
+#define SCALE_PPM	(65536 / 1000)	/* crude ns/s to scaled PPM */
+#define MAXTC		10		/* max time constant */
+
+/*
+ * Control mode codes (timex.modes)
+ */
+#define MOD_OFFSET	0x0001		/* set time offset */
+#define MOD_FREQUENCY	0x0002		/* set frequency offset */
+#define MOD_MAXERROR	0x0004		/* set maximum time error */
+#define MOD_ESTERROR	0x0008		/* set estimated time error */
+#define MOD_STATUS	0x0010		/* set clock status bits */
+#define MOD_TIMECONST	0x0020		/* set PLL time constant */
+#define MOD_PPSMAX	0x0040		/* set PPS maximum averaging time */
+#define MOD_TAI		0x0080		/* set TAI offset */
+#define	MOD_MICRO	0x1000		/* select microsecond resolution */
+#define	MOD_NANO	0x2000		/* select nanosecond resolution */
+#define MOD_CLKB	0x4000		/* select clock B */
+#define MOD_CLKA	0x8000		/* select clock A */
+
+/*
+ * Status codes (timex.status)
+ */
+#define STA_PLL		0x0001		/* enable PLL updates (rw) */
+#define STA_PPSFREQ	0x0002		/* enable PPS freq discipline (rw) */
+#define STA_PPSTIME	0x0004		/* enable PPS time discipline (rw) */
+#define STA_FLL		0x0008		/* enable FLL mode (rw) */
+#define STA_INS		0x0010		/* insert leap (rw) */
+#define STA_DEL		0x0020		/* delete leap (rw) */
+#define STA_UNSYNC	0x0040		/* clock unsynchronized (rw) */
+#define STA_FREQHOLD	0x0080		/* hold frequency (rw) */
+#define STA_PPSSIGNAL	0x0100		/* PPS signal present (ro) */
+#define STA_PPSJITTER	0x0200		/* PPS signal jitter exceeded (ro) */
+#define STA_PPSWANDER	0x0400		/* PPS signal wander exceeded (ro) */
+#define STA_PPSERROR	0x0800		/* PPS signal calibration error (ro) */
+#define STA_CLOCKERR	0x1000		/* clock hardware fault (ro) */
+#define STA_NANO	0x2000		/* resolution (0 = us, 1 = ns) (ro) */
+#define STA_MODE	0x4000		/* mode (0 = PLL, 1 = FLL) (ro) */
+#define STA_CLK		0x8000		/* clock source (0 = A, 1 = B) (ro) */
+
+#define STA_RONLY (STA_PPSSIGNAL | STA_PPSJITTER | STA_PPSWANDER | \
+    STA_PPSERROR | STA_CLOCKERR | STA_NANO | STA_MODE | STA_CLK)
+
+/*
+ * Clock states (ntptimeval.time_state)
+ */
+#define TIME_OK		0		/* no leap second warning */
+#define TIME_INS	1		/* insert leap second warning */
+#define TIME_DEL	2		/* delete leap second warning */
+#define TIME_OOP	3		/* leap second in progress */
+#define TIME_WAIT	4		/* leap second has occured */
+#define TIME_ERROR	5		/* error (see status word) */
+
+/*
+ * NTP user interface -- ntp_gettime(2) - used to read kernel clock values
+ */
+struct ntptimeval {
+	struct timespec time;		/* current time (ns) (ro) */
+	long maxerror;			/* maximum error (us) (ro) */
+	long esterror;			/* estimated error (us) (ro) */
+	long tai;			/* TAI offset */
+	int time_state;			/* time status */
+};
+
+/*
+ * NTP daemon interface -- ntp_adjtime(2) -- used to discipline CPU clock
+ * oscillator and control/determine status.
+ *
+ * Note: The offset, precision and jitter members are in microseconds if
+ * STA_NANO is zero and nanoseconds if not.
+ */
+struct timex {
+	unsigned int modes;		/* clock mode bits (wo) */
+	long	offset;			/* time offset (ns/us) (rw) */
+	long	freq;			/* frequency offset (scaled PPM) (rw) */
+	long	maxerror;		/* maximum error (us) (rw) */
+	long	esterror;		/* estimated error (us) (rw) */
+	int	status;			/* clock status bits (rw) */
+	long	constant;		/* poll interval (log2 s) (rw) */
+	long	precision;		/* clock precision (ns/us) (ro) */
+	long	tolerance;		/* clock frequency tolerance (scaled
+				 	 * PPM) (ro) */
+	/*
+	 * The following read-only structure members are implemented
+	 * only if the PPS signal discipline is configured in the
+	 * kernel. They are included in all configurations to insure
+	 * portability.
+	 */
+	long	ppsfreq;		/* PPS frequency (scaled PPM) (ro) */
+	long	jitter;			/* PPS jitter (ns/us) (ro) */
+	int	shift;			/* interval duration (s) (shift) (ro) */
+	long	stabil;			/* PPS stability (scaled PPM) (ro) */
+	long	jitcnt;			/* jitter limit exceeded (ro) */
+	long	calcnt;			/* calibration intervals (ro) */
+	long	errcnt;			/* calibration errors (ro) */
+	long	stbcnt;			/* stability limit exceeded (ro) */
+};
+
+#ifdef __FreeBSD__
+
+#ifdef _KERNEL
+void	ntp_update_second(int64_t *adjustment, time_t *newsec);
+#else /* !_KERNEL */
+#include <sys/cdefs.h>
+
+__BEGIN_DECLS
+int	ntp_adjtime(struct timex *);
+int	ntp_gettime(struct ntptimeval *);
+__END_DECLS
+#endif /* _KERNEL */
+
+#endif /* __FreeBSD__ */
+
+#endif /* !_SYS_TIMEX_H_ */