blob: 5c00242fa921cca007ee2f366493903e246d4769 [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>
john stultz4c7ee8d2006-09-30 23:28:22 -070018
Roman Zippelb0ee7552006-09-30 23:28:22 -070019/*
Ingo Molnar53bbfa92008-02-20 07:58:42 +010020 * NTP timekeeping variables:
Roman Zippelb0ee7552006-09-30 23:28:22 -070021 */
Roman Zippelb0ee7552006-09-30 23:28:22 -070022
Ingo Molnar53bbfa92008-02-20 07:58:42 +010023/* USER_HZ period (usecs): */
24unsigned long tick_usec = TICK_USEC;
Roman Zippel7dffa3c2008-05-01 04:34:41 -070025
Ingo Molnar53bbfa92008-02-20 07:58:42 +010026/* ACTHZ period (nsecs): */
27unsigned long tick_nsec;
28
29u64 tick_length;
30static u64 tick_length_base;
31
32static struct hrtimer leap_timer;
33
Ingo Molnarbbd12672009-02-22 12:11:11 +010034#define MAX_TICKADJ 500LL /* usecs */
Ingo Molnar53bbfa92008-02-20 07:58:42 +010035#define MAX_TICKADJ_SCALED \
Ingo Molnarbbd12672009-02-22 12:11:11 +010036 (((MAX_TICKADJ * NSEC_PER_USEC) << NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ)
john stultz4c7ee8d2006-09-30 23:28:22 -070037
38/*
39 * phase-lock loop variables
40 */
Ingo Molnar53bbfa92008-02-20 07:58:42 +010041
42/*
43 * clock synchronization status
44 *
45 * (TIME_ERROR prevents overwriting the CMOS clock)
46 */
47static int time_state = TIME_OK;
48
49/* clock status bits: */
50int time_status = STA_UNSYNC;
51
52/* TAI offset (secs): */
53static long time_tai;
54
55/* time adjustment (nsecs): */
56static s64 time_offset;
57
58/* pll time constant: */
59static long time_constant = 2;
60
61/* maximum error (usecs): */
john stultz1f5b8f82010-01-28 15:02:41 -080062static long time_maxerror = NTP_PHASE_LIMIT;
Ingo Molnar53bbfa92008-02-20 07:58:42 +010063
64/* estimated error (usecs): */
john stultz1f5b8f82010-01-28 15:02:41 -080065static long time_esterror = NTP_PHASE_LIMIT;
Ingo Molnar53bbfa92008-02-20 07:58:42 +010066
67/* frequency offset (scaled nsecs/secs): */
68static s64 time_freq;
69
70/* time at last adjustment (secs): */
71static long time_reftime;
72
John Stultze1292ba2010-03-18 20:19:27 -070073static long time_adjust;
Ingo Molnar53bbfa92008-02-20 07:58:42 +010074
Ingo Molnar069569e2009-02-22 16:03:37 +010075/* constant (boot-param configurable) NTP tick adjustment (upscaled) */
76static s64 ntp_tick_adj;
Ingo Molnar53bbfa92008-02-20 07:58:42 +010077
Alexander Gordeev025b40a2011-01-12 17:00:56 -080078#ifdef CONFIG_NTP_PPS
79
80/*
81 * The following variables are used when a pulse-per-second (PPS) signal
82 * is available. They establish the engineering parameters of the clock
83 * discipline loop when controlled by the PPS signal.
84 */
85#define PPS_VALID 10 /* PPS signal watchdog max (s) */
86#define PPS_POPCORN 4 /* popcorn spike threshold (shift) */
87#define PPS_INTMIN 2 /* min freq interval (s) (shift) */
88#define PPS_INTMAX 8 /* max freq interval (s) (shift) */
89#define PPS_INTCOUNT 4 /* number of consecutive good intervals to
90 increase pps_shift or consecutive bad
91 intervals to decrease it */
92#define PPS_MAXWANDER 100000 /* max PPS freq wander (ns/s) */
93
94static int pps_valid; /* signal watchdog counter */
95static long pps_tf[3]; /* phase median filter */
96static long pps_jitter; /* current jitter (ns) */
97static struct timespec pps_fbase; /* beginning of the last freq interval */
98static int pps_shift; /* current interval duration (s) (shift) */
99static int pps_intcnt; /* interval counter */
100static s64 pps_freq; /* frequency offset (scaled ns/s) */
101static long pps_stabil; /* current stability (scaled ns/s) */
102
103/*
104 * PPS signal quality monitors
105 */
106static long pps_calcnt; /* calibration intervals */
107static long pps_jitcnt; /* jitter limit exceeded */
108static long pps_stbcnt; /* stability limit exceeded */
109static long pps_errcnt; /* calibration errors */
110
111
112/* PPS kernel consumer compensates the whole phase error immediately.
113 * Otherwise, reduce the offset by a fixed factor times the time constant.
114 */
115static inline s64 ntp_offset_chunk(s64 offset)
116{
117 if (time_status & STA_PPSTIME && time_status & STA_PPSSIGNAL)
118 return offset;
119 else
120 return shift_right(offset, SHIFT_PLL + time_constant);
121}
122
123static inline void pps_reset_freq_interval(void)
124{
125 /* the PPS calibration interval may end
126 surprisingly early */
127 pps_shift = PPS_INTMIN;
128 pps_intcnt = 0;
129}
130
131/**
132 * pps_clear - Clears the PPS state variables
133 *
134 * Must be called while holding a write on the xtime_lock
135 */
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.
149 *
150 * Must be called while holding a write on the xtime_lock
151 */
152static inline void pps_dec_valid(void)
153{
154 if (pps_valid > 0)
155 pps_valid--;
156 else {
157 time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
158 STA_PPSWANDER | STA_PPSERROR);
159 pps_clear();
160 }
161}
162
163static inline void pps_set_freq(s64 freq)
164{
165 pps_freq = freq;
166}
167
168static inline int is_error_status(int status)
169{
170 return (time_status & (STA_UNSYNC|STA_CLOCKERR))
171 /* PPS signal lost when either PPS time or
172 * PPS frequency synchronization requested
173 */
174 || ((time_status & (STA_PPSFREQ|STA_PPSTIME))
175 && !(time_status & STA_PPSSIGNAL))
176 /* PPS jitter exceeded when
177 * PPS time synchronization requested */
178 || ((time_status & (STA_PPSTIME|STA_PPSJITTER))
179 == (STA_PPSTIME|STA_PPSJITTER))
180 /* PPS wander exceeded or calibration error when
181 * PPS frequency synchronization requested
182 */
183 || ((time_status & STA_PPSFREQ)
184 && (time_status & (STA_PPSWANDER|STA_PPSERROR)));
185}
186
187static inline void pps_fill_timex(struct timex *txc)
188{
189 txc->ppsfreq = shift_right((pps_freq >> PPM_SCALE_INV_SHIFT) *
190 PPM_SCALE_INV, NTP_SCALE_SHIFT);
191 txc->jitter = pps_jitter;
192 if (!(time_status & STA_NANO))
193 txc->jitter /= NSEC_PER_USEC;
194 txc->shift = pps_shift;
195 txc->stabil = pps_stabil;
196 txc->jitcnt = pps_jitcnt;
197 txc->calcnt = pps_calcnt;
198 txc->errcnt = pps_errcnt;
199 txc->stbcnt = pps_stbcnt;
200}
201
202#else /* !CONFIG_NTP_PPS */
203
204static inline s64 ntp_offset_chunk(s64 offset)
205{
206 return shift_right(offset, SHIFT_PLL + time_constant);
207}
208
209static inline void pps_reset_freq_interval(void) {}
210static inline void pps_clear(void) {}
211static inline void pps_dec_valid(void) {}
212static inline void pps_set_freq(s64 freq) {}
213
214static inline int is_error_status(int status)
215{
216 return status & (STA_UNSYNC|STA_CLOCKERR);
217}
218
219static inline void pps_fill_timex(struct timex *txc)
220{
221 /* PPS is not implemented, so these are zero */
222 txc->ppsfreq = 0;
223 txc->jitter = 0;
224 txc->shift = 0;
225 txc->stabil = 0;
226 txc->jitcnt = 0;
227 txc->calcnt = 0;
228 txc->errcnt = 0;
229 txc->stbcnt = 0;
230}
231
232#endif /* CONFIG_NTP_PPS */
233
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100234/*
235 * NTP methods:
236 */
john stultz4c7ee8d2006-09-30 23:28:22 -0700237
Ingo Molnar9ce616a2009-02-22 12:42:59 +0100238/*
239 * Update (tick_length, tick_length_base, tick_nsec), based
240 * on (tick_usec, ntp_tick_adj, time_freq):
241 */
Adrian Bunk70bc42f2006-09-30 23:28:29 -0700242static void ntp_update_frequency(void)
243{
Ingo Molnar9ce616a2009-02-22 12:42:59 +0100244 u64 second_length;
Ingo Molnarbc26c312009-02-22 12:17:36 +0100245 u64 new_base;
Adrian Bunk70bc42f2006-09-30 23:28:29 -0700246
Ingo Molnar9ce616a2009-02-22 12:42:59 +0100247 second_length = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ)
248 << NTP_SCALE_SHIFT;
249
Ingo Molnar069569e2009-02-22 16:03:37 +0100250 second_length += ntp_tick_adj;
Ingo Molnar9ce616a2009-02-22 12:42:59 +0100251 second_length += time_freq;
252
Ingo Molnar9ce616a2009-02-22 12:42:59 +0100253 tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
Ingo Molnarbc26c312009-02-22 12:17:36 +0100254 new_base = div_u64(second_length, NTP_INTERVAL_FREQ);
john stultzfdcedf72009-02-18 16:02:22 -0800255
256 /*
257 * Don't wait for the next second_overflow, apply
Ingo Molnarbc26c312009-02-22 12:17:36 +0100258 * the change to the tick length immediately:
john stultzfdcedf72009-02-18 16:02:22 -0800259 */
Ingo Molnarbc26c312009-02-22 12:17:36 +0100260 tick_length += new_base - tick_length_base;
261 tick_length_base = new_base;
Adrian Bunk70bc42f2006-09-30 23:28:29 -0700262}
263
Ingo Molnar478b7aa2009-02-22 13:22:23 +0100264static inline s64 ntp_update_offset_fll(s64 offset64, long secs)
Ingo Molnarf9398902009-02-22 12:57:49 +0100265{
266 time_status &= ~STA_MODE;
267
268 if (secs < MINSEC)
Ingo Molnar478b7aa2009-02-22 13:22:23 +0100269 return 0;
Ingo Molnarf9398902009-02-22 12:57:49 +0100270
271 if (!(time_status & STA_FLL) && (secs <= MAXSEC))
Ingo Molnar478b7aa2009-02-22 13:22:23 +0100272 return 0;
Ingo Molnarf9398902009-02-22 12:57:49 +0100273
Ingo Molnarf9398902009-02-22 12:57:49 +0100274 time_status |= STA_MODE;
275
Ingo Molnar478b7aa2009-02-22 13:22:23 +0100276 return div_s64(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs);
Ingo Molnarf9398902009-02-22 12:57:49 +0100277}
278
Roman Zippelee9851b2008-05-01 04:34:32 -0700279static void ntp_update_offset(long offset)
280{
Roman Zippelee9851b2008-05-01 04:34:32 -0700281 s64 freq_adj;
Ingo Molnarf9398902009-02-22 12:57:49 +0100282 s64 offset64;
283 long secs;
Roman Zippelee9851b2008-05-01 04:34:32 -0700284
285 if (!(time_status & STA_PLL))
286 return;
287
Roman Zippeleea83d82008-05-01 04:34:33 -0700288 if (!(time_status & STA_NANO))
Roman Zippel9f14f662008-05-01 04:34:36 -0700289 offset *= NSEC_PER_USEC;
Roman Zippelee9851b2008-05-01 04:34:32 -0700290
291 /*
292 * Scale the phase adjustment and
293 * clamp to the operating range.
294 */
Roman Zippel9f14f662008-05-01 04:34:36 -0700295 offset = min(offset, MAXPHASE);
296 offset = max(offset, -MAXPHASE);
Roman Zippelee9851b2008-05-01 04:34:32 -0700297
298 /*
299 * Select how the frequency is to be controlled
300 * and in which mode (PLL or FLL).
301 */
John Stultz7e1b5842010-01-28 20:20:44 -0800302 secs = get_seconds() - time_reftime;
Ingo Molnar10dd31a2009-02-22 13:38:40 +0100303 if (unlikely(time_status & STA_FREQHOLD))
Ingo Molnarc7986ac2009-02-22 13:29:09 +0100304 secs = 0;
305
John Stultz7e1b5842010-01-28 20:20:44 -0800306 time_reftime = get_seconds();
Roman Zippelee9851b2008-05-01 04:34:32 -0700307
Ingo Molnarf9398902009-02-22 12:57:49 +0100308 offset64 = offset;
Miroslav Lichvar8af3c152010-09-07 16:43:46 +0200309 freq_adj = ntp_update_offset_fll(offset64, secs);
Roman Zippel9f14f662008-05-01 04:34:36 -0700310
Miroslav Lichvar8af3c152010-09-07 16:43:46 +0200311 /*
312 * Clamp update interval to reduce PLL gain with low
313 * sampling rate (e.g. intermittent network connection)
314 * to avoid instability.
315 */
316 if (unlikely(secs > 1 << (SHIFT_PLL + 1 + time_constant)))
317 secs = 1 << (SHIFT_PLL + 1 + time_constant);
318
319 freq_adj += (offset64 * secs) <<
320 (NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant));
Ingo Molnarf9398902009-02-22 12:57:49 +0100321
322 freq_adj = min(freq_adj + time_freq, MAXFREQ_SCALED);
323
324 time_freq = max(freq_adj, -MAXFREQ_SCALED);
325
326 time_offset = div_s64(offset64 << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ);
Roman Zippelee9851b2008-05-01 04:34:32 -0700327}
328
Roman Zippelb0ee7552006-09-30 23:28:22 -0700329/**
330 * ntp_clear - Clears the NTP state variables
331 *
332 * Must be called while holding a write on the xtime_lock
333 */
334void ntp_clear(void)
335{
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100336 time_adjust = 0; /* stop active adjtime() */
337 time_status |= STA_UNSYNC;
338 time_maxerror = NTP_PHASE_LIMIT;
339 time_esterror = NTP_PHASE_LIMIT;
Roman Zippelb0ee7552006-09-30 23:28:22 -0700340
341 ntp_update_frequency();
342
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100343 tick_length = tick_length_base;
344 time_offset = 0;
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800345
346 /* Clear PPS state variables */
347 pps_clear();
Roman Zippelb0ee7552006-09-30 23:28:22 -0700348}
349
john stultz4c7ee8d2006-09-30 23:28:22 -0700350/*
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700351 * Leap second processing. If in leap-insert state at the end of the
352 * day, the system clock is set back one second; if in leap-delete
353 * state, the system clock is set ahead one second.
354 */
355static enum hrtimer_restart ntp_leap_second(struct hrtimer *timer)
356{
357 enum hrtimer_restart res = HRTIMER_NORESTART;
358
Peter Zijlstraca109492008-11-25 12:43:51 +0100359 write_seqlock(&xtime_lock);
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700360
361 switch (time_state) {
362 case TIME_OK:
363 break;
364 case TIME_INS:
John Stultz31089c12009-08-14 15:47:18 +0200365 timekeeping_leap_insert(-1);
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700366 time_state = TIME_OOP;
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100367 printk(KERN_NOTICE
368 "Clock: inserting leap second 23:59:60 UTC\n");
Arjan van de Vencc584b22008-09-01 15:02:30 -0700369 hrtimer_add_expires_ns(&leap_timer, NSEC_PER_SEC);
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700370 res = HRTIMER_RESTART;
371 break;
372 case TIME_DEL:
John Stultz31089c12009-08-14 15:47:18 +0200373 timekeeping_leap_insert(1);
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700374 time_tai--;
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700375 time_state = TIME_WAIT;
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100376 printk(KERN_NOTICE
377 "Clock: deleting leap second 23:59:59 UTC\n");
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700378 break;
379 case TIME_OOP:
380 time_tai++;
381 time_state = TIME_WAIT;
382 /* fall through */
383 case TIME_WAIT:
384 if (!(time_status & (STA_INS | STA_DEL)))
385 time_state = TIME_OK;
386 break;
387 }
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700388
Peter Zijlstraca109492008-11-25 12:43:51 +0100389 write_sequnlock(&xtime_lock);
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700390
391 return res;
392}
393
394/*
john stultz4c7ee8d2006-09-30 23:28:22 -0700395 * this routine handles the overflow of the microsecond field
396 *
397 * The tricky bits of code to handle the accurate clock support
398 * were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame.
399 * They were originally developed for SUN and DEC kernels.
400 * All the kudos should go to Dave for this stuff.
401 */
402void second_overflow(void)
403{
Ingo Molnar39854fe2009-02-22 16:06:58 +0100404 s64 delta;
john stultz4c7ee8d2006-09-30 23:28:22 -0700405
406 /* Bump the maxerror field */
Roman Zippel074b3b82008-05-01 04:34:34 -0700407 time_maxerror += MAXFREQ / NSEC_PER_USEC;
john stultz4c7ee8d2006-09-30 23:28:22 -0700408 if (time_maxerror > NTP_PHASE_LIMIT) {
409 time_maxerror = NTP_PHASE_LIMIT;
410 time_status |= STA_UNSYNC;
411 }
412
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800413 /* Compute the phase adjustment for the next second */
Ingo Molnar39854fe2009-02-22 16:06:58 +0100414 tick_length = tick_length_base;
415
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800416 delta = ntp_offset_chunk(time_offset);
Ingo Molnar39854fe2009-02-22 16:06:58 +0100417 time_offset -= delta;
418 tick_length += delta;
john stultz4c7ee8d2006-09-30 23:28:22 -0700419
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800420 /* Check PPS signal */
421 pps_dec_valid();
422
Ingo Molnar3c972c22009-02-22 12:06:57 +0100423 if (!time_adjust)
424 return;
425
426 if (time_adjust > MAX_TICKADJ) {
427 time_adjust -= MAX_TICKADJ;
428 tick_length += MAX_TICKADJ_SCALED;
429 return;
john stultz4c7ee8d2006-09-30 23:28:22 -0700430 }
Ingo Molnar3c972c22009-02-22 12:06:57 +0100431
432 if (time_adjust < -MAX_TICKADJ) {
433 time_adjust += MAX_TICKADJ;
434 tick_length -= MAX_TICKADJ_SCALED;
435 return;
436 }
437
438 tick_length += (s64)(time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)
439 << NTP_SCALE_SHIFT;
440 time_adjust = 0;
john stultz4c7ee8d2006-09-30 23:28:22 -0700441}
442
Thomas Gleixner82644452007-07-21 04:37:37 -0700443#ifdef CONFIG_GENERIC_CMOS_UPDATE
john stultz4c7ee8d2006-09-30 23:28:22 -0700444
Thomas Gleixner82644452007-07-21 04:37:37 -0700445/* Disable the cmos update - used by virtualization and embedded */
446int no_sync_cmos_clock __read_mostly;
447
Maciej W. Rozyckieb3f9382008-09-22 14:42:40 -0700448static void sync_cmos_clock(struct work_struct *work);
Thomas Gleixner82644452007-07-21 04:37:37 -0700449
Maciej W. Rozyckieb3f9382008-09-22 14:42:40 -0700450static DECLARE_DELAYED_WORK(sync_cmos_work, sync_cmos_clock);
Thomas Gleixner82644452007-07-21 04:37:37 -0700451
Maciej W. Rozyckieb3f9382008-09-22 14:42:40 -0700452static void sync_cmos_clock(struct work_struct *work)
john stultz4c7ee8d2006-09-30 23:28:22 -0700453{
Thomas Gleixner82644452007-07-21 04:37:37 -0700454 struct timespec now, next;
455 int fail = 1;
456
457 /*
458 * If we have an externally synchronized Linux clock, then update
459 * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
460 * called as close as possible to 500 ms before the new second starts.
461 * This code is run on a timer. If the clock is set, that timer
462 * may not expire at the correct time. Thus, we adjust...
463 */
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100464 if (!ntp_synced()) {
Thomas Gleixner82644452007-07-21 04:37:37 -0700465 /*
466 * Not synced, exit, do not restart a timer (if one is
467 * running, let it run out).
468 */
469 return;
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100470 }
Thomas Gleixner82644452007-07-21 04:37:37 -0700471
472 getnstimeofday(&now);
David P. Reedfa6a1a52007-11-14 17:49:21 -0500473 if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2)
Thomas Gleixner82644452007-07-21 04:37:37 -0700474 fail = update_persistent_clock(now);
475
Maciej W. Rozycki4ff4b9e2008-09-05 14:05:31 -0700476 next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec - (TICK_NSEC / 2);
Thomas Gleixner82644452007-07-21 04:37:37 -0700477 if (next.tv_nsec <= 0)
478 next.tv_nsec += NSEC_PER_SEC;
479
480 if (!fail)
481 next.tv_sec = 659;
482 else
483 next.tv_sec = 0;
484
485 if (next.tv_nsec >= NSEC_PER_SEC) {
486 next.tv_sec++;
487 next.tv_nsec -= NSEC_PER_SEC;
488 }
Maciej W. Rozyckieb3f9382008-09-22 14:42:40 -0700489 schedule_delayed_work(&sync_cmos_work, timespec_to_jiffies(&next));
john stultz4c7ee8d2006-09-30 23:28:22 -0700490}
491
Thomas Gleixner82644452007-07-21 04:37:37 -0700492static void notify_cmos_timer(void)
493{
Tony Breeds298a5df2007-09-11 15:24:03 -0700494 if (!no_sync_cmos_clock)
Maciej W. Rozyckieb3f9382008-09-22 14:42:40 -0700495 schedule_delayed_work(&sync_cmos_work, 0);
Thomas Gleixner82644452007-07-21 04:37:37 -0700496}
497
498#else
499static inline void notify_cmos_timer(void) { }
500#endif
501
Ingo Molnare9629162009-02-22 15:35:18 +0100502/*
503 * Start the leap seconds timer:
504 */
505static inline void ntp_start_leap_timer(struct timespec *ts)
506{
507 long now = ts->tv_sec;
508
509 if (time_status & STA_INS) {
510 time_state = TIME_INS;
511 now += 86400 - now % 86400;
512 hrtimer_start(&leap_timer, ktime_set(now, 0), HRTIMER_MODE_ABS);
513
514 return;
515 }
516
517 if (time_status & STA_DEL) {
518 time_state = TIME_DEL;
519 now += 86400 - (now + 1) % 86400;
520 hrtimer_start(&leap_timer, ktime_set(now, 0), HRTIMER_MODE_ABS);
521 }
522}
Ingo Molnar80f22572009-02-22 15:15:32 +0100523
524/*
525 * Propagate a new txc->status value into the NTP state:
526 */
527static inline void process_adj_status(struct timex *txc, struct timespec *ts)
528{
Ingo Molnar80f22572009-02-22 15:15:32 +0100529 if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) {
530 time_state = TIME_OK;
531 time_status = STA_UNSYNC;
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800532 /* restart PPS frequency calibration */
533 pps_reset_freq_interval();
Ingo Molnar80f22572009-02-22 15:15:32 +0100534 }
Ingo Molnar80f22572009-02-22 15:15:32 +0100535
536 /*
537 * If we turn on PLL adjustments then reset the
538 * reference time to current time.
539 */
540 if (!(time_status & STA_PLL) && (txc->status & STA_PLL))
John Stultz7e1b5842010-01-28 20:20:44 -0800541 time_reftime = get_seconds();
Ingo Molnar80f22572009-02-22 15:15:32 +0100542
John Stultza2a5ac82009-02-26 09:46:14 -0800543 /* only set allowed bits */
544 time_status &= STA_RONLY;
Ingo Molnar80f22572009-02-22 15:15:32 +0100545 time_status |= txc->status & ~STA_RONLY;
546
547 switch (time_state) {
548 case TIME_OK:
Ingo Molnare9629162009-02-22 15:35:18 +0100549 ntp_start_leap_timer(ts);
Ingo Molnar80f22572009-02-22 15:15:32 +0100550 break;
551 case TIME_INS:
552 case TIME_DEL:
553 time_state = TIME_OK;
Ingo Molnare9629162009-02-22 15:35:18 +0100554 ntp_start_leap_timer(ts);
Ingo Molnar80f22572009-02-22 15:15:32 +0100555 case TIME_WAIT:
556 if (!(time_status & (STA_INS | STA_DEL)))
557 time_state = TIME_OK;
558 break;
559 case TIME_OOP:
560 hrtimer_restart(&leap_timer);
561 break;
562 }
563}
564/*
565 * Called with the xtime lock held, so we can access and modify
566 * all the global NTP state:
567 */
568static inline void process_adjtimex_modes(struct timex *txc, struct timespec *ts)
569{
570 if (txc->modes & ADJ_STATUS)
571 process_adj_status(txc, ts);
572
573 if (txc->modes & ADJ_NANO)
574 time_status |= STA_NANO;
Ingo Molnare9629162009-02-22 15:35:18 +0100575
Ingo Molnar80f22572009-02-22 15:15:32 +0100576 if (txc->modes & ADJ_MICRO)
577 time_status &= ~STA_NANO;
578
579 if (txc->modes & ADJ_FREQUENCY) {
Ingo Molnar2b9d1492009-02-22 15:48:43 +0100580 time_freq = txc->freq * PPM_SCALE;
Ingo Molnar80f22572009-02-22 15:15:32 +0100581 time_freq = min(time_freq, MAXFREQ_SCALED);
582 time_freq = max(time_freq, -MAXFREQ_SCALED);
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800583 /* update pps_freq */
584 pps_set_freq(time_freq);
Ingo Molnar80f22572009-02-22 15:15:32 +0100585 }
586
587 if (txc->modes & ADJ_MAXERROR)
588 time_maxerror = txc->maxerror;
Ingo Molnare9629162009-02-22 15:35:18 +0100589
Ingo Molnar80f22572009-02-22 15:15:32 +0100590 if (txc->modes & ADJ_ESTERROR)
591 time_esterror = txc->esterror;
592
593 if (txc->modes & ADJ_TIMECONST) {
594 time_constant = txc->constant;
595 if (!(time_status & STA_NANO))
596 time_constant += 4;
597 time_constant = min(time_constant, (long)MAXTC);
598 time_constant = max(time_constant, 0l);
599 }
600
601 if (txc->modes & ADJ_TAI && txc->constant > 0)
602 time_tai = txc->constant;
603
604 if (txc->modes & ADJ_OFFSET)
605 ntp_update_offset(txc->offset);
Ingo Molnare9629162009-02-22 15:35:18 +0100606
Ingo Molnar80f22572009-02-22 15:15:32 +0100607 if (txc->modes & ADJ_TICK)
608 tick_usec = txc->tick;
609
610 if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET))
611 ntp_update_frequency();
612}
613
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100614/*
615 * adjtimex mainly allows reading (and writing, if superuser) of
john stultz4c7ee8d2006-09-30 23:28:22 -0700616 * kernel time-keeping variables. used by xntpd.
617 */
618int do_adjtimex(struct timex *txc)
619{
Roman Zippeleea83d82008-05-01 04:34:33 -0700620 struct timespec ts;
john stultz4c7ee8d2006-09-30 23:28:22 -0700621 int result;
622
Roman Zippel916c7a82008-08-20 16:46:08 -0700623 /* Validate the data before disabling interrupts */
624 if (txc->modes & ADJ_ADJTIME) {
Roman Zippeleea83d82008-05-01 04:34:33 -0700625 /* singleshot must not be used with any other mode bits */
Roman Zippel916c7a82008-08-20 16:46:08 -0700626 if (!(txc->modes & ADJ_OFFSET_SINGLESHOT))
john stultz4c7ee8d2006-09-30 23:28:22 -0700627 return -EINVAL;
Roman Zippel916c7a82008-08-20 16:46:08 -0700628 if (!(txc->modes & ADJ_OFFSET_READONLY) &&
629 !capable(CAP_SYS_TIME))
630 return -EPERM;
631 } else {
632 /* In order to modify anything, you gotta be super-user! */
633 if (txc->modes && !capable(CAP_SYS_TIME))
634 return -EPERM;
635
Ingo Molnar53bbfa92008-02-20 07:58:42 +0100636 /*
637 * if the quartz is off by more than 10% then
638 * something is VERY wrong!
639 */
Roman Zippel916c7a82008-08-20 16:46:08 -0700640 if (txc->modes & ADJ_TICK &&
641 (txc->tick < 900000/USER_HZ ||
642 txc->tick > 1100000/USER_HZ))
Ingo Molnare9629162009-02-22 15:35:18 +0100643 return -EINVAL;
Roman Zippel916c7a82008-08-20 16:46:08 -0700644
645 if (txc->modes & ADJ_STATUS && time_state != TIME_OK)
646 hrtimer_cancel(&leap_timer);
John Stultz52bfb362007-11-26 20:42:19 +0100647 }
john stultz4c7ee8d2006-09-30 23:28:22 -0700648
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700649 getnstimeofday(&ts);
650
john stultz4c7ee8d2006-09-30 23:28:22 -0700651 write_seqlock_irq(&xtime_lock);
john stultz4c7ee8d2006-09-30 23:28:22 -0700652
Roman Zippel916c7a82008-08-20 16:46:08 -0700653 if (txc->modes & ADJ_ADJTIME) {
654 long save_adjust = time_adjust;
655
656 if (!(txc->modes & ADJ_OFFSET_READONLY)) {
657 /* adjtime() is independent from ntp_adjtime() */
658 time_adjust = txc->offset;
659 ntp_update_frequency();
660 }
661 txc->offset = save_adjust;
Ingo Molnare9629162009-02-22 15:35:18 +0100662 } else {
663
664 /* If there are input parameters, then process them: */
665 if (txc->modes)
666 process_adjtimex_modes(txc, &ts);
667
668 txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
669 NTP_SCALE_SHIFT);
670 if (!(time_status & STA_NANO))
671 txc->offset /= NSEC_PER_USEC;
Roman Zippel916c7a82008-08-20 16:46:08 -0700672 }
Roman Zippel916c7a82008-08-20 16:46:08 -0700673
Roman Zippeleea83d82008-05-01 04:34:33 -0700674 result = time_state; /* mostly `TIME_OK' */
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800675 /* check for errors */
676 if (is_error_status(time_status))
john stultz4c7ee8d2006-09-30 23:28:22 -0700677 result = TIME_ERROR;
678
Roman Zippeld40e9442008-09-22 14:42:44 -0700679 txc->freq = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) *
Ingo Molnar2b9d1492009-02-22 15:48:43 +0100680 PPM_SCALE_INV, NTP_SCALE_SHIFT);
john stultz4c7ee8d2006-09-30 23:28:22 -0700681 txc->maxerror = time_maxerror;
682 txc->esterror = time_esterror;
683 txc->status = time_status;
684 txc->constant = time_constant;
Adrian Bunk70bc42f2006-09-30 23:28:29 -0700685 txc->precision = 1;
Roman Zippel074b3b82008-05-01 04:34:34 -0700686 txc->tolerance = MAXFREQ_SCALED / PPM_SCALE;
john stultz4c7ee8d2006-09-30 23:28:22 -0700687 txc->tick = tick_usec;
Roman Zippel153b5d02008-05-01 04:34:37 -0700688 txc->tai = time_tai;
john stultz4c7ee8d2006-09-30 23:28:22 -0700689
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800690 /* fill PPS status fields */
691 pps_fill_timex(txc);
Ingo Molnare9629162009-02-22 15:35:18 +0100692
john stultz4c7ee8d2006-09-30 23:28:22 -0700693 write_sequnlock_irq(&xtime_lock);
Roman Zippelee9851b2008-05-01 04:34:32 -0700694
Roman Zippeleea83d82008-05-01 04:34:33 -0700695 txc->time.tv_sec = ts.tv_sec;
696 txc->time.tv_usec = ts.tv_nsec;
697 if (!(time_status & STA_NANO))
698 txc->time.tv_usec /= NSEC_PER_USEC;
Roman Zippelee9851b2008-05-01 04:34:32 -0700699
Thomas Gleixner82644452007-07-21 04:37:37 -0700700 notify_cmos_timer();
Roman Zippelee9851b2008-05-01 04:34:32 -0700701
702 return result;
john stultz4c7ee8d2006-09-30 23:28:22 -0700703}
Roman Zippel10a398d2008-03-04 15:14:26 -0800704
Alexander Gordeev025b40a2011-01-12 17:00:56 -0800705#ifdef CONFIG_NTP_PPS
706
707/* actually struct pps_normtime is good old struct timespec, but it is
708 * semantically different (and it is the reason why it was invented):
709 * pps_normtime.nsec has a range of ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ]
710 * while timespec.tv_nsec has a range of [0, NSEC_PER_SEC) */
711struct pps_normtime {
712 __kernel_time_t sec; /* seconds */
713 long nsec; /* nanoseconds */
714};
715
716/* normalize the timestamp so that nsec is in the
717 ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ] interval */
718static inline struct pps_normtime pps_normalize_ts(struct timespec ts)
719{
720 struct pps_normtime norm = {
721 .sec = ts.tv_sec,
722 .nsec = ts.tv_nsec
723 };
724
725 if (norm.nsec > (NSEC_PER_SEC >> 1)) {
726 norm.nsec -= NSEC_PER_SEC;
727 norm.sec++;
728 }
729
730 return norm;
731}
732
733/* get current phase correction and jitter */
734static inline long pps_phase_filter_get(long *jitter)
735{
736 *jitter = pps_tf[0] - pps_tf[1];
737 if (*jitter < 0)
738 *jitter = -*jitter;
739
740 /* TODO: test various filters */
741 return pps_tf[0];
742}
743
744/* add the sample to the phase filter */
745static inline void pps_phase_filter_add(long err)
746{
747 pps_tf[2] = pps_tf[1];
748 pps_tf[1] = pps_tf[0];
749 pps_tf[0] = err;
750}
751
752/* decrease frequency calibration interval length.
753 * It is halved after four consecutive unstable intervals.
754 */
755static inline void pps_dec_freq_interval(void)
756{
757 if (--pps_intcnt <= -PPS_INTCOUNT) {
758 pps_intcnt = -PPS_INTCOUNT;
759 if (pps_shift > PPS_INTMIN) {
760 pps_shift--;
761 pps_intcnt = 0;
762 }
763 }
764}
765
766/* increase frequency calibration interval length.
767 * It is doubled after four consecutive stable intervals.
768 */
769static inline void pps_inc_freq_interval(void)
770{
771 if (++pps_intcnt >= PPS_INTCOUNT) {
772 pps_intcnt = PPS_INTCOUNT;
773 if (pps_shift < PPS_INTMAX) {
774 pps_shift++;
775 pps_intcnt = 0;
776 }
777 }
778}
779
780/* update clock frequency based on MONOTONIC_RAW clock PPS signal
781 * timestamps
782 *
783 * At the end of the calibration interval the difference between the
784 * first and last MONOTONIC_RAW clock timestamps divided by the length
785 * of the interval becomes the frequency update. If the interval was
786 * too long, the data are discarded.
787 * Returns the difference between old and new frequency values.
788 */
789static long hardpps_update_freq(struct pps_normtime freq_norm)
790{
791 long delta, delta_mod;
792 s64 ftemp;
793
794 /* check if the frequency interval was too long */
795 if (freq_norm.sec > (2 << pps_shift)) {
796 time_status |= STA_PPSERROR;
797 pps_errcnt++;
798 pps_dec_freq_interval();
799 pr_err("hardpps: PPSERROR: interval too long - %ld s\n",
800 freq_norm.sec);
801 return 0;
802 }
803
804 /* here the raw frequency offset and wander (stability) is
805 * calculated. If the wander is less than the wander threshold
806 * the interval is increased; otherwise it is decreased.
807 */
808 ftemp = div_s64(((s64)(-freq_norm.nsec)) << NTP_SCALE_SHIFT,
809 freq_norm.sec);
810 delta = shift_right(ftemp - pps_freq, NTP_SCALE_SHIFT);
811 pps_freq = ftemp;
812 if (delta > PPS_MAXWANDER || delta < -PPS_MAXWANDER) {
813 pr_warning("hardpps: PPSWANDER: change=%ld\n", delta);
814 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)) {
857 pr_warning("hardpps: PPSJITTER: jitter=%ld, limit=%ld\n",
858 jitter, (pps_jitter << PPS_POPCORN));
859 time_status |= STA_PPSJITTER;
860 pps_jitcnt++;
861 } else if (time_status & STA_PPSTIME) {
862 /* correct the time using the phase offset */
863 time_offset = div_s64(((s64)correction) << NTP_SCALE_SHIFT,
864 NTP_INTERVAL_FREQ);
865 /* cancel running adjtime() */
866 time_adjust = 0;
867 }
868 /* update jitter */
869 pps_jitter += (jitter - pps_jitter) >> PPS_INTMIN;
870}
871
872/*
873 * hardpps() - discipline CPU clock oscillator to external PPS signal
874 *
875 * This routine is called at each PPS signal arrival in order to
876 * discipline the CPU clock oscillator to the PPS signal. It takes two
877 * parameters: REALTIME and MONOTONIC_RAW clock timestamps. The former
878 * is used to correct clock phase error and the latter is used to
879 * correct the frequency.
880 *
881 * This code is based on David Mills's reference nanokernel
882 * implementation. It was mostly rewritten but keeps the same idea.
883 */
884void hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
885{
886 struct pps_normtime pts_norm, freq_norm;
887 unsigned long flags;
888
889 pts_norm = pps_normalize_ts(*phase_ts);
890
891 write_seqlock_irqsave(&xtime_lock, flags);
892
893 /* clear the error bits, they will be set again if needed */
894 time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR);
895
896 /* indicate signal presence */
897 time_status |= STA_PPSSIGNAL;
898 pps_valid = PPS_VALID;
899
900 /* when called for the first time,
901 * just start the frequency interval */
902 if (unlikely(pps_fbase.tv_sec == 0)) {
903 pps_fbase = *raw_ts;
904 write_sequnlock_irqrestore(&xtime_lock, flags);
905 return;
906 }
907
908 /* ok, now we have a base for frequency calculation */
909 freq_norm = pps_normalize_ts(timespec_sub(*raw_ts, pps_fbase));
910
911 /* check that the signal is in the range
912 * [1s - MAXFREQ us, 1s + MAXFREQ us], otherwise reject it */
913 if ((freq_norm.sec == 0) ||
914 (freq_norm.nsec > MAXFREQ * freq_norm.sec) ||
915 (freq_norm.nsec < -MAXFREQ * freq_norm.sec)) {
916 time_status |= STA_PPSJITTER;
917 /* restart the frequency calibration interval */
918 pps_fbase = *raw_ts;
919 write_sequnlock_irqrestore(&xtime_lock, flags);
920 pr_err("hardpps: PPSJITTER: bad pulse\n");
921 return;
922 }
923
924 /* signal is ok */
925
926 /* check if the current frequency interval is finished */
927 if (freq_norm.sec >= (1 << pps_shift)) {
928 pps_calcnt++;
929 /* restart the frequency calibration interval */
930 pps_fbase = *raw_ts;
931 hardpps_update_freq(freq_norm);
932 }
933
934 hardpps_update_phase(pts_norm.nsec);
935
936 write_sequnlock_irqrestore(&xtime_lock, flags);
937}
938EXPORT_SYMBOL(hardpps);
939
940#endif /* CONFIG_NTP_PPS */
941
Roman Zippel10a398d2008-03-04 15:14:26 -0800942static int __init ntp_tick_adj_setup(char *str)
943{
944 ntp_tick_adj = simple_strtol(str, NULL, 0);
Ingo Molnar069569e2009-02-22 16:03:37 +0100945 ntp_tick_adj <<= NTP_SCALE_SHIFT;
946
Roman Zippel10a398d2008-03-04 15:14:26 -0800947 return 1;
948}
949
950__setup("ntp_tick_adj=", ntp_tick_adj_setup);
Roman Zippel7dffa3c2008-05-01 04:34:41 -0700951
952void __init ntp_init(void)
953{
954 ntp_clear();
955 hrtimer_init(&leap_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
956 leap_timer.function = ntp_leap_second;
957}