1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) 2018 ROHM Semiconductors
3 // ROHM BD70528MWV watchdog driver
4
5 #include <linux/bcd.h>
6 #include <linux/kernel.h>
7 #include <linux/mfd/rohm-bd70528.h>
8 #include <linux/module.h>
9 #include <linux/of.h>
10 #include <linux/platform_device.h>
11 #include <linux/regmap.h>
12 #include <linux/watchdog.h>
13
14 /*
15 * Max time we can set is 1 hour, 59 minutes and 59 seconds
16 * and Minimum time is 1 second
17 */
18 #define WDT_MAX_MS ((2 * 60 * 60 - 1) * 1000)
19 #define WDT_MIN_MS 1000
20 #define DEFAULT_TIMEOUT 60
21
22 #define WD_CTRL_MAGIC1 0x55
23 #define WD_CTRL_MAGIC2 0xAA
24
25 struct wdtbd70528 {
26 struct device *dev;
27 struct regmap *regmap;
28 struct rohm_regmap_dev *mfd;
29 struct watchdog_device wdt;
30 };
31
32 /**
33 * bd70528_wdt_set - arm or disarm watchdog timer
34 *
35 * @data: device data for the PMIC instance we want to operate on
36 * @enable: new state of WDT. zero to disable, non zero to enable
37 * @old_state: previous state of WDT will be filled here
38 *
39 * Arm or disarm WDT on BD70528 PMIC. Expected to be called only by
40 * BD70528 RTC and BD70528 WDT drivers. The rtc_timer_lock must be taken
41 * by calling bd70528_wdt_lock before calling bd70528_wdt_set.
42 */
bd70528_wdt_set(struct rohm_regmap_dev * data,int enable,int * old_state)43 int bd70528_wdt_set(struct rohm_regmap_dev *data, int enable, int *old_state)
44 {
45 int ret, i;
46 unsigned int tmp;
47 struct bd70528_data *bd70528 = container_of(data, struct bd70528_data,
48 chip);
49 u8 wd_ctrl_arr[3] = { WD_CTRL_MAGIC1, WD_CTRL_MAGIC2, 0 };
50 u8 *wd_ctrl = &wd_ctrl_arr[2];
51
52 ret = regmap_read(bd70528->chip.regmap, BD70528_REG_WDT_CTRL, &tmp);
53 if (ret)
54 return ret;
55
56 *wd_ctrl = (u8)tmp;
57
58 if (old_state) {
59 if (*wd_ctrl & BD70528_MASK_WDT_EN)
60 *old_state |= BD70528_WDT_STATE_BIT;
61 else
62 *old_state &= ~BD70528_WDT_STATE_BIT;
63 if ((!enable) == (!(*old_state & BD70528_WDT_STATE_BIT)))
64 return 0;
65 }
66
67 if (enable) {
68 if (*wd_ctrl & BD70528_MASK_WDT_EN)
69 return 0;
70 *wd_ctrl |= BD70528_MASK_WDT_EN;
71 } else {
72 if (*wd_ctrl & BD70528_MASK_WDT_EN)
73 *wd_ctrl &= ~BD70528_MASK_WDT_EN;
74 else
75 return 0;
76 }
77
78 for (i = 0; i < 3; i++) {
79 ret = regmap_write(bd70528->chip.regmap, BD70528_REG_WDT_CTRL,
80 wd_ctrl_arr[i]);
81 if (ret)
82 return ret;
83 }
84
85 ret = regmap_read(bd70528->chip.regmap, BD70528_REG_WDT_CTRL, &tmp);
86 if ((tmp & BD70528_MASK_WDT_EN) != (*wd_ctrl & BD70528_MASK_WDT_EN)) {
87 dev_err(bd70528->chip.dev,
88 "Watchdog ctrl mismatch (hw) 0x%x (set) 0x%x\n",
89 tmp, *wd_ctrl);
90 ret = -EIO;
91 }
92
93 return ret;
94 }
95 EXPORT_SYMBOL(bd70528_wdt_set);
96
97 /**
98 * bd70528_wdt_lock - take WDT lock
99 *
100 * @data: device data for the PMIC instance we want to operate on
101 *
102 * Lock WDT for arming/disarming in order to avoid race condition caused
103 * by WDT state changes initiated by WDT and RTC drivers.
104 */
bd70528_wdt_lock(struct rohm_regmap_dev * data)105 void bd70528_wdt_lock(struct rohm_regmap_dev *data)
106 {
107 struct bd70528_data *bd70528 = container_of(data, struct bd70528_data,
108 chip);
109
110 mutex_lock(&bd70528->rtc_timer_lock);
111 }
112 EXPORT_SYMBOL(bd70528_wdt_lock);
113
114 /**
115 * bd70528_wdt_unlock - unlock WDT lock
116 *
117 * @data: device data for the PMIC instance we want to operate on
118 *
119 * Unlock WDT lock which has previously been taken by call to
120 * bd70528_wdt_lock.
121 */
bd70528_wdt_unlock(struct rohm_regmap_dev * data)122 void bd70528_wdt_unlock(struct rohm_regmap_dev *data)
123 {
124 struct bd70528_data *bd70528 = container_of(data, struct bd70528_data,
125 chip);
126
127 mutex_unlock(&bd70528->rtc_timer_lock);
128 }
129 EXPORT_SYMBOL(bd70528_wdt_unlock);
130
bd70528_wdt_set_locked(struct wdtbd70528 * w,int enable)131 static int bd70528_wdt_set_locked(struct wdtbd70528 *w, int enable)
132 {
133 return bd70528_wdt_set(w->mfd, enable, NULL);
134 }
135
bd70528_wdt_change(struct wdtbd70528 * w,int enable)136 static int bd70528_wdt_change(struct wdtbd70528 *w, int enable)
137 {
138 int ret;
139
140 bd70528_wdt_lock(w->mfd);
141 ret = bd70528_wdt_set_locked(w, enable);
142 bd70528_wdt_unlock(w->mfd);
143
144 return ret;
145 }
146
bd70528_wdt_start(struct watchdog_device * wdt)147 static int bd70528_wdt_start(struct watchdog_device *wdt)
148 {
149 struct wdtbd70528 *w = watchdog_get_drvdata(wdt);
150
151 dev_dbg(w->dev, "WDT ping...\n");
152 return bd70528_wdt_change(w, 1);
153 }
154
bd70528_wdt_stop(struct watchdog_device * wdt)155 static int bd70528_wdt_stop(struct watchdog_device *wdt)
156 {
157 struct wdtbd70528 *w = watchdog_get_drvdata(wdt);
158
159 dev_dbg(w->dev, "WDT stopping...\n");
160 return bd70528_wdt_change(w, 0);
161 }
162
bd70528_wdt_set_timeout(struct watchdog_device * wdt,unsigned int timeout)163 static int bd70528_wdt_set_timeout(struct watchdog_device *wdt,
164 unsigned int timeout)
165 {
166 unsigned int hours;
167 unsigned int minutes;
168 unsigned int seconds;
169 int ret;
170 struct wdtbd70528 *w = watchdog_get_drvdata(wdt);
171
172 seconds = timeout;
173 hours = timeout / (60 * 60);
174 /* Maximum timeout is 1h 59m 59s => hours is 1 or 0 */
175 if (hours)
176 seconds -= (60 * 60);
177 minutes = seconds / 60;
178 seconds = seconds % 60;
179
180 bd70528_wdt_lock(w->mfd);
181
182 ret = bd70528_wdt_set_locked(w, 0);
183 if (ret)
184 goto out_unlock;
185
186 ret = regmap_update_bits(w->regmap, BD70528_REG_WDT_HOUR,
187 BD70528_MASK_WDT_HOUR, hours);
188 if (ret) {
189 dev_err(w->dev, "Failed to set WDT hours\n");
190 goto out_en_unlock;
191 }
192 ret = regmap_update_bits(w->regmap, BD70528_REG_WDT_MINUTE,
193 BD70528_MASK_WDT_MINUTE, bin2bcd(minutes));
194 if (ret) {
195 dev_err(w->dev, "Failed to set WDT minutes\n");
196 goto out_en_unlock;
197 }
198 ret = regmap_update_bits(w->regmap, BD70528_REG_WDT_SEC,
199 BD70528_MASK_WDT_SEC, bin2bcd(seconds));
200 if (ret)
201 dev_err(w->dev, "Failed to set WDT seconds\n");
202 else
203 dev_dbg(w->dev, "WDT tmo set to %u\n", timeout);
204
205 out_en_unlock:
206 ret = bd70528_wdt_set_locked(w, 1);
207 out_unlock:
208 bd70528_wdt_unlock(w->mfd);
209
210 return ret;
211 }
212
213 static const struct watchdog_info bd70528_wdt_info = {
214 .identity = "bd70528-wdt",
215 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
216 };
217
218 static const struct watchdog_ops bd70528_wdt_ops = {
219 .start = bd70528_wdt_start,
220 .stop = bd70528_wdt_stop,
221 .set_timeout = bd70528_wdt_set_timeout,
222 };
223
bd70528_wdt_probe(struct platform_device * pdev)224 static int bd70528_wdt_probe(struct platform_device *pdev)
225 {
226 struct rohm_regmap_dev *bd70528;
227 struct wdtbd70528 *w;
228 int ret;
229 unsigned int reg;
230
231 bd70528 = dev_get_drvdata(pdev->dev.parent);
232 if (!bd70528) {
233 dev_err(&pdev->dev, "No MFD driver data\n");
234 return -EINVAL;
235 }
236 w = devm_kzalloc(&pdev->dev, sizeof(*w), GFP_KERNEL);
237 if (!w)
238 return -ENOMEM;
239
240 w->regmap = bd70528->regmap;
241 w->mfd = bd70528;
242 w->dev = &pdev->dev;
243
244 w->wdt.info = &bd70528_wdt_info;
245 w->wdt.ops = &bd70528_wdt_ops;
246 w->wdt.min_hw_heartbeat_ms = WDT_MIN_MS;
247 w->wdt.max_hw_heartbeat_ms = WDT_MAX_MS;
248 w->wdt.parent = pdev->dev.parent;
249 w->wdt.timeout = DEFAULT_TIMEOUT;
250 watchdog_set_drvdata(&w->wdt, w);
251 watchdog_init_timeout(&w->wdt, 0, pdev->dev.parent);
252
253 ret = bd70528_wdt_set_timeout(&w->wdt, w->wdt.timeout);
254 if (ret) {
255 dev_err(&pdev->dev, "Failed to set the watchdog timeout\n");
256 return ret;
257 }
258
259 bd70528_wdt_lock(w->mfd);
260 ret = regmap_read(w->regmap, BD70528_REG_WDT_CTRL, ®);
261 bd70528_wdt_unlock(w->mfd);
262
263 if (ret) {
264 dev_err(&pdev->dev, "Failed to get the watchdog state\n");
265 return ret;
266 }
267 if (reg & BD70528_MASK_WDT_EN) {
268 dev_dbg(&pdev->dev, "watchdog was running during probe\n");
269 set_bit(WDOG_HW_RUNNING, &w->wdt.status);
270 }
271
272 ret = devm_watchdog_register_device(&pdev->dev, &w->wdt);
273 if (ret < 0)
274 dev_err(&pdev->dev, "watchdog registration failed: %d\n", ret);
275
276 return ret;
277 }
278
279 static struct platform_driver bd70528_wdt = {
280 .driver = {
281 .name = "bd70528-wdt"
282 },
283 .probe = bd70528_wdt_probe,
284 };
285
286 module_platform_driver(bd70528_wdt);
287
288 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
289 MODULE_DESCRIPTION("BD70528 watchdog driver");
290 MODULE_LICENSE("GPL");
291 MODULE_ALIAS("platform:bd70528-wdt");
292
