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