[linux-2.6-block.git] / drivers / watchdog / digicolor_wdt.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Watchdog driver for Conexant Digicolor
 *
 * Copyright (C) 2015 Paradox Innovation Ltd.
 *
 */

#include <linux/types.h>
#include <linux/module.h>
#include <linux/io.h>
#include <linux/delay.h>
#include <linux/clk.h>
#include <linux/watchdog.h>
#include <linux/platform_device.h>
#include <linux/of_address.h>

#define TIMER_A_CONTROL		0
#define TIMER_A_COUNT		4

#define TIMER_A_ENABLE_COUNT	BIT(0)
#define TIMER_A_ENABLE_WATCHDOG	BIT(1)

struct dc_wdt {
	void __iomem		*base;
	struct clk		*clk;
	spinlock_t		lock;
};

static unsigned timeout;
module_param(timeout, uint, 0);
MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds");

static void dc_wdt_set(struct dc_wdt *wdt, u32 ticks)
{
	unsigned long flags;

	spin_lock_irqsave(&wdt->lock, flags);

	writel_relaxed(0, wdt->base + TIMER_A_CONTROL);
	writel_relaxed(ticks, wdt->base + TIMER_A_COUNT);
	writel_relaxed(TIMER_A_ENABLE_COUNT | TIMER_A_ENABLE_WATCHDOG,
		       wdt->base + TIMER_A_CONTROL);

	spin_unlock_irqrestore(&wdt->lock, flags);
}

static int dc_wdt_restart(struct watchdog_device *wdog, unsigned long action,
			  void *data)
{
	struct dc_wdt *wdt = watchdog_get_drvdata(wdog);

	dc_wdt_set(wdt, 1);
	/* wait for reset to assert... */
	mdelay(500);

	return 0;
}

static int dc_wdt_start(struct watchdog_device *wdog)
{
	struct dc_wdt *wdt = watchdog_get_drvdata(wdog);

	dc_wdt_set(wdt, wdog->timeout * clk_get_rate(wdt->clk));

	return 0;
}

static int dc_wdt_stop(struct watchdog_device *wdog)
{
	struct dc_wdt *wdt = watchdog_get_drvdata(wdog);

	writel_relaxed(0, wdt->base + TIMER_A_CONTROL);

	return 0;
}

static int dc_wdt_set_timeout(struct watchdog_device *wdog, unsigned int t)
{
	struct dc_wdt *wdt = watchdog_get_drvdata(wdog);

	dc_wdt_set(wdt, t * clk_get_rate(wdt->clk));
	wdog->timeout = t;

	return 0;
}

static unsigned int dc_wdt_get_timeleft(struct watchdog_device *wdog)
{
	struct dc_wdt *wdt = watchdog_get_drvdata(wdog);
	uint32_t count = readl_relaxed(wdt->base + TIMER_A_COUNT);

	return count / clk_get_rate(wdt->clk);
}

static const struct watchdog_ops dc_wdt_ops = {
	.owner		= THIS_MODULE,
	.start		= dc_wdt_start,
	.stop		= dc_wdt_stop,
	.set_timeout	= dc_wdt_set_timeout,
	.get_timeleft	= dc_wdt_get_timeleft,
	.restart        = dc_wdt_restart,
};

static const struct watchdog_info dc_wdt_info = {
	.options	= WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE
			| WDIOF_KEEPALIVEPING,
	.identity	= "Conexant Digicolor Watchdog",
};

static struct watchdog_device dc_wdt_wdd = {
	.info		= &dc_wdt_info,
	.ops		= &dc_wdt_ops,
	.min_timeout	= 1,
};

static int dc_wdt_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct dc_wdt *wdt;

	wdt = devm_kzalloc(dev, sizeof(struct dc_wdt), GFP_KERNEL);
	if (!wdt)
		return -ENOMEM;

	wdt->base = devm_platform_ioremap_resource(pdev, 0);
	if (IS_ERR(wdt->base))
		return PTR_ERR(wdt->base);

	wdt->clk = devm_clk_get(dev, NULL);
	if (IS_ERR(wdt->clk))
		return PTR_ERR(wdt->clk);
	dc_wdt_wdd.max_timeout = U32_MAX / clk_get_rate(wdt->clk);
	dc_wdt_wdd.timeout = dc_wdt_wdd.max_timeout;
	dc_wdt_wdd.parent = dev;

	spin_lock_init(&wdt->lock);

	watchdog_set_drvdata(&dc_wdt_wdd, wdt);
	watchdog_set_restart_priority(&dc_wdt_wdd, 128);
	watchdog_init_timeout(&dc_wdt_wdd, timeout, dev);
	watchdog_stop_on_reboot(&dc_wdt_wdd);
	return devm_watchdog_register_device(dev, &dc_wdt_wdd);
}

