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