[linux-2.6-block.git] / drivers / clocksource / nomadik-mtu.c

/*
 * Copyright (C) 2008 STMicroelectronics
 * Copyright (C) 2010 Alessandro Rubini
 * Copyright (C) 2010 Linus Walleij for ST-Ericsson
 *
 * 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.
 */
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/io.h>
#include <linux/clockchips.h>
#include <linux/clocksource.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_platform.h>
#include <linux/clk.h>
#include <linux/jiffies.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/sched_clock.h>
#include <asm/mach/time.h>

/*
 * The MTU device hosts four different counters, with 4 set of
 * registers. These are register names.
 */

#define MTU_IMSC	0x00	/* Interrupt mask set/clear */
#define MTU_RIS		0x04	/* Raw interrupt status */
#define MTU_MIS		0x08	/* Masked interrupt status */
#define MTU_ICR		0x0C	/* Interrupt clear register */

/* per-timer registers take 0..3 as argument */
#define MTU_LR(x)	(0x10 + 0x10 * (x) + 0x00)	/* Load value */
#define MTU_VAL(x)	(0x10 + 0x10 * (x) + 0x04)	/* Current value */
#define MTU_CR(x)	(0x10 + 0x10 * (x) + 0x08)	/* Control reg */
#define MTU_BGLR(x)	(0x10 + 0x10 * (x) + 0x0c)	/* At next overflow */

/* bits for the control register */
#define MTU_CRn_ENA		0x80
#define MTU_CRn_PERIODIC	0x40	/* if 0 = free-running */
#define MTU_CRn_PRESCALE_MASK	0x0c
#define MTU_CRn_PRESCALE_1		0x00
#define MTU_CRn_PRESCALE_16		0x04
#define MTU_CRn_PRESCALE_256		0x08
#define MTU_CRn_32BITS		0x02
#define MTU_CRn_ONESHOT		0x01	/* if 0 = wraps reloading from BGLR*/

/* Other registers are usual amba/primecell registers, currently not used */
#define MTU_ITCR	0xff0
#define MTU_ITOP	0xff4

#define MTU_PERIPH_ID0	0xfe0
#define MTU_PERIPH_ID1	0xfe4
#define MTU_PERIPH_ID2	0xfe8
#define MTU_PERIPH_ID3	0xfeC

#define MTU_PCELL0	0xff0
#define MTU_PCELL1	0xff4
#define MTU_PCELL2	0xff8
#define MTU_PCELL3	0xffC

static void __iomem *mtu_base;
static bool clkevt_periodic;
static u32 clk_prescale;
static u32 nmdk_cycle;		/* write-once */
static struct delay_timer mtu_delay_timer;

/*
 * Override the global weak sched_clock symbol with this
 * local implementation which uses the clocksource to get some
 * better resolution when scheduling the kernel.
 */
static u64 notrace nomadik_read_sched_clock(void)
{
	if (unlikely(!mtu_base))
		return 0;

	return -readl(mtu_base + MTU_VAL(0));
}

static unsigned long nmdk_timer_read_current_timer(void)
{
	return ~readl_relaxed(mtu_base + MTU_VAL(0));
}

/* Clockevent device: use one-shot mode */
static int nmdk_clkevt_next(unsigned long evt, struct clock_event_device *ev)
{
	writel(1 << 1, mtu_base + MTU_IMSC);
	writel(evt, mtu_base + MTU_LR(1));
	/* Load highest value, enable device, enable interrupts */
	writel(MTU_CRn_ONESHOT | clk_prescale |
	       MTU_CRn_32BITS | MTU_CRn_ENA,
	       mtu_base + MTU_CR(1));

	return 0;
}

static void nmdk_clkevt_reset(void)
{
	if (clkevt_periodic) {
		/* Timer: configure load and background-load, and fire it up */
		writel(nmdk_cycle, mtu_base + MTU_LR(1));
		writel(nmdk_cycle, mtu_base + MTU_BGLR(1));

		writel(MTU_CRn_PERIODIC | clk_prescale |
		       MTU_CRn_32BITS | MTU_CRn_ENA,
		       mtu_base + MTU_CR(1));
		writel(1 << 1, mtu_base + MTU_IMSC);
	} else {
		/* Generate an interrupt to start the clockevent again */
		(void) nmdk_clkevt_next(nmdk_cycle, NULL);
	}
}

