1/*
2 * Watchdog driver for Conexant Digicolor
3 *
4 * Copyright (C) 2015 Paradox Innovation Ltd.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2 of the License, or (at your
9 * option) any later version.
10 */
11
12#include <linux/types.h>
13#include <linux/module.h>
14#include <linux/io.h>
15#include <linux/delay.h>
16#include <linux/clk.h>
17#include <linux/watchdog.h>
18#include <linux/reboot.h>
19#include <linux/platform_device.h>
20#include <linux/of_address.h>
21
22#define TIMER_A_CONTROL		0
23#define TIMER_A_COUNT		4
24
25#define TIMER_A_ENABLE_COUNT	BIT(0)
26#define TIMER_A_ENABLE_WATCHDOG	BIT(1)
27
28struct dc_wdt {
29	void __iomem		*base;
30	struct clk		*clk;
31	struct notifier_block	restart_handler;
32	spinlock_t		lock;
33};
34
35static unsigned timeout;
36module_param(timeout, uint, 0);
37MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds");
38
39static void dc_wdt_set(struct dc_wdt *wdt, u32 ticks)
40{
41	unsigned long flags;
42
43	spin_lock_irqsave(&wdt->lock, flags);
44
45	writel_relaxed(0, wdt->base + TIMER_A_CONTROL);
46	writel_relaxed(ticks, wdt->base + TIMER_A_COUNT);
47	writel_relaxed(TIMER_A_ENABLE_COUNT | TIMER_A_ENABLE_WATCHDOG,
48		       wdt->base + TIMER_A_CONTROL);
49
50	spin_unlock_irqrestore(&wdt->lock, flags);
51}
52
53static int dc_restart_handler(struct notifier_block *this, unsigned long mode,
54			      void *cmd)
55{
56	struct dc_wdt *wdt = container_of(this, struct dc_wdt, restart_handler);
57
58	dc_wdt_set(wdt, 1);
59	/* wait for reset to assert... */
60	mdelay(500);
61
62	return NOTIFY_DONE;
63}
64
65static int dc_wdt_start(struct watchdog_device *wdog)
66{
67	struct dc_wdt *wdt = watchdog_get_drvdata(wdog);
68
69	dc_wdt_set(wdt, wdog->timeout * clk_get_rate(wdt->clk));
70
71	return 0;
72}
73
74static int dc_wdt_stop(struct watchdog_device *wdog)
75{
76	struct dc_wdt *wdt = watchdog_get_drvdata(wdog);
77
78	writel_relaxed(0, wdt->base + TIMER_A_CONTROL);
79
80	return 0;
81}
82
83static int dc_wdt_set_timeout(struct watchdog_device *wdog, unsigned int t)
84{
85	struct dc_wdt *wdt = watchdog_get_drvdata(wdog);
86
87	dc_wdt_set(wdt, t * clk_get_rate(wdt->clk));
88	wdog->timeout = t;
89
90	return 0;
91}
92
93static unsigned int dc_wdt_get_timeleft(struct watchdog_device *wdog)
94{
95	struct dc_wdt *wdt = watchdog_get_drvdata(wdog);
96	uint32_t count = readl_relaxed(wdt->base + TIMER_A_COUNT);
97
98	return count / clk_get_rate(wdt->clk);
99}
100
101static struct watchdog_ops dc_wdt_ops = {
102	.owner		= THIS_MODULE,
103	.start		= dc_wdt_start,
104	.stop		= dc_wdt_stop,
105	.set_timeout	= dc_wdt_set_timeout,
106	.get_timeleft	= dc_wdt_get_timeleft,
107};
108
109static struct watchdog_info dc_wdt_info = {
110	.options	= WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE
111			| WDIOF_KEEPALIVEPING,
112	.identity	= "Conexant Digicolor Watchdog",
113};
114
115static struct watchdog_device dc_wdt_wdd = {
116	.info		= &dc_wdt_info,
117	.ops		= &dc_wdt_ops,
118	.min_timeout	= 1,
119};
120
121static int dc_wdt_probe(struct platform_device *pdev)
122{
123	struct device *dev = &pdev->dev;
124	struct device_node *np = dev->of_node;
125	struct dc_wdt *wdt;
126	int ret;
127
128	wdt = devm_kzalloc(dev, sizeof(struct dc_wdt), GFP_KERNEL);
129	if (!wdt)
130		return -ENOMEM;
131	platform_set_drvdata(pdev, wdt);
132
133	wdt->base = of_iomap(np, 0);
134	if (!wdt->base) {
135		dev_err(dev, "Failed to remap watchdog regs");
136		return -ENODEV;
137	}
138
139	wdt->clk = devm_clk_get(&pdev->dev, NULL);
140	if (IS_ERR(wdt->clk)) {
141		ret = PTR_ERR(wdt->clk);
142		goto err_iounmap;
143	}
144	dc_wdt_wdd.max_timeout = U32_MAX / clk_get_rate(wdt->clk);
145	dc_wdt_wdd.timeout = dc_wdt_wdd.max_timeout;
146	dc_wdt_wdd.parent = &pdev->dev;
147
148	spin_lock_init(&wdt->lock);
149
150	watchdog_set_drvdata(&dc_wdt_wdd, wdt);
151	watchdog_init_timeout(&dc_wdt_wdd, timeout, dev);
152	ret = watchdog_register_device(&dc_wdt_wdd);
153	if (ret) {
154		dev_err(dev, "Failed to register watchdog device");
155		goto err_iounmap;
156	}
157
158	wdt->restart_handler.notifier_call = dc_restart_handler;
159	wdt->restart_handler.priority = 128;
160	ret = register_restart_handler(&wdt->restart_handler);
161	if (ret)
162		dev_warn(&pdev->dev, "cannot register restart handler\n");
163
164	return 0;
165
166err_iounmap:
167	iounmap(wdt->base);
168	return ret;
169}
170
171static int dc_wdt_remove(struct platform_device *pdev)
172{
173	struct dc_wdt *wdt = platform_get_drvdata(pdev);
174
175	unregister_restart_handler(&wdt->restart_handler);
176	watchdog_unregister_device(&dc_wdt_wdd);
177	iounmap(wdt->base);
178
179	return 0;
180}
181
182static void dc_wdt_shutdown(struct platform_device *pdev)
183{
184	dc_wdt_stop(&dc_wdt_wdd);
185}
186
187static const struct of_device_id dc_wdt_of_match[] = {
188	{ .compatible = "cnxt,cx92755-wdt", },
189	{},
190};
191MODULE_DEVICE_TABLE(of, dc_wdt_of_match);
192
193static struct platform_driver dc_wdt_driver = {
194	.probe		= dc_wdt_probe,
195	.remove		= dc_wdt_remove,
196	.shutdown	= dc_wdt_shutdown,
197	.driver = {
198		.name =		"digicolor-wdt",
199		.of_match_table = dc_wdt_of_match,
200	},
201};
202module_platform_driver(dc_wdt_driver);
203
204MODULE_AUTHOR("Baruch Siach <baruch@tkos.co.il>");
205MODULE_DESCRIPTION("Driver for Conexant Digicolor watchdog timer");
206MODULE_LICENSE("GPL");
207