Lines Matching refs:wdd
53 * @wdd: Pointer to watchdog device.
60 struct watchdog_device *wdd;
96 static inline bool watchdog_need_worker(struct watchdog_device *wdd)
99 unsigned int hm = wdd->max_hw_heartbeat_ms;
100 unsigned int t = wdd->timeout * 1000;
115 return (hm && watchdog_active(wdd) && t > hm) ||
116 (t && !watchdog_active(wdd) && watchdog_hw_running(wdd));
119 static ktime_t watchdog_next_keepalive(struct watchdog_device *wdd)
121 struct watchdog_core_data *wd_data = wdd->wd_data;
122 unsigned int timeout_ms = wdd->timeout * 1000;
128 if (watchdog_active(wdd))
134 hw_heartbeat_ms = min_not_zero(timeout_ms, wdd->max_hw_heartbeat_ms);
138 * To ensure that the watchdog times out wdd->timeout seconds
149 static inline void watchdog_update_worker(struct watchdog_device *wdd)
151 struct watchdog_core_data *wd_data = wdd->wd_data;
153 if (watchdog_need_worker(wdd)) {
154 ktime_t t = watchdog_next_keepalive(wdd);
164 static int __watchdog_ping(struct watchdog_device *wdd)
166 struct watchdog_core_data *wd_data = wdd->wd_data;
171 ms_to_ktime(wdd->min_hw_heartbeat_ms));
183 if (wdd->ops->ping)
184 err = wdd->ops->ping(wdd); /* ping the watchdog */
186 err = wdd->ops->start(wdd); /* restart watchdog */
188 watchdog_update_worker(wdd);
195 * @wdd: the watchdog device to ping
205 static int watchdog_ping(struct watchdog_device *wdd)
207 struct watchdog_core_data *wd_data = wdd->wd_data;
209 if (!watchdog_active(wdd) && !watchdog_hw_running(wdd))
215 return __watchdog_ping(wdd);
220 struct watchdog_device *wdd = wd_data->wdd;
222 if (!wdd)
225 if (watchdog_active(wdd))
228 return watchdog_hw_running(wdd) && !watchdog_past_open_deadline(wd_data);
239 __watchdog_ping(wd_data->wdd);
255 * @wdd: the watchdog device to start
264 static int watchdog_start(struct watchdog_device *wdd)
266 struct watchdog_core_data *wd_data = wdd->wd_data;
270 if (watchdog_active(wdd))
276 if (watchdog_hw_running(wdd) && wdd->ops->ping) {
277 err = __watchdog_ping(wdd);
279 set_bit(WDOG_ACTIVE, &wdd->status);
281 err = wdd->ops->start(wdd);
283 set_bit(WDOG_ACTIVE, &wdd->status);
286 watchdog_update_worker(wdd);
295 * @wdd: the watchdog device to stop
305 static int watchdog_stop(struct watchdog_device *wdd)
309 if (!watchdog_active(wdd))
312 if (test_bit(WDOG_NO_WAY_OUT, &wdd->status)) {
314 wdd->id);
318 if (wdd->ops->stop) {
319 clear_bit(WDOG_HW_RUNNING, &wdd->status);
320 err = wdd->ops->stop(wdd);
322 set_bit(WDOG_HW_RUNNING, &wdd->status);
326 clear_bit(WDOG_ACTIVE, &wdd->status);
327 watchdog_update_worker(wdd);
335 * @wdd: the watchdog device to get the status from
342 static unsigned int watchdog_get_status(struct watchdog_device *wdd)
344 struct watchdog_core_data *wd_data = wdd->wd_data;
347 if (wdd->ops->status)
348 status = wdd->ops->status(wdd);
350 status = wdd->bootstatus & (WDIOF_CARDRESET |
369 * @wdd: the watchdog device to set the timeout for
375 static int watchdog_set_timeout(struct watchdog_device *wdd,
380 if (!(wdd->info->options & WDIOF_SETTIMEOUT))
383 if (watchdog_timeout_invalid(wdd, timeout))
386 if (wdd->ops->set_timeout) {
387 err = wdd->ops->set_timeout(wdd, timeout);
389 wdd->timeout = timeout;
391 if (wdd->pretimeout >= wdd->timeout)
392 wdd->pretimeout = 0;
395 watchdog_update_worker(wdd);
402 * @wdd: the watchdog device to set the timeout for
406 static int watchdog_set_pretimeout(struct watchdog_device *wdd,
411 if (!(wdd->info->options & WDIOF_PRETIMEOUT))
414 if (watchdog_pretimeout_invalid(wdd, timeout))
417 if (wdd->ops->set_pretimeout)
418 err = wdd->ops->set_pretimeout(wdd, timeout);
420 wdd->pretimeout = timeout;
427 * @wdd: the watchdog device to get the remaining time from
435 static int watchdog_get_timeleft(struct watchdog_device *wdd,
440 if (!wdd->ops->get_timeleft)
443 *timeleft = wdd->ops->get_timeleft(wdd);
452 struct watchdog_device *wdd = dev_get_drvdata(dev);
454 return sprintf(buf, "%d\n", !!test_bit(WDOG_NO_WAY_OUT, &wdd->status));
460 struct watchdog_device *wdd = dev_get_drvdata(dev);
470 if (test_bit(WDOG_NO_WAY_OUT, &wdd->status) && !value)
472 watchdog_set_nowayout(wdd, value);
480 struct watchdog_device *wdd = dev_get_drvdata(dev);
481 struct watchdog_core_data *wd_data = wdd->wd_data;
485 status = watchdog_get_status(wdd);
495 struct watchdog_device *wdd = dev_get_drvdata(dev);
497 return sprintf(buf, "%u\n", wdd->bootstatus);
504 struct watchdog_device *wdd = dev_get_drvdata(dev);
505 struct watchdog_core_data *wd_data = wdd->wd_data;
510 status = watchdog_get_timeleft(wdd, &val);
522 struct watchdog_device *wdd = dev_get_drvdata(dev);
524 return sprintf(buf, "%u\n", wdd->timeout);
531 struct watchdog_device *wdd = dev_get_drvdata(dev);
533 return sprintf(buf, "%u\n", wdd->pretimeout);
540 struct watchdog_device *wdd = dev_get_drvdata(dev);
542 return sprintf(buf, "%s\n", wdd->info->identity);
549 struct watchdog_device *wdd = dev_get_drvdata(dev);
551 if (watchdog_active(wdd))
569 struct watchdog_device *wdd = dev_get_drvdata(dev);
571 return watchdog_pretimeout_governor_get(wdd, buf);
578 struct watchdog_device *wdd = dev_get_drvdata(dev);
579 int ret = watchdog_pretimeout_governor_set(wdd, buf);
592 struct watchdog_device *wdd = dev_get_drvdata(dev);
595 if (attr == &dev_attr_timeleft.attr && !wdd->ops->get_timeleft)
598 !(wdd->info->options & WDIOF_PRETIMEOUT))
602 (!(wdd->info->options & WDIOF_PRETIMEOUT) ||
633 * @wdd: the watchdog device to do the ioctl on
640 static int watchdog_ioctl_op(struct watchdog_device *wdd, unsigned int cmd,
643 if (!wdd->ops->ioctl)
646 return wdd->ops->ioctl(wdd, cmd, arg);
665 struct watchdog_device *wdd;
691 wdd = wd_data->wdd;
692 if (wdd)
693 err = watchdog_ping(wdd);
717 struct watchdog_device *wdd;
724 wdd = wd_data->wdd;
725 if (!wdd) {
730 err = watchdog_ioctl_op(wdd, cmd, arg);
736 err = copy_to_user(argp, wdd->info,
740 val = watchdog_get_status(wdd);
744 err = put_user(wdd->bootstatus, p);
752 err = watchdog_stop(wdd);
757 err = watchdog_start(wdd);
760 if (!(wdd->info->options & WDIOF_KEEPALIVEPING)) {
764 err = watchdog_ping(wdd);
771 err = watchdog_set_timeout(wdd, val);
777 err = watchdog_ping(wdd);
783 if (wdd->timeout == 0) {
787 err = put_user(wdd->timeout, p);
790 err = watchdog_get_timeleft(wdd, &val);
800 err = watchdog_set_pretimeout(wdd, val);
803 err = put_user(wdd->pretimeout, p);
828 struct watchdog_device *wdd;
843 wdd = wd_data->wdd;
849 hw_running = watchdog_hw_running(wdd);
850 if (!hw_running && !try_module_get(wdd->ops->owner)) {
855 err = watchdog_start(wdd);
877 module_put(wd_data->wdd->ops->owner);
905 struct watchdog_device *wdd;
911 wdd = wd_data->wdd;
912 if (!wdd)
920 if (!watchdog_active(wdd))
923 !(wdd->info->options & WDIOF_MAGICCLOSE))
924 err = watchdog_stop(wdd);
928 pr_crit("watchdog%d: watchdog did not stop!\n", wdd->id);
929 watchdog_ping(wdd);
932 watchdog_update_worker(wdd);
938 running = wdd && watchdog_hw_running(wdd);
975 * @wdd: watchdog device
982 static int watchdog_cdev_register(struct watchdog_device *wdd)
992 wd_data->wdd = wdd;
993 wdd->wd_data = wd_data;
1001 wd_data->dev.devt = MKDEV(MAJOR(watchdog_devt), wdd->id);
1003 wd_data->dev.parent = wdd->parent;
1004 wd_data->dev.groups = wdd->groups;
1006 dev_set_drvdata(&wd_data->dev, wdd);
1007 dev_set_name(&wd_data->dev, "watchdog%d", wdd->id);
1013 if (wdd->id == 0) {
1015 watchdog_miscdev.parent = wdd->parent;
1019 wdd->info->identity, WATCHDOG_MINOR, err);
1022 wdd->info->identity);
1031 wd_data->cdev.owner = wdd->ops->owner;
1037 wdd->id, MAJOR(watchdog_devt), wdd->id);
1038 if (wdd->id == 0) {
1054 if (watchdog_hw_running(wdd)) {
1055 __module_get(wdd->ops->owner);
1062 wdd->id);
1076 static void watchdog_cdev_unregister(struct watchdog_device *wdd)
1078 struct watchdog_core_data *wd_data = wdd->wd_data;
1081 if (wdd->id == 0) {
1086 if (watchdog_active(wdd) &&
1087 test_bit(WDOG_STOP_ON_UNREGISTER, &wdd->status)) {
1088 watchdog_stop(wdd);
1092 wd_data->wdd = NULL;
1093 wdd->wd_data = NULL;
1104 * @wdd: watchdog device
1111 int watchdog_dev_register(struct watchdog_device *wdd)
1115 ret = watchdog_cdev_register(wdd);
1119 ret = watchdog_register_pretimeout(wdd);
1121 watchdog_cdev_unregister(wdd);
1134 void watchdog_dev_unregister(struct watchdog_device *wdd)
1136 watchdog_unregister_pretimeout(wdd);
1137 watchdog_cdev_unregister(wdd);
1142 * @wdd: watchdog device
1151 int watchdog_set_last_hw_keepalive(struct watchdog_device *wdd,
1157 if (!wdd)
1160 wd_data = wdd->wd_data;
1166 if (watchdog_hw_running(wdd) && handle_boot_enabled)
1167 return __watchdog_ping(wdd);