static int nmdk_clkevt_shutdown(struct clock_event_device *evt)
{
	writel(0, mtu_base + MTU_IMSC);
	/* disable timer */
	writel(0, mtu_base + MTU_CR(1));
	/* load some high default value */
	writel(0xffffffff, mtu_base + MTU_LR(1));
	return 0;
}

static int nmdk_clkevt_set_oneshot(struct clock_event_device *evt)
{
	clkevt_periodic = false;
	return 0;
}

static int nmdk_clkevt_set_periodic(struct clock_event_device *evt)
{
	clkevt_periodic = true;
	nmdk_clkevt_reset();
	return 0;
}

static void nmdk_clksrc_reset(void)
{
	/* Disable */
	writel(0, mtu_base + MTU_CR(0));

	/* ClockSource: configure load and background-load, and fire it up */
	writel(nmdk_cycle, mtu_base + MTU_LR(0));
	writel(nmdk_cycle, mtu_base + MTU_BGLR(0));

	writel(clk_prescale | MTU_CRn_32BITS | MTU_CRn_ENA,
	       mtu_base + MTU_CR(0));
}

static void nmdk_clkevt_resume(struct clock_event_device *cedev)
{
	nmdk_clkevt_reset();
	nmdk_clksrc_reset();
}

static struct clock_event_device nmdk_clkevt = {
	.name			= "mtu_1",
	.features		= CLOCK_EVT_FEAT_ONESHOT |
				  CLOCK_EVT_FEAT_PERIODIC |
				  CLOCK_EVT_FEAT_DYNIRQ,
	.rating			= 200,
	.set_state_shutdown	= nmdk_clkevt_shutdown,
	.set_state_periodic	= nmdk_clkevt_set_periodic,
	.set_state_oneshot	= nmdk_clkevt_set_oneshot,
	.set_next_event		= nmdk_clkevt_next,
	.resume			= nmdk_clkevt_resume,
};

/*
 * IRQ Handler for timer 1 of the MTU block.
 */
static irqreturn_t nmdk_timer_interrupt(int irq, void *dev_id)
{
	struct clock_event_device *evdev = dev_id;

	writel(1 << 1, mtu_base + MTU_ICR); /* Interrupt clear reg */
	evdev->event_handler(evdev);
	return IRQ_HANDLED;
}

static struct irqaction nmdk_timer_irq = {
	.name		= "Nomadik Timer Tick",
	.flags		= IRQF_TIMER,
	.handler	= nmdk_timer_interrupt,
	.dev_id		= &nmdk_clkevt,
};

static int __init nmdk_timer_init(void __iomem *base, int irq,
				   struct clk *pclk, struct clk *clk)
{
	unsigned long rate;
	int ret;

	mtu_base = base;

	BUG_ON(clk_prepare_enable(pclk));
	BUG_ON(clk_prepare_enable(clk));

	/*
	 * Tick rate is 2.4MHz for Nomadik and 2.4Mhz, 100MHz or 133 MHz
	 * for ux500.
	 * Use a divide-by-16 counter if the tick rate is more than 32MHz.
	 * At 32 MHz, the timer (with 32 bit counter) can be programmed
	 * to wake-up at a max 127s a head in time. Dividing a 2.4 MHz timer
	 * with 16 gives too low timer resolution.
	 */
	rate = clk_get_rate(clk);
	if (rate > 32000000) {
		rate /= 16;
		clk_prescale = MTU_CRn_PRESCALE_16;
	} else {
		clk_prescale = MTU_CRn_PRESCALE_1;
	}

	/* Cycles for periodic mode */
	nmdk_cycle = DIV_ROUND_CLOSEST(rate, HZ);


