[linux.git] / drivers / clocksource / clps711x-timer.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  Cirrus Logic CLPS711X clocksource driver
 *
 *  Copyright (C) 2014 Alexander Shiyan <[email protected]>
 */

#include <linux/clk.h>
#include <linux/clockchips.h>
#include <linux/clocksource.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/sched_clock.h>
#include <linux/slab.h>

enum {
	CLPS711X_CLKSRC_CLOCKSOURCE,
	CLPS711X_CLKSRC_CLOCKEVENT,
};

static void __iomem *tcd;

static u64 notrace clps711x_sched_clock_read(void)
{
	return ~readw(tcd);
}

static void __init clps711x_clksrc_init(struct clk *clock, void __iomem *base)
{
	unsigned long rate = clk_get_rate(clock);

	tcd = base;

	clocksource_mmio_init(tcd, "clps711x-clocksource", rate, 300, 16,
			      clocksource_mmio_readw_down);

	sched_clock_register(clps711x_sched_clock_read, 16, rate);
}

static irqreturn_t clps711x_timer_interrupt(int irq, void *dev_id)
{
	struct clock_event_device *evt = dev_id;

	evt->event_handler(evt);

	return IRQ_HANDLED;
}

static int __init _clps711x_clkevt_init(struct clk *clock, void __iomem *base,
					unsigned int irq)
{
	struct clock_event_device *clkevt;
	unsigned long rate;

	clkevt = kzalloc(sizeof(*clkevt), GFP_KERNEL);
	if (!clkevt)
		return -ENOMEM;

	rate = clk_get_rate(clock);

	/* Set Timer prescaler */
	writew(DIV_ROUND_CLOSEST(rate, HZ), base);

	clkevt->name = "clps711x-clockevent";
	clkevt->rating = 300;
	clkevt->features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_C3STOP;
	clkevt->cpumask = cpumask_of(0);
	clockevents_config_and_register(clkevt, HZ, 0, 0);

	return request_irq(irq, clps711x_timer_interrupt, IRQF_TIMER,
			   "clps711x-timer", clkevt);
}

static int __init clps711x_timer_init(struct device_node *np)
{
	unsigned int irq = irq_of_parse_and_map(np, 0);
	struct clk *clock = of_clk_get(np, 0);
	void __iomem *base = of_iomap(np, 0);

	if (!base)
		return -ENOMEM;
	if (!irq)
		return -EINVAL;
	if (IS_ERR(clock))
		return PTR_ERR(clock);

	switch (of_alias_get_id(np, "timer")) {
	case CLPS711X_CLKSRC_CLOCKSOURCE:
		clps711x_clksrc_init(clock, base);
		break;
	case CLPS711X_CLKSRC_CLOCKEVENT:
		return _clps711x_clkevt_init(clock, base, irq);
	default:
		return -EINVAL;
	}

	return 0;
}
TIMER_OF_DECLARE(clps711x, "cirrus,ep7209-timer", clps711x_timer_init);
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
f0b7fabe AS	2	/*
	3	* Cirrus Logic CLPS711X clocksource driver
	4	*
	5	* Copyright (C) 2014 Alexander Shiyan <[email protected]>
f0b7fabe AS	6	*/
	7
	8	#include <linux/clk.h>
	9	#include <linux/clockchips.h>
	10	#include <linux/clocksource.h>
	11	#include <linux/interrupt.h>
	12	#include <linux/io.h>
	13	#include <linux/of_address.h>
	14	#include <linux/of_irq.h>
	15	#include <linux/sched_clock.h>
	16	#include <linux/slab.h>
	17
	18	enum {
	19	CLPS711X_CLKSRC_CLOCKSOURCE,
	20	CLPS711X_CLKSRC_CLOCKEVENT,
	21	};
	22
	23	static void __iomem *tcd;
	24
	25	static u64 notrace clps711x_sched_clock_read(void)
	26	{
	27	return ~readw(tcd);
	28	}
	29
2a6a8e2d	30	static void __init clps711x_clksrc_init(struct clk clock, void __iomem base)
f0b7fabe	31	{
2a6a8e2d	32	unsigned long rate = clk_get_rate(clock);
f0b7fabe AS	33
	34	tcd = base;
	35
	36	clocksource_mmio_init(tcd, "clps711x-clocksource", rate, 300, 16,
	37	clocksource_mmio_readw_down);
	38
	39	sched_clock_register(clps711x_sched_clock_read, 16, rate);
f0b7fabe AS	40	}
	41
	42	static irqreturn_t clps711x_timer_interrupt(int irq, void *dev_id)
	43	{
	44	struct clock_event_device *evt = dev_id;
	45
	46	evt->event_handler(evt);
	47
	48	return IRQ_HANDLED;
	49	}
	50
f0b7fabe AS	51	static int __init _clps711x_clkevt_init(struct clk clock, void __iomem base,
	52	unsigned int irq)
	53	{
	54	struct clock_event_device *clkevt;
	55	unsigned long rate;
	56
f0b7fabe AS	57	clkevt = kzalloc(sizeof(*clkevt), GFP_KERNEL);
	58	if (!clkevt)
	59	return -ENOMEM;
	60
	61	rate = clk_get_rate(clock);
	62
	63	/* Set Timer prescaler */
	64	writew(DIV_ROUND_CLOSEST(rate, HZ), base);
	65
	66	clkevt->name = "clps711x-clockevent";
	67	clkevt->rating = 300;
	68	clkevt->features = CLOCK_EVT_FEAT_PERIODIC \| CLOCK_EVT_FEAT_C3STOP;
f0b7fabe AS	69	clkevt->cpumask = cpumask_of(0);
	70	clockevents_config_and_register(clkevt, HZ, 0, 0);
	71
	72	return request_irq(irq, clps711x_timer_interrupt, IRQF_TIMER,
	73	"clps711x-timer", clkevt);
	74	}
	75
04410efb	76	static int __init clps711x_timer_init(struct device_node *np)
f0b7fabe AS	77	{
	78	unsigned int irq = irq_of_parse_and_map(np, 0);
	79	struct clk *clock = of_clk_get(np, 0);
	80	void __iomem *base = of_iomap(np, 0);
	81
2a6a8e2d AS	82	if (!base)
	83	return -ENOMEM;
	84	if (!irq)
	85	return -EINVAL;
	86	if (IS_ERR(clock))
	87	return PTR_ERR(clock);
	88
f0b7fabe AS	89	switch (of_alias_get_id(np, "timer")) {
f0b7fabe AS	90	case CLPS711X_CLKSRC_CLOCKSOURCE:
2a6a8e2d AS	91	clps711x_clksrc_init(clock, base);
2a6a8e2d AS	92	break;
f0b7fabe	93	case CLPS711X_CLKSRC_CLOCKEVENT:
04410efb	94	return _clps711x_clkevt_init(clock, base, irq);
f0b7fabe	95	default:
04410efb	96	return -EINVAL;
f0b7fabe	97	}
2a6a8e2d AS	98
2a6a8e2d AS	99	return 0;
f0b7fabe	100	}
17273395	101	TIMER_OF_DECLARE(clps711x, "cirrus,ep7209-timer", clps711x_timer_init);