blob: 28bf91c60a0b412d1c97911659c30d735ba40d78 [file] [log] [blame]
john stultz4c7ee8d2006-09-30 23:28:22 -07001/*
john stultz4c7ee8d2006-09-30 23:28:22 -07002 * NTP state machine interfaces and logic.
3 *
4 * This code was mainly moved from kernel/timer.c and kernel/time.c
5 * Please see those files for relevant copyright info and historical
6 * changelogs.
7 */
Alexey Dobriyanaa0ac362007-07-15 23:40:39 -07008#include <linux/capability.h>
Roman Zippel7dffa3c2008-05-01 04:34:41 -07009#include <linux/clocksource.h>
Maciej W. Rozyckieb3f9382008-09-22 14:42:40 -070010#include <linux/workqueue.h>
Ingo Molnar53bbfa92008-02-20 07:58:42 +010011#include <linux/hrtimer.h>
12#include <linux/jiffies.h>
13#include <linux/math64.h>
14#include <linux/timex.h>
15#include <linux/time.h>
16#include <linux/mm.h>
Alexander Gordeev025b40a2011-01-12 17:00:56 -080017#include <linux/module.h>
Jason Gunthorpe023f3332012-12-17 14:30:53 -070018#include <linux/rtc.h>
john stultz4c7ee8d2006-09-30 23:28:22 -070019
Torben Hohne2830b52011-01-27 16:00:32 +010020#include "tick-internal.h"
John Stultzaa6f9c592013-03-22 11:31:29 -070021#include "ntp_internal.h"
Torben Hohne2830b52011-01-27 16:00:32 +010022
Roman Zippelb0ee7552006-09-30 23:28:22 -070023/*
Ingo Molnar53bbfa92008-02-20 07:58:42 +010024 * NTP timekeeping variables:
John Stultza076b212013-03-22 11:52:03 -070025 *
26 * Note: All of the NTP state is protected by the timekeeping locks.
Roman Zippelb0ee7552006-09-30 23:28:22 -070027 */
Roman Zippelb0ee7552006-09-30 23:28:22 -070028
John Stultzbd331262011-11-14 13:48:36 -080029
Ingo Molnar53bbfa92008-02-20 07:58:42 +010030/* USER_HZ period (usecs): */
31unsigned long tick_usec = TICK_USEC;
Roman Zippel7dffa3c2008-05-01 04:34:41 -070032
John Stultz02ab20a2012-07-27 14:48:10 -040033/* SHIFTED_HZ period (nsecs): */
Ingo Molnar53bbfa92008-02-20 07:58:42 +010034unsigned long tick_nsec;
35
John Stultzea7cf492011-11-14 13:18:07 -080036static u64 tick_length;
Ingo Molnar53bbfa92008-02-20 07:58:42 +010037static u64 tick_length_base;
38
Ingo Molnarbbd12672009-02-22 12:11:11 +010039#define MAX_TICKADJ 500LL /* usecs */
Ingo Molnar53bbfa92008-02-20 07:58:42 +010040#define MAX_TICKADJ_SCALED \
Ingo Molnarbbd12672009-02-22 12:11:11 +010041 (((MAX_TICKADJ * NSEC_PER_USEC) << NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ)
john stultz4c7ee8d2006-09-30 23:28:22 -070042
43/*
44 * phase-lock loop variables
45 */
Ingo Molnar53bbfa92008-02-20 07:58:42 +010046
47/*
48 * clock synchronization status
49 *
50 * (TIME_ERROR prevents overwriting the CMOS clock)
51 */
52static int time_state = TIME_OK;
53
54/* clock status bits: */
John Stultz83579292011-11-14 13:06:21 -080055static int time_status = STA_UNSYNC;
Ingo Molnar53bbfa92008-02-20 07:58:42 +010056
Ingo Molnar53bbfa92008-02-20 07:58:42 +010057/* time adjustment (nsecs): */
58static s64 time_offset;
59
60/* pll time constant: */
61static long time_constant = 2;
62
63/* maximum error (usecs): */
john stultz1f5b8f82010-01-28 15:02:41 -080064static long time_maxerror = NTP_PHASE_LIMIT;
Ingo Molnar53bbfa92008-02-20 07:58:42 +010065
66/* estimated error (usecs): */
john stultz1f5b8f82010-01-28 15:02:41 -080067static long time_esterror = NTP_PHASE_LIMIT;
Ingo Molnar53bbfa92008-02-20 07:58:42 +010068
69/* frequency offset (scaled nsecs/secs): */
70static s64 time_freq;
71
72/* time at last adjustment (secs): */
73static long time_reftime;
74
John Stultze1292ba2010-03-18 20:19:27 -070075static long time_adjust;
Ingo Molnar53bbfa92008-02-20 07:58:42 +010076
Ingo Molnar069569e2009-02-22 16:03:37 +010077/* constant (boot-param configurable) NTP tick adjustment (upscaled) */
78static s64 ntp_tick_adj;
Ingo Molnar53bbfa92008-02-20 07:58:42 +010079
Alexander Gordeev025b40a2011-01-12 17:00:56 -080080#ifdef CONFIG_NTP_PPS
81
82/*
83 * The following variables are used when a pulse-per-second (PPS) signal
84 * is available. They establish the engineering parameters of the clock
85 * discipline loop when controlled by the PPS signal.
86 */
87#define PPS_VALID 10 /* PPS signal watchdog max (s) */
88#define PPS_POPCORN 4 /* popcorn spike threshold (shift) */
89#define PPS_INTMIN 2 /* min freq interval (s) (shift) */
90#define PPS_INTMAX 8 /* max freq interval (s) (shift) */
91#define PPS_INTCOUNT 4 /* number of consecutive good intervals to
92 increase pps_shift or consecutive bad
93 intervals to decrease it */
94#define PPS_MAXWANDER 100000 /* max PPS freq wander (ns/s) */
95
96static int pps_valid; /* signal watchdog counter */
97static long pps_tf[3]; /* phase median filter */
98static long pps_jitter; /* current jitter (ns) */
99static struct timespec pps_fbase; /* beginning of the last freq interval */
100static int pps_shift; /* current interval duration (s) (shift) */
101static int pps_intcnt; /* interval counter */
102static s64 pps_freq; /* frequency offset (scaled ns/s) */
103static long pps_stabil; /* current stability (scaled ns/s) */
104
105/*
106 * PPS signal quality monitors
107 */
108static long pps_calcnt; /* calibration intervals */
109static long pps_jitcnt; /* jitter limit exceeded */
110static long pps_stbcnt; /* stability limit exceeded */
111static long pps_errcnt; /* calibration errors */
112
113
114/* PPS kernel consumer compensates the whole phase error immediately.
115 * Otherwise, reduce the offset by a fixed factor times the time constant.
116 */
117static inline s64 ntp_offset_chunk(s64 offset)
118{
119 if (time_status & STA_PPSTIME && time_status & STA_PPSSIGNAL)
120 return offset;
121 else
122 return shift_right(offset, SHIFT_PLL + time_constant);
123}
124
125static inline void pps_reset_freq_interval(void)
126{
127 /* the PPS calibration interval may end
128 surprisingly early */
129 pps_shift = PPS_INTMIN;
130 pps_intcnt = 0;
131}
132
133/**
134 * pps_clear - Clears the PPS state variables
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800135 */
136static inline void pps_clear(void)
137{
138 pps_reset_freq_interval();
139 pps_tf[0] = 0;
140 pps_tf[1] = 0;
141 pps_tf[2] = 0;
142 pps_fbase.tv_sec = pps_fbase.tv_nsec = 0;
143 pps_freq = 0;
144}
145
146/* Decrease pps_valid to indicate that another second has passed since
147 * the last PPS signal. When it reaches 0, indicate that PPS signal is
148 * missing.
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800149 */
150static inline void pps_dec_valid(void)
151{
152 if (pps_valid > 0)
153 pps_valid--;
154 else {
155 time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
156 STA_PPSWANDER | STA_PPSERROR);
157 pps_clear();
158 }
159}
160
161static inline void pps_set_freq(s64 freq)
162{
163 pps_freq = freq;
164}
165
166static inline int is_error_status(int status)
167{
George Spelvinea54bca32014-05-12 09:35:48 -0400168 return (status & (STA_UNSYNC|STA_CLOCKERR))
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800169 /* PPS signal lost when either PPS time or
170 * PPS frequency synchronization requested
171 */
George Spelvinea54bca32014-05-12 09:35:48 -0400172 || ((status & (STA_PPSFREQ|STA_PPSTIME))
173 && !(status & STA_PPSSIGNAL))
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800174 /* PPS jitter exceeded when
175 * PPS time synchronization requested */
George Spelvinea54bca32014-05-12 09:35:48 -0400176 || ((status & (STA_PPSTIME|STA_PPSJITTER))
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800177 == (STA_PPSTIME|STA_PPSJITTER))
178 /* PPS wander exceeded or calibration error when
179 * PPS frequency synchronization requested
180 */
George Spelvinea54bca32014-05-12 09:35:48 -0400181 || ((status & STA_PPSFREQ)
182 && (status & (STA_PPSWANDER|STA_PPSERROR)));
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800183}
184
185static inline void pps_fill_timex(struct timex *txc)
186{
187 txc->ppsfreq = shift_right((pps_freq >> PPM_SCALE_INV_SHIFT) *
188 PPM_SCALE_INV, NTP_SCALE_SHIFT);
189 txc->jitter = pps_jitter;
190 if (!(time_status & STA_NANO))
191 txc->jitter /= NSEC_PER_USEC;
192 txc->shift = pps_shift;
193 txc->stabil = pps_stabil;
194 txc->jitcnt = pps_jitcnt;
195 txc->calcnt = pps_calcnt;
196 txc->errcnt = pps_errcnt;
197 txc->stbcnt = pps_stbcnt;
198}
199
200#else /* !CONFIG_NTP_PPS */
201
202static inline s64 ntp_offset_chunk(s64 offset)
203{
204 return shift_right(offset, SHIFT_PLL + time_constant);
205}
206
207static inline void pps_reset_freq_interval(void) {}
208static inline void pps_clear(void) {}
209static inline void pps_dec_valid(void) {}
210static inline void pps_set_freq(s64 freq) {}
211
212static inline int is_error_status(int status)
213{
214 return status & (STA_UNSYNC|STA_CLOCKERR);
215}
216
217static inline void pps_fill_timex(struct timex *txc)
218{
219 /* PPS is not implemented, so these are zero */
220 txc->ppsfreq = 0;
221 txc->jitter = 0;
222 txc->shift = 0;
223 txc->stabil = 0;
224 txc->jitcnt = 0;
225 txc->calcnt = 0;
226 txc->errcnt = 0;
227 txc->stbcnt = 0;
228}
229
230#endif /* CONFIG_NTP_PPS */
231
John Stultz83579292011-11-14 13:06:21 -0800232
233/**
234 * ntp_synced - Returns 1 if the NTP status is not UNSYNC
235 *
236 */
237static inline int ntp_synced(void)
238{
239 return !(time_status & STA_UNSYNC);
240}
241
242
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100243/*
244 * NTP methods:
245 */
john stultz4c7ee8d2006-09-30 23:28:22 -0700246
Ingo Molnar9ce616a2009-02-22 12:42:59 +0100247/*
248 * Update (tick_length, tick_length_base, tick_nsec), based
249 * on (tick_usec, ntp_tick_adj, time_freq):
250 */
Adrian Bunk70bc42f2006-09-30 23:28:29 -0700251static void ntp_update_frequency(void)
252{
Ingo Molnar9ce616a2009-02-22 12:42:59 +0100253 u64 second_length;
Ingo Molnarbc26c312009-02-22 12:17:36 +0100254 u64 new_base;
Adrian Bunk70bc42f2006-09-30 23:28:29 -0700255
Ingo Molnar9ce616a2009-02-22 12:42:59 +0100256 second_length = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ)
257 << NTP_SCALE_SHIFT;
258
Ingo Molnar069569e2009-02-22 16:03:37 +0100259 second_length += ntp_tick_adj;
Ingo Molnar9ce616a2009-02-22 12:42:59 +0100260 second_length += time_freq;
261
Ingo Molnar9ce616a2009-02-22 12:42:59 +0100262 tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
Ingo Molnarbc26c312009-02-22 12:17:36 +0100263 new_base = div_u64(second_length, NTP_INTERVAL_FREQ);
john stultzfdcedf72009-02-18 16:02:22 -0800264
265 /*
266 * Don't wait for the next second_overflow, apply
Ingo Molnarbc26c312009-02-22 12:17:36 +0100267 * the change to the tick length immediately:
john stultzfdcedf72009-02-18 16:02:22 -0800268 */
Ingo Molnarbc26c312009-02-22 12:17:36 +0100269 tick_length += new_base - tick_length_base;
270 tick_length_base = new_base;
Adrian Bunk70bc42f2006-09-30 23:28:29 -0700271}
272
Ingo Molnar478b7aa2009-02-22 13:22:23 +0100273static inline s64 ntp_update_offset_fll(s64 offset64, long secs)
Ingo Molnarf9398902009-02-22 12:57:49 +0100274{
275 time_status &= ~STA_MODE;
276
277 if (secs < MINSEC)
Ingo Molnar478b7aa2009-02-22 13:22:23 +0100278 return 0;
Ingo Molnarf9398902009-02-22 12:57:49 +0100279
280 if (!(time_status & STA_FLL) && (secs <= MAXSEC))
Ingo Molnar478b7aa2009-02-22 13:22:23 +0100281 return 0;
Ingo Molnarf9398902009-02-22 12:57:49 +0100282
Ingo Molnarf9398902009-02-22 12:57:49 +0100283 time_status |= STA_MODE;
284
Sasha Levina078c6d2012-03-15 12:36:14 -0400285 return div64_long(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs);
Ingo Molnarf9398902009-02-22 12:57:49 +0100286}
287
Roman Zippelee9851b2008-05-01 04:34:32 -0700288static void ntp_update_offset(long offset)
289{
Roman Zippelee9851b2008-05-01 04:34:32 -0700290 s64 freq_adj;
Ingo Molnarf9398902009-02-22 12:57:49 +0100291 s64 offset64;
292 long secs;
Roman Zippelee9851b2008-05-01 04:34:32 -0700293
294 if (!(time_status & STA_PLL))
295 return;
296
Roman Zippeleea83d82008-05-01 04:34:33 -0700297 if (!(time_status & STA_NANO))
Roman Zippel9f14f662008-05-01 04:34:36 -0700298 offset *= NSEC_PER_USEC;
Roman Zippelee9851b2008-05-01 04:34:32 -0700299
300 /*
301 * Scale the phase adjustment and
302 * clamp to the operating range.
303 */
Roman Zippel9f14f662008-05-01 04:34:36 -0700304 offset = min(offset, MAXPHASE);
305 offset = max(offset, -MAXPHASE);
Roman Zippelee9851b2008-05-01 04:34:32 -0700306
307 /*
308 * Select how the frequency is to be controlled
309 * and in which mode (PLL or FLL).
310 */
John Stultz7e1b5842010-01-28 20:20:44 -0800311 secs = get_seconds() - time_reftime;
Ingo Molnar10dd31a2009-02-22 13:38:40 +0100312 if (unlikely(time_status & STA_FREQHOLD))
Ingo Molnarc7986ac2009-02-22 13:29:09 +0100313 secs = 0;
314
John Stultz7e1b5842010-01-28 20:20:44 -0800315 time_reftime = get_seconds();
Roman Zippelee9851b2008-05-01 04:34:32 -0700316
Ingo Molnarf9398902009-02-22 12:57:49 +0100317 offset64 = offset;
Miroslav Lichvar8af3c152010-09-07 16:43:46 +0200318 freq_adj = ntp_update_offset_fll(offset64, secs);
Roman Zippel9f14f662008-05-01 04:34:36 -0700319
Miroslav Lichvar8af3c152010-09-07 16:43:46 +0200320 /*
321 * Clamp update interval to reduce PLL gain with low
322 * sampling rate (e.g. intermittent network connection)
323 * to avoid instability.
324 */
325 if (unlikely(secs > 1 << (SHIFT_PLL + 1 + time_constant)))
326 secs = 1 << (SHIFT_PLL + 1 + time_constant);
327
328 freq_adj += (offset64 * secs) <<
329 (NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant));
Ingo Molnarf9398902009-02-22 12:57:49 +0100330
331 freq_adj = min(freq_adj + time_freq, MAXFREQ_SCALED);
332
333 time_freq = max(freq_adj, -MAXFREQ_SCALED);
334
335 time_offset = div_s64(offset64 << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ);
Roman Zippelee9851b2008-05-01 04:34:32 -0700336}
337
Roman Zippelb0ee7552006-09-30 23:28:22 -0700338/**
339 * ntp_clear - Clears the NTP state variables
Roman Zippelb0ee7552006-09-30 23:28:22 -0700340 */
341void ntp_clear(void)
342{
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100343 time_adjust = 0; /* stop active adjtime() */
344 time_status |= STA_UNSYNC;
345 time_maxerror = NTP_PHASE_LIMIT;
346 time_esterror = NTP_PHASE_LIMIT;
Roman Zippelb0ee7552006-09-30 23:28:22 -0700347
348 ntp_update_frequency();
349
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100350 tick_length = tick_length_base;
351 time_offset = 0;
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800352
353 /* Clear PPS state variables */
354 pps_clear();
Roman Zippelb0ee7552006-09-30 23:28:22 -0700355}
356
John Stultzea7cf492011-11-14 13:18:07 -0800357
358u64 ntp_tick_length(void)
359{
John Stultza076b212013-03-22 11:52:03 -0700360 return tick_length;
John Stultzea7cf492011-11-14 13:18:07 -0800361}
362
363
john stultz4c7ee8d2006-09-30 23:28:22 -0700364/*
365 * this routine handles the overflow of the microsecond field
366 *
367 * The tricky bits of code to handle the accurate clock support
368 * were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame.
369 * They were originally developed for SUN and DEC kernels.
370 * All the kudos should go to Dave for this stuff.
John Stultz6b43ae82012-03-15 13:04:03 -0700371 *
372 * Also handles leap second processing, and returns leap offset
john stultz4c7ee8d2006-09-30 23:28:22 -0700373 */
John Stultz6b43ae82012-03-15 13:04:03 -0700374int second_overflow(unsigned long secs)
john stultz4c7ee8d2006-09-30 23:28:22 -0700375{
Ingo Molnar39854fe2009-02-22 16:06:58 +0100376 s64 delta;
John Stultz6b43ae82012-03-15 13:04:03 -0700377 int leap = 0;
john stultz4c7ee8d2006-09-30 23:28:22 -0700378
John Stultz6b43ae82012-03-15 13:04:03 -0700379 /*
380 * Leap second processing. If in leap-insert state at the end of the
381 * day, the system clock is set back one second; if in leap-delete
382 * state, the system clock is set ahead one second.
383 */
384 switch (time_state) {
385 case TIME_OK:
386 if (time_status & STA_INS)
387 time_state = TIME_INS;
388 else if (time_status & STA_DEL)
389 time_state = TIME_DEL;
390 break;
391 case TIME_INS:
John Stultz6b1859d2012-07-13 01:21:50 -0400392 if (!(time_status & STA_INS))
393 time_state = TIME_OK;
394 else if (secs % 86400 == 0) {
John Stultz6b43ae82012-03-15 13:04:03 -0700395 leap = -1;
396 time_state = TIME_OOP;
397 printk(KERN_NOTICE
398 "Clock: inserting leap second 23:59:60 UTC\n");
399 }
400 break;
401 case TIME_DEL:
John Stultz6b1859d2012-07-13 01:21:50 -0400402 if (!(time_status & STA_DEL))
403 time_state = TIME_OK;
404 else if ((secs + 1) % 86400 == 0) {
John Stultz6b43ae82012-03-15 13:04:03 -0700405 leap = 1;
John Stultz6b43ae82012-03-15 13:04:03 -0700406 time_state = TIME_WAIT;
407 printk(KERN_NOTICE
408 "Clock: deleting leap second 23:59:59 UTC\n");
409 }
410 break;
411 case TIME_OOP:
John Stultz6b43ae82012-03-15 13:04:03 -0700412 time_state = TIME_WAIT;
413 break;
414
415 case TIME_WAIT:
416 if (!(time_status & (STA_INS | STA_DEL)))
417 time_state = TIME_OK;
418 break;
419 }
420
421
john stultz4c7ee8d2006-09-30 23:28:22 -0700422 /* Bump the maxerror field */
Roman Zippel074b3b82008-05-01 04:34:34 -0700423 time_maxerror += MAXFREQ / NSEC_PER_USEC;
john stultz4c7ee8d2006-09-30 23:28:22 -0700424 if (time_maxerror > NTP_PHASE_LIMIT) {
425 time_maxerror = NTP_PHASE_LIMIT;
426 time_status |= STA_UNSYNC;
427 }
428
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800429 /* Compute the phase adjustment for the next second */
Ingo Molnar39854fe2009-02-22 16:06:58 +0100430 tick_length = tick_length_base;
431
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800432 delta = ntp_offset_chunk(time_offset);
Ingo Molnar39854fe2009-02-22 16:06:58 +0100433 time_offset -= delta;
434 tick_length += delta;
john stultz4c7ee8d2006-09-30 23:28:22 -0700435
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800436 /* Check PPS signal */
437 pps_dec_valid();
438
Ingo Molnar3c972c22009-02-22 12:06:57 +0100439 if (!time_adjust)
John Stultzbd331262011-11-14 13:48:36 -0800440 goto out;
Ingo Molnar3c972c22009-02-22 12:06:57 +0100441
442 if (time_adjust > MAX_TICKADJ) {
443 time_adjust -= MAX_TICKADJ;
444 tick_length += MAX_TICKADJ_SCALED;
John Stultzbd331262011-11-14 13:48:36 -0800445 goto out;
john stultz4c7ee8d2006-09-30 23:28:22 -0700446 }
Ingo Molnar3c972c22009-02-22 12:06:57 +0100447
448 if (time_adjust < -MAX_TICKADJ) {
449 time_adjust += MAX_TICKADJ;
450 tick_length -= MAX_TICKADJ_SCALED;
John Stultzbd331262011-11-14 13:48:36 -0800451 goto out;
Ingo Molnar3c972c22009-02-22 12:06:57 +0100452 }
453
454 tick_length += (s64)(time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)
455 << NTP_SCALE_SHIFT;
456 time_adjust = 0;
John Stultz6b43ae82012-03-15 13:04:03 -0700457
John Stultzbd331262011-11-14 13:48:36 -0800458out:
John Stultz6b43ae82012-03-15 13:04:03 -0700459 return leap;
john stultz4c7ee8d2006-09-30 23:28:22 -0700460}
461
Jason Gunthorpe023f3332012-12-17 14:30:53 -0700462#if defined(CONFIG_GENERIC_CMOS_UPDATE) || defined(CONFIG_RTC_SYSTOHC)
Maciej W. Rozyckieb3f9382008-09-22 14:42:40 -0700463static void sync_cmos_clock(struct work_struct *work);
Thomas Gleixner82644452007-07-21 04:37:37 -0700464
Maciej W. Rozyckieb3f9382008-09-22 14:42:40 -0700465static DECLARE_DELAYED_WORK(sync_cmos_work, sync_cmos_clock);
Thomas Gleixner82644452007-07-21 04:37:37 -0700466
Maciej W. Rozyckieb3f9382008-09-22 14:42:40 -0700467static void sync_cmos_clock(struct work_struct *work)
john stultz4c7ee8d2006-09-30 23:28:22 -0700468{
Thomas Gleixnerd6d29892014-07-16 21:04:04 +0000469 struct timespec64 now;
470 struct timespec next;
Thomas Gleixner82644452007-07-21 04:37:37 -0700471 int fail = 1;
472
473 /*
474 * If we have an externally synchronized Linux clock, then update
475 * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
476 * called as close as possible to 500 ms before the new second starts.
477 * This code is run on a timer. If the clock is set, that timer
478 * may not expire at the correct time. Thus, we adjust...
Miroslav Lichvara97ad0c2013-08-01 19:31:35 +0200479 * We want the clock to be within a couple of ticks from the target.
Thomas Gleixner82644452007-07-21 04:37:37 -0700480 */
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100481 if (!ntp_synced()) {
Thomas Gleixner82644452007-07-21 04:37:37 -0700482 /*
483 * Not synced, exit, do not restart a timer (if one is
484 * running, let it run out).
485 */
486 return;
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100487 }
Thomas Gleixner82644452007-07-21 04:37:37 -0700488
Thomas Gleixnerd6d29892014-07-16 21:04:04 +0000489 getnstimeofday64(&now);
Miroslav Lichvara97ad0c2013-08-01 19:31:35 +0200490 if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec * 5) {
Thomas Gleixnerd6d29892014-07-16 21:04:04 +0000491 struct timespec adjust = timespec64_to_timespec(now);
Prarit Bhargava84e345e2013-02-08 17:59:53 -0500492
Jason Gunthorpe023f3332012-12-17 14:30:53 -0700493 fail = -ENODEV;
Prarit Bhargava84e345e2013-02-08 17:59:53 -0500494 if (persistent_clock_is_local)
495 adjust.tv_sec -= (sys_tz.tz_minuteswest * 60);
Jason Gunthorpe023f3332012-12-17 14:30:53 -0700496#ifdef CONFIG_GENERIC_CMOS_UPDATE
Prarit Bhargava84e345e2013-02-08 17:59:53 -0500497 fail = update_persistent_clock(adjust);
Jason Gunthorpe023f3332012-12-17 14:30:53 -0700498#endif
499#ifdef CONFIG_RTC_SYSTOHC
500 if (fail == -ENODEV)
Prarit Bhargava84e345e2013-02-08 17:59:53 -0500501 fail = rtc_set_ntp_time(adjust);
Jason Gunthorpe023f3332012-12-17 14:30:53 -0700502#endif
503 }
Thomas Gleixner82644452007-07-21 04:37:37 -0700504
Maciej W. Rozycki4ff4b9e2008-09-05 14:05:31 -0700505 next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec - (TICK_NSEC / 2);
Thomas Gleixner82644452007-07-21 04:37:37 -0700506 if (next.tv_nsec <= 0)
507 next.tv_nsec += NSEC_PER_SEC;
508
Jason Gunthorpe023f3332012-12-17 14:30:53 -0700509 if (!fail || fail == -ENODEV)
Thomas Gleixner82644452007-07-21 04:37:37 -0700510 next.tv_sec = 659;
511 else
512 next.tv_sec = 0;
513
514 if (next.tv_nsec >= NSEC_PER_SEC) {
515 next.tv_sec++;
516 next.tv_nsec -= NSEC_PER_SEC;
517 }
Shaibal Duttae8b17592014-01-31 11:18:24 -0800518 queue_delayed_work(system_power_efficient_wq,
519 &sync_cmos_work, timespec_to_jiffies(&next));
john stultz4c7ee8d2006-09-30 23:28:22 -0700520}
521
John Stultz7bd36012013-09-11 16:50:56 -0700522void ntp_notify_cmos_timer(void)
Thomas Gleixner82644452007-07-21 04:37:37 -0700523{
Shaibal Duttae8b17592014-01-31 11:18:24 -0800524 queue_delayed_work(system_power_efficient_wq, &sync_cmos_work, 0);
Thomas Gleixner82644452007-07-21 04:37:37 -0700525}
526
527#else
John Stultz7bd36012013-09-11 16:50:56 -0700528void ntp_notify_cmos_timer(void) { }
Thomas Gleixner82644452007-07-21 04:37:37 -0700529#endif
530
Ingo Molnar80f22572009-02-22 15:15:32 +0100531
532/*
533 * Propagate a new txc->status value into the NTP state:
534 */
John Stultz7d489d12014-07-16 21:04:01 +0000535static inline void process_adj_status(struct timex *txc, struct timespec64 *ts)
Ingo Molnar80f22572009-02-22 15:15:32 +0100536{
Ingo Molnar80f22572009-02-22 15:15:32 +0100537 if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) {
538 time_state = TIME_OK;
539 time_status = STA_UNSYNC;
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800540 /* restart PPS frequency calibration */
541 pps_reset_freq_interval();
Ingo Molnar80f22572009-02-22 15:15:32 +0100542 }
Ingo Molnar80f22572009-02-22 15:15:32 +0100543
544 /*
545 * If we turn on PLL adjustments then reset the
546 * reference time to current time.
547 */
548 if (!(time_status & STA_PLL) && (txc->status & STA_PLL))
John Stultz7e1b5842010-01-28 20:20:44 -0800549 time_reftime = get_seconds();
Ingo Molnar80f22572009-02-22 15:15:32 +0100550
John Stultza2a5ac82009-02-26 09:46:14 -0800551 /* only set allowed bits */
552 time_status &= STA_RONLY;
Ingo Molnar80f22572009-02-22 15:15:32 +0100553 time_status |= txc->status & ~STA_RONLY;
Ingo Molnar80f22572009-02-22 15:15:32 +0100554}
Richard Cochrancd5398b2012-04-27 10:12:41 +0200555
John Stultza076b212013-03-22 11:52:03 -0700556
John Stultzcc244dd2012-05-03 12:30:07 -0700557static inline void process_adjtimex_modes(struct timex *txc,
John Stultz7d489d12014-07-16 21:04:01 +0000558 struct timespec64 *ts,
John Stultzcc244dd2012-05-03 12:30:07 -0700559 s32 *time_tai)
Ingo Molnar80f22572009-02-22 15:15:32 +0100560{
561 if (txc->modes & ADJ_STATUS)
562 process_adj_status(txc, ts);
563
564 if (txc->modes & ADJ_NANO)
565 time_status |= STA_NANO;
Ingo Molnare9629162009-02-22 15:35:18 +0100566
Ingo Molnar80f22572009-02-22 15:15:32 +0100567 if (txc->modes & ADJ_MICRO)
568 time_status &= ~STA_NANO;
569
570 if (txc->modes & ADJ_FREQUENCY) {
Ingo Molnar2b9d1492009-02-22 15:48:43 +0100571 time_freq = txc->freq * PPM_SCALE;
Ingo Molnar80f22572009-02-22 15:15:32 +0100572 time_freq = min(time_freq, MAXFREQ_SCALED);
573 time_freq = max(time_freq, -MAXFREQ_SCALED);
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800574 /* update pps_freq */
575 pps_set_freq(time_freq);
Ingo Molnar80f22572009-02-22 15:15:32 +0100576 }
577
578 if (txc->modes & ADJ_MAXERROR)
579 time_maxerror = txc->maxerror;
Ingo Molnare9629162009-02-22 15:35:18 +0100580
Ingo Molnar80f22572009-02-22 15:15:32 +0100581 if (txc->modes & ADJ_ESTERROR)
582 time_esterror = txc->esterror;
583
584 if (txc->modes & ADJ_TIMECONST) {
585 time_constant = txc->constant;
586 if (!(time_status & STA_NANO))
587 time_constant += 4;
588 time_constant = min(time_constant, (long)MAXTC);
589 time_constant = max(time_constant, 0l);
590 }
591
592 if (txc->modes & ADJ_TAI && txc->constant > 0)
John Stultzcc244dd2012-05-03 12:30:07 -0700593 *time_tai = txc->constant;
Ingo Molnar80f22572009-02-22 15:15:32 +0100594
595 if (txc->modes & ADJ_OFFSET)
596 ntp_update_offset(txc->offset);
Ingo Molnare9629162009-02-22 15:35:18 +0100597
Ingo Molnar80f22572009-02-22 15:15:32 +0100598 if (txc->modes & ADJ_TICK)
599 tick_usec = txc->tick;
600
601 if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET))
602 ntp_update_frequency();
603}
604
john stultz4c7ee8d2006-09-30 23:28:22 -0700605
John Stultzad460962013-03-22 11:59:04 -0700606
607/**
608 * ntp_validate_timex - Ensures the timex is ok for use in do_adjtimex
609 */
610int ntp_validate_timex(struct timex *txc)
611{
Roman Zippel916c7a82008-08-20 16:46:08 -0700612 if (txc->modes & ADJ_ADJTIME) {
Roman Zippeleea83d82008-05-01 04:34:33 -0700613 /* singleshot must not be used with any other mode bits */
Roman Zippel916c7a82008-08-20 16:46:08 -0700614 if (!(txc->modes & ADJ_OFFSET_SINGLESHOT))
john stultz4c7ee8d2006-09-30 23:28:22 -0700615 return -EINVAL;
Roman Zippel916c7a82008-08-20 16:46:08 -0700616 if (!(txc->modes & ADJ_OFFSET_READONLY) &&
617 !capable(CAP_SYS_TIME))
618 return -EPERM;
619 } else {
620 /* In order to modify anything, you gotta be super-user! */
621 if (txc->modes && !capable(CAP_SYS_TIME))
622 return -EPERM;
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100623 /*
624 * if the quartz is off by more than 10% then
625 * something is VERY wrong!
626 */
Roman Zippel916c7a82008-08-20 16:46:08 -0700627 if (txc->modes & ADJ_TICK &&
628 (txc->tick < 900000/USER_HZ ||
629 txc->tick > 1100000/USER_HZ))
Ingo Molnare9629162009-02-22 15:35:18 +0100630 return -EINVAL;
John Stultz52bfb362007-11-26 20:42:19 +0100631 }
john stultz4c7ee8d2006-09-30 23:28:22 -0700632
John Stultzad460962013-03-22 11:59:04 -0700633 if ((txc->modes & ADJ_SETOFFSET) && (!capable(CAP_SYS_TIME)))
634 return -EPERM;
635
Sasha Levin5e5aeb42014-12-03 19:25:05 -0500636 if (txc->modes & ADJ_FREQUENCY) {
637 if (LONG_MIN / PPM_SCALE > txc->freq)
638 return -EINVAL;
639 if (LONG_MAX / PPM_SCALE < txc->freq)
640 return -EINVAL;
641 }
642
John Stultzad460962013-03-22 11:59:04 -0700643 return 0;
644}
645
646
647/*
648 * adjtimex mainly allows reading (and writing, if superuser) of
649 * kernel time-keeping variables. used by xntpd.
650 */
John Stultz7d489d12014-07-16 21:04:01 +0000651int __do_adjtimex(struct timex *txc, struct timespec64 *ts, s32 *time_tai)
John Stultzad460962013-03-22 11:59:04 -0700652{
John Stultzad460962013-03-22 11:59:04 -0700653 int result;
654
Roman Zippel916c7a82008-08-20 16:46:08 -0700655 if (txc->modes & ADJ_ADJTIME) {
656 long save_adjust = time_adjust;
657
658 if (!(txc->modes & ADJ_OFFSET_READONLY)) {
659 /* adjtime() is independent from ntp_adjtime() */
660 time_adjust = txc->offset;
661 ntp_update_frequency();
662 }
663 txc->offset = save_adjust;
Ingo Molnare9629162009-02-22 15:35:18 +0100664 } else {
665
666 /* If there are input parameters, then process them: */
667 if (txc->modes)
John Stultz87ace392013-03-22 12:28:15 -0700668 process_adjtimex_modes(txc, ts, time_tai);
Ingo Molnare9629162009-02-22 15:35:18 +0100669
670 txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
671 NTP_SCALE_SHIFT);
672 if (!(time_status & STA_NANO))
673 txc->offset /= NSEC_PER_USEC;
Roman Zippel916c7a82008-08-20 16:46:08 -0700674 }
Roman Zippel916c7a82008-08-20 16:46:08 -0700675
Roman Zippeleea83d82008-05-01 04:34:33 -0700676 result = time_state; /* mostly `TIME_OK' */
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800677 /* check for errors */
678 if (is_error_status(time_status))
john stultz4c7ee8d2006-09-30 23:28:22 -0700679 result = TIME_ERROR;
680
Roman Zippeld40e9442008-09-22 14:42:44 -0700681 txc->freq = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) *
Ingo Molnar2b9d1492009-02-22 15:48:43 +0100682 PPM_SCALE_INV, NTP_SCALE_SHIFT);
john stultz4c7ee8d2006-09-30 23:28:22 -0700683 txc->maxerror = time_maxerror;
684 txc->esterror = time_esterror;
685 txc->status = time_status;
686 txc->constant = time_constant;
Adrian Bunk70bc42f2006-09-30 23:28:29 -0700687 txc->precision = 1;
Roman Zippel074b3b82008-05-01 04:34:34 -0700688 txc->tolerance = MAXFREQ_SCALED / PPM_SCALE;
john stultz4c7ee8d2006-09-30 23:28:22 -0700689 txc->tick = tick_usec;
John Stultz87ace392013-03-22 12:28:15 -0700690 txc->tai = *time_tai;
john stultz4c7ee8d2006-09-30 23:28:22 -0700691
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800692 /* fill PPS status fields */
693 pps_fill_timex(txc);
Ingo Molnare9629162009-02-22 15:35:18 +0100694
John Stultz7d489d12014-07-16 21:04:01 +0000695 txc->time.tv_sec = (time_t)ts->tv_sec;
John Stultz87ace392013-03-22 12:28:15 -0700696 txc->time.tv_usec = ts->tv_nsec;
Roman Zippeleea83d82008-05-01 04:34:33 -0700697 if (!(time_status & STA_NANO))
698 txc->time.tv_usec /= NSEC_PER_USEC;
Roman Zippelee9851b2008-05-01 04:34:32 -0700699
Roman Zippelee9851b2008-05-01 04:34:32 -0700700 return result;
john stultz4c7ee8d2006-09-30 23:28:22 -0700701}
Roman Zippel10a398d2008-03-04 15:14:26 -0800702
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800703#ifdef CONFIG_NTP_PPS
704
705/* actually struct pps_normtime is good old struct timespec, but it is
706 * semantically different (and it is the reason why it was invented):
707 * pps_normtime.nsec has a range of ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ]
708 * while timespec.tv_nsec has a range of [0, NSEC_PER_SEC) */
709struct pps_normtime {
710 __kernel_time_t sec; /* seconds */
711 long nsec; /* nanoseconds */
712};
713
714/* normalize the timestamp so that nsec is in the
715 ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ] interval */
716static inline struct pps_normtime pps_normalize_ts(struct timespec ts)
717{
718 struct pps_normtime norm = {
719 .sec = ts.tv_sec,
720 .nsec = ts.tv_nsec
721 };
722
723 if (norm.nsec > (NSEC_PER_SEC >> 1)) {
724 norm.nsec -= NSEC_PER_SEC;
725 norm.sec++;
726 }
727
728 return norm;
729}
730
731/* get current phase correction and jitter */
732static inline long pps_phase_filter_get(long *jitter)
733{
734 *jitter = pps_tf[0] - pps_tf[1];
735 if (*jitter < 0)
736 *jitter = -*jitter;
737
738 /* TODO: test various filters */
739 return pps_tf[0];
740}
741
742/* add the sample to the phase filter */
743static inline void pps_phase_filter_add(long err)
744{
745 pps_tf[2] = pps_tf[1];
746 pps_tf[1] = pps_tf[0];
747 pps_tf[0] = err;
748}
749
750/* decrease frequency calibration interval length.
751 * It is halved after four consecutive unstable intervals.
752 */
753static inline void pps_dec_freq_interval(void)
754{
755 if (--pps_intcnt <= -PPS_INTCOUNT) {
756 pps_intcnt = -PPS_INTCOUNT;
757 if (pps_shift > PPS_INTMIN) {
758 pps_shift--;
759 pps_intcnt = 0;
760 }
761 }
762}
763
764/* increase frequency calibration interval length.
765 * It is doubled after four consecutive stable intervals.
766 */
767static inline void pps_inc_freq_interval(void)
768{
769 if (++pps_intcnt >= PPS_INTCOUNT) {
770 pps_intcnt = PPS_INTCOUNT;
771 if (pps_shift < PPS_INTMAX) {
772 pps_shift++;
773 pps_intcnt = 0;
774 }
775 }
776}
777
778/* update clock frequency based on MONOTONIC_RAW clock PPS signal
779 * timestamps
780 *
781 * At the end of the calibration interval the difference between the
782 * first and last MONOTONIC_RAW clock timestamps divided by the length
783 * of the interval becomes the frequency update. If the interval was
784 * too long, the data are discarded.
785 * Returns the difference between old and new frequency values.
786 */
787static long hardpps_update_freq(struct pps_normtime freq_norm)
788{
789 long delta, delta_mod;
790 s64 ftemp;
791
792 /* check if the frequency interval was too long */
793 if (freq_norm.sec > (2 << pps_shift)) {
794 time_status |= STA_PPSERROR;
795 pps_errcnt++;
796 pps_dec_freq_interval();
John Stultz6d9bcb62014-06-04 16:11:43 -0700797 printk_deferred(KERN_ERR
798 "hardpps: PPSERROR: interval too long - %ld s\n",
799 freq_norm.sec);
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800800 return 0;
801 }
802
803 /* here the raw frequency offset and wander (stability) is
804 * calculated. If the wander is less than the wander threshold
805 * the interval is increased; otherwise it is decreased.
806 */
807 ftemp = div_s64(((s64)(-freq_norm.nsec)) << NTP_SCALE_SHIFT,
808 freq_norm.sec);
809 delta = shift_right(ftemp - pps_freq, NTP_SCALE_SHIFT);
810 pps_freq = ftemp;
811 if (delta > PPS_MAXWANDER || delta < -PPS_MAXWANDER) {
John Stultz6d9bcb62014-06-04 16:11:43 -0700812 printk_deferred(KERN_WARNING
813 "hardpps: PPSWANDER: change=%ld\n", delta);
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800814 time_status |= STA_PPSWANDER;
815 pps_stbcnt++;
816 pps_dec_freq_interval();
817 } else { /* good sample */
818 pps_inc_freq_interval();
819 }
820
821 /* the stability metric is calculated as the average of recent
822 * frequency changes, but is used only for performance
823 * monitoring
824 */
825 delta_mod = delta;
826 if (delta_mod < 0)
827 delta_mod = -delta_mod;
828 pps_stabil += (div_s64(((s64)delta_mod) <<
829 (NTP_SCALE_SHIFT - SHIFT_USEC),
830 NSEC_PER_USEC) - pps_stabil) >> PPS_INTMIN;
831
832 /* if enabled, the system clock frequency is updated */
833 if ((time_status & STA_PPSFREQ) != 0 &&
834 (time_status & STA_FREQHOLD) == 0) {
835 time_freq = pps_freq;
836 ntp_update_frequency();
837 }
838
839 return delta;
840}
841
842/* correct REALTIME clock phase error against PPS signal */
843static void hardpps_update_phase(long error)
844{
845 long correction = -error;
846 long jitter;
847
848 /* add the sample to the median filter */
849 pps_phase_filter_add(correction);
850 correction = pps_phase_filter_get(&jitter);
851
852 /* Nominal jitter is due to PPS signal noise. If it exceeds the
853 * threshold, the sample is discarded; otherwise, if so enabled,
854 * the time offset is updated.
855 */
856 if (jitter > (pps_jitter << PPS_POPCORN)) {
John Stultz6d9bcb62014-06-04 16:11:43 -0700857 printk_deferred(KERN_WARNING
858 "hardpps: PPSJITTER: jitter=%ld, limit=%ld\n",
859 jitter, (pps_jitter << PPS_POPCORN));
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800860 time_status |= STA_PPSJITTER;
861 pps_jitcnt++;
862 } else if (time_status & STA_PPSTIME) {
863 /* correct the time using the phase offset */
864 time_offset = div_s64(((s64)correction) << NTP_SCALE_SHIFT,
865 NTP_INTERVAL_FREQ);
866 /* cancel running adjtime() */
867 time_adjust = 0;
868 }
869 /* update jitter */
870 pps_jitter += (jitter - pps_jitter) >> PPS_INTMIN;
871}
872
873/*
John Stultzaa6f9c592013-03-22 11:31:29 -0700874 * __hardpps() - discipline CPU clock oscillator to external PPS signal
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800875 *
876 * This routine is called at each PPS signal arrival in order to
877 * discipline the CPU clock oscillator to the PPS signal. It takes two
878 * parameters: REALTIME and MONOTONIC_RAW clock timestamps. The former
879 * is used to correct clock phase error and the latter is used to
880 * correct the frequency.
881 *
882 * This code is based on David Mills's reference nanokernel
883 * implementation. It was mostly rewritten but keeps the same idea.
884 */
John Stultzaa6f9c592013-03-22 11:31:29 -0700885void __hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800886{
887 struct pps_normtime pts_norm, freq_norm;
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800888
889 pts_norm = pps_normalize_ts(*phase_ts);
890
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800891 /* clear the error bits, they will be set again if needed */
892 time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR);
893
894 /* indicate signal presence */
895 time_status |= STA_PPSSIGNAL;
896 pps_valid = PPS_VALID;
897
898 /* when called for the first time,
899 * just start the frequency interval */
900 if (unlikely(pps_fbase.tv_sec == 0)) {
901 pps_fbase = *raw_ts;
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800902 return;
903 }
904
905 /* ok, now we have a base for frequency calculation */
906 freq_norm = pps_normalize_ts(timespec_sub(*raw_ts, pps_fbase));
907
908 /* check that the signal is in the range
909 * [1s - MAXFREQ us, 1s + MAXFREQ us], otherwise reject it */
910 if ((freq_norm.sec == 0) ||
911 (freq_norm.nsec > MAXFREQ * freq_norm.sec) ||
912 (freq_norm.nsec < -MAXFREQ * freq_norm.sec)) {
913 time_status |= STA_PPSJITTER;
914 /* restart the frequency calibration interval */
915 pps_fbase = *raw_ts;
John Stultz6d9bcb62014-06-04 16:11:43 -0700916 printk_deferred(KERN_ERR "hardpps: PPSJITTER: bad pulse\n");
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800917 return;
918 }
919
920 /* signal is ok */
921
922 /* check if the current frequency interval is finished */
923 if (freq_norm.sec >= (1 << pps_shift)) {
924 pps_calcnt++;
925 /* restart the frequency calibration interval */
926 pps_fbase = *raw_ts;
927 hardpps_update_freq(freq_norm);
928 }
929
930 hardpps_update_phase(pts_norm.nsec);
931
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800932}
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800933#endif /* CONFIG_NTP_PPS */
934
Roman Zippel10a398d2008-03-04 15:14:26 -0800935static int __init ntp_tick_adj_setup(char *str)
936{
Fabian Frederickcdafb932014-05-09 20:32:25 +0200937 int rc = kstrtol(str, 0, (long *)&ntp_tick_adj);
938
939 if (rc)
940 return rc;
Ingo Molnar069569e2009-02-22 16:03:37 +0100941 ntp_tick_adj <<= NTP_SCALE_SHIFT;
942
Roman Zippel10a398d2008-03-04 15:14:26 -0800943 return 1;
944}
945
946__setup("ntp_tick_adj=", ntp_tick_adj_setup);
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700947
948void __init ntp_init(void)
949{
950 ntp_clear();
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700951}