	/* Timer 0 is the free running clocksource */
	nmdk_clksrc_reset();

	ret = clocksource_mmio_init(mtu_base + MTU_VAL(0), "mtu_0",
				    rate, 200, 32, clocksource_mmio_readl_down);
	if (ret) {
		pr_err("timer: failed to initialize clock source %s\n", "mtu_0");
		return ret;
	}

	sched_clock_register(nomadik_read_sched_clock, 32, rate);

	/* Timer 1 is used for events, register irq and clockevents */
	setup_irq(irq, &nmdk_timer_irq);
	nmdk_clkevt.cpumask = cpumask_of(0);
	nmdk_clkevt.irq = irq;
	clockevents_config_and_register(&nmdk_clkevt, rate, 2, 0xffffffffU);

	mtu_delay_timer.read_current_timer = &nmdk_timer_read_current_timer;
	mtu_delay_timer.freq = rate;
	register_current_timer_delay(&mtu_delay_timer);

	return 0;
}

static int __init nmdk_timer_of_init(struct device_node *node)
{
	struct clk *pclk;
	struct clk *clk;
	void __iomem *base;
	int irq;

	base = of_iomap(node, 0);
	if (!base) {
		pr_err("Can't remap registers\n");
		return -ENXIO;
	}

	pclk = of_clk_get_by_name(node, "apb_pclk");
	if (IS_ERR(pclk)) {
		pr_err("could not get apb_pclk\n");
		return PTR_ERR(pclk);
	}

	clk = of_clk_get_by_name(node, "timclk");
	if (IS_ERR(clk)) {
		pr_err("could not get timclk\n");
		return PTR_ERR(clk);
	}

	irq = irq_of_parse_and_map(node, 0);
	if (irq <= 0) {
		pr_err("Can't parse IRQ\n");
		return -EINVAL;
	}

	return nmdk_timer_init(base, irq, pclk, clk);
}
TIMER_OF_DECLARE(nomadik_mtu, "st,nomadik-mtu",
		       nmdk_timer_of_init);
Commit	Line	Data
28ad94ec	1	/*
28ad94ec	2	* Copyright (C) 2008 STMicroelectronics
b102c01f	3	* Copyright (C) 2010 Alessandro Rubini
8fbb97a2	4	* Copyright (C) 2010 Linus Walleij for ST-Ericsson
28ad94ec AR	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2, as
	8	* published by the Free Software Foundation.
	9	*/
	10	#include <linux/init.h>
	11	#include <linux/interrupt.h>
	12	#include <linux/irq.h>
	13	#include <linux/io.h>
	14	#include <linux/clockchips.h>
694e33a7	15	#include <linux/clocksource.h>
c7785ea0 RV	16	#include <linux/of_address.h>
	17	#include <linux/of_irq.h>
	18	#include <linux/of_platform.h>
