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