This source file includes following definitions.
- watchdog_deferred_registration_add
- watchdog_deferred_registration_del
- watchdog_check_min_max_timeout
- watchdog_init_timeout
- watchdog_reboot_notifier
- watchdog_restart_notifier
- watchdog_set_restart_priority
- __watchdog_register_device
- watchdog_register_device
- __watchdog_unregister_device
- watchdog_unregister_device
- devm_watchdog_unregister_device
- devm_watchdog_register_device
- watchdog_deferred_registration
- watchdog_init
- watchdog_exit
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26
27 #include <linux/module.h>
28 #include <linux/types.h>
29 #include <linux/errno.h>
30 #include <linux/kernel.h>
31 #include <linux/reboot.h>
32 #include <linux/watchdog.h>
33 #include <linux/init.h>
34 #include <linux/idr.h>
35 #include <linux/err.h>
36 #include <linux/of.h>
37
38 #include "watchdog_core.h"
39
40 static DEFINE_IDA(watchdog_ida);
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55 static DEFINE_MUTEX(wtd_deferred_reg_mutex);
56 static LIST_HEAD(wtd_deferred_reg_list);
57 static bool wtd_deferred_reg_done;
58
59 static void watchdog_deferred_registration_add(struct watchdog_device *wdd)
60 {
61 list_add_tail(&wdd->deferred,
62 &wtd_deferred_reg_list);
63 }
64
65 static void watchdog_deferred_registration_del(struct watchdog_device *wdd)
66 {
67 struct list_head *p, *n;
68 struct watchdog_device *wdd_tmp;
69
70 list_for_each_safe(p, n, &wtd_deferred_reg_list) {
71 wdd_tmp = list_entry(p, struct watchdog_device,
72 deferred);
73 if (wdd_tmp == wdd) {
74 list_del(&wdd_tmp->deferred);
75 break;
76 }
77 }
78 }
79
80 static void watchdog_check_min_max_timeout(struct watchdog_device *wdd)
81 {
82
83
84
85
86 if (!wdd->max_hw_heartbeat_ms && wdd->min_timeout > wdd->max_timeout) {
87 pr_info("Invalid min and max timeout values, resetting to 0!\n");
88 wdd->min_timeout = 0;
89 wdd->max_timeout = 0;
90 }
91 }
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110 int watchdog_init_timeout(struct watchdog_device *wdd,
111 unsigned int timeout_parm, struct device *dev)
112 {
113 const char *dev_str = wdd->parent ? dev_name(wdd->parent) :
114 (const char *)wdd->info->identity;
115 unsigned int t = 0;
116 int ret = 0;
117
118 watchdog_check_min_max_timeout(wdd);
119
120
121 if (timeout_parm) {
122 if (!watchdog_timeout_invalid(wdd, timeout_parm)) {
123 wdd->timeout = timeout_parm;
124 return 0;
125 }
126 pr_err("%s: driver supplied timeout (%u) out of range\n",
127 dev_str, timeout_parm);
128 ret = -EINVAL;
129 }
130
131
132 if (dev && dev->of_node &&
133 of_property_read_u32(dev->of_node, "timeout-sec", &t) == 0) {
134 if (t && !watchdog_timeout_invalid(wdd, t)) {
135 wdd->timeout = t;
136 return 0;
137 }
138 pr_err("%s: DT supplied timeout (%u) out of range\n", dev_str, t);
139 ret = -EINVAL;
140 }
141
142 if (ret < 0 && wdd->timeout)
143 pr_warn("%s: falling back to default timeout (%u)\n", dev_str,
144 wdd->timeout);
145
146 return ret;
147 }
148 EXPORT_SYMBOL_GPL(watchdog_init_timeout);
149
150 static int watchdog_reboot_notifier(struct notifier_block *nb,
151 unsigned long code, void *data)
152 {
153 struct watchdog_device *wdd;
154
155 wdd = container_of(nb, struct watchdog_device, reboot_nb);
156 if (code == SYS_DOWN || code == SYS_HALT) {
157 if (watchdog_active(wdd)) {
158 int ret;
159
160 ret = wdd->ops->stop(wdd);
161 if (ret)
162 return NOTIFY_BAD;
163 }
164 }
165
166 return NOTIFY_DONE;
167 }
168
169 static int watchdog_restart_notifier(struct notifier_block *nb,
170 unsigned long action, void *data)
171 {
172 struct watchdog_device *wdd = container_of(nb, struct watchdog_device,
173 restart_nb);
174
175 int ret;
176
177 ret = wdd->ops->restart(wdd, action, data);
178 if (ret)
179 return NOTIFY_BAD;
180
181 return NOTIFY_DONE;
182 }
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198 void watchdog_set_restart_priority(struct watchdog_device *wdd, int priority)
199 {
200 wdd->restart_nb.priority = priority;
201 }
202 EXPORT_SYMBOL_GPL(watchdog_set_restart_priority);
203
204 static int __watchdog_register_device(struct watchdog_device *wdd)
205 {
206 int ret, id = -1;
207
208 if (wdd == NULL || wdd->info == NULL || wdd->ops == NULL)
209 return -EINVAL;
210
211
212 if (!wdd->ops->start || (!wdd->ops->stop && !wdd->max_hw_heartbeat_ms))
213 return -EINVAL;
214
215 watchdog_check_min_max_timeout(wdd);
216
217
218
219
220
221
222
223
224 if (wdd->parent) {
225 ret = of_alias_get_id(wdd->parent->of_node, "watchdog");
226 if (ret >= 0)
227 id = ida_simple_get(&watchdog_ida, ret,
228 ret + 1, GFP_KERNEL);
229 }
230
231 if (id < 0)
232 id = ida_simple_get(&watchdog_ida, 0, MAX_DOGS, GFP_KERNEL);
233
234 if (id < 0)
235 return id;
236 wdd->id = id;
237
238 ret = watchdog_dev_register(wdd);
239 if (ret) {
240 ida_simple_remove(&watchdog_ida, id);
241 if (!(id == 0 && ret == -EBUSY))
242 return ret;
243
244
245 id = ida_simple_get(&watchdog_ida, 1, MAX_DOGS, GFP_KERNEL);
246 if (id < 0)
247 return id;
248 wdd->id = id;
249
250 ret = watchdog_dev_register(wdd);
251 if (ret) {
252 ida_simple_remove(&watchdog_ida, id);
253 return ret;
254 }
255 }
256
257 if (test_bit(WDOG_STOP_ON_REBOOT, &wdd->status)) {
258 wdd->reboot_nb.notifier_call = watchdog_reboot_notifier;
259
260 ret = register_reboot_notifier(&wdd->reboot_nb);
261 if (ret) {
262 pr_err("watchdog%d: Cannot register reboot notifier (%d)\n",
263 wdd->id, ret);
264 watchdog_dev_unregister(wdd);
265 ida_simple_remove(&watchdog_ida, id);
266 return ret;
267 }
268 }
269
270 if (wdd->ops->restart) {
271 wdd->restart_nb.notifier_call = watchdog_restart_notifier;
272
273 ret = register_restart_handler(&wdd->restart_nb);
274 if (ret)
275 pr_warn("watchdog%d: Cannot register restart handler (%d)\n",
276 wdd->id, ret);
277 }
278
279 return 0;
280 }
281
282
283
284
285
286
287
288
289
290
291
292
293 int watchdog_register_device(struct watchdog_device *wdd)
294 {
295 const char *dev_str;
296 int ret = 0;
297
298 mutex_lock(&wtd_deferred_reg_mutex);
299 if (wtd_deferred_reg_done)
300 ret = __watchdog_register_device(wdd);
301 else
302 watchdog_deferred_registration_add(wdd);
303 mutex_unlock(&wtd_deferred_reg_mutex);
304
305 if (ret) {
306 dev_str = wdd->parent ? dev_name(wdd->parent) :
307 (const char *)wdd->info->identity;
308 pr_err("%s: failed to register watchdog device (err = %d)\n",
309 dev_str, ret);
310 }
311
312 return ret;
313 }
314 EXPORT_SYMBOL_GPL(watchdog_register_device);
315
316 static void __watchdog_unregister_device(struct watchdog_device *wdd)
317 {
318 if (wdd == NULL)
319 return;
320
321 if (wdd->ops->restart)
322 unregister_restart_handler(&wdd->restart_nb);
323
324 if (test_bit(WDOG_STOP_ON_REBOOT, &wdd->status))
325 unregister_reboot_notifier(&wdd->reboot_nb);
326
327 watchdog_dev_unregister(wdd);
328 ida_simple_remove(&watchdog_ida, wdd->id);
329 }
330
331
332
333
334
335
336
337
338
339 void watchdog_unregister_device(struct watchdog_device *wdd)
340 {
341 mutex_lock(&wtd_deferred_reg_mutex);
342 if (wtd_deferred_reg_done)
343 __watchdog_unregister_device(wdd);
344 else
345 watchdog_deferred_registration_del(wdd);
346 mutex_unlock(&wtd_deferred_reg_mutex);
347 }
348
349 EXPORT_SYMBOL_GPL(watchdog_unregister_device);
350
351 static void devm_watchdog_unregister_device(struct device *dev, void *res)
352 {
353 watchdog_unregister_device(*(struct watchdog_device **)res);
354 }
355
356
357
358
359
360
361
362
363
364
365 int devm_watchdog_register_device(struct device *dev,
366 struct watchdog_device *wdd)
367 {
368 struct watchdog_device **rcwdd;
369 int ret;
370
371 rcwdd = devres_alloc(devm_watchdog_unregister_device, sizeof(*rcwdd),
372 GFP_KERNEL);
373 if (!rcwdd)
374 return -ENOMEM;
375
376 ret = watchdog_register_device(wdd);
377 if (!ret) {
378 *rcwdd = wdd;
379 devres_add(dev, rcwdd);
380 } else {
381 devres_free(rcwdd);
382 }
383
384 return ret;
385 }
386 EXPORT_SYMBOL_GPL(devm_watchdog_register_device);
387
388 static int __init watchdog_deferred_registration(void)
389 {
390 mutex_lock(&wtd_deferred_reg_mutex);
391 wtd_deferred_reg_done = true;
392 while (!list_empty(&wtd_deferred_reg_list)) {
393 struct watchdog_device *wdd;
394
395 wdd = list_first_entry(&wtd_deferred_reg_list,
396 struct watchdog_device, deferred);
397 list_del(&wdd->deferred);
398 __watchdog_register_device(wdd);
399 }
400 mutex_unlock(&wtd_deferred_reg_mutex);
401 return 0;
402 }
403
404 static int __init watchdog_init(void)
405 {
406 int err;
407
408 err = watchdog_dev_init();
409 if (err < 0)
410 return err;
411
412 watchdog_deferred_registration();
413 return 0;
414 }
415
416 static void __exit watchdog_exit(void)
417 {
418 watchdog_dev_exit();
419 ida_destroy(&watchdog_ida);
420 }
421
422 subsys_initcall_sync(watchdog_init);
423 module_exit(watchdog_exit);
424
425 MODULE_AUTHOR("Alan Cox <alan@lxorguk.ukuu.org.uk>");
426 MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>");
427 MODULE_DESCRIPTION("WatchDog Timer Driver Core");
428 MODULE_LICENSE("GPL");