ntp.c 23.4 KB
Newer Older
1 2 3 4 5 6 7
/*
 * NTP state machine interfaces and logic.
 *
 * This code was mainly moved from kernel/timer.c and kernel/time.c
 * Please see those files for relevant copyright info and historical
 * changelogs.
 */
A
Alexey Dobriyan 已提交
8
#include <linux/capability.h>
R
Roman Zippel 已提交
9
#include <linux/clocksource.h>
10
#include <linux/workqueue.h>
11 12 13 14 15 16
#include <linux/hrtimer.h>
#include <linux/jiffies.h>
#include <linux/math64.h>
#include <linux/timex.h>
#include <linux/time.h>
#include <linux/mm.h>
17
#include <linux/module.h>
18

19 20
#include "tick-internal.h"

21
/*
22
 * NTP timekeeping variables:
23 24
 */

25 26 27
DEFINE_SPINLOCK(ntp_lock);


28 29 30 31 32
/* USER_HZ period (usecs): */
unsigned long			tick_usec = TICK_USEC;

/* ACTHZ period (nsecs): */
unsigned long			tick_nsec;
R
Roman Zippel 已提交
33

34
static u64			tick_length;
35 36
static u64			tick_length_base;

37
#define MAX_TICKADJ		500LL		/* usecs */
38
#define MAX_TICKADJ_SCALED \
39
	(((MAX_TICKADJ * NSEC_PER_USEC) << NTP_SCALE_SHIFT) / NTP_INTERVAL_FREQ)
40 41 42 43

/*
 * phase-lock loop variables
 */
44 45 46 47 48 49 50 51 52

/*
 * clock synchronization status
 *
 * (TIME_ERROR prevents overwriting the CMOS clock)
 */
static int			time_state = TIME_OK;

/* clock status bits:							*/
J
John Stultz 已提交
53
static int			time_status = STA_UNSYNC;
54 55 56 57 58 59 60 61 62 63 64

/* TAI offset (secs):							*/
static long			time_tai;

/* time adjustment (nsecs):						*/
static s64			time_offset;

/* pll time constant:							*/
static long			time_constant = 2;

/* maximum error (usecs):						*/
65
static long			time_maxerror = NTP_PHASE_LIMIT;
66 67

/* estimated error (usecs):						*/
68
static long			time_esterror = NTP_PHASE_LIMIT;
69 70 71 72 73 74 75

/* frequency offset (scaled nsecs/secs):				*/
static s64			time_freq;

/* time at last adjustment (secs):					*/
static long			time_reftime;

J
John Stultz 已提交
76
static long			time_adjust;
77

78 79
/* constant (boot-param configurable) NTP tick adjustment (upscaled)	*/
static s64			ntp_tick_adj;
80

81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
#ifdef CONFIG_NTP_PPS

/*
 * The following variables are used when a pulse-per-second (PPS) signal
 * is available. They establish the engineering parameters of the clock
 * discipline loop when controlled by the PPS signal.
 */
#define PPS_VALID	10	/* PPS signal watchdog max (s) */
#define PPS_POPCORN	4	/* popcorn spike threshold (shift) */
#define PPS_INTMIN	2	/* min freq interval (s) (shift) */
#define PPS_INTMAX	8	/* max freq interval (s) (shift) */
#define PPS_INTCOUNT	4	/* number of consecutive good intervals to
				   increase pps_shift or consecutive bad
				   intervals to decrease it */
#define PPS_MAXWANDER	100000	/* max PPS freq wander (ns/s) */

static int pps_valid;		/* signal watchdog counter */
static long pps_tf[3];		/* phase median filter */
static long pps_jitter;		/* current jitter (ns) */
static struct timespec pps_fbase; /* beginning of the last freq interval */
static int pps_shift;		/* current interval duration (s) (shift) */
static int pps_intcnt;		/* interval counter */
static s64 pps_freq;		/* frequency offset (scaled ns/s) */
static long pps_stabil;		/* current stability (scaled ns/s) */

/*
 * PPS signal quality monitors
 */
static long pps_calcnt;		/* calibration intervals */
static long pps_jitcnt;		/* jitter limit exceeded */
static long pps_stbcnt;		/* stability limit exceeded */
static long pps_errcnt;		/* calibration errors */


/* PPS kernel consumer compensates the whole phase error immediately.
 * Otherwise, reduce the offset by a fixed factor times the time constant.
 */
