Merge branch 'core-locking-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[~shefty/rdma-dev.git] / kernel / time / ntp.c
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
22 /*
23  * NTP timekeeping variables:
24  */
25
26 DEFINE_RAW_SPINLOCK(ntp_lock);
27
28
29 /* USER_HZ period (usecs): */
30 unsigned long                   tick_usec = TICK_USEC;
31
32 /* SHIFTED_HZ period (nsecs): */
33 unsigned long                   tick_nsec;
34
35 static u64                      tick_length;
36 static u64                      tick_length_base;
37
38 #define MAX_TICKADJ             500LL           /* usecs */
39 #define MAX_TICKADJ_SCALED \
40         (((MAX_TICKADJ * NSEC_PER_USEC) << NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ)
41
42 /*
43  * phase-lock loop variables
44  */
45
46 /*
47  * clock synchronization status
48  *
49  * (TIME_ERROR prevents overwriting the CMOS clock)
50  */
51 static int                      time_state = TIME_OK;
52
53 /* clock status bits:                                                   */
54 static int                      time_status = STA_UNSYNC;
55
56 /* TAI offset (secs):                                                   */
57 static long                     time_tai;
58
59 /* time adjustment (nsecs):                                             */
60 static s64                      time_offset;
61
62 /* pll time constant:                                                   */
63 static long                     time_constant = 2;
64
65 /* maximum error (usecs):                                               */
66 static long                     time_maxerror = NTP_PHASE_LIMIT;
67
68 /* estimated error (usecs):                                             */
69 static long                     time_esterror = NTP_PHASE_LIMIT;
70
71 /* frequency offset (scaled nsecs/secs):                                */
72 static s64                      time_freq;
73
74 /* time at last adjustment (secs):                                      */
75 static long                     time_reftime;
76
77 static long                     time_adjust;
78
79 /* constant (boot-param configurable) NTP tick adjustment (upscaled)    */
80 static s64                      ntp_tick_adj;
81
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
98 static int pps_valid;           /* signal watchdog counter */
99 static long pps_tf[3];          /* phase median filter */
100 static long pps_jitter;         /* current jitter (ns) */
101 static struct timespec pps_fbase; /* beginning of the last freq interval */
102 static int pps_shift;           /* current interval duration (s) (shift) */
103 static int pps_intcnt;          /* interval counter */
104 static s64 pps_freq;            /* frequency offset (scaled ns/s) */
105 static long pps_stabil;         /* current stability (scaled ns/s) */
106
107 /*
108  * PPS signal quality monitors
109  */
110 static long pps_calcnt;         /* calibration intervals */
111 static long pps_jitcnt;         /* jitter limit exceeded */
112 static long pps_stbcnt;         /* stability limit exceeded */
113 static 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  */
119 static 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
127 static 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  *
138  * Must be called while holding a write on the ntp_lock
139  */
140 static 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  *
154  * Must be called while holding a write on the ntp_lock
155  */
156 static inline void pps_dec_valid(void)
157 {
158         if (pps_valid > 0)
159                 pps_valid--;
160         else {
161                 time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
162                                  STA_PPSWANDER | STA_PPSERROR);
163                 pps_clear();
164         }
165 }
166
167 static inline void pps_set_freq(s64 freq)
168 {
169         pps_freq = freq;
170 }
171
172 static inline int is_error_status(int status)
173 {
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
191 static 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
208 static inline s64 ntp_offset_chunk(s64 offset)
209 {
210         return shift_right(offset, SHIFT_PLL + time_constant);
211 }
212
213 static inline void pps_reset_freq_interval(void) {}
214 static inline void pps_clear(void) {}
215 static inline void pps_dec_valid(void) {}
216 static inline void pps_set_freq(s64 freq) {}
217
218 static inline int is_error_status(int status)
219 {
220         return status & (STA_UNSYNC|STA_CLOCKERR);
221 }
222
223 static 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
238
239 /**
240  * ntp_synced - Returns 1 if the NTP status is not UNSYNC
241  *
242  */
243 static inline int ntp_synced(void)
244 {
245         return !(time_status & STA_UNSYNC);
246 }
247
248
249 /*
250  * NTP methods:
251  */
252
253 /*
254  * Update (tick_length, tick_length_base, tick_nsec), based
255  * on (tick_usec, ntp_tick_adj, time_freq):
256  */
257 static void ntp_update_frequency(void)
258 {
259         u64 second_length;
260         u64 new_base;
261
262         second_length            = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ)
263                                                 << NTP_SCALE_SHIFT;
264
265         second_length           += ntp_tick_adj;
266         second_length           += time_freq;
267
268         tick_nsec                = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
269         new_base                 = div_u64(second_length, NTP_INTERVAL_FREQ);
270
271         /*
272          * Don't wait for the next second_overflow, apply
273          * the change to the tick length immediately:
274          */
275         tick_length             += new_base - tick_length_base;
276         tick_length_base         = new_base;
277 }
278
279 static inline s64 ntp_update_offset_fll(s64 offset64, long secs)
280 {
281         time_status &= ~STA_MODE;
282
283         if (secs < MINSEC)
284                 return 0;
285
286         if (!(time_status & STA_FLL) && (secs <= MAXSEC))
287                 return 0;
288
289         time_status |= STA_MODE;
290
291         return div64_long(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs);
292 }
293
294 static void ntp_update_offset(long offset)
295 {
296         s64 freq_adj;
297         s64 offset64;
298         long secs;
299
300         if (!(time_status & STA_PLL))
301                 return;
302
303         if (!(time_status & STA_NANO))
304                 offset *= NSEC_PER_USEC;
305
306         /*
307          * Scale the phase adjustment and
308          * clamp to the operating range.
309          */
310         offset = min(offset, MAXPHASE);
311         offset = max(offset, -MAXPHASE);
312
313         /*
314          * Select how the frequency is to be controlled
315          * and in which mode (PLL or FLL).
316          */
317         secs = get_seconds() - time_reftime;
318         if (unlikely(time_status & STA_FREQHOLD))
319                 secs = 0;
320
321         time_reftime = get_seconds();
322
323         offset64    = offset;
324         freq_adj    = ntp_update_offset_fll(offset64, secs);
325
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));
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);
342 }
343
344 /**
345  * ntp_clear - Clears the NTP state variables
346  */
347 void ntp_clear(void)
348 {
349         unsigned long flags;
350
351         raw_spin_lock_irqsave(&ntp_lock, flags);
352
353         time_adjust     = 0;            /* stop active adjtime() */
354         time_status     |= STA_UNSYNC;
355         time_maxerror   = NTP_PHASE_LIMIT;
356         time_esterror   = NTP_PHASE_LIMIT;
357
358         ntp_update_frequency();
359
360         tick_length     = tick_length_base;
361         time_offset     = 0;
362
363         /* Clear PPS state variables */
364         pps_clear();
365         raw_spin_unlock_irqrestore(&ntp_lock, flags);
366
367 }
368
369
370 u64 ntp_tick_length(void)
371 {
372         unsigned long flags;
373         s64 ret;
374
375         raw_spin_lock_irqsave(&ntp_lock, flags);
376         ret = tick_length;
377         raw_spin_unlock_irqrestore(&ntp_lock, flags);
378         return ret;
379 }
380
381
382 /*
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
391  */
392 int second_overflow(unsigned long secs)
393 {
394         s64 delta;
395         int leap = 0;
396         unsigned long flags;
397
398         raw_spin_lock_irqsave(&ntp_lock, flags);
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          */
405         switch (time_state) {
406         case TIME_OK:
407                 if (time_status & STA_INS)
408                         time_state = TIME_INS;
409                 else if (time_status & STA_DEL)
410                         time_state = TIME_DEL;
411                 break;
412         case TIME_INS:
413                 if (!(time_status & STA_INS))
414                         time_state = TIME_OK;
415                 else if (secs % 86400 == 0) {
416                         leap = -1;
417                         time_state = TIME_OOP;
418                         time_tai++;
419                         printk(KERN_NOTICE
420                                 "Clock: inserting leap second 23:59:60 UTC\n");
421                 }
422                 break;
423         case TIME_DEL:
424                 if (!(time_status & STA_DEL))
425                         time_state = TIME_OK;
426                 else if ((secs + 1) % 86400 == 0) {
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                 }
433                 break;
434         case TIME_OOP:
435                 time_state = TIME_WAIT;
436                 break;
437
438         case TIME_WAIT:
439                 if (!(time_status & (STA_INS | STA_DEL)))
440                         time_state = TIME_OK;
441                 break;
442         }
443
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;
450         }
451
452         /* Compute the phase adjustment for the next second */
453         tick_length      = tick_length_base;
454
455         delta            = ntp_offset_chunk(time_offset);
456         time_offset     -= delta;
457         tick_length     += delta;
458
459         /* Check PPS signal */
460         pps_dec_valid();
461
462         if (!time_adjust)
463                 goto out;
464
465         if (time_adjust > MAX_TICKADJ) {
466                 time_adjust -= MAX_TICKADJ;
467                 tick_length += MAX_TICKADJ_SCALED;
468                 goto out;
469         }
470
471         if (time_adjust < -MAX_TICKADJ) {
472                 time_adjust += MAX_TICKADJ;
473                 tick_length -= MAX_TICKADJ_SCALED;
474                 goto out;
475         }
476
477         tick_length += (s64)(time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)
478                                                          << NTP_SCALE_SHIFT;
479         time_adjust = 0;
480
481 out:
482         raw_spin_unlock_irqrestore(&ntp_lock, flags);
483
484         return leap;
485 }
486
487 #if defined(CONFIG_GENERIC_CMOS_UPDATE) || defined(CONFIG_RTC_SYSTOHC)
488 static void sync_cmos_clock(struct work_struct *work);
489
490 static DECLARE_DELAYED_WORK(sync_cmos_work, sync_cmos_clock);
491
492 static void sync_cmos_clock(struct work_struct *work)
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          */
504         if (!ntp_synced()) {
505                 /*
506                  * Not synced, exit, do not restart a timer (if one is
507                  * running, let it run out).
508                  */
509                 return;
510         }
511
512         getnstimeofday(&now);
513         if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2) {
514                 struct timespec adjust = now;
515
516                 fail = -ENODEV;
517                 if (persistent_clock_is_local)
518                         adjust.tv_sec -= (sys_tz.tz_minuteswest * 60);
519 #ifdef CONFIG_GENERIC_CMOS_UPDATE
520                 fail = update_persistent_clock(adjust);
521 #endif
522 #ifdef CONFIG_RTC_SYSTOHC
523                 if (fail == -ENODEV)
524                         fail = rtc_set_ntp_time(adjust);
525 #endif
526         }
527
528         next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec - (TICK_NSEC / 2);
529         if (next.tv_nsec <= 0)
530                 next.tv_nsec += NSEC_PER_SEC;
531
532         if (!fail || fail == -ENODEV)
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         }
541         schedule_delayed_work(&sync_cmos_work, timespec_to_jiffies(&next));
542 }
543
544 static void notify_cmos_timer(void)
545 {
546         schedule_delayed_work(&sync_cmos_work, 0);
547 }
548
549 #else
550 static inline void notify_cmos_timer(void) { }
551 #endif
552
553
554 /*
555  * Propagate a new txc->status value into the NTP state:
556  */
557 static inline void process_adj_status(struct timex *txc, struct timespec *ts)
558 {
559         if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) {
560                 time_state = TIME_OK;
561                 time_status = STA_UNSYNC;
562                 /* restart PPS frequency calibration */
563                 pps_reset_freq_interval();
564         }
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))
571                 time_reftime = get_seconds();
572
573         /* only set allowed bits */
574         time_status &= STA_RONLY;
575         time_status |= txc->status & ~STA_RONLY;
576 }
577
578 /*
579  * Called with ntp_lock held, so we can access and modify
580  * all the global NTP state:
581  */
582 static 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;
589
590         if (txc->modes & ADJ_MICRO)
591                 time_status &= ~STA_NANO;
592
593         if (txc->modes & ADJ_FREQUENCY) {
594                 time_freq = txc->freq * PPM_SCALE;
595                 time_freq = min(time_freq, MAXFREQ_SCALED);
596                 time_freq = max(time_freq, -MAXFREQ_SCALED);
597                 /* update pps_freq */
598                 pps_set_freq(time_freq);
599         }
600
601         if (txc->modes & ADJ_MAXERROR)
602                 time_maxerror = txc->maxerror;
603
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);
620
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
628 /*
629  * adjtimex mainly allows reading (and writing, if superuser) of
630  * kernel time-keeping variables. used by xntpd.
631  */
632 int do_adjtimex(struct timex *txc)
633 {
634         struct timespec ts;
635         int result;
636
637         /* Validate the data before disabling interrupts */
638         if (txc->modes & ADJ_ADJTIME) {
639                 /* singleshot must not be used with any other mode bits */
640                 if (!(txc->modes & ADJ_OFFSET_SINGLESHOT))
641                         return -EINVAL;
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
650                 /*
651                  * if the quartz is off by more than 10% then
652                  * something is VERY wrong!
653                  */
654                 if (txc->modes & ADJ_TICK &&
655                     (txc->tick <  900000/USER_HZ ||
656                      txc->tick > 1100000/USER_HZ))
657                         return -EINVAL;
658         }
659
660         if (txc->modes & ADJ_SETOFFSET) {
661                 struct timespec delta;
662                 delta.tv_sec  = txc->time.tv_sec;
663                 delta.tv_nsec = txc->time.tv_usec;
664                 if (!capable(CAP_SYS_TIME))
665                         return -EPERM;
666                 if (!(txc->modes & ADJ_NANO))
667                         delta.tv_nsec *= 1000;
668                 result = timekeeping_inject_offset(&delta);
669                 if (result)
670                         return result;
671         }
672
673         getnstimeofday(&ts);
674
675         raw_spin_lock_irq(&ntp_lock);
676
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;
686         } else {
687
688                 /* If there are input parameters, then process them: */
689                 if (txc->modes)
690                         process_adjtimex_modes(txc, &ts);
691
692                 txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
693                                   NTP_SCALE_SHIFT);
694                 if (!(time_status & STA_NANO))
695                         txc->offset /= NSEC_PER_USEC;
696         }
697
698         result = time_state;    /* mostly `TIME_OK' */
699         /* check for errors */
700         if (is_error_status(time_status))
701                 result = TIME_ERROR;
702
703         txc->freq          = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) *
704                                          PPM_SCALE_INV, NTP_SCALE_SHIFT);
705         txc->maxerror      = time_maxerror;
706         txc->esterror      = time_esterror;
707         txc->status        = time_status;
708         txc->constant      = time_constant;
709         txc->precision     = 1;
710         txc->tolerance     = MAXFREQ_SCALED / PPM_SCALE;
711         txc->tick          = tick_usec;
712         txc->tai           = time_tai;
713
714         /* fill PPS status fields */
715         pps_fill_timex(txc);
716
717         raw_spin_unlock_irq(&ntp_lock);
718
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;
723
724         notify_cmos_timer();
725
726         return result;
727 }
728
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) */
735 struct 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 */
742 static 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 */
758 static 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 */
769 static 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  */
779 static 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  */
793 static 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  */
813 static 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 */
867 static 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  */
908 void 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
915         raw_spin_lock_irqsave(&ntp_lock, flags);
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;
928                 raw_spin_unlock_irqrestore(&ntp_lock, flags);
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;
943                 raw_spin_unlock_irqrestore(&ntp_lock, flags);
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
960         raw_spin_unlock_irqrestore(&ntp_lock, flags);
961 }
962 EXPORT_SYMBOL(hardpps);
963
964 #endif  /* CONFIG_NTP_PPS */
965
966 static int __init ntp_tick_adj_setup(char *str)
967 {
968         ntp_tick_adj = simple_strtol(str, NULL, 0);
969         ntp_tick_adj <<= NTP_SCALE_SHIFT;
970
971         return 1;
972 }
973
974 __setup("ntp_tick_adj=", ntp_tick_adj_setup);
975
976 void __init ntp_init(void)
977 {
978         ntp_clear();
979 }