]>
Commit | Line | Data |
---|---|---|
4c7ee8de | 1 | /* |
4c7ee8de JS |
2 | * 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 | */ | |
aa0ac365 | 8 | #include <linux/capability.h> |
7dffa3c6 | 9 | #include <linux/clocksource.h> |
eb3f938f | 10 | #include <linux/workqueue.h> |
53bbfa9e IM |
11 | #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> | |
025b40ab | 17 | #include <linux/module.h> |
023f333a | 18 | #include <linux/rtc.h> |
4c7ee8de | 19 | |
aa6f9c59 | 20 | #include "ntp_internal.h" |
e2830b5c | 21 | |
b0ee7556 | 22 | /* |
53bbfa9e | 23 | * NTP timekeeping variables: |
a076b214 JS |
24 | * |
25 | * Note: All of the NTP state is protected by the timekeeping locks. | |
b0ee7556 | 26 | */ |
b0ee7556 | 27 | |
bd331268 | 28 | |
53bbfa9e IM |
29 | /* USER_HZ period (usecs): */ |
30 | unsigned long tick_usec = TICK_USEC; | |
31 | ||
02ab20ae | 32 | /* SHIFTED_HZ period (nsecs): */ |
53bbfa9e | 33 | unsigned long tick_nsec; |
7dffa3c6 | 34 | |
ea7cf49a | 35 | static u64 tick_length; |
53bbfa9e IM |
36 | static u64 tick_length_base; |
37 | ||
90bf361c | 38 | #define SECS_PER_DAY 86400 |
bbd12676 | 39 | #define MAX_TICKADJ 500LL /* usecs */ |
53bbfa9e | 40 | #define MAX_TICKADJ_SCALED \ |
bbd12676 | 41 | (((MAX_TICKADJ * NSEC_PER_USEC) << NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ) |
4c7ee8de JS |
42 | |
43 | /* | |
44 | * phase-lock loop variables | |
45 | */ | |
53bbfa9e IM |
46 | |
47 | /* | |
48 | * clock synchronization status | |
49 | * | |
50 | * (TIME_ERROR prevents overwriting the CMOS clock) | |
51 | */ | |
52 | static int time_state = TIME_OK; | |
53 | ||
54 | /* clock status bits: */ | |
8357929e | 55 | static int time_status = STA_UNSYNC; |
53bbfa9e | 56 | |
53bbfa9e IM |
57 | /* time adjustment (nsecs): */ |
58 | static s64 time_offset; | |
59 | ||
60 | /* pll time constant: */ | |
61 | static long time_constant = 2; | |
62 | ||
63 | /* maximum error (usecs): */ | |
1f5b8f8a | 64 | static long time_maxerror = NTP_PHASE_LIMIT; |
53bbfa9e IM |
65 | |
66 | /* estimated error (usecs): */ | |
1f5b8f8a | 67 | static long time_esterror = NTP_PHASE_LIMIT; |
53bbfa9e IM |
68 | |
69 | /* frequency offset (scaled nsecs/secs): */ | |
70 | static s64 time_freq; | |
71 | ||
72 | /* time at last adjustment (secs): */ | |
73 | static long time_reftime; | |
74 | ||
e1292ba1 | 75 | static long time_adjust; |
53bbfa9e | 76 | |
069569e0 IM |
77 | /* constant (boot-param configurable) NTP tick adjustment (upscaled) */ |
78 | static s64 ntp_tick_adj; | |
53bbfa9e | 79 | |
833f32d7 JS |
80 | /* second value of the next pending leapsecond, or TIME64_MAX if no leap */ |
81 | static time64_t ntp_next_leap_sec = TIME64_MAX; | |
82 | ||
025b40ab AG |
83 | #ifdef CONFIG_NTP_PPS |
84 | ||
85 | /* | |
86 | * The following variables are used when a pulse-per-second (PPS) signal | |
87 | * is available. They establish the engineering parameters of the clock | |
88 | * discipline loop when controlled by the PPS signal. | |
89 | */ | |
90 | #define PPS_VALID 10 /* PPS signal watchdog max (s) */ | |
91 | #define PPS_POPCORN 4 /* popcorn spike threshold (shift) */ | |
92 | #define PPS_INTMIN 2 /* min freq interval (s) (shift) */ | |
93 | #define PPS_INTMAX 8 /* max freq interval (s) (shift) */ | |
94 | #define PPS_INTCOUNT 4 /* number of consecutive good intervals to | |
95 | increase pps_shift or consecutive bad | |
96 | intervals to decrease it */ | |
97 | #define PPS_MAXWANDER 100000 /* max PPS freq wander (ns/s) */ | |
98 | ||
99 | static int pps_valid; /* signal watchdog counter */ | |
100 | static long pps_tf[3]; /* phase median filter */ | |
101 | static long pps_jitter; /* current jitter (ns) */ | |
102 | static struct timespec pps_fbase; /* beginning of the last freq interval */ | |
103 | static int pps_shift; /* current interval duration (s) (shift) */ | |
104 | static int pps_intcnt; /* interval counter */ | |
105 | static s64 pps_freq; /* frequency offset (scaled ns/s) */ | |
106 | static long pps_stabil; /* current stability (scaled ns/s) */ | |
107 | ||
108 | /* | |
109 | * PPS signal quality monitors | |
110 | */ | |
111 | static long pps_calcnt; /* calibration intervals */ | |
112 | static long pps_jitcnt; /* jitter limit exceeded */ | |
113 | static long pps_stbcnt; /* stability limit exceeded */ | |
114 | static long pps_errcnt; /* calibration errors */ | |
115 | ||
116 | ||
117 | /* PPS kernel consumer compensates the whole phase error immediately. | |
118 | * Otherwise, reduce the offset by a fixed factor times the time constant. | |
119 | */ | |
120 | static inline s64 ntp_offset_chunk(s64 offset) | |
121 | { | |
122 | if (time_status & STA_PPSTIME && time_status & STA_PPSSIGNAL) | |
123 | return offset; | |
124 | else | |
125 | return shift_right(offset, SHIFT_PLL + time_constant); | |
126 | } | |
127 | ||
128 | static inline void pps_reset_freq_interval(void) | |
129 | { | |
130 | /* the PPS calibration interval may end | |
131 | surprisingly early */ | |
132 | pps_shift = PPS_INTMIN; | |
133 | pps_intcnt = 0; | |
134 | } | |
135 | ||
136 | /** | |
137 | * pps_clear - Clears the PPS state variables | |
025b40ab AG |
138 | */ |
139 | static inline void pps_clear(void) | |
140 | { | |
141 | pps_reset_freq_interval(); | |
142 | pps_tf[0] = 0; | |
143 | pps_tf[1] = 0; | |
144 | pps_tf[2] = 0; | |
145 | pps_fbase.tv_sec = pps_fbase.tv_nsec = 0; | |
146 | pps_freq = 0; | |
147 | } | |
148 | ||
149 | /* Decrease pps_valid to indicate that another second has passed since | |
150 | * the last PPS signal. When it reaches 0, indicate that PPS signal is | |
151 | * missing. | |
025b40ab AG |
152 | */ |
153 | static inline void pps_dec_valid(void) | |
154 | { | |
155 | if (pps_valid > 0) | |
156 | pps_valid--; | |
157 | else { | |
158 | time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER | | |
159 | STA_PPSWANDER | STA_PPSERROR); | |
160 | pps_clear(); | |
161 | } | |
162 | } | |
163 | ||
164 | static inline void pps_set_freq(s64 freq) | |
165 | { | |
166 | pps_freq = freq; | |
167 | } | |
168 | ||
169 | static inline int is_error_status(int status) | |
170 | { | |
ea54bca3 | 171 | return (status & (STA_UNSYNC|STA_CLOCKERR)) |
025b40ab AG |
172 | /* PPS signal lost when either PPS time or |
173 | * PPS frequency synchronization requested | |
174 | */ | |
ea54bca3 GS |
175 | || ((status & (STA_PPSFREQ|STA_PPSTIME)) |
176 | && !(status & STA_PPSSIGNAL)) | |
025b40ab AG |
177 | /* PPS jitter exceeded when |
178 | * PPS time synchronization requested */ | |
ea54bca3 | 179 | || ((status & (STA_PPSTIME|STA_PPSJITTER)) |
025b40ab AG |
180 | == (STA_PPSTIME|STA_PPSJITTER)) |
181 | /* PPS wander exceeded or calibration error when | |
182 | * PPS frequency synchronization requested | |
183 | */ | |
ea54bca3 GS |
184 | || ((status & STA_PPSFREQ) |
185 | && (status & (STA_PPSWANDER|STA_PPSERROR))); | |
025b40ab AG |
186 | } |
187 | ||
188 | static inline void pps_fill_timex(struct timex *txc) | |
189 | { | |
190 | txc->ppsfreq = shift_right((pps_freq >> PPM_SCALE_INV_SHIFT) * | |
191 | PPM_SCALE_INV, NTP_SCALE_SHIFT); | |
192 | txc->jitter = pps_jitter; | |
193 | if (!(time_status & STA_NANO)) | |
194 | txc->jitter /= NSEC_PER_USEC; | |
195 | txc->shift = pps_shift; | |
196 | txc->stabil = pps_stabil; | |
197 | txc->jitcnt = pps_jitcnt; | |
198 | txc->calcnt = pps_calcnt; | |
199 | txc->errcnt = pps_errcnt; | |
200 | txc->stbcnt = pps_stbcnt; | |
201 | } | |
202 | ||
203 | #else /* !CONFIG_NTP_PPS */ | |
204 | ||
205 | static inline s64 ntp_offset_chunk(s64 offset) | |
206 | { | |
207 | return shift_right(offset, SHIFT_PLL + time_constant); | |
208 | } | |
209 | ||
210 | static inline void pps_reset_freq_interval(void) {} | |
211 | static inline void pps_clear(void) {} | |
212 | static inline void pps_dec_valid(void) {} | |
213 | static inline void pps_set_freq(s64 freq) {} | |
214 | ||
215 | static inline int is_error_status(int status) | |
216 | { | |
217 | return status & (STA_UNSYNC|STA_CLOCKERR); | |
218 | } | |
219 | ||
220 | static inline void pps_fill_timex(struct timex *txc) | |
221 | { | |
222 | /* PPS is not implemented, so these are zero */ | |
223 | txc->ppsfreq = 0; | |
224 | txc->jitter = 0; | |
225 | txc->shift = 0; | |
226 | txc->stabil = 0; | |
227 | txc->jitcnt = 0; | |
228 | txc->calcnt = 0; | |
229 | txc->errcnt = 0; | |
230 | txc->stbcnt = 0; | |
231 | } | |
232 | ||
233 | #endif /* CONFIG_NTP_PPS */ | |
234 | ||
8357929e JS |
235 | |
236 | /** | |
237 | * ntp_synced - Returns 1 if the NTP status is not UNSYNC | |
238 | * | |
239 | */ | |
240 | static inline int ntp_synced(void) | |
241 | { | |
242 | return !(time_status & STA_UNSYNC); | |
243 | } | |
244 | ||
245 | ||
53bbfa9e IM |
246 | /* |
247 | * NTP methods: | |
248 | */ | |
4c7ee8de | 249 | |
9ce616aa IM |
250 | /* |
251 | * Update (tick_length, tick_length_base, tick_nsec), based | |
252 | * on (tick_usec, ntp_tick_adj, time_freq): | |
253 | */ | |
70bc42f9 AB |
254 | static void ntp_update_frequency(void) |
255 | { | |
9ce616aa | 256 | u64 second_length; |
bc26c31d | 257 | u64 new_base; |
9ce616aa IM |
258 | |
259 | second_length = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ) | |
260 | << NTP_SCALE_SHIFT; | |
261 | ||
069569e0 | 262 | second_length += ntp_tick_adj; |
9ce616aa | 263 | second_length += time_freq; |
70bc42f9 | 264 | |
9ce616aa | 265 | tick_nsec = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT; |
bc26c31d | 266 | new_base = div_u64(second_length, NTP_INTERVAL_FREQ); |
fdcedf7b JS |
267 | |
268 | /* | |
269 | * Don't wait for the next second_overflow, apply | |
bc26c31d | 270 | * the change to the tick length immediately: |
fdcedf7b | 271 | */ |
bc26c31d IM |
272 | tick_length += new_base - tick_length_base; |
273 | tick_length_base = new_base; | |
70bc42f9 AB |
274 | } |
275 | ||
478b7aab | 276 | static inline s64 ntp_update_offset_fll(s64 offset64, long secs) |
f939890b IM |
277 | { |
278 | time_status &= ~STA_MODE; | |
279 | ||
280 | if (secs < MINSEC) | |
478b7aab | 281 | return 0; |
f939890b IM |
282 | |
283 | if (!(time_status & STA_FLL) && (secs <= MAXSEC)) | |
478b7aab | 284 | return 0; |
f939890b | 285 | |
f939890b IM |
286 | time_status |= STA_MODE; |
287 | ||
a078c6d0 | 288 | return div64_long(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs); |
f939890b IM |
289 | } |
290 | ||
ee9851b2 RZ |
291 | static void ntp_update_offset(long offset) |
292 | { | |
ee9851b2 | 293 | s64 freq_adj; |
f939890b IM |
294 | s64 offset64; |
295 | long secs; | |
ee9851b2 RZ |
296 | |
297 | if (!(time_status & STA_PLL)) | |
298 | return; | |
299 | ||
eea83d89 | 300 | if (!(time_status & STA_NANO)) |
9f14f669 | 301 | offset *= NSEC_PER_USEC; |
ee9851b2 RZ |
302 | |
303 | /* | |
304 | * Scale the phase adjustment and | |
305 | * clamp to the operating range. | |
306 | */ | |
9f14f669 RZ |
307 | offset = min(offset, MAXPHASE); |
308 | offset = max(offset, -MAXPHASE); | |
ee9851b2 RZ |
309 | |
310 | /* | |
311 | * Select how the frequency is to be controlled | |
312 | * and in which mode (PLL or FLL). | |
313 | */ | |
7e1b5847 | 314 | secs = get_seconds() - time_reftime; |
10dd31a7 | 315 | if (unlikely(time_status & STA_FREQHOLD)) |
c7986acb IM |
316 | secs = 0; |
317 | ||
7e1b5847 | 318 | time_reftime = get_seconds(); |
ee9851b2 | 319 | |
f939890b | 320 | offset64 = offset; |
8af3c153 | 321 | freq_adj = ntp_update_offset_fll(offset64, secs); |
f939890b | 322 | |
8af3c153 ML |
323 | /* |
324 | * Clamp update interval to reduce PLL gain with low | |
325 | * sampling rate (e.g. intermittent network connection) | |
326 | * to avoid instability. | |
327 | */ | |
328 | if (unlikely(secs > 1 << (SHIFT_PLL + 1 + time_constant))) | |
329 | secs = 1 << (SHIFT_PLL + 1 + time_constant); | |
330 | ||
331 | freq_adj += (offset64 * secs) << | |
332 | (NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant)); | |
f939890b IM |
333 | |
334 | freq_adj = min(freq_adj + time_freq, MAXFREQ_SCALED); | |
335 | ||
336 | time_freq = max(freq_adj, -MAXFREQ_SCALED); | |
337 | ||
338 | time_offset = div_s64(offset64 << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ); | |
ee9851b2 RZ |
339 | } |
340 | ||
b0ee7556 RZ |
341 | /** |
342 | * ntp_clear - Clears the NTP state variables | |
b0ee7556 RZ |
343 | */ |
344 | void ntp_clear(void) | |
345 | { | |
53bbfa9e IM |
346 | time_adjust = 0; /* stop active adjtime() */ |
347 | time_status |= STA_UNSYNC; | |
348 | time_maxerror = NTP_PHASE_LIMIT; | |
349 | time_esterror = NTP_PHASE_LIMIT; | |
b0ee7556 RZ |
350 | |
351 | ntp_update_frequency(); | |
352 | ||
53bbfa9e IM |
353 | tick_length = tick_length_base; |
354 | time_offset = 0; | |
025b40ab | 355 | |
833f32d7 | 356 | ntp_next_leap_sec = TIME64_MAX; |
025b40ab AG |
357 | /* Clear PPS state variables */ |
358 | pps_clear(); | |
b0ee7556 RZ |
359 | } |
360 | ||
ea7cf49a JS |
361 | |
362 | u64 ntp_tick_length(void) | |
363 | { | |
a076b214 | 364 | return tick_length; |
ea7cf49a JS |
365 | } |
366 | ||
833f32d7 JS |
367 | /** |
368 | * ntp_get_next_leap - Returns the next leapsecond in CLOCK_REALTIME ktime_t | |
369 | * | |
370 | * Provides the time of the next leapsecond against CLOCK_REALTIME in | |
371 | * a ktime_t format. Returns KTIME_MAX if no leapsecond is pending. | |
372 | */ | |
373 | ktime_t ntp_get_next_leap(void) | |
374 | { | |
375 | ktime_t ret; | |
376 | ||
377 | if ((time_state == TIME_INS) && (time_status & STA_INS)) | |
378 | return ktime_set(ntp_next_leap_sec, 0); | |
379 | ret.tv64 = KTIME_MAX; | |
380 | return ret; | |
381 | } | |
ea7cf49a | 382 | |
4c7ee8de | 383 | /* |
6b43ae8a JS |
384 | * this routine handles the overflow of the microsecond field |
385 | * | |
386 | * The tricky bits of code to handle the accurate clock support | |
387 | * were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame. | |
388 | * They were originally developed for SUN and DEC kernels. | |
389 | * All the kudos should go to Dave for this stuff. | |
390 | * | |
391 | * Also handles leap second processing, and returns leap offset | |
4c7ee8de | 392 | */ |
6b43ae8a | 393 | int second_overflow(unsigned long secs) |
4c7ee8de | 394 | { |
6b43ae8a | 395 | s64 delta; |
bd331268 | 396 | int leap = 0; |
6b43ae8a JS |
397 | |
398 | /* | |
399 | * Leap second processing. If in leap-insert state at the end of the | |
400 | * day, the system clock is set back one second; if in leap-delete | |
401 | * state, the system clock is set ahead one second. | |
402 | */ | |
4c7ee8de JS |
403 | switch (time_state) { |
404 | case TIME_OK: | |
833f32d7 | 405 | if (time_status & STA_INS) { |
6b43ae8a | 406 | time_state = TIME_INS; |
833f32d7 JS |
407 | ntp_next_leap_sec = secs + SECS_PER_DAY - |
408 | (secs % SECS_PER_DAY); | |
409 | } else if (time_status & STA_DEL) { | |
6b43ae8a | 410 | time_state = TIME_DEL; |
833f32d7 JS |
411 | ntp_next_leap_sec = secs + SECS_PER_DAY - |
412 | ((secs+1) % SECS_PER_DAY); | |
413 | } | |
4c7ee8de JS |
414 | break; |
415 | case TIME_INS: | |
833f32d7 JS |
416 | if (!(time_status & STA_INS)) { |
417 | ntp_next_leap_sec = TIME64_MAX; | |
6b1859db | 418 | time_state = TIME_OK; |
833f32d7 | 419 | } else if (secs % SECS_PER_DAY == 0) { |
6b43ae8a JS |
420 | leap = -1; |
421 | time_state = TIME_OOP; | |
422 | printk(KERN_NOTICE | |
423 | "Clock: inserting leap second 23:59:60 UTC\n"); | |
424 | } | |
4c7ee8de JS |
425 | break; |
426 | case TIME_DEL: | |
833f32d7 JS |
427 | if (!(time_status & STA_DEL)) { |
428 | ntp_next_leap_sec = TIME64_MAX; | |
6b1859db | 429 | time_state = TIME_OK; |
833f32d7 | 430 | } else if ((secs + 1) % SECS_PER_DAY == 0) { |
6b43ae8a | 431 | leap = 1; |
833f32d7 | 432 | ntp_next_leap_sec = TIME64_MAX; |
6b43ae8a JS |
433 | time_state = TIME_WAIT; |
434 | printk(KERN_NOTICE | |
435 | "Clock: deleting leap second 23:59:59 UTC\n"); | |
436 | } | |
4c7ee8de JS |
437 | break; |
438 | case TIME_OOP: | |
833f32d7 | 439 | ntp_next_leap_sec = TIME64_MAX; |
4c7ee8de | 440 | time_state = TIME_WAIT; |
6b43ae8a | 441 | break; |
4c7ee8de JS |
442 | case TIME_WAIT: |
443 | if (!(time_status & (STA_INS | STA_DEL))) | |
ee9851b2 | 444 | time_state = TIME_OK; |
7dffa3c6 RZ |
445 | break; |
446 | } | |
bd331268 | 447 | |
7dffa3c6 RZ |
448 | |
449 | /* Bump the maxerror field */ | |
450 | time_maxerror += MAXFREQ / NSEC_PER_USEC; | |
451 | if (time_maxerror > NTP_PHASE_LIMIT) { | |
452 | time_maxerror = NTP_PHASE_LIMIT; | |
453 | time_status |= STA_UNSYNC; | |
4c7ee8de JS |
454 | } |
455 | ||
025b40ab | 456 | /* Compute the phase adjustment for the next second */ |
39854fe8 IM |
457 | tick_length = tick_length_base; |
458 | ||
025b40ab | 459 | delta = ntp_offset_chunk(time_offset); |
39854fe8 IM |
460 | time_offset -= delta; |
461 | tick_length += delta; | |
4c7ee8de | 462 | |
025b40ab AG |
463 | /* Check PPS signal */ |
464 | pps_dec_valid(); | |
465 | ||
3c972c24 | 466 | if (!time_adjust) |
bd331268 | 467 | goto out; |
3c972c24 IM |
468 | |
469 | if (time_adjust > MAX_TICKADJ) { | |
470 | time_adjust -= MAX_TICKADJ; | |
471 | tick_length += MAX_TICKADJ_SCALED; | |
bd331268 | 472 | goto out; |
4c7ee8de | 473 | } |
3c972c24 IM |
474 | |
475 | if (time_adjust < -MAX_TICKADJ) { | |
476 | time_adjust += MAX_TICKADJ; | |
477 | tick_length -= MAX_TICKADJ_SCALED; | |
bd331268 | 478 | goto out; |
3c972c24 IM |
479 | } |
480 | ||
481 | tick_length += (s64)(time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ) | |
482 | << NTP_SCALE_SHIFT; | |
483 | time_adjust = 0; | |
6b43ae8a | 484 | |
bd331268 | 485 | out: |
6b43ae8a | 486 | return leap; |
4c7ee8de JS |
487 | } |
488 | ||
3c00a1fe XP |
489 | #ifdef CONFIG_GENERIC_CMOS_UPDATE |
490 | int __weak update_persistent_clock64(struct timespec64 now64) | |
491 | { | |
492 | struct timespec now; | |
493 | ||
494 | now = timespec64_to_timespec(now64); | |
495 | return update_persistent_clock(now); | |
496 | } | |
497 | #endif | |
498 | ||
023f333a | 499 | #if defined(CONFIG_GENERIC_CMOS_UPDATE) || defined(CONFIG_RTC_SYSTOHC) |
eb3f938f | 500 | static void sync_cmos_clock(struct work_struct *work); |
82644459 | 501 | |
eb3f938f | 502 | static DECLARE_DELAYED_WORK(sync_cmos_work, sync_cmos_clock); |
82644459 | 503 | |
eb3f938f | 504 | static void sync_cmos_clock(struct work_struct *work) |
82644459 | 505 | { |
d6d29896 TG |
506 | struct timespec64 now; |
507 | struct timespec next; | |
82644459 TG |
508 | int fail = 1; |
509 | ||
510 | /* | |
511 | * If we have an externally synchronized Linux clock, then update | |
512 | * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be | |
513 | * called as close as possible to 500 ms before the new second starts. | |
514 | * This code is run on a timer. If the clock is set, that timer | |
515 | * may not expire at the correct time. Thus, we adjust... | |
a97ad0c4 | 516 | * We want the clock to be within a couple of ticks from the target. |
82644459 | 517 | */ |
53bbfa9e | 518 | if (!ntp_synced()) { |
82644459 TG |
519 | /* |
520 | * Not synced, exit, do not restart a timer (if one is | |
521 | * running, let it run out). | |
522 | */ | |
523 | return; | |
53bbfa9e | 524 | } |
82644459 | 525 | |
d6d29896 | 526 | getnstimeofday64(&now); |
a97ad0c4 | 527 | if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec * 5) { |
9a4a445e | 528 | struct timespec64 adjust = now; |
84e345e4 | 529 | |
023f333a | 530 | fail = -ENODEV; |
84e345e4 PB |
531 | if (persistent_clock_is_local) |
532 | adjust.tv_sec -= (sys_tz.tz_minuteswest * 60); | |
023f333a | 533 | #ifdef CONFIG_GENERIC_CMOS_UPDATE |
3c00a1fe | 534 | fail = update_persistent_clock64(adjust); |
023f333a | 535 | #endif |
3c00a1fe | 536 | |
023f333a JG |
537 | #ifdef CONFIG_RTC_SYSTOHC |
538 | if (fail == -ENODEV) | |
84e345e4 | 539 | fail = rtc_set_ntp_time(adjust); |
023f333a JG |
540 | #endif |
541 | } | |
82644459 | 542 | |
4ff4b9e1 | 543 | next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec - (TICK_NSEC / 2); |
82644459 TG |
544 | if (next.tv_nsec <= 0) |
545 | next.tv_nsec += NSEC_PER_SEC; | |
546 | ||
023f333a | 547 | if (!fail || fail == -ENODEV) |
82644459 TG |
548 | next.tv_sec = 659; |
549 | else | |
550 | next.tv_sec = 0; | |
551 | ||
552 | if (next.tv_nsec >= NSEC_PER_SEC) { | |
553 | next.tv_sec++; | |
554 | next.tv_nsec -= NSEC_PER_SEC; | |
555 | } | |
e8b17594 SD |
556 | queue_delayed_work(system_power_efficient_wq, |
557 | &sync_cmos_work, timespec_to_jiffies(&next)); | |
82644459 TG |
558 | } |
559 | ||
7bd36014 | 560 | void ntp_notify_cmos_timer(void) |
4c7ee8de | 561 | { |
e8b17594 | 562 | queue_delayed_work(system_power_efficient_wq, &sync_cmos_work, 0); |
4c7ee8de JS |
563 | } |
564 | ||
82644459 | 565 | #else |
7bd36014 | 566 | void ntp_notify_cmos_timer(void) { } |
82644459 TG |
567 | #endif |
568 | ||
80f22571 IM |
569 | |
570 | /* | |
571 | * Propagate a new txc->status value into the NTP state: | |
572 | */ | |
7d489d15 | 573 | static inline void process_adj_status(struct timex *txc, struct timespec64 *ts) |
80f22571 | 574 | { |
80f22571 IM |
575 | if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) { |
576 | time_state = TIME_OK; | |
577 | time_status = STA_UNSYNC; | |
833f32d7 | 578 | ntp_next_leap_sec = TIME64_MAX; |
025b40ab AG |
579 | /* restart PPS frequency calibration */ |
580 | pps_reset_freq_interval(); | |
80f22571 | 581 | } |
80f22571 IM |
582 | |
583 | /* | |
584 | * If we turn on PLL adjustments then reset the | |
585 | * reference time to current time. | |
586 | */ | |
587 | if (!(time_status & STA_PLL) && (txc->status & STA_PLL)) | |
7e1b5847 | 588 | time_reftime = get_seconds(); |
80f22571 | 589 | |
a2a5ac86 JS |
590 | /* only set allowed bits */ |
591 | time_status &= STA_RONLY; | |
80f22571 | 592 | time_status |= txc->status & ~STA_RONLY; |
80f22571 | 593 | } |
cd5398be | 594 | |
a076b214 | 595 | |
cc244dda | 596 | static inline void process_adjtimex_modes(struct timex *txc, |
7d489d15 | 597 | struct timespec64 *ts, |
cc244dda | 598 | s32 *time_tai) |
80f22571 IM |
599 | { |
600 | if (txc->modes & ADJ_STATUS) | |
601 | process_adj_status(txc, ts); | |
602 | ||
603 | if (txc->modes & ADJ_NANO) | |
604 | time_status |= STA_NANO; | |
e9629165 | 605 | |
80f22571 IM |
606 | if (txc->modes & ADJ_MICRO) |
607 | time_status &= ~STA_NANO; | |
608 | ||
609 | if (txc->modes & ADJ_FREQUENCY) { | |
2b9d1496 | 610 | time_freq = txc->freq * PPM_SCALE; |
80f22571 IM |
611 | time_freq = min(time_freq, MAXFREQ_SCALED); |
612 | time_freq = max(time_freq, -MAXFREQ_SCALED); | |
025b40ab AG |
613 | /* update pps_freq */ |
614 | pps_set_freq(time_freq); | |
80f22571 IM |
615 | } |
616 | ||
617 | if (txc->modes & ADJ_MAXERROR) | |
618 | time_maxerror = txc->maxerror; | |
e9629165 | 619 | |
80f22571 IM |
620 | if (txc->modes & ADJ_ESTERROR) |
621 | time_esterror = txc->esterror; | |
622 | ||
623 | if (txc->modes & ADJ_TIMECONST) { | |
624 | time_constant = txc->constant; | |
625 | if (!(time_status & STA_NANO)) | |
626 | time_constant += 4; | |
627 | time_constant = min(time_constant, (long)MAXTC); | |
628 | time_constant = max(time_constant, 0l); | |
629 | } | |
630 | ||
631 | if (txc->modes & ADJ_TAI && txc->constant > 0) | |
cc244dda | 632 | *time_tai = txc->constant; |
80f22571 IM |
633 | |
634 | if (txc->modes & ADJ_OFFSET) | |
635 | ntp_update_offset(txc->offset); | |
e9629165 | 636 | |
80f22571 IM |
637 | if (txc->modes & ADJ_TICK) |
638 | tick_usec = txc->tick; | |
639 | ||
640 | if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET)) | |
641 | ntp_update_frequency(); | |
642 | } | |
643 | ||
ad460967 JS |
644 | |
645 | ||
646 | /** | |
647 | * ntp_validate_timex - Ensures the timex is ok for use in do_adjtimex | |
4c7ee8de | 648 | */ |
ad460967 | 649 | int ntp_validate_timex(struct timex *txc) |
4c7ee8de | 650 | { |
916c7a85 | 651 | if (txc->modes & ADJ_ADJTIME) { |
eea83d89 | 652 | /* singleshot must not be used with any other mode bits */ |
916c7a85 | 653 | if (!(txc->modes & ADJ_OFFSET_SINGLESHOT)) |
4c7ee8de | 654 | return -EINVAL; |
916c7a85 RZ |
655 | if (!(txc->modes & ADJ_OFFSET_READONLY) && |
656 | !capable(CAP_SYS_TIME)) | |
657 | return -EPERM; | |
658 | } else { | |
659 | /* In order to modify anything, you gotta be super-user! */ | |
660 | if (txc->modes && !capable(CAP_SYS_TIME)) | |
661 | return -EPERM; | |
53bbfa9e IM |
662 | /* |
663 | * if the quartz is off by more than 10% then | |
664 | * something is VERY wrong! | |
665 | */ | |
916c7a85 RZ |
666 | if (txc->modes & ADJ_TICK && |
667 | (txc->tick < 900000/USER_HZ || | |
668 | txc->tick > 1100000/USER_HZ)) | |
e9629165 | 669 | return -EINVAL; |
52bfb360 | 670 | } |
4c7ee8de | 671 | |
ad460967 JS |
672 | if ((txc->modes & ADJ_SETOFFSET) && (!capable(CAP_SYS_TIME))) |
673 | return -EPERM; | |
674 | ||
29183a70 JS |
675 | /* |
676 | * Check for potential multiplication overflows that can | |
677 | * only happen on 64-bit systems: | |
678 | */ | |
679 | if ((txc->modes & ADJ_FREQUENCY) && (BITS_PER_LONG == 64)) { | |
680 | if (LLONG_MIN / PPM_SCALE > txc->freq) | |
5e5aeb43 | 681 | return -EINVAL; |
29183a70 | 682 | if (LLONG_MAX / PPM_SCALE < txc->freq) |
5e5aeb43 SL |
683 | return -EINVAL; |
684 | } | |
685 | ||
ad460967 JS |
686 | return 0; |
687 | } | |
688 | ||
689 | ||
690 | /* | |
691 | * adjtimex mainly allows reading (and writing, if superuser) of | |
692 | * kernel time-keeping variables. used by xntpd. | |
693 | */ | |
7d489d15 | 694 | int __do_adjtimex(struct timex *txc, struct timespec64 *ts, s32 *time_tai) |
ad460967 | 695 | { |
ad460967 JS |
696 | int result; |
697 | ||
916c7a85 RZ |
698 | if (txc->modes & ADJ_ADJTIME) { |
699 | long save_adjust = time_adjust; | |
700 | ||
701 | if (!(txc->modes & ADJ_OFFSET_READONLY)) { | |
702 | /* adjtime() is independent from ntp_adjtime() */ | |
703 | time_adjust = txc->offset; | |
704 | ntp_update_frequency(); | |
705 | } | |
706 | txc->offset = save_adjust; | |
e9629165 | 707 | } else { |
ee9851b2 | 708 | |
e9629165 IM |
709 | /* If there are input parameters, then process them: */ |
710 | if (txc->modes) | |
87ace39b | 711 | process_adjtimex_modes(txc, ts, time_tai); |
eea83d89 | 712 | |
e9629165 | 713 | txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ, |
916c7a85 | 714 | NTP_SCALE_SHIFT); |
e9629165 IM |
715 | if (!(time_status & STA_NANO)) |
716 | txc->offset /= NSEC_PER_USEC; | |
717 | } | |
916c7a85 | 718 | |
eea83d89 | 719 | result = time_state; /* mostly `TIME_OK' */ |
025b40ab AG |
720 | /* check for errors */ |
721 | if (is_error_status(time_status)) | |
4c7ee8de JS |
722 | result = TIME_ERROR; |
723 | ||
d40e944c | 724 | txc->freq = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) * |
2b9d1496 | 725 | PPM_SCALE_INV, NTP_SCALE_SHIFT); |
4c7ee8de JS |
726 | txc->maxerror = time_maxerror; |
727 | txc->esterror = time_esterror; | |
728 | txc->status = time_status; | |
729 | txc->constant = time_constant; | |
70bc42f9 | 730 | txc->precision = 1; |
074b3b87 | 731 | txc->tolerance = MAXFREQ_SCALED / PPM_SCALE; |
4c7ee8de | 732 | txc->tick = tick_usec; |
87ace39b | 733 | txc->tai = *time_tai; |
4c7ee8de | 734 | |
025b40ab AG |
735 | /* fill PPS status fields */ |
736 | pps_fill_timex(txc); | |
e9629165 | 737 | |
7d489d15 | 738 | txc->time.tv_sec = (time_t)ts->tv_sec; |
87ace39b | 739 | txc->time.tv_usec = ts->tv_nsec; |
eea83d89 RZ |
740 | if (!(time_status & STA_NANO)) |
741 | txc->time.tv_usec /= NSEC_PER_USEC; | |
ee9851b2 | 742 | |
96efdcf2 JS |
743 | /* Handle leapsec adjustments */ |
744 | if (unlikely(ts->tv_sec >= ntp_next_leap_sec)) { | |
745 | if ((time_state == TIME_INS) && (time_status & STA_INS)) { | |
746 | result = TIME_OOP; | |
747 | txc->tai++; | |
748 | txc->time.tv_sec--; | |
749 | } | |
750 | if ((time_state == TIME_DEL) && (time_status & STA_DEL)) { | |
751 | result = TIME_WAIT; | |
752 | txc->tai--; | |
753 | txc->time.tv_sec++; | |
754 | } | |
755 | if ((time_state == TIME_OOP) && | |
756 | (ts->tv_sec == ntp_next_leap_sec)) { | |
757 | result = TIME_WAIT; | |
758 | } | |
759 | } | |
760 | ||
ee9851b2 | 761 | return result; |
4c7ee8de | 762 | } |
10a398d0 | 763 | |
025b40ab AG |
764 | #ifdef CONFIG_NTP_PPS |
765 | ||
766 | /* actually struct pps_normtime is good old struct timespec, but it is | |
767 | * semantically different (and it is the reason why it was invented): | |
768 | * pps_normtime.nsec has a range of ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ] | |
769 | * while timespec.tv_nsec has a range of [0, NSEC_PER_SEC) */ | |
770 | struct pps_normtime { | |
771 | __kernel_time_t sec; /* seconds */ | |
772 | long nsec; /* nanoseconds */ | |
773 | }; | |
774 | ||
775 | /* normalize the timestamp so that nsec is in the | |
776 | ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ] interval */ | |
777 | static inline struct pps_normtime pps_normalize_ts(struct timespec ts) | |
778 | { | |
779 | struct pps_normtime norm = { | |
780 | .sec = ts.tv_sec, | |
781 | .nsec = ts.tv_nsec | |
782 | }; | |
783 | ||
784 | if (norm.nsec > (NSEC_PER_SEC >> 1)) { | |
785 | norm.nsec -= NSEC_PER_SEC; | |
786 | norm.sec++; | |
787 | } | |
788 | ||
789 | return norm; | |
790 | } | |
791 | ||
792 | /* get current phase correction and jitter */ | |
793 | static inline long pps_phase_filter_get(long *jitter) | |
794 | { | |
795 | *jitter = pps_tf[0] - pps_tf[1]; | |
796 | if (*jitter < 0) | |
797 | *jitter = -*jitter; | |
798 | ||
799 | /* TODO: test various filters */ | |
800 | return pps_tf[0]; | |
801 | } | |
802 | ||
803 | /* add the sample to the phase filter */ | |
804 | static inline void pps_phase_filter_add(long err) | |
805 | { | |
806 | pps_tf[2] = pps_tf[1]; | |
807 | pps_tf[1] = pps_tf[0]; | |
808 | pps_tf[0] = err; | |
809 | } | |
810 | ||
811 | /* decrease frequency calibration interval length. | |
812 | * It is halved after four consecutive unstable intervals. | |
813 | */ | |
814 | static inline void pps_dec_freq_interval(void) | |
815 | { | |
816 | if (--pps_intcnt <= -PPS_INTCOUNT) { | |
817 | pps_intcnt = -PPS_INTCOUNT; | |
818 | if (pps_shift > PPS_INTMIN) { | |
819 | pps_shift--; | |
820 | pps_intcnt = 0; | |
821 | } | |
822 | } | |
823 | } | |
824 | ||
825 | /* increase frequency calibration interval length. | |
826 | * It is doubled after four consecutive stable intervals. | |
827 | */ | |
828 | static inline void pps_inc_freq_interval(void) | |
829 | { | |
830 | if (++pps_intcnt >= PPS_INTCOUNT) { | |
831 | pps_intcnt = PPS_INTCOUNT; | |
832 | if (pps_shift < PPS_INTMAX) { | |
833 | pps_shift++; | |
834 | pps_intcnt = 0; | |
835 | } | |
836 | } | |
837 | } | |
838 | ||
839 | /* update clock frequency based on MONOTONIC_RAW clock PPS signal | |
840 | * timestamps | |
841 | * | |
842 | * At the end of the calibration interval the difference between the | |
843 | * first and last MONOTONIC_RAW clock timestamps divided by the length | |
844 | * of the interval becomes the frequency update. If the interval was | |
845 | * too long, the data are discarded. | |
846 | * Returns the difference between old and new frequency values. | |
847 | */ | |
848 | static long hardpps_update_freq(struct pps_normtime freq_norm) | |
849 | { | |
850 | long delta, delta_mod; | |
851 | s64 ftemp; | |
852 | ||
853 | /* check if the frequency interval was too long */ | |
854 | if (freq_norm.sec > (2 << pps_shift)) { | |
855 | time_status |= STA_PPSERROR; | |
856 | pps_errcnt++; | |
857 | pps_dec_freq_interval(); | |
6d9bcb62 JS |
858 | printk_deferred(KERN_ERR |
859 | "hardpps: PPSERROR: interval too long - %ld s\n", | |
860 | freq_norm.sec); | |
025b40ab AG |
861 | return 0; |
862 | } | |
863 | ||
864 | /* here the raw frequency offset and wander (stability) is | |
865 | * calculated. If the wander is less than the wander threshold | |
866 | * the interval is increased; otherwise it is decreased. | |
867 | */ | |
868 | ftemp = div_s64(((s64)(-freq_norm.nsec)) << NTP_SCALE_SHIFT, | |
869 | freq_norm.sec); | |
870 | delta = shift_right(ftemp - pps_freq, NTP_SCALE_SHIFT); | |
871 | pps_freq = ftemp; | |
872 | if (delta > PPS_MAXWANDER || delta < -PPS_MAXWANDER) { | |
6d9bcb62 JS |
873 | printk_deferred(KERN_WARNING |
874 | "hardpps: PPSWANDER: change=%ld\n", delta); | |
025b40ab AG |
875 | time_status |= STA_PPSWANDER; |
876 | pps_stbcnt++; | |
877 | pps_dec_freq_interval(); | |
878 | } else { /* good sample */ | |
879 | pps_inc_freq_interval(); | |
880 | } | |
881 | ||
882 | /* the stability metric is calculated as the average of recent | |
883 | * frequency changes, but is used only for performance | |
884 | * monitoring | |
885 | */ | |
886 | delta_mod = delta; | |
887 | if (delta_mod < 0) | |
888 | delta_mod = -delta_mod; | |
889 | pps_stabil += (div_s64(((s64)delta_mod) << | |
890 | (NTP_SCALE_SHIFT - SHIFT_USEC), | |
891 | NSEC_PER_USEC) - pps_stabil) >> PPS_INTMIN; | |
892 | ||
893 | /* if enabled, the system clock frequency is updated */ | |
894 | if ((time_status & STA_PPSFREQ) != 0 && | |
895 | (time_status & STA_FREQHOLD) == 0) { | |
896 | time_freq = pps_freq; | |
897 | ntp_update_frequency(); | |
898 | } | |
899 | ||
900 | return delta; | |
901 | } | |
902 | ||
903 | /* correct REALTIME clock phase error against PPS signal */ | |
904 | static void hardpps_update_phase(long error) | |
905 | { | |
906 | long correction = -error; | |
907 | long jitter; | |
908 | ||
909 | /* add the sample to the median filter */ | |
910 | pps_phase_filter_add(correction); | |
911 | correction = pps_phase_filter_get(&jitter); | |
912 | ||
913 | /* Nominal jitter is due to PPS signal noise. If it exceeds the | |
914 | * threshold, the sample is discarded; otherwise, if so enabled, | |
915 | * the time offset is updated. | |
916 | */ | |
917 | if (jitter > (pps_jitter << PPS_POPCORN)) { | |
6d9bcb62 JS |
918 | printk_deferred(KERN_WARNING |
919 | "hardpps: PPSJITTER: jitter=%ld, limit=%ld\n", | |
920 | jitter, (pps_jitter << PPS_POPCORN)); | |
025b40ab AG |
921 | time_status |= STA_PPSJITTER; |
922 | pps_jitcnt++; | |
923 | } else if (time_status & STA_PPSTIME) { | |
924 | /* correct the time using the phase offset */ | |
925 | time_offset = div_s64(((s64)correction) << NTP_SCALE_SHIFT, | |
926 | NTP_INTERVAL_FREQ); | |
927 | /* cancel running adjtime() */ | |
928 | time_adjust = 0; | |
929 | } | |
930 | /* update jitter */ | |
931 | pps_jitter += (jitter - pps_jitter) >> PPS_INTMIN; | |
932 | } | |
933 | ||
934 | /* | |
aa6f9c59 | 935 | * __hardpps() - discipline CPU clock oscillator to external PPS signal |
025b40ab AG |
936 | * |
937 | * This routine is called at each PPS signal arrival in order to | |
938 | * discipline the CPU clock oscillator to the PPS signal. It takes two | |
939 | * parameters: REALTIME and MONOTONIC_RAW clock timestamps. The former | |
940 | * is used to correct clock phase error and the latter is used to | |
941 | * correct the frequency. | |
942 | * | |
943 | * This code is based on David Mills's reference nanokernel | |
944 | * implementation. It was mostly rewritten but keeps the same idea. | |
945 | */ | |
aa6f9c59 | 946 | void __hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts) |
025b40ab AG |
947 | { |
948 | struct pps_normtime pts_norm, freq_norm; | |
025b40ab AG |
949 | |
950 | pts_norm = pps_normalize_ts(*phase_ts); | |
951 | ||
025b40ab AG |
952 | /* clear the error bits, they will be set again if needed */ |
953 | time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR); | |
954 | ||
955 | /* indicate signal presence */ | |
956 | time_status |= STA_PPSSIGNAL; | |
957 | pps_valid = PPS_VALID; | |
958 | ||
959 | /* when called for the first time, | |
960 | * just start the frequency interval */ | |
961 | if (unlikely(pps_fbase.tv_sec == 0)) { | |
962 | pps_fbase = *raw_ts; | |
025b40ab AG |
963 | return; |
964 | } | |
965 | ||
966 | /* ok, now we have a base for frequency calculation */ | |
967 | freq_norm = pps_normalize_ts(timespec_sub(*raw_ts, pps_fbase)); | |
968 | ||
969 | /* check that the signal is in the range | |
970 | * [1s - MAXFREQ us, 1s + MAXFREQ us], otherwise reject it */ | |
971 | if ((freq_norm.sec == 0) || | |
972 | (freq_norm.nsec > MAXFREQ * freq_norm.sec) || | |
973 | (freq_norm.nsec < -MAXFREQ * freq_norm.sec)) { | |
974 | time_status |= STA_PPSJITTER; | |
975 | /* restart the frequency calibration interval */ | |
976 | pps_fbase = *raw_ts; | |
6d9bcb62 | 977 | printk_deferred(KERN_ERR "hardpps: PPSJITTER: bad pulse\n"); |
025b40ab AG |
978 | return; |
979 | } | |
980 | ||
981 | /* signal is ok */ | |
982 | ||
983 | /* check if the current frequency interval is finished */ | |
984 | if (freq_norm.sec >= (1 << pps_shift)) { | |
985 | pps_calcnt++; | |
986 | /* restart the frequency calibration interval */ | |
987 | pps_fbase = *raw_ts; | |
988 | hardpps_update_freq(freq_norm); | |
989 | } | |
990 | ||
991 | hardpps_update_phase(pts_norm.nsec); | |
992 | ||
025b40ab | 993 | } |
025b40ab AG |
994 | #endif /* CONFIG_NTP_PPS */ |
995 | ||
10a398d0 RZ |
996 | static int __init ntp_tick_adj_setup(char *str) |
997 | { | |
cdafb93f FF |
998 | int rc = kstrtol(str, 0, (long *)&ntp_tick_adj); |
999 | ||
1000 | if (rc) | |
1001 | return rc; | |
069569e0 IM |
1002 | ntp_tick_adj <<= NTP_SCALE_SHIFT; |
1003 | ||
10a398d0 RZ |
1004 | return 1; |
1005 | } | |
1006 | ||
1007 | __setup("ntp_tick_adj=", ntp_tick_adj_setup); | |
7dffa3c6 RZ |
1008 | |
1009 | void __init ntp_init(void) | |
1010 | { | |
1011 | ntp_clear(); | |
7dffa3c6 | 1012 | } |