static inline s64 ntp_offset_chunk(s64 offset)
{
	if (time_status & STA_PPSTIME && time_status & STA_PPSSIGNAL)
		return offset;
	else
		return shift_right(offset, SHIFT_PLL + time_constant);
}

static inline void pps_reset_freq_interval(void)
{
	/* the PPS calibration interval may end
	   surprisingly early */
	pps_shift = PPS_INTMIN;
	pps_intcnt = 0;
}

/**
 * pps_clear - Clears the PPS state variables
 *
137
 * Must be called while holding a write on the ntp_lock
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
 */
static inline void pps_clear(void)
{
	pps_reset_freq_interval();
	pps_tf[0] = 0;
	pps_tf[1] = 0;
	pps_tf[2] = 0;
	pps_fbase.tv_sec = pps_fbase.tv_nsec = 0;
	pps_freq = 0;
}

/* Decrease pps_valid to indicate that another second has passed since
 * the last PPS signal. When it reaches 0, indicate that PPS signal is
 * missing.
 *
153
 * Must be called while holding a write on the ntp_lock
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
 */
static inline void pps_dec_valid(void)
{
	if (pps_valid > 0)
		pps_valid--;
	else {
		time_status &= ~(STA_PPSSIGNAL | STA_PPSJITTER |
				 STA_PPSWANDER | STA_PPSERROR);
		pps_clear();
	}
}

static inline void pps_set_freq(s64 freq)
{
	pps_freq = freq;
}

static inline int is_error_status(int status)
{
	return (time_status & (STA_UNSYNC|STA_CLOCKERR))
		/* PPS signal lost when either PPS time or
		 * PPS frequency synchronization requested
		 */
		|| ((time_status & (STA_PPSFREQ|STA_PPSTIME))
			&& !(time_status & STA_PPSSIGNAL))
		/* PPS jitter exceeded when
		 * PPS time synchronization requested */
		|| ((time_status & (STA_PPSTIME|STA_PPSJITTER))
			== (STA_PPSTIME|STA_PPSJITTER))
		/* PPS wander exceeded or calibration error when
		 * PPS frequency synchronization requested
		 */
		|| ((time_status & STA_PPSFREQ)
			&& (time_status & (STA_PPSWANDER|STA_PPSERROR)));
}

static inline void pps_fill_timex(struct timex *txc)
{
	txc->ppsfreq	   = shift_right((pps_freq >> PPM_SCALE_INV_SHIFT) *
					 PPM_SCALE_INV, NTP_SCALE_SHIFT);
	txc->jitter	   = pps_jitter;
	if (!(time_status & STA_NANO))
		txc->jitter /= NSEC_PER_USEC;
	txc->shift	   = pps_shift;
	txc->stabil	   = pps_stabil;
	txc->jitcnt	   = pps_jitcnt;
	txc->calcnt	   = pps_calcnt;
	txc->errcnt	   = pps_errcnt;
	txc->stbcnt	   = pps_stbcnt;
}

#else /* !CONFIG_NTP_PPS */

static inline s64 ntp_offset_chunk(s64 offset)
{
	return shift_right(offset, SHIFT_PLL + time_constant);
}

static inline void pps_reset_freq_interval(void) {}
static inline void pps_clear(void) {}
static inline void pps_dec_valid(void) {}
static inline void pps_set_freq(s64 freq) {}

static inline int is_error_status(int status)
{
	return status & (STA_UNSYNC|STA_CLOCKERR);
}

static inline void pps_fill_timex(struct timex *txc)
{
	/* PPS is not implemented, so these are zero */
	txc->ppsfreq	   = 0;
	txc->jitter	   = 0;
	txc->shift	   = 0;
	txc->stabil	   = 0;
	txc->jitcnt	   = 0;
	txc->calcnt	   = 0;
	txc->errcnt	   = 0;
	txc->stbcnt	   = 0;
}

#endif /* CONFIG_NTP_PPS */

J
John Stultz 已提交
237 238 239 240 241 242 243 244 245 246 247

/**
 * ntp_synced - Returns 1 if the NTP status is not UNSYNC
 *
 */
static inline int ntp_synced(void)
{
	return !(time_status & STA_UNSYNC);
}


248 249 250
/*
 * NTP methods:
 */
251

