Root/
1 | /* |
2 | * watchdog_dev.c |
3 | * |
4 | * (c) Copyright 2008-2011 Alan Cox <alan@lxorguk.ukuu.org.uk>, |
5 | * All Rights Reserved. |
6 | * |
7 | * (c) Copyright 2008-2011 Wim Van Sebroeck <wim@iguana.be>. |
8 | * |
9 | * |
10 | * This source code is part of the generic code that can be used |
11 | * by all the watchdog timer drivers. |
12 | * |
13 | * This part of the generic code takes care of the following |
14 | * misc device: /dev/watchdog. |
15 | * |
16 | * Based on source code of the following authors: |
17 | * Matt Domsch <Matt_Domsch@dell.com>, |
18 | * Rob Radez <rob@osinvestor.com>, |
19 | * Rusty Lynch <rusty@linux.co.intel.com> |
20 | * Satyam Sharma <satyam@infradead.org> |
21 | * Randy Dunlap <randy.dunlap@oracle.com> |
22 | * |
23 | * This program is free software; you can redistribute it and/or |
24 | * modify it under the terms of the GNU General Public License |
25 | * as published by the Free Software Foundation; either version |
26 | * 2 of the License, or (at your option) any later version. |
27 | * |
28 | * Neither Alan Cox, CymruNet Ltd., Wim Van Sebroeck nor Iguana vzw. |
29 | * admit liability nor provide warranty for any of this software. |
30 | * This material is provided "AS-IS" and at no charge. |
31 | */ |
32 | |
33 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
34 | |
35 | #include <linux/module.h> /* For module stuff/... */ |
36 | #include <linux/types.h> /* For standard types (like size_t) */ |
37 | #include <linux/errno.h> /* For the -ENODEV/... values */ |
38 | #include <linux/kernel.h> /* For printk/panic/... */ |
39 | #include <linux/fs.h> /* For file operations */ |
40 | #include <linux/watchdog.h> /* For watchdog specific items */ |
41 | #include <linux/miscdevice.h> /* For handling misc devices */ |
42 | #include <linux/init.h> /* For __init/__exit/... */ |
43 | #include <linux/uaccess.h> /* For copy_to_user/put_user/... */ |
44 | |
45 | #include "watchdog_core.h" |
46 | |
47 | /* the dev_t structure to store the dynamically allocated watchdog devices */ |
48 | static dev_t watchdog_devt; |
49 | /* the watchdog device behind /dev/watchdog */ |
50 | static struct watchdog_device *old_wdd; |
51 | |
52 | /* |
53 | * watchdog_ping: ping the watchdog. |
54 | * @wddev: the watchdog device to ping |
55 | * |
56 | * If the watchdog has no own ping operation then it needs to be |
57 | * restarted via the start operation. This wrapper function does |
58 | * exactly that. |
59 | * We only ping when the watchdog device is running. |
60 | */ |
61 | |
62 | static int watchdog_ping(struct watchdog_device *wddev) |
63 | { |
64 | int err = 0; |
65 | |
66 | mutex_lock(&wddev->lock); |
67 | |
68 | if (test_bit(WDOG_UNREGISTERED, &wddev->status)) { |
69 | err = -ENODEV; |
70 | goto out_ping; |
71 | } |
72 | |
73 | if (!watchdog_active(wddev)) |
74 | goto out_ping; |
75 | |
76 | if (wddev->ops->ping) |
77 | err = wddev->ops->ping(wddev); /* ping the watchdog */ |
78 | else |
79 | err = wddev->ops->start(wddev); /* restart watchdog */ |
80 | |
81 | out_ping: |
82 | mutex_unlock(&wddev->lock); |
83 | return err; |
84 | } |
85 | |
86 | /* |
87 | * watchdog_start: wrapper to start the watchdog. |
88 | * @wddev: the watchdog device to start |
89 | * |
90 | * Start the watchdog if it is not active and mark it active. |
91 | * This function returns zero on success or a negative errno code for |
92 | * failure. |
93 | */ |
94 | |
95 | static int watchdog_start(struct watchdog_device *wddev) |
96 | { |
97 | int err = 0; |
98 | |
99 | mutex_lock(&wddev->lock); |
100 | |
101 | if (test_bit(WDOG_UNREGISTERED, &wddev->status)) { |
102 | err = -ENODEV; |
103 | goto out_start; |
104 | } |
105 | |
106 | if (watchdog_active(wddev)) |
107 | goto out_start; |
108 | |
109 | err = wddev->ops->start(wddev); |
110 | if (err == 0) |
111 | set_bit(WDOG_ACTIVE, &wddev->status); |
112 | |
113 | out_start: |
114 | mutex_unlock(&wddev->lock); |
115 | return err; |
116 | } |
117 | |
118 | /* |
119 | * watchdog_stop: wrapper to stop the watchdog. |
120 | * @wddev: the watchdog device to stop |
121 | * |
122 | * Stop the watchdog if it is still active and unmark it active. |
123 | * This function returns zero on success or a negative errno code for |
124 | * failure. |
125 | * If the 'nowayout' feature was set, the watchdog cannot be stopped. |
126 | */ |
127 | |
128 | static int watchdog_stop(struct watchdog_device *wddev) |
129 | { |
130 | int err = 0; |
131 | |
132 | mutex_lock(&wddev->lock); |
133 | |
134 | if (test_bit(WDOG_UNREGISTERED, &wddev->status)) { |
135 | err = -ENODEV; |
136 | goto out_stop; |
137 | } |
138 | |
139 | if (!watchdog_active(wddev)) |
140 | goto out_stop; |
141 | |
142 | if (test_bit(WDOG_NO_WAY_OUT, &wddev->status)) { |
143 | dev_info(wddev->dev, "nowayout prevents watchdog being stopped!\n"); |
144 | err = -EBUSY; |
145 | goto out_stop; |
146 | } |
147 | |
148 | err = wddev->ops->stop(wddev); |
149 | if (err == 0) |
150 | clear_bit(WDOG_ACTIVE, &wddev->status); |
151 | |
152 | out_stop: |
153 | mutex_unlock(&wddev->lock); |
154 | return err; |
155 | } |
156 | |
157 | /* |
158 | * watchdog_get_status: wrapper to get the watchdog status |
159 | * @wddev: the watchdog device to get the status from |
160 | * @status: the status of the watchdog device |
161 | * |
162 | * Get the watchdog's status flags. |
163 | */ |
164 | |
165 | static int watchdog_get_status(struct watchdog_device *wddev, |
166 | unsigned int *status) |
167 | { |
168 | int err = 0; |
169 | |
170 | *status = 0; |
171 | if (!wddev->ops->status) |
172 | return -EOPNOTSUPP; |
173 | |
174 | mutex_lock(&wddev->lock); |
175 | |
176 | if (test_bit(WDOG_UNREGISTERED, &wddev->status)) { |
177 | err = -ENODEV; |
178 | goto out_status; |
179 | } |
180 | |
181 | *status = wddev->ops->status(wddev); |
182 | |
183 | out_status: |
184 | mutex_unlock(&wddev->lock); |
185 | return err; |
186 | } |
187 | |
188 | /* |
189 | * watchdog_set_timeout: set the watchdog timer timeout |
190 | * @wddev: the watchdog device to set the timeout for |
191 | * @timeout: timeout to set in seconds |
192 | */ |
193 | |
194 | static int watchdog_set_timeout(struct watchdog_device *wddev, |
195 | unsigned int timeout) |
196 | { |
197 | int err; |
198 | |
199 | if ((wddev->ops->set_timeout == NULL) || |
200 | !(wddev->info->options & WDIOF_SETTIMEOUT)) |
201 | return -EOPNOTSUPP; |
202 | |
203 | if (watchdog_timeout_invalid(wddev, timeout)) |
204 | return -EINVAL; |
205 | |
206 | mutex_lock(&wddev->lock); |
207 | |
208 | if (test_bit(WDOG_UNREGISTERED, &wddev->status)) { |
209 | err = -ENODEV; |
210 | goto out_timeout; |
211 | } |
212 | |
213 | err = wddev->ops->set_timeout(wddev, timeout); |
214 | |
215 | out_timeout: |
216 | mutex_unlock(&wddev->lock); |
217 | return err; |
218 | } |
219 | |
220 | /* |
221 | * watchdog_get_timeleft: wrapper to get the time left before a reboot |
222 | * @wddev: the watchdog device to get the remaining time from |
223 | * @timeleft: the time that's left |
224 | * |
225 | * Get the time before a watchdog will reboot (if not pinged). |
226 | */ |
227 | |
228 | static int watchdog_get_timeleft(struct watchdog_device *wddev, |
229 | unsigned int *timeleft) |
230 | { |
231 | int err = 0; |
232 | |
233 | *timeleft = 0; |
234 | if (!wddev->ops->get_timeleft) |
235 | return -EOPNOTSUPP; |
236 | |
237 | mutex_lock(&wddev->lock); |
238 | |
239 | if (test_bit(WDOG_UNREGISTERED, &wddev->status)) { |
240 | err = -ENODEV; |
241 | goto out_timeleft; |
242 | } |
243 | |
244 | *timeleft = wddev->ops->get_timeleft(wddev); |
245 | |
246 | out_timeleft: |
247 | mutex_unlock(&wddev->lock); |
248 | return err; |
249 | } |
250 | |
251 | /* |
252 | * watchdog_ioctl_op: call the watchdog drivers ioctl op if defined |
253 | * @wddev: the watchdog device to do the ioctl on |
254 | * @cmd: watchdog command |
255 | * @arg: argument pointer |
256 | */ |
257 | |
258 | static int watchdog_ioctl_op(struct watchdog_device *wddev, unsigned int cmd, |
259 | unsigned long arg) |
260 | { |
261 | int err; |
262 | |
263 | if (!wddev->ops->ioctl) |
264 | return -ENOIOCTLCMD; |
265 | |
266 | mutex_lock(&wddev->lock); |
267 | |
268 | if (test_bit(WDOG_UNREGISTERED, &wddev->status)) { |
269 | err = -ENODEV; |
270 | goto out_ioctl; |
271 | } |
272 | |
273 | err = wddev->ops->ioctl(wddev, cmd, arg); |
274 | |
275 | out_ioctl: |
276 | mutex_unlock(&wddev->lock); |
277 | return err; |
278 | } |
279 | |
280 | /* |
281 | * watchdog_write: writes to the watchdog. |
282 | * @file: file from VFS |
283 | * @data: user address of data |
284 | * @len: length of data |
285 | * @ppos: pointer to the file offset |
286 | * |
287 | * A write to a watchdog device is defined as a keepalive ping. |
288 | * Writing the magic 'V' sequence allows the next close to turn |
289 | * off the watchdog (if 'nowayout' is not set). |
290 | */ |
291 | |
292 | static ssize_t watchdog_write(struct file *file, const char __user *data, |
293 | size_t len, loff_t *ppos) |
294 | { |
295 | struct watchdog_device *wdd = file->private_data; |
296 | size_t i; |
297 | char c; |
298 | |
299 | if (len == 0) |
300 | return 0; |
301 | |
302 | /* |
303 | * Note: just in case someone wrote the magic character |
304 | * five months ago... |
305 | */ |
306 | clear_bit(WDOG_ALLOW_RELEASE, &wdd->status); |
307 | |
308 | /* scan to see whether or not we got the magic character */ |
309 | for (i = 0; i != len; i++) { |
310 | if (get_user(c, data + i)) |
311 | return -EFAULT; |
312 | if (c == 'V') |
313 | set_bit(WDOG_ALLOW_RELEASE, &wdd->status); |
314 | } |
315 | |
316 | /* someone wrote to us, so we send the watchdog a keepalive ping */ |
317 | watchdog_ping(wdd); |
318 | |
319 | return len; |
320 | } |
321 | |
322 | /* |
323 | * watchdog_ioctl: handle the different ioctl's for the watchdog device. |
324 | * @file: file handle to the device |
325 | * @cmd: watchdog command |
326 | * @arg: argument pointer |
327 | * |
328 | * The watchdog API defines a common set of functions for all watchdogs |
329 | * according to their available features. |
330 | */ |
331 | |
332 | static long watchdog_ioctl(struct file *file, unsigned int cmd, |
333 | unsigned long arg) |
334 | { |
335 | struct watchdog_device *wdd = file->private_data; |
336 | void __user *argp = (void __user *)arg; |
337 | int __user *p = argp; |
338 | unsigned int val; |
339 | int err; |
340 | |
341 | err = watchdog_ioctl_op(wdd, cmd, arg); |
342 | if (err != -ENOIOCTLCMD) |
343 | return err; |
344 | |
345 | switch (cmd) { |
346 | case WDIOC_GETSUPPORT: |
347 | return copy_to_user(argp, wdd->info, |
348 | sizeof(struct watchdog_info)) ? -EFAULT : 0; |
349 | case WDIOC_GETSTATUS: |
350 | err = watchdog_get_status(wdd, &val); |
351 | if (err == -ENODEV) |
352 | return err; |
353 | return put_user(val, p); |
354 | case WDIOC_GETBOOTSTATUS: |
355 | return put_user(wdd->bootstatus, p); |
356 | case WDIOC_SETOPTIONS: |
357 | if (get_user(val, p)) |
358 | return -EFAULT; |
359 | if (val & WDIOS_DISABLECARD) { |
360 | err = watchdog_stop(wdd); |
361 | if (err < 0) |
362 | return err; |
363 | } |
364 | if (val & WDIOS_ENABLECARD) { |
365 | err = watchdog_start(wdd); |
366 | if (err < 0) |
367 | return err; |
368 | } |
369 | return 0; |
370 | case WDIOC_KEEPALIVE: |
371 | if (!(wdd->info->options & WDIOF_KEEPALIVEPING)) |
372 | return -EOPNOTSUPP; |
373 | watchdog_ping(wdd); |
374 | return 0; |
375 | case WDIOC_SETTIMEOUT: |
376 | if (get_user(val, p)) |
377 | return -EFAULT; |
378 | err = watchdog_set_timeout(wdd, val); |
379 | if (err < 0) |
380 | return err; |
381 | /* If the watchdog is active then we send a keepalive ping |
382 | * to make sure that the watchdog keep's running (and if |
383 | * possible that it takes the new timeout) */ |
384 | watchdog_ping(wdd); |
385 | /* Fall */ |
386 | case WDIOC_GETTIMEOUT: |
387 | /* timeout == 0 means that we don't know the timeout */ |
388 | if (wdd->timeout == 0) |
389 | return -EOPNOTSUPP; |
390 | return put_user(wdd->timeout, p); |
391 | case WDIOC_GETTIMELEFT: |
392 | err = watchdog_get_timeleft(wdd, &val); |
393 | if (err) |
394 | return err; |
395 | return put_user(val, p); |
396 | default: |
397 | return -ENOTTY; |
398 | } |
399 | } |
400 | |
401 | /* |
402 | * watchdog_open: open the /dev/watchdog* devices. |
403 | * @inode: inode of device |
404 | * @file: file handle to device |
405 | * |
406 | * When the /dev/watchdog* device gets opened, we start the watchdog. |
407 | * Watch out: the /dev/watchdog device is single open, so we make sure |
408 | * it can only be opened once. |
409 | */ |
410 | |
411 | static int watchdog_open(struct inode *inode, struct file *file) |
412 | { |
413 | int err = -EBUSY; |
414 | struct watchdog_device *wdd; |
415 | |
416 | /* Get the corresponding watchdog device */ |
417 | if (imajor(inode) == MISC_MAJOR) |
418 | wdd = old_wdd; |
419 | else |
420 | wdd = container_of(inode->i_cdev, struct watchdog_device, cdev); |
421 | |
422 | /* the watchdog is single open! */ |
423 | if (test_and_set_bit(WDOG_DEV_OPEN, &wdd->status)) |
424 | return -EBUSY; |
425 | |
426 | /* |
427 | * If the /dev/watchdog device is open, we don't want the module |
428 | * to be unloaded. |
429 | */ |
430 | if (!try_module_get(wdd->ops->owner)) |
431 | goto out; |
432 | |
433 | err = watchdog_start(wdd); |
434 | if (err < 0) |
435 | goto out_mod; |
436 | |
437 | file->private_data = wdd; |
438 | |
439 | if (wdd->ops->ref) |
440 | wdd->ops->ref(wdd); |
441 | |
442 | /* dev/watchdog is a virtual (and thus non-seekable) filesystem */ |
443 | return nonseekable_open(inode, file); |
444 | |
445 | out_mod: |
446 | module_put(wdd->ops->owner); |
447 | out: |
448 | clear_bit(WDOG_DEV_OPEN, &wdd->status); |
449 | return err; |
450 | } |
451 | |
452 | /* |
453 | * watchdog_release: release the watchdog device. |
454 | * @inode: inode of device |
455 | * @file: file handle to device |
456 | * |
457 | * This is the code for when /dev/watchdog gets closed. We will only |
458 | * stop the watchdog when we have received the magic char (and nowayout |
459 | * was not set), else the watchdog will keep running. |
460 | */ |
461 | |
462 | static int watchdog_release(struct inode *inode, struct file *file) |
463 | { |
464 | struct watchdog_device *wdd = file->private_data; |
465 | int err = -EBUSY; |
466 | |
467 | /* |
468 | * We only stop the watchdog if we received the magic character |
469 | * or if WDIOF_MAGICCLOSE is not set. If nowayout was set then |
470 | * watchdog_stop will fail. |
471 | */ |
472 | if (test_and_clear_bit(WDOG_ALLOW_RELEASE, &wdd->status) || |
473 | !(wdd->info->options & WDIOF_MAGICCLOSE)) |
474 | err = watchdog_stop(wdd); |
475 | |
476 | /* If the watchdog was not stopped, send a keepalive ping */ |
477 | if (err < 0) { |
478 | mutex_lock(&wdd->lock); |
479 | if (!test_bit(WDOG_UNREGISTERED, &wdd->status)) |
480 | dev_crit(wdd->dev, "watchdog did not stop!\n"); |
481 | mutex_unlock(&wdd->lock); |
482 | watchdog_ping(wdd); |
483 | } |
484 | |
485 | /* Allow the owner module to be unloaded again */ |
486 | module_put(wdd->ops->owner); |
487 | |
488 | /* make sure that /dev/watchdog can be re-opened */ |
489 | clear_bit(WDOG_DEV_OPEN, &wdd->status); |
490 | |
491 | /* Note wdd may be gone after this, do not use after this! */ |
492 | if (wdd->ops->unref) |
493 | wdd->ops->unref(wdd); |
494 | |
495 | return 0; |
496 | } |
497 | |
498 | static const struct file_operations watchdog_fops = { |
499 | .owner = THIS_MODULE, |
500 | .write = watchdog_write, |
501 | .unlocked_ioctl = watchdog_ioctl, |
502 | .open = watchdog_open, |
503 | .release = watchdog_release, |
504 | }; |
505 | |
506 | static struct miscdevice watchdog_miscdev = { |
507 | .minor = WATCHDOG_MINOR, |
508 | .name = "watchdog", |
509 | .fops = &watchdog_fops, |
510 | }; |
511 | |
512 | /* |
513 | * watchdog_dev_register: register a watchdog device |
514 | * @watchdog: watchdog device |
515 | * |
516 | * Register a watchdog device including handling the legacy |
517 | * /dev/watchdog node. /dev/watchdog is actually a miscdevice and |
518 | * thus we set it up like that. |
519 | */ |
520 | |
521 | int watchdog_dev_register(struct watchdog_device *watchdog) |
522 | { |
523 | int err, devno; |
524 | |
525 | if (watchdog->id == 0) { |
526 | watchdog_miscdev.parent = watchdog->parent; |
527 | err = misc_register(&watchdog_miscdev); |
528 | if (err != 0) { |
529 | pr_err("%s: cannot register miscdev on minor=%d (err=%d).\n", |
530 | watchdog->info->identity, WATCHDOG_MINOR, err); |
531 | if (err == -EBUSY) |
532 | pr_err("%s: a legacy watchdog module is probably present.\n", |
533 | watchdog->info->identity); |
534 | return err; |
535 | } |
536 | old_wdd = watchdog; |
537 | } |
538 | |
539 | /* Fill in the data structures */ |
540 | devno = MKDEV(MAJOR(watchdog_devt), watchdog->id); |
541 | cdev_init(&watchdog->cdev, &watchdog_fops); |
542 | watchdog->cdev.owner = watchdog->ops->owner; |
543 | |
544 | /* Add the device */ |
545 | err = cdev_add(&watchdog->cdev, devno, 1); |
546 | if (err) { |
547 | pr_err("watchdog%d unable to add device %d:%d\n", |
548 | watchdog->id, MAJOR(watchdog_devt), watchdog->id); |
549 | if (watchdog->id == 0) { |
550 | misc_deregister(&watchdog_miscdev); |
551 | old_wdd = NULL; |
552 | } |
553 | } |
554 | return err; |
555 | } |
556 | |
557 | /* |
558 | * watchdog_dev_unregister: unregister a watchdog device |
559 | * @watchdog: watchdog device |
560 | * |
561 | * Unregister the watchdog and if needed the legacy /dev/watchdog device. |
562 | */ |
563 | |
564 | int watchdog_dev_unregister(struct watchdog_device *watchdog) |
565 | { |
566 | mutex_lock(&watchdog->lock); |
567 | set_bit(WDOG_UNREGISTERED, &watchdog->status); |
568 | mutex_unlock(&watchdog->lock); |
569 | |
570 | cdev_del(&watchdog->cdev); |
571 | if (watchdog->id == 0) { |
572 | misc_deregister(&watchdog_miscdev); |
573 | old_wdd = NULL; |
574 | } |
575 | return 0; |
576 | } |
577 | |
578 | /* |
579 | * watchdog_dev_init: init dev part of watchdog core |
580 | * |
581 | * Allocate a range of chardev nodes to use for watchdog devices |
582 | */ |
583 | |
584 | int __init watchdog_dev_init(void) |
585 | { |
586 | int err = alloc_chrdev_region(&watchdog_devt, 0, MAX_DOGS, "watchdog"); |
587 | if (err < 0) |
588 | pr_err("watchdog: unable to allocate char dev region\n"); |
589 | return err; |
590 | } |
591 | |
592 | /* |
593 | * watchdog_dev_exit: exit dev part of watchdog core |
594 | * |
595 | * Release the range of chardev nodes used for watchdog devices |
596 | */ |
597 | |
598 | void __exit watchdog_dev_exit(void) |
599 | { |
600 | unregister_chrdev_region(watchdog_devt, MAX_DOGS); |
601 | } |
602 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9