Merge branch 'fortglx/3.4/time' of git://git.linaro.org/people/jstultz/linux into timers/core

extern unsigned long tick_usec;		/* USER_HZ period (usec) */

extern unsigned long tick_nsec;		/* ACTHZ          period (nsec) */

/*

 * phase-lock loop variables

 */

extern int time_status;		/* clock synchronization status bits */

extern void ntp_init(void);

extern void ntp_clear(void);

/**

 * ntp_synced - Returns 1 if the NTP status is not UNSYNC

 *

 */

static inline int ntp_synced(void)

{

	return !(time_status & STA_UNSYNC);

}

/* Required to safely shift negative values */

#define shift_right(x, s) ({	\

	__typeof__(x) __x = (x);	\

#define NTP_INTERVAL_LENGTH (NSEC_PER_SEC/NTP_INTERVAL_FREQ)

/* Returns how long ticks are at present, in ns / 2^NTP_SCALE_SHIFT. */

extern u64 tick_length;

extern u64 ntp_tick_length(void);

extern void second_overflow(void);

extern void update_ntp_one_tick(void);

extern int do_adjtimex(struct timex *);

extern void hardpps(const struct timespec *, const struct timespec *);

 * NTP timekeeping variables:

 */

DEFINE_SPINLOCK(ntp_lock);

/* USER_HZ period (usecs): */

unsigned long			tick_usec = TICK_USEC;

/* ACTHZ period (nsecs): */

unsigned long			tick_nsec;

u64				tick_length;

static u64			tick_length;

static u64			tick_length_base;

static struct hrtimer		leap_timer;

static int			time_state = TIME_OK;

/* clock status bits:							*/

int				time_status = STA_UNSYNC;

static int			time_status = STA_UNSYNC;

/* TAI offset (secs):							*/

static long			time_tai;

/**

 * pps_clear - Clears the PPS state variables

 *

 * Must be called while holding a write on the xtime_lock

 * Must be called while holding a write on the ntp_lock

 */

static inline void pps_clear(void)