252 253 254 255
/*
 * Update (tick_length, tick_length_base, tick_nsec), based
 * on (tick_usec, ntp_tick_adj, time_freq):
 */
256 257
static void ntp_update_frequency(void)
{
258
	u64 second_length;
259
	u64 new_base;
260 261 262 263

	second_length		 = (u64)(tick_usec * NSEC_PER_USEC * USER_HZ)
						<< NTP_SCALE_SHIFT;

264
	second_length		+= ntp_tick_adj;
265
	second_length		+= time_freq;
266

267
	tick_nsec		 = div_u64(second_length, HZ) >> NTP_SCALE_SHIFT;
268
	new_base		 = div_u64(second_length, NTP_INTERVAL_FREQ);
269 270 271

	/*
	 * Don't wait for the next second_overflow, apply
272
	 * the change to the tick length immediately:
273
	 */
274 275
	tick_length		+= new_base - tick_length_base;
	tick_length_base	 = new_base;
276 277
}

278
static inline s64 ntp_update_offset_fll(s64 offset64, long secs)
279 280 281 282
{
	time_status &= ~STA_MODE;

	if (secs < MINSEC)
283
		return 0;
284 285

	if (!(time_status & STA_FLL) && (secs <= MAXSEC))
286
		return 0;
287 288 289

	time_status |= STA_MODE;

290
	return div64_long(offset64 << (NTP_SCALE_SHIFT - SHIFT_FLL), secs);
291 292
}

R
Roman Zippel 已提交
293 294 295
static void ntp_update_offset(long offset)
{
	s64 freq_adj;
296 297
	s64 offset64;
	long secs;
R
Roman Zippel 已提交
298 299 300 301

	if (!(time_status & STA_PLL))
		return;

R
Roman Zippel 已提交
302
	if (!(time_status & STA_NANO))
303
		offset *= NSEC_PER_USEC;
R
Roman Zippel 已提交
304 305 306 307 308

	/*
	 * Scale the phase adjustment and
	 * clamp to the operating range.
	 */
309 310
	offset = min(offset, MAXPHASE);
	offset = max(offset, -MAXPHASE);
R
Roman Zippel 已提交
311 312 313 314 315

	/*
	 * Select how the frequency is to be controlled
	 * and in which mode (PLL or FLL).
	 */
316
	secs = get_seconds() - time_reftime;
317
	if (unlikely(time_status & STA_FREQHOLD))
318 319
		secs = 0;

320
	time_reftime = get_seconds();
R
Roman Zippel 已提交
321

322
	offset64    = offset;
323
	freq_adj    = ntp_update_offset_fll(offset64, secs);
324

325 326 327 328 329 330 331 332 333 334
	/*
	 * Clamp update interval to reduce PLL gain with low
	 * sampling rate (e.g. intermittent network connection)
	 * to avoid instability.
	 */
	if (unlikely(secs > 1 << (SHIFT_PLL + 1 + time_constant)))
		secs = 1 << (SHIFT_PLL + 1 + time_constant);

	freq_adj    += (offset64 * secs) <<
			(NTP_SCALE_SHIFT - 2 * (SHIFT_PLL + 2 + time_constant));
335 336 337 338 339 340

	freq_adj    = min(freq_adj + time_freq, MAXFREQ_SCALED);

	time_freq   = max(freq_adj, -MAXFREQ_SCALED);

	time_offset = div_s64(offset64 << NTP_SCALE_SHIFT, NTP_INTERVAL_FREQ);
R
Roman Zippel 已提交
341 342
}

343 344 345 346 347
/**
 * ntp_clear - Clears the NTP state variables
 */
void ntp_clear(void)
{
348 349 350 351
	unsigned long flags;

	spin_lock_irqsave(&ntp_lock, flags);

352 353 354 355
	time_adjust	= 0;		/* stop active adjtime() */
	time_status	|= STA_UNSYNC;
	time_maxerror	= NTP_PHASE_LIMIT;
	time_esterror	= NTP_PHASE_LIMIT;
356 357 358

	ntp_update_frequency();

359 360
	tick_length	= tick_length_base;
	time_offset	= 0;
361 362 363

	/* Clear PPS state variables */
	pps_clear();
364 365
	spin_unlock_irqrestore(&ntp_lock, flags);

366 367
}

368 369 370

