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 } 980