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