u64 ntp_tick_length(void)
{
371 372 373 374 375 376 377
	unsigned long flags;
	s64 ret;

	spin_lock_irqsave(&ntp_lock, flags);
	ret = tick_length;
	spin_unlock_irqrestore(&ntp_lock, flags);
	return ret;
378 379 380
}


381
/*
382 383 384 385 386 387 388 389
 * this routine handles the overflow of the microsecond field
 *
 * The tricky bits of code to handle the accurate clock support
 * were provided by Dave Mills (Mills@UDEL.EDU) of NTP fame.
 * They were originally developed for SUN and DEC kernels.
 * All the kudos should go to Dave for this stuff.
 *
 * Also handles leap second processing, and returns leap offset
390
 */
391
int second_overflow(unsigned long secs)
392
{
393
	s64 delta;
394
	int leap = 0;
395
	unsigned long flags;
396

397
	spin_lock_irqsave(&ntp_lock, flags);
398 399 400 401 402 403

	/*
	 * Leap second processing. If in leap-insert state at the end of the
	 * day, the system clock is set back one second; if in leap-delete
	 * state, the system clock is set ahead one second.
	 */
404 405
	switch (time_state) {
	case TIME_OK:
406 407 408 409
		if (time_status & STA_INS)
			time_state = TIME_INS;
		else if (time_status & STA_DEL)
			time_state = TIME_DEL;
410 411
		break;
	case TIME_INS:
412 413 414 415 416 417
		if (secs % 86400 == 0) {
			leap = -1;
			time_state = TIME_OOP;
			printk(KERN_NOTICE
				"Clock: inserting leap second 23:59:60 UTC\n");
		}
418 419
		break;
	case TIME_DEL:
420 421 422 423 424 425 426
		if ((secs + 1) % 86400 == 0) {
			leap = 1;
			time_tai--;
			time_state = TIME_WAIT;
			printk(KERN_NOTICE
				"Clock: deleting leap second 23:59:59 UTC\n");
		}
427 428
		break;
	case TIME_OOP:
R
Roman Zippel 已提交
429
		time_tai++;
430
		time_state = TIME_WAIT;
431 432
		break;

433 434
	case TIME_WAIT:
		if (!(time_status & (STA_INS | STA_DEL)))
R
Roman Zippel 已提交
435
			time_state = TIME_OK;
R
Roman Zippel 已提交
436 437
		break;
	}
438

R
Roman Zippel 已提交
439 440 441 442 443 444

	/* Bump the maxerror field */
	time_maxerror += MAXFREQ / NSEC_PER_USEC;
	if (time_maxerror > NTP_PHASE_LIMIT) {
		time_maxerror = NTP_PHASE_LIMIT;
		time_status |= STA_UNSYNC;
445 446
	}

447
	/* Compute the phase adjustment for the next second */
448 449
	tick_length	 = tick_length_base;

450
	delta		 = ntp_offset_chunk(time_offset);
451 452
	time_offset	-= delta;
	tick_length	+= delta;
453

454 455 456
	/* Check PPS signal */
	pps_dec_valid();

457
	if (!time_adjust)
458
		goto out;
459 460 461 462

	if (time_adjust > MAX_TICKADJ) {
		time_adjust -= MAX_TICKADJ;
		tick_length += MAX_TICKADJ_SCALED;
463
		goto out;
464
	}
465 466 467 468

	if (time_adjust < -MAX_TICKADJ) {
		time_adjust += MAX_TICKADJ;
		tick_length -= MAX_TICKADJ_SCALED;
469
		goto out;
470 471 472 473 474
	}

	tick_length += (s64)(time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)
							 << NTP_SCALE_SHIFT;
	time_adjust = 0;
475 476 477



478 479
out:
	spin_unlock_irqrestore(&ntp_lock, flags);
480 481

	return leap;
482 483
}

484
#ifdef CONFIG_GENERIC_CMOS_UPDATE
485

486
static void sync_cmos_clock(struct work_struct *work);
487

488
static DECLARE_DELAYED_WORK(sync_cmos_work, sync_cmos_clock);
489

