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, 0, 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 const 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 .get_timeleft = wdat_wdt_get_timeleft, 311 }; 312 313 static int wdat_wdt_probe(struct platform_device *pdev) 314 { 315 struct device *dev = &pdev->dev; 316 const struct acpi_wdat_entry *entries; 317 const struct acpi_table_wdat *tbl; 318 struct wdat_wdt *wdat; 319 struct resource *res; 320 void __iomem **regs; 321 acpi_status status; 322 int i, ret; 323 324 status = acpi_get_table(ACPI_SIG_WDAT, 0, 325 (struct acpi_table_header **)&tbl); 326 if (ACPI_FAILURE(status)) 327 return -ENODEV; 328 329 wdat = devm_kzalloc(dev, sizeof(*wdat), GFP_KERNEL); 330 if (!wdat) 331 return -ENOMEM; 332 333 regs = devm_kcalloc(dev, pdev->num_resources, sizeof(*regs), 334 GFP_KERNEL); 335 if (!regs) 336 return -ENOMEM; 337 338 /* WDAT specification wants to have >= 1ms period */ 339 if (tbl->timer_period < 1) 340 return -EINVAL; 341 if (tbl->min_count > tbl->max_count) 342 return -EINVAL; 343 344 wdat->period = tbl->timer_period; 345 wdat->wdd.min_hw_heartbeat_ms = wdat->period * tbl->min_count; 346 wdat->wdd.max_hw_heartbeat_ms = wdat->period * tbl->max_count; 347 wdat->wdd.min_timeout = 1; 348 wdat->stopped_in_sleep = tbl->flags & ACPI_WDAT_STOPPED; 349 wdat->wdd.info = &wdat_wdt_info; 350 wdat->wdd.ops = &wdat_wdt_ops; 351 wdat->pdev = pdev; 352 353 /* Request and map all resources */ 354 for (i = 0; i < pdev->num_resources; i++) { 355 void __iomem *reg; 356 357 res = &pdev->resource[i]; 358 if (resource_type(res) == IORESOURCE_MEM) { 359 reg = devm_ioremap_resource(dev, res); 360 if (IS_ERR(reg)) 361 return PTR_ERR(reg); 362 } else if (resource_type(res) == IORESOURCE_IO) { 363 reg = devm_ioport_map(dev, res->start, 1); 364 if (!reg) 365 return -ENOMEM; 366 } else { 367 dev_err(dev, "Unsupported resource\n"); 368 return -EINVAL; 369 } 370 371 regs[i] = reg; 372 } 373 374 entries = (struct acpi_wdat_entry *)(tbl + 1); 375 for (i = 0; i < tbl->entries; i++) { 376 const struct acpi_generic_address *gas; 377 struct wdat_instruction *instr; 378 struct list_head *instructions; 379 unsigned int action; 380 struct resource r; 381 int j; 382 383 action = entries[i].action; 384 if (action >= MAX_WDAT_ACTIONS) { 385 dev_dbg(dev, "Skipping unknown action: %u\n", action); 386 continue; 387 } 388 389 instr = devm_kzalloc(dev, sizeof(*instr), GFP_KERNEL); 390 if (!instr) 391 return -ENOMEM; 392 393 INIT_LIST_HEAD(&instr->node); 394 instr->entry = entries[i]; 395 396 gas = &entries[i].register_region; 397 398 memset(&r, 0, sizeof(r)); 399 r.start = gas->address; 400 r.end = r.start + ACPI_ACCESS_BYTE_WIDTH(gas->access_width) - 1; 401 if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) { 402 r.flags = IORESOURCE_MEM; 403 } else if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO) { 404 r.flags = IORESOURCE_IO; 405 } else { 406 dev_dbg(dev, "Unsupported address space: %d\n", 407 gas->space_id); 408 continue; 409 } 410 411 /* Find the matching resource */ 412 for (j = 0; j < pdev->num_resources; j++) { 413 res = &pdev->resource[j]; 414 if (resource_contains(res, &r)) { 415 instr->reg = regs[j] + r.start - res->start; 416 break; 417 } 418 } 419 420 if (!instr->reg) { 421 dev_err(dev, "I/O resource not found\n"); 422 return -EINVAL; 423 } 424 425 instructions = wdat->instructions[action]; 426 if (!instructions) { 427 instructions = devm_kzalloc(dev, 428 sizeof(*instructions), 429 GFP_KERNEL); 430 if (!instructions) 431 return -ENOMEM; 432 433 INIT_LIST_HEAD(instructions); 434 wdat->instructions[action] = instructions; 435 } 436 437 list_add_tail(&instr->node, instructions); 438 } 439 440 wdat_wdt_boot_status(wdat); 441 wdat_wdt_set_running(wdat); 442 443 ret = wdat_wdt_enable_reboot(wdat); 444 if (ret) 445 return ret; 446 447 platform_set_drvdata(pdev, wdat); 448 449 /* 450 * Set initial timeout so that userspace has time to configure the 451 * watchdog properly after it has opened the device. In some cases 452 * the BIOS default is too short and causes immediate reboot. 453 */ 454 if (watchdog_timeout_invalid(&wdat->wdd, timeout)) { 455 dev_warn(dev, "Invalid timeout %d given, using %d\n", 456 timeout, WDAT_DEFAULT_TIMEOUT); 457 timeout = WDAT_DEFAULT_TIMEOUT; 458 } 459 460 ret = wdat_wdt_set_timeout(&wdat->wdd, timeout); 461 if (ret) 462 return ret; 463 464 watchdog_set_nowayout(&wdat->wdd, nowayout); 465 watchdog_stop_on_reboot(&wdat->wdd); 466 watchdog_stop_on_unregister(&wdat->wdd); 467 return devm_watchdog_register_device(dev, &wdat->wdd); 468 } 469 470 #ifdef CONFIG_PM_SLEEP 471 static int wdat_wdt_suspend_noirq(struct device *dev) 472 { 473 struct wdat_wdt *wdat = dev_get_drvdata(dev); 474 int ret; 475 476 if (!watchdog_active(&wdat->wdd)) 477 return 0; 478 479 /* 480 * We need to stop the watchdog if firmware is not doing it or if we 481 * are going suspend to idle (where firmware is not involved). If 482 * firmware is stopping the watchdog we kick it here one more time 483 * to give it some time. 484 */ 485 wdat->stopped = false; 486 if (acpi_target_system_state() == ACPI_STATE_S0 || 487 !wdat->stopped_in_sleep) { 488 ret = wdat_wdt_stop(&wdat->wdd); 489 if (!ret) 490 wdat->stopped = true; 491 } else { 492 ret = wdat_wdt_ping(&wdat->wdd); 493 } 494 495 return ret; 496 } 497 498 static int wdat_wdt_resume_noirq(struct device *dev) 499 { 500 struct wdat_wdt *wdat = dev_get_drvdata(dev); 501 int ret; 502 503 if (!watchdog_active(&wdat->wdd)) 504 return 0; 505 506 if (!wdat->stopped) { 507 /* 508 * Looks like the boot firmware reinitializes the watchdog 509 * before it hands off to the OS on resume from sleep so we 510 * stop and reprogram the watchdog here. 511 */ 512 ret = wdat_wdt_stop(&wdat->wdd); 513 if (ret) 514 return ret; 515 516 ret = wdat_wdt_set_timeout(&wdat->wdd, wdat->wdd.timeout); 517 if (ret) 518 return ret; 519 520 ret = wdat_wdt_enable_reboot(wdat); 521 if (ret) 522 return ret; 523 524 ret = wdat_wdt_ping(&wdat->wdd); 525 if (ret) 526 return ret; 527 } 528 529 return wdat_wdt_start(&wdat->wdd); 530 } 531 #endif 532 533 static const struct dev_pm_ops wdat_wdt_pm_ops = { 534 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(wdat_wdt_suspend_noirq, 535 wdat_wdt_resume_noirq) 536 }; 537 538 static struct platform_driver wdat_wdt_driver = { 539 .probe = wdat_wdt_probe, 540 .driver = { 541 .name = "wdat_wdt", 542 .pm = &wdat_wdt_pm_ops, 543 }, 544 }; 545 546 module_platform_driver(wdat_wdt_driver); 547 548 MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>"); 549 MODULE_DESCRIPTION("ACPI Hardware Watchdog (WDAT) driver"); 550 MODULE_LICENSE("GPL v2"); 551 MODULE_ALIAS("platform:wdat_wdt"); 552