ntp.c (f43dc23d5ea91fca257be02138a255f02d98e806) ntp.c (025b40abe715d638e60516a657d354e8560c1a85)
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>
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>
17
18/*
19 * NTP timekeeping variables:
20 */
21
22/* USER_HZ period (usecs): */
23unsigned long tick_usec = TICK_USEC;
24

--- 44 unchanged lines hidden (view full) ---

69/* time at last adjustment (secs): */
70static long time_reftime;
71
72static long time_adjust;
73
74/* constant (boot-param configurable) NTP tick adjustment (upscaled) */
75static s64 ntp_tick_adj;
76
18
19/*
20 * NTP timekeeping variables:
21 */
22
23/* USER_HZ period (usecs): */
24unsigned long tick_usec = TICK_USEC;
25

--- 44 unchanged lines hidden (view full) ---

70/* time at last adjustment (secs): */
71static long time_reftime;
72
73static long time_adjust;
74
75/* constant (boot-param configurable) NTP tick adjustment (upscaled) */
76static s64 ntp_tick_adj;
77
78#ifdef CONFIG_NTP_PPS
79
77/*
80/*
81 * The following variables are used when a pulse-per-second (PPS) signal
82 * is available. They establish the engineering parameters of the clock
83 * discipline loop when controlled by the PPS signal.
84 */
85#define PPS_VALID 10 /* PPS signal watchdog max (s) */
86#define PPS_POPCORN 4 /* popcorn spike threshold (shift) */
87#define PPS_INTMIN 2 /* min freq interval (s) (shift) */
88#define PPS_INTMAX 8 /* max freq interval (s) (shift) */
89#define PPS_INTCOUNT 4 /* number of consecutive good intervals to
90 increase pps_shift or consecutive bad
91 intervals to decrease it */
92#define PPS_MAXWANDER 100000 /* max PPS freq wander (ns/s) */
93
94static int pps_valid; /* signal watchdog counter */
95static long pps_tf[3]; /* phase median filter */
96static long pps_jitter; /* current jitter (ns) */
97static struct timespec pps_fbase; /* beginning of the last freq interval */
98static int pps_shift; /* current interval duration (s) (shift) */
99static int pps_intcnt; /* interval counter */
100static s64 pps_freq; /* frequency offset (scaled ns/s) */
101static long pps_stabil; /* current stability (scaled ns/s) */
102
103/*
104 * PPS signal quality monitors
105 */
106static long pps_calcnt; /* calibration intervals */
107static long pps_jitcnt; /* jitter limit exceeded */
108static long pps_stbcnt; /* stability limit exceeded */
109static long pps_errcnt; /* calibration errors */
110
111
112/* PPS kernel consumer compensates the whole phase error immediately.
113 * Otherwise, reduce the offset by a fixed factor times the time constant.
114 */
115static inline s64 ntp_offset_chunk(s64 offset)
116{
117 if (time_status & STA_PPSTIME && time_status & STA_PPSSIGNAL)
118 return offset;
119 else
120 return shift_right(offset, SHIFT_PLL + time_constant);
121}
122
123static inline void pps_reset_freq_interval(void)
124{
125 /* the PPS calibration interval may end
126 surprisingly early */
127 pps_shift = PPS_INTMIN;
128 pps_intcnt = 0;
129}
130
131/**
132 * pps_clear - Clears the PPS state variables
133 *
134 * Must be called while holding a write on the xtime_lock
135 */
136static 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 *
150 * Must be called while holding a write on the xtime_lock
151 */
152static inline void pps_dec_valid(void)
153{
154 if (pps_valid > 0)
155 pps_valid--;
156 else {
157 time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
158 STA_PPSWANDER | STA_PPSERROR);
159 pps_clear();
160 }
161}
162
163static inline void pps_set_freq(s64 freq)
164{
165 pps_freq = freq;
166}
167
168static inline int is_error_status(int status)
169{
170 return (time_status & (STA_UNSYNC|STA_CLOCKERR))
171 /* PPS signal lost when either PPS time or
172 * PPS frequency synchronization requested
173 */
174 || ((time_status & (STA_PPSFREQ|STA_PPSTIME))
175 && !(time_status & STA_PPSSIGNAL))
176 /* PPS jitter exceeded when
177 * PPS time synchronization requested */
178 || ((time_status & (STA_PPSTIME|STA_PPSJITTER))
179 == (STA_PPSTIME|STA_PPSJITTER))
180 /* PPS wander exceeded or calibration error when
181 * PPS frequency synchronization requested
182 */
183 || ((time_status & STA_PPSFREQ)
184 && (time_status & (STA_PPSWANDER|STA_PPSERROR)));
185}
186
187static inline void pps_fill_timex(struct timex *txc)
188{
189 txc->ppsfreq = shift_right((pps_freq >> PPM_SCALE_INV_SHIFT) *
190 PPM_SCALE_INV, NTP_SCALE_SHIFT);
191 txc->jitter = pps_jitter;
192 if (!(time_status & STA_NANO))
193 txc->jitter /= NSEC_PER_USEC;
194 txc->shift = pps_shift;
195 txc->stabil = pps_stabil;
196 txc->jitcnt = pps_jitcnt;
197 txc->calcnt = pps_calcnt;
198 txc->errcnt = pps_errcnt;
199 txc->stbcnt = pps_stbcnt;
200}
201
202#else /* !CONFIG_NTP_PPS */
203
204static inline s64 ntp_offset_chunk(s64 offset)
205{
206 return shift_right(offset, SHIFT_PLL + time_constant);
207}
208
209static inline void pps_reset_freq_interval(void) {}
210static inline void pps_clear(void) {}
211static inline void pps_dec_valid(void) {}
212static inline void pps_set_freq(s64 freq) {}
213
214static inline int is_error_status(int status)
215{
216 return status & (STA_UNSYNC|STA_CLOCKERR);
217}
218
219static inline void pps_fill_timex(struct timex *txc)
220{
221 /* PPS is not implemented, so these are zero */
222 txc->ppsfreq = 0;
223 txc->jitter = 0;
224 txc->shift = 0;
225 txc->stabil = 0;
226 txc->jitcnt = 0;
227 txc->calcnt = 0;
228 txc->errcnt = 0;
229 txc->stbcnt = 0;
230}
231
232#endif /* CONFIG_NTP_PPS */
233
234/*
78 * NTP methods:
79 */
80
81/*
82 * Update (tick_length, tick_length_base, tick_nsec), based
83 * on (tick_usec, ntp_tick_adj, time_freq):
84 */
85static void ntp_update_frequency(void)

