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 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 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 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 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 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 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 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 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 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 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 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 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 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 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