[mirror_ubuntu-zesty-kernel.git] / arch / m32r / kernel / time.c

/*
 *  linux/arch/m32r/kernel/time.c
 *
 *  Copyright (c) 2001, 2002  Hiroyuki Kondo, Hirokazu Takata,
 *                            Hitoshi Yamamoto
 *  Taken from i386 version.
 *    Copyright (C) 1991, 1992, 1995  Linus Torvalds
 *    Copyright (C) 1996, 1997, 1998  Ralf Baechle
 *
 *  This file contains the time handling details for PC-style clocks as
 *  found in some MIPS systems.
 *
 *  Some code taken from sh version.
 *    Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
 *    Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
 */

#undef  DEBUG_TIMER

#include <linux/config.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/param.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/profile.h>

#include <asm/io.h>
#include <asm/m32r.h>

#include <asm/hw_irq.h>

#ifdef CONFIG_SMP
extern void send_IPI_allbutself(int, int);
extern void smp_local_timer_interrupt(struct pt_regs *);
#endif

u64 jiffies_64 = INITIAL_JIFFIES;

EXPORT_SYMBOL(jiffies_64);

extern unsigned long wall_jiffies;
#define TICK_SIZE	(tick_nsec / 1000)

/*
 * Change this if you have some constant time drift
 */

/* This is for machines which generate the exact clock. */
#define USECS_PER_JIFFY (1000000/HZ)

static unsigned long latch;

static unsigned long do_gettimeoffset(void)
{
	unsigned long  elapsed_time = 0;  /* [us] */

#if defined(CONFIG_CHIP_M32102) || defined(CONFIG_CHIP_XNUX2) \
	|| defined(CONFIG_CHIP_VDEC2) || defined(CONFIG_CHIP_M32700) \
	|| defined(CONFIG_CHIP_OPSP)
#ifndef CONFIG_SMP

	unsigned long count;

	/* timer count may underflow right here */
	count = inl(M32R_MFT2CUT_PORTL);

	if (inl(M32R_ICU_CR18_PORTL) & 0x00000100)	/* underflow check */
		count = 0;

	count = (latch - count) * TICK_SIZE;
	elapsed_time = (count + latch / 2) / latch;
	/* NOTE: LATCH is equal to the "interval" value (= reload count). */

#else /* CONFIG_SMP */
	unsigned long count;
	static unsigned long p_jiffies = -1;
	static unsigned long p_count = 0;

	/* timer count may underflow right here */
	count = inl(M32R_MFT2CUT_PORTL);

	if (jiffies == p_jiffies && count > p_count)
		count = 0;

	p_jiffies = jiffies;
	p_count = count;

	count = (latch - count) * TICK_SIZE;
	elapsed_time = (count + latch / 2) / latch;
	/* NOTE: LATCH is equal to the "interval" value (= reload count). */
#endif /* CONFIG_SMP */
#elif defined(CONFIG_CHIP_M32310)
#warning do_gettimeoffse not implemented
#else
#error no chip configuration
#endif

	return elapsed_time;
}

/*
 * This version of gettimeofday has near microsecond resolution.
 */
void do_gettimeofday(struct timeval *tv)
{
	unsigned long seq;
	unsigned long usec, sec;
	unsigned long max_ntp_tick = tick_usec - tickadj;

	do {
		unsigned long lost;

		seq = read_seqbegin(&xtime_lock);

		usec = do_gettimeoffset();
		lost = jiffies - wall_jiffies;

		/*
		 * If time_adjust is negative then NTP is slowing the clock
		 * so make sure not to go into next possible interval.
		 * Better to lose some accuracy than have time go backwards..
		 */
		if (unlikely(time_adjust < 0)) {
			usec = min(usec, max_ntp_tick);
			if (lost)
				usec += lost * max_ntp_tick;
		} else if (unlikely(lost))
			usec += lost * tick_usec;

		sec = xtime.tv_sec;
		usec += (xtime.tv_nsec / 1000);
	} while (read_seqretry(&xtime_lock, seq));

	while (usec >= 1000000) {
		usec -= 1000000;
		sec++;
	}

	tv->tv_sec = sec;
	tv->tv_usec = usec;
}

EXPORT_SYMBOL(do_gettimeofday);