{

 * the last PPS signal. When it reaches 0, indicate that PPS signal is

 * missing.

 *

 * Must be called while holding a write on the xtime_lock

 * Must be called while holding a write on the ntp_lock

 */

static inline void pps_dec_valid(void)

{

#endif /* CONFIG_NTP_PPS */

/**

 * ntp_synced - Returns 1 if the NTP status is not UNSYNC

 *

 */

static inline int ntp_synced(void)

{

	return !(time_status & STA_UNSYNC);

}

/*

 * NTP methods:

 */

/**

 * ntp_clear - Clears the NTP state variables

 *

 * Must be called while holding a write on the xtime_lock

 */

void ntp_clear(void)

{

	unsigned long flags;

	spin_lock_irqsave(&ntp_lock, flags);

	time_adjust	= 0;		/* stop active adjtime() */

	time_status	|= STA_UNSYNC;

	time_maxerror	= NTP_PHASE_LIMIT;

	/* Clear PPS state variables */

	pps_clear();

	spin_unlock_irqrestore(&ntp_lock, flags);

}

u64 ntp_tick_length(void)

{

	unsigned long flags;

	s64 ret;

	spin_lock_irqsave(&ntp_lock, flags);

	ret = tick_length;

	spin_unlock_irqrestore(&ntp_lock, flags);

	return ret;

}

/*

 * 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

static enum hrtimer_restart ntp_leap_second(struct hrtimer *timer)

{

	enum hrtimer_restart res = HRTIMER_NORESTART;

	unsigned long flags;

	int leap = 0;

	write_seqlock(&xtime_lock);

	spin_lock_irqsave(&ntp_lock, flags);

	switch (time_state) {

	case TIME_OK:

		break;

	case TIME_INS:

		timekeeping_leap_insert(-1);

		leap = -1;

		time_state = TIME_OOP;

		printk(KERN_NOTICE

			"Clock: inserting leap second 23:59:60 UTC\n");

		res = HRTIMER_RESTART;

		break;

	case TIME_DEL:

		timekeeping_leap_insert(1);

		leap = 1;

		time_tai--;

		time_state = TIME_WAIT;

		printk(KERN_NOTICE

			time_state = TIME_OK;

		break;

	}

	spin_unlock_irqrestore(&ntp_lock, flags);

	write_sequnlock(&xtime_lock);

	/*

	 * We have to call this outside of the ntp_lock to keep

	 * the proper locking hierarchy

	 */

	if (leap)

		timekeeping_leap_insert(leap);

	return res;

}

void second_overflow(void)

{

	s64 delta;

	unsigned long flags;

	spin_lock_irqsave(&ntp_lock, flags);

	/* Bump the maxerror field */

	time_maxerror += MAXFREQ / NSEC_PER_USEC;

	pps_dec_valid();

	if (!time_adjust)

		return;

		goto out;

	if (time_adjust > MAX_TICKADJ) {

		time_adjust -= MAX_TICKADJ;

		tick_length += MAX_TICKADJ_SCALED;

		return;

		goto out;

	}

	if (time_adjust < -MAX_TICKADJ) {

		time_adjust += MAX_TICKADJ;

		tick_length -= MAX_TICKADJ_SCALED;

		return;

		goto out;

	}

	tick_length += (s64)(time_adjust * NSEC_PER_USEC / NTP_INTERVAL_FREQ)

							 << NTP_SCALE_SHIFT;

	time_adjust = 0;

out:

	spin_unlock_irqrestore(&ntp_lock, flags);

}

#ifdef CONFIG_GENERIC_CMOS_UPDATE

	getnstimeofday(&ts);

	write_seqlock_irq(&xtime_lock);

	spin_lock_irq(&ntp_lock);

	if (txc->modes & ADJ_ADJTIME) {

		long save_adjust = time_adjust;

	/* fill PPS status fields */

	pps_fill_timex(txc);

	write_sequnlock_irq(&xtime_lock);

	spin_unlock_irq(&ntp_lock);

	txc->time.tv_sec = ts.tv_sec;

	txc->time.tv_usec = ts.tv_nsec;

	pts_norm = pps_normalize_ts(*phase_ts);

	write_seqlock_irqsave(&xtime_lock, flags);

	spin_lock_irqsave(&ntp_lock, flags);

	/* clear the error bits, they will be set again if needed */

	time_status &= ~(STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR);

	 * just start the frequency interval */

	if (unlikely(pps_fbase.tv_sec == 0)) {

		pps_fbase = *raw_ts;

		write_sequnlock_irqrestore(&xtime_lock, flags);

		spin_unlock_irqrestore(&ntp_lock, flags);

		return;

	}

		time_status |= STA_PPSJITTER;

		/* restart the frequency calibration interval */

		pps_fbase = *raw_ts;

		write_sequnlock_irqrestore(&xtime_lock, flags);

		spin_unlock_irqrestore(&ntp_lock, flags);

		pr_err("hardpps: PPSJITTER: bad pulse\n");

		return;

	}

	hardpps_update_phase(pts_norm.nsec);

	write_sequnlock_irqrestore(&xtime_lock, flags);

	spin_unlock_irqrestore(&ntp_lock, flags);

}

EXPORT_SYMBOL(hardpps);

struct timekeeper {

	/* Current clocksource used for timekeeping. */

	struct clocksource *clock;

	/* NTP adjusted clock multiplier */

	u32	mult;

	/* The shift value of the current clocksource. */

	int	shift;

	/* Shift conversion between clock shifted nano seconds and

	 * ntp shifted nano seconds. */

	int	ntp_error_shift;

	/* NTP adjusted clock multiplier */

	u32	mult;

	/* The current time */

	struct timespec xtime;

	/*

	 * wall_to_monotonic is what we need to add to xtime (or xtime corrected

	 * for sub jiffie times) to get to monotonic time.  Monotonic is pegged

	 * at zero at system boot time, so wall_to_monotonic will be negative,

	 * however, we will ALWAYS keep the tv_nsec part positive so we can use

	 * the usual normalization.

	 *

	 * wall_to_monotonic is moved after resume from suspend for the

	 * monotonic time not to jump. We need to add total_sleep_time to

	 * wall_to_monotonic to get the real boot based time offset.

	 *

	 * - wall_to_monotonic is no longer the boot time, getboottime must be

	 * used instead.

	 */

	struct timespec wall_to_monotonic;

	/* time spent in suspend */

	struct timespec total_sleep_time;

	/* The raw monotonic time for the CLOCK_MONOTONIC_RAW posix clock. */