static const struct of_device_id dc_wdt_of_match[] = {
	{ .compatible = "cnxt,cx92755-wdt", },
	{},
};
MODULE_DEVICE_TABLE(of, dc_wdt_of_match);

static struct platform_driver dc_wdt_driver = {
	.probe		= dc_wdt_probe,
	.driver = {
		.name =		"digicolor-wdt",
		.of_match_table = dc_wdt_of_match,
	},
};
module_platform_driver(dc_wdt_driver);

MODULE_AUTHOR("Baruch Siach <baruch@tkos.co.il>");
MODULE_DESCRIPTION("Driver for Conexant Digicolor watchdog timer");
MODULE_LICENSE("GPL");
Commit	Line	Data
2e62c498	1	// SPDX-License-Identifier: GPL-2.0+
336694a0 BS	2	/*
	3	* Watchdog driver for Conexant Digicolor
	4	*
	5	* Copyright (C) 2015 Paradox Innovation Ltd.
	6	*
336694a0 BS	7	*/
	8
	9	#include <linux/types.h>
	10	#include <linux/module.h>
	11	#include <linux/io.h>
	12	#include <linux/delay.h>
	13	#include <linux/clk.h>
	14	#include <linux/watchdog.h>
336694a0 BS	15	#include <linux/platform_device.h>
	16	#include <linux/of_address.h>
	17
	18	#define TIMER_A_CONTROL 0
	19	#define TIMER_A_COUNT 4
	20
	21	#define TIMER_A_ENABLE_COUNT BIT(0)
	22	#define TIMER_A_ENABLE_WATCHDOG BIT(1)
	23
	24	struct dc_wdt {
	25	void __iomem *base;
	26	struct clk *clk;
336694a0 BS	27	spinlock_t lock;
	28	};
	29
	30	static unsigned timeout;
	31	module_param(timeout, uint, 0);
	32	MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds");
	33
	34	static void dc_wdt_set(struct dc_wdt *wdt, u32 ticks)
	35	{
	36	unsigned long flags;
	37
	38	spin_lock_irqsave(&wdt->lock, flags);
	39
	40	writel_relaxed(0, wdt->base + TIMER_A_CONTROL);
	41	writel_relaxed(ticks, wdt->base + TIMER_A_COUNT);
	42	writel_relaxed(TIMER_A_ENABLE_COUNT \| TIMER_A_ENABLE_WATCHDOG,
	43	wdt->base + TIMER_A_CONTROL);
	44
	45	spin_unlock_irqrestore(&wdt->lock, flags);
	46	}
	47
4d8b229d GR	48	static int dc_wdt_restart(struct watchdog_device *wdog, unsigned long action,
4d8b229d GR	49	void *data)
336694a0	50	{
d3b08185	51	struct dc_wdt *wdt = watchdog_get_drvdata(wdog);
336694a0 BS	52
	53	dc_wdt_set(wdt, 1);
	54	/* wait for reset to assert... */
	55	mdelay(500);
	56
d3b08185	57	return 0;
336694a0 BS	58	}
	59
	60	static int dc_wdt_start(struct watchdog_device *wdog)
	61	{
	62	struct dc_wdt *wdt = watchdog_get_drvdata(wdog);
	63
	64	dc_wdt_set(wdt, wdog->timeout * clk_get_rate(wdt->clk));
	65
	66	return 0;
	67	}
	68
	69	static int dc_wdt_stop(struct watchdog_device *wdog)
	70	{
	71	struct dc_wdt *wdt = watchdog_get_drvdata(wdog);
	72
	73	writel_relaxed(0, wdt->base + TIMER_A_CONTROL);
	74
	75	return 0;
	76	}
	77
	78	static int dc_wdt_set_timeout(struct watchdog_device *wdog, unsigned int t)
	79	{
	80	struct dc_wdt *wdt = watchdog_get_drvdata(wdog);
	81
	82	dc_wdt_set(wdt, t * clk_get_rate(wdt->clk));
	83	wdog->timeout = t;
	84
	85	return 0;
	86	}
	87
	88	static unsigned int dc_wdt_get_timeleft(struct watchdog_device *wdog)
	89	{
	90	struct dc_wdt *wdt = watchdog_get_drvdata(wdog);
	91	uint32_t count = readl_relaxed(wdt->base + TIMER_A_COUNT);
	92
	93	return count / clk_get_rate(wdt->clk);
	94	}
	95