490
static void sync_cmos_clock(struct work_struct *work)
491 492 493 494 495 496 497 498 499 500 501
{
	struct timespec now, next;
	int fail = 1;

	/*
	 * If we have an externally synchronized Linux clock, then update
	 * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
	 * called as close as possible to 500 ms before the new second starts.
	 * This code is run on a timer.  If the clock is set, that timer
	 * may not expire at the correct time.  Thus, we adjust...
	 */
502
	if (!ntp_synced()) {
503 504 505 506 507
		/*
		 * Not synced, exit, do not restart a timer (if one is
		 * running, let it run out).
		 */
		return;
508
	}
509 510

	getnstimeofday(&now);
511
	if (abs(now.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2)
512 513
		fail = update_persistent_clock(now);

514
	next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec - (TICK_NSEC / 2);
515 516 517 518 519 520 521 522 523 524 525 526
	if (next.tv_nsec <= 0)
		next.tv_nsec += NSEC_PER_SEC;

	if (!fail)
		next.tv_sec = 659;
	else
		next.tv_sec = 0;

	if (next.tv_nsec >= NSEC_PER_SEC) {
		next.tv_sec++;
		next.tv_nsec -= NSEC_PER_SEC;
	}
527
	schedule_delayed_work(&sync_cmos_work, timespec_to_jiffies(&next));
528 529 530
}

static void notify_cmos_timer(void)
531
{
532
	schedule_delayed_work(&sync_cmos_work, 0);
533 534
}

535 536 537 538
#else
static inline void notify_cmos_timer(void) { }
#endif

I
Ingo Molnar 已提交
539 540 541 542 543 544 545 546 547

/*
 * Propagate a new txc->status value into the NTP state:
 */
static inline void process_adj_status(struct timex *txc, struct timespec *ts)
{
	if ((time_status & STA_PLL) && !(txc->status & STA_PLL)) {
		time_state = TIME_OK;
		time_status = STA_UNSYNC;
548 549
		/* restart PPS frequency calibration */
		pps_reset_freq_interval();
I
Ingo Molnar 已提交
550 551 552 553 554 555 556
	}

	/*
	 * If we turn on PLL adjustments then reset the
	 * reference time to current time.
	 */
	if (!(time_status & STA_PLL) && (txc->status & STA_PLL))
557
		time_reftime = get_seconds();
I
Ingo Molnar 已提交
558

559 560
	/* only set allowed bits */
	time_status &= STA_RONLY;
I
Ingo Molnar 已提交
561 562 563 564 565 566 567 568 569 570 571 572 573 574
	time_status |= txc->status & ~STA_RONLY;

}
/*
 * Called with the xtime lock held, so we can access and modify
 * all the global NTP state:
 */
static inline void process_adjtimex_modes(struct timex *txc, struct timespec *ts)
{
	if (txc->modes & ADJ_STATUS)
		process_adj_status(txc, ts);

	if (txc->modes & ADJ_NANO)
		time_status |= STA_NANO;
575

I
Ingo Molnar 已提交
576 577 578 579
	if (txc->modes & ADJ_MICRO)
		time_status &= ~STA_NANO;

	if (txc->modes & ADJ_FREQUENCY) {
580
		time_freq = txc->freq * PPM_SCALE;
I
Ingo Molnar 已提交
581 582
		time_freq = min(time_freq, MAXFREQ_SCALED);
		time_freq = max(time_freq, -MAXFREQ_SCALED);
583 584
		/* update pps_freq */
		pps_set_freq(time_freq);
I
Ingo Molnar 已提交
585 586 587 588
	}

	if (txc->modes & ADJ_MAXERROR)
		time_maxerror = txc->maxerror;
589

I
Ingo Molnar 已提交
590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605
	if (txc->modes & ADJ_ESTERROR)
		time_esterror = txc->esterror;

	if (txc->modes & ADJ_TIMECONST) {
		time_constant = txc->constant;
		if (!(time_status & STA_NANO))
			time_constant += 4;
		time_constant = min(time_constant, (long)MAXTC);
		time_constant = max(time_constant, 0l);
	}

	if (txc->modes & ADJ_TAI && txc->constant > 0)
		time_tai = txc->constant;

	if (txc->modes & ADJ_OFFSET)
		ntp_update_offset(txc->offset);
606

I
Ingo Molnar 已提交
607 608 609 610 611 612 613
	if (txc->modes & ADJ_TICK)
		tick_usec = txc->tick;

	if (txc->modes & (ADJ_TICK|ADJ_FREQUENCY|ADJ_OFFSET))
		ntp_update_frequency();
}

614 615
/*
 * adjtimex mainly allows reading (and writing, if superuser) of
616 617 618 619
 * kernel time-keeping variables. used by xntpd.
 */
int do_adjtimex(struct timex *txc)
{
R
Roman Zippel 已提交
620
	struct timespec ts;
621 622
	int result;

623 624
	/* Validate the data before disabling interrupts */
	if (txc->modes & ADJ_ADJTIME) {
R
Roman Zippel 已提交
625
		/* singleshot must not be used with any other mode bits */
626
		if (!(txc->modes & ADJ_OFFSET_SINGLESHOT))
627
			return -EINVAL;
628 629 630 631 632 633 634 635
		if (!(txc->modes & ADJ_OFFSET_READONLY) &&
		    !capable(CAP_SYS_TIME))
			return -EPERM;
	} else {
		/* In order to modify anything, you gotta be super-user! */
		 if (txc->modes && !capable(CAP_SYS_TIME))
			return -EPERM;

636 637 638 639
		/*
		 * if the quartz is off by more than 10% then
		 * something is VERY wrong!
		 */
640 641 642
		if (txc->modes & ADJ_TICK &&
		    (txc->tick <  900000/USER_HZ ||
		     txc->tick > 1100000/USER_HZ))
643
			return -EINVAL;
J
John Stultz 已提交
644
	}
645

646 647 648 649
	if (txc->modes & ADJ_SETOFFSET) {
		struct timespec delta;
		delta.tv_sec  = txc->time.tv_sec;
		delta.tv_nsec = txc->time.tv_usec;
650 651
		if (!capable(CAP_SYS_TIME))
			return -EPERM;
652 653
		if (!(txc->modes & ADJ_NANO))
			delta.tv_nsec *= 1000;
654 655 656
		result = timekeeping_inject_offset(&delta);
		if (result)
			return result;
657 658
	}

R
Roman Zippel 已提交
659 660
	getnstimeofday(&ts);

661
	spin_lock_irq(&ntp_lock);
662

663 664 665 666 667 668 669 670 671
	if (txc->modes & ADJ_ADJTIME) {
		long save_adjust = time_adjust;

		if (!(txc->modes & ADJ_OFFSET_READONLY)) {
			/* adjtime() is independent from ntp_adjtime() */
			time_adjust = txc->offset;
			ntp_update_frequency();
		}
		txc->offset = save_adjust;
672
	} else {
R
Roman Zippel 已提交
673

674 675 676
		/* If there are input parameters, then process them: */
		if (txc->modes)
			process_adjtimex_modes(txc, &ts);
R
Roman Zippel 已提交
677

678
		txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
679
				  NTP_SCALE_SHIFT);
680 681 682
		if (!(time_status & STA_NANO))
			txc->offset /= NSEC_PER_USEC;
	}
683

R
Roman Zippel 已提交
684
	result = time_state;	/* mostly `TIME_OK' */
685 686
	/* check for errors */
	if (is_error_status(time_status))
687 688
		result = TIME_ERROR;

689
	txc->freq	   = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) *
