[deliverable/linux.git] / arch / arm / kernel / time.c

/*
 *  linux/arch/arm/kernel/time.c
 *
 *  Copyright (C) 1991, 1992, 1995  Linus Torvalds
 *  Modifications for ARM (C) 1994-2001 Russell King
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 *  This file contains the ARM-specific time handling details:
 *  reading the RTC at bootup, etc...
 */
#include <linux/clk-provider.h>
#include <linux/clocksource.h>
#include <linux/errno.h>
#include <linux/export.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/kernel.h>
#include <linux/profile.h>
#include <linux/sched.h>
#include <linux/sched_clock.h>
#include <linux/smp.h>
#include <linux/time.h>
#include <linux/timex.h>
#include <linux/timer.h>

#include <asm/mach/arch.h>
#include <asm/mach/time.h>
#include <asm/stacktrace.h>
#include <asm/thread_info.h>

#if defined(CONFIG_RTC_DRV_CMOS) || defined(CONFIG_RTC_DRV_CMOS_MODULE) || \
    defined(CONFIG_NVRAM) || defined(CONFIG_NVRAM_MODULE)
/* this needs a better home */
DEFINE_SPINLOCK(rtc_lock);
EXPORT_SYMBOL(rtc_lock);
#endif	/* pc-style 'CMOS' RTC support */

/* change this if you have some constant time drift */
#define USECS_PER_JIFFY	(1000000/HZ)

#ifdef CONFIG_SMP
unsigned long profile_pc(struct pt_regs *regs)
{
	struct stackframe frame;

	if (!in_lock_functions(regs->ARM_pc))
		return regs->ARM_pc;

	arm_get_current_stackframe(regs, &frame);
	do {
		int ret = unwind_frame(&frame);
		if (ret < 0)
			return 0;
	} while (in_lock_functions(frame.pc));

	return frame.pc;
}
EXPORT_SYMBOL(profile_pc);
#endif

#ifndef CONFIG_GENERIC_CLOCKEVENTS
/*
 * Kernel system timer support.
 */
void timer_tick(void)
{
	profile_tick(CPU_PROFILING);
	xtime_update(1);
#ifndef CONFIG_SMP
	update_process_times(user_mode(get_irq_regs()));
#endif
}
#endif

static void dummy_clock_access(struct timespec *ts)
{
	ts->tv_sec = 0;
	ts->tv_nsec = 0;
}

static clock_access_fn __read_persistent_clock = dummy_clock_access;
static clock_access_fn __read_boot_clock = dummy_clock_access;;

void read_persistent_clock(struct timespec *ts)
{
	__read_persistent_clock(ts);
}

void read_boot_clock(struct timespec *ts)
{
	__read_boot_clock(ts);
}

int __init register_persistent_clock(clock_access_fn read_boot,
				     clock_access_fn read_persistent)
{
	/* Only allow the clockaccess functions to be registered once */
	if (__read_persistent_clock == dummy_clock_access &&
	    __read_boot_clock == dummy_clock_access) {
		if (read_boot)
			__read_boot_clock = read_boot;
		if (read_persistent)
			__read_persistent_clock = read_persistent;

		return 0;
	}

	return -EINVAL;
}

