xref: /openbmc/linux/drivers/watchdog/kempld_wdt.c (revision 758f46c2)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Kontron PLD watchdog driver
4  *
5  * Copyright (c) 2010-2013 Kontron Europe GmbH
6  * Author: Michael Brunner <michael.brunner@kontron.com>
7  *
8  * Note: From the PLD watchdog point of view timeout and pretimeout are
9  *       defined differently than in the kernel.
10  *       First the pretimeout stage runs out before the timeout stage gets
11  *       active.
12  *
13  * Kernel/API:                     P-----| pretimeout
14  *               |-----------------------T timeout
15  * Watchdog:     |-----------------P       pretimeout_stage
16  *                                 |-----T timeout_stage
17  */
18 
19 #include <linux/module.h>
20 #include <linux/moduleparam.h>
21 #include <linux/uaccess.h>
22 #include <linux/watchdog.h>
23 #include <linux/platform_device.h>
24 #include <linux/mfd/kempld.h>
25 
26 #define KEMPLD_WDT_STAGE_TIMEOUT(x)	(0x1b + (x) * 4)
27 #define KEMPLD_WDT_STAGE_CFG(x)		(0x18 + (x))
28 #define STAGE_CFG_GET_PRESCALER(x)	(((x) & 0x30) >> 4)
29 #define STAGE_CFG_SET_PRESCALER(x)	(((x) & 0x3) << 4)
30 #define STAGE_CFG_PRESCALER_MASK	0x30
31 #define STAGE_CFG_ACTION_MASK		0x7
32 #define STAGE_CFG_ASSERT		(1 << 3)
33 
34 #define KEMPLD_WDT_MAX_STAGES		2
35 #define KEMPLD_WDT_KICK			0x16
36 #define KEMPLD_WDT_CFG			0x17
37 #define KEMPLD_WDT_CFG_ENABLE		0x10
38 #define KEMPLD_WDT_CFG_ENABLE_LOCK	0x8
39 #define KEMPLD_WDT_CFG_GLOBAL_LOCK	0x80
40 
41 enum {
42 	ACTION_NONE = 0,
43 	ACTION_RESET,
44 	ACTION_NMI,
45 	ACTION_SMI,
46 	ACTION_SCI,
47 	ACTION_DELAY,
48 };
49 
50 enum {
51 	STAGE_TIMEOUT = 0,
52 	STAGE_PRETIMEOUT,
53 };
54 
55 enum {
56 	PRESCALER_21 = 0,
57 	PRESCALER_17,
58 	PRESCALER_12,
59 };
60 
61 static const u32 kempld_prescaler[] = {
62 	[PRESCALER_21] = (1 << 21) - 1,
63 	[PRESCALER_17] = (1 << 17) - 1,
64 	[PRESCALER_12] = (1 << 12) - 1,
65 	0,
66 };
67 
68 struct kempld_wdt_stage {
69 	unsigned int	id;
70 	u32		mask;
71 };
72 
73 struct kempld_wdt_data {
74 	struct kempld_device_data	*pld;
75 	struct watchdog_device		wdd;
76 	unsigned int			pretimeout;
77 	struct kempld_wdt_stage		stage[KEMPLD_WDT_MAX_STAGES];
78 	u8				pm_status_store;
79 };
80 
81 #define DEFAULT_TIMEOUT		30 /* seconds */
82 #define DEFAULT_PRETIMEOUT	0
83 
84 static unsigned int timeout = DEFAULT_TIMEOUT;
85 module_param(timeout, uint, 0);
86 MODULE_PARM_DESC(timeout,
87 	"Watchdog timeout in seconds. (>=0, default="
88 	__MODULE_STRING(DEFAULT_TIMEOUT) ")");
89 
90 static unsigned int pretimeout = DEFAULT_PRETIMEOUT;
91 module_param(pretimeout, uint, 0);
92 MODULE_PARM_DESC(pretimeout,
93 	"Watchdog pretimeout in seconds. (>=0, default="
94 	__MODULE_STRING(DEFAULT_PRETIMEOUT) ")");
95 
96 static bool nowayout = WATCHDOG_NOWAYOUT;
97 module_param(nowayout, bool, 0);
98 MODULE_PARM_DESC(nowayout,
99 	"Watchdog cannot be stopped once started (default="
100 	__MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
101 
kempld_wdt_set_stage_action(struct kempld_wdt_data * wdt_data,struct kempld_wdt_stage * stage,u8 action)102 static int kempld_wdt_set_stage_action(struct kempld_wdt_data *wdt_data,
103 					struct kempld_wdt_stage *stage,
104 					u8 action)
105 {
106 	struct kempld_device_data *pld = wdt_data->pld;
107 	u8 stage_cfg;
108 
109 	if (!stage || !stage->mask)
110 		return -EINVAL;
111 
112 	kempld_get_mutex(pld);
113 	stage_cfg = kempld_read8(pld, KEMPLD_WDT_STAGE_CFG(stage->id));
114 	stage_cfg &= ~STAGE_CFG_ACTION_MASK;
115 	stage_cfg |= (action & STAGE_CFG_ACTION_MASK);
116 
117 	if (action == ACTION_RESET)
118 		stage_cfg |= STAGE_CFG_ASSERT;
119 	else
120 		stage_cfg &= ~STAGE_CFG_ASSERT;
121 
122 	kempld_write8(pld, KEMPLD_WDT_STAGE_CFG(stage->id), stage_cfg);
123 	kempld_release_mutex(pld);
124 
125 	return 0;
126 }
127 
kempld_wdt_set_stage_timeout(struct kempld_wdt_data * wdt_data,struct kempld_wdt_stage * stage,unsigned int timeout)128 static int kempld_wdt_set_stage_timeout(struct kempld_wdt_data *wdt_data,
129 					struct kempld_wdt_stage *stage,
130 					unsigned int timeout)
131 {
132 	struct kempld_device_data *pld = wdt_data->pld;
133 	u32 prescaler;
134 	u64 stage_timeout64;
135 	u32 stage_timeout;
136 	u32 remainder;
137 	u8 stage_cfg;
138 
139 	prescaler = kempld_prescaler[PRESCALER_21];
140 
141 	if (!stage)
142 		return -EINVAL;
143 
144 	stage_timeout64 = (u64)timeout * pld->pld_clock;
145 	remainder = do_div(stage_timeout64, prescaler);
146 	if (remainder)
147 		stage_timeout64++;
148 
149 	if (stage_timeout64 > stage->mask)
150 		return -EINVAL;
151 
152 	stage_timeout = stage_timeout64 & stage->mask;
153 
154 	kempld_get_mutex(pld);
155 	stage_cfg = kempld_read8(pld, KEMPLD_WDT_STAGE_CFG(stage->id));
156 	stage_cfg &= ~STAGE_CFG_PRESCALER_MASK;
157 	stage_cfg |= STAGE_CFG_SET_PRESCALER(PRESCALER_21);
158 	kempld_write8(pld, KEMPLD_WDT_STAGE_CFG(stage->id), stage_cfg);
159 	kempld_write32(pld, KEMPLD_WDT_STAGE_TIMEOUT(stage->id),
160 			stage_timeout);
161 	kempld_release_mutex(pld);
162 
163 	return 0;
164 }
165 
166 /*
167  * kempld_get_mutex must be called prior to calling this function.
168  */
kempld_wdt_get_timeout(struct kempld_wdt_data * wdt_data,struct kempld_wdt_stage * stage)169 static unsigned int kempld_wdt_get_timeout(struct kempld_wdt_data *wdt_data,
170 						struct kempld_wdt_stage *stage)
171 {
172 	struct kempld_device_data *pld = wdt_data->pld;
173 	unsigned int timeout;
174 	u64 stage_timeout;
175 	u32 prescaler;
176 	u32 remainder;
177 	u8 stage_cfg;
178 
179 	if (!stage->mask)
180 		return 0;
181 
182 	stage_cfg = kempld_read8(pld, KEMPLD_WDT_STAGE_CFG(stage->id));
183 	stage_timeout = kempld_read32(pld, KEMPLD_WDT_STAGE_TIMEOUT(stage->id));
184 	prescaler = kempld_prescaler[STAGE_CFG_GET_PRESCALER(stage_cfg)];
185 
186 	stage_timeout = (stage_timeout & stage->mask) * prescaler;
187 	remainder = do_div(stage_timeout, pld->pld_clock);
188 	if (remainder)
189 		stage_timeout++;
190 
191 	timeout = stage_timeout;
192 	WARN_ON_ONCE(timeout != stage_timeout);
193 
194 	return timeout;
195 }
196 
kempld_wdt_set_timeout(struct watchdog_device * wdd,unsigned int timeout)197 static int kempld_wdt_set_timeout(struct watchdog_device *wdd,
198 					unsigned int timeout)
199 {
200 	struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
201 	struct kempld_wdt_stage *pretimeout_stage;
202 	struct kempld_wdt_stage *timeout_stage;
203 	int ret;
204 
205 	timeout_stage = &wdt_data->stage[STAGE_TIMEOUT];
206 	pretimeout_stage = &wdt_data->stage[STAGE_PRETIMEOUT];
207 
208 	if (pretimeout_stage->mask && wdt_data->pretimeout > 0)
209 		timeout = wdt_data->pretimeout;
210 
211 	ret = kempld_wdt_set_stage_action(wdt_data, timeout_stage,
212 						ACTION_RESET);
213 	if (ret)
214 		return ret;
215 	ret = kempld_wdt_set_stage_timeout(wdt_data, timeout_stage,
216 						timeout);
217 	if (ret)
218 		return ret;
219 
220 	wdd->timeout = timeout;
221 	return 0;
222 }
223 
kempld_wdt_set_pretimeout(struct watchdog_device * wdd,unsigned int pretimeout)224 static int kempld_wdt_set_pretimeout(struct watchdog_device *wdd,
225 					unsigned int pretimeout)
226 {
227 	struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
228 	struct kempld_wdt_stage *pretimeout_stage;
229 	u8 action = ACTION_NONE;
230 	int ret;
231 
232 	pretimeout_stage = &wdt_data->stage[STAGE_PRETIMEOUT];
233 
234 	if (!pretimeout_stage->mask)
235 		return -ENXIO;
236 
237 	if (pretimeout > wdd->timeout)
238 		return -EINVAL;
239 
240 	if (pretimeout > 0)
241 		action = ACTION_NMI;
242 
243 	ret = kempld_wdt_set_stage_action(wdt_data, pretimeout_stage,
244 						action);
245 	if (ret)
246 		return ret;
247 	ret = kempld_wdt_set_stage_timeout(wdt_data, pretimeout_stage,
248 						wdd->timeout - pretimeout);
249 	if (ret)
250 		return ret;
251 
252 	wdt_data->pretimeout = pretimeout;
253 	return 0;
254 }
255 
kempld_wdt_update_timeouts(struct kempld_wdt_data * wdt_data)256 static void kempld_wdt_update_timeouts(struct kempld_wdt_data *wdt_data)
257 {
258 	struct kempld_device_data *pld = wdt_data->pld;
259 	struct kempld_wdt_stage *pretimeout_stage;
260 	struct kempld_wdt_stage *timeout_stage;
261 	unsigned int pretimeout, timeout;
262 
263 	pretimeout_stage = &wdt_data->stage[STAGE_PRETIMEOUT];
264 	timeout_stage = &wdt_data->stage[STAGE_TIMEOUT];
265 
266 	kempld_get_mutex(pld);
267 	pretimeout = kempld_wdt_get_timeout(wdt_data, pretimeout_stage);
268 	timeout = kempld_wdt_get_timeout(wdt_data, timeout_stage);
269 	kempld_release_mutex(pld);
270 
271 	if (pretimeout)
272 		wdt_data->pretimeout = timeout;
273 	else
274 		wdt_data->pretimeout = 0;
275 
276 	wdt_data->wdd.timeout = pretimeout + timeout;
277 }
278 
kempld_wdt_start(struct watchdog_device * wdd)279 static int kempld_wdt_start(struct watchdog_device *wdd)
280 {
281 	struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
282 	struct kempld_device_data *pld = wdt_data->pld;
283 	u8 status;
284 	int ret;
285 
286 	ret = kempld_wdt_set_timeout(wdd, wdd->timeout);
287 	if (ret)
288 		return ret;
289 
290 	kempld_get_mutex(pld);
291 	status = kempld_read8(pld, KEMPLD_WDT_CFG);
292 	status |= KEMPLD_WDT_CFG_ENABLE;
293 	kempld_write8(pld, KEMPLD_WDT_CFG, status);
294 	status = kempld_read8(pld, KEMPLD_WDT_CFG);
295 	kempld_release_mutex(pld);
296 
297 	/* Check if the watchdog was enabled */
298 	if (!(status & KEMPLD_WDT_CFG_ENABLE))
299 		return -EACCES;
300 
301 	return 0;
302 }
303 
kempld_wdt_stop(struct watchdog_device * wdd)304 static int kempld_wdt_stop(struct watchdog_device *wdd)
305 {
306 	struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
307 	struct kempld_device_data *pld = wdt_data->pld;
308 	u8 status;
309 
310 	kempld_get_mutex(pld);
311 	status = kempld_read8(pld, KEMPLD_WDT_CFG);
312 	status &= ~KEMPLD_WDT_CFG_ENABLE;
313 	kempld_write8(pld, KEMPLD_WDT_CFG, status);
314 	status = kempld_read8(pld, KEMPLD_WDT_CFG);
315 	kempld_release_mutex(pld);
316 
317 	/* Check if the watchdog was disabled */
318 	if (status & KEMPLD_WDT_CFG_ENABLE)
319 		return -EACCES;
320 
321 	return 0;
322 }
323 
kempld_wdt_keepalive(struct watchdog_device * wdd)324 static int kempld_wdt_keepalive(struct watchdog_device *wdd)
325 {
326 	struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
327 	struct kempld_device_data *pld = wdt_data->pld;
328 
329 	kempld_get_mutex(pld);
330 	kempld_write8(pld, KEMPLD_WDT_KICK, 'K');
331 	kempld_release_mutex(pld);
332 
333 	return 0;
334 }
335 
kempld_wdt_ioctl(struct watchdog_device * wdd,unsigned int cmd,unsigned long arg)336 static long kempld_wdt_ioctl(struct watchdog_device *wdd, unsigned int cmd,
337 				unsigned long arg)
338 {
339 	struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
340 	void __user *argp = (void __user *)arg;
341 	int ret = -ENOIOCTLCMD;
342 	int __user *p = argp;
343 	int new_value;
344 
345 	switch (cmd) {
346 	case WDIOC_SETPRETIMEOUT:
347 		if (get_user(new_value, p))
348 			return -EFAULT;
349 		ret = kempld_wdt_set_pretimeout(wdd, new_value);
350 		if (ret)
351 			return ret;
352 		ret = kempld_wdt_keepalive(wdd);
353 		break;
354 	case WDIOC_GETPRETIMEOUT:
355 		ret = put_user(wdt_data->pretimeout, (int __user *)arg);
356 		break;
357 	}
358 
359 	return ret;
360 }
361 
kempld_wdt_probe_stages(struct watchdog_device * wdd)362 static int kempld_wdt_probe_stages(struct watchdog_device *wdd)
363 {
364 	struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd);
365 	struct kempld_device_data *pld = wdt_data->pld;
366 	struct kempld_wdt_stage *pretimeout_stage;
367 	struct kempld_wdt_stage *timeout_stage;
368 	u8 index, data, data_orig;
369 	u32 mask;
370 	int i, j;
371 
372 	pretimeout_stage = &wdt_data->stage[STAGE_PRETIMEOUT];
373 	timeout_stage = &wdt_data->stage[STAGE_TIMEOUT];
374 
375 	pretimeout_stage->mask = 0;
376 	timeout_stage->mask = 0;
377 
378 	for (i = 0; i < 3; i++) {
379 		index = KEMPLD_WDT_STAGE_TIMEOUT(i);
380 		mask = 0;
381 
382 		kempld_get_mutex(pld);
383 		/* Probe each byte individually. */
384 		for (j = 0; j < 4; j++) {
385 			data_orig = kempld_read8(pld, index + j);
386 			kempld_write8(pld, index + j, 0x00);
387 			data = kempld_read8(pld, index + j);
388 			/* A failed write means this byte is reserved */
389 			if (data != 0x00)
390 				break;
391 			kempld_write8(pld, index + j, data_orig);
392 			mask |= 0xff << (j * 8);
393 		}
394 		kempld_release_mutex(pld);
395 
396 		/* Assign available stages to timeout and pretimeout */
397 		if (!timeout_stage->mask) {
398 			timeout_stage->mask = mask;
399 			timeout_stage->id = i;
400 		} else {
401 			if (pld->feature_mask & KEMPLD_FEATURE_BIT_NMI) {
402 				pretimeout_stage->mask = timeout_stage->mask;
403 				timeout_stage->mask = mask;
404 				pretimeout_stage->id = timeout_stage->id;
405 				timeout_stage->id = i;
406 			}
407 			break;
408 		}
409 	}
410 
411 	if (!timeout_stage->mask)
412 		return -ENODEV;
413 
414 	return 0;
415 }
416 
417 static const struct watchdog_info kempld_wdt_info = {
418 	.identity	= "KEMPLD Watchdog",
419 	.options	= WDIOF_SETTIMEOUT |
420 			WDIOF_KEEPALIVEPING |
421 			WDIOF_MAGICCLOSE |
422 			WDIOF_PRETIMEOUT
423 };
424 
425 static const struct watchdog_ops kempld_wdt_ops = {
426 	.owner		= THIS_MODULE,
427 	.start		= kempld_wdt_start,
428 	.stop		= kempld_wdt_stop,
429 	.ping		= kempld_wdt_keepalive,
430 	.set_timeout	= kempld_wdt_set_timeout,
431 	.ioctl		= kempld_wdt_ioctl,
432 };
433 
kempld_wdt_probe(struct platform_device * pdev)434 static int kempld_wdt_probe(struct platform_device *pdev)
435 {
436 	struct kempld_device_data *pld = dev_get_drvdata(pdev->dev.parent);
437 	struct kempld_wdt_data *wdt_data;
438 	struct device *dev = &pdev->dev;
439 	struct watchdog_device *wdd;
440 	u8 status;
441 	int ret = 0;
442 
443 	wdt_data = devm_kzalloc(dev, sizeof(*wdt_data), GFP_KERNEL);
444 	if (!wdt_data)
445 		return -ENOMEM;
446 
447 	wdt_data->pld = pld;
448 	wdd = &wdt_data->wdd;
449 	wdd->parent = dev;
450 
451 	kempld_get_mutex(pld);
452 	status = kempld_read8(pld, KEMPLD_WDT_CFG);
453 	kempld_release_mutex(pld);
454 
455 	/* Enable nowayout if watchdog is already locked */
456 	if (status & (KEMPLD_WDT_CFG_ENABLE_LOCK |
457 			KEMPLD_WDT_CFG_GLOBAL_LOCK)) {
458 		if (!nowayout)
459 			dev_warn(dev,
460 				 "Forcing nowayout - watchdog lock enabled!\n");
461 		nowayout = true;
462 	}
463 
464 	wdd->info = &kempld_wdt_info;
465 	wdd->ops = &kempld_wdt_ops;
466 
467 	watchdog_set_drvdata(wdd, wdt_data);
468 	watchdog_set_nowayout(wdd, nowayout);
469 
470 	ret = kempld_wdt_probe_stages(wdd);
471 	if (ret)
472 		return ret;
473 
474 	kempld_wdt_set_timeout(wdd, timeout);
475 	kempld_wdt_set_pretimeout(wdd, pretimeout);
476 
477 	/* Check if watchdog is already enabled */
478 	if (status & KEMPLD_WDT_CFG_ENABLE) {
479 		/* Get current watchdog settings */
480 		kempld_wdt_update_timeouts(wdt_data);
481 		dev_info(dev, "Watchdog was already enabled\n");
482 	}
483 
484 	platform_set_drvdata(pdev, wdt_data);
485 	watchdog_stop_on_reboot(wdd);
486 	watchdog_stop_on_unregister(wdd);
487 	ret = devm_watchdog_register_device(dev, wdd);
488 	if (ret)
489 		return ret;
490 
491 	dev_info(dev, "Watchdog registered with %ds timeout\n", wdd->timeout);
492 
493 	return 0;
494 }
495 
496 /* Disable watchdog if it is active during suspend */
kempld_wdt_suspend(struct platform_device * pdev,pm_message_t message)497 static int kempld_wdt_suspend(struct platform_device *pdev,
498 				pm_message_t message)
499 {
500 	struct kempld_wdt_data *wdt_data = platform_get_drvdata(pdev);
501 	struct kempld_device_data *pld = wdt_data->pld;
502 	struct watchdog_device *wdd = &wdt_data->wdd;
503 
504 	kempld_get_mutex(pld);
505 	wdt_data->pm_status_store = kempld_read8(pld, KEMPLD_WDT_CFG);
506 	kempld_release_mutex(pld);
507 
508 	kempld_wdt_update_timeouts(wdt_data);
509 
510 	if (wdt_data->pm_status_store & KEMPLD_WDT_CFG_ENABLE)
511 		return kempld_wdt_stop(wdd);
512 
513 	return 0;
514 }
515 
516 /* Enable watchdog and configure it if necessary */
kempld_wdt_resume(struct platform_device * pdev)517 static int kempld_wdt_resume(struct platform_device *pdev)
518 {
519 	struct kempld_wdt_data *wdt_data = platform_get_drvdata(pdev);
520 	struct watchdog_device *wdd = &wdt_data->wdd;
521 
522 	/*
523 	 * If watchdog was stopped before suspend be sure it gets disabled
524 	 * again, for the case BIOS has enabled it during resume
525 	 */
526 	if (wdt_data->pm_status_store & KEMPLD_WDT_CFG_ENABLE)
527 		return kempld_wdt_start(wdd);
528 	else
529 		return kempld_wdt_stop(wdd);
530 }
531 
532 static struct platform_driver kempld_wdt_driver = {
533 	.driver		= {
534 		.name	= "kempld-wdt",
535 	},
536 	.probe		= kempld_wdt_probe,
537 	.suspend	= pm_ptr(kempld_wdt_suspend),
538 	.resume		= pm_ptr(kempld_wdt_resume),
539 };
540 
541 module_platform_driver(kempld_wdt_driver);
542 
543 MODULE_DESCRIPTION("KEM PLD Watchdog Driver");
544 MODULE_AUTHOR("Michael Brunner <michael.brunner@kontron.com>");
545 MODULE_LICENSE("GPL");
546