drivers/watchdog/wdat_wdt.c

   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
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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;
 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
 448 static int wdat_wdt_suspend_noirq(struct device *dev)
 449 {
 450         struct platform_device *pdev = to_platform_device(dev);
 451         struct wdat_wdt *wdat = platform_get_drvdata(pdev);
 452         int ret;
 453
 454         if (!watchdog_active(&wdat->wdd))
 455                 return 0;
 456
 457         /*
 458          * We need to stop the watchdog if firmare is not doing it or if we
 459          * are going suspend to idle (where firmware is not involved). If
 460          * firmware is stopping the watchdog we kick it here one more time
 461          * to give it some time.
 462          */
 463         wdat->stopped = false;
 464         if (acpi_target_system_state() == ACPI_STATE_S0 ||
 465             !wdat->stopped_in_sleep) {
 466                 ret = wdat_wdt_stop(&wdat->wdd);
 467                 if (!ret)
 468                         wdat->stopped = true;
 469         } else {
 470                 ret = wdat_wdt_ping(&wdat->wdd);
 471         }
 472
 473         return ret;
 474 }
 475
 476 static int wdat_wdt_resume_noirq(struct device *dev)
 477 {
 478         struct platform_device *pdev = to_platform_device(dev);
 479         struct wdat_wdt *wdat = platform_get_drvdata(pdev);
 480         int ret;
 481
 482         if (!watchdog_active(&wdat->wdd))
 483                 return 0;
 484
 485         if (!wdat->stopped) {
 486                 /*
 487                  * Looks like the boot firmware reinitializes the watchdog
 488                  * before it hands off to the OS on resume from sleep so we
 489                  * stop and reprogram the watchdog here.
 490                  */
 491                 ret = wdat_wdt_stop(&wdat->wdd);
 492                 if (ret)
 493                         return ret;
 494
 495                 ret = wdat_wdt_set_timeout(&wdat->wdd, wdat->wdd.timeout);
 496                 if (ret)
 497                         return ret;
 498
 499                 ret = wdat_wdt_enable_reboot(wdat);
 500                 if (ret)
 501                         return ret;
 502
 503                 ret = wdat_wdt_ping(&wdat->wdd);
 504                 if (ret)
 505                         return ret;
 506         }
 507
 508         return wdat_wdt_start(&wdat->wdd);
 509 }
 510 #endif
 511
 512 static const struct dev_pm_ops wdat_wdt_pm_ops = {
 513         SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(wdat_wdt_suspend_noirq,
 514                                       wdat_wdt_resume_noirq)
 515 };
 516
 517 static struct platform_driver wdat_wdt_driver = {
 518         .probe = wdat_wdt_probe,
 519         .driver = {
 520                 .name = "wdat_wdt",
 521                 .pm = &wdat_wdt_pm_ops,
 522         },
 523 };
 524
 525 module_platform_driver(wdat_wdt_driver);
 526
 527 MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
 528 MODULE_DESCRIPTION("ACPI Hardware Watchdog (WDAT) driver");
 529 MODULE_LICENSE("GPL v2");
 530 MODULE_ALIAS("platform:wdat_wdt");