--- 94 unchanged lines hidden (view full) ---

180 time_status |= STA_UNSYNC;
181 time_maxerror = NTP_PHASE_LIMIT;
182 time_esterror = NTP_PHASE_LIMIT;
183
184 ntp_update_frequency();
185
186 tick_length = tick_length_base;
187 time_offset = 0;
235 * NTP methods:
236 */
237
238/*
239 * Update (tick_length, tick_length_base, tick_nsec), based
240 * on (tick_usec, ntp_tick_adj, time_freq):
241 */
242static void ntp_update_frequency(void)

--- 94 unchanged lines hidden (view full) ---

337 time_status |= STA_UNSYNC;
338 time_maxerror = NTP_PHASE_LIMIT;
339 time_esterror = NTP_PHASE_LIMIT;
340
341 ntp_update_frequency();
342
343 tick_length = tick_length_base;
344 time_offset = 0;
345
346 /* Clear PPS state variables */
347 pps_clear();
188}
189
190/*
191 * Leap second processing. If in leap-insert state at the end of the
192 * day, the system clock is set back one second; if in leap-delete
193 * state, the system clock is set ahead one second.
194 */
195static enum hrtimer_restart ntp_leap_second(struct hrtimer *timer)

--- 49 unchanged lines hidden (view full) ---

