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 */
24 struct 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 */
41 struct 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
52 static bool nowayout = WATCHDOG_NOWAYOUT;
53 module_param(nowayout, bool, 0);
54 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
55 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
56
57 #define WDAT_DEFAULT_TIMEOUT 30
58
59 static int timeout = WDAT_DEFAULT_TIMEOUT;
60 module_param(timeout, int, 0);
61 MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds (default="
62 __MODULE_STRING(WDAT_DEFAULT_TIMEOUT) ")");
63
wdat_wdt_read(struct wdat_wdt * wdat,const struct wdat_instruction * instr,u32 * value)64 static 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
wdat_wdt_write(struct wdat_wdt * wdat,const struct wdat_instruction * instr,u32 value)89 static 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
wdat_wdt_run_action(struct wdat_wdt * wdat,unsigned int action,u32 param,u32 * retval)114 static 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
wdat_wdt_enable_reboot(struct wdat_wdt * wdat)204 static 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
wdat_wdt_boot_status(struct wdat_wdt * wdat)224 static 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
wdat_wdt_set_running(struct wdat_wdt * wdat)244 static 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
wdat_wdt_start(struct watchdog_device * wdd)258 static 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
wdat_wdt_stop(struct watchdog_device * wdd)264 static 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
wdat_wdt_ping(struct watchdog_device * wdd)270 static 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
wdat_wdt_set_timeout(struct watchdog_device * wdd,unsigned int timeout)275 static 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
wdat_wdt_get_timeleft(struct watchdog_device * wdd)289 static 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
298 static 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
304 static 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
wdat_wdt_probe(struct platform_device * pdev)312 static 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
488 out_put_table:
489 acpi_put_table((struct acpi_table_header *)tbl);
490 return ret;
491 }
492
wdat_wdt_suspend_noirq(struct device * dev)493 static 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
wdat_wdt_resume_noirq(struct device * dev)520 static 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
554 static 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
558 static 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
566 module_platform_driver(wdat_wdt_driver);
567
568 MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
569 MODULE_DESCRIPTION("ACPI Hardware Watchdog (WDAT) driver");
570 MODULE_LICENSE("GPL v2");
571 MODULE_ALIAS("platform:wdat_wdt");
572