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