245
246 /* Bump the maxerror field */
247 time_maxerror += MAXFREQ / NSEC_PER_USEC;
248 if (time_maxerror > NTP_PHASE_LIMIT) {
249 time_maxerror = NTP_PHASE_LIMIT;
250 time_status |= STA_UNSYNC;
251 }
252
348}
349
350/*
351 * Leap second processing. If in leap-insert state at the end of the
352 * day, the system clock is set back one second; if in leap-delete
353 * state, the system clock is set ahead one second.
354 */
355static enum hrtimer_restart ntp_leap_second(struct hrtimer *timer)

--- 49 unchanged lines hidden (view full) ---

405
406 /* Bump the maxerror field */
407 time_maxerror += MAXFREQ / NSEC_PER_USEC;
408 if (time_maxerror > NTP_PHASE_LIMIT) {
409 time_maxerror = NTP_PHASE_LIMIT;
410 time_status |= STA_UNSYNC;
411 }
412
253 /*
254 * Compute the phase adjustment for the next second. The offset is
255 * reduced by a fixed factor times the time constant.
256 */
413 /* Compute the phase adjustment for the next second */
257 tick_length = tick_length_base;
258
414 tick_length = tick_length_base;
415
259 delta = shift_right(time_offset, SHIFT_PLL + time_constant);
416 delta = ntp_offset_chunk(time_offset);
260 time_offset -= delta;
261 tick_length += delta;
262
417 time_offset -= delta;
418 tick_length += delta;
419
420 /* Check PPS signal */
421 pps_dec_valid();
422
263 if (!time_adjust)
264 return;
265
266 if (time_adjust > MAX_TICKADJ) {
267 time_adjust -= MAX_TICKADJ;
268 tick_length += MAX_TICKADJ_SCALED;
269 return;
270 }

--- 93 unchanged lines hidden (view full) ---

364/*
365 * Propagate a new txc->status value into the NTP state:
366 */
367static inline void process_adj_status(struct timex *txc, struct timespec *ts)
368{
369 if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) {
370 time_state = TIME_OK;
371 time_status = STA_UNSYNC;
423 if (!time_adjust)
424 return;
425
426 if (time_adjust > MAX_TICKADJ) {
427 time_adjust -= MAX_TICKADJ;
428 tick_length += MAX_TICKADJ_SCALED;
429 return;
430 }

--- 93 unchanged lines hidden (view full) ---

524/*
525 * Propagate a new txc->status value into the NTP state:
526 */
527static inline void process_adj_status(struct timex *txc, struct timespec *ts)
528{
529 if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) {
530 time_state = TIME_OK;
531 time_status = STA_UNSYNC;
532 /* restart PPS frequency calibration */
533 pps_reset_freq_interval();
372 }
373
374 /*
375 * If we turn on PLL adjustments then reset the
376 * reference time to current time.
377 */
378 if (!(time_status & STA_PLL) && (txc->status & STA_PLL))
379 time_reftime = get_seconds();

--- 33 unchanged lines hidden (view full) ---

413
414 if (txc->modes & ADJ_MICRO)
415 time_status &= ~STA_NANO;
416
417 if (txc->modes & ADJ_FREQUENCY) {
418 time_freq = txc->freq * PPM_SCALE;
419 time_freq = min(time_freq, MAXFREQ_SCALED);
420 time_freq = max(time_freq, -MAXFREQ_SCALED);
534 }
535
536 /*
537 * If we turn on PLL adjustments then reset the
538 * reference time to current time.
539 */
540 if (!(time_status & STA_PLL) && (txc->status & STA_PLL))
541 time_reftime = get_seconds();

--- 33 unchanged lines hidden (view full) ---

575
576 if (txc->modes & ADJ_MICRO)
577 time_status &= ~STA_NANO;
578
579 if (txc->modes & ADJ_FREQUENCY) {
580 time_freq = txc->freq * PPM_SCALE;
581 time_freq = min(time_freq, MAXFREQ_SCALED);
582 time_freq = max(time_freq, -MAXFREQ_SCALED);
583 /* update pps_freq */
584 pps_set_freq(time_freq);
421 }
422
423 if (txc->modes & ADJ_MAXERROR)
424 time_maxerror = txc->maxerror;
425
426 if (txc->modes & ADJ_ESTERROR)
427 time_esterror = txc->esterror;
428

--- 74 unchanged lines hidden (view full) ---

503
504 txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
505 NTP_SCALE_SHIFT);
506 if (!(time_status & STA_NANO))
507 txc->offset /= NSEC_PER_USEC;
508 }
509
510 result = time_state; /* mostly `TIME_OK' */
585 }
586
587 if (txc->modes & ADJ_MAXERROR)
588 time_maxerror = txc->maxerror;
589
590 if (txc->modes & ADJ_ESTERROR)
591 time_esterror = txc->esterror;
592