ba327b1e	19	#include <linux/clk.h>
28ad94ec	20	#include <linux/jiffies.h>
6f179b72	21	#include <linux/delay.h>
ba327b1e	22	#include <linux/err.h>
38ff87f7	23	#include <linux/sched_clock.h>
28ad94ec	24	#include <asm/mach/time.h>
28ad94ec	25
05387a9f JA	26	/*
	27	* The MTU device hosts four different counters, with 4 set of
	28	* registers. These are register names.
	29	*/
	30
	31	#define MTU_IMSC 0x00 /* Interrupt mask set/clear */
	32	#define MTU_RIS 0x04 /* Raw interrupt status */
	33	#define MTU_MIS 0x08 /* Masked interrupt status */
	34	#define MTU_ICR 0x0C /* Interrupt clear register */
	35
	36	/* per-timer registers take 0..3 as argument */
	37	#define MTU_LR(x) (0x10 + 0x10 * (x) + 0x00) /* Load value */
	38	#define MTU_VAL(x) (0x10 + 0x10 * (x) + 0x04) /* Current value */
	39	#define MTU_CR(x) (0x10 + 0x10 * (x) + 0x08) /* Control reg */
	40	#define MTU_BGLR(x) (0x10 + 0x10 * (x) + 0x0c) /* At next overflow */
	41
	42	/* bits for the control register */
	43	#define MTU_CRn_ENA 0x80
	44	#define MTU_CRn_PERIODIC 0x40 /* if 0 = free-running */
	45	#define MTU_CRn_PRESCALE_MASK 0x0c
	46	#define MTU_CRn_PRESCALE_1 0x00
	47	#define MTU_CRn_PRESCALE_16 0x04
	48	#define MTU_CRn_PRESCALE_256 0x08
	49	#define MTU_CRn_32BITS 0x02
	50	#define MTU_CRn_ONESHOT 0x01 /* if 0 = wraps reloading from BGLR*/
	51
	52	/* Other registers are usual amba/primecell registers, currently not used */
	53	#define MTU_ITCR 0xff0
	54	#define MTU_ITOP 0xff4
	55
	56	#define MTU_PERIPH_ID0 0xfe0
	57	#define MTU_PERIPH_ID1 0xfe4
	58	#define MTU_PERIPH_ID2 0xfe8
	59	#define MTU_PERIPH_ID3 0xfeC
	60
	61	#define MTU_PCELL0 0xff0
	62	#define MTU_PCELL1 0xff4
	63	#define MTU_PCELL2 0xff8
	64	#define MTU_PCELL3 0xffC
28ad94ec	65
b9576623	66	static void __iomem *mtu_base;
2f73a068 JA	67	static bool clkevt_periodic;
	68	static u32 clk_prescale;
	69	static u32 nmdk_cycle; /* write-once */
6f179b72	70	static struct delay_timer mtu_delay_timer;
2f73a068	71
2a847513 LW	72	/*
	73	* Override the global weak sched_clock symbol with this
	74	* local implementation which uses the clocksource to get some
8fbb97a2	75	* better resolution when scheduling the kernel.
2a847513	76	*/
e25bc5f5	77	static u64 notrace nomadik_read_sched_clock(void)
2a847513	78	{
8fbb97a2 LW	79	if (unlikely(!mtu_base))
	80	return 0;
	81
2f0778af	82	return -readl(mtu_base + MTU_VAL(0));
2a847513	83	}
2f73a068	84
6f179b72 FB	85	static unsigned long nmdk_timer_read_current_timer(void)
	86	{
	87	return ~readl_relaxed(mtu_base + MTU_VAL(0));
	88	}
	89
b102c01f	90	/* Clockevent device: use one-shot mode */
2f73a068 JA	91	static int nmdk_clkevt_next(unsigned long evt, struct clock_event_device *ev)
	92	{
	93	writel(1 << 1, mtu_base + MTU_IMSC);
	94	writel(evt, mtu_base + MTU_LR(1));
	95	/* Load highest value, enable device, enable interrupts */
	96	writel(MTU_CRn_ONESHOT \| clk_prescale \|
	97	MTU_CRn_32BITS \| MTU_CRn_ENA,
	98	mtu_base + MTU_CR(1));
	99
	100	return 0;
	101	}
	102
7172c19a	103	static void nmdk_clkevt_reset(void)
2f73a068 JA	104	{
2f73a068 JA	105	if (clkevt_periodic) {
2f73a068 JA	106	/* Timer: configure load and background-load, and fire it up */
	107	writel(nmdk_cycle, mtu_base + MTU_LR(1));
	108	writel(nmdk_cycle, mtu_base + MTU_BGLR(1));
	109
	110	writel(MTU_CRn_PERIODIC \| clk_prescale \|
	111	MTU_CRn_32BITS \| MTU_CRn_ENA,
	112	mtu_base + MTU_CR(1));
	113	writel(1 << 1, mtu_base + MTU_IMSC);
	114	} else {
	115	/* Generate an interrupt to start the clockevent again */
	116	(void) nmdk_clkevt_next(nmdk_cycle, NULL);
	117	}
	118	}
	119
