2 * drivers/watchdog/orion_wdt.c
4 * Watchdog driver for Orion/Kirkwood processors
6 * Author: Sylver Bruneau <sylver.bruneau@googlemail.com>
8 * This file is licensed under the terms of the GNU General Public
9 * License version 2. This program is licensed "as is" without any
10 * warranty of any kind, whether express or implied.
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 #include <linux/module.h>
16 #include <linux/moduleparam.h>
17 #include <linux/types.h>
18 #include <linux/kernel.h>
19 #include <linux/miscdevice.h>
20 #include <linux/platform_device.h>
21 #include <linux/watchdog.h>
22 #include <linux/init.h>
24 #include <linux/spinlock.h>
25 #include <linux/clk.h>
26 #include <linux/err.h>
28 #include <mach/bridge-regs.h>
31 * Watchdog timer block registers.
33 #define TIMER_CTRL 0x0000
35 #define WDT_VAL 0x0024
37 #define WDT_MAX_CYCLE_COUNT 0xffffffff
39 #define WDT_OK_TO_CLOSE 1
41 #define WDT_RESET_OUT_EN BIT(1)
42 #define WDT_INT_REQ BIT(3)
44 static bool nowayout = WATCHDOG_NOWAYOUT;
45 static int heartbeat = -1; /* module parameter (seconds) */
46 static unsigned int wdt_max_duration; /* (seconds) */
47 static struct clk *clk;
48 static unsigned int wdt_tclk;
49 static void __iomem *wdt_reg;
50 static DEFINE_SPINLOCK(wdt_lock);
52 static int orion_wdt_ping(struct watchdog_device *wdt_dev)
56 /* Reload watchdog duration */
57 writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL);
59 spin_unlock(&wdt_lock);
63 static int orion_wdt_start(struct watchdog_device *wdt_dev)
69 /* Set watchdog duration */
70 writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL);
72 /* Clear watchdog timer interrupt */
73 reg = readl(BRIDGE_CAUSE);
75 writel(reg, BRIDGE_CAUSE);
77 /* Enable watchdog timer */
78 reg = readl(wdt_reg + TIMER_CTRL);
80 writel(reg, wdt_reg + TIMER_CTRL);
82 /* Enable reset on watchdog */
83 reg = readl(RSTOUTn_MASK);
84 reg |= WDT_RESET_OUT_EN;
85 writel(reg, RSTOUTn_MASK);
87 spin_unlock(&wdt_lock);
91 static int orion_wdt_stop(struct watchdog_device *wdt_dev)
97 /* Disable reset on watchdog */
98 reg = readl(RSTOUTn_MASK);
99 reg &= ~WDT_RESET_OUT_EN;
100 writel(reg, RSTOUTn_MASK);
102 /* Disable watchdog timer */
103 reg = readl(wdt_reg + TIMER_CTRL);
105 writel(reg, wdt_reg + TIMER_CTRL);
107 spin_unlock(&wdt_lock);
111 static unsigned int orion_wdt_get_timeleft(struct watchdog_device *wdt_dev)
113 unsigned int time_left;
115 spin_lock(&wdt_lock);
116 time_left = readl(wdt_reg + WDT_VAL) / wdt_tclk;
117 spin_unlock(&wdt_lock);
122 static int orion_wdt_set_timeout(struct watchdog_device *wdt_dev,
123 unsigned int timeout)
125 wdt_dev->timeout = timeout;
129 static const struct watchdog_info orion_wdt_info = {
130 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
131 .identity = "Orion Watchdog",
134 static const struct watchdog_ops orion_wdt_ops = {
135 .owner = THIS_MODULE,
136 .start = orion_wdt_start,
137 .stop = orion_wdt_stop,
138 .ping = orion_wdt_ping,
139 .set_timeout = orion_wdt_set_timeout,
140 .get_timeleft = orion_wdt_get_timeleft,
143 static struct watchdog_device orion_wdt = {
144 .info = &orion_wdt_info,
145 .ops = &orion_wdt_ops,
149 static int orion_wdt_probe(struct platform_device *pdev)
151 struct resource *res;
154 clk = devm_clk_get(&pdev->dev, NULL);
156 dev_err(&pdev->dev, "Orion Watchdog missing clock\n");
159 clk_prepare_enable(clk);
160 wdt_tclk = clk_get_rate(clk);
162 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
165 wdt_reg = devm_ioremap(&pdev->dev, res->start, resource_size(res));
169 wdt_max_duration = WDT_MAX_CYCLE_COUNT / wdt_tclk;
171 orion_wdt.timeout = wdt_max_duration;
172 orion_wdt.max_timeout = wdt_max_duration;
173 watchdog_init_timeout(&orion_wdt, heartbeat, &pdev->dev);
175 watchdog_set_nowayout(&orion_wdt, nowayout);
176 ret = watchdog_register_device(&orion_wdt);
178 clk_disable_unprepare(clk);
182 pr_info("Initial timeout %d sec%s\n",
183 orion_wdt.timeout, nowayout ? ", nowayout" : "");
187 static int orion_wdt_remove(struct platform_device *pdev)
189 watchdog_unregister_device(&orion_wdt);
190 clk_disable_unprepare(clk);
194 static void orion_wdt_shutdown(struct platform_device *pdev)
196 orion_wdt_stop(&orion_wdt);
199 static const struct of_device_id orion_wdt_of_match_table[] = {
200 { .compatible = "marvell,orion-wdt", },
203 MODULE_DEVICE_TABLE(of, orion_wdt_of_match_table);
205 static struct platform_driver orion_wdt_driver = {
206 .probe = orion_wdt_probe,
207 .remove = orion_wdt_remove,
208 .shutdown = orion_wdt_shutdown,
210 .owner = THIS_MODULE,
212 .of_match_table = of_match_ptr(orion_wdt_of_match_table),
216 module_platform_driver(orion_wdt_driver);
218 MODULE_AUTHOR("Sylver Bruneau <sylver.bruneau@googlemail.com>");
219 MODULE_DESCRIPTION("Orion Processor Watchdog");
221 module_param(heartbeat, int, 0);
222 MODULE_PARM_DESC(heartbeat, "Initial watchdog heartbeat in seconds");
224 module_param(nowayout, bool, 0);
225 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
226 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
228 MODULE_LICENSE("GPL");
229 MODULE_ALIAS("platform:orion_wdt");
230 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);