| /linux-4.4.14/drivers/watchdog/ |
| H A D | watchdog_dev.c | 54 * @wdd: the watchdog device to ping
62 static int watchdog_ping(struct watchdog_device *wdd) watchdog_ping() argument
66 mutex_lock(&wdd->lock); watchdog_ping()
68 if (test_bit(WDOG_UNREGISTERED, &wdd->status)) { watchdog_ping()
73 if (!watchdog_active(wdd)) watchdog_ping()
76 if (wdd->ops->ping) watchdog_ping()
77 err = wdd->ops->ping(wdd); /* ping the watchdog */ watchdog_ping()
79 err = wdd->ops->start(wdd); /* restart watchdog */ watchdog_ping()
82 mutex_unlock(&wdd->lock); watchdog_ping()
88 * @wdd: the watchdog device to start
95 static int watchdog_start(struct watchdog_device *wdd) watchdog_start() argument
99 mutex_lock(&wdd->lock); watchdog_start()
101 if (test_bit(WDOG_UNREGISTERED, &wdd->status)) { watchdog_start()
106 if (watchdog_active(wdd)) watchdog_start()
109 err = wdd->ops->start(wdd); watchdog_start()
111 set_bit(WDOG_ACTIVE, &wdd->status); watchdog_start()
114 mutex_unlock(&wdd->lock); watchdog_start()
120 * @wdd: the watchdog device to stop
128 static int watchdog_stop(struct watchdog_device *wdd) watchdog_stop() argument
132 mutex_lock(&wdd->lock); watchdog_stop()
134 if (test_bit(WDOG_UNREGISTERED, &wdd->status)) { watchdog_stop()
139 if (!watchdog_active(wdd)) watchdog_stop()
142 if (test_bit(WDOG_NO_WAY_OUT, &wdd->status)) { watchdog_stop()
143 dev_info(wdd->dev, "nowayout prevents watchdog being stopped!\n"); watchdog_stop()
148 err = wdd->ops->stop(wdd); watchdog_stop()
150 clear_bit(WDOG_ACTIVE, &wdd->status); watchdog_stop()
153 mutex_unlock(&wdd->lock); watchdog_stop()
159 * @wdd: the watchdog device to get the status from
165 static int watchdog_get_status(struct watchdog_device *wdd, watchdog_get_status() argument
171 if (!wdd->ops->status) watchdog_get_status()
174 mutex_lock(&wdd->lock); watchdog_get_status()
176 if (test_bit(WDOG_UNREGISTERED, &wdd->status)) { watchdog_get_status()
181 *status = wdd->ops->status(wdd); watchdog_get_status()
184 mutex_unlock(&wdd->lock); watchdog_get_status()
190 * @wdd: the watchdog device to set the timeout for
194 static int watchdog_set_timeout(struct watchdog_device *wdd, watchdog_set_timeout() argument
199 if (!wdd->ops->set_timeout || !(wdd->info->options & WDIOF_SETTIMEOUT)) watchdog_set_timeout()
202 if (watchdog_timeout_invalid(wdd, timeout)) watchdog_set_timeout()
205 mutex_lock(&wdd->lock); watchdog_set_timeout()
207 if (test_bit(WDOG_UNREGISTERED, &wdd->status)) { watchdog_set_timeout()
212 err = wdd->ops->set_timeout(wdd, timeout); watchdog_set_timeout()
215 mutex_unlock(&wdd->lock); watchdog_set_timeout()
221 * @wdd: the watchdog device to get the remaining time from
227 static int watchdog_get_timeleft(struct watchdog_device *wdd, watchdog_get_timeleft() argument
233 if (!wdd->ops->get_timeleft) watchdog_get_timeleft()
236 mutex_lock(&wdd->lock); watchdog_get_timeleft()
238 if (test_bit(WDOG_UNREGISTERED, &wdd->status)) { watchdog_get_timeleft()
243 *timeleft = wdd->ops->get_timeleft(wdd); watchdog_get_timeleft()
246 mutex_unlock(&wdd->lock); watchdog_get_timeleft()
252 * @wdd: the watchdog device to do the ioctl on
257 static int watchdog_ioctl_op(struct watchdog_device *wdd, unsigned int cmd, watchdog_ioctl_op() argument
262 if (!wdd->ops->ioctl) watchdog_ioctl_op()
265 mutex_lock(&wdd->lock); watchdog_ioctl_op()
267 if (test_bit(WDOG_UNREGISTERED, &wdd->status)) { watchdog_ioctl_op()
272 err = wdd->ops->ioctl(wdd, cmd, arg); watchdog_ioctl_op()
275 mutex_unlock(&wdd->lock); watchdog_ioctl_op()
294 struct watchdog_device *wdd = file->private_data; watchdog_write() local
306 clear_bit(WDOG_ALLOW_RELEASE, &wdd->status); watchdog_write()
313 set_bit(WDOG_ALLOW_RELEASE, &wdd->status); watchdog_write()
317 err = watchdog_ping(wdd); watchdog_write()
337 struct watchdog_device *wdd = file->private_data; watchdog_ioctl() local
343 err = watchdog_ioctl_op(wdd, cmd, arg); watchdog_ioctl()
349 return copy_to_user(argp, wdd->info, watchdog_ioctl()
352 err = watchdog_get_status(wdd, &val); watchdog_ioctl()
357 return put_user(wdd->bootstatus, p); watchdog_ioctl()
362 err = watchdog_stop(wdd); watchdog_ioctl()
367 err = watchdog_start(wdd); watchdog_ioctl()
373 if (!(wdd->info->options & WDIOF_KEEPALIVEPING)) watchdog_ioctl()
375 return watchdog_ping(wdd); watchdog_ioctl()
379 err = watchdog_set_timeout(wdd, val); watchdog_ioctl()
385 err = watchdog_ping(wdd); watchdog_ioctl()
391 if (wdd->timeout == 0) watchdog_ioctl()
393 return put_user(wdd->timeout, p); watchdog_ioctl()
395 err = watchdog_get_timeleft(wdd, &val); watchdog_ioctl()
417 struct watchdog_device *wdd; watchdog_open() local
421 wdd = old_wdd; watchdog_open()
423 wdd = container_of(inode->i_cdev, struct watchdog_device, cdev); watchdog_open()
426 if (test_and_set_bit(WDOG_DEV_OPEN, &wdd->status)) watchdog_open()
433 if (!try_module_get(wdd->ops->owner)) watchdog_open()
436 err = watchdog_start(wdd); watchdog_open()
440 file->private_data = wdd; watchdog_open()
442 if (wdd->ops->ref) watchdog_open()
443 wdd->ops->ref(wdd); watchdog_open()
449 module_put(wdd->ops->owner); watchdog_open()
451 clear_bit(WDOG_DEV_OPEN, &wdd->status); watchdog_open()
467 struct watchdog_device *wdd = file->private_data; watchdog_release() local
475 if (!test_bit(WDOG_ACTIVE, &wdd->status)) watchdog_release()
477 else if (test_and_clear_bit(WDOG_ALLOW_RELEASE, &wdd->status) || watchdog_release()
478 !(wdd->info->options & WDIOF_MAGICCLOSE)) watchdog_release()
479 err = watchdog_stop(wdd); watchdog_release()
483 mutex_lock(&wdd->lock); watchdog_release()
484 if (!test_bit(WDOG_UNREGISTERED, &wdd->status)) watchdog_release()
485 dev_crit(wdd->dev, "watchdog did not stop!\n"); watchdog_release()
486 mutex_unlock(&wdd->lock); watchdog_release()
487 watchdog_ping(wdd); watchdog_release()
491 module_put(wdd->ops->owner); watchdog_release()
494 clear_bit(WDOG_DEV_OPEN, &wdd->status); watchdog_release()
496 /* Note wdd may be gone after this, do not use after this! */ watchdog_release()
497 if (wdd->ops->unref) watchdog_release()
498 wdd->ops->unref(wdd); watchdog_release()
519 * @wdd: watchdog device
526 int watchdog_dev_register(struct watchdog_device *wdd) watchdog_dev_register() argument
530 if (wdd->id == 0) { watchdog_dev_register()
531 old_wdd = wdd; watchdog_dev_register()
532 watchdog_miscdev.parent = wdd->parent; watchdog_dev_register()
536 wdd->info->identity, WATCHDOG_MINOR, err); watchdog_dev_register()
539 wdd->info->identity); watchdog_dev_register()
546 devno = MKDEV(MAJOR(watchdog_devt), wdd->id); watchdog_dev_register()
547 cdev_init(&wdd->cdev, &watchdog_fops); watchdog_dev_register()
548 wdd->cdev.owner = wdd->ops->owner; watchdog_dev_register()
551 err = cdev_add(&wdd->cdev, devno, 1); watchdog_dev_register()
554 wdd->id, MAJOR(watchdog_devt), wdd->id); watchdog_dev_register()
555 if (wdd->id == 0) { watchdog_dev_register()
570 int watchdog_dev_unregister(struct watchdog_device *wdd) watchdog_dev_unregister() argument
572 mutex_lock(&wdd->lock); watchdog_dev_unregister()
573 set_bit(WDOG_UNREGISTERED, &wdd->status); watchdog_dev_unregister()
574 mutex_unlock(&wdd->lock); watchdog_dev_unregister()
576 cdev_del(&wdd->cdev); watchdog_dev_unregister()
577 if (wdd->id == 0) { watchdog_dev_unregister()
|
| H A D | bcm47xx_wdt.c | 47 static inline struct bcm47xx_wdt *bcm47xx_wdt_get(struct watchdog_device *wdd) bcm47xx_wdt_get() argument
49 return container_of(wdd, struct bcm47xx_wdt, wdd); bcm47xx_wdt_get()
52 static int bcm47xx_wdt_hard_keepalive(struct watchdog_device *wdd) bcm47xx_wdt_hard_keepalive() argument
54 struct bcm47xx_wdt *wdt = bcm47xx_wdt_get(wdd); bcm47xx_wdt_hard_keepalive()
56 wdt->timer_set_ms(wdt, wdd->timeout * 1000); bcm47xx_wdt_hard_keepalive()
61 static int bcm47xx_wdt_hard_start(struct watchdog_device *wdd) bcm47xx_wdt_hard_start() argument
66 static int bcm47xx_wdt_hard_stop(struct watchdog_device *wdd) bcm47xx_wdt_hard_stop() argument
68 struct bcm47xx_wdt *wdt = bcm47xx_wdt_get(wdd); bcm47xx_wdt_hard_stop()
75 static int bcm47xx_wdt_hard_set_timeout(struct watchdog_device *wdd, bcm47xx_wdt_hard_set_timeout() argument
78 struct bcm47xx_wdt *wdt = bcm47xx_wdt_get(wdd); bcm47xx_wdt_hard_set_timeout()
87 wdd->timeout = new_time; bcm47xx_wdt_hard_set_timeout()
102 u32 next_tick = min(wdt->wdd.timeout * 1000, wdt->max_timer_ms); bcm47xx_wdt_soft_timer_tick()
112 static int bcm47xx_wdt_soft_keepalive(struct watchdog_device *wdd) bcm47xx_wdt_soft_keepalive() argument
114 struct bcm47xx_wdt *wdt = bcm47xx_wdt_get(wdd); bcm47xx_wdt_soft_keepalive()
116 atomic_set(&wdt->soft_ticks, wdd->timeout); bcm47xx_wdt_soft_keepalive()
121 static int bcm47xx_wdt_soft_start(struct watchdog_device *wdd) bcm47xx_wdt_soft_start() argument
123 struct bcm47xx_wdt *wdt = bcm47xx_wdt_get(wdd); bcm47xx_wdt_soft_start()
125 bcm47xx_wdt_soft_keepalive(wdd); bcm47xx_wdt_soft_start()
131 static int bcm47xx_wdt_soft_stop(struct watchdog_device *wdd) bcm47xx_wdt_soft_stop() argument
133 struct bcm47xx_wdt *wdt = bcm47xx_wdt_get(wdd); bcm47xx_wdt_soft_stop()
141 static int bcm47xx_wdt_soft_set_timeout(struct watchdog_device *wdd, bcm47xx_wdt_soft_set_timeout() argument
150 wdd->timeout = new_time; bcm47xx_wdt_soft_set_timeout()
168 wdt->wdd.ops->stop(&wdt->wdd); bcm47xx_wdt_notify_sys()
203 wdt->wdd.ops = &bcm47xx_wdt_soft_ops; bcm47xx_wdt_probe()
207 wdt->wdd.ops = &bcm47xx_wdt_hard_ops; bcm47xx_wdt_probe()
210 wdt->wdd.info = &bcm47xx_wdt_info; bcm47xx_wdt_probe()
211 wdt->wdd.timeout = WDT_DEFAULT_TIME; bcm47xx_wdt_probe()
212 wdt->wdd.parent = &pdev->dev; bcm47xx_wdt_probe()
213 ret = wdt->wdd.ops->set_timeout(&wdt->wdd, timeout); bcm47xx_wdt_probe()
216 watchdog_set_nowayout(&wdt->wdd, nowayout); bcm47xx_wdt_probe()
230 ret = watchdog_register_device(&wdt->wdd); bcm47xx_wdt_probe()
257 watchdog_unregister_device(&wdt->wdd); bcm47xx_wdt_remove()
|
| H A D | watchdog_core.c | 63 static int watchdog_deferred_registration_add(struct watchdog_device *wdd) watchdog_deferred_registration_add() argument
65 list_add_tail(&wdd->deferred, watchdog_deferred_registration_add()
70 static void watchdog_deferred_registration_del(struct watchdog_device *wdd) watchdog_deferred_registration_del() argument
78 if (wdd_tmp == wdd) { watchdog_deferred_registration_del()
85 static void watchdog_check_min_max_timeout(struct watchdog_device *wdd) watchdog_check_min_max_timeout() argument
91 if (wdd->min_timeout > wdd->max_timeout) { watchdog_check_min_max_timeout()
93 wdd->min_timeout = 0; watchdog_check_min_max_timeout()
94 wdd->max_timeout = 0; watchdog_check_min_max_timeout()
111 int watchdog_init_timeout(struct watchdog_device *wdd, watchdog_init_timeout() argument
117 watchdog_check_min_max_timeout(wdd); watchdog_init_timeout()
120 if (!watchdog_timeout_invalid(wdd, timeout_parm) && timeout_parm) { watchdog_init_timeout()
121 wdd->timeout = timeout_parm; watchdog_init_timeout()
131 if (!watchdog_timeout_invalid(wdd, t) && t) watchdog_init_timeout()
132 wdd->timeout = t; watchdog_init_timeout()
140 static int __watchdog_register_device(struct watchdog_device *wdd) __watchdog_register_device() argument
144 if (wdd == NULL || wdd->info == NULL || wdd->ops == NULL) __watchdog_register_device()
148 if (wdd->ops->start == NULL || wdd->ops->stop == NULL) __watchdog_register_device()
151 watchdog_check_min_max_timeout(wdd); __watchdog_register_device()
159 mutex_init(&wdd->lock); __watchdog_register_device()
162 if (wdd->parent) { __watchdog_register_device()
163 ret = of_alias_get_id(wdd->parent->of_node, "watchdog"); __watchdog_register_device()
174 wdd->id = id; __watchdog_register_device()
176 ret = watchdog_dev_register(wdd); __watchdog_register_device()
186 wdd->id = id; __watchdog_register_device()
188 ret = watchdog_dev_register(wdd); __watchdog_register_device()
195 devno = wdd->cdev.dev; __watchdog_register_device()
196 wdd->dev = device_create(watchdog_class, wdd->parent, devno, __watchdog_register_device()
197 NULL, "watchdog%d", wdd->id); __watchdog_register_device()
198 if (IS_ERR(wdd->dev)) { __watchdog_register_device()
199 watchdog_dev_unregister(wdd); __watchdog_register_device()
201 ret = PTR_ERR(wdd->dev); __watchdog_register_device()
210 * @wdd: watchdog device
219 int watchdog_register_device(struct watchdog_device *wdd) watchdog_register_device() argument
225 ret = __watchdog_register_device(wdd); watchdog_register_device()
227 ret = watchdog_deferred_registration_add(wdd); watchdog_register_device()
233 static void __watchdog_unregister_device(struct watchdog_device *wdd) __watchdog_unregister_device() argument
238 if (wdd == NULL) __watchdog_unregister_device()
241 devno = wdd->cdev.dev; __watchdog_unregister_device()
242 ret = watchdog_dev_unregister(wdd); __watchdog_unregister_device()
246 ida_simple_remove(&watchdog_ida, wdd->id); __watchdog_unregister_device()
247 wdd->dev = NULL; __watchdog_unregister_device()
252 * @wdd: watchdog device to unregister
258 void watchdog_unregister_device(struct watchdog_device *wdd) watchdog_unregister_device() argument
262 __watchdog_unregister_device(wdd); watchdog_unregister_device()
264 watchdog_deferred_registration_del(wdd); watchdog_unregister_device()
275 struct watchdog_device *wdd; watchdog_deferred_registration() local
277 wdd = list_first_entry(&wtd_deferred_reg_list, watchdog_deferred_registration()
279 list_del(&wdd->deferred); watchdog_deferred_registration()
280 __watchdog_register_device(wdd); watchdog_deferred_registration()
|
| H A D | stmp3xxx_rtc_wdt.c | 28 static int wdt_start(struct watchdog_device *wdd) wdt_start() argument
30 struct device *dev = watchdog_get_drvdata(wdd); wdt_start()
33 pdata->wdt_set_timeout(dev->parent, wdd->timeout * WDOG_TICK_RATE); wdt_start()
37 static int wdt_stop(struct watchdog_device *wdd) wdt_stop() argument
39 struct device *dev = watchdog_get_drvdata(wdd); wdt_stop()
46 static int wdt_set_timeout(struct watchdog_device *wdd, unsigned new_timeout) wdt_set_timeout() argument
48 wdd->timeout = new_timeout; wdt_set_timeout()
49 return wdt_start(wdd); wdt_set_timeout()
100 struct watchdog_device *wdd = &stmp3xxx_wdd; stmp3xxx_wdt_suspend() local
102 if (watchdog_active(wdd)) stmp3xxx_wdt_suspend()
103 return wdt_stop(wdd); stmp3xxx_wdt_suspend()
110 struct watchdog_device *wdd = &stmp3xxx_wdd; stmp3xxx_wdt_resume() local
112 if (watchdog_active(wdd)) stmp3xxx_wdt_resume()
113 return wdt_start(wdd); stmp3xxx_wdt_resume()
|
| H A D | sama5d4_wdt.c | 29 struct watchdog_device wdd; member in struct:sama5d4_wdt
53 static int sama5d4_wdt_start(struct watchdog_device *wdd) sama5d4_wdt_start() argument
55 struct sama5d4_wdt *wdt = watchdog_get_drvdata(wdd); sama5d4_wdt_start()
65 static int sama5d4_wdt_stop(struct watchdog_device *wdd) sama5d4_wdt_stop() argument
67 struct sama5d4_wdt *wdt = watchdog_get_drvdata(wdd); sama5d4_wdt_stop()
77 static int sama5d4_wdt_ping(struct watchdog_device *wdd) sama5d4_wdt_ping() argument
79 struct sama5d4_wdt *wdt = watchdog_get_drvdata(wdd); sama5d4_wdt_ping()
86 static int sama5d4_wdt_set_timeout(struct watchdog_device *wdd, sama5d4_wdt_set_timeout() argument
89 struct sama5d4_wdt *wdt = watchdog_get_drvdata(wdd); sama5d4_wdt_set_timeout()
100 wdd->timeout = timeout; sama5d4_wdt_set_timeout()
154 struct watchdog_device *wdd = &wdt->wdd; sama5d4_wdt_init() local
155 u32 value = WDT_SEC2TICKS(wdd->timeout); sama5d4_wdt_init()
177 struct watchdog_device *wdd; sama5d4_wdt_probe() local
188 wdd = &wdt->wdd; sama5d4_wdt_probe()
189 wdd->timeout = wdt_timeout; sama5d4_wdt_probe()
190 wdd->info = &sama5d4_wdt_info; sama5d4_wdt_probe()
191 wdd->ops = &sama5d4_wdt_ops; sama5d4_wdt_probe()
192 wdd->min_timeout = MIN_WDT_TIMEOUT; sama5d4_wdt_probe()
193 wdd->max_timeout = MAX_WDT_TIMEOUT; sama5d4_wdt_probe()
195 watchdog_set_drvdata(wdd, wdt); sama5d4_wdt_probe()
225 ret = watchdog_init_timeout(wdd, wdt_timeout, &pdev->dev); sama5d4_wdt_probe()
235 watchdog_set_nowayout(wdd, nowayout); sama5d4_wdt_probe()
237 ret = watchdog_register_device(wdd); sama5d4_wdt_probe()
255 sama5d4_wdt_stop(&wdt->wdd); sama5d4_wdt_remove()
257 watchdog_unregister_device(&wdt->wdd); sama5d4_wdt_remove()
|
| H A D | davinci_wdt.c | 63 * @wdd - hold watchdog device as is in WDT core
68 struct watchdog_device wdd; member in struct:davinci_wdt_device
71 static int davinci_wdt_start(struct watchdog_device *wdd) davinci_wdt_start() argument
76 struct davinci_wdt_device *davinci_wdt = watchdog_get_drvdata(wdd); davinci_wdt_start()
90 timer_margin = (((u64)wdd->timeout * wdt_freq) & 0xffffffff); davinci_wdt_start()
92 timer_margin = (((u64)wdd->timeout * wdt_freq) >> 32); davinci_wdt_start()
107 static int davinci_wdt_ping(struct watchdog_device *wdd) davinci_wdt_ping() argument
109 struct davinci_wdt_device *davinci_wdt = watchdog_get_drvdata(wdd); davinci_wdt_ping()
118 static unsigned int davinci_wdt_get_timeleft(struct watchdog_device *wdd) davinci_wdt_get_timeleft() argument
123 struct davinci_wdt_device *davinci_wdt = watchdog_get_drvdata(wdd); davinci_wdt_get_timeleft()
140 return wdd->timeout - timer_counter; davinci_wdt_get_timeleft()
161 struct watchdog_device *wdd; davinci_wdt_probe() local
176 wdd = &davinci_wdt->wdd; davinci_wdt_probe()
177 wdd->info = &davinci_wdt_info; davinci_wdt_probe()
178 wdd->ops = &davinci_wdt_ops; davinci_wdt_probe()
179 wdd->min_timeout = 1; davinci_wdt_probe()
180 wdd->max_timeout = MAX_HEARTBEAT; davinci_wdt_probe()
181 wdd->timeout = DEFAULT_HEARTBEAT; davinci_wdt_probe()
182 wdd->parent = &pdev->dev; davinci_wdt_probe()
184 watchdog_init_timeout(wdd, heartbeat, dev); davinci_wdt_probe()
186 dev_info(dev, "heartbeat %d sec\n", wdd->timeout); davinci_wdt_probe()
188 watchdog_set_drvdata(wdd, davinci_wdt); davinci_wdt_probe()
189 watchdog_set_nowayout(wdd, 1); davinci_wdt_probe()
196 ret = watchdog_register_device(wdd); davinci_wdt_probe()
207 watchdog_unregister_device(&davinci_wdt->wdd); davinci_wdt_remove()
|
| H A D | tegra_wdt.c | 68 struct watchdog_device wdd; member in struct:tegra_wdt
86 static int tegra_wdt_start(struct watchdog_device *wdd) tegra_wdt_start() argument
88 struct tegra_wdt *wdt = watchdog_get_drvdata(wdd); tegra_wdt_start()
109 (wdd->timeout << WDT_CFG_PERIOD_SHIFT) | tegra_wdt_start()
118 static int tegra_wdt_stop(struct watchdog_device *wdd) tegra_wdt_stop() argument
120 struct tegra_wdt *wdt = watchdog_get_drvdata(wdd); tegra_wdt_stop()
129 static int tegra_wdt_ping(struct watchdog_device *wdd) tegra_wdt_ping() argument
131 struct tegra_wdt *wdt = watchdog_get_drvdata(wdd); tegra_wdt_ping()
138 static int tegra_wdt_set_timeout(struct watchdog_device *wdd, tegra_wdt_set_timeout() argument
141 wdd->timeout = timeout; tegra_wdt_set_timeout()
143 if (watchdog_active(wdd)) { tegra_wdt_set_timeout()
144 tegra_wdt_stop(wdd); tegra_wdt_set_timeout()
145 return tegra_wdt_start(wdd); tegra_wdt_set_timeout()
151 static unsigned int tegra_wdt_get_timeleft(struct watchdog_device *wdd) tegra_wdt_get_timeleft() argument
153 struct tegra_wdt *wdt = watchdog_get_drvdata(wdd); tegra_wdt_get_timeleft()
170 return (((3 - exp) * wdd->timeout) + count) / 4; tegra_wdt_get_timeleft()
192 struct watchdog_device *wdd; tegra_wdt_probe() local
217 wdd = &wdt->wdd; tegra_wdt_probe()
218 wdd->timeout = heartbeat; tegra_wdt_probe()
219 wdd->info = &tegra_wdt_info; tegra_wdt_probe()
220 wdd->ops = &tegra_wdt_ops; tegra_wdt_probe()
221 wdd->min_timeout = MIN_WDT_TIMEOUT; tegra_wdt_probe()
222 wdd->max_timeout = MAX_WDT_TIMEOUT; tegra_wdt_probe()
223 wdd->parent = &pdev->dev; tegra_wdt_probe()
225 watchdog_set_drvdata(wdd, wdt); tegra_wdt_probe()
227 watchdog_set_nowayout(wdd, nowayout); tegra_wdt_probe()
229 ret = watchdog_register_device(wdd); tegra_wdt_probe()
249 tegra_wdt_stop(&wdt->wdd); tegra_wdt_remove()
251 watchdog_unregister_device(&wdt->wdd); tegra_wdt_remove()
263 if (watchdog_active(&wdt->wdd)) tegra_wdt_runtime_suspend()
264 tegra_wdt_stop(&wdt->wdd); tegra_wdt_runtime_suspend()
273 if (watchdog_active(&wdt->wdd)) tegra_wdt_runtime_resume()
274 tegra_wdt_start(&wdt->wdd); tegra_wdt_runtime_resume()
|
| H A D | sp805_wdt.c | 55 * @wdd: instance of struct watchdog_device
64 struct watchdog_device wdd; member in struct:sp805_wdt
78 static int wdt_setload(struct watchdog_device *wdd, unsigned int timeout) wdt_setload() argument
80 struct sp805_wdt *wdt = watchdog_get_drvdata(wdd); wdt_setload()
99 wdd->timeout = div_u64((load + 1) * 2 + (rate / 2), rate); wdt_setload()
106 static unsigned int wdt_timeleft(struct watchdog_device *wdd) wdt_timeleft() argument
108 struct sp805_wdt *wdt = watchdog_get_drvdata(wdd); wdt_timeleft()
124 static int wdt_config(struct watchdog_device *wdd, bool ping) wdt_config() argument
126 struct sp805_wdt *wdt = watchdog_get_drvdata(wdd); wdt_config()
158 static int wdt_ping(struct watchdog_device *wdd) wdt_ping() argument
160 return wdt_config(wdd, true); wdt_ping()
164 static int wdt_enable(struct watchdog_device *wdd) wdt_enable() argument
166 return wdt_config(wdd, false); wdt_enable()
170 static int wdt_disable(struct watchdog_device *wdd) wdt_disable() argument
172 struct sp805_wdt *wdt = watchdog_get_drvdata(wdd); wdt_disable()
227 wdt->wdd.info = &wdt_info; sp805_wdt_probe()
228 wdt->wdd.ops = &wdt_ops; sp805_wdt_probe()
229 wdt->wdd.parent = &adev->dev; sp805_wdt_probe()
232 watchdog_set_nowayout(&wdt->wdd, nowayout); sp805_wdt_probe()
233 watchdog_set_drvdata(&wdt->wdd, wdt); sp805_wdt_probe()
234 wdt_setload(&wdt->wdd, DEFAULT_TIMEOUT); sp805_wdt_probe()
236 ret = watchdog_register_device(&wdt->wdd); sp805_wdt_probe()
256 watchdog_unregister_device(&wdt->wdd); sp805_wdt_remove()
257 watchdog_set_drvdata(&wdt->wdd, NULL); sp805_wdt_remove()
266 if (watchdog_active(&wdt->wdd)) sp805_wdt_suspend()
267 return wdt_disable(&wdt->wdd); sp805_wdt_suspend()
276 if (watchdog_active(&wdt->wdd)) sp805_wdt_resume()
277 return wdt_enable(&wdt->wdd); sp805_wdt_resume()
|
| H A D | gpio_wdt.c | 41 struct watchdog_device wdd; member in struct:gpio_wdt_priv
55 struct watchdog_device *wdd = (struct watchdog_device *)data; gpio_wdt_hwping() local
56 struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd); gpio_wdt_hwping()
59 msecs_to_jiffies(wdd->timeout * 1000))) { gpio_wdt_hwping()
60 dev_crit(wdd->dev, "Timer expired. System will reboot soon!\n"); gpio_wdt_hwping()
87 gpio_wdt_hwping((unsigned long)&priv->wdd); gpio_wdt_start_impl()
90 static int gpio_wdt_start(struct watchdog_device *wdd) gpio_wdt_start() argument
92 struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd); gpio_wdt_start()
100 static int gpio_wdt_stop(struct watchdog_device *wdd) gpio_wdt_stop() argument
102 struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd); gpio_wdt_stop()
113 static int gpio_wdt_ping(struct watchdog_device *wdd) gpio_wdt_ping() argument
115 struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd); gpio_wdt_ping()
122 static int gpio_wdt_set_timeout(struct watchdog_device *wdd, unsigned int t) gpio_wdt_set_timeout() argument
124 wdd->timeout = t; gpio_wdt_set_timeout()
126 return gpio_wdt_ping(wdd); gpio_wdt_set_timeout()
214 watchdog_set_drvdata(&priv->wdd, priv); gpio_wdt_probe()
216 priv->wdd.info = &gpio_wdt_ident; gpio_wdt_probe()
217 priv->wdd.ops = &gpio_wdt_ops; gpio_wdt_probe()
218 priv->wdd.min_timeout = SOFT_TIMEOUT_MIN; gpio_wdt_probe()
219 priv->wdd.max_timeout = SOFT_TIMEOUT_MAX; gpio_wdt_probe()
220 priv->wdd.parent = &pdev->dev; gpio_wdt_probe()
222 if (watchdog_init_timeout(&priv->wdd, 0, &pdev->dev) < 0) gpio_wdt_probe()
223 priv->wdd.timeout = SOFT_TIMEOUT_DEF; gpio_wdt_probe()
225 setup_timer(&priv->timer, gpio_wdt_hwping, (unsigned long)&priv->wdd); gpio_wdt_probe()
227 ret = watchdog_register_device(&priv->wdd); gpio_wdt_probe()
242 watchdog_unregister_device(&priv->wdd); gpio_wdt_probe()
252 watchdog_unregister_device(&priv->wdd); gpio_wdt_remove()
|
| H A D | kempld_wdt.c | 83 struct watchdog_device wdd; member in struct:kempld_wdt_data
205 static int kempld_wdt_set_timeout(struct watchdog_device *wdd, kempld_wdt_set_timeout() argument
208 struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); kempld_wdt_set_timeout()
228 wdd->timeout = timeout; kempld_wdt_set_timeout()
232 static int kempld_wdt_set_pretimeout(struct watchdog_device *wdd, kempld_wdt_set_pretimeout() argument
235 struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); kempld_wdt_set_pretimeout()
245 if (pretimeout > wdd->timeout) kempld_wdt_set_pretimeout()
256 wdd->timeout - pretimeout); kempld_wdt_set_pretimeout()
284 wdt_data->wdd.timeout = pretimeout + timeout; kempld_wdt_update_timeouts()
287 static int kempld_wdt_start(struct watchdog_device *wdd) kempld_wdt_start() argument
289 struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); kempld_wdt_start()
294 ret = kempld_wdt_set_timeout(wdd, wdd->timeout); kempld_wdt_start()
312 static int kempld_wdt_stop(struct watchdog_device *wdd) kempld_wdt_stop() argument
314 struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); kempld_wdt_stop()
332 static int kempld_wdt_keepalive(struct watchdog_device *wdd) kempld_wdt_keepalive() argument
334 struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); kempld_wdt_keepalive()
344 static long kempld_wdt_ioctl(struct watchdog_device *wdd, unsigned int cmd, kempld_wdt_ioctl() argument
347 struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); kempld_wdt_ioctl()
357 ret = kempld_wdt_set_pretimeout(wdd, new_value); kempld_wdt_ioctl()
360 ret = kempld_wdt_keepalive(wdd); kempld_wdt_ioctl()
370 static int kempld_wdt_probe_stages(struct watchdog_device *wdd) kempld_wdt_probe_stages() argument
372 struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); kempld_wdt_probe_stages()
447 struct watchdog_device *wdd; kempld_wdt_probe() local
456 wdd = &wdt_data->wdd; kempld_wdt_probe()
457 wdd->parent = dev; kempld_wdt_probe()
472 wdd->info = &kempld_wdt_info; kempld_wdt_probe()
473 wdd->ops = &kempld_wdt_ops; kempld_wdt_probe()
475 watchdog_set_drvdata(wdd, wdt_data); kempld_wdt_probe()
476 watchdog_set_nowayout(wdd, nowayout); kempld_wdt_probe()
478 ret = kempld_wdt_probe_stages(wdd); kempld_wdt_probe()
482 kempld_wdt_set_timeout(wdd, timeout); kempld_wdt_probe()
483 kempld_wdt_set_pretimeout(wdd, pretimeout); kempld_wdt_probe()
493 ret = watchdog_register_device(wdd); kempld_wdt_probe()
497 dev_info(dev, "Watchdog registered with %ds timeout\n", wdd->timeout); kempld_wdt_probe()
506 kempld_wdt_stop(&wdt_data->wdd); kempld_wdt_shutdown()
512 struct watchdog_device *wdd = &wdt_data->wdd; kempld_wdt_remove() local
516 ret = kempld_wdt_stop(wdd); kempld_wdt_remove()
517 watchdog_unregister_device(wdd); kempld_wdt_remove()
529 struct watchdog_device *wdd = &wdt_data->wdd; kempld_wdt_suspend() local
538 return kempld_wdt_stop(wdd); kempld_wdt_suspend()
547 struct watchdog_device *wdd = &wdt_data->wdd; kempld_wdt_resume() local
554 return kempld_wdt_start(wdd); kempld_wdt_resume()
556 return kempld_wdt_stop(wdd); kempld_wdt_resume()
|
| H A D | bcm7038_wdt.c | 38 struct watchdog_device wdd; member in struct:bcm7038_watchdog
149 wdt->wdd.info = &bcm7038_wdt_info; bcm7038_wdt_probe()
150 wdt->wdd.ops = &bcm7038_wdt_ops; bcm7038_wdt_probe()
151 wdt->wdd.min_timeout = WDT_MIN_TIMEOUT; bcm7038_wdt_probe()
152 wdt->wdd.timeout = WDT_DEFAULT_TIMEOUT; bcm7038_wdt_probe()
153 wdt->wdd.max_timeout = 0xffffffff / wdt->rate; bcm7038_wdt_probe()
154 wdt->wdd.parent = dev; bcm7038_wdt_probe()
155 watchdog_set_drvdata(&wdt->wdd, wdt); bcm7038_wdt_probe()
157 err = watchdog_register_device(&wdt->wdd); bcm7038_wdt_probe()
174 bcm7038_wdt_stop(&wdt->wdd); bcm7038_wdt_remove()
176 watchdog_unregister_device(&wdt->wdd); bcm7038_wdt_remove()
187 if (watchdog_active(&wdt->wdd)) bcm7038_wdt_suspend()
188 return bcm7038_wdt_stop(&wdt->wdd); bcm7038_wdt_suspend()
197 if (watchdog_active(&wdt->wdd)) bcm7038_wdt_resume()
198 return bcm7038_wdt_start(&wdt->wdd); bcm7038_wdt_resume()
211 if (watchdog_active(&wdt->wdd)) bcm7038_wdt_shutdown()
212 bcm7038_wdt_stop(&wdt->wdd); bcm7038_wdt_shutdown()
|
| H A D | sirfsoc_wdt.c | 42 static unsigned int sirfsoc_wdt_gettimeleft(struct watchdog_device *wdd) sirfsoc_wdt_gettimeleft() argument
48 wdt_base = watchdog_get_drvdata(wdd); sirfsoc_wdt_gettimeleft()
58 static int sirfsoc_wdt_updatetimeout(struct watchdog_device *wdd) sirfsoc_wdt_updatetimeout() argument
63 timeout_ticks = wdd->timeout * CLOCK_FREQ; sirfsoc_wdt_updatetimeout()
64 wdt_base = watchdog_get_drvdata(wdd); sirfsoc_wdt_updatetimeout()
80 static int sirfsoc_wdt_enable(struct watchdog_device *wdd) sirfsoc_wdt_enable() argument
82 void __iomem *wdt_base = watchdog_get_drvdata(wdd); sirfsoc_wdt_enable()
83 sirfsoc_wdt_updatetimeout(wdd); sirfsoc_wdt_enable()
97 static int sirfsoc_wdt_disable(struct watchdog_device *wdd) sirfsoc_wdt_disable() argument
99 void __iomem *wdt_base = watchdog_get_drvdata(wdd); sirfsoc_wdt_disable()
109 static int sirfsoc_wdt_settimeout(struct watchdog_device *wdd, unsigned int to) sirfsoc_wdt_settimeout() argument
111 wdd->timeout = to; sirfsoc_wdt_settimeout()
112 sirfsoc_wdt_updatetimeout(wdd); sirfsoc_wdt_settimeout()
170 struct watchdog_device *wdd = platform_get_drvdata(pdev); sirfsoc_wdt_shutdown() local
172 sirfsoc_wdt_disable(wdd); sirfsoc_wdt_shutdown()
189 struct watchdog_device *wdd = dev_get_drvdata(dev); sirfsoc_wdt_resume() local
196 sirfsoc_wdt_updatetimeout(wdd); sirfsoc_wdt_resume()
|
| H A D | qcom-wdt.c | 28 struct watchdog_device wdd; member in struct:qcom_wdt
36 struct qcom_wdt *to_qcom_wdt(struct watchdog_device *wdd) to_qcom_wdt() argument
38 return container_of(wdd, struct qcom_wdt, wdd); to_qcom_wdt()
41 static int qcom_wdt_start(struct watchdog_device *wdd) qcom_wdt_start() argument
43 struct qcom_wdt *wdt = to_qcom_wdt(wdd); qcom_wdt_start()
47 writel(wdd->timeout * wdt->rate, wdt->base + WDT_BITE_TIME); qcom_wdt_start()
52 static int qcom_wdt_stop(struct watchdog_device *wdd) qcom_wdt_stop() argument
54 struct qcom_wdt *wdt = to_qcom_wdt(wdd); qcom_wdt_stop()
60 static int qcom_wdt_ping(struct watchdog_device *wdd) qcom_wdt_ping() argument
62 struct qcom_wdt *wdt = to_qcom_wdt(wdd); qcom_wdt_ping()
68 static int qcom_wdt_set_timeout(struct watchdog_device *wdd, qcom_wdt_set_timeout() argument
71 wdd->timeout = timeout; qcom_wdt_set_timeout()
72 return qcom_wdt_start(wdd); qcom_wdt_set_timeout()
169 wdt->wdd.dev = &pdev->dev; qcom_wdt_probe()
170 wdt->wdd.info = &qcom_wdt_info; qcom_wdt_probe()
171 wdt->wdd.ops = &qcom_wdt_ops; qcom_wdt_probe()
172 wdt->wdd.min_timeout = 1; qcom_wdt_probe()
173 wdt->wdd.max_timeout = 0x10000000U / wdt->rate; qcom_wdt_probe()
174 wdt->wdd.parent = &pdev->dev; qcom_wdt_probe()
181 wdt->wdd.timeout = min(wdt->wdd.max_timeout, 30U); qcom_wdt_probe()
182 watchdog_init_timeout(&wdt->wdd, 0, &pdev->dev); qcom_wdt_probe()
184 ret = watchdog_register_device(&wdt->wdd); qcom_wdt_probe()
211 watchdog_unregister_device(&wdt->wdd); qcom_wdt_remove()
|
| H A D | at91sam9_wdt.c | 83 #define to_wdt(wdd) container_of(wdd, struct at91wdt, wdd)
85 struct watchdog_device wdd; member in struct:at91wdt
127 !watchdog_active(&wdt->wdd)) { at91_ping()
135 static int at91_wdt_start(struct watchdog_device *wdd) at91_wdt_start() argument
137 struct at91wdt *wdt = to_wdt(wdd); at91_wdt_start()
139 wdt->next_heartbeat = jiffies + wdd->timeout * HZ; at91_wdt_start()
143 static int at91_wdt_stop(struct watchdog_device *wdd) at91_wdt_stop() argument
149 static int at91_wdt_set_timeout(struct watchdog_device *wdd, unsigned int new_timeout) at91_wdt_set_timeout() argument
151 wdd->timeout = new_timeout; at91_wdt_set_timeout()
152 return at91_wdt_start(wdd); at91_wdt_set_timeout()
237 if (watchdog_init_timeout(&wdt->wdd, 0, dev)) at91_wdt_init()
238 watchdog_init_timeout(&wdt->wdd, heartbeat, dev); at91_wdt_init()
239 watchdog_set_nowayout(&wdt->wdd, wdt->nowayout); at91_wdt_init()
240 err = watchdog_register_device(&wdt->wdd); at91_wdt_init()
244 wdt->next_heartbeat = jiffies + wdt->wdd.timeout * HZ; at91_wdt_init()
278 dev_warn(wdt->wdd.parent, "failed to get IRQ from DT\n"); of_at91wdt_init()
345 wdt->wdd.parent = &pdev->dev; at91wdt_probe()
346 wdt->wdd.info = &at91_wdt_info; at91wdt_probe()
347 wdt->wdd.ops = &at91_wdt_ops; at91wdt_probe()
348 wdt->wdd.timeout = WDT_HEARTBEAT; at91wdt_probe()
349 wdt->wdd.min_timeout = 1; at91wdt_probe()
350 wdt->wdd.max_timeout = 0xFFFF; at91wdt_probe()
380 wdt->wdd.timeout, wdt->nowayout); at91wdt_probe()
393 watchdog_unregister_device(&wdt->wdd); at91wdt_remove()
|
| H A D | max63xx_wdt.c | 47 struct watchdog_device wdd; member in struct:max63xx_wdt
119 static int max63xx_wdt_ping(struct watchdog_device *wdd) max63xx_wdt_ping() argument
121 struct max63xx_wdt *wdt = watchdog_get_drvdata(wdd); max63xx_wdt_ping()
127 static int max63xx_wdt_start(struct watchdog_device *wdd) max63xx_wdt_start() argument
129 struct max63xx_wdt *wdt = watchdog_get_drvdata(wdd); max63xx_wdt_start()
139 static int max63xx_wdt_stop(struct watchdog_device *wdd) max63xx_wdt_stop() argument
141 struct max63xx_wdt *wdt = watchdog_get_drvdata(wdd); max63xx_wdt_stop()
228 platform_set_drvdata(pdev, &wdt->wdd); max63xx_wdt_probe()
229 watchdog_set_drvdata(&wdt->wdd, wdt); max63xx_wdt_probe()
231 wdt->wdd.parent = &pdev->dev; max63xx_wdt_probe()
232 wdt->wdd.timeout = wdt->timeout->twd; max63xx_wdt_probe()
233 wdt->wdd.info = &max63xx_wdt_info; max63xx_wdt_probe()
234 wdt->wdd.ops = &max63xx_wdt_ops; max63xx_wdt_probe()
236 watchdog_set_nowayout(&wdt->wdd, nowayout); max63xx_wdt_probe()
238 err = watchdog_register_device(&wdt->wdd); max63xx_wdt_probe()
249 struct watchdog_device *wdd = platform_get_drvdata(pdev); max63xx_wdt_remove() local
251 watchdog_unregister_device(wdd); max63xx_wdt_remove()
|
| H A D | da9062_wdt.c | 109 static int da9062_wdt_start(struct watchdog_device *wdd) da9062_wdt_start() argument
111 struct da9062_watchdog *wdt = watchdog_get_drvdata(wdd); da9062_wdt_start()
124 static int da9062_wdt_stop(struct watchdog_device *wdd) da9062_wdt_stop() argument
126 struct da9062_watchdog *wdt = watchdog_get_drvdata(wdd); da9062_wdt_stop()
147 static int da9062_wdt_ping(struct watchdog_device *wdd) da9062_wdt_ping() argument
149 struct da9062_watchdog *wdt = watchdog_get_drvdata(wdd); da9062_wdt_ping()
160 static int da9062_wdt_set_timeout(struct watchdog_device *wdd, da9062_wdt_set_timeout() argument
163 struct da9062_watchdog *wdt = watchdog_get_drvdata(wdd); da9062_wdt_set_timeout()
173 wdd->timeout = wdt_timeout[selector]; da9062_wdt_set_timeout()
|
| H A D | da9063_wdt.c | 63 static int da9063_wdt_start(struct watchdog_device *wdd) da9063_wdt_start() argument
65 struct da9063_watchdog *wdt = watchdog_get_drvdata(wdd); da9063_wdt_start()
78 static int da9063_wdt_stop(struct watchdog_device *wdd) da9063_wdt_stop() argument
80 struct da9063_watchdog *wdt = watchdog_get_drvdata(wdd); da9063_wdt_stop()
92 static int da9063_wdt_ping(struct watchdog_device *wdd) da9063_wdt_ping() argument
94 struct da9063_watchdog *wdt = watchdog_get_drvdata(wdd); da9063_wdt_ping()
106 static int da9063_wdt_set_timeout(struct watchdog_device *wdd, da9063_wdt_set_timeout() argument
109 struct da9063_watchdog *wdt = watchdog_get_drvdata(wdd); da9063_wdt_set_timeout()
119 wdd->timeout = wdt_timeout[selector]; da9063_wdt_set_timeout()
|
| H A D | ux500_wdt.c | 41 static int ux500_wdt_start(struct watchdog_device *wdd) ux500_wdt_start() argument
46 static int ux500_wdt_stop(struct watchdog_device *wdd) ux500_wdt_stop() argument
51 static int ux500_wdt_keepalive(struct watchdog_device *wdd) ux500_wdt_keepalive() argument
56 static int ux500_wdt_set_timeout(struct watchdog_device *wdd, ux500_wdt_set_timeout() argument
59 ux500_wdt_stop(wdd); ux500_wdt_set_timeout()
61 ux500_wdt_start(wdd); ux500_wdt_set_timeout()
|
| H A D | mpc8xxx_wdt.c | 55 struct watchdog_device wdd; member in struct:mpc8xxx_wdt_ddata
90 mod_timer(&ddata->timer, jiffies + HZ * ddata->wdd.timeout / 2); mpc8xxx_wdt_timer_ping()
96 container_of(w, struct mpc8xxx_wdt_ddata, wdd); mpc8xxx_wdt_start()
116 container_of(w, struct mpc8xxx_wdt_ddata, wdd); mpc8xxx_wdt_ping()
125 container_of(w, struct mpc8xxx_wdt_ddata, wdd); mpc8xxx_wdt_stop()
180 ddata->wdd.info = &mpc8xxx_wdt_info, mpc8xxx_wdt_probe()
181 ddata->wdd.ops = &mpc8xxx_wdt_ops, mpc8xxx_wdt_probe()
186 ddata->wdd.timeout = timeout_sec; mpc8xxx_wdt_probe()
188 watchdog_set_nowayout(&ddata->wdd, nowayout); mpc8xxx_wdt_probe()
190 ret = watchdog_register_device(&ddata->wdd); mpc8xxx_wdt_probe()
218 watchdog_unregister_device(&ddata->wdd); mpc8xxx_wdt_remove()
|
| H A D | st_lpc_wdt.c | 126 static int st_wdog_start(struct watchdog_device *wdd) st_wdog_start() argument
128 struct st_wdog *st_wdog = watchdog_get_drvdata(wdd); st_wdog_start()
135 static int st_wdog_stop(struct watchdog_device *wdd) st_wdog_stop() argument
137 struct st_wdog *st_wdog = watchdog_get_drvdata(wdd); st_wdog_stop()
144 static int st_wdog_set_timeout(struct watchdog_device *wdd, st_wdog_set_timeout() argument
147 struct st_wdog *st_wdog = watchdog_get_drvdata(wdd); st_wdog_set_timeout()
149 wdd->timeout = timeout; st_wdog_set_timeout()
155 static int st_wdog_keepalive(struct watchdog_device *wdd) st_wdog_keepalive() argument
157 struct st_wdog *st_wdog = watchdog_get_drvdata(wdd); st_wdog_keepalive()
159 st_wdog_load_timer(st_wdog, wdd->timeout); st_wdog_keepalive()
|
| H A D | of_xilinx_wdt.c | 50 static int xilinx_wdt_start(struct watchdog_device *wdd) xilinx_wdt_start() argument
53 struct xwdt_device *xdev = watchdog_get_drvdata(wdd); xilinx_wdt_start()
71 static int xilinx_wdt_stop(struct watchdog_device *wdd) xilinx_wdt_stop() argument
74 struct xwdt_device *xdev = watchdog_get_drvdata(wdd); xilinx_wdt_stop()
91 static int xilinx_wdt_keepalive(struct watchdog_device *wdd) xilinx_wdt_keepalive() argument
94 struct xwdt_device *xdev = watchdog_get_drvdata(wdd); xilinx_wdt_keepalive()
|
| H A D | via_wdt.c | 101 static int wdt_ping(struct watchdog_device *wdd) wdt_ping() argument
104 next_heartbeat = jiffies + wdd->timeout * HZ; wdt_ping()
108 static int wdt_start(struct watchdog_device *wdd) wdt_start() argument
112 writel(wdd->timeout, wdt_mem + VIA_WDT_COUNT); wdt_start()
114 wdt_ping(wdd); wdt_start()
119 static int wdt_stop(struct watchdog_device *wdd) wdt_stop() argument
127 static int wdt_set_timeout(struct watchdog_device *wdd, wdt_set_timeout() argument
131 wdd->timeout = new_timeout; wdt_set_timeout()
|
| H A D | cadence_wdt.c | 123 * @wdd: watchdog device
130 static int cdns_wdt_stop(struct watchdog_device *wdd) cdns_wdt_stop() argument
132 struct cdns_wdt *wdt = watchdog_get_drvdata(wdd); cdns_wdt_stop()
145 * @wdd: watchdog device
151 static int cdns_wdt_reload(struct watchdog_device *wdd) cdns_wdt_reload() argument
153 struct cdns_wdt *wdt = watchdog_get_drvdata(wdd); cdns_wdt_reload()
166 * @wdd: watchdog device
181 static int cdns_wdt_start(struct watchdog_device *wdd) cdns_wdt_start() argument
183 struct cdns_wdt *wdt = watchdog_get_drvdata(wdd); cdns_wdt_start()
192 count = (wdd->timeout * (clock_f / wdt->prescaler)) / cdns_wdt_start()
229 * @wdd: watchdog device
236 static int cdns_wdt_settimeout(struct watchdog_device *wdd, cdns_wdt_settimeout() argument
239 wdd->timeout = new_time; cdns_wdt_settimeout()
241 return cdns_wdt_start(wdd); cdns_wdt_settimeout()
|
| H A D | pnx4008_wdt.c | 85 static int pnx4008_wdt_start(struct watchdog_device *wdd) pnx4008_wdt_start() argument
102 writel(wdd->timeout * WDOG_COUNTER_RATE, WDTIM_MATCH0(wdt_base)); pnx4008_wdt_start()
110 static int pnx4008_wdt_stop(struct watchdog_device *wdd) pnx4008_wdt_stop() argument
120 static int pnx4008_wdt_set_timeout(struct watchdog_device *wdd, pnx4008_wdt_set_timeout() argument
123 wdd->timeout = new_timeout; pnx4008_wdt_set_timeout()
|
| H A D | ie6xx_wdt.c | 101 static int ie6xx_wdt_ping(struct watchdog_device *wdd) ie6xx_wdt_ping() argument
110 static int ie6xx_wdt_set_timeout(struct watchdog_device *wdd, unsigned int t) ie6xx_wdt_set_timeout() argument
143 wdd->timeout = t; ie6xx_wdt_set_timeout()
147 static int ie6xx_wdt_start(struct watchdog_device *wdd) ie6xx_wdt_start() argument
149 ie6xx_wdt_set_timeout(wdd, wdd->timeout); ie6xx_wdt_start()
159 static int ie6xx_wdt_stop(struct watchdog_device *wdd) ie6xx_wdt_stop() argument
|
| H A D | ep93xx_wdt.c | 69 static int ep93xx_wdt_start(struct watchdog_device *wdd) ep93xx_wdt_start() argument
79 static int ep93xx_wdt_stop(struct watchdog_device *wdd) ep93xx_wdt_stop() argument
87 static int ep93xx_wdt_keepalive(struct watchdog_device *wdd) ep93xx_wdt_keepalive() argument
|
| H A D | s3c2410_wdt.c | 237 static int s3c2410wdt_keepalive(struct watchdog_device *wdd) s3c2410wdt_keepalive() argument
239 struct s3c2410_wdt *wdt = watchdog_get_drvdata(wdd); s3c2410wdt_keepalive()
257 static int s3c2410wdt_stop(struct watchdog_device *wdd) s3c2410wdt_stop() argument
259 struct s3c2410_wdt *wdt = watchdog_get_drvdata(wdd); s3c2410wdt_stop()
268 static int s3c2410wdt_start(struct watchdog_device *wdd) s3c2410wdt_start() argument
271 struct s3c2410_wdt *wdt = watchdog_get_drvdata(wdd); s3c2410wdt_start()
304 static int s3c2410wdt_set_heartbeat(struct watchdog_device *wdd, unsigned timeout) s3c2410wdt_set_heartbeat() argument
306 struct s3c2410_wdt *wdt = watchdog_get_drvdata(wdd); s3c2410wdt_set_heartbeat()
349 wdd->timeout = (count * divisor) / freq; s3c2410wdt_set_heartbeat()
|
| H A D | coh901327_wdt.c | 166 static int coh901327_ping(struct watchdog_device *wdd) coh901327_ping() argument
|
| /linux-4.4.14/include/linux/ |
| H A D | watchdog.h | 107 static inline bool watchdog_active(struct watchdog_device *wdd) watchdog_active() argument
109 return test_bit(WDOG_ACTIVE, &wdd->status); watchdog_active()
113 static inline void watchdog_set_nowayout(struct watchdog_device *wdd, bool nowayout) watchdog_set_nowayout() argument
116 set_bit(WDOG_NO_WAY_OUT, &wdd->status); watchdog_set_nowayout()
120 static inline bool watchdog_timeout_invalid(struct watchdog_device *wdd, unsigned int t) watchdog_timeout_invalid() argument
129 return t < wdd->min_timeout || watchdog_timeout_invalid()
130 (wdd->max_timeout && t > wdd->max_timeout); watchdog_timeout_invalid()
134 static inline void watchdog_set_drvdata(struct watchdog_device *wdd, void *data) watchdog_set_drvdata() argument
136 wdd->driver_data = data; watchdog_set_drvdata()
139 static inline void *watchdog_get_drvdata(struct watchdog_device *wdd) watchdog_get_drvdata() argument
141 return wdd->driver_data; watchdog_get_drvdata()
145 extern int watchdog_init_timeout(struct watchdog_device *wdd,
|
| H A D | bcm47xx_wdt.h | 17 struct watchdog_device wdd; member in struct:bcm47xx_wdt
|