blob: 461336c4519faf3acee6dad759030a6f0778876d [file] [log] [blame]
Wim Van Sebroeck43316042011-07-22 18:55:18 +00001/*
2 * watchdog_core.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 * This source code is part of the generic code that can be used
10 * by all the watchdog timer drivers.
11 *
12 * Based on source code of the following authors:
13 * Matt Domsch <Matt_Domsch@dell.com>,
14 * Rob Radez <rob@osinvestor.com>,
15 * Rusty Lynch <rusty@linux.co.intel.com>
16 * Satyam Sharma <satyam@infradead.org>
17 * Randy Dunlap <randy.dunlap@oracle.com>
18 *
19 * This program is free software; you can redistribute it and/or
20 * modify it under the terms of the GNU General Public License
21 * as published by the Free Software Foundation; either version
22 * 2 of the License, or (at your option) any later version.
23 *
24 * Neither Alan Cox, CymruNet Ltd., Wim Van Sebroeck nor Iguana vzw.
25 * admit liability nor provide warranty for any of this software.
26 * This material is provided "AS-IS" and at no charge.
27 */
28
29#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
30
31#include <linux/module.h> /* For EXPORT_SYMBOL/module stuff/... */
32#include <linux/types.h> /* For standard types */
33#include <linux/errno.h> /* For the -ENODEV/... values */
34#include <linux/kernel.h> /* For printk/panic/... */
35#include <linux/watchdog.h> /* For watchdog specific items */
36#include <linux/init.h> /* For __init/__exit/... */
Alan Cox45f5fed2012-05-10 21:48:59 +020037#include <linux/idr.h> /* For ida_* macros */
Alan Coxd6b469d2012-05-11 12:00:20 +020038#include <linux/err.h> /* For IS_ERR macros */
Fabio Porcedda30482532013-01-08 11:04:10 +010039#include <linux/of.h> /* For of_get_timeout_sec */
Wim Van Sebroeck43316042011-07-22 18:55:18 +000040
Wim Van Sebroeck6cfb5aa2012-05-21 15:31:06 +020041#include "watchdog_core.h" /* For watchdog_dev_register/... */
Wim Van Sebroeck43316042011-07-22 18:55:18 +000042
Alan Cox45f5fed2012-05-10 21:48:59 +020043static DEFINE_IDA(watchdog_ida);
Alan Coxd6b469d2012-05-11 12:00:20 +020044static struct class *watchdog_class;
Alan Cox45f5fed2012-05-10 21:48:59 +020045
Fabio Porcedda30482532013-01-08 11:04:10 +010046static void watchdog_check_min_max_timeout(struct watchdog_device *wdd)
47{
48 /*
49 * Check that we have valid min and max timeout values, if
50 * not reset them both to 0 (=not used or unknown)
51 */
52 if (wdd->min_timeout > wdd->max_timeout) {
53 pr_info("Invalid min and max timeout values, resetting to 0!\n");
54 wdd->min_timeout = 0;
55 wdd->max_timeout = 0;
56 }
57}
58
59/**
60 * watchdog_init_timeout() - initialize the timeout field
61 * @timeout_parm: timeout module parameter
62 * @dev: Device that stores the timeout-sec property
63 *
64 * Initialize the timeout field of the watchdog_device struct with either the
65 * timeout module parameter (if it is valid value) or the timeout-sec property
66 * (only if it is a valid value and the timeout_parm is out of bounds).
67 * If none of them are valid then we keep the old value (which should normally
68 * be the default timeout value.
69 *
70 * A zero is returned on success and -EINVAL for failure.
71 */
72int watchdog_init_timeout(struct watchdog_device *wdd,
73 unsigned int timeout_parm, struct device *dev)
74{
75 unsigned int t = 0;
76 int ret = 0;
77
78 watchdog_check_min_max_timeout(wdd);
79
Sachin Kamat6ffcff92013-10-28 14:17:17 +053080 /* try to get the timeout module parameter first */
Fabio Porcedda30482532013-01-08 11:04:10 +010081 if (!watchdog_timeout_invalid(wdd, timeout_parm)) {
82 wdd->timeout = timeout_parm;
83 return ret;
84 }
85 if (timeout_parm)
86 ret = -EINVAL;
87
88 /* try to get the timeout_sec property */
89 if (dev == NULL || dev->of_node == NULL)
90 return ret;
91 of_property_read_u32(dev->of_node, "timeout-sec", &t);
92 if (!watchdog_timeout_invalid(wdd, t))
93 wdd->timeout = t;
94 else
95 ret = -EINVAL;
96
97 return ret;
98}
99EXPORT_SYMBOL_GPL(watchdog_init_timeout);
100
Wim Van Sebroeck43316042011-07-22 18:55:18 +0000101/**
102 * watchdog_register_device() - register a watchdog device
103 * @wdd: watchdog device
104 *
105 * Register a watchdog device with the kernel so that the
106 * watchdog timer can be accessed from userspace.
107 *
108 * A zero is returned on success and a negative errno code for
109 * failure.
110 */
111int watchdog_register_device(struct watchdog_device *wdd)
112{
Alan Coxd6b469d2012-05-11 12:00:20 +0200113 int ret, id, devno;
Wim Van Sebroeck43316042011-07-22 18:55:18 +0000114
115 if (wdd == NULL || wdd->info == NULL || wdd->ops == NULL)
116 return -EINVAL;
117
118 /* Mandatory operations need to be supported */
119 if (wdd->ops->start == NULL || wdd->ops->stop == NULL)
120 return -EINVAL;
121
Fabio Porcedda30482532013-01-08 11:04:10 +0100122 watchdog_check_min_max_timeout(wdd);
Wim Van Sebroeck3f43f682011-07-22 19:00:16 +0000123
124 /*
Wim Van Sebroeck43316042011-07-22 18:55:18 +0000125 * Note: now that all watchdog_device data has been verified, we
126 * will not check this anymore in other functions. If data gets
127 * corrupted in a later stage then we expect a kernel panic!
128 */
129
Hans de Goedef4e9c822012-05-22 11:40:26 +0200130 mutex_init(&wdd->lock);
Alan Cox45f5fed2012-05-10 21:48:59 +0200131 id = ida_simple_get(&watchdog_ida, 0, MAX_DOGS, GFP_KERNEL);
132 if (id < 0)
133 return id;
134 wdd->id = id;
135
Wim Van Sebroeck43316042011-07-22 18:55:18 +0000136 ret = watchdog_dev_register(wdd);
137 if (ret) {
Alan Cox45f5fed2012-05-10 21:48:59 +0200138 ida_simple_remove(&watchdog_ida, id);
139 if (!(id == 0 && ret == -EBUSY))
140 return ret;
141
142 /* Retry in case a legacy watchdog module exists */
143 id = ida_simple_get(&watchdog_ida, 1, MAX_DOGS, GFP_KERNEL);
144 if (id < 0)
145 return id;
146 wdd->id = id;
147
148 ret = watchdog_dev_register(wdd);
149 if (ret) {
150 ida_simple_remove(&watchdog_ida, id);
151 return ret;
152 }
Wim Van Sebroeck43316042011-07-22 18:55:18 +0000153 }
154
Alan Coxd6b469d2012-05-11 12:00:20 +0200155 devno = wdd->cdev.dev;
156 wdd->dev = device_create(watchdog_class, wdd->parent, devno,
157 NULL, "watchdog%d", wdd->id);
158 if (IS_ERR(wdd->dev)) {
159 watchdog_dev_unregister(wdd);
160 ida_simple_remove(&watchdog_ida, id);
161 ret = PTR_ERR(wdd->dev);
162 return ret;
163 }
164
Wim Van Sebroeck43316042011-07-22 18:55:18 +0000165 return 0;
166}
167EXPORT_SYMBOL_GPL(watchdog_register_device);
168
169/**
170 * watchdog_unregister_device() - unregister a watchdog device
171 * @wdd: watchdog device to unregister
172 *
173 * Unregister a watchdog device that was previously successfully
174 * registered with watchdog_register_device().
175 */
176void watchdog_unregister_device(struct watchdog_device *wdd)
177{
178 int ret;
Wei Yongjunb232a702012-09-10 12:41:15 +0800179 int devno;
Wim Van Sebroeck43316042011-07-22 18:55:18 +0000180
181 if (wdd == NULL)
182 return;
183
Wei Yongjunb232a702012-09-10 12:41:15 +0800184 devno = wdd->cdev.dev;
Wim Van Sebroeck43316042011-07-22 18:55:18 +0000185 ret = watchdog_dev_unregister(wdd);
186 if (ret)
Joe Perches27c766a2012-02-15 15:06:19 -0800187 pr_err("error unregistering /dev/watchdog (err=%d)\n", ret);
Alan Coxd6b469d2012-05-11 12:00:20 +0200188 device_destroy(watchdog_class, devno);
Alan Cox45f5fed2012-05-10 21:48:59 +0200189 ida_simple_remove(&watchdog_ida, wdd->id);
Alan Coxd6b469d2012-05-11 12:00:20 +0200190 wdd->dev = NULL;
Wim Van Sebroeck43316042011-07-22 18:55:18 +0000191}
192EXPORT_SYMBOL_GPL(watchdog_unregister_device);
193
Alan Cox45f5fed2012-05-10 21:48:59 +0200194static int __init watchdog_init(void)
195{
Alan Coxd6b469d2012-05-11 12:00:20 +0200196 int err;
197
198 watchdog_class = class_create(THIS_MODULE, "watchdog");
199 if (IS_ERR(watchdog_class)) {
200 pr_err("couldn't create class\n");
201 return PTR_ERR(watchdog_class);
202 }
203
204 err = watchdog_dev_init();
205 if (err < 0) {
206 class_destroy(watchdog_class);
207 return err;
208 }
209
210 return 0;
Alan Cox45f5fed2012-05-10 21:48:59 +0200211}
212
213static void __exit watchdog_exit(void)
214{
215 watchdog_dev_exit();
Alan Coxd6b469d2012-05-11 12:00:20 +0200216 class_destroy(watchdog_class);
Alan Cox45f5fed2012-05-10 21:48:59 +0200217 ida_destroy(&watchdog_ida);
218}
219
220subsys_initcall(watchdog_init);
221module_exit(watchdog_exit);
222
Wim Van Sebroeck43316042011-07-22 18:55:18 +0000223MODULE_AUTHOR("Alan Cox <alan@lxorguk.ukuu.org.uk>");
224MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>");
225MODULE_DESCRIPTION("WatchDog Timer Driver Core");
226MODULE_LICENSE("GPL");