wdat_wdt.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * ACPI Hardware Watchdog (WDAT) driver.
  4 *
  5 * Copyright (C) 2016, Intel Corporation
  6 * Author: Mika Westerberg <mika.westerberg@linux.intel.com>
  7 */
  8
  9#include <linux/acpi.h>
 10#include <linux/ioport.h>
 11#include <linux/module.h>
 12#include <linux/platform_device.h>
 13#include <linux/pm.h>
 14#include <linux/watchdog.h>
 15
 16#define MAX_WDAT_ACTIONS ACPI_WDAT_ACTION_RESERVED
 17
 18/**
 19 * struct wdat_instruction - Single ACPI WDAT instruction
 20 * @entry: Copy of the ACPI table instruction
 21 * @reg: Register the instruction is accessing
 22 * @node: Next instruction in action sequence
 23 */
 24struct wdat_instruction {
 25	struct acpi_wdat_entry entry;
 26	void __iomem *reg;
 27	struct list_head node;
 28};
 29
 30/**
 31 * struct wdat_wdt - ACPI WDAT watchdog device
 32 * @pdev: Parent platform device
 33 * @wdd: Watchdog core device
 34 * @period: How long is one watchdog period in ms
 35 * @stopped_in_sleep: Is this watchdog stopped by the firmware in S1-S5
 36 * @stopped: Was the watchdog stopped by the driver in suspend
 37 * @instructions: An array of instruction lists indexed by an action number from
 38 *                the WDAT table. There can be %NULL entries for not implemented
 39 *                actions.
 40 */
 41struct wdat_wdt {
 42	struct platform_device *pdev;
 43	struct watchdog_device wdd;
 44	unsigned int period;
 45	bool stopped_in_sleep;
 46	bool stopped;
 47	struct list_head *instructions[MAX_WDAT_ACTIONS];
 48};
 49
 50#define to_wdat_wdt(wdd) container_of(wdd, struct wdat_wdt, wdd)
 51
 52static bool nowayout = WATCHDOG_NOWAYOUT;
 53module_param(nowayout, bool, 0);
 54MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
 55		 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 56
 57#define WDAT_DEFAULT_TIMEOUT	30
 58
 59static int timeout = WDAT_DEFAULT_TIMEOUT;
 60module_param(timeout, int, 0);
 61MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds (default="
 62		 __MODULE_STRING(WDAT_DEFAULT_TIMEOUT) ")");
 63
 64static int wdat_wdt_read(struct wdat_wdt *wdat,
 65	 const struct wdat_instruction *instr, u32 *value)
 66{
 67	const struct acpi_generic_address *gas = &instr->entry.register_region;
 68
 69	switch (gas->access_width) {
 70	case 1:
 71		*value = ioread8(instr->reg);
 72		break;
 73	case 2:
 74		*value = ioread16(instr->reg);
 75		break;
 76	case 3:
 77		*value = ioread32(instr->reg);
 78		break;
 79	default:
 80		return -EINVAL;
 81	}
 82
 83	dev_dbg(&wdat->pdev->dev, "Read %#x from 0x%08llx\n", *value,
 84		gas->address);
 85
 86	return 0;
 87}
 88
 89static int wdat_wdt_write(struct wdat_wdt *wdat,
 90	const struct wdat_instruction *instr, u32 value)
 91{
 92	const struct acpi_generic_address *gas = &instr->entry.register_region;
 93
 94	switch (gas->access_width) {
 95	case 1:
 96		iowrite8((u8)value, instr->reg);
 97		break;
 98	case 2:
 99		iowrite16((u16)value, instr->reg);
100		break;
101	case 3:
102		iowrite32(value, instr->reg);
103		break;
104	default:
105		return -EINVAL;
106	}
107
108	dev_dbg(&wdat->pdev->dev, "Wrote %#x to 0x%08llx\n", value,
109		gas->address);
110
111	return 0;
112}
113
114static int wdat_wdt_run_action(struct wdat_wdt *wdat, unsigned int action,
115			       u32 param, u32 *retval)
116{
117	struct wdat_instruction *instr;
118
119	if (action >= ARRAY_SIZE(wdat->instructions))
120		return -EINVAL;
121
122	if (!wdat->instructions[action])
123		return -EOPNOTSUPP;
124
125	dev_dbg(&wdat->pdev->dev, "Running action %#x\n", action);
126
127	/* Run each instruction sequentially */
128	list_for_each_entry(instr, wdat->instructions[action], node) {
129		const struct acpi_wdat_entry *entry = &instr->entry;
130		const struct acpi_generic_address *gas;
131		u32 flags, value, mask, x, y;
132		bool preserve;
133		int ret;
134
135		gas = &entry->register_region;
136
137		preserve = entry->instruction & ACPI_WDAT_PRESERVE_REGISTER;
138		flags = entry->instruction & ~ACPI_WDAT_PRESERVE_REGISTER;
139		value = entry->value;
140		mask = entry->mask;
141
142		switch (flags) {
143		case ACPI_WDAT_READ_VALUE:
144			ret = wdat_wdt_read(wdat, instr, &x);
145			if (ret)
146				return ret;
147			x >>= gas->bit_offset;
148			x &= mask;
149			if (retval)
150				*retval = x == value;
151			break;
152
153		case ACPI_WDAT_READ_COUNTDOWN:
154			ret = wdat_wdt_read(wdat, instr, &x);
155			if (ret)
156				return ret;
157			x >>= gas->bit_offset;
158			x &= mask;
159			if (retval)
160				*retval = x;
161			break;
162
163		case ACPI_WDAT_WRITE_VALUE:
164			x = value & mask;
165			x <<= gas->bit_offset;
166			if (preserve) {
167				ret = wdat_wdt_read(wdat, instr, &y);
168				if (ret)
169					return ret;
170				y = y & ~(mask << gas->bit_offset);
171				x |= y;
172			}
173			ret = wdat_wdt_write(wdat, instr, x);
174			if (ret)
175				return ret;
176			break;
177
178		case ACPI_WDAT_WRITE_COUNTDOWN:
179			x = param;
180			x &= mask;
181			x <<= gas->bit_offset;
182			if (preserve) {
183				ret = wdat_wdt_read(wdat, instr, &y);
184				if (ret)
185					return ret;
186				y = y & ~(mask << gas->bit_offset);
187				x |= y;
188			}
189			ret = wdat_wdt_write(wdat, instr, x);
190			if (ret)
191				return ret;
192			break;
193
194		default:
195			dev_err(&wdat->pdev->dev, "Unknown instruction: %u\n",
196				flags);
197			return -EINVAL;
198		}
199	}
200
201	return 0;
202}
203
204static int wdat_wdt_enable_reboot(struct wdat_wdt *wdat)
205{
206	int ret;
207
208	/*
209	 * WDAT specification says that the watchdog is required to reboot
210	 * the system when it fires. However, it also states that it is
211	 * recommended to make it configurable through hardware register. We
212	 * enable reboot now if it is configurable, just in case.
213	 */
214	ret = wdat_wdt_run_action(wdat, ACPI_WDAT_SET_REBOOT, 0, NULL);
215	if (ret && ret != -EOPNOTSUPP) {
216		dev_err(&wdat->pdev->dev,
217			"Failed to enable reboot when watchdog triggers\n");
218		return ret;
219	}
220
221	return 0;
222}
223
224static void wdat_wdt_boot_status(struct wdat_wdt *wdat)
225{
226	u32 boot_status = 0;
227	int ret;
228
229	ret = wdat_wdt_run_action(wdat, ACPI_WDAT_GET_STATUS, 0, &boot_status);
230	if (ret && ret != -EOPNOTSUPP) {
231		dev_err(&wdat->pdev->dev, "Failed to read boot status\n");
232		return;
233	}
234
235	if (boot_status)
236		wdat->wdd.bootstatus = WDIOF_CARDRESET;
237
238	/* Clear the boot status in case BIOS did not do it */
239	ret = wdat_wdt_run_action(wdat, ACPI_WDAT_SET_STATUS, 0, NULL);
240	if (ret && ret != -EOPNOTSUPP)
241		dev_err(&wdat->pdev->dev, "Failed to clear boot status\n");
242}
243
244static void wdat_wdt_set_running(struct wdat_wdt *wdat)
245{
246	u32 running = 0;
247	int ret;
248
249	ret = wdat_wdt_run_action(wdat, ACPI_WDAT_GET_RUNNING_STATE, 0,
250				  &running);
251	if (ret && ret != -EOPNOTSUPP)
252		dev_err(&wdat->pdev->dev, "Failed to read running state\n");
253
254	if (running)
255		set_bit(WDOG_HW_RUNNING, &wdat->wdd.status);
256}
257
258static int wdat_wdt_start(struct watchdog_device *wdd)
259{
260	return wdat_wdt_run_action(to_wdat_wdt(wdd),
261				   ACPI_WDAT_SET_RUNNING_STATE, 0, NULL);
262}
263
264static int wdat_wdt_stop(struct watchdog_device *wdd)
265{
266	return wdat_wdt_run_action(to_wdat_wdt(wdd),
267				   ACPI_WDAT_SET_STOPPED_STATE, 0, NULL);
268}
269
270static int wdat_wdt_ping(struct watchdog_device *wdd)
271{
272	return wdat_wdt_run_action(to_wdat_wdt(wdd), ACPI_WDAT_RESET, wdd->timeout, NULL);
273}
274
275static int wdat_wdt_set_timeout(struct watchdog_device *wdd,
276				unsigned int timeout)
277{
278	struct wdat_wdt *wdat = to_wdat_wdt(wdd);
279	unsigned int periods;
280	int ret;
281
282	periods = timeout * 1000 / wdat->period;
283	ret = wdat_wdt_run_action(wdat, ACPI_WDAT_SET_COUNTDOWN, periods, NULL);
284	if (!ret)
285		wdd->timeout = timeout;
286	return ret;
287}
288
289static unsigned int wdat_wdt_get_timeleft(struct watchdog_device *wdd)
290{
291	struct wdat_wdt *wdat = to_wdat_wdt(wdd);
292	u32 periods = 0;
293
294	wdat_wdt_run_action(wdat, ACPI_WDAT_GET_CURRENT_COUNTDOWN, 0, &periods);
295	return periods * wdat->period / 1000;
296}
297
298static const struct watchdog_info wdat_wdt_info = {
299	.options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
300	.firmware_version = 0,
301	.identity = "wdat_wdt",
302};
303
304static struct watchdog_ops wdat_wdt_ops = {
305	.owner = THIS_MODULE,
306	.start = wdat_wdt_start,
307	.stop = wdat_wdt_stop,
308	.ping = wdat_wdt_ping,
309	.set_timeout = wdat_wdt_set_timeout,
310};
311
312static int wdat_wdt_probe(struct platform_device *pdev)
313{
314	struct device *dev = &pdev->dev;
315	const struct acpi_wdat_entry *entries;
316	const struct acpi_table_wdat *tbl;
317	struct wdat_wdt *wdat;
318	struct resource *res;
319	void __iomem **regs;
320	acpi_status status;
321	int i, ret;
322
323	status = acpi_get_table(ACPI_SIG_WDAT, 0,
324				(struct acpi_table_header **)&tbl);
325	if (ACPI_FAILURE(status))
326		return -ENODEV;
327
328	wdat = devm_kzalloc(dev, sizeof(*wdat), GFP_KERNEL);
329	if (!wdat) {
330		ret = -ENOMEM;
331		goto out_put_table;
332	}
333
334	regs = devm_kcalloc(dev, pdev->num_resources, sizeof(*regs),
335			    GFP_KERNEL);
336	if (!regs) {
337		ret = -ENOMEM;
338		goto out_put_table;
339	}
340
341	/* WDAT specification wants to have >= 1ms period */
342	if (tbl->timer_period < 1) {
343		ret = -EINVAL;
344		goto out_put_table;
345	}
346	if (tbl->min_count > tbl->max_count) {
347		ret = -EINVAL;
348		goto out_put_table;
349	}
350
351	wdat->period = tbl->timer_period;
352	wdat->wdd.min_timeout = DIV_ROUND_UP(wdat->period * tbl->min_count, 1000);
353	wdat->wdd.max_timeout = wdat->period * tbl->max_count / 1000;
354	wdat->stopped_in_sleep = tbl->flags & ACPI_WDAT_STOPPED;
355	wdat->wdd.info = &wdat_wdt_info;
356	wdat->wdd.ops = &wdat_wdt_ops;
357	wdat->pdev = pdev;
358
359	/* Request and map all resources */
360	for (i = 0; i < pdev->num_resources; i++) {
361		void __iomem *reg;
362
363		res = &pdev->resource[i];
364		if (resource_type(res) == IORESOURCE_MEM) {
365			reg = devm_ioremap_resource(dev, res);
366			if (IS_ERR(reg)) {
367				ret = PTR_ERR(reg);
368				goto out_put_table;
369			}
370		} else if (resource_type(res) == IORESOURCE_IO) {
371			reg = devm_ioport_map(dev, res->start, 1);
372			if (!reg) {
373				ret = -ENOMEM;
374				goto out_put_table;
375			}
376		} else {
377			dev_err(dev, "Unsupported resource\n");
378			ret = -EINVAL;
379			goto out_put_table;
380		}
381
382		regs[i] = reg;
383	}
384
385	entries = (struct acpi_wdat_entry *)(tbl + 1);
386	for (i = 0; i < tbl->entries; i++) {
387		const struct acpi_generic_address *gas;
388		struct wdat_instruction *instr;
389		struct list_head *instructions;
390		unsigned int action;
391		struct resource r;
392		int j;
393
394		action = entries[i].action;
395		if (action >= MAX_WDAT_ACTIONS) {
396			dev_dbg(dev, "Skipping unknown action: %u\n", action);
397			continue;
398		}
399
400		instr = devm_kzalloc(dev, sizeof(*instr), GFP_KERNEL);
401		if (!instr) {
402			ret = -ENOMEM;
403			goto out_put_table;
404		}
405
406		INIT_LIST_HEAD(&instr->node);
407		instr->entry = entries[i];
408
409		gas = &entries[i].register_region;
410
411		memset(&r, 0, sizeof(r));
412		r.start = gas->address;
413		r.end = r.start + ACPI_ACCESS_BYTE_WIDTH(gas->access_width) - 1;
414		if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
415			r.flags = IORESOURCE_MEM;
416		} else if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
417			r.flags = IORESOURCE_IO;
418		} else {
419			dev_dbg(dev, "Unsupported address space: %d\n",
420				gas->space_id);
421			continue;
422		}
423
424		/* Find the matching resource */
425		for (j = 0; j < pdev->num_resources; j++) {
426			res = &pdev->resource[j];
427			if (resource_contains(res, &r)) {
428				instr->reg = regs[j] + r.start - res->start;
429				break;
430			}
431		}
432
433		if (!instr->reg) {
434			dev_err(dev, "I/O resource not found\n");
435			ret = -EINVAL;
436			goto out_put_table;
437		}
438
439		instructions = wdat->instructions[action];
440		if (!instructions) {
441			instructions = devm_kzalloc(dev,
442						    sizeof(*instructions),
443						    GFP_KERNEL);
444			if (!instructions) {
445				ret = -ENOMEM;
446				goto out_put_table;
447			}
448
449			INIT_LIST_HEAD(instructions);
450			wdat->instructions[action] = instructions;
451		}
452
453		list_add_tail(&instr->node, instructions);
454	}
455
456	if (wdat->instructions[ACPI_WDAT_GET_CURRENT_COUNTDOWN])
457		wdat_wdt_ops.get_timeleft = wdat_wdt_get_timeleft;
458
459	wdat_wdt_boot_status(wdat);
460	wdat_wdt_set_running(wdat);
461
462	ret = wdat_wdt_enable_reboot(wdat);
463	if (ret)
464		goto out_put_table;
465
466	platform_set_drvdata(pdev, wdat);
467
468	/*
469	 * Set initial timeout so that userspace has time to configure the
470	 * watchdog properly after it has opened the device. In some cases
471	 * the BIOS default is too short and causes immediate reboot.
472	 */
473	if (watchdog_timeout_invalid(&wdat->wdd, timeout)) {
474		dev_warn(dev, "Invalid timeout %d given, using %d\n",
475			 timeout, WDAT_DEFAULT_TIMEOUT);
476		timeout = WDAT_DEFAULT_TIMEOUT;
477	}
478
479	ret = wdat_wdt_set_timeout(&wdat->wdd, timeout);
480	if (ret)
481		goto out_put_table;
482
483	watchdog_set_nowayout(&wdat->wdd, nowayout);
484	watchdog_stop_on_reboot(&wdat->wdd);
485	watchdog_stop_on_unregister(&wdat->wdd);
486	ret = devm_watchdog_register_device(dev, &wdat->wdd);
487
488out_put_table:
489	acpi_put_table((struct acpi_table_header *)tbl);
490	return ret;
491}
492
493static int wdat_wdt_suspend_noirq(struct device *dev)
494{
495	struct wdat_wdt *wdat = dev_get_drvdata(dev);
496	int ret;
497
498	if (!watchdog_active(&wdat->wdd))
499		return 0;
500
501	/*
502	 * We need to stop the watchdog if firmware is not doing it or if we
503	 * are going suspend to idle (where firmware is not involved). If
504	 * firmware is stopping the watchdog we kick it here one more time
505	 * to give it some time.
506	 */
507	wdat->stopped = false;
508	if (acpi_target_system_state() == ACPI_STATE_S0 ||
509	    !wdat->stopped_in_sleep) {
510		ret = wdat_wdt_stop(&wdat->wdd);
511		if (!ret)
512			wdat->stopped = true;
513	} else {
514		ret = wdat_wdt_ping(&wdat->wdd);
515	}
516
517	return ret;
518}
519
520static int wdat_wdt_resume_noirq(struct device *dev)
521{
522	struct wdat_wdt *wdat = dev_get_drvdata(dev);
523	int ret;
524
525	if (!watchdog_active(&wdat->wdd))
526		return 0;
527
528	if (!wdat->stopped) {
529		/*
530		 * Looks like the boot firmware reinitializes the watchdog
531		 * before it hands off to the OS on resume from sleep so we
532		 * stop and reprogram the watchdog here.
533		 */
534		ret = wdat_wdt_stop(&wdat->wdd);
535		if (ret)
536			return ret;
537
538		ret = wdat_wdt_set_timeout(&wdat->wdd, wdat->wdd.timeout);
539		if (ret)
540			return ret;
541
542		ret = wdat_wdt_enable_reboot(wdat);
543		if (ret)
544			return ret;
545
546		ret = wdat_wdt_ping(&wdat->wdd);
547		if (ret)
548			return ret;
549	}
550
551	return wdat_wdt_start(&wdat->wdd);
552}
553
554static const struct dev_pm_ops wdat_wdt_pm_ops = {
555	NOIRQ_SYSTEM_SLEEP_PM_OPS(wdat_wdt_suspend_noirq, wdat_wdt_resume_noirq)
556};
557
558static struct platform_driver wdat_wdt_driver = {
559	.probe = wdat_wdt_probe,
560	.driver = {
561		.name = "wdat_wdt",
562		.pm = pm_sleep_ptr(&wdat_wdt_pm_ops),
563	},
564};
565
566module_platform_driver(wdat_wdt_driver);
567
568MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
569MODULE_DESCRIPTION("ACPI Hardware Watchdog (WDAT) driver");
570MODULE_LICENSE("GPL v2");
571MODULE_ALIAS("platform:wdat_wdt");