2006-10-01 10:28:22 +04:00
|
|
|
/*
|
|
|
|
* NTP state machine interfaces and logic.
|
|
|
|
*
|
|
|
|
* This code was mainly moved from kernel/timer.c and kernel/time.c
|
|
|
|
* Please see those files for relevant copyright info and historical
|
|
|
|
* changelogs.
|
|
|
|
*/
|
2007-07-16 10:40:39 +04:00
|
|
|
#include <linux/capability.h>
|
2008-05-01 15:34:41 +04:00
|
|
|
#include <linux/clocksource.h>
|
2008-09-23 01:42:40 +04:00
|
|
|
#include <linux/workqueue.h>
|
2008-02-20 09:58:42 +03:00
|
|
|
#include <linux/hrtimer.h>
|
|
|
|
#include <linux/jiffies.h>
|
|
|
|
#include <linux/math64.h>
|
|
|
|
#include <linux/timex.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/mm.h>
|
2011-01-13 04:00:56 +03:00
|
|
|
#include <linux/module.h>
|
2012-12-18 01:30:53 +04:00
|
|
|
#include <linux/rtc.h>
|
2006-10-01 10:28:22 +04:00
|
|
|
|
2011-01-27 18:00:32 +03:00
|
|
|
#include "tick-internal.h"
|
2013-03-22 22:31:29 +04:00
|
|
|
#include "ntp_internal.h"
|
2011-01-27 18:00:32 +03:00
|
|
|
|
2006-10-01 10:28:22 +04:00
|
|
|
/*
|
2008-02-20 09:58:42 +03:00
|
|
|
* NTP timekeeping variables:
|
2013-03-22 22:52:03 +04:00
|
|
|
*
|
|
|
|
* Note: All of the NTP state is protected by the timekeeping locks.
|
2006-10-01 10:28:22 +04:00
|
|
|
*/
|
|
|
|
|
2011-11-15 01:48:36 +04:00
|
|
|
|
2008-02-20 09:58:42 +03:00
|
|
|
/* USER_HZ period (usecs): */
|
|
|
|
unsigned long tick_usec = TICK_USEC;
|
|
|
|
|
2012-07-27 22:48:10 +04:00
|
|
|
/* SHIFTED_HZ period (nsecs): */
|
2008-02-20 09:58:42 +03:00
|
|
|
unsigned long tick_nsec;
|
2008-05-01 15:34:41 +04:00
|
|
|
|
2011-11-15 01:18:07 +04:00
|
|
|
static u64 tick_length;
|
2008-02-20 09:58:42 +03:00
|
|
|
static u64 tick_length_base;
|
|
|
|
|
2009-02-22 14:11:11 +03:00
|
|
|
#define MAX_TICKADJ 500LL /* usecs */
|
2008-02-20 09:58:42 +03:00
|
|
|
#define MAX_TICKADJ_SCALED \
|
2009-02-22 14:11:11 +03:00
|
|
|
(((MAX_TICKADJ * NSEC_PER_USEC) << NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ)
|
2006-10-01 10:28:22 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* phase-lock loop variables
|
|
|
|
*/
|
2008-02-20 09:58:42 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* clock synchronization status
|
|
|
|
*
|
|
|
|
* (TIME_ERROR prevents overwriting the CMOS clock)
|
|
|
|
*/
|
|
|
|
static int time_state = TIME_OK;
|
|
|
|
|
|
|
|
/* clock status bits: */
|
2011-11-15 01:06:21 +04:00
|
|
|
static int time_status = STA_UNSYNC;
|
2008-02-20 09:58:42 +03:00
|
|
|
|
|
|
|
/* time adjustment (nsecs): */
|
|
|
|
static s64 time_offset;
|
|
|
|
|
|
|
|
/* pll time constant: */
|
|
|
|
static long time_constant = 2;
|
|
|
|
|
|
|
|
/* maximum error (usecs): */
|
2010-01-29 02:02:41 +03:00
|
|
|
static long time_maxerror = NTP_PHASE_LIMIT;
|
2008-02-20 09:58:42 +03:00
|
|
|
|
|
|
|
/* estimated error (usecs): */
|
2010-01-29 02:02:41 +03:00
|
|
|
static long time_esterror = NTP_PHASE_LIMIT;
|
2008-02-20 09:58:42 +03:00
|
|
|
|
|
|
|
/* frequency offset (scaled nsecs/secs): */
|
|
|
|
static s64 time_freq;
|
|
|
|
|
|
|
|
/* time at last adjustment (secs): */
|
|
|
|
static long time_reftime;
|
|
|
|
|
2010-03-19 06:19:27 +03:00
|
|
|
static long time_adjust;
|
2008-02-20 09:58:42 +03:00
|
|
|
|
2009-02-22 18:03:37 +03:00
|
|
|
/* constant (boot-param configurable) NTP tick adjustment (upscaled) */
|
|
|
|
static s64 ntp_tick_adj;
|
2008-02-20 09:58:42 +03:00
|
|
|
|
2011-01-13 04:00:56 +03:00
|
|
|
#ifdef CONFIG_NTP_PPS
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The following variables are used when a pulse-per-second (PPS) signal
|
|
|
|
* is available. They establish the engineering parameters of the clock
|
|
|
|
* discipline loop when controlled by the PPS signal.
|
|
|
|
*/
|
|
|
|
#define PPS_VALID 10 /* PPS signal watchdog max (s) */
|
|
|
|
#define PPS_POPCORN 4 /* popcorn spike threshold (shift) */
|
|
|
|
#define PPS_INTMIN 2 /* min freq interval (s) (shift) */
|
|
|
|
#define PPS_INTMAX 8 /* max freq interval (s) (shift) */
|
|
|
|
#define PPS_INTCOUNT 4 /* number of consecutive good intervals to
|
|
|
|
increase pps_shift or consecutive bad
|
|
|
|
intervals to decrease it */
|
|
|
|
#define PPS_MAXWANDER 100000 /* max PPS freq wander (ns/s) */
|
|
|
|
|
|
|
|
static int pps_valid; /* signal watchdog counter */
|
|
|
|
static long pps_tf[3]; /* phase median filter */
|
|
|
|
static long pps_jitter; /* current jitter (ns) */
|
|
|
|
static struct timespec pps_fbase; /* beginning of the last freq interval */
|
|
|
|
static int pps_shift; /* current interval duration (s) (shift) */
|
|
|
|
static int pps_intcnt; /* interval counter */
|
|
|
|
static s64 pps_freq; /* frequency offset (scaled ns/s) */
|
|
|
|
static long pps_stabil; /* current stability (scaled ns/s) */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* PPS signal quality monitors
|
|
|
|
*/
|
|
|
|
static long pps_calcnt; /* calibration intervals */
|
|
|
|
static long pps_jitcnt; /* jitter limit exceeded */
|
|
|
|
static long pps_stbcnt; /* stability limit exceeded */
|
|
|
|
static long pps_errcnt; /* calibration errors */
|
|
|
|
|
|
|
|
|
|
|
|
/* PPS kernel consumer compensates the whole phase error immediately.
|
|
|
|
* Otherwise, reduce the offset by a fixed factor times the time constant.
|
|
|
|
*/
|
|
|
|
static inline s64 ntp_offset_chunk(s64 offset)
|
|
|
|
{
|
|
|
|
if (time_status & STA_PPSTIME && time_status & STA_PPSSIGNAL)
|
|
|
|
return offset;
|
|
|
|
else
|
|
|
|
return shift_right(offset, SHIFT_PLL + time_constant);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void pps_reset_freq_interval(void)
|
|
|
|
{
|
|
|
|
/* the PPS calibration interval may end
|
|
|
|
surprisingly early */
|
|
|
|
pps_shift = PPS_INTMIN;
|
|
|
|
pps_intcnt = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pps_clear - Clears the PPS state variables
|
|
|
|
*/
|
|
|
|
static inline void pps_clear(void)
|
|
|
|
{
|
|
|
|
pps_reset_freq_interval();
|
|
|
|
pps_tf[0] = 0;
|
|
|
|
pps_tf[1] = 0;
|
|
|
|
pps_tf[2] = 0;
|
|
|
|
pps_fbase.tv_sec = pps_fbase.tv_nsec = 0;
|
|
|
|
pps_freq = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Decrease pps_valid to indicate that another second has passed since
|
|
|
|
* the last PPS signal. When it reaches 0, indicate that PPS signal is
|
|
|
|
* missing.
|
|
|
|
*/
|
|
|
|
static inline void pps_dec_valid(void)
|
|
|
|
{
|
|
|
|
if (pps_valid > 0)
|
|
|
|
pps_valid--;
|
|
|
|
else {
|
|
|
|
time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
|
|
|
|
STA_PPSWANDER | STA_PPSERROR);
|
|
|
|
pps_clear();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void pps_set_freq(s64 freq)
|
|
|
|
{
|
|
|
|
pps_freq = freq;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int is_error_status(int status)
|
|
|
|
{
|
|
|
|
return (time_status & (STA_UNSYNC|STA_CLOCKERR))
|
|
|
|
/* PPS signal lost when either PPS time or
|
|
|
|
* PPS frequency synchronization requested
|
|
|
|
*/
|
|
|
|
|| ((time_status & (STA_PPSFREQ|STA_PPSTIME))
|
|
|
|
&& !(time_status & STA_PPSSIGNAL))
|
|
|
|
/* PPS jitter exceeded when
|
|
|
|
* PPS time synchronization requested */
|
|
|
|
|| ((time_status & (STA_PPSTIME|STA_PPSJITTER))
|
|
|
|
== (STA_PPSTIME|STA_PPSJITTER))
|
|
|
|
/* PPS wander exceeded or calibration error when
|
|
|
|
* PPS frequency synchronization requested
|
|
|
|
*/
|
|
|
|
|| ((time_status & STA_PPSFREQ)
|
|
|
|
&& (time_status & (STA_PPSWANDER|STA_PPSERROR)));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void pps_fill_timex(struct timex *txc)
|
|
|
|
{
|
|
|
|
txc->ppsfreq = shift_right((pps_freq >> PPM_SCALE_INV_SHIFT) *
|
|
|
|
PPM_SCALE_INV, NTP_SCALE_SHIFT);
|
|
|
|
txc->jitter = pps_jitter;
|
|
|
|
if (!(time_status & STA_NANO))
|
|
|
|
txc->jitter /= NSEC_PER_USEC;
|
|
|
|
txc->shift = pps_shift;
|
|
|
|
txc->stabil = pps_stabil;
|
|
|
|
txc->jitcnt = pps_jitcnt;
|
|
|
|
txc->calcnt = pps_calcnt;
|
|
|
|
txc->errcnt = pps_errcnt;
|
|
|
|
txc->stbcnt = pps_stbcnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else /* !CONFIG_NTP_PPS */
|
|
|
|
|
|
|
|
static inline s64 ntp_offset_chunk(s64 offset)
|
|
|
|
{
|
|
|
|
return shift_right(offset, SHIFT_PLL + time_constant);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void pps_reset_freq_interval(void) {}
|
|
|
|
static inline void pps_clear(void) {}
|
|
|
|
static inline void pps_dec_valid(void) {}
|
|
|
|
static inline void pps_set_freq(s64 freq) {}
|
|
|
|
|
|
|
|
static inline int is_error_status(int status)
|
|
|
|
{
|
|
|
|
return status & (STA_UNSYNC|STA_CLOCKERR);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void pps_fill_timex(struct timex *txc)
|
|
|
|
{
|
|
|
|
/* PPS is not implemented, so these are zero */
|
|
|
|
txc->ppsfreq = 0;
|
|
|
|
txc->jitter = 0;
|
|
|
|
txc->shift = 0;
|
|
|
|
txc->stabil = 0;
|
|
|
|
txc->jitcnt = 0;
|
|
|
|
txc->calcnt = 0;
|
|
|
|
txc->errcnt = 0;
|
|
|
|
txc->stbcnt = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_NTP_PPS */
|
|
|
|
|
2011-11-15 01:06:21 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* ntp_synced - Returns 1 if the NTP status is not UNSYNC
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static inline int ntp_synced(void)
|
|
|
|
{
|
|
|
|
return !(time_status & STA_UNSYNC);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-20 09:58:42 +03:00
|
|
|
/*
|
|
|
|
* NTP methods:
|
|
|
|
*/
|
2006-10-01 10:28:22 +04:00
|
|
|
|
2009-02-22 14:42:59 +03:00
|
|
|
/*
|
|
|
|
* Update (tick_length, tick_length_base, tick_nsec), based
|
|
|
|
* on (tick_usec, ntp_tick_adj, time_freq):
|
|
|
|
*/
|
2006-10-01 10:28:29 +04:00
|
|
|
static void ntp_update_frequency(void)
|
|
|
|
{
|
2009-02-22 14:42:59 +03:00
|
|
|
u64 second_length;
|
2009-02-22 14:17:36 +03:00
|
|
|
u64 new_base;
|
2009-02-22 14:42:59 +03:00
|
|
|
|
|
|
|
second_length = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ)
|
|
|
|
<< NTP_SCALE_SHIFT;
|
|
|
|
|
2009-02-22 18:03:37 +03:00
|
|
|
second_length += ntp_tick_adj;
|
2009-02-22 14:42:59 +03:00
|
|
|
second_length += time_freq;
|
2006-10-01 10:28:29 +04:00
|
|
|
|
2009-02-22 14:42:59 +03:00
|
|
|
tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
|
2009-02-22 14:17:36 +03:00
|
|
|
new_base = div_u64(second_length, NTP_INTERVAL_FREQ);
|
2009-02-19 03:02:22 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't wait for the next second_overflow, apply
|
2009-02-22 14:17:36 +03:00
|
|
|
* the change to the tick length immediately:
|
2009-02-19 03:02:22 +03:00
|
|
|
*/
|
2009-02-22 14:17:36 +03:00
|
|
|
tick_length += new_base - tick_length_base;
|
|
|
|
tick_length_base = new_base;
|
2006-10-01 10:28:29 +04:00
|
|
|
}
|
|
|
|
|
2009-02-22 15:22:23 +03:00
|
|
|
static inline s64 ntp_update_offset_fll(s64 offset64, long secs)
|
2009-02-22 14:57:49 +03:00
|
|
|
{
|
|
|
|
time_status &= ~STA_MODE;
|
|
|
|
|
|
|
|
if (secs < MINSEC)
|
2009-02-22 15:22:23 +03:00
|
|
|
return 0;
|
2009-02-22 14:57:49 +03:00
|
|
|
|
|
|
|
if (!(time_status & STA_FLL) && (secs <= MAXSEC))
|
2009-02-22 15:22:23 +03:00
|
|
|
return 0;
|
2009-02-22 14:57:49 +03:00
|
|
|
|
|
|
|
time_status |= STA_MODE;
|
|
|
|
|
2012-03-15 20:36:14 +04:00
|
|
|
return div64_long(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs);
|
2009-02-22 14:57:49 +03:00
|
|
|
}
|
|
|
|
|
2008-05-01 15:34:32 +04:00
|
|
|
static void ntp_update_offset(long offset)
|
|
|
|
{
|
|
|
|
s64 freq_adj;
|
2009-02-22 14:57:49 +03:00
|
|
|
s64 offset64;
|
|
|
|
long secs;
|
2008-05-01 15:34:32 +04:00
|
|
|
|
|
|
|
if (!(time_status & STA_PLL))
|
|
|
|
return;
|
|
|
|
|
2008-05-01 15:34:33 +04:00
|
|
|
if (!(time_status & STA_NANO))
|
2008-05-01 15:34:36 +04:00
|
|
|
offset *= NSEC_PER_USEC;
|
2008-05-01 15:34:32 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Scale the phase adjustment and
|
|
|
|
* clamp to the operating range.
|
|
|
|
*/
|
2008-05-01 15:34:36 +04:00
|
|
|
offset = min(offset, MAXPHASE);
|
|
|
|
offset = max(offset, -MAXPHASE);
|
2008-05-01 15:34:32 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Select how the frequency is to be controlled
|
|
|
|
* and in which mode (PLL or FLL).
|
|
|
|
*/
|
2010-01-29 07:20:44 +03:00
|
|
|
secs = get_seconds() - time_reftime;
|
2009-02-22 15:38:40 +03:00
|
|
|
if (unlikely(time_status & STA_FREQHOLD))
|
2009-02-22 15:29:09 +03:00
|
|
|
secs = 0;
|
|
|
|
|
2010-01-29 07:20:44 +03:00
|
|
|
time_reftime = get_seconds();
|
2008-05-01 15:34:32 +04:00
|
|
|
|
2009-02-22 14:57:49 +03:00
|
|
|
offset64 = offset;
|
2010-09-07 18:43:46 +04:00
|
|
|
freq_adj = ntp_update_offset_fll(offset64, secs);
|
2009-02-22 14:57:49 +03:00
|
|
|
|
2010-09-07 18:43:46 +04:00
|
|
|
/*
|
|
|
|
* Clamp update interval to reduce PLL gain with low
|
|
|
|
* sampling rate (e.g. intermittent network connection)
|
|
|
|
* to avoid instability.
|
|
|
|
*/
|
|
|
|
if (unlikely(secs > 1 << (SHIFT_PLL + 1 + time_constant)))
|
|
|
|
secs = 1 << (SHIFT_PLL + 1 + time_constant);
|
|
|
|
|
|
|
|
freq_adj += (offset64 * secs) <<
|
|
|
|
(NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant));
|
2009-02-22 14:57:49 +03:00
|
|
|
|
|
|
|
freq_adj = min(freq_adj + time_freq, MAXFREQ_SCALED);
|
|
|
|
|
|
|
|
time_freq = max(freq_adj, -MAXFREQ_SCALED);
|
|
|
|
|
|
|
|
time_offset = div_s64(offset64 << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ);
|
2008-05-01 15:34:32 +04:00
|
|
|
}
|
|
|
|
|
2006-10-01 10:28:22 +04:00
|
|
|
/**
|
|
|
|
* ntp_clear - Clears the NTP state variables
|
|
|
|
*/
|
|
|
|
void ntp_clear(void)
|
|
|
|
{
|
2008-02-20 09:58:42 +03:00
|
|
|
time_adjust = 0; /* stop active adjtime() */
|
|
|
|
time_status |= STA_UNSYNC;
|
|
|
|
time_maxerror = NTP_PHASE_LIMIT;
|
|
|
|
time_esterror = NTP_PHASE_LIMIT;
|
2006-10-01 10:28:22 +04:00
|
|
|
|
|
|
|
ntp_update_frequency();
|
|
|
|
|
2008-02-20 09:58:42 +03:00
|
|
|
tick_length = tick_length_base;
|
|
|
|
time_offset = 0;
|
2011-01-13 04:00:56 +03:00
|
|
|
|
|
|
|
/* Clear PPS state variables */
|
|
|
|
pps_clear();
|
2006-10-01 10:28:22 +04:00
|
|
|
}
|
|
|
|
|
2011-11-15 01:18:07 +04:00
|
|
|
|
|
|
|
u64 ntp_tick_length(void)
|
|
|
|
{
|
2013-03-22 22:52:03 +04:00
|
|
|
return tick_length;
|
2011-11-15 01:18:07 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-10-01 10:28:22 +04:00
|
|
|
/*
|
2012-03-16 00:04:03 +04:00
|
|
|
* this routine handles the overflow of the microsecond field
|
|
|
|
*
|
|
|
|
* The tricky bits of code to handle the accurate clock support
|
|
|
|
* were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame.
|
|
|
|
* They were originally developed for SUN and DEC kernels.
|
|
|
|
* All the kudos should go to Dave for this stuff.
|
|
|
|
*
|
|
|
|
* Also handles leap second processing, and returns leap offset
|
2006-10-01 10:28:22 +04:00
|
|
|
*/
|
2012-03-16 00:04:03 +04:00
|
|
|
int second_overflow(unsigned long secs)
|
2006-10-01 10:28:22 +04:00
|
|
|
{
|
2012-03-16 00:04:03 +04:00
|
|
|
s64 delta;
|
2011-11-15 01:48:36 +04:00
|
|
|
int leap = 0;
|
2012-03-16 00:04:03 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2006-10-01 10:28:22 +04:00
|
|
|
switch (time_state) {
|
|
|
|
case TIME_OK:
|
2012-03-16 00:04:03 +04:00
|
|
|
if (time_status & STA_INS)
|
|
|
|
time_state = TIME_INS;
|
|
|
|
else if (time_status & STA_DEL)
|
|
|
|
time_state = TIME_DEL;
|
2006-10-01 10:28:22 +04:00
|
|
|
break;
|
|
|
|
case TIME_INS:
|
2012-07-13 09:21:50 +04:00
|
|
|
if (!(time_status & STA_INS))
|
|
|
|
time_state = TIME_OK;
|
|
|
|
else if (secs % 86400 == 0) {
|
2012-03-16 00:04:03 +04:00
|
|
|
leap = -1;
|
|
|
|
time_state = TIME_OOP;
|
|
|
|
printk(KERN_NOTICE
|
|
|
|
"Clock: inserting leap second 23:59:60 UTC\n");
|
|
|
|
}
|
2006-10-01 10:28:22 +04:00
|
|
|
break;
|
|
|
|
case TIME_DEL:
|
2012-07-13 09:21:50 +04:00
|
|
|
if (!(time_status & STA_DEL))
|
|
|
|
time_state = TIME_OK;
|
|
|
|
else if ((secs + 1) % 86400 == 0) {
|
2012-03-16 00:04:03 +04:00
|
|
|
leap = 1;
|
|
|
|
time_state = TIME_WAIT;
|
|
|
|
printk(KERN_NOTICE
|
|
|
|
"Clock: deleting leap second 23:59:59 UTC\n");
|
|
|
|
}
|
2006-10-01 10:28:22 +04:00
|
|
|
break;
|
|
|
|
case TIME_OOP:
|
|
|
|
time_state = TIME_WAIT;
|
2012-03-16 00:04:03 +04:00
|
|
|
break;
|
|
|
|
|
2006-10-01 10:28:22 +04:00
|
|
|
case TIME_WAIT:
|
|
|
|
if (!(time_status & (STA_INS | STA_DEL)))
|
2008-05-01 15:34:32 +04:00
|
|
|
time_state = TIME_OK;
|
2008-05-01 15:34:41 +04:00
|
|
|
break;
|
|
|
|
}
|
2011-11-15 01:48:36 +04:00
|
|
|
|
2008-05-01 15:34:41 +04:00
|
|
|
|
|
|
|
/* Bump the maxerror field */
|
|
|
|
time_maxerror += MAXFREQ / NSEC_PER_USEC;
|
|
|
|
if (time_maxerror > NTP_PHASE_LIMIT) {
|
|
|
|
time_maxerror = NTP_PHASE_LIMIT;
|
|
|
|
time_status |= STA_UNSYNC;
|
2006-10-01 10:28:22 +04:00
|
|
|
}
|
|
|
|
|
2011-01-13 04:00:56 +03:00
|
|
|
/* Compute the phase adjustment for the next second */
|
2009-02-22 18:06:58 +03:00
|
|
|
tick_length = tick_length_base;
|
|
|
|
|
2011-01-13 04:00:56 +03:00
|
|
|
delta = ntp_offset_chunk(time_offset);
|
2009-02-22 18:06:58 +03:00
|
|
|
time_offset -= delta;
|
|
|
|
tick_length += delta;
|
2006-10-01 10:28:22 +04:00
|
|
|
|
2011-01-13 04:00:56 +03:00
|
|
|
/* Check PPS signal */
|
|
|
|
pps_dec_valid();
|
|
|
|
|
2009-02-22 14:06:57 +03:00
|
|
|
if (!time_adjust)
|
2011-11-15 01:48:36 +04:00
|
|
|
goto out;
|
2009-02-22 14:06:57 +03:00
|
|
|
|
|
|
|
if (time_adjust > MAX_TICKADJ) {
|
|
|
|
time_adjust -= MAX_TICKADJ;
|
|
|
|
tick_length += MAX_TICKADJ_SCALED;
|
2011-11-15 01:48:36 +04:00
|
|
|
goto out;
|
2006-10-01 10:28:22 +04:00
|
|
|
}
|
2009-02-22 14:06:57 +03:00
|
|
|
|
|
|
|
if (time_adjust < -MAX_TICKADJ) {
|
|
|
|
time_adjust += MAX_TICKADJ;
|
|
|
|
tick_length -= MAX_TICKADJ_SCALED;
|
2011-11-15 01:48:36 +04:00
|
|
|
goto out;
|
2009-02-22 14:06:57 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
tick_length += (s64)(time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)
|
|
|
|
<< NTP_SCALE_SHIFT;
|
|
|
|
time_adjust = 0;
|
2012-03-16 00:04:03 +04:00
|
|
|
|
2011-11-15 01:48:36 +04:00
|
|
|
out:
|
2012-03-16 00:04:03 +04:00
|
|
|
return leap;
|
2006-10-01 10:28:22 +04:00
|
|
|
}
|
|
|
|
|
2012-12-18 01:30:53 +04:00
|
|
|
#if defined(CONFIG_GENERIC_CMOS_UPDATE) || defined(CONFIG_RTC_SYSTOHC)
|
2008-09-23 01:42:40 +04:00
|
|
|
static void sync_cmos_clock(struct work_struct *work);
|
2007-07-21 15:37:37 +04:00
|
|
|
|
2008-09-23 01:42:40 +04:00
|
|
|
static DECLARE_DELAYED_WORK(sync_cmos_work, sync_cmos_clock);
|
2007-07-21 15:37:37 +04:00
|
|
|
|
2008-09-23 01:42:40 +04:00
|
|
|
static void sync_cmos_clock(struct work_struct *work)
|
2007-07-21 15:37:37 +04:00
|
|
|
{
|
|
|
|
struct timespec now, next;
|
|
|
|
int fail = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we have an externally synchronized Linux clock, then update
|
|
|
|
* CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
|
|
|
|
* called as close as possible to 500 ms before the new second starts.
|
|
|
|
* This code is run on a timer. If the clock is set, that timer
|
|
|
|
* may not expire at the correct time. Thus, we adjust...
|
|
|
|
*/
|
2008-02-20 09:58:42 +03:00
|
|
|
if (!ntp_synced()) {
|
2007-07-21 15:37:37 +04:00
|
|
|
/*
|
|
|
|
* Not synced, exit, do not restart a timer (if one is
|
|
|
|
* running, let it run out).
|
|
|
|
*/
|
|
|
|
return;
|
2008-02-20 09:58:42 +03:00
|
|
|
}
|
2007-07-21 15:37:37 +04:00
|
|
|
|
|
|
|
getnstimeofday(&now);
|
2012-12-18 01:30:53 +04:00
|
|
|
if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2) {
|
2013-02-09 02:59:53 +04:00
|
|
|
struct timespec adjust = now;
|
|
|
|
|
2012-12-18 01:30:53 +04:00
|
|
|
fail = -ENODEV;
|
2013-02-09 02:59:53 +04:00
|
|
|
if (persistent_clock_is_local)
|
|
|
|
adjust.tv_sec -= (sys_tz.tz_minuteswest * 60);
|
2012-12-18 01:30:53 +04:00
|
|
|
#ifdef CONFIG_GENERIC_CMOS_UPDATE
|
2013-02-09 02:59:53 +04:00
|
|
|
fail = update_persistent_clock(adjust);
|
2012-12-18 01:30:53 +04:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_RTC_SYSTOHC
|
|
|
|
if (fail == -ENODEV)
|
2013-02-09 02:59:53 +04:00
|
|
|
fail = rtc_set_ntp_time(adjust);
|
2012-12-18 01:30:53 +04:00
|
|
|
#endif
|
|
|
|
}
|
2007-07-21 15:37:37 +04:00
|
|
|
|
2008-09-06 01:05:31 +04:00
|
|
|
next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec - (TICK_NSEC / 2);
|
2007-07-21 15:37:37 +04:00
|
|
|
if (next.tv_nsec <= 0)
|
|
|
|
next.tv_nsec += NSEC_PER_SEC;
|
|
|
|
|
2012-12-18 01:30:53 +04:00
|
|
|
if (!fail || fail == -ENODEV)
|
2007-07-21 15:37:37 +04:00
|
|
|
next.tv_sec = 659;
|
|
|
|
else
|
|
|
|
next.tv_sec = 0;
|
|
|
|
|
|
|
|
if (next.tv_nsec >= NSEC_PER_SEC) {
|
|
|
|
next.tv_sec++;
|
|
|
|
next.tv_nsec -= NSEC_PER_SEC;
|
|
|
|
}
|
2008-09-23 01:42:40 +04:00
|
|
|
schedule_delayed_work(&sync_cmos_work, timespec_to_jiffies(&next));
|
2007-07-21 15:37:37 +04:00
|
|
|
}
|
|
|
|
|
2013-09-12 03:50:56 +04:00
|
|
|
void ntp_notify_cmos_timer(void)
|
2006-10-01 10:28:22 +04:00
|
|
|
{
|
2012-02-11 23:54:59 +04:00
|
|
|
schedule_delayed_work(&sync_cmos_work, 0);
|
2006-10-01 10:28:22 +04:00
|
|
|
}
|
|
|
|
|
2007-07-21 15:37:37 +04:00
|
|
|
#else
|
2013-09-12 03:50:56 +04:00
|
|
|
void ntp_notify_cmos_timer(void) { }
|
2007-07-21 15:37:37 +04:00
|
|
|
#endif
|
|
|
|
|
2009-02-22 17:15:32 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Propagate a new txc->status value into the NTP state:
|
|
|
|
*/
|
|
|
|
static inline void process_adj_status(struct timex *txc, struct timespec *ts)
|
|
|
|
{
|
|
|
|
if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) {
|
|
|
|
time_state = TIME_OK;
|
|
|
|
time_status = STA_UNSYNC;
|
2011-01-13 04:00:56 +03:00
|
|
|
/* restart PPS frequency calibration */
|
|
|
|
pps_reset_freq_interval();
|
2009-02-22 17:15:32 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we turn on PLL adjustments then reset the
|
|
|
|
* reference time to current time.
|
|
|
|
*/
|
|
|
|
if (!(time_status & STA_PLL) && (txc->status & STA_PLL))
|
2010-01-29 07:20:44 +03:00
|
|
|
time_reftime = get_seconds();
|
2009-02-22 17:15:32 +03:00
|
|
|
|
2009-02-26 20:46:14 +03:00
|
|
|
/* only set allowed bits */
|
|
|
|
time_status &= STA_RONLY;
|
2009-02-22 17:15:32 +03:00
|
|
|
time_status |= txc->status & ~STA_RONLY;
|
|
|
|
}
|
2012-04-27 12:12:41 +04:00
|
|
|
|
2013-03-22 22:52:03 +04:00
|
|
|
|
2012-05-03 23:30:07 +04:00
|
|
|
static inline void process_adjtimex_modes(struct timex *txc,
|
|
|
|
struct timespec *ts,
|
|
|
|
s32 *time_tai)
|
2009-02-22 17:15:32 +03:00
|
|
|
{
|
|
|
|
if (txc->modes & ADJ_STATUS)
|
|
|
|
process_adj_status(txc, ts);
|
|
|
|
|
|
|
|
if (txc->modes & ADJ_NANO)
|
|
|
|
time_status |= STA_NANO;
|
2009-02-22 17:35:18 +03:00
|
|
|
|
2009-02-22 17:15:32 +03:00
|
|
|
if (txc->modes & ADJ_MICRO)
|
|
|
|
time_status &= ~STA_NANO;
|
|
|
|
|
|
|
|
if (txc->modes & ADJ_FREQUENCY) {
|
2009-02-22 17:48:43 +03:00
|
|
|
time_freq = txc->freq * PPM_SCALE;
|
2009-02-22 17:15:32 +03:00
|
|
|
time_freq = min(time_freq, MAXFREQ_SCALED);
|
|
|
|
time_freq = max(time_freq, -MAXFREQ_SCALED);
|
2011-01-13 04:00:56 +03:00
|
|
|
/* update pps_freq */
|
|
|
|
pps_set_freq(time_freq);
|
2009-02-22 17:15:32 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (txc->modes & ADJ_MAXERROR)
|
|
|
|
time_maxerror = txc->maxerror;
|
2009-02-22 17:35:18 +03:00
|
|
|
|
2009-02-22 17:15:32 +03:00
|
|
|
if (txc->modes & ADJ_ESTERROR)
|
|
|
|
time_esterror = txc->esterror;
|
|
|
|
|
|
|
|
if (txc->modes & ADJ_TIMECONST) {
|
|
|
|
time_constant = txc->constant;
|
|
|
|
if (!(time_status & STA_NANO))
|
|
|
|
time_constant += 4;
|
|
|
|
time_constant = min(time_constant, (long)MAXTC);
|
|
|
|
time_constant = max(time_constant, 0l);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (txc->modes & ADJ_TAI && txc->constant > 0)
|
2012-05-03 23:30:07 +04:00
|
|
|
*time_tai = txc->constant;
|
2009-02-22 17:15:32 +03:00
|
|
|
|
|
|
|
if (txc->modes & ADJ_OFFSET)
|
|
|
|
ntp_update_offset(txc->offset);
|
2009-02-22 17:35:18 +03:00
|
|
|
|
2009-02-22 17:15:32 +03:00
|
|
|
if (txc->modes & ADJ_TICK)
|
|
|
|
tick_usec = txc->tick;
|
|
|
|
|
|
|
|
if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET))
|
|
|
|
ntp_update_frequency();
|
|
|
|
}
|
|
|
|
|
2013-03-22 22:59:04 +04:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ntp_validate_timex - Ensures the timex is ok for use in do_adjtimex
|
2006-10-01 10:28:22 +04:00
|
|
|
*/
|
2013-03-22 22:59:04 +04:00
|
|
|
int ntp_validate_timex(struct timex *txc)
|
2006-10-01 10:28:22 +04:00
|
|
|
{
|
2008-08-21 03:46:08 +04:00
|
|
|
if (txc->modes & ADJ_ADJTIME) {
|
2008-05-01 15:34:33 +04:00
|
|
|
/* singleshot must not be used with any other mode bits */
|
2008-08-21 03:46:08 +04:00
|
|
|
if (!(txc->modes & ADJ_OFFSET_SINGLESHOT))
|
2006-10-01 10:28:22 +04:00
|
|
|
return -EINVAL;
|
2008-08-21 03:46:08 +04:00
|
|
|
if (!(txc->modes & ADJ_OFFSET_READONLY) &&
|
|
|
|
!capable(CAP_SYS_TIME))
|
|
|
|
return -EPERM;
|
|
|
|
} else {
|
|
|
|
/* In order to modify anything, you gotta be super-user! */
|
|
|
|
if (txc->modes && !capable(CAP_SYS_TIME))
|
|
|
|
return -EPERM;
|
2008-02-20 09:58:42 +03:00
|
|
|
/*
|
|
|
|
* if the quartz is off by more than 10% then
|
|
|
|
* something is VERY wrong!
|
|
|
|
*/
|
2008-08-21 03:46:08 +04:00
|
|
|
if (txc->modes & ADJ_TICK &&
|
|
|
|
(txc->tick < 900000/USER_HZ ||
|
|
|
|
txc->tick > 1100000/USER_HZ))
|
2009-02-22 17:35:18 +03:00
|
|
|
return -EINVAL;
|
2007-11-26 22:42:19 +03:00
|
|
|
}
|
2006-10-01 10:28:22 +04:00
|
|
|
|
2013-03-22 22:59:04 +04:00
|
|
|
if ((txc->modes & ADJ_SETOFFSET) && (!capable(CAP_SYS_TIME)))
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* adjtimex mainly allows reading (and writing, if superuser) of
|
|
|
|
* kernel time-keeping variables. used by xntpd.
|
|
|
|
*/
|
2013-03-22 23:28:15 +04:00
|
|
|
int __do_adjtimex(struct timex *txc, struct timespec *ts, s32 *time_tai)
|
2013-03-22 22:59:04 +04:00
|
|
|
{
|
|
|
|
int result;
|
|
|
|
|
2008-08-21 03:46:08 +04:00
|
|
|
if (txc->modes & ADJ_ADJTIME) {
|
|
|
|
long save_adjust = time_adjust;
|
|
|
|
|
|
|
|
if (!(txc->modes & ADJ_OFFSET_READONLY)) {
|
|
|
|
/* adjtime() is independent from ntp_adjtime() */
|
|
|
|
time_adjust = txc->offset;
|
|
|
|
ntp_update_frequency();
|
|
|
|
}
|
|
|
|
txc->offset = save_adjust;
|
2009-02-22 17:35:18 +03:00
|
|
|
} else {
|
2008-05-01 15:34:32 +04:00
|
|
|
|
2009-02-22 17:35:18 +03:00
|
|
|
/* If there are input parameters, then process them: */
|
|
|
|
if (txc->modes)
|
2013-03-22 23:28:15 +04:00
|
|
|
process_adjtimex_modes(txc, ts, time_tai);
|
2008-05-01 15:34:33 +04:00
|
|
|
|
2009-02-22 17:35:18 +03:00
|
|
|
txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
|
2008-08-21 03:46:08 +04:00
|
|
|
NTP_SCALE_SHIFT);
|
2009-02-22 17:35:18 +03:00
|
|
|
if (!(time_status & STA_NANO))
|
|
|
|
txc->offset /= NSEC_PER_USEC;
|
|
|
|
}
|
2008-08-21 03:46:08 +04:00
|
|
|
|
2008-05-01 15:34:33 +04:00
|
|
|
result = time_state; /* mostly `TIME_OK' */
|
2011-01-13 04:00:56 +03:00
|
|
|
/* check for errors */
|
|
|
|
if (is_error_status(time_status))
|
2006-10-01 10:28:22 +04:00
|
|
|
result = TIME_ERROR;
|
|
|
|
|
2008-09-23 01:42:44 +04:00
|
|
|
txc->freq = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) *
|
2009-02-22 17:48:43 +03:00
|
|
|
PPM_SCALE_INV, NTP_SCALE_SHIFT);
|
2006-10-01 10:28:22 +04:00
|
|
|
txc->maxerror = time_maxerror;
|
|
|
|
txc->esterror = time_esterror;
|
|
|
|
txc->status = time_status;
|
|
|
|
txc->constant = time_constant;
|
2006-10-01 10:28:29 +04:00
|
|
|
txc->precision = 1;
|
2008-05-01 15:34:34 +04:00
|
|
|
txc->tolerance = MAXFREQ_SCALED / PPM_SCALE;
|
2006-10-01 10:28:22 +04:00
|
|
|
txc->tick = tick_usec;
|
2013-03-22 23:28:15 +04:00
|
|
|
txc->tai = *time_tai;
|
2006-10-01 10:28:22 +04:00
|
|
|
|
2011-01-13 04:00:56 +03:00
|
|
|
/* fill PPS status fields */
|
|
|
|
pps_fill_timex(txc);
|
2009-02-22 17:35:18 +03:00
|
|
|
|
2013-03-22 23:28:15 +04:00
|
|
|
txc->time.tv_sec = ts->tv_sec;
|
|
|
|
txc->time.tv_usec = ts->tv_nsec;
|
2008-05-01 15:34:33 +04:00
|
|
|
if (!(time_status & STA_NANO))
|
|
|
|
txc->time.tv_usec /= NSEC_PER_USEC;
|
2008-05-01 15:34:32 +04:00
|
|
|
|
|
|
|
return result;
|
2006-10-01 10:28:22 +04:00
|
|
|
}
|
time: remove obsolete CLOCK_TICK_ADJUST
The first version of the ntp_interval/tick_length inconsistent usage patch was
recently merged as bbe4d18ac2e058c56adb0cd71f49d9ed3216a405
http://git.kernel.org/gitweb.cgi?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=bbe4d18ac2e058c56adb0cd71f49d9ed3216a405
While the fix did greatly improve the situation, it was correctly pointed out
by Roman that it does have a small bug: If the users change clocksources after
the system has been running and NTP has made corrections, the correctoins made
against the old clocksource will be applied against the new clocksource,
causing error.
The second attempt, which corrects the issue in the NTP_INTERVAL_LENGTH
definition has also made it up-stream as commit
e13a2e61dd5152f5499d2003470acf9c838eab84
http://git.kernel.org/gitweb.cgi?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=e13a2e61dd5152f5499d2003470acf9c838eab84
Roman has correctly pointed out that CLOCK_TICK_ADJUST is calculated
based on the PIT's frequency, and isn't really relevant to non-PIT
driven clocksources (that is, clocksources other then jiffies and pit).
This patch reverts both of those changes, and simply removes
CLOCK_TICK_ADJUST.
This does remove the granularity error correction for users of PIT and Jiffies
clocksource users, but the granularity error but for the majority of users, it
should be within the 500ppm range NTP can accommodate for.
For systems that have granularity errors greater then 500ppm, the
"ntp_tick_adj=" boot option can be used to compensate.
[johnstul@us.ibm.com: provided changelog]
[mattilinnanvuori@yahoo.com: maek ntp_tick_adj static]
Signed-off-by: Roman Zippel <zippel@linux-m68k.org>
Acked-by: john stultz <johnstul@us.ibm.com>
Signed-off-by: Matti Linnanvuori <mattilinnanvuori@yahoo.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Cc: mingo@elte.hu
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-03-05 02:14:26 +03:00
|
|
|
|
2011-01-13 04:00:56 +03:00
|
|
|
#ifdef CONFIG_NTP_PPS
|
|
|
|
|
|
|
|
/* actually struct pps_normtime is good old struct timespec, but it is
|
|
|
|
* semantically different (and it is the reason why it was invented):
|
|
|
|
* pps_normtime.nsec has a range of ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ]
|
|
|
|
* while timespec.tv_nsec has a range of [0, NSEC_PER_SEC) */
|
|
|
|
struct pps_normtime {
|
|
|
|
__kernel_time_t sec; /* seconds */
|
|
|
|
long nsec; /* nanoseconds */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* normalize the timestamp so that nsec is in the
|
|
|
|
( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ] interval */
|
|
|
|
static inline struct pps_normtime pps_normalize_ts(struct timespec ts)
|
|
|
|
{
|
|
|
|
struct pps_normtime norm = {
|
|
|
|
.sec = ts.tv_sec,
|
|
|
|
.nsec = ts.tv_nsec
|
|
|
|
};
|
|
|
|
|
|
|
|
if (norm.nsec > (NSEC_PER_SEC >> 1)) {
|
|
|
|
norm.nsec -= NSEC_PER_SEC;
|
|
|
|
norm.sec++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return norm;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* get current phase correction and jitter */
|
|
|
|
static inline long pps_phase_filter_get(long *jitter)
|
|
|
|
{
|
|
|
|
*jitter = pps_tf[0] - pps_tf[1];
|
|
|
|
if (*jitter < 0)
|
|
|
|
*jitter = -*jitter;
|
|
|
|
|
|
|
|
/* TODO: test various filters */
|
|
|
|
return pps_tf[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add the sample to the phase filter */
|
|
|
|
static inline void pps_phase_filter_add(long err)
|
|
|
|
{
|
|
|
|
pps_tf[2] = pps_tf[1];
|
|
|
|
pps_tf[1] = pps_tf[0];
|
|
|
|
pps_tf[0] = err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* decrease frequency calibration interval length.
|
|
|
|
* It is halved after four consecutive unstable intervals.
|
|
|
|
*/
|
|
|
|
static inline void pps_dec_freq_interval(void)
|
|
|
|
{
|
|
|
|
if (--pps_intcnt <= -PPS_INTCOUNT) {
|
|
|
|
pps_intcnt = -PPS_INTCOUNT;
|
|
|
|
if (pps_shift > PPS_INTMIN) {
|
|
|
|
pps_shift--;
|
|
|
|
pps_intcnt = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* increase frequency calibration interval length.
|
|
|
|
* It is doubled after four consecutive stable intervals.
|
|
|
|
*/
|
|
|
|
static inline void pps_inc_freq_interval(void)
|
|
|
|
{
|
|
|
|
if (++pps_intcnt >= PPS_INTCOUNT) {
|
|
|
|
pps_intcnt = PPS_INTCOUNT;
|
|
|
|
if (pps_shift < PPS_INTMAX) {
|
|
|
|
pps_shift++;
|
|
|
|
pps_intcnt = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* update clock frequency based on MONOTONIC_RAW clock PPS signal
|
|
|
|
* timestamps
|
|
|
|
*
|
|
|
|
* At the end of the calibration interval the difference between the
|
|
|
|
* first and last MONOTONIC_RAW clock timestamps divided by the length
|
|
|
|
* of the interval becomes the frequency update. If the interval was
|
|
|
|
* too long, the data are discarded.
|
|
|
|
* Returns the difference between old and new frequency values.
|
|
|
|
*/
|
|
|
|
static long hardpps_update_freq(struct pps_normtime freq_norm)
|
|
|
|
{
|
|
|
|
long delta, delta_mod;
|
|
|
|
s64 ftemp;
|
|
|
|
|
|
|
|
/* check if the frequency interval was too long */
|
|
|
|
if (freq_norm.sec > (2 << pps_shift)) {
|
|
|
|
time_status |= STA_PPSERROR;
|
|
|
|
pps_errcnt++;
|
|
|
|
pps_dec_freq_interval();
|
|
|
|
pr_err("hardpps: PPSERROR: interval too long - %ld s\n",
|
|
|
|
freq_norm.sec);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* here the raw frequency offset and wander (stability) is
|
|
|
|
* calculated. If the wander is less than the wander threshold
|
|
|
|
* the interval is increased; otherwise it is decreased.
|
|
|
|
*/
|
|
|
|
ftemp = div_s64(((s64)(-freq_norm.nsec)) << NTP_SCALE_SHIFT,
|
|
|
|
freq_norm.sec);
|
|
|
|
delta = shift_right(ftemp - pps_freq, NTP_SCALE_SHIFT);
|
|
|
|
pps_freq = ftemp;
|
|
|
|
if (delta > PPS_MAXWANDER || delta < -PPS_MAXWANDER) {
|
|
|
|
pr_warning("hardpps: PPSWANDER: change=%ld\n", delta);
|
|
|
|
time_status |= STA_PPSWANDER;
|
|
|
|
pps_stbcnt++;
|
|
|
|
pps_dec_freq_interval();
|
|
|
|
} else { /* good sample */
|
|
|
|
pps_inc_freq_interval();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* the stability metric is calculated as the average of recent
|
|
|
|
* frequency changes, but is used only for performance
|
|
|
|
* monitoring
|
|
|
|
*/
|
|
|
|
delta_mod = delta;
|
|
|
|
if (delta_mod < 0)
|
|
|
|
delta_mod = -delta_mod;
|
|
|
|
pps_stabil += (div_s64(((s64)delta_mod) <<
|
|
|
|
(NTP_SCALE_SHIFT - SHIFT_USEC),
|
|
|
|
NSEC_PER_USEC) - pps_stabil) >> PPS_INTMIN;
|
|
|
|
|
|
|
|
/* if enabled, the system clock frequency is updated */
|
|
|
|
if ((time_status & STA_PPSFREQ) != 0 &&
|
|
|
|
(time_status & STA_FREQHOLD) == 0) {
|
|
|
|
time_freq = pps_freq;
|
|
|
|
ntp_update_frequency();
|
|
|
|
}
|
|
|
|
|
|
|
|
return delta;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* correct REALTIME clock phase error against PPS signal */
|
|
|
|
static void hardpps_update_phase(long error)
|
|
|
|
{
|
|
|
|
long correction = -error;
|
|
|
|
long jitter;
|
|
|
|
|
|
|
|
/* add the sample to the median filter */
|
|
|
|
pps_phase_filter_add(correction);
|
|
|
|
correction = pps_phase_filter_get(&jitter);
|
|
|
|
|
|
|
|
/* Nominal jitter is due to PPS signal noise. If it exceeds the
|
|
|
|
* threshold, the sample is discarded; otherwise, if so enabled,
|
|
|
|
* the time offset is updated.
|
|
|
|
*/
|
|
|
|
if (jitter > (pps_jitter << PPS_POPCORN)) {
|
|
|
|
pr_warning("hardpps: PPSJITTER: jitter=%ld, limit=%ld\n",
|
|
|
|
jitter, (pps_jitter << PPS_POPCORN));
|
|
|
|
time_status |= STA_PPSJITTER;
|
|
|
|
pps_jitcnt++;
|
|
|
|
} else if (time_status & STA_PPSTIME) {
|
|
|
|
/* correct the time using the phase offset */
|
|
|
|
time_offset = div_s64(((s64)correction) << NTP_SCALE_SHIFT,
|
|
|
|
NTP_INTERVAL_FREQ);
|
|
|
|
/* cancel running adjtime() */
|
|
|
|
time_adjust = 0;
|
|
|
|
}
|
|
|
|
/* update jitter */
|
|
|
|
pps_jitter += (jitter - pps_jitter) >> PPS_INTMIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2013-03-22 22:31:29 +04:00
|
|
|
* __hardpps() - discipline CPU clock oscillator to external PPS signal
|
2011-01-13 04:00:56 +03:00
|
|
|
*
|
|
|
|
* This routine is called at each PPS signal arrival in order to
|
|
|
|
* discipline the CPU clock oscillator to the PPS signal. It takes two
|
|
|
|
* parameters: REALTIME and MONOTONIC_RAW clock timestamps. The former
|
|
|
|
* is used to correct clock phase error and the latter is used to
|
|
|
|
* correct the frequency.
|
|
|
|
*
|
|
|
|
* This code is based on David Mills's reference nanokernel
|
|
|
|
* implementation. It was mostly rewritten but keeps the same idea.
|
|
|
|
*/
|
2013-03-22 22:31:29 +04:00
|
|
|
void __hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
|
2011-01-13 04:00:56 +03:00
|
|
|
{
|
|
|
|
struct pps_normtime pts_norm, freq_norm;
|
|
|
|
|
|
|
|
pts_norm = pps_normalize_ts(*phase_ts);
|
|
|
|
|
|
|
|
/* clear the error bits, they will be set again if needed */
|
|
|
|
time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR);
|
|
|
|
|
|
|
|
/* indicate signal presence */
|
|
|
|
time_status |= STA_PPSSIGNAL;
|
|
|
|
pps_valid = PPS_VALID;
|
|
|
|
|
|
|
|
/* when called for the first time,
|
|
|
|
* just start the frequency interval */
|
|
|
|
if (unlikely(pps_fbase.tv_sec == 0)) {
|
|
|
|
pps_fbase = *raw_ts;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ok, now we have a base for frequency calculation */
|
|
|
|
freq_norm = pps_normalize_ts(timespec_sub(*raw_ts, pps_fbase));
|
|
|
|
|
|
|
|
/* check that the signal is in the range
|
|
|
|
* [1s - MAXFREQ us, 1s + MAXFREQ us], otherwise reject it */
|
|
|
|
if ((freq_norm.sec == 0) ||
|
|
|
|
(freq_norm.nsec > MAXFREQ * freq_norm.sec) ||
|
|
|
|
(freq_norm.nsec < -MAXFREQ * freq_norm.sec)) {
|
|
|
|
time_status |= STA_PPSJITTER;
|
|
|
|
/* restart the frequency calibration interval */
|
|
|
|
pps_fbase = *raw_ts;
|
|
|
|
pr_err("hardpps: PPSJITTER: bad pulse\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* signal is ok */
|
|
|
|
|
|
|
|
/* check if the current frequency interval is finished */
|
|
|
|
if (freq_norm.sec >= (1 << pps_shift)) {
|
|
|
|
pps_calcnt++;
|
|
|
|
/* restart the frequency calibration interval */
|
|
|
|
pps_fbase = *raw_ts;
|
|
|
|
hardpps_update_freq(freq_norm);
|
|
|
|
}
|
|
|
|
|
|
|
|
hardpps_update_phase(pts_norm.nsec);
|
|
|
|
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_NTP_PPS */
|
|
|
|
|
time: remove obsolete CLOCK_TICK_ADJUST
The first version of the ntp_interval/tick_length inconsistent usage patch was
recently merged as bbe4d18ac2e058c56adb0cd71f49d9ed3216a405
http://git.kernel.org/gitweb.cgi?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=bbe4d18ac2e058c56adb0cd71f49d9ed3216a405
While the fix did greatly improve the situation, it was correctly pointed out
by Roman that it does have a small bug: If the users change clocksources after
the system has been running and NTP has made corrections, the correctoins made
against the old clocksource will be applied against the new clocksource,
causing error.
The second attempt, which corrects the issue in the NTP_INTERVAL_LENGTH
definition has also made it up-stream as commit
e13a2e61dd5152f5499d2003470acf9c838eab84
http://git.kernel.org/gitweb.cgi?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=e13a2e61dd5152f5499d2003470acf9c838eab84
Roman has correctly pointed out that CLOCK_TICK_ADJUST is calculated
based on the PIT's frequency, and isn't really relevant to non-PIT
driven clocksources (that is, clocksources other then jiffies and pit).
This patch reverts both of those changes, and simply removes
CLOCK_TICK_ADJUST.
This does remove the granularity error correction for users of PIT and Jiffies
clocksource users, but the granularity error but for the majority of users, it
should be within the 500ppm range NTP can accommodate for.
For systems that have granularity errors greater then 500ppm, the
"ntp_tick_adj=" boot option can be used to compensate.
[johnstul@us.ibm.com: provided changelog]
[mattilinnanvuori@yahoo.com: maek ntp_tick_adj static]
Signed-off-by: Roman Zippel <zippel@linux-m68k.org>
Acked-by: john stultz <johnstul@us.ibm.com>
Signed-off-by: Matti Linnanvuori <mattilinnanvuori@yahoo.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Cc: mingo@elte.hu
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-03-05 02:14:26 +03:00
|
|
|
static int __init ntp_tick_adj_setup(char *str)
|
|
|
|
{
|
|
|
|
ntp_tick_adj = simple_strtol(str, NULL, 0);
|
2009-02-22 18:03:37 +03:00
|
|
|
ntp_tick_adj <<= NTP_SCALE_SHIFT;
|
|
|
|
|
time: remove obsolete CLOCK_TICK_ADJUST
The first version of the ntp_interval/tick_length inconsistent usage patch was
recently merged as bbe4d18ac2e058c56adb0cd71f49d9ed3216a405
http://git.kernel.org/gitweb.cgi?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=bbe4d18ac2e058c56adb0cd71f49d9ed3216a405
While the fix did greatly improve the situation, it was correctly pointed out
by Roman that it does have a small bug: If the users change clocksources after
the system has been running and NTP has made corrections, the correctoins made
against the old clocksource will be applied against the new clocksource,
causing error.
The second attempt, which corrects the issue in the NTP_INTERVAL_LENGTH
definition has also made it up-stream as commit
e13a2e61dd5152f5499d2003470acf9c838eab84
http://git.kernel.org/gitweb.cgi?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=e13a2e61dd5152f5499d2003470acf9c838eab84
Roman has correctly pointed out that CLOCK_TICK_ADJUST is calculated
based on the PIT's frequency, and isn't really relevant to non-PIT
driven clocksources (that is, clocksources other then jiffies and pit).
This patch reverts both of those changes, and simply removes
CLOCK_TICK_ADJUST.
This does remove the granularity error correction for users of PIT and Jiffies
clocksource users, but the granularity error but for the majority of users, it
should be within the 500ppm range NTP can accommodate for.
For systems that have granularity errors greater then 500ppm, the
"ntp_tick_adj=" boot option can be used to compensate.
[johnstul@us.ibm.com: provided changelog]
[mattilinnanvuori@yahoo.com: maek ntp_tick_adj static]
Signed-off-by: Roman Zippel <zippel@linux-m68k.org>
Acked-by: john stultz <johnstul@us.ibm.com>
Signed-off-by: Matti Linnanvuori <mattilinnanvuori@yahoo.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Cc: mingo@elte.hu
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-03-05 02:14:26 +03:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__setup("ntp_tick_adj=", ntp_tick_adj_setup);
|
2008-05-01 15:34:41 +04:00
|
|
|
|
|
|
|
void __init ntp_init(void)
|
|
|
|
{
|
|
|
|
ntp_clear();
|
|
|
|
}
|