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