9b0af699	120	static int nmdk_clkevt_shutdown(struct clock_event_device *evt)
28ad94ec	121	{
9b0af699 VK	122	writel(0, mtu_base + MTU_IMSC);
	123	/* disable timer */
	124	writel(0, mtu_base + MTU_CR(1));
	125	/* load some high default value */
	126	writel(0xffffffff, mtu_base + MTU_LR(1));
	127	return 0;
	128	}
	129
	130	static int nmdk_clkevt_set_oneshot(struct clock_event_device *evt)
	131	{
	132	clkevt_periodic = false;
	133	return 0;
	134	}
	135
	136	static int nmdk_clkevt_set_periodic(struct clock_event_device *evt)
	137	{
	138	clkevt_periodic = true;
	139	nmdk_clkevt_reset();
	140	return 0;
28ad94ec AR	141	}
28ad94ec AR	142
7172c19a	143	static void nmdk_clksrc_reset(void)
8726e96f SW	144	{
	145	/* Disable */
	146	writel(0, mtu_base + MTU_CR(0));
	147
	148	/* ClockSource: configure load and background-load, and fire it up */
	149	writel(nmdk_cycle, mtu_base + MTU_LR(0));
	150	writel(nmdk_cycle, mtu_base + MTU_BGLR(0));
	151
	152	writel(clk_prescale \| MTU_CRn_32BITS \| MTU_CRn_ENA,
	153	mtu_base + MTU_CR(0));
	154	}
	155
	156	static void nmdk_clkevt_resume(struct clock_event_device *cedev)
	157	{
	158	nmdk_clkevt_reset();
	159	nmdk_clksrc_reset();
	160	}
	161
28ad94ec	162	static struct clock_event_device nmdk_clkevt = {
9b0af699 VK	163	.name = "mtu_1",
	164	.features = CLOCK_EVT_FEAT_ONESHOT \|
	165	CLOCK_EVT_FEAT_PERIODIC \|
	166	CLOCK_EVT_FEAT_DYNIRQ,
	167	.rating = 200,
	168	.set_state_shutdown = nmdk_clkevt_shutdown,
	169	.set_state_periodic = nmdk_clkevt_set_periodic,
	170	.set_state_oneshot = nmdk_clkevt_set_oneshot,
	171	.set_next_event = nmdk_clkevt_next,
	172	.resume = nmdk_clkevt_resume,
28ad94ec AR	173	};
	174
	175	/*
b102c01f	176	* IRQ Handler for timer 1 of the MTU block.
28ad94ec AR	177	*/
	178	static irqreturn_t nmdk_timer_interrupt(int irq, void *dev_id)
	179	{
b102c01f	180	struct clock_event_device *evdev = dev_id;
28ad94ec	181
b102c01f AR	182	writel(1 << 1, mtu_base + MTU_ICR); /* Interrupt clear reg */
b102c01f AR	183	evdev->event_handler(evdev);
28ad94ec AR	184	return IRQ_HANDLED;
	185	}
	186