690
					 PPM_SCALE_INV, NTP_SCALE_SHIFT);
691 692 693 694
	txc->maxerror	   = time_maxerror;
	txc->esterror	   = time_esterror;
	txc->status	   = time_status;
	txc->constant	   = time_constant;
695
	txc->precision	   = 1;
696
	txc->tolerance	   = MAXFREQ_SCALED / PPM_SCALE;
697
	txc->tick	   = tick_usec;
R
Roman Zippel 已提交
698
	txc->tai	   = time_tai;
699

700 701
	/* fill PPS status fields */
	pps_fill_timex(txc);
702

703
	spin_unlock_irq(&ntp_lock);
R
Roman Zippel 已提交
704

R
Roman Zippel 已提交
705 706 707 708
	txc->time.tv_sec = ts.tv_sec;
	txc->time.tv_usec = ts.tv_nsec;
	if (!(time_status & STA_NANO))
		txc->time.tv_usec /= NSEC_PER_USEC;
R
Roman Zippel 已提交
709

710
	notify_cmos_timer();
R
Roman Zippel 已提交
711 712

	return result;
713
}
714

715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900
#ifdef	CONFIG_NTP_PPS

/* actually struct pps_normtime is good old struct timespec, but it is
 * semantically different (and it is the reason why it was invented):
 * pps_normtime.nsec has a range of ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ]
 * while timespec.tv_nsec has a range of [0, NSEC_PER_SEC) */
