powerpc: Keep xtime and gettimeofday in sync

};

extern int do_adjtimex(struct timex *);

extern void ppc_adjtimex(void);

asmlinkage long compat_sys_adjtimex(struct timex32 __user *utp)

{

	ret = do_adjtimex(&txc);

	/* adjust the conversion of TB to time of day to track adjtimex */

	ppc_adjtimex();

	if(put_user(txc.modes, &utp->modes) ||

	   __put_user(txc.offset, &utp->offset) ||

	   __put_user(txc.freq, &utp->freq) ||

#include <linux/security.h>

#include <linux/percpu.h>

#include <linux/rtc.h>

#include <linux/jiffies.h>

#include <asm/io.h>

#include <asm/processor.h>

unsigned long tb_ticks_per_sec;

u64 tb_to_xs;

unsigned tb_to_us;

unsigned long processor_freq;

#define TICKLEN_SCALE	(SHIFT_SCALE - 10)

u64 last_tick_len;	/* units are ns / 2^TICKLEN_SCALE */

u64 ticklen_to_xs;	/* 0.64 fraction */

/* If last_tick_len corresponds to about 1/HZ seconds, then

   last_tick_len << TICKLEN_SHIFT will be about 2^63. */

#define TICKLEN_SHIFT	(63 - 30 - TICKLEN_SCALE + SHIFT_HZ)

DEFINE_SPINLOCK(rtc_lock);

EXPORT_SYMBOL_GPL(rtc_lock);

extern struct timezone sys_tz;

static long timezone_offset;

void ppc_adjtimex(void);

static unsigned adjusting_time = 0;

unsigned long ppc_proc_freq;

unsigned long ppc_tb_freq;

         */

        if (ppc_md.set_rtc_time && ntp_synced() &&

	    xtime.tv_sec - last_rtc_update >= 659 &&

	    abs((xtime.tv_nsec/1000) - (1000000-1000000/HZ)) < 500000/HZ &&

	    jiffies - wall_jiffies == 1) {

	    abs((xtime.tv_nsec/1000) - (1000000-1000000/HZ)) < 500000/HZ) {

		struct rtc_time tm;

		to_tm(xtime.tv_sec + 1 + timezone_offset, &tm);

		tm.tm_year -= 1900;

	if (__USE_RTC()) {

		/* do this the old way */

		unsigned long flags, seq;

		unsigned int sec, nsec, usec, lost;

		unsigned int sec, nsec, usec;

		do {

			seq = read_seqbegin_irqsave(&xtime_lock, flags);

			sec = xtime.tv_sec;

			nsec = xtime.tv_nsec + tb_ticks_since(tb_last_stamp);

			lost = jiffies - wall_jiffies;

		} while (read_seqretry_irqrestore(&xtime_lock, seq, flags));

		usec = nsec / 1000 + lost * (1000000 / HZ);

		usec = nsec / 1000;

		while (usec >= 1000000) {

			usec -= 1000000;

			++sec;

EXPORT_SYMBOL(do_gettimeofday);

/* Synchronize xtime with do_gettimeofday */ 

static inline void timer_sync_xtime(unsigned long cur_tb)

{

#ifdef CONFIG_PPC64

	/* why do we do this? */

	struct timeval my_tv;

	__do_gettimeofday(&my_tv, cur_tb);

	if (xtime.tv_sec <= my_tv.tv_sec) {

		xtime.tv_sec = my_tv.tv_sec;

		xtime.tv_nsec = my_tv.tv_usec * 1000;

	}

#endif

}

/*

 * There are two copies of tb_to_xs and stamp_xsec so that no

 * lock is needed to access and use these values in

{

	unsigned long offset;

	u64 new_stamp_xsec;

	u64 tlen, t2x;

	if (__USE_RTC())

		return;

	tlen = current_tick_length();

	offset = cur_tb - do_gtod.varp->tb_orig_stamp;

	if ((offset & 0x80000000u) == 0)

	if (tlen == last_tick_len && offset < 0x80000000u) {

		/* check that we're still in sync; if not, resync */

		struct timeval tv;

		__do_gettimeofday(&tv, cur_tb);

		if (tv.tv_sec <= xtime.tv_sec &&

		    (tv.tv_sec < xtime.tv_sec ||

		     tv.tv_usec * 1000 <= xtime.tv_nsec))

			return;

	new_stamp_xsec = do_gtod.varp->stamp_xsec

		+ mulhdu(offset, do_gtod.varp->tb_to_xs);

	update_gtod(cur_tb, new_stamp_xsec, do_gtod.varp->tb_to_xs);

	}

	if (tlen != last_tick_len) {

		t2x = mulhdu(tlen << TICKLEN_SHIFT, ticklen_to_xs);

		last_tick_len = tlen;

	} else

		t2x = do_gtod.varp->tb_to_xs;

	new_stamp_xsec = (u64) xtime.tv_nsec * XSEC_PER_SEC;

	do_div(new_stamp_xsec, 1000000000);

	new_stamp_xsec += (u64) xtime.tv_sec * XSEC_PER_SEC;

	update_gtod(cur_tb, new_stamp_xsec, t2x);

}

#ifdef CONFIG_SMP

		write_seqlock(&xtime_lock);

		tb_last_jiffy += tb_ticks_per_jiffy;

		tb_last_stamp = per_cpu(last_jiffy, cpu);

		timer_recalc_offset(tb_last_jiffy);

		do_timer(regs);

		timer_sync_xtime(tb_last_jiffy);

		timer_recalc_offset(tb_last_jiffy);

		timer_check_rtc();

		write_sequnlock(&xtime_lock);

		if (adjusting_time && (time_adjust == 0))

			ppc_adjtimex();

	}

	next_dec = tb_ticks_per_jiffy - ticks;

void wakeup_decrementer(void)

{

	int i;

	unsigned long ticks;

	set_dec(tb_ticks_per_jiffy);

	/*

	 * We don't expect this to be called on a machine with a 601,

	 * so using get_tbl is fine.

	 * The timebase gets saved on sleep and restored on wakeup,

	 * so all we need to do is to reset the decrementer.

	 */

	tb_last_stamp = tb_last_jiffy = get_tb();

	for_each_cpu(i)

		per_cpu(last_jiffy, i) = tb_last_stamp;

	ticks = tb_ticks_since(__get_cpu_var(last_jiffy));

	if (ticks < tb_ticks_per_jiffy)

		ticks = tb_ticks_per_jiffy - ticks;

	else

		ticks = 1;

	set_dec(ticks);

}

#ifdef CONFIG_SMP

	time_t wtm_sec, new_sec = tv->tv_sec;

	long wtm_nsec, new_nsec = tv->tv_nsec;

	unsigned long flags;

	long int tb_delta;

	u64 new_xsec, tb_delta_xs;

	u64 new_xsec;

	unsigned long tb_delta;

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

		return -EINVAL;

		first_settimeofday = 0;

	}

#endif

	/*

	 * Subtract off the number of nanoseconds since the

	 * beginning of the last tick.

	 * Note that since we don't increment jiffies_64 anywhere other

	 * than in do_timer (since we don't have a lost tick problem),

	 * wall_jiffies will always be the same as jiffies,

	 * and therefore the (jiffies - wall_jiffies) computation

	 * has been removed.

	 */

	tb_delta = tb_ticks_since(tb_last_stamp);

	tb_delta += (jiffies - wall_jiffies) * tb_ticks_per_jiffy;

	tb_delta_xs = mulhdu(tb_delta, do_gtod.varp->tb_to_xs);

	tb_delta = mulhdu(tb_delta, do_gtod.varp->tb_to_xs); /* in xsec */

	new_nsec -= SCALE_XSEC(tb_delta, 1000000000);

	wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - new_sec);

	wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - new_nsec);

	ntp_clear();

	new_xsec = 0;

	if (new_nsec != 0) {

		new_xsec = (u64)new_nsec * XSEC_PER_SEC;

	new_xsec = xtime.tv_nsec;

	if (new_xsec != 0) {

		new_xsec *= XSEC_PER_SEC;

		do_div(new_xsec, NSEC_PER_SEC);

	}

	new_xsec += (u64)new_sec * XSEC_PER_SEC - tb_delta_xs;

	new_xsec += (u64)xtime.tv_sec * XSEC_PER_SEC;

	update_gtod(tb_last_jiffy, new_xsec, do_gtod.varp->tb_to_xs);

	vdso_data->tz_minuteswest = sys_tz.tz_minuteswest;

	unsigned long flags;

	unsigned long tm = 0;

	struct div_result res;

	u64 scale;

	u64 scale, x;

	unsigned shift;

        if (ppc_md.time_init != NULL)

	}

	tb_ticks_per_jiffy = ppc_tb_freq / HZ;

	tb_ticks_per_sec = tb_ticks_per_jiffy * HZ;

	tb_ticks_per_sec = ppc_tb_freq;

	tb_ticks_per_usec = ppc_tb_freq / 1000000;

	tb_to_us = mulhwu_scale_factor(ppc_tb_freq, 1000000);

	div128_by_32(1024*1024, 0, tb_ticks_per_sec, &res);

	tb_to_xs = res.result_low;

	/*

	 * Calculate the length of each tick in ns.  It will not be

	 * exactly 1e9/HZ unless ppc_tb_freq is divisible by HZ.

	 * We compute 1e9 * tb_ticks_per_jiffy / ppc_tb_freq,

	 * rounded up.

	 */

	x = (u64) NSEC_PER_SEC * tb_ticks_per_jiffy + ppc_tb_freq - 1;

	do_div(x, ppc_tb_freq);

	tick_nsec = x;

	last_tick_len = x << TICKLEN_SCALE;

	/*

	 * Compute ticklen_to_xs, which is a factor which gets multiplied

	 * by (last_tick_len << TICKLEN_SHIFT) to get a tb_to_xs value.

	 * It is computed as:

	 * ticklen_to_xs = 2^N / (tb_ticks_per_jiffy * 1e9)

	 * where N = 64 + 20 - TICKLEN_SCALE - TICKLEN_SHIFT

	 * so as to give the result as a 0.64 fixed-point fraction.

	 */

	div128_by_32(1ULL << (64 + 20 - TICKLEN_SCALE - TICKLEN_SHIFT), 0,

		     tb_ticks_per_jiffy, &res);

	div128_by_32(res.result_high, res.result_low, NSEC_PER_SEC, &res);

	ticklen_to_xs = res.result_low;

	/* Compute tb_to_xs from tick_nsec */

	tb_to_xs = mulhdu(last_tick_len << TICKLEN_SHIFT, ticklen_to_xs);

	/*

	 * Compute scale factor for sched_clock.

		tm = get_boot_time();

	write_seqlock_irqsave(&xtime_lock, flags);

	/* If platform provided a timezone (pmac), we correct the time */

        if (timezone_offset) {

		sys_tz.tz_minuteswest = -timezone_offset / 60;

		sys_tz.tz_dsttime = 0;

		tm -= timezone_offset;

        }

	xtime.tv_sec = tm;

	xtime.tv_nsec = 0;

	do_gtod.varp = &do_gtod.vars[0];

	vdso_data->tb_orig_stamp = tb_last_jiffy;

	vdso_data->tb_update_count = 0;

	vdso_data->tb_ticks_per_sec = tb_ticks_per_sec;

	vdso_data->stamp_xsec = xtime.tv_sec * XSEC_PER_SEC;

	vdso_data->stamp_xsec = (u64) xtime.tv_sec * XSEC_PER_SEC;

	vdso_data->tb_to_xs = tb_to_xs;

	time_freq = 0;

	/* If platform provided a timezone (pmac), we correct the time */

        if (timezone_offset) {

		sys_tz.tz_minuteswest = -timezone_offset / 60;

		sys_tz.tz_dsttime = 0;

		xtime.tv_sec -= timezone_offset;

        }

	last_rtc_update = xtime.tv_sec;

	set_normalized_timespec(&wall_to_monotonic,

	                        -xtime.tv_sec, -xtime.tv_nsec);

	set_dec(tb_ticks_per_jiffy);

}