b893e344	96	static const struct watchdog_ops dc_wdt_ops = {
336694a0 BS	97	.owner = THIS_MODULE,
	98	.start = dc_wdt_start,
	99	.stop = dc_wdt_stop,
	100	.set_timeout = dc_wdt_set_timeout,
	101	.get_timeleft = dc_wdt_get_timeleft,
d3b08185	102	.restart = dc_wdt_restart,
336694a0 BS	103	};
336694a0 BS	104
6c368932	105	static const struct watchdog_info dc_wdt_info = {
336694a0 BS	106	.options = WDIOF_SETTIMEOUT \| WDIOF_MAGICCLOSE
	107	\| WDIOF_KEEPALIVEPING,
	108	.identity = "Conexant Digicolor Watchdog",
	109	};
	110
	111	static struct watchdog_device dc_wdt_wdd = {
	112	.info = &dc_wdt_info,
	113	.ops = &dc_wdt_ops,
	114	.min_timeout = 1,
	115	};
	116
	117	static int dc_wdt_probe(struct platform_device *pdev)
	118	{
	119	struct device *dev = &pdev->dev;
336694a0	120	struct dc_wdt *wdt;
336694a0 BS	121
	122	wdt = devm_kzalloc(dev, sizeof(struct dc_wdt), GFP_KERNEL);
	123	if (!wdt)
	124	return -ENOMEM;
336694a0	125
0f0a6a28	126	wdt->base = devm_platform_ioremap_resource(pdev, 0);
dd36f6ce GR	127	if (IS_ERR(wdt->base))
dd36f6ce GR	128	return PTR_ERR(wdt->base);
336694a0	129
dd36f6ce GR	130	wdt->clk = devm_clk_get(dev, NULL);
	131	if (IS_ERR(wdt->clk))
	132	return PTR_ERR(wdt->clk);
336694a0 BS	133	dc_wdt_wdd.max_timeout = U32_MAX / clk_get_rate(wdt->clk);
336694a0 BS	134	dc_wdt_wdd.timeout = dc_wdt_wdd.max_timeout;
dd36f6ce	135	dc_wdt_wdd.parent = dev;
336694a0 BS	136
	137	spin_lock_init(&wdt->lock);
	138
	139	watchdog_set_drvdata(&dc_wdt_wdd, wdt);
d3b08185	140	watchdog_set_restart_priority(&dc_wdt_wdd, 128);
336694a0	141	watchdog_init_timeout(&dc_wdt_wdd, timeout, dev);
dd36f6ce	142	watchdog_stop_on_reboot(&dc_wdt_wdd);
cdad2697	143	return devm_watchdog_register_device(dev, &dc_wdt_wdd);
336694a0 BS	144	}
	145
	146	static const struct of_device_id dc_wdt_of_match[] = {
	147	{ .compatible = "cnxt,cx92755-wdt", },
	148	{},
	149	};
	150	MODULE_DEVICE_TABLE(of, dc_wdt_of_match);
	151
	152	static struct platform_driver dc_wdt_driver = {
	153	.probe = dc_wdt_probe,
336694a0 BS	154	.driver = {
	155	.name = "digicolor-wdt",
	156	.of_match_table = dc_wdt_of_match,
	157	},
	158	};
	159	module_platform_driver(dc_wdt_driver);
	160
	161	MODULE_AUTHOR("Baruch Siach <baruch@tkos.co.il>");
	162	MODULE_DESCRIPTION("Driver for Conexant Digicolor watchdog timer");
	163	MODULE_LICENSE("GPL");