	struct timespec raw_time;

	/* Seqlock for all timekeeper values */

	seqlock_t lock;

};

static struct timekeeper timekeeper;

/*

 * This read-write spinlock protects us from races in SMP while

 * playing with xtime.

 */

__cacheline_aligned_in_smp DEFINE_SEQLOCK(xtime_lock);

/* flag for if timekeeping is suspended */

int __read_mostly timekeeping_suspended;

/**

 * timekeeper_setup_internals - Set up internals to use clocksource clock.

 *

	return clocksource_cyc2ns(cycle_delta, clock->mult, clock->shift);

}

/*

 * This read-write spinlock protects us from races in SMP while

 * playing with xtime.

 */

__cacheline_aligned_in_smp DEFINE_SEQLOCK(xtime_lock);

/*

 * The current time

 * wall_to_monotonic is what we need to add to xtime (or xtime corrected

 * for sub jiffie times) to get to monotonic time.  Monotonic is pegged

 * at zero at system boot time, so wall_to_monotonic will be negative,

 * however, we will ALWAYS keep the tv_nsec part positive so we can use

 * the usual normalization.

 *

 * wall_to_monotonic is moved after resume from suspend for the monotonic

 * time not to jump. We need to add total_sleep_time to wall_to_monotonic

 * to get the real boot based time offset.

 *

 * - wall_to_monotonic is no longer the boot time, getboottime must be

 * used instead.

 */

static struct timespec xtime __attribute__ ((aligned (16)));

static struct timespec wall_to_monotonic __attribute__ ((aligned (16)));

static struct timespec total_sleep_time;

/*

 * The raw monotonic time for the CLOCK_MONOTONIC_RAW posix clock.

 */

static struct timespec raw_time;

/* must hold write on timekeeper.lock */

static void timekeeping_update(bool clearntp)

{

	if (clearntp) {

		timekeeper.ntp_error = 0;

		ntp_clear();

	}

	update_vsyscall(&timekeeper.xtime, &timekeeper.wall_to_monotonic,

			 timekeeper.clock, timekeeper.mult);

}

/* flag for if timekeeping is suspended */

int __read_mostly timekeeping_suspended;

/* must hold xtime_lock */

void timekeeping_leap_insert(int leapsecond)

{

	xtime.tv_sec += leapsecond;

	wall_to_monotonic.tv_sec -= leapsecond;

	update_vsyscall(&xtime, &wall_to_monotonic, timekeeper.clock,

			timekeeper.mult);

	unsigned long flags;

	write_seqlock_irqsave(&timekeeper.lock, flags);

	timekeeper.xtime.tv_sec += leapsecond;

	timekeeper.wall_to_monotonic.tv_sec -= leapsecond;

	timekeeping_update(false);

	write_sequnlock_irqrestore(&timekeeper.lock, flags);

}

/**

	/* If arch requires, add in gettimeoffset() */

	nsec += arch_gettimeoffset();

	timespec_add_ns(&xtime, nsec);

	timespec_add_ns(&timekeeper.xtime, nsec);

	nsec = clocksource_cyc2ns(cycle_delta, clock->mult, clock->shift);

	timespec_add_ns(&raw_time, nsec);

	timespec_add_ns(&timekeeper.raw_time, nsec);

}