/* 

 * After adjtimex is called, adjust the conversion of tb ticks

 * to microseconds to keep do_gettimeofday synchronized 

 * with ntpd.

 *

 * Use the time_adjust, time_freq and time_offset computed by adjtimex to 

 * adjust the frequency.

 */

/* #define DEBUG_PPC_ADJTIMEX 1 */

void ppc_adjtimex(void)

{

#ifdef CONFIG_PPC64

	unsigned long den, new_tb_ticks_per_sec, tb_ticks, old_xsec,

		new_tb_to_xs, new_xsec, new_stamp_xsec;

	unsigned long tb_ticks_per_sec_delta;

	long delta_freq, ltemp;

	struct div_result divres; 

	unsigned long flags;

	long singleshot_ppm = 0;

	/*

	 * Compute parts per million frequency adjustment to

	 * accomplish the time adjustment implied by time_offset to be

	 * applied over the elapsed time indicated by time_constant.

	 * Use SHIFT_USEC to get it into the same units as

	 * time_freq.

	 */

	if ( time_offset < 0 ) {

		ltemp = -time_offset;

		ltemp <<= SHIFT_USEC - SHIFT_UPDATE;

		ltemp >>= SHIFT_KG + time_constant;

		ltemp = -ltemp;

	} else {

		ltemp = time_offset;

		ltemp <<= SHIFT_USEC - SHIFT_UPDATE;

		ltemp >>= SHIFT_KG + time_constant;

	}

	/* If there is a single shot time adjustment in progress */

	if ( time_adjust ) {

#ifdef DEBUG_PPC_ADJTIMEX

		printk("ppc_adjtimex: ");

		if ( adjusting_time == 0 )

			printk("starting ");

		printk("single shot time_adjust = %ld\n", time_adjust);

#endif	

		adjusting_time = 1;

		/*

		 * Compute parts per million frequency adjustment

		 * to match time_adjust

		 */

		singleshot_ppm = tickadj * HZ;	

		/*

		 * The adjustment should be tickadj*HZ to match the code in

		 * linux/kernel/timer.c, but experiments show that this is too

		 * large. 3/4 of tickadj*HZ seems about right

		 */

		singleshot_ppm -= singleshot_ppm / 4;

		/* Use SHIFT_USEC to get it into the same units as time_freq */

		singleshot_ppm <<= SHIFT_USEC;

		if ( time_adjust < 0 )

			singleshot_ppm = -singleshot_ppm;

	}

	else {

#ifdef DEBUG_PPC_ADJTIMEX

		if ( adjusting_time )

			printk("ppc_adjtimex: ending single shot time_adjust\n");

#endif

		adjusting_time = 0;

	}

	/* Add up all of the frequency adjustments */

	delta_freq = time_freq + ltemp + singleshot_ppm;

	/*

	 * Compute a new value for tb_ticks_per_sec based on

	 * the frequency adjustment

	 */

	den = 1000000 * (1 << (SHIFT_USEC - 8));

	if ( delta_freq < 0 ) {

		tb_ticks_per_sec_delta = ( tb_ticks_per_sec * ( (-delta_freq) >> (SHIFT_USEC - 8))) / den;

		new_tb_ticks_per_sec = tb_ticks_per_sec + tb_ticks_per_sec_delta;

	}

	else {

		tb_ticks_per_sec_delta = ( tb_ticks_per_sec * ( delta_freq >> (SHIFT_USEC - 8))) / den;

		new_tb_ticks_per_sec = tb_ticks_per_sec - tb_ticks_per_sec_delta;

	}

#ifdef DEBUG_PPC_ADJTIMEX

	printk("ppc_adjtimex: ltemp = %ld, time_freq = %ld, singleshot_ppm = %ld\n", ltemp, time_freq, singleshot_ppm);

	printk("ppc_adjtimex: tb_ticks_per_sec - base = %ld  new = %ld\n", tb_ticks_per_sec, new_tb_ticks_per_sec);

#endif

	/*

	 * Compute a new value of tb_to_xs (used to convert tb to

	 * microseconds) and a new value of stamp_xsec which is the

	 * time (in 1/2^20 second units) corresponding to

	 * tb_orig_stamp.  This new value of stamp_xsec compensates

	 * for the change in frequency (implied by the new tb_to_xs)

	 * which guarantees that the current time remains the same.

	 */

	write_seqlock_irqsave( &xtime_lock, flags );

	tb_ticks = get_tb() - do_gtod.varp->tb_orig_stamp;

	div128_by_32(1024*1024, 0, new_tb_ticks_per_sec, &divres);

	new_tb_to_xs = divres.result_low;

	new_xsec = mulhdu(tb_ticks, new_tb_to_xs);

	old_xsec = mulhdu(tb_ticks, do_gtod.varp->tb_to_xs);

	new_stamp_xsec = do_gtod.varp->stamp_xsec + old_xsec - new_xsec;

	update_gtod(do_gtod.varp->tb_orig_stamp, new_stamp_xsec, new_tb_to_xs);

	write_sequnlock_irqrestore( &xtime_lock, flags );

#endif /* CONFIG_PPC64 */

}

#define FEBRUARY	2

#define	STARTOFTIME	1970