struct pps_normtime {
	__kernel_time_t	sec;	/* seconds */
	long		nsec;	/* nanoseconds */
};

/* normalize the timestamp so that nsec is in the
   ( -NSEC_PER_SEC / 2, NSEC_PER_SEC / 2 ] interval */
static inline struct pps_normtime pps_normalize_ts(struct timespec ts)
{
	struct pps_normtime norm = {
		.sec = ts.tv_sec,
		.nsec = ts.tv_nsec
	};

	if (norm.nsec > (NSEC_PER_SEC >> 1)) {
		norm.nsec -= NSEC_PER_SEC;
		norm.sec++;
	}

	return norm;
}

/* get current phase correction and jitter */
static inline long pps_phase_filter_get(long *jitter)
{
	*jitter = pps_tf[0] - pps_tf[1];
	if (*jitter < 0)
		*jitter = -*jitter;

	/* TODO: test various filters */
	return pps_tf[0];
}

/* add the sample to the phase filter */
static inline void pps_phase_filter_add(long err)
{
	pps_tf[2] = pps_tf[1];
	pps_tf[1] = pps_tf[0];
	pps_tf[0] = err;
}

/* decrease frequency calibration interval length.
 * It is halved after four consecutive unstable intervals.
 */
static inline void pps_dec_freq_interval(void)
{
	if (--pps_intcnt <= -PPS_INTCOUNT) {
		pps_intcnt = -PPS_INTCOUNT;
		if (pps_shift > PPS_INTMIN) {
			pps_shift--;
			pps_intcnt = 0;
		}
	}
}

/* increase frequency calibration interval length.
 * It is doubled after four consecutive stable intervals.
 */
static inline void pps_inc_freq_interval(void)
{
	if (++pps_intcnt >= PPS_INTCOUNT) {
		pps_intcnt = PPS_INTCOUNT;
		if (pps_shift < PPS_INTMAX) {
			pps_shift++;
			pps_intcnt = 0;
		}
	}
}

/* update clock frequency based on MONOTONIC_RAW clock PPS signal
 * timestamps
 *
 * At the end of the calibration interval the difference between the
 * first and last MONOTONIC_RAW clock timestamps divided by the length
 * of the interval becomes the frequency update. If the interval was
 * too long, the data are discarded.
 * Returns the difference between old and new frequency values.
 */
static long hardpps_update_freq(struct pps_normtime freq_norm)
{
	long delta, delta_mod;
	s64 ftemp;

	/* check if the frequency interval was too long */
	if (freq_norm.sec > (2 << pps_shift)) {
		time_status |= STA_PPSERROR;
		pps_errcnt++;
		pps_dec_freq_interval();
		pr_err("hardpps: PPSERROR: interval too long - %ld s\n",
				freq_norm.sec);
		return 0;
	}

	/* here the raw frequency offset and wander (stability) is
	 * calculated. If the wander is less than the wander threshold
	 * the interval is increased; otherwise it is decreased.
	 */
	ftemp = div_s64(((s64)(-freq_norm.nsec)) << NTP_SCALE_SHIFT,
			freq_norm.sec);
	delta = shift_right(ftemp - pps_freq, NTP_SCALE_SHIFT);
	pps_freq = ftemp;
	if (delta > PPS_MAXWANDER || delta < -PPS_MAXWANDER) {
		pr_warning("hardpps: PPSWANDER: change=%ld\n", delta);
		time_status |= STA_PPSWANDER;
		pps_stbcnt++;
		pps_dec_freq_interval();
	} else {	/* good sample */
		pps_inc_freq_interval();
	}

	/* the stability metric is calculated as the average of recent
	 * frequency changes, but is used only for performance
	 * monitoring
	 */
	delta_mod = delta;
	if (delta_mod < 0)
		delta_mod = -delta_mod;
	pps_stabil += (div_s64(((s64)delta_mod) <<
				(NTP_SCALE_SHIFT - SHIFT_USEC),
				NSEC_PER_USEC) - pps_stabil) >> PPS_INTMIN;

	/* if enabled, the system clock frequency is updated */
	if ((time_status & STA_PPSFREQ) != 0 &&
	    (time_status & STA_FREQHOLD) == 0) {
		time_freq = pps_freq;
		ntp_update_frequency();
	}

	return delta;
}

