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