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