Lines Matching refs:wdd
76 static inline bool watchdog_need_worker(struct watchdog_device *wdd)
79 unsigned int hm = wdd->max_hw_heartbeat_ms;
80 unsigned int t = wdd->timeout * 1000;
95 return (hm && watchdog_active(wdd) && t > hm) ||
96 (t && !watchdog_active(wdd) && watchdog_hw_running(wdd));
99 static ktime_t watchdog_next_keepalive(struct watchdog_device *wdd)
101 struct watchdog_core_data *wd_data = wdd->wd_data;
102 unsigned int timeout_ms = wdd->timeout * 1000;
108 if (watchdog_active(wdd))
114 hw_heartbeat_ms = min_not_zero(timeout_ms, wdd->max_hw_heartbeat_ms);
118 * To ensure that the watchdog times out wdd->timeout seconds
129 static inline void watchdog_update_worker(struct watchdog_device *wdd)
131 struct watchdog_core_data *wd_data = wdd->wd_data;
133 if (watchdog_need_worker(wdd)) {
134 ktime_t t = watchdog_next_keepalive(wdd);
144 static int __watchdog_ping(struct watchdog_device *wdd)
146 struct watchdog_core_data *wd_data = wdd->wd_data;
151 ms_to_ktime(wdd->min_hw_heartbeat_ms));
163 if (wdd->ops->ping) {
164 err = wdd->ops->ping(wdd); /* ping the watchdog */
165 trace_watchdog_ping(wdd, err);
167 err = wdd->ops->start(wdd); /* restart watchdog */
168 trace_watchdog_start(wdd, err);
172 watchdog_hrtimer_pretimeout_start(wdd);
174 watchdog_update_worker(wdd);
181 * @wdd: The watchdog device to ping
191 static int watchdog_ping(struct watchdog_device *wdd)
193 struct watchdog_core_data *wd_data = wdd->wd_data;
195 if (!watchdog_hw_running(wdd))
201 return __watchdog_ping(wdd);
206 struct watchdog_device *wdd = wd_data->wdd;
208 if (!wdd)
211 if (watchdog_active(wdd))
214 return watchdog_hw_running(wdd) && !watchdog_past_open_deadline(wd_data);
225 __watchdog_ping(wd_data->wdd);
241 * @wdd: The watchdog device to start
248 static int watchdog_start(struct watchdog_device *wdd)
250 struct watchdog_core_data *wd_data = wdd->wd_data;
254 if (watchdog_active(wdd))
260 if (watchdog_hw_running(wdd) && wdd->ops->ping) {
261 err = __watchdog_ping(wdd);
263 set_bit(WDOG_ACTIVE, &wdd->status);
264 watchdog_hrtimer_pretimeout_start(wdd);
267 err = wdd->ops->start(wdd);
268 trace_watchdog_start(wdd, err);
270 set_bit(WDOG_ACTIVE, &wdd->status);
271 set_bit(WDOG_HW_RUNNING, &wdd->status);
274 watchdog_update_worker(wdd);
275 watchdog_hrtimer_pretimeout_start(wdd);
284 * @wdd: The watchdog device to stop
292 static int watchdog_stop(struct watchdog_device *wdd)
296 if (!watchdog_active(wdd))
299 if (test_bit(WDOG_NO_WAY_OUT, &wdd->status)) {
301 wdd->id);
305 if (wdd->ops->stop) {
306 clear_bit(WDOG_HW_RUNNING, &wdd->status);
307 err = wdd->ops->stop(wdd);
308 trace_watchdog_stop(wdd, err);
310 set_bit(WDOG_HW_RUNNING, &wdd->status);
314 clear_bit(WDOG_ACTIVE, &wdd->status);
315 watchdog_update_worker(wdd);
316 watchdog_hrtimer_pretimeout_stop(wdd);
324 * @wdd: The watchdog device to get the status from
331 static unsigned int watchdog_get_status(struct watchdog_device *wdd)
333 struct watchdog_core_data *wd_data = wdd->wd_data;
336 if (wdd->ops->status)
337 status = wdd->ops->status(wdd);
339 status = wdd->bootstatus & (WDIOF_CARDRESET |
361 * @wdd: The watchdog device to set the timeout for
368 static int watchdog_set_timeout(struct watchdog_device *wdd,
373 if (!(wdd->info->options & WDIOF_SETTIMEOUT))
376 if (watchdog_timeout_invalid(wdd, timeout))
379 if (wdd->ops->set_timeout) {
380 err = wdd->ops->set_timeout(wdd, timeout);
381 trace_watchdog_set_timeout(wdd, timeout, err);
383 wdd->timeout = timeout;
385 if (wdd->pretimeout >= wdd->timeout)
386 wdd->pretimeout = 0;
389 watchdog_update_worker(wdd);
396 * @wdd: The watchdog device to set the timeout for
401 static int watchdog_set_pretimeout(struct watchdog_device *wdd,
406 if (!watchdog_have_pretimeout(wdd))
409 if (watchdog_pretimeout_invalid(wdd, timeout))
412 if (wdd->ops->set_pretimeout && (wdd->info->options & WDIOF_PRETIMEOUT))
413 err = wdd->ops->set_pretimeout(wdd, timeout);
415 wdd->pretimeout = timeout;
422 * @wdd: The watchdog device to get the remaining time from
430 static int watchdog_get_timeleft(struct watchdog_device *wdd,
435 if (!wdd->ops->get_timeleft)
438 *timeleft = wdd->ops->get_timeleft(wdd);
447 struct watchdog_device *wdd = dev_get_drvdata(dev);
450 &wdd->status));
456 struct watchdog_device *wdd = dev_get_drvdata(dev);
466 if (test_bit(WDOG_NO_WAY_OUT, &wdd->status) && !value)
468 watchdog_set_nowayout(wdd, value);
476 struct watchdog_device *wdd = dev_get_drvdata(dev);
477 struct watchdog_core_data *wd_data = wdd->wd_data;
481 status = watchdog_get_status(wdd);
491 struct watchdog_device *wdd = dev_get_drvdata(dev);
493 return sysfs_emit(buf, "%u\n", wdd->bootstatus);
500 struct watchdog_device *wdd = dev_get_drvdata(dev);
501 struct watchdog_core_data *wd_data = wdd->wd_data;
506 status = watchdog_get_timeleft(wdd, &val);
518 struct watchdog_device *wdd = dev_get_drvdata(dev);
520 return sysfs_emit(buf, "%u\n", wdd->timeout);
527 struct watchdog_device *wdd = dev_get_drvdata(dev);
529 return sysfs_emit(buf, "%u\n", wdd->min_timeout);
536 struct watchdog_device *wdd = dev_get_drvdata(dev);
538 return sysfs_emit(buf, "%u\n", wdd->max_timeout);
545 struct watchdog_device *wdd = dev_get_drvdata(dev);
547 return sysfs_emit(buf, "%u\n", wdd->pretimeout);
554 struct watchdog_device *wdd = dev_get_drvdata(dev);
556 return sysfs_emit(buf, "0x%x\n", wdd->info->options);
563 struct watchdog_device *wdd = dev_get_drvdata(dev);
565 return sysfs_emit(buf, "%d\n", wdd->info->firmware_version);
572 struct watchdog_device *wdd = dev_get_drvdata(dev);
574 return sysfs_emit(buf, "%s\n", wdd->info->identity);
581 struct watchdog_device *wdd = dev_get_drvdata(dev);
583 if (watchdog_active(wdd))
601 struct watchdog_device *wdd = dev_get_drvdata(dev);
603 return watchdog_pretimeout_governor_get(wdd, buf);
610 struct watchdog_device *wdd = dev_get_drvdata(dev);
611 int ret = watchdog_pretimeout_governor_set(wdd, buf);
624 struct watchdog_device *wdd = dev_get_drvdata(dev);
627 if (attr == &dev_attr_timeleft.attr && !wdd->ops->get_timeleft)
629 else if (attr == &dev_attr_pretimeout.attr && !watchdog_have_pretimeout(wdd))
633 (!watchdog_have_pretimeout(wdd) || !IS_ENABLED(CONFIG_WATCHDOG_PRETIMEOUT_GOV)))
667 * @wdd: The watchdog device to do the ioctl on
675 static int watchdog_ioctl_op(struct watchdog_device *wdd, unsigned int cmd,
678 if (!wdd->ops->ioctl)
681 return wdd->ops->ioctl(wdd, cmd, arg);
701 struct watchdog_device *wdd;
727 wdd = wd_data->wdd;
728 if (wdd)
729 err = watchdog_ping(wdd);
755 struct watchdog_device *wdd;
762 wdd = wd_data->wdd;
763 if (!wdd) {
768 err = watchdog_ioctl_op(wdd, cmd, arg);
774 err = copy_to_user(argp, wdd->info,
778 val = watchdog_get_status(wdd);
782 err = put_user(wdd->bootstatus, p);
790 err = watchdog_stop(wdd);
795 err = watchdog_start(wdd);
798 if (!(wdd->info->options & WDIOF_KEEPALIVEPING)) {
802 err = watchdog_ping(wdd);
809 err = watchdog_set_timeout(wdd, val);
815 err = watchdog_ping(wdd);
821 if (wdd->timeout == 0) {
825 err = put_user(wdd->timeout, p);
828 err = watchdog_get_timeleft(wdd, &val);
838 err = watchdog_set_pretimeout(wdd, val);
841 err = put_user(wdd->pretimeout, p);
867 struct watchdog_device *wdd;
882 wdd = wd_data->wdd;
888 hw_running = watchdog_hw_running(wdd);
889 if (!hw_running && !try_module_get(wdd->ops->owner)) {
894 err = watchdog_start(wdd);
916 module_put(wd_data->wdd->ops->owner);
945 struct watchdog_device *wdd;
951 wdd = wd_data->wdd;
952 if (!wdd)
960 if (!watchdog_active(wdd))
963 !(wdd->info->options & WDIOF_MAGICCLOSE))
964 err = watchdog_stop(wdd);
968 pr_crit("watchdog%d: watchdog did not stop!\n", wdd->id);
969 watchdog_ping(wdd);
972 watchdog_update_worker(wdd);
978 running = wdd && watchdog_hw_running(wdd);
1014 * @wdd: Watchdog device
1022 static int watchdog_cdev_register(struct watchdog_device *wdd)
1032 wd_data->wdd = wdd;
1033 wdd->wd_data = wd_data;
1041 wd_data->dev.devt = MKDEV(MAJOR(watchdog_devt), wdd->id);
1043 wd_data->dev.parent = wdd->parent;
1044 wd_data->dev.groups = wdd->groups;
1046 dev_set_drvdata(&wd_data->dev, wdd);
1047 err = dev_set_name(&wd_data->dev, "watchdog%d", wdd->id);
1056 watchdog_hrtimer_pretimeout_init(wdd);
1058 if (wdd->id == 0) {
1060 watchdog_miscdev.parent = wdd->parent;
1064 wdd->info->identity, WATCHDOG_MINOR, err);
1067 wdd->info->identity);
1076 wd_data->cdev.owner = wdd->ops->owner;
1082 wdd->id, MAJOR(watchdog_devt), wdd->id);
1083 if (wdd->id == 0) {
1099 if (watchdog_hw_running(wdd)) {
1100 __module_get(wdd->ops->owner);
1107 wdd->id);
1115 * @wdd: Watchdog device
1120 static void watchdog_cdev_unregister(struct watchdog_device *wdd)
1122 struct watchdog_core_data *wd_data = wdd->wd_data;
1125 if (wdd->id == 0) {
1130 if (watchdog_active(wdd) &&
1131 test_bit(WDOG_STOP_ON_UNREGISTER, &wdd->status)) {
1132 watchdog_stop(wdd);
1135 watchdog_hrtimer_pretimeout_stop(wdd);
1138 wd_data->wdd = NULL;
1139 wdd->wd_data = NULL;
1150 * @wdd: Watchdog device
1158 int watchdog_dev_register(struct watchdog_device *wdd)
1162 ret = watchdog_cdev_register(wdd);
1166 ret = watchdog_register_pretimeout(wdd);
1168 watchdog_cdev_unregister(wdd);
1175 * @wdd: watchdog device
1180 void watchdog_dev_unregister(struct watchdog_device *wdd)
1182 watchdog_unregister_pretimeout(wdd);
1183 watchdog_cdev_unregister(wdd);
1188 * @wdd: Watchdog device
1199 int watchdog_set_last_hw_keepalive(struct watchdog_device *wdd,
1205 if (!wdd)
1208 wd_data = wdd->wd_data;
1214 if (watchdog_hw_running(wdd) && handle_boot_enabled)
1215 return __watchdog_ping(wdd);
1272 int watchdog_dev_suspend(struct watchdog_device *wdd)
1274 struct watchdog_core_data *wd_data = wdd->wd_data;
1277 if (!wdd->wd_data)
1283 ret = __watchdog_ping(wd_data->wdd);
1299 int watchdog_dev_resume(struct watchdog_device *wdd)
1301 struct watchdog_core_data *wd_data = wdd->wd_data;
1304 if (!wdd->wd_data)
1313 ret = __watchdog_ping(wd_data->wdd);