Commit | Line | Data |
---|---|---|
2671a3a3 | 1 | // SPDX-License-Identifier: GPL-2.0 |
de6303ab WS |
2 | /* |
3 | * Watchdog driver for the RTC based watchdog in STMP3xxx and i.MX23/28 | |
4 | * | |
cf82f52d | 5 | * Author: Wolfram Sang <kernel@pengutronix.de> |
de6303ab WS |
6 | * |
7 | * Copyright (C) 2011-12 Wolfram Sang, Pengutronix | |
de6303ab | 8 | */ |
de6303ab WS |
9 | #include <linux/kernel.h> |
10 | #include <linux/module.h> | |
de6303ab WS |
11 | #include <linux/watchdog.h> |
12 | #include <linux/platform_device.h> | |
13 | #include <linux/stmp3xxx_rtc_wdt.h> | |
8d2fa171 HG |
14 | #include <linux/notifier.h> |
15 | #include <linux/reboot.h> | |
de6303ab WS |
16 | |
17 | #define WDOG_TICK_RATE 1000 /* 1 kHz clock */ | |
18 | #define STMP3XXX_DEFAULT_TIMEOUT 19 | |
19 | #define STMP3XXX_MAX_TIMEOUT (UINT_MAX / WDOG_TICK_RATE) | |
20 | ||
21 | static int heartbeat = STMP3XXX_DEFAULT_TIMEOUT; | |
22 | module_param(heartbeat, uint, 0); | |
23 | MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat period in seconds from 1 to " | |
24 | __MODULE_STRING(STMP3XXX_MAX_TIMEOUT) ", default " | |
25 | __MODULE_STRING(STMP3XXX_DEFAULT_TIMEOUT)); | |
26 | ||
27 | static int wdt_start(struct watchdog_device *wdd) | |
28 | { | |
29 | struct device *dev = watchdog_get_drvdata(wdd); | |
bc8fdfbe | 30 | struct stmp3xxx_wdt_pdata *pdata = dev_get_platdata(dev); |
de6303ab WS |
31 | |
32 | pdata->wdt_set_timeout(dev->parent, wdd->timeout * WDOG_TICK_RATE); | |
33 | return 0; | |
34 | } | |
35 | ||
36 | static int wdt_stop(struct watchdog_device *wdd) | |
37 | { | |
38 | struct device *dev = watchdog_get_drvdata(wdd); | |
bc8fdfbe | 39 | struct stmp3xxx_wdt_pdata *pdata = dev_get_platdata(dev); |
de6303ab WS |
40 | |
41 | pdata->wdt_set_timeout(dev->parent, 0); | |
42 | return 0; | |
43 | } | |
44 | ||
45 | static int wdt_set_timeout(struct watchdog_device *wdd, unsigned new_timeout) | |
46 | { | |
47 | wdd->timeout = new_timeout; | |
48 | return wdt_start(wdd); | |
49 | } | |
50 | ||
51 | static const struct watchdog_info stmp3xxx_wdt_ident = { | |
52 | .options = WDIOF_MAGICCLOSE | WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING, | |
53 | .identity = "STMP3XXX RTC Watchdog", | |
54 | }; | |
55 | ||
56 | static const struct watchdog_ops stmp3xxx_wdt_ops = { | |
57 | .owner = THIS_MODULE, | |
58 | .start = wdt_start, | |
59 | .stop = wdt_stop, | |
60 | .set_timeout = wdt_set_timeout, | |
61 | }; | |
62 | ||
63 | static struct watchdog_device stmp3xxx_wdd = { | |
64 | .info = &stmp3xxx_wdt_ident, | |
65 | .ops = &stmp3xxx_wdt_ops, | |
66 | .min_timeout = 1, | |
67 | .max_timeout = STMP3XXX_MAX_TIMEOUT, | |
68 | .status = WATCHDOG_NOWAYOUT_INIT_STATUS, | |
69 | }; | |
70 | ||
8d2fa171 HG |
71 | static int wdt_notify_sys(struct notifier_block *nb, unsigned long code, |
72 | void *unused) | |
73 | { | |
8d2fa171 HG |
74 | switch (code) { |
75 | case SYS_DOWN: /* keep enabled, system might crash while going down */ | |
76 | break; | |
77 | case SYS_HALT: /* allow the system to actually halt */ | |
78 | case SYS_POWER_OFF: | |
79 | wdt_stop(&stmp3xxx_wdd); | |
80 | break; | |
81 | } | |
82 | ||
83 | return NOTIFY_DONE; | |
84 | } | |
85 | ||
86 | static struct notifier_block wdt_notifier = { | |
87 | .notifier_call = wdt_notify_sys, | |
88 | }; | |
89 | ||
de6303ab WS |
90 | static int stmp3xxx_wdt_probe(struct platform_device *pdev) |
91 | { | |
92 | int ret; | |
93 | ||
94 | watchdog_set_drvdata(&stmp3xxx_wdd, &pdev->dev); | |
95 | ||
96 | stmp3xxx_wdd.timeout = clamp_t(unsigned, heartbeat, 1, STMP3XXX_MAX_TIMEOUT); | |
6551881c | 97 | stmp3xxx_wdd.parent = &pdev->dev; |
de6303ab WS |
98 | |
99 | ret = watchdog_register_device(&stmp3xxx_wdd); | |
100 | if (ret < 0) { | |
101 | dev_err(&pdev->dev, "cannot register watchdog device\n"); | |
102 | return ret; | |
103 | } | |
104 | ||
8d2fa171 HG |
105 | if (register_reboot_notifier(&wdt_notifier)) |
106 | dev_warn(&pdev->dev, "cannot register reboot notifier\n"); | |
107 | ||
de6303ab WS |
108 | dev_info(&pdev->dev, "initialized watchdog with heartbeat %ds\n", |
109 | stmp3xxx_wdd.timeout); | |
110 | return 0; | |
111 | } | |
112 | ||
113 | static int stmp3xxx_wdt_remove(struct platform_device *pdev) | |
114 | { | |
8d2fa171 | 115 | unregister_reboot_notifier(&wdt_notifier); |
de6303ab WS |
116 | watchdog_unregister_device(&stmp3xxx_wdd); |
117 | return 0; | |
118 | } | |
119 | ||
3281b85c JU |
120 | static int __maybe_unused stmp3xxx_wdt_suspend(struct device *dev) |
121 | { | |
122 | struct watchdog_device *wdd = &stmp3xxx_wdd; | |
123 | ||
124 | if (watchdog_active(wdd)) | |
125 | return wdt_stop(wdd); | |
126 | ||
127 | return 0; | |
128 | } | |
129 | ||
130 | static int __maybe_unused stmp3xxx_wdt_resume(struct device *dev) | |
131 | { | |
132 | struct watchdog_device *wdd = &stmp3xxx_wdd; | |
133 | ||
134 | if (watchdog_active(wdd)) | |
135 | return wdt_start(wdd); | |
136 | ||
137 | return 0; | |
138 | } | |
139 | ||
140 | static SIMPLE_DEV_PM_OPS(stmp3xxx_wdt_pm_ops, | |
141 | stmp3xxx_wdt_suspend, stmp3xxx_wdt_resume); | |
142 | ||
de6303ab WS |
143 | static struct platform_driver stmp3xxx_wdt_driver = { |
144 | .driver = { | |
145 | .name = "stmp3xxx_rtc_wdt", | |
3281b85c | 146 | .pm = &stmp3xxx_wdt_pm_ops, |
de6303ab WS |
147 | }, |
148 | .probe = stmp3xxx_wdt_probe, | |
149 | .remove = stmp3xxx_wdt_remove, | |
150 | }; | |
151 | module_platform_driver(stmp3xxx_wdt_driver); | |
152 | ||
153 | MODULE_DESCRIPTION("STMP3XXX RTC Watchdog Driver"); | |
154 | MODULE_LICENSE("GPL v2"); | |
cf82f52d | 155 | MODULE_AUTHOR("Wolfram Sang <kernel@pengutronix.de>"); |