--- 74 unchanged lines hidden (view full) ---

667
668 txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
669 NTP_SCALE_SHIFT);
670 if (!(time_status & STA_NANO))
671 txc->offset /= NSEC_PER_USEC;
672 }
673
674 result = time_state; /* mostly `TIME_OK' */
511 if (time_status & (STA_UNSYNC|STA_CLOCKERR))
675 /* check for errors */
676 if (is_error_status(time_status))
512 result = TIME_ERROR;
513
514 txc->freq = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) *
515 PPM_SCALE_INV, NTP_SCALE_SHIFT);
516 txc->maxerror = time_maxerror;
517 txc->esterror = time_esterror;
518 txc->status = time_status;
519 txc->constant = time_constant;
520 txc->precision = 1;
521 txc->tolerance = MAXFREQ_SCALED / PPM_SCALE;
522 txc->tick = tick_usec;
523 txc->tai = time_tai;
524
677 result = TIME_ERROR;
678
679 txc->freq = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) *
680 PPM_SCALE_INV, NTP_SCALE_SHIFT);
681 txc->maxerror = time_maxerror;
682 txc->esterror = time_esterror;
683 txc->status = time_status;
684 txc->constant = time_constant;
685 txc->precision = 1;
686 txc->tolerance = MAXFREQ_SCALED / PPM_SCALE;
687 txc->tick = tick_usec;
688 txc->tai = time_tai;
689
525 /* PPS is not implemented, so these are zero */
526 txc->ppsfreq = 0;
527 txc->jitter = 0;
528 txc->shift = 0;
529 txc->stabil = 0;
530 txc->jitcnt = 0;
531 txc->calcnt = 0;
532 txc->errcnt = 0;
533 txc->stbcnt = 0;
690 /* fill PPS status fields */
691 pps_fill_timex(txc);
534
535 write_sequnlock_irq(&xtime_lock);
536
537 txc->time.tv_sec = ts.tv_sec;
538 txc->time.tv_usec = ts.tv_nsec;
539 if (!(time_status & STA_NANO))
540 txc->time.tv_usec /= NSEC_PER_USEC;
541
542 notify_cmos_timer();
543
544 return result;
545}
546
692
693 write_sequnlock_irq(&xtime_lock);
694
695 txc->time.tv_sec = ts.tv_sec;
696 txc->time.tv_usec = ts.tv_nsec;
697 if (!(time_status & STA_NANO))
698 txc->time.tv_usec /= NSEC_PER_USEC;
699
700 notify_cmos_timer();
701
702 return result;
703}
704
705#ifdef CONFIG_NTP_PPS
706
707/* actually struct pps_normtime is good old struct timespec, but it is
708 * semantically different (and it is the reason why it was invented):
709 * pps_normtime.nsec has a range of ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ]
710 * while timespec.tv_nsec has a range of [0, NSEC_PER_SEC) */
711struct pps_normtime {
712 __kernel_time_t sec; /* seconds */
713 long nsec; /* nanoseconds */
714};
715
716/* normalize the timestamp so that nsec is in the
717 ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ] interval */
718static inline struct pps_normtime pps_normalize_ts(struct timespec ts)
719{
720 struct pps_normtime norm = {
721 .sec = ts.tv_sec,
722 .nsec = ts.tv_nsec
723 };
724
725 if (norm.nsec > (NSEC_PER_SEC >> 1)) {
726 norm.nsec -= NSEC_PER_SEC;
727 norm.sec++;
728 }
729
730 return norm;
731}
732
733/* get current phase correction and jitter */
734static inline long pps_phase_filter_get(long *jitter)
735{
736 *jitter = pps_tf[0] - pps_tf[1];
737 if (*jitter < 0)
738 *jitter = -*jitter;
739
740 /* TODO: test various filters */
741 return pps_tf[0];
742}
743
744/* add the sample to the phase filter */
745static inline void pps_phase_filter_add(long err)
746{
747 pps_tf[2] = pps_tf[1];
748 pps_tf[1] = pps_tf[0];
749 pps_tf[0] = err;
750}
751
752/* decrease frequency calibration interval length.
753 * It is halved after four consecutive unstable intervals.
754 */
755static inline void pps_dec_freq_interval(void)
756{
757 if (--pps_intcnt <= -PPS_INTCOUNT) {
758 pps_intcnt = -PPS_INTCOUNT;
759 if (pps_shift > PPS_INTMIN) {
760 pps_shift--;
761 pps_intcnt = 0;
762 }
763 }
764}
765
766/* increase frequency calibration interval length.
767 * It is doubled after four consecutive stable intervals.
768 */
769static inline void pps_inc_freq_interval(void)
770{
771 if (++pps_intcnt >= PPS_INTCOUNT) {
772 pps_intcnt = PPS_INTCOUNT;
773 if (pps_shift < PPS_INTMAX) {
774 pps_shift++;
775 pps_intcnt = 0;
776 }
777 }
778}
779
780/* update clock frequency based on MONOTONIC_RAW clock PPS signal
781 * timestamps
782 *
783 * At the end of the calibration interval the difference between the
784 * first and last MONOTONIC_RAW clock timestamps divided by the length
785 * of the interval becomes the frequency update. If the interval was
786 * too long, the data are discarded.
787 * Returns the difference between old and new frequency values.
788 */
789static long hardpps_update_freq(struct pps_normtime freq_norm)
790{
791 long delta, delta_mod;
792 s64 ftemp;
793
794 /* check if the frequency interval was too long */
795 if (freq_norm.sec > (2 << pps_shift)) {
796 time_status |= STA_PPSERROR;
797 pps_errcnt++;
798 pps_dec_freq_interval();
799 pr_err("hardpps: PPSERROR: interval too long - %ld s\n",
800 freq_norm.sec);
801 return 0;
802 }
803
804 /* here the raw frequency offset and wander (stability) is
805 * calculated. If the wander is less than the wander threshold
806 * the interval is increased; otherwise it is decreased.
807 */
808 ftemp = div_s64(((s64)(-freq_norm.nsec)) << NTP_SCALE_SHIFT,
809 freq_norm.sec);
810 delta = shift_right(ftemp - pps_freq, NTP_SCALE_SHIFT);
811 pps_freq = ftemp;
812 if (delta > PPS_MAXWANDER || delta < -PPS_MAXWANDER) {
813 pr_warning("hardpps: PPSWANDER: change=%ld\n", delta);
814 time_status |= STA_PPSWANDER;
815 pps_stbcnt++;
816 pps_dec_freq_interval();
817 } else { /* good sample */
818 pps_inc_freq_interval();
819 }
820
821 /* the stability metric is calculated as the average of recent
822 * frequency changes, but is used only for performance
823 * monitoring
824 */
825 delta_mod = delta;
826 if (delta_mod < 0)
827 delta_mod = -delta_mod;
828 pps_stabil += (div_s64(((s64)delta_mod) <<
829 (NTP_SCALE_SHIFT - SHIFT_USEC),
830 NSEC_PER_USEC) - pps_stabil) >> PPS_INTMIN;
831
832 /* if enabled, the system clock frequency is updated */
833 if ((time_status & STA_PPSFREQ) != 0 &&
834 (time_status & STA_FREQHOLD) == 0) {
835 time_freq = pps_freq;
836 ntp_update_frequency();
837 }
838
839 return delta;
840}
841
842/* correct REALTIME clock phase error against PPS signal */
843static void hardpps_update_phase(long error)
844{
845 long correction = -error;
846 long jitter;
847
848 /* add the sample to the median filter */
849 pps_phase_filter_add(correction);
850 correction = pps_phase_filter_get(&jitter);
851
852 /* Nominal jitter is due to PPS signal noise. If it exceeds the
853 * threshold, the sample is discarded; otherwise, if so enabled,
854 * the time offset is updated.
855 */
856 if (jitter > (pps_jitter << PPS_POPCORN)) {
857 pr_warning("hardpps: PPSJITTER: jitter=%ld, limit=%ld\n",
858 jitter, (pps_jitter << PPS_POPCORN));
859 time_status |= STA_PPSJITTER;
860 pps_jitcnt++;
861 } else if (time_status & STA_PPSTIME) {
862 /* correct the time using the phase offset */
863 time_offset = div_s64(((s64)correction) << NTP_SCALE_SHIFT,
864 NTP_INTERVAL_FREQ);
865 /* cancel running adjtime() */
866 time_adjust = 0;
867 }
868 /* update jitter */
869 pps_jitter += (jitter - pps_jitter) >> PPS_INTMIN;
870}
871
872/*
873 * hardpps() - discipline CPU clock oscillator to external PPS signal
874 *
875 * This routine is called at each PPS signal arrival in order to
876 * discipline the CPU clock oscillator to the PPS signal. It takes two
877 * parameters: REALTIME and MONOTONIC_RAW clock timestamps. The former
878 * is used to correct clock phase error and the latter is used to
879 * correct the frequency.
880 *
881 * This code is based on David Mills's reference nanokernel
882 * implementation. It was mostly rewritten but keeps the same idea.
883 */
884void hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
885{
886 struct pps_normtime pts_norm, freq_norm;
887 unsigned long flags;
888
889 pts_norm = pps_normalize_ts(*phase_ts);
890
891 write_seqlock_irqsave(&xtime_lock, flags);
892
893 /* clear the error bits, they will be set again if needed */
894 time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR);
895
896 /* indicate signal presence */
897 time_status |= STA_PPSSIGNAL;
898 pps_valid = PPS_VALID;
899
900 /* when called for the first time,
901 * just start the frequency interval */
902 if (unlikely(pps_fbase.tv_sec == 0)) {
903 pps_fbase = *raw_ts;
904 write_sequnlock_irqrestore(&xtime_lock, flags);
905 return;
906 }
907
908 /* ok, now we have a base for frequency calculation */
909 freq_norm = pps_normalize_ts(timespec_sub(*raw_ts, pps_fbase));
910
911 /* check that the signal is in the range
912 * [1s - MAXFREQ us, 1s + MAXFREQ us], otherwise reject it */
913 if ((freq_norm.sec == 0) ||
914 (freq_norm.nsec > MAXFREQ * freq_norm.sec) ||
915 (freq_norm.nsec < -MAXFREQ * freq_norm.sec)) {
916 time_status |= STA_PPSJITTER;
917 /* restart the frequency calibration interval */
918 pps_fbase = *raw_ts;
919 write_sequnlock_irqrestore(&xtime_lock, flags);
920 pr_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 write_sequnlock_irqrestore(&xtime_lock, flags);
937}
938EXPORT_SYMBOL(hardpps);
939
940#endif /* CONFIG_NTP_PPS */
941
547static int __init ntp_tick_adj_setup(char *str)
548{
549 ntp_tick_adj = simple_strtol(str, NULL, 0);
550 ntp_tick_adj <<= NTP_SCALE_SHIFT;
551
552 return 1;
553}
554
555__setup("ntp_tick_adj=", ntp_tick_adj_setup);
556
557void __init ntp_init(void)
558{
559 ntp_clear();
560 hrtimer_init(&leap_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
561 leap_timer.function = ntp_leap_second;
562}
942static int __init ntp_tick_adj_setup(char *str)
943{
944 ntp_tick_adj = simple_strtol(str, NULL, 0);
945 ntp_tick_adj <<= NTP_SCALE_SHIFT;
946
947 return 1;
948}
949
950__setup("ntp_tick_adj=", ntp_tick_adj_setup);
951
952void __init ntp_init(void)
953{
954 ntp_clear();
955 hrtimer_init(&leap_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
956 leap_timer.function = ntp_leap_second;
957}