/**

	WARN_ON(timekeeping_suspended);

	do {

		seq = read_seqbegin(&xtime_lock);

		seq = read_seqbegin(&timekeeper.lock);

		*ts = xtime;

		*ts = timekeeper.xtime;

		nsecs = timekeeping_get_ns();

		/* If arch requires, add in gettimeoffset() */

		nsecs += arch_gettimeoffset();

	} while (read_seqretry(&xtime_lock, seq));

	} while (read_seqretry(&timekeeper.lock, seq));

	timespec_add_ns(ts, nsecs);

}

	WARN_ON(timekeeping_suspended);

	do {

		seq = read_seqbegin(&xtime_lock);

		secs = xtime.tv_sec + wall_to_monotonic.tv_sec;

		nsecs = xtime.tv_nsec + wall_to_monotonic.tv_nsec;

		seq = read_seqbegin(&timekeeper.lock);

		secs = timekeeper.xtime.tv_sec +

				timekeeper.wall_to_monotonic.tv_sec;

		nsecs = timekeeper.xtime.tv_nsec +

				timekeeper.wall_to_monotonic.tv_nsec;

		nsecs += timekeeping_get_ns();

		/* If arch requires, add in gettimeoffset() */

		nsecs += arch_gettimeoffset();

	} while (read_seqretry(&xtime_lock, seq));

	} while (read_seqretry(&timekeeper.lock, seq));

	/*

	 * Use ktime_set/ktime_add_ns to create a proper ktime on

	 * 32-bit architectures without CONFIG_KTIME_SCALAR.

	WARN_ON(timekeeping_suspended);

	do {

		seq = read_seqbegin(&xtime_lock);

		*ts = xtime;

		tomono = wall_to_monotonic;

		seq = read_seqbegin(&timekeeper.lock);

		*ts = timekeeper.xtime;

		tomono = timekeeper.wall_to_monotonic;

		nsecs = timekeeping_get_ns();

		/* If arch requires, add in gettimeoffset() */

		nsecs += arch_gettimeoffset();

	} while (read_seqretry(&xtime_lock, seq));

	} while (read_seqretry(&timekeeper.lock, seq));

	set_normalized_timespec(ts, ts->tv_sec + tomono.tv_sec,

				ts->tv_nsec + tomono.tv_nsec + nsecs);

	do {

		u32 arch_offset;

		seq = read_seqbegin(&xtime_lock);

		seq = read_seqbegin(&timekeeper.lock);

		*ts_raw = raw_time;

		*ts_real = xtime;

		*ts_raw = timekeeper.raw_time;

		*ts_real = timekeeper.xtime;

		nsecs_raw = timekeeping_get_ns_raw();

		nsecs_real = timekeeping_get_ns();

		nsecs_raw += arch_offset;

		nsecs_real += arch_offset;

	} while (read_seqretry(&xtime_lock, seq));

	} while (read_seqretry(&timekeeper.lock, seq));

	timespec_add_ns(ts_raw, nsecs_raw);

	timespec_add_ns(ts_real, nsecs_real);

	if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)

		return -EINVAL;

	write_seqlock_irqsave(&xtime_lock, flags);

	write_seqlock_irqsave(&timekeeper.lock, flags);

	timekeeping_forward_now();

	ts_delta.tv_sec = tv->tv_sec - xtime.tv_sec;

	ts_delta.tv_nsec = tv->tv_nsec - xtime.tv_nsec;

	wall_to_monotonic = timespec_sub(wall_to_monotonic, ts_delta);

	xtime = *tv;

	ts_delta.tv_sec = tv->tv_sec - timekeeper.xtime.tv_sec;

	ts_delta.tv_nsec = tv->tv_nsec - timekeeper.xtime.tv_nsec;

	timekeeper.wall_to_monotonic =

			timespec_sub(timekeeper.wall_to_monotonic, ts_delta);

	timekeeper.ntp_error = 0;

	ntp_clear();

	timekeeper.xtime = *tv;

	timekeeping_update(true);

	update_vsyscall(&xtime, &wall_to_monotonic, timekeeper.clock,

				timekeeper.mult);

	write_sequnlock_irqrestore(&xtime_lock, flags);

	write_sequnlock_irqrestore(&timekeeper.lock, flags);

	/* signal hrtimers about time change */

	clock_was_set();

	if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)

		return -EINVAL;

	write_seqlock_irqsave(&xtime_lock, flags);

	write_seqlock_irqsave(&timekeeper.lock, flags);

	timekeeping_forward_now();

	xtime = timespec_add(xtime, *ts);

	wall_to_monotonic = timespec_sub(wall_to_monotonic, *ts);

	timekeeper.xtime = timespec_add(timekeeper.xtime, *ts);

	timekeeper.wall_to_monotonic =

				timespec_sub(timekeeper.wall_to_monotonic, *ts);

	timekeeper.ntp_error = 0;

	ntp_clear();

	timekeeping_update(true);

	update_vsyscall(&xtime, &wall_to_monotonic, timekeeper.clock,

				timekeeper.mult);

	write_sequnlock_irqrestore(&xtime_lock, flags);

	write_sequnlock_irqrestore(&timekeeper.lock, flags);

	/* signal hrtimers about time change */

	clock_was_set();

	s64 nsecs;

	do {

		seq = read_seqbegin(&xtime_lock);

		seq = read_seqbegin(&timekeeper.lock);

		nsecs = timekeeping_get_ns_raw();

		*ts = raw_time;

		*ts = timekeeper.raw_time;

	} while (read_seqretry(&xtime_lock, seq));

	} while (read_seqretry(&timekeeper.lock, seq));

	timespec_add_ns(ts, nsecs);

}

	int ret;

	do {

		seq = read_seqbegin(&xtime_lock);

		seq = read_seqbegin(&timekeeper.lock);

		ret = timekeeper.clock->flags & CLOCK_SOURCE_VALID_FOR_HRES;

	} while (read_seqretry(&xtime_lock, seq));

	} while (read_seqretry(&timekeeper.lock, seq));

	return ret;

}