/* correct REALTIME clock phase error against PPS signal */
static void hardpps_update_phase(long error)
{
	long correction = -error;
	long jitter;

	/* add the sample to the median filter */
	pps_phase_filter_add(correction);
	correction = pps_phase_filter_get(&jitter);

	/* Nominal jitter is due to PPS signal noise. If it exceeds the
	 * threshold, the sample is discarded; otherwise, if so enabled,
	 * the time offset is updated.
	 */
	if (jitter > (pps_jitter << PPS_POPCORN)) {
		pr_warning("hardpps: PPSJITTER: jitter=%ld, limit=%ld\n",
		       jitter, (pps_jitter << PPS_POPCORN));
		time_status |= STA_PPSJITTER;
		pps_jitcnt++;
	} else if (time_status & STA_PPSTIME) {
		/* correct the time using the phase offset */
		time_offset = div_s64(((s64)correction) << NTP_SCALE_SHIFT,
				NTP_INTERVAL_FREQ);
		/* cancel running adjtime() */
		time_adjust = 0;
	}
	/* update jitter */
	pps_jitter += (jitter - pps_jitter) >> PPS_INTMIN;
}

/*
 * hardpps() - discipline CPU clock oscillator to external PPS signal
 *
 * This routine is called at each PPS signal arrival in order to
 * discipline the CPU clock oscillator to the PPS signal. It takes two
 * parameters: REALTIME and MONOTONIC_RAW clock timestamps. The former
 * is used to correct clock phase error and the latter is used to
 * correct the frequency.
 *
 * This code is based on David Mills's reference nanokernel
 * implementation. It was mostly rewritten but keeps the same idea.
 */
void hardpps(const struct timespec *phase_ts, const struct timespec *raw_ts)
{
	struct pps_normtime pts_norm, freq_norm;
	unsigned long flags;

	pts_norm = pps_normalize_ts(*phase_ts);

901
	spin_lock_irqsave(&ntp_lock, flags);
902 903 904 905 906 907 908 909 910 911 912 913

	/* clear the error bits, they will be set again if needed */
	time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR);

	/* indicate signal presence */
	time_status |= STA_PPSSIGNAL;
	pps_valid = PPS_VALID;

	/* when called for the first time,
	 * just start the frequency interval */
	if (unlikely(pps_fbase.tv_sec == 0)) {
		pps_fbase = *raw_ts;
914
		spin_unlock_irqrestore(&ntp_lock, flags);
915 916 917 918 919 920 921 922 923 924 925 926 927 928
		return;
	}

	/* ok, now we have a base for frequency calculation */
	freq_norm = pps_normalize_ts(timespec_sub(*raw_ts, pps_fbase));

	/* check that the signal is in the range
	 * [1s - MAXFREQ us, 1s + MAXFREQ us], otherwise reject it */
	if ((freq_norm.sec == 0) ||
			(freq_norm.nsec > MAXFREQ * freq_norm.sec) ||
			(freq_norm.nsec < -MAXFREQ * freq_norm.sec)) {
		time_status |= STA_PPSJITTER;
		/* restart the frequency calibration interval */
		pps_fbase = *raw_ts;
929
		spin_unlock_irqrestore(&ntp_lock, flags);
930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945
		pr_err("hardpps: PPSJITTER: bad pulse\n");
		return;
	}

	/* signal is ok */

	/* check if the current frequency interval is finished */
	if (freq_norm.sec >= (1 << pps_shift)) {
		pps_calcnt++;
		/* restart the frequency calibration interval */
		pps_fbase = *raw_ts;
		hardpps_update_freq(freq_norm);
	}

	hardpps_update_phase(pts_norm.nsec);

946
	spin_unlock_irqrestore(&ntp_lock, flags);
947 948 949 950 951
}
EXPORT_SYMBOL(hardpps);

#endif	/* CONFIG_NTP_PPS */

952 953 954
static int __init ntp_tick_adj_setup(char *str)
{
	ntp_tick_adj = simple_strtol(str, NULL, 0);
955 956
	ntp_tick_adj <<= NTP_SCALE_SHIFT;

957 958 959 960
	return 1;
}

__setup("ntp_tick_adj=", ntp_tick_adj_setup);
R
Roman Zippel 已提交
961 962 963 964 965

void __init ntp_init(void)
{
	ntp_clear();
}