[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;

	frame.fp = regs->ARM_fp;
	frame.sp = regs->ARM_sp;
	frame.lr = regs->ARM_lr;
	frame.pc = regs->ARM_pc;
	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
2d7c11bf CM	53	frame.fp = regs->ARM_fp;
	54	frame.sp = regs->ARM_sp;
	55	frame.lr = regs->ARM_lr;
	56	frame.pc = regs->ARM_pc;
	57	do {
	58	int ret = unwind_frame(&frame);
	59	if (ret < 0)
	60	return 0;
	61	} while (in_lock_functions(frame.pc));
	62
	63	return frame.pc;
1da177e4 LT	64	}
	65	EXPORT_SYMBOL(profile_pc);
	66	#endif
	67
9e4559dd	68	#ifndef CONFIG_GENERIC_CLOCKEVENTS
1da177e4 LT	69	/*
	70	* Kernel system timer support.
	71	*/
0cd61b68	72	void timer_tick(void)
1da177e4	73	{
e317c8cc	74	profile_tick(CPU_PROFILING);
6906e33c	75	xtime_update(1);
1da177e4	76	#ifndef CONFIG_SMP
c97d4869	77	update_process_times(user_mode(get_irq_regs()));
1da177e4 LT	78	#endif
1da177e4 LT	79	}
9e4559dd	80	#endif
1da177e4	81
bd0493ea MZ	82	static void dummy_clock_access(struct timespec *ts)
	83	{
	84	ts->tv_sec = 0;
	85	ts->tv_nsec = 0;
	86	}
	87
	88	static clock_access_fn __read_persistent_clock = dummy_clock_access;
	89	static clock_access_fn __read_boot_clock = dummy_clock_access;;
	90
	91	void read_persistent_clock(struct timespec *ts)
	92	{
	93	__read_persistent_clock(ts);
	94	}
	95
	96	void read_boot_clock(struct timespec *ts)
	97	{
	98	__read_boot_clock(ts);
	99	}
	100
	101	int __init register_persistent_clock(clock_access_fn read_boot,
	102	clock_access_fn read_persistent)
	103	{
	104	/* Only allow the clockaccess functions to be registered once */
	105	if (__read_persistent_clock == dummy_clock_access &&
	106	__read_boot_clock == dummy_clock_access) {
	107	if (read_boot)
	108	__read_boot_clock = read_boot;
	109	if (read_persistent)
	110	__read_persistent_clock = read_persistent;
	111
	112	return 0;
	113	}
	114
	115	return -EINVAL;
	116	}
	117
1da177e4 LT	118	void __init time_init(void)
1da177e4 LT	119	{
4178bac4	120	if (machine_desc->init_time) {
f414f13f	121	machine_desc->init_time();
4178bac4 SH	122	} else {
	123	#ifdef CONFIG_COMMON_CLK
	124	of_clk_init(NULL);
	125	#endif
f414f13f	126	clocksource_of_init();
4178bac4	127	}
1da177e4	128	}