int do_settimeofday(struct timespec *tv)
{
	time_t wtm_sec, sec = tv->tv_sec;
 	long wtm_nsec, nsec = tv->tv_nsec;

	if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
		return -EINVAL;

	write_seqlock_irq(&xtime_lock);
	/*
	 * This is revolting. We need to set "xtime" correctly. However, the
	 * value in this location is the value at the most recent update of
	 * wall time.  Discover what correction gettimeofday() would have
	 * made, and then undo it!
	 */
	nsec -= do_gettimeoffset() * NSEC_PER_USEC;
	nsec -= (jiffies - wall_jiffies) * TICK_NSEC;

	wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
	wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);

	set_normalized_timespec(&xtime, sec, nsec);
	set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);

	ntp_clear();
	write_sequnlock_irq(&xtime_lock);
	clock_was_set();

	return 0;
}

EXPORT_SYMBOL(do_settimeofday);

/*
 * In order to set the CMOS clock precisely, set_rtc_mmss has to be
 * called 500 ms after the second nowtime has started, because when
 * nowtime is written into the registers of the CMOS clock, it will
 * jump to the next second precisely 500 ms later. Check the Motorola
 * MC146818A or Dallas DS12887 data sheet for details.
 *
 * BUG: This routine does not handle hour overflow properly; it just
 *      sets the minutes. Usually you won't notice until after reboot!
 */
static inline int set_rtc_mmss(unsigned long nowtime)
{
	return 0;
}

/* last time the cmos clock got updated */
static long last_rtc_update = 0;

/*
 * timer_interrupt() needs to keep up the real-time clock,
 * as well as call the "do_timer()" routine every clocktick
 */
irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
#ifndef CONFIG_SMP
	profile_tick(CPU_PROFILING, regs);
#endif
	do_timer(regs);

#ifndef CONFIG_SMP
	update_process_times(user_mode(regs));
#endif
	/*
	 * 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.
	 */
	write_seqlock(&xtime_lock);
	if (ntp_synced()
		&& xtime.tv_sec > last_rtc_update + 660
		&& (xtime.tv_nsec / 1000) >= 500000 - ((unsigned)TICK_SIZE) / 2
		&& (xtime.tv_nsec / 1000) <= 500000 + ((unsigned)TICK_SIZE) / 2)
	{
		if (set_rtc_mmss(xtime.tv_sec) == 0)
			last_rtc_update = xtime.tv_sec;
		else	/* do it again in 60 s */
			last_rtc_update = xtime.tv_sec - 600;
	}
	write_sequnlock(&xtime_lock);
	/* As we return to user mode fire off the other CPU schedulers..
	   this is basically because we don't yet share IRQ's around.
	   This message is rigged to be safe on the 386 - basically it's
	   a hack, so don't look closely for now.. */

#ifdef CONFIG_SMP
	smp_local_timer_interrupt(regs);
	smp_send_timer();
#endif

	return IRQ_HANDLED;
}

struct irqaction irq0 = { timer_interrupt, SA_INTERRUPT, CPU_MASK_NONE,
			  "MFT2", NULL, NULL };

void __init time_init(void)
{
	unsigned int epoch, year, mon, day, hour, min, sec;

	sec = min = hour = day = mon = year = 0;
	epoch = 0;

	year = 23;
	mon = 4;
	day = 17;

	/* Attempt to guess the epoch.  This is the same heuristic as in rtc.c
	   so no stupid things will happen to timekeeping.  Who knows, maybe
	   Ultrix also uses 1952 as epoch ...  */
	if (year > 10 && year < 44)
		epoch = 1980;
	else if (year < 96)
		epoch = 1952;
	year += epoch;

	xtime.tv_sec = mktime(year, mon, day, hour, min, sec);
	xtime.tv_nsec = (INITIAL_JIFFIES % HZ) * (NSEC_PER_SEC / HZ);
	set_normalized_timespec(&wall_to_monotonic,
		-xtime.tv_sec, -xtime.tv_nsec);

#if defined(CONFIG_CHIP_M32102) || defined(CONFIG_CHIP_XNUX2) \
	|| defined(CONFIG_CHIP_VDEC2) || defined(CONFIG_CHIP_M32700) \
	|| defined(CONFIG_CHIP_OPSP)

	/* M32102 MFT setup */
	setup_irq(M32R_IRQ_MFT2, &irq0);
	{
		unsigned long bus_clock;
		unsigned short divide;

		bus_clock = boot_cpu_data.bus_clock;
		divide = boot_cpu_data.timer_divide;
		latch = (bus_clock/divide + HZ / 2) / HZ;

		printk("Timer start : latch = %ld\n", latch);

		outl((M32R_MFTMOD_CC_MASK | M32R_MFTMOD_TCCR \
			|M32R_MFTMOD_CSSEL011), M32R_MFT2MOD_PORTL);
		outl(latch, M32R_MFT2RLD_PORTL);
		outl(latch, M32R_MFT2CUT_PORTL);
		outl(0, M32R_MFT2CMPRLD_PORTL);
		outl((M32R_MFTCR_MFT2MSK|M32R_MFTCR_MFT2EN), M32R_MFTCR_PORTL);
	}

#elif defined(CONFIG_CHIP_M32310)
#warning time_init not implemented
#else
#error no chip configuration
#endif
}

/*
 *  Scheduler clock - returns current time in nanosec units.
 */
unsigned long long sched_clock(void)
{
	return (unsigned long long)jiffies * (1000000000 / HZ);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/m32r/kernel/time.c
	3	*
	4	* Copyright (c) 2001, 2002 Hiroyuki Kondo, Hirokazu Takata,
	5	* Hitoshi Yamamoto
	6	* Taken from i386 version.
	7	* Copyright (C) 1991, 1992, 1995 Linus Torvalds
	8	* Copyright (C) 1996, 1997, 1998 Ralf Baechle
	9	*
	10	* This file contains the time handling details for PC-style clocks as
	11	* found in some MIPS systems.
	12	*
	13	* Some code taken from sh version.
	14	* Copyright (C) 1999 Tetsuya Okada & Niibe Yutaka
	15	* Copyright (C) 2000 Philipp Rumpf <prumpf@tux.org>
	16	*/
	17
	18	#undef DEBUG_TIMER
	19
	20	#include <linux/config.h>
	21	#include <linux/errno.h>
	22	#include <linux/init.h>
	23	#include <linux/module.h>
	24	#include <linux/sched.h>
	25	#include <linux/kernel.h>
	26	#include <linux/param.h>
	27	#include <linux/string.h>
	28	#include <linux/mm.h>
	29	#include <linux/interrupt.h>
	30	#include <linux/profile.h>
	31
	32	#include <asm/io.h>
	33	#include <asm/m32r.h>
	34
	35	#include <asm/hw_irq.h>
	36
	37	#ifdef CONFIG_SMP
	38	extern void send_IPI_allbutself(int, int);
	39	extern void smp_local_timer_interrupt(struct pt_regs *);
	40	#endif
	41
	42	u64 jiffies_64 = INITIAL_JIFFIES;
	43
	44	EXPORT_SYMBOL(jiffies_64);
	45
	46	extern unsigned long wall_jiffies;
	47	#define TICK_SIZE (tick_nsec / 1000)
	48
	49	/*
	50	* Change this if you have some constant time drift
	51	*/
	52
	53	/* This is for machines which generate the exact clock. */
	54	#define USECS_PER_JIFFY (1000000/HZ)
	55
	56	static unsigned long latch;
	57
	58	static unsigned long do_gettimeoffset(void)
	59	{
	60	unsigned long elapsed_time = 0; /* [us] */
	61
	62	#if defined(CONFIG_CHIP_M32102) \|\| defined(CONFIG_CHIP_XNUX2) \
	63	\|\| defined(CONFIG_CHIP_VDEC2) \|\| defined(CONFIG_CHIP_M32700) \
	64	\|\| defined(CONFIG_CHIP_OPSP)
65	#ifndef CONFIG_SMP
66
67	unsigned long count;
68
69	/* timer count may underflow right here */
70	count = inl(M32R_MFT2CUT_PORTL);
71
72	if (inl(M32R_ICU_CR18_PORTL) & 0x00000100) /* underflow check */
73	count = 0;
74
75	count = (latch - count) * TICK_SIZE;
76	elapsed_time = (count + latch / 2) / latch;
77	/* NOTE: LATCH is equal to the "interval" value (= reload count). */
78
79	#else /* CONFIG_SMP */
80	unsigned long count;
81	static unsigned long p_jiffies = -1;
82	static unsigned long p_count = 0;
83
84	/* timer count may underflow right here */
85	count = inl(M32R_MFT2CUT_PORTL);
86
87	if (jiffies == p_jiffies && count > p_count)
88	count = 0;
89
90	p_jiffies = jiffies;
91	p_count = count;
92
93	count = (latch - count) * TICK_SIZE;
94	elapsed_time = (count + latch / 2) / latch;
95	/* NOTE: LATCH is equal to the "interval" value (= reload count). */
96	#endif /* CONFIG_SMP */
97	#elif defined(CONFIG_CHIP_M32310)
98	#warning do_gettimeoffse not implemented
99	#else
100	#error no chip configuration
101	#endif
102
103	return elapsed_time;
104	}
105
106	/*
107	* This version of gettimeofday has near microsecond resolution.
108	*/
109	void do_gettimeofday(struct timeval *tv)
110	{
111	unsigned long seq;
112	unsigned long usec, sec;
113	unsigned long max_ntp_tick = tick_usec - tickadj;
114
115	do {
116	unsigned long lost;
117
118	seq = read_seqbegin(&xtime_lock);
119
120	usec = do_gettimeoffset();
121	lost = jiffies - wall_jiffies;
122
123	/*
124	* If time_adjust is negative then NTP is slowing the clock
125	* so make sure not to go into next possible interval.
126	* Better to lose some accuracy than have time go backwards..
127	*/
128	if (unlikely(time_adjust < 0)) {
129	usec = min(usec, max_ntp_tick);
130	if (lost)
131	usec += lost * max_ntp_tick;
132	} else if (unlikely(lost))
133	usec += lost * tick_usec;
134
135	sec = xtime.tv_sec;
136	usec += (xtime.tv_nsec / 1000);
137	} while (read_seqretry(&xtime_lock, seq));
138
139	while (usec >= 1000000) {
140	usec -= 1000000;
141	sec++;
142	}
143
144	tv->tv_sec = sec;
145	tv->tv_usec = usec;
146	}
147
148	EXPORT_SYMBOL(do_gettimeofday);
149
150	int do_settimeofday(struct timespec *tv)
151	{
152	time_t wtm_sec, sec = tv->tv_sec;
153	long wtm_nsec, nsec = tv->tv_nsec;
154
155	if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
156	return -EINVAL;
157
158	write_seqlock_irq(&xtime_lock);
159	/*
160	* This is revolting. We need to set "xtime" correctly. However, the
161	* value in this location is the value at the most recent update of
162	* wall time. Discover what correction gettimeofday() would have
163	* made, and then undo it!
164	*/
165	nsec -= do_gettimeoffset() * NSEC_PER_USEC;
166	nsec -= (jiffies - wall_jiffies) * TICK_NSEC;
167
168	wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
169	wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
170
171	set_normalized_timespec(&xtime, sec, nsec);
172	set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
173
b149ee22	174	ntp_clear();
1da177e4 LT	175	write_sequnlock_irq(&xtime_lock);
	176	clock_was_set();
	177
	178	return 0;
	179	}
	180
	181	EXPORT_SYMBOL(do_settimeofday);
	182
	183	/*
	184	* In order to set the CMOS clock precisely, set_rtc_mmss has to be
	185	* called 500 ms after the second nowtime has started, because when
	186	* nowtime is written into the registers of the CMOS clock, it will
	187	* jump to the next second precisely 500 ms later. Check the Motorola
	188	* MC146818A or Dallas DS12887 data sheet for details.
	189	*
	190	* BUG: This routine does not handle hour overflow properly; it just
	191	* sets the minutes. Usually you won't notice until after reboot!
	192	*/
	193	static inline int set_rtc_mmss(unsigned long nowtime)
	194	{
	195	return 0;
	196	}
	197
	198	/* last time the cmos clock got updated */
	199	static long last_rtc_update = 0;
	200
	201	/*
	202	* timer_interrupt() needs to keep up the real-time clock,
	203	* as well as call the "do_timer()" routine every clocktick
	204	*/
2757a71c	205	irqreturn_t timer_interrupt(int irq, void dev_id, struct pt_regs regs)
1da177e4 LT	206	{
	207	#ifndef CONFIG_SMP
	208	profile_tick(CPU_PROFILING, regs);
	209	#endif
	210	do_timer(regs);
	211
	212	#ifndef CONFIG_SMP
	213	update_process_times(user_mode(regs));
	214	#endif
	215	/*
	216	* If we have an externally synchronized Linux clock, then update
	217	* CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
	218	* called as close as possible to 500 ms before the new second starts.
	219	*/
2757a71c	220	write_seqlock(&xtime_lock);
b149ee22	221	if (ntp_synced()
1da177e4 LT	222	&& xtime.tv_sec > last_rtc_update + 660
	223	&& (xtime.tv_nsec / 1000) >= 500000 - ((unsigned)TICK_SIZE) / 2
	224	&& (xtime.tv_nsec / 1000) <= 500000 + ((unsigned)TICK_SIZE) / 2)
	225	{
	226	if (set_rtc_mmss(xtime.tv_sec) == 0)
	227	last_rtc_update = xtime.tv_sec;
	228	else /* do it again in 60 s */
	229	last_rtc_update = xtime.tv_sec - 600;
	230	}
2757a71c	231	write_sequnlock(&xtime_lock);
1da177e4 LT	232	/* As we return to user mode fire off the other CPU schedulers..
	233	this is basically because we don't yet share IRQ's around.
	234	This message is rigged to be safe on the 386 - basically it's
	235	a hack, so don't look closely for now.. */
	236
	237	#ifdef CONFIG_SMP
	238	smp_local_timer_interrupt(regs);
2757a71c	239	smp_send_timer();
1da177e4	240	#endif
1da177e4 LT	241
	242	return IRQ_HANDLED;
	243	}
	244
	245	struct irqaction irq0 = { timer_interrupt, SA_INTERRUPT, CPU_MASK_NONE,
	246	"MFT2", NULL, NULL };
	247
	248	void __init time_init(void)
	249	{
	250	unsigned int epoch, year, mon, day, hour, min, sec;
	251
	252	sec = min = hour = day = mon = year = 0;
	253	epoch = 0;
	254
	255	year = 23;
	256	mon = 4;
	257	day = 17;
	258
	259	/* Attempt to guess the epoch. This is the same heuristic as in rtc.c
	260	so no stupid things will happen to timekeeping. Who knows, maybe
	261	Ultrix also uses 1952 as epoch ... */
	262	if (year > 10 && year < 44)
	263	epoch = 1980;
	264	else if (year < 96)
	265	epoch = 1952;
	266	year += epoch;
	267
	268	xtime.tv_sec = mktime(year, mon, day, hour, min, sec);
	269	xtime.tv_nsec = (INITIAL_JIFFIES % HZ) * (NSEC_PER_SEC / HZ);
	270	set_normalized_timespec(&wall_to_monotonic,
	271	-xtime.tv_sec, -xtime.tv_nsec);
	272
	273	#if defined(CONFIG_CHIP_M32102) \|\| defined(CONFIG_CHIP_XNUX2) \
	274	\|\| defined(CONFIG_CHIP_VDEC2) \|\| defined(CONFIG_CHIP_M32700) \
	275	\|\| defined(CONFIG_CHIP_OPSP)
	276
	277	/* M32102 MFT setup */
	278	setup_irq(M32R_IRQ_MFT2, &irq0);
	279	{
	280	unsigned long bus_clock;
	281	unsigned short divide;
	282
	283	bus_clock = boot_cpu_data.bus_clock;
	284	divide = boot_cpu_data.timer_divide;
	285	latch = (bus_clock/divide + HZ / 2) / HZ;
	286
	287	printk("Timer start : latch = %ld\n", latch);
	288
	289	outl((M32R_MFTMOD_CC_MASK \| M32R_MFTMOD_TCCR \
	290	\|M32R_MFTMOD_CSSEL011), M32R_MFT2MOD_PORTL);
	291	outl(latch, M32R_MFT2RLD_PORTL);
	292	outl(latch, M32R_MFT2CUT_PORTL);
	293	outl(0, M32R_MFT2CMPRLD_PORTL);
	294	outl((M32R_MFTCR_MFT2MSK\|M32R_MFTCR_MFT2EN), M32R_MFTCR_PORTL);
	295	}
	296
	297	#elif defined(CONFIG_CHIP_M32310)
	298	#warning time_init not implemented
	299	#else
	300	#error no chip configuration
	301	#endif
	302	}
	303
	304	/*
305	* Scheduler clock - returns current time in nanosec units.
306	*/
307	unsigned long long sched_clock(void)
308	{
309	return (unsigned long long)jiffies * (1000000000 / HZ);
310	}