[mirror_ubuntu-bionic-kernel.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/export.h>
#include <linux/kernel.h>
#include <linux/interrupt.h>
#include <linux/time.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/smp.h>
#include <linux/timex.h>
#include <linux/errno.h>
#include <linux/profile.h>
#include <linux/timer.h>
#include <linux/irq.h>

#include <asm/thread_info.h>
#include <asm/sched_clock.h>
#include <asm/stacktrace.h>
#include <asm/mach/arch.h>
#include <asm/mach/time.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)
{
	machine_desc->init_time();
	sched_clock_postinit();
}
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	*/
ecea4ab6	14	#include <linux/export.h>
1da177e4 LT	15	#include <linux/kernel.h>
	16	#include <linux/interrupt.h>
	17	#include <linux/time.h>
	18	#include <linux/init.h>
d43c36dc	19	#include <linux/sched.h>
1da177e4 LT	20	#include <linux/smp.h>
	21	#include <linux/timex.h>
	22	#include <linux/errno.h>
	23	#include <linux/profile.h>
1da177e4	24	#include <linux/timer.h>
e317c8cc	25	#include <linux/irq.h>
1da177e4	26
1da177e4	27	#include <asm/thread_info.h>
211baa70	28	#include <asm/sched_clock.h>
2d7c11bf	29	#include <asm/stacktrace.h>
8ff1443c	30	#include <asm/mach/arch.h>
1da177e4 LT	31	#include <asm/mach/time.h>
1da177e4 LT	32
63216d3c AB	33	#if defined(CONFIG_RTC_DRV_CMOS) \|\| defined(CONFIG_RTC_DRV_CMOS_MODULE) \|\| \
63216d3c AB	34	defined(CONFIG_NVRAM) \|\| defined(CONFIG_NVRAM_MODULE)
1da177e4 LT	35	/* this needs a better home */
1da177e4 LT	36	DEFINE_SPINLOCK(rtc_lock);
1da177e4	37	EXPORT_SYMBOL(rtc_lock);
9dd34948	38	#endif /* pc-style 'CMOS' RTC support */
1da177e4 LT	39
	40	/* change this if you have some constant time drift */
	41	#define USECS_PER_JIFFY (1000000/HZ)
	42
	43	#ifdef CONFIG_SMP
	44	unsigned long profile_pc(struct pt_regs *regs)
	45	{
2d7c11bf	46	struct stackframe frame;
1da177e4	47
2d7c11bf CM	48	if (!in_lock_functions(regs->ARM_pc))
2d7c11bf CM	49	return regs->ARM_pc;
1da177e4	50
2d7c11bf CM	51	frame.fp = regs->ARM_fp;
	52	frame.sp = regs->ARM_sp;
	53	frame.lr = regs->ARM_lr;
	54	frame.pc = regs->ARM_pc;
	55	do {
	56	int ret = unwind_frame(&frame);
	57	if (ret < 0)
	58	return 0;
	59	} while (in_lock_functions(frame.pc));
	60
	61	return frame.pc;
1da177e4 LT	62	}
	63	EXPORT_SYMBOL(profile_pc);
	64	#endif
	65
9e4559dd	66	#ifndef CONFIG_GENERIC_CLOCKEVENTS
1da177e4 LT	67	/*
	68	* Kernel system timer support.
	69	*/
0cd61b68	70	void timer_tick(void)
1da177e4	71	{
e317c8cc	72	profile_tick(CPU_PROFILING);
6906e33c	73	xtime_update(1);
1da177e4	74	#ifndef CONFIG_SMP
c97d4869	75	update_process_times(user_mode(get_irq_regs()));
1da177e4 LT	76	#endif
1da177e4 LT	77	}
9e4559dd	78	#endif
1da177e4	79
bd0493ea MZ	80	static void dummy_clock_access(struct timespec *ts)
	81	{
	82	ts->tv_sec = 0;
	83	ts->tv_nsec = 0;
	84	}
	85
	86	static clock_access_fn __read_persistent_clock = dummy_clock_access;
	87	static clock_access_fn __read_boot_clock = dummy_clock_access;;
	88
	89	void read_persistent_clock(struct timespec *ts)
	90	{
	91	__read_persistent_clock(ts);
	92	}
	93
	94	void read_boot_clock(struct timespec *ts)
	95	{
	96	__read_boot_clock(ts);
	97	}
	98
	99	int __init register_persistent_clock(clock_access_fn read_boot,
	100	clock_access_fn read_persistent)
	101	{
	102	/* Only allow the clockaccess functions to be registered once */
	103	if (__read_persistent_clock == dummy_clock_access &&
	104	__read_boot_clock == dummy_clock_access) {
	105	if (read_boot)
	106	__read_boot_clock = read_boot;
	107	if (read_persistent)
	108	__read_persistent_clock = read_persistent;
	109
	110	return 0;
	111	}
	112
	113	return -EINVAL;
	114	}
	115
1da177e4 LT	116	void __init time_init(void)
1da177e4 LT	117	{
6bb27d73	118	machine_desc->init_time();
211baa70	119	sched_clock_postinit();
1da177e4	120	}