]>
Commit | Line | Data |
---|---|---|
38461c5c TR |
1 | /* |
2 | * Copyright (C) 2008-2009 Avionic Design GmbH | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License version 2 as | |
6 | * published by the Free Software Foundation. | |
7 | */ | |
8 | ||
9 | #include <linux/fs.h> | |
5a0e3ad6 | 10 | #include <linux/gfp.h> |
38461c5c TR |
11 | #include <linux/io.h> |
12 | #include <linux/miscdevice.h> | |
13 | #include <linux/module.h> | |
14 | #include <linux/platform_device.h> | |
15 | #include <linux/types.h> | |
16 | #include <linux/uaccess.h> | |
17 | #include <linux/watchdog.h> | |
18 | ||
19 | #define WATCHDOG_NAME "adx-wdt" | |
20 | ||
21 | /* register offsets */ | |
22 | #define ADX_WDT_CONTROL 0x00 | |
23 | #define ADX_WDT_CONTROL_ENABLE (1 << 0) | |
24 | #define ADX_WDT_CONTROL_nRESET (1 << 1) | |
25 | #define ADX_WDT_TIMEOUT 0x08 | |
26 | ||
27 | static struct platform_device *adx_wdt_dev; | |
28 | static unsigned long driver_open; | |
29 | ||
30 | #define WDT_STATE_STOP 0 | |
31 | #define WDT_STATE_START 1 | |
32 | ||
33 | struct adx_wdt { | |
34 | void __iomem *base; | |
35 | unsigned long timeout; | |
36 | unsigned int state; | |
37 | unsigned int wake; | |
38 | spinlock_t lock; | |
39 | }; | |
40 | ||
42747d71 | 41 | static const struct watchdog_info adx_wdt_info = { |
38461c5c TR |
42 | .identity = "Avionic Design Xanthos Watchdog", |
43 | .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING, | |
44 | }; | |
45 | ||
46 | static void adx_wdt_start_locked(struct adx_wdt *wdt) | |
47 | { | |
48 | u32 ctrl; | |
49 | ||
50 | ctrl = readl(wdt->base + ADX_WDT_CONTROL); | |
51 | ctrl |= ADX_WDT_CONTROL_ENABLE; | |
52 | writel(ctrl, wdt->base + ADX_WDT_CONTROL); | |
53 | wdt->state = WDT_STATE_START; | |
54 | } | |
55 | ||
56 | static void adx_wdt_start(struct adx_wdt *wdt) | |
57 | { | |
58 | unsigned long flags; | |
59 | ||
60 | spin_lock_irqsave(&wdt->lock, flags); | |
61 | adx_wdt_start_locked(wdt); | |
62 | spin_unlock_irqrestore(&wdt->lock, flags); | |
63 | } | |
64 | ||
65 | static void adx_wdt_stop_locked(struct adx_wdt *wdt) | |
66 | { | |
67 | u32 ctrl; | |
68 | ||
69 | ctrl = readl(wdt->base + ADX_WDT_CONTROL); | |
70 | ctrl &= ~ADX_WDT_CONTROL_ENABLE; | |
71 | writel(ctrl, wdt->base + ADX_WDT_CONTROL); | |
72 | wdt->state = WDT_STATE_STOP; | |
73 | } | |
74 | ||
75 | static void adx_wdt_stop(struct adx_wdt *wdt) | |
76 | { | |
77 | unsigned long flags; | |
78 | ||
79 | spin_lock_irqsave(&wdt->lock, flags); | |
80 | adx_wdt_stop_locked(wdt); | |
81 | spin_unlock_irqrestore(&wdt->lock, flags); | |
82 | } | |
83 | ||
84 | static void adx_wdt_set_timeout(struct adx_wdt *wdt, unsigned long seconds) | |
85 | { | |
86 | unsigned long timeout = seconds * 1000; | |
87 | unsigned long flags; | |
88 | unsigned int state; | |
89 | ||
90 | spin_lock_irqsave(&wdt->lock, flags); | |
91 | state = wdt->state; | |
92 | adx_wdt_stop_locked(wdt); | |
93 | writel(timeout, wdt->base + ADX_WDT_TIMEOUT); | |
94 | ||
95 | if (state == WDT_STATE_START) | |
96 | adx_wdt_start_locked(wdt); | |
97 | ||
98 | wdt->timeout = timeout; | |
99 | spin_unlock_irqrestore(&wdt->lock, flags); | |
100 | } | |
101 | ||
102 | static void adx_wdt_get_timeout(struct adx_wdt *wdt, unsigned long *seconds) | |
103 | { | |
104 | *seconds = wdt->timeout / 1000; | |
105 | } | |
106 | ||
107 | static void adx_wdt_keepalive(struct adx_wdt *wdt) | |
108 | { | |
109 | unsigned long flags; | |
110 | ||
111 | spin_lock_irqsave(&wdt->lock, flags); | |
112 | writel(wdt->timeout, wdt->base + ADX_WDT_TIMEOUT); | |
113 | spin_unlock_irqrestore(&wdt->lock, flags); | |
114 | } | |
115 | ||
116 | static int adx_wdt_open(struct inode *inode, struct file *file) | |
117 | { | |
118 | struct adx_wdt *wdt = platform_get_drvdata(adx_wdt_dev); | |
119 | ||
120 | if (test_and_set_bit(0, &driver_open)) | |
121 | return -EBUSY; | |
122 | ||
123 | file->private_data = wdt; | |
124 | adx_wdt_set_timeout(wdt, 30); | |
125 | adx_wdt_start(wdt); | |
126 | ||
127 | return nonseekable_open(inode, file); | |
128 | } | |
129 | ||
130 | static int adx_wdt_release(struct inode *inode, struct file *file) | |
131 | { | |
132 | struct adx_wdt *wdt = file->private_data; | |
133 | ||
134 | adx_wdt_stop(wdt); | |
135 | clear_bit(0, &driver_open); | |
136 | ||
137 | return 0; | |
138 | } | |
139 | ||
140 | static long adx_wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg) | |
141 | { | |
142 | struct adx_wdt *wdt = file->private_data; | |
143 | void __user *argp = (void __user *)arg; | |
144 | unsigned long __user *p = argp; | |
145 | unsigned long seconds = 0; | |
146 | unsigned int options; | |
147 | long ret = -EINVAL; | |
148 | ||
149 | switch (cmd) { | |
150 | case WDIOC_GETSUPPORT: | |
151 | if (copy_to_user(argp, &adx_wdt_info, sizeof(adx_wdt_info))) | |
152 | return -EFAULT; | |
153 | else | |
154 | return 0; | |
155 | ||
156 | case WDIOC_GETSTATUS: | |
157 | case WDIOC_GETBOOTSTATUS: | |
158 | return put_user(0, p); | |
159 | ||
160 | case WDIOC_KEEPALIVE: | |
161 | adx_wdt_keepalive(wdt); | |
162 | return 0; | |
163 | ||
164 | case WDIOC_SETTIMEOUT: | |
165 | if (get_user(seconds, p)) | |
166 | return -EFAULT; | |
167 | ||
168 | adx_wdt_set_timeout(wdt, seconds); | |
169 | ||
170 | /* fallthrough */ | |
171 | case WDIOC_GETTIMEOUT: | |
172 | adx_wdt_get_timeout(wdt, &seconds); | |
173 | return put_user(seconds, p); | |
174 | ||
175 | case WDIOC_SETOPTIONS: | |
176 | if (copy_from_user(&options, argp, sizeof(options))) | |
177 | return -EFAULT; | |
178 | ||
179 | if (options & WDIOS_DISABLECARD) { | |
180 | adx_wdt_stop(wdt); | |
181 | ret = 0; | |
182 | } | |
183 | ||
184 | if (options & WDIOS_ENABLECARD) { | |
185 | adx_wdt_start(wdt); | |
186 | ret = 0; | |
187 | } | |
188 | ||
189 | return ret; | |
190 | ||
191 | default: | |
192 | break; | |
193 | } | |
194 | ||
195 | return -ENOTTY; | |
196 | } | |
197 | ||
198 | static ssize_t adx_wdt_write(struct file *file, const char __user *data, | |
199 | size_t len, loff_t *ppos) | |
200 | { | |
201 | struct adx_wdt *wdt = file->private_data; | |
202 | ||
203 | if (len) | |
204 | adx_wdt_keepalive(wdt); | |
205 | ||
206 | return len; | |
207 | } | |
208 | ||
209 | static const struct file_operations adx_wdt_fops = { | |
210 | .owner = THIS_MODULE, | |
211 | .llseek = no_llseek, | |
212 | .open = adx_wdt_open, | |
213 | .release = adx_wdt_release, | |
214 | .unlocked_ioctl = adx_wdt_ioctl, | |
215 | .write = adx_wdt_write, | |
216 | }; | |
217 | ||
218 | static struct miscdevice adx_wdt_miscdev = { | |
219 | .minor = WATCHDOG_MINOR, | |
220 | .name = "watchdog", | |
221 | .fops = &adx_wdt_fops, | |
222 | }; | |
223 | ||
224 | static int __devinit adx_wdt_probe(struct platform_device *pdev) | |
225 | { | |
226 | struct resource *res; | |
227 | struct adx_wdt *wdt; | |
228 | int ret = 0; | |
229 | u32 ctrl; | |
230 | ||
231 | wdt = devm_kzalloc(&pdev->dev, sizeof(*wdt), GFP_KERNEL); | |
232 | if (!wdt) { | |
233 | dev_err(&pdev->dev, "cannot allocate WDT structure\n"); | |
234 | return -ENOMEM; | |
235 | } | |
236 | ||
237 | spin_lock_init(&wdt->lock); | |
238 | ||
239 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
240 | if (!res) { | |
241 | dev_err(&pdev->dev, "cannot obtain I/O memory region\n"); | |
242 | return -ENXIO; | |
243 | } | |
244 | ||
245 | res = devm_request_mem_region(&pdev->dev, res->start, | |
b782a563 | 246 | resource_size(res), res->name); |
38461c5c TR |
247 | if (!res) { |
248 | dev_err(&pdev->dev, "cannot request I/O memory region\n"); | |
249 | return -ENXIO; | |
250 | } | |
251 | ||
252 | wdt->base = devm_ioremap_nocache(&pdev->dev, res->start, | |
b782a563 | 253 | resource_size(res)); |
38461c5c TR |
254 | if (!wdt->base) { |
255 | dev_err(&pdev->dev, "cannot remap I/O memory region\n"); | |
256 | return -ENXIO; | |
257 | } | |
258 | ||
259 | /* disable watchdog and reboot on timeout */ | |
260 | ctrl = readl(wdt->base + ADX_WDT_CONTROL); | |
261 | ctrl &= ~ADX_WDT_CONTROL_ENABLE; | |
262 | ctrl &= ~ADX_WDT_CONTROL_nRESET; | |
263 | writel(ctrl, wdt->base + ADX_WDT_CONTROL); | |
264 | ||
265 | platform_set_drvdata(pdev, wdt); | |
266 | adx_wdt_dev = pdev; | |
267 | ||
268 | ret = misc_register(&adx_wdt_miscdev); | |
269 | if (ret) { | |
270 | dev_err(&pdev->dev, "cannot register miscdev on minor %d " | |
271 | "(err=%d)\n", WATCHDOG_MINOR, ret); | |
272 | return ret; | |
273 | } | |
274 | ||
275 | return 0; | |
276 | } | |
277 | ||
278 | static int __devexit adx_wdt_remove(struct platform_device *pdev) | |
279 | { | |
280 | struct adx_wdt *wdt = platform_get_drvdata(pdev); | |
281 | ||
282 | misc_deregister(&adx_wdt_miscdev); | |
283 | adx_wdt_stop(wdt); | |
284 | platform_set_drvdata(pdev, NULL); | |
285 | ||
286 | return 0; | |
287 | } | |
288 | ||
289 | static void adx_wdt_shutdown(struct platform_device *pdev) | |
290 | { | |
291 | struct adx_wdt *wdt = platform_get_drvdata(pdev); | |
292 | adx_wdt_stop(wdt); | |
293 | } | |
294 | ||
295 | #ifdef CONFIG_PM | |
296 | static int adx_wdt_suspend(struct device *dev) | |
297 | { | |
298 | struct platform_device *pdev = to_platform_device(dev); | |
299 | struct adx_wdt *wdt = platform_get_drvdata(pdev); | |
300 | ||
301 | wdt->wake = (wdt->state == WDT_STATE_START) ? 1 : 0; | |
302 | adx_wdt_stop(wdt); | |
303 | ||
304 | return 0; | |
305 | } | |
306 | ||
307 | static int adx_wdt_resume(struct device *dev) | |
308 | { | |
309 | struct platform_device *pdev = to_platform_device(dev); | |
310 | struct adx_wdt *wdt = platform_get_drvdata(pdev); | |
311 | ||
312 | if (wdt->wake) | |
313 | adx_wdt_start(wdt); | |
314 | ||
315 | return 0; | |
316 | } | |
317 | ||
47145210 | 318 | static const struct dev_pm_ops adx_wdt_pm_ops = { |
38461c5c TR |
319 | .suspend = adx_wdt_suspend, |
320 | .resume = adx_wdt_resume, | |
321 | }; | |
322 | ||
323 | # define ADX_WDT_PM_OPS (&adx_wdt_pm_ops) | |
324 | #else | |
325 | # define ADX_WDT_PM_OPS NULL | |
326 | #endif | |
327 | ||
328 | static struct platform_driver adx_wdt_driver = { | |
329 | .probe = adx_wdt_probe, | |
330 | .remove = __devexit_p(adx_wdt_remove), | |
331 | .shutdown = adx_wdt_shutdown, | |
332 | .driver = { | |
333 | .name = WATCHDOG_NAME, | |
334 | .owner = THIS_MODULE, | |
335 | .pm = ADX_WDT_PM_OPS, | |
336 | }, | |
337 | }; | |
338 | ||
339 | static int __init adx_wdt_init(void) | |
340 | { | |
341 | return platform_driver_register(&adx_wdt_driver); | |
342 | } | |
343 | ||
344 | static void __exit adx_wdt_exit(void) | |
345 | { | |
346 | platform_driver_unregister(&adx_wdt_driver); | |
347 | } | |
348 | ||
349 | module_init(adx_wdt_init); | |
350 | module_exit(adx_wdt_exit); | |
351 | ||
352 | MODULE_DESCRIPTION("Avionic Design Xanthos Watchdog Driver"); | |
353 | MODULE_LICENSE("GPL v2"); | |
354 | MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>"); | |
355 | MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); |