| // SPDX-License-Identifier: GPL-2.0 | |
| /* | |
| * Intel OC Watchdog driver | |
| * | |
| * Copyright (C) 2025, Siemens | |
| * Author: Diogo Ivo <diogo.ivo@siemens.com> | |
| */ | |
| #define DRV_NAME "intel_oc_wdt" | |
| #include <linux/acpi.h> | |
| #include <linux/bits.h> | |
| #include <linux/io.h> | |
| #include <linux/module.h> | |
| #include <linux/moduleparam.h> | |
| #include <linux/platform_device.h> | |
| #include <linux/watchdog.h> | |
| #define INTEL_OC_WDT_TOV GENMASK(9, 0) | |
| #define INTEL_OC_WDT_MIN_TOV 1 | |
| #define INTEL_OC_WDT_MAX_TOV 1024 | |
| #define INTEL_OC_WDT_DEF_TOV 60 | |
| /* | |
| * One-time writable lock bit. If set forbids | |
| * modification of itself, _TOV and _EN until | |
| * next reboot. | |
| */ | |
| #define INTEL_OC_WDT_CTL_LCK BIT(12) | |
| #define INTEL_OC_WDT_EN BIT(14) | |
| #define INTEL_OC_WDT_NO_ICCSURV_STS BIT(24) | |
| #define INTEL_OC_WDT_ICCSURV_STS BIT(25) | |
| #define INTEL_OC_WDT_RLD BIT(31) | |
| #define INTEL_OC_WDT_STS_BITS (INTEL_OC_WDT_NO_ICCSURV_STS | \ | |
| INTEL_OC_WDT_ICCSURV_STS) | |
| #define INTEL_OC_WDT_CTRL_REG(wdt) ((wdt)->ctrl_res->start) | |
| struct intel_oc_wdt { | |
| struct watchdog_device wdd; | |
| struct resource *ctrl_res; | |
| struct watchdog_info info; | |
| bool locked; | |
| }; | |
| static int heartbeat; | |
| module_param(heartbeat, uint, 0); | |
| MODULE_PARM_DESC(heartbeat, "Watchdog heartbeats in seconds. (default=" | |
| __MODULE_STRING(WDT_HEARTBEAT) ")"); | |
| static bool nowayout = WATCHDOG_NOWAYOUT; | |
| module_param(nowayout, bool, 0); | |
| MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" | |
| __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); | |
| static int intel_oc_wdt_start(struct watchdog_device *wdd) | |
| { | |
| struct intel_oc_wdt *oc_wdt = watchdog_get_drvdata(wdd); | |
| if (oc_wdt->locked) | |
| return 0; | |
| outl(inl(INTEL_OC_WDT_CTRL_REG(oc_wdt)) | INTEL_OC_WDT_EN, | |
| INTEL_OC_WDT_CTRL_REG(oc_wdt)); | |
| return 0; | |
| } | |
| static int intel_oc_wdt_stop(struct watchdog_device *wdd) | |
| { | |
| struct intel_oc_wdt *oc_wdt = watchdog_get_drvdata(wdd); | |
| outl(inl(INTEL_OC_WDT_CTRL_REG(oc_wdt)) & ~INTEL_OC_WDT_EN, | |
| INTEL_OC_WDT_CTRL_REG(oc_wdt)); | |
| return 0; | |
| } | |
| static int intel_oc_wdt_ping(struct watchdog_device *wdd) | |
| { | |
| struct intel_oc_wdt *oc_wdt = watchdog_get_drvdata(wdd); | |
| outl(inl(INTEL_OC_WDT_CTRL_REG(oc_wdt)) | INTEL_OC_WDT_RLD, | |
| INTEL_OC_WDT_CTRL_REG(oc_wdt)); | |
| return 0; | |
| } | |
| static int intel_oc_wdt_set_timeout(struct watchdog_device *wdd, | |
| unsigned int t) | |
| { | |
| struct intel_oc_wdt *oc_wdt = watchdog_get_drvdata(wdd); | |
| outl((inl(INTEL_OC_WDT_CTRL_REG(oc_wdt)) & ~INTEL_OC_WDT_TOV) | (t - 1), | |
| INTEL_OC_WDT_CTRL_REG(oc_wdt)); | |
| wdd->timeout = t; | |
| return 0; | |
| } | |
| static const struct watchdog_info intel_oc_wdt_info = { | |
| .options = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING, | |
| .identity = DRV_NAME, | |
| }; | |
| static const struct watchdog_ops intel_oc_wdt_ops = { | |
| .owner = THIS_MODULE, | |
| .start = intel_oc_wdt_start, | |
| .stop = intel_oc_wdt_stop, | |
| .ping = intel_oc_wdt_ping, | |
| .set_timeout = intel_oc_wdt_set_timeout, | |
| }; | |
| static int intel_oc_wdt_setup(struct intel_oc_wdt *oc_wdt) | |
| { | |
| unsigned long val; | |
| val = inl(INTEL_OC_WDT_CTRL_REG(oc_wdt)); | |
| if (val & INTEL_OC_WDT_STS_BITS) | |
| oc_wdt->wdd.bootstatus |= WDIOF_CARDRESET; | |
| oc_wdt->locked = !!(val & INTEL_OC_WDT_CTL_LCK); | |
| if (val & INTEL_OC_WDT_EN) { | |
| /* | |
| * No need to issue a ping here to "commit" the new timeout | |
| * value to hardware as the watchdog core schedules one | |
| * immediately when registering the watchdog. | |
| */ | |
| set_bit(WDOG_HW_RUNNING, &oc_wdt->wdd.status); | |
| if (oc_wdt->locked) { | |
| /* | |
| * Set nowayout unconditionally as we cannot stop | |
| * the watchdog. | |
| */ | |
| nowayout = true; | |
| /* | |
| * If we are locked read the current timeout value | |
| * and inform the core we can't change it. | |
| */ | |
| oc_wdt->wdd.timeout = (val & INTEL_OC_WDT_TOV) + 1; | |
| oc_wdt->info.options &= ~WDIOF_SETTIMEOUT; | |
| dev_info(oc_wdt->wdd.parent, | |
| "Register access locked, heartbeat fixed at: %u s\n", | |
| oc_wdt->wdd.timeout); | |
| } | |
| } else if (oc_wdt->locked) { | |
| /* | |
| * In case the watchdog is disabled and locked there | |
| * is nothing we can do with it so just fail probing. | |
| */ | |
| return -EACCES; | |
| } | |
| val &= ~INTEL_OC_WDT_TOV; | |
| outl(val | (oc_wdt->wdd.timeout - 1), INTEL_OC_WDT_CTRL_REG(oc_wdt)); | |
| return 0; | |
| } | |
| static int intel_oc_wdt_probe(struct platform_device *pdev) | |
| { | |
| struct device *dev = &pdev->dev; | |
| struct intel_oc_wdt *oc_wdt; | |
| struct watchdog_device *wdd; | |
| int ret; | |
| oc_wdt = devm_kzalloc(&pdev->dev, sizeof(*oc_wdt), GFP_KERNEL); | |
| if (!oc_wdt) | |
| return -ENOMEM; | |
| oc_wdt->ctrl_res = platform_get_resource(pdev, IORESOURCE_IO, 0); | |
| if (!oc_wdt->ctrl_res) { | |
| dev_err(&pdev->dev, "missing I/O resource\n"); | |
| return -ENODEV; | |
| } | |
| if (!devm_request_region(&pdev->dev, oc_wdt->ctrl_res->start, | |
| resource_size(oc_wdt->ctrl_res), pdev->name)) { | |
| dev_err(dev, "resource %pR already in use, device disabled\n", | |
| oc_wdt->ctrl_res); | |
| return -EBUSY; | |
| } | |
| wdd = &oc_wdt->wdd; | |
| wdd->min_timeout = INTEL_OC_WDT_MIN_TOV; | |
| wdd->max_timeout = INTEL_OC_WDT_MAX_TOV; | |
| wdd->timeout = INTEL_OC_WDT_DEF_TOV; | |
| oc_wdt->info = intel_oc_wdt_info; | |
| wdd->info = &oc_wdt->info; | |
| wdd->ops = &intel_oc_wdt_ops; | |
| wdd->parent = dev; | |
| watchdog_init_timeout(wdd, heartbeat, dev); | |
| ret = intel_oc_wdt_setup(oc_wdt); | |
| if (ret) | |
| return ret; | |
| watchdog_set_drvdata(wdd, oc_wdt); | |
| watchdog_set_nowayout(wdd, nowayout); | |
| watchdog_stop_on_reboot(wdd); | |
| watchdog_stop_on_unregister(wdd); | |
| return devm_watchdog_register_device(dev, wdd); | |
| } | |
| static const struct acpi_device_id intel_oc_wdt_match[] = { | |
| { "INT3F0D" }, | |
| { "INTC1099" }, | |
| { }, | |
| }; | |
| MODULE_DEVICE_TABLE(acpi, intel_oc_wdt_match); | |
| static struct platform_driver intel_oc_wdt_platform_driver = { | |
| .driver = { | |
| .name = DRV_NAME, | |
| .acpi_match_table = intel_oc_wdt_match, | |
| }, | |
| .probe = intel_oc_wdt_probe, | |
| }; | |
| module_platform_driver(intel_oc_wdt_platform_driver); | |
| MODULE_AUTHOR("Diogo Ivo <diogo.ivo@siemens.com>"); | |
| MODULE_LICENSE("GPL"); | |
| MODULE_DESCRIPTION("Intel OC Watchdog driver"); |