]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/watchdog/orion_wdt.c
watchdog: Orion: Fix possible null-deference in orion_wdt_probe
[~shefty/rdma-dev.git] / drivers / watchdog / orion_wdt.c
1 /*
2  * drivers/watchdog/orion_wdt.c
3  *
4  * Watchdog driver for Orion/Kirkwood processors
5  *
6  * Author: Sylver Bruneau <sylver.bruneau@googlemail.com>
7  *
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.
11  */
12
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
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>
23 #include <linux/io.h>
24 #include <linux/spinlock.h>
25 #include <linux/clk.h>
26 #include <linux/err.h>
27 #include <linux/of.h>
28 #include <mach/bridge-regs.h>
29
30 /*
31  * Watchdog timer block registers.
32  */
33 #define TIMER_CTRL              0x0000
34 #define WDT_EN                  0x0010
35 #define WDT_VAL                 0x0024
36
37 #define WDT_MAX_CYCLE_COUNT     0xffffffff
38 #define WDT_IN_USE              0
39 #define WDT_OK_TO_CLOSE         1
40
41 static bool nowayout = WATCHDOG_NOWAYOUT;
42 static int heartbeat = -1;              /* module parameter (seconds) */
43 static unsigned int wdt_max_duration;   /* (seconds) */
44 static struct clk *clk;
45 static unsigned int wdt_tclk;
46 static void __iomem *wdt_reg;
47 static DEFINE_SPINLOCK(wdt_lock);
48
49 static int orion_wdt_ping(struct watchdog_device *wdt_dev)
50 {
51         spin_lock(&wdt_lock);
52
53         /* Reload watchdog duration */
54         writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL);
55
56         spin_unlock(&wdt_lock);
57         return 0;
58 }
59
60 static int orion_wdt_start(struct watchdog_device *wdt_dev)
61 {
62         u32 reg;
63
64         spin_lock(&wdt_lock);
65
66         /* Set watchdog duration */
67         writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL);
68
69         /* Clear watchdog timer interrupt */
70         reg = readl(BRIDGE_CAUSE);
71         reg &= ~WDT_INT_REQ;
72         writel(reg, BRIDGE_CAUSE);
73
74         /* Enable watchdog timer */
75         reg = readl(wdt_reg + TIMER_CTRL);
76         reg |= WDT_EN;
77         writel(reg, wdt_reg + TIMER_CTRL);
78
79         /* Enable reset on watchdog */
80         reg = readl(RSTOUTn_MASK);
81         reg |= WDT_RESET_OUT_EN;
82         writel(reg, RSTOUTn_MASK);
83
84         spin_unlock(&wdt_lock);
85         return 0;
86 }
87
88 static int orion_wdt_stop(struct watchdog_device *wdt_dev)
89 {
90         u32 reg;
91
92         spin_lock(&wdt_lock);
93
94         /* Disable reset on watchdog */
95         reg = readl(RSTOUTn_MASK);
96         reg &= ~WDT_RESET_OUT_EN;
97         writel(reg, RSTOUTn_MASK);
98
99         /* Disable watchdog timer */
100         reg = readl(wdt_reg + TIMER_CTRL);
101         reg &= ~WDT_EN;
102         writel(reg, wdt_reg + TIMER_CTRL);
103
104         spin_unlock(&wdt_lock);
105         return 0;
106 }
107
108 static unsigned int orion_wdt_get_timeleft(struct watchdog_device *wdt_dev)
109 {
110         unsigned int time_left;
111
112         spin_lock(&wdt_lock);
113         time_left = readl(wdt_reg + WDT_VAL) / wdt_tclk;
114         spin_unlock(&wdt_lock);
115
116         return time_left;
117 }
118
119 static int orion_wdt_set_timeout(struct watchdog_device *wdt_dev,
120                                  unsigned int timeout)
121 {
122         wdt_dev->timeout = timeout;
123         return 0;
124 }
125
126 static const struct watchdog_info orion_wdt_info = {
127         .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
128         .identity = "Orion Watchdog",
129 };
130
131 static const struct watchdog_ops orion_wdt_ops = {
132         .owner = THIS_MODULE,
133         .start = orion_wdt_start,
134         .stop = orion_wdt_stop,
135         .ping = orion_wdt_ping,
136         .set_timeout = orion_wdt_set_timeout,
137         .get_timeleft = orion_wdt_get_timeleft,
138 };
139
140 static struct watchdog_device orion_wdt = {
141         .info = &orion_wdt_info,
142         .ops = &orion_wdt_ops,
143 };
144
145 static int orion_wdt_probe(struct platform_device *pdev)
146 {
147         struct resource *res;
148         int ret;
149
150         clk = devm_clk_get(&pdev->dev, NULL);
151         if (IS_ERR(clk)) {
152                 dev_err(&pdev->dev, "Orion Watchdog missing clock\n");
153                 return -ENODEV;
154         }
155         clk_prepare_enable(clk);
156         wdt_tclk = clk_get_rate(clk);
157
158         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
159         if (!res)
160                 return -ENODEV;
161         wdt_reg = devm_ioremap(&pdev->dev, res->start, resource_size(res));
162         if (!wdt_reg)
163                 return -ENOMEM;
164
165         wdt_max_duration = WDT_MAX_CYCLE_COUNT / wdt_tclk;
166
167         if ((heartbeat < 1) || (heartbeat > wdt_max_duration))
168                 heartbeat = wdt_max_duration;
169
170         orion_wdt.timeout = heartbeat;
171         orion_wdt.min_timeout = 1;
172         orion_wdt.max_timeout = wdt_max_duration;
173
174         watchdog_set_nowayout(&orion_wdt, nowayout);
175         ret = watchdog_register_device(&orion_wdt);
176         if (ret) {
177                 clk_disable_unprepare(clk);
178                 return ret;
179         }
180
181         pr_info("Initial timeout %d sec%s\n",
182                 heartbeat, nowayout ? ", nowayout" : "");
183         return 0;
184 }
185
186 static int orion_wdt_remove(struct platform_device *pdev)
187 {
188         watchdog_unregister_device(&orion_wdt);
189         clk_disable_unprepare(clk);
190         return 0;
191 }
192
193 static void orion_wdt_shutdown(struct platform_device *pdev)
194 {
195         orion_wdt_stop(&orion_wdt);
196 }
197
198 static const struct of_device_id orion_wdt_of_match_table[] = {
199         { .compatible = "marvell,orion-wdt", },
200         {},
201 };
202 MODULE_DEVICE_TABLE(of, orion_wdt_of_match_table);
203
204 static struct platform_driver orion_wdt_driver = {
205         .probe          = orion_wdt_probe,
206         .remove         = orion_wdt_remove,
207         .shutdown       = orion_wdt_shutdown,
208         .driver         = {
209                 .owner  = THIS_MODULE,
210                 .name   = "orion_wdt",
211                 .of_match_table = of_match_ptr(orion_wdt_of_match_table),
212         },
213 };
214
215 module_platform_driver(orion_wdt_driver);
216
217 MODULE_AUTHOR("Sylver Bruneau <sylver.bruneau@googlemail.com>");
218 MODULE_DESCRIPTION("Orion Processor Watchdog");
219
220 module_param(heartbeat, int, 0);
221 MODULE_PARM_DESC(heartbeat, "Initial watchdog heartbeat in seconds");
222
223 module_param(nowayout, bool, 0);
224 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
225                                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
226
227 MODULE_LICENSE("GPL");
228 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);