28ad94ec AR	187	static struct irqaction nmdk_timer_irq = {
28ad94ec AR	188	.name = "Nomadik Timer Tick",
38c30a84	189	.flags = IRQF_TIMER,
28ad94ec	190	.handler = nmdk_timer_interrupt,
b102c01f	191	.dev_id = &nmdk_clkevt,
28ad94ec AR	192	};
28ad94ec AR	193
e46105af	194	static int __init nmdk_timer_init(void __iomem *base, int irq,
7172c19a	195	struct clk pclk, struct clk clk)
28ad94ec	196	{
28ad94ec	197	unsigned long rate;
e46105af	198	int ret;
ba327b1e	199
b9576623	200	mtu_base = base;
16defa66	201
c7785ea0 RV	202	BUG_ON(clk_prepare_enable(pclk));
c7785ea0 RV	203	BUG_ON(clk_prepare_enable(clk));
b102c01f AR	204
b102c01f AR	205	/*
a0719f52 LW	206	* Tick rate is 2.4MHz for Nomadik and 2.4Mhz, 100MHz or 133 MHz
	207	* for ux500.
	208	* Use a divide-by-16 counter if the tick rate is more than 32MHz.
	209	* At 32 MHz, the timer (with 32 bit counter) can be programmed
	210	* to wake-up at a max 127s a head in time. Dividing a 2.4 MHz timer
	211	* with 16 gives too low timer resolution.
b102c01f	212	*/
c7785ea0	213	rate = clk_get_rate(clk);
a0719f52	214	if (rate > 32000000) {
b102c01f	215	rate /= 16;
2f73a068	216	clk_prescale = MTU_CRn_PRESCALE_16;
b102c01f	217	} else {
2f73a068	218	clk_prescale = MTU_CRn_PRESCALE_1;
b102c01f	219	}
28ad94ec	220
21366831 LW	221	/* Cycles for periodic mode */
21366831 LW	222	nmdk_cycle = DIV_ROUND_CLOSEST(rate, HZ);
2f73a068 JA	223
2f73a068 JA	224
b102c01f	225	/* Timer 0 is the free running clocksource */
2f73a068	226	nmdk_clksrc_reset();
28ad94ec	227
e46105af DL	228	ret = clocksource_mmio_init(mtu_base + MTU_VAL(0), "mtu_0",
	229	rate, 200, 32, clocksource_mmio_readl_down);
	230	if (ret) {
	231	pr_err("timer: failed to initialize clock source %s\n", "mtu_0");
	232	return ret;
	233	}
2f0778af	234
e25bc5f5	235	sched_clock_register(nomadik_read_sched_clock, 32, rate);
2f0778af	236
a3b86a6d	237	/* Timer 1 is used for events, register irq and clockevents */
0813069d	238	setup_irq(irq, &nmdk_timer_irq);
a3b86a6d	239	nmdk_clkevt.cpumask = cpumask_of(0);
00f4e13c	240	nmdk_clkevt.irq = irq;
a3b86a6d	241	clockevents_config_and_register(&nmdk_clkevt, rate, 2, 0xffffffffU);
6f179b72 FB	242
	243	mtu_delay_timer.read_current_timer = &nmdk_timer_read_current_timer;
	244	mtu_delay_timer.freq = rate;
	245	register_current_timer_delay(&mtu_delay_timer);
e46105af DL	246
e46105af DL	247	return 0;
28ad94ec	248	}
c7785ea0	249
e46105af	250	static int __init nmdk_timer_of_init(struct device_node *node)
c7785ea0	251	{
c7785ea0 RV	252	struct clk *pclk;
	253	struct clk *clk;
	254	void __iomem *base;
	255	int irq;
	256
c7785ea0	257	base = of_iomap(node, 0);
e46105af	258	if (!base) {
ac9ce6d1	259	pr_err("Can't remap registers\n");
e46105af DL	260	return -ENXIO;
e46105af DL	261	}
c7785ea0 RV	262
c7785ea0 RV	263	pclk = of_clk_get_by_name(node, "apb_pclk");
e46105af	264	if (IS_ERR(pclk)) {
ac9ce6d1	265	pr_err("could not get apb_pclk\n");
e46105af DL	266	return PTR_ERR(pclk);
e46105af DL	267	}
c7785ea0 RV	268
c7785ea0 RV	269	clk = of_clk_get_by_name(node, "timclk");
e46105af	270	if (IS_ERR(clk)) {
ac9ce6d1	271	pr_err("could not get timclk\n");
e46105af DL	272	return PTR_ERR(clk);
e46105af DL	273	}
c7785ea0 RV	274
c7785ea0 RV	275	irq = irq_of_parse_and_map(node, 0);
e46105af	276	if (irq <= 0) {
ac9ce6d1	277	pr_err("Can't parse IRQ\n");
e46105af DL	278	return -EINVAL;
e46105af DL	279	}
c7785ea0	280
e46105af	281	return nmdk_timer_init(base, irq, pclk, clk);
c7785ea0	282	}
17273395	283	TIMER_OF_DECLARE(nomadik_mtu, "st,nomadik-mtu",
c7785ea0	284	nmdk_timer_of_init);