/**

 * timekeeping_max_deferment - Returns max time the clocksource can be deferred

 *

 * Caller must observe xtime_lock via read_seqbegin/read_seqretry to

 * ensure that the clocksource does not change!

 */

u64 timekeeping_max_deferment(void)

{

	return timekeeper.clock->max_idle_ns;

	unsigned long seq;

	u64 ret;

	do {

		seq = read_seqbegin(&timekeeper.lock);

		ret = timekeeper.clock->max_idle_ns;

	} while (read_seqretry(&timekeeper.lock, seq));

	return ret;

}

/**

	read_persistent_clock(&now);

	read_boot_clock(&boot);

	write_seqlock_irqsave(&xtime_lock, flags);

	seqlock_init(&timekeeper.lock);

	ntp_init();

	write_seqlock_irqsave(&timekeeper.lock, flags);

	clock = clocksource_default_clock();

	if (clock->enable)

		clock->enable(clock);

	timekeeper_setup_internals(clock);

	xtime.tv_sec = now.tv_sec;

	xtime.tv_nsec = now.tv_nsec;

	raw_time.tv_sec = 0;

	raw_time.tv_nsec = 0;

	timekeeper.xtime.tv_sec = now.tv_sec;

	timekeeper.xtime.tv_nsec = now.tv_nsec;

	timekeeper.raw_time.tv_sec = 0;

	timekeeper.raw_time.tv_nsec = 0;

	if (boot.tv_sec == 0 && boot.tv_nsec == 0) {

		boot.tv_sec = xtime.tv_sec;

		boot.tv_nsec = xtime.tv_nsec;

		boot.tv_sec = timekeeper.xtime.tv_sec;

		boot.tv_nsec = timekeeper.xtime.tv_nsec;

	}

	set_normalized_timespec(&wall_to_monotonic,

	set_normalized_timespec(&timekeeper.wall_to_monotonic,

				-boot.tv_sec, -boot.tv_nsec);

	total_sleep_time.tv_sec = 0;

	total_sleep_time.tv_nsec = 0;

	write_sequnlock_irqrestore(&xtime_lock, flags);

	timekeeper.total_sleep_time.tv_sec = 0;

	timekeeper.total_sleep_time.tv_nsec = 0;

	write_sequnlock_irqrestore(&timekeeper.lock, flags);

}

/* time in seconds when suspend began */

		return;

	}

	xtime = timespec_add(xtime, *delta);

	wall_to_monotonic = timespec_sub(wall_to_monotonic, *delta);

	total_sleep_time = timespec_add(total_sleep_time, *delta);

	timekeeper.xtime = timespec_add(timekeeper.xtime, *delta);

	timekeeper.wall_to_monotonic =

			timespec_sub(timekeeper.wall_to_monotonic, *delta);

	timekeeper.total_sleep_time = timespec_add(

					timekeeper.total_sleep_time, *delta);

}

	if (!(ts.tv_sec == 0 && ts.tv_nsec == 0))

		return;

	write_seqlock_irqsave(&xtime_lock, flags);

	write_seqlock_irqsave(&timekeeper.lock, flags);

	timekeeping_forward_now();

	__timekeeping_inject_sleeptime(delta);

	timekeeper.ntp_error = 0;

	ntp_clear();

	update_vsyscall(&xtime, &wall_to_monotonic, timekeeper.clock,

				timekeeper.mult);

	timekeeping_update(true);

	write_sequnlock_irqrestore(&xtime_lock, flags);