void __init time_init(void)
{
	if (machine_desc->init_time) {
		machine_desc->init_time();
	} else {
#ifdef CONFIG_COMMON_CLK
		of_clk_init(NULL);
#endif
		clocksource_of_init();
	}
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/arm/kernel/time.c
	3	*
	4	* Copyright (C) 1991, 1992, 1995 Linus Torvalds
	5	* Modifications for ARM (C) 1994-2001 Russell King
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*
	11	* This file contains the ARM-specific time handling details:
	12	* reading the RTC at bootup, etc...
1da177e4	13	*/
4178bac4 SH	14	#include <linux/clk-provider.h>
	15	#include <linux/clocksource.h>
	16	#include <linux/errno.h>
ecea4ab6	17	#include <linux/export.h>
1da177e4	18	#include <linux/init.h>
4178bac4 SH	19	#include <linux/interrupt.h>
	20	#include <linux/irq.h>
	21	#include <linux/kernel.h>
	22	#include <linux/profile.h>
d43c36dc	23	#include <linux/sched.h>
4178bac4	24	#include <linux/sched_clock.h>
1da177e4	25	#include <linux/smp.h>
4178bac4	26	#include <linux/time.h>
1da177e4	27	#include <linux/timex.h>
1da177e4 LT	28	#include <linux/timer.h>
1da177e4 LT	29
8ff1443c	30	#include <asm/mach/arch.h>
1da177e4	31	#include <asm/mach/time.h>
4178bac4 SH	32	#include <asm/stacktrace.h>
4178bac4 SH	33	#include <asm/thread_info.h>
1da177e4	34
63216d3c AB	35	#if defined(CONFIG_RTC_DRV_CMOS) \|\| defined(CONFIG_RTC_DRV_CMOS_MODULE) \|\| \
63216d3c AB	36	defined(CONFIG_NVRAM) \|\| defined(CONFIG_NVRAM_MODULE)
1da177e4 LT	37	/* this needs a better home */
1da177e4 LT	38	DEFINE_SPINLOCK(rtc_lock);
1da177e4	39	EXPORT_SYMBOL(rtc_lock);
9dd34948	40	#endif /* pc-style 'CMOS' RTC support */
1da177e4 LT	41
	42	/* change this if you have some constant time drift */
	43	#define USECS_PER_JIFFY (1000000/HZ)
	44
	45	#ifdef CONFIG_SMP
	46	unsigned long profile_pc(struct pt_regs *regs)
	47	{
2d7c11bf	48	struct stackframe frame;
1da177e4	49
2d7c11bf CM	50	if (!in_lock_functions(regs->ARM_pc))
2d7c11bf CM	51	return regs->ARM_pc;
1da177e4	52
a3250c92	53	arm_get_current_stackframe(regs, &frame);
2d7c11bf CM	54	do {
	55	int ret = unwind_frame(&frame);
	56	if (ret < 0)
	57	return 0;
	58	} while (in_lock_functions(frame.pc));
	59
	60	return frame.pc;
1da177e4 LT	61	}
	62	EXPORT_SYMBOL(profile_pc);
	63	#endif
	64
9e4559dd	65	#ifndef CONFIG_GENERIC_CLOCKEVENTS
1da177e4 LT	66	/*
	67	* Kernel system timer support.
	68	*/
0cd61b68	69	void timer_tick(void)
1da177e4	70	{
e317c8cc	71	profile_tick(CPU_PROFILING);
6906e33c	72	xtime_update(1);
1da177e4	73	#ifndef CONFIG_SMP
c97d4869	74	update_process_times(user_mode(get_irq_regs()));
1da177e4 LT	75	#endif
1da177e4 LT	76	}
9e4559dd	77	#endif
1da177e4	78
bd0493ea MZ	79	static void dummy_clock_access(struct timespec *ts)
	80	{
	81	ts->tv_sec = 0;
	82	ts->tv_nsec = 0;
	83	}
	84
	85	static clock_access_fn __read_persistent_clock = dummy_clock_access;
	86	static clock_access_fn __read_boot_clock = dummy_clock_access;;
	87
	88	void read_persistent_clock(struct timespec *ts)
	89	{
	90	__read_persistent_clock(ts);
	91	}
	92
	93	void read_boot_clock(struct timespec *ts)
	94	{
	95	__read_boot_clock(ts);
	96	}
	97
	98	int __init register_persistent_clock(clock_access_fn read_boot,
	99	clock_access_fn read_persistent)
	100	{
	101	/* Only allow the clockaccess functions to be registered once */
	102	if (__read_persistent_clock == dummy_clock_access &&
	103	__read_boot_clock == dummy_clock_access) {
	104	if (read_boot)
	105	__read_boot_clock = read_boot;
	106	if (read_persistent)
	107	__read_persistent_clock = read_persistent;
	108
	109	return 0;
	110	}
	111
	112	return -EINVAL;
	113	}
	114
1da177e4 LT	115	void __init time_init(void)
1da177e4 LT	116	{
4178bac4	117	if (machine_desc->init_time) {
f414f13f	118	machine_desc->init_time();
4178bac4 SH	119	} else {
	120	#ifdef CONFIG_COMMON_CLK
	121	of_clk_init(NULL);
	122	#endif
f414f13f	123	clocksource_of_init();
4178bac4	124	}
1da177e4	125	}