| Message ID | 20240118195325.2964918-3-lma@chromium.org (mailing list archive) |
|---|---|
| State | Superseded |
| Headers | show |
| Series | Introduce EC-based watchdog | expand |
On Thu, Jan 18, 2024 at 07:53:23PM +0000, Lukasz Majczak wrote: > Embedded Controller (EC) present on Chromebook devices > can be used as a watchdog. > Implement a driver to support it. > > Signed-off-by: Lukasz Majczak <lma@chromium.org> Nits: > +#define CROS_EC_WATCHDOG_DEFAULT_TIME 30 /* seconds */ > +#define DRV_NAME "cros-ec-wdt-drv" #define<space>NAME<tab>value please, and "-drv" in the driver name is really unnecessary. With that changed, Reviewed-by: Guenter Roeck <linux@roeck-us.net> Thanks, Guenter
On Thu, Jan 18, 2024 at 07:53:23PM +0000, Lukasz Majczak wrote: > diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig > index 7d22051b15a2..4700b218340f 100644 > --- a/drivers/watchdog/Kconfig > +++ b/drivers/watchdog/Kconfig > @@ -181,6 +181,17 @@ config BD957XMUF_WATCHDOG > watchdog. Alternatively say M to compile the driver as a module, > which will be called bd9576_wdt. > > +config CROS_EC_WATCHDOG > + tristate "ChromeOS EC-based watchdog" > + select WATCHDOG_CORE > + depends on CROS_EC > + help > + Watchdog driver for Chromebook devices equipped with embedded controller. > + Trigger event is recorded in EC and checked on the subsequent boot. Perhaps unrelated to the patch, but I'm curious what the mechanism is. Does it use any existing paths for checking the saved events in EC? What it does if there is a saved WDT reset event? > diff --git a/drivers/watchdog/cros_ec_wdt.c b/drivers/watchdog/cros_ec_wdt.c [...] > +static int cros_ec_wdt_ping(struct watchdog_device *wdd) > +{ [...] > + arg.req.command = EC_HANG_DETECT_CMD_RELOAD; > + ret = cros_ec_wdt_send_cmd(cros_ec, &arg); > + if (ret < 0) > + dev_dbg(wdd->parent, "Failed to ping watchdog (%d)", ret); I think this would be worth dev_info() or dev_warn()? > +static int cros_ec_wdt_start(struct watchdog_device *wdd) > +{ [...] > + /* Prepare watchdog on EC side */ > + arg.req.command = EC_HANG_DETECT_CMD_SET_TIMEOUT; > + arg.req.reboot_timeout_sec = wdd->timeout; > + ret = cros_ec_wdt_send_cmd(cros_ec, &arg); > + if (ret < 0) > + dev_dbg(wdd->parent, "Failed to start watchdog (%d)", ret); Same here: dev_info() or dev_warn()? > +static int cros_ec_wdt_stop(struct watchdog_device *wdd) > +{ [...] > + arg.req.command = EC_HANG_DETECT_CMD_CANCEL; > + ret = cros_ec_wdt_send_cmd(cros_ec, &arg); > + if (ret < 0) > + dev_dbg(wdd->parent, "Failed to stop watchdog (%d)", ret); Same here: dev_info() or dev_warn()? > +static int cros_ec_wdt_probe(struct platform_device *pdev) > +{ > + struct device *dev = &pdev->dev; > + struct cros_ec_dev *ec_dev = dev_get_drvdata(dev->parent); > + struct cros_ec_device *cros_ec = ec_dev->ec_dev; > + struct watchdog_device *wdd; > + union cros_ec_wdt_data arg; > + int ret = 0; nit: `ret` doesn't need to be initialized.
On 1/18/24 19:42, Tzung-Bi Shih wrote: > On Thu, Jan 18, 2024 at 07:53:23PM +0000, Lukasz Majczak wrote: >> diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig >> index 7d22051b15a2..4700b218340f 100644 >> --- a/drivers/watchdog/Kconfig >> +++ b/drivers/watchdog/Kconfig >> @@ -181,6 +181,17 @@ config BD957XMUF_WATCHDOG >> watchdog. Alternatively say M to compile the driver as a module, >> which will be called bd9576_wdt. >> >> +config CROS_EC_WATCHDOG >> + tristate "ChromeOS EC-based watchdog" >> + select WATCHDOG_CORE >> + depends on CROS_EC >> + help >> + Watchdog driver for Chromebook devices equipped with embedded controller. >> + Trigger event is recorded in EC and checked on the subsequent boot. > > Perhaps unrelated to the patch, but I'm curious what the mechanism is. Does > it use any existing paths for checking the saved events in EC? What it does > if there is a saved WDT reset event? > Reporting the reason of the previous reset/restart is part of the watchdog API. >> diff --git a/drivers/watchdog/cros_ec_wdt.c b/drivers/watchdog/cros_ec_wdt.c > [...] >> +static int cros_ec_wdt_ping(struct watchdog_device *wdd) >> +{ > [...] >> + arg.req.command = EC_HANG_DETECT_CMD_RELOAD; >> + ret = cros_ec_wdt_send_cmd(cros_ec, &arg); >> + if (ret < 0) >> + dev_dbg(wdd->parent, "Failed to ping watchdog (%d)", ret); > > I think this would be worth dev_info() or dev_warn()? > >> +static int cros_ec_wdt_start(struct watchdog_device *wdd) >> +{ > [...] >> + /* Prepare watchdog on EC side */ >> + arg.req.command = EC_HANG_DETECT_CMD_SET_TIMEOUT; >> + arg.req.reboot_timeout_sec = wdd->timeout; >> + ret = cros_ec_wdt_send_cmd(cros_ec, &arg); >> + if (ret < 0) >> + dev_dbg(wdd->parent, "Failed to start watchdog (%d)", ret); > > Same here: dev_info() or dev_warn()? > We had that before. It is just noise. If it fails, it will likely fail continuously, causing log spam. We don't do that kind of continuous error messages for other watchdog drivers and should not start doing it here. Thanks, Guenter
On Thu, Jan 18, 2024 at 07:55:39PM -0800, Guenter Roeck wrote: > On 1/18/24 19:42, Tzung-Bi Shih wrote: > > On Thu, Jan 18, 2024 at 07:53:23PM +0000, Lukasz Majczak wrote: > > > diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig > > > index 7d22051b15a2..4700b218340f 100644 > > > --- a/drivers/watchdog/Kconfig > > > +++ b/drivers/watchdog/Kconfig > > > @@ -181,6 +181,17 @@ config BD957XMUF_WATCHDOG > > > watchdog. Alternatively say M to compile the driver as a module, > > > which will be called bd9576_wdt. > > > +config CROS_EC_WATCHDOG > > > + tristate "ChromeOS EC-based watchdog" > > > + select WATCHDOG_CORE > > > + depends on CROS_EC > > > + help > > > + Watchdog driver for Chromebook devices equipped with embedded controller. > > > + Trigger event is recorded in EC and checked on the subsequent boot. > > > > Perhaps unrelated to the patch, but I'm curious what the mechanism is. Does > > it use any existing paths for checking the saved events in EC? What it does > > if there is a saved WDT reset event? > > > > Reporting the reason of the previous reset/restart is part of the watchdog API. Oh, I see. It is in cros_ec_wdt_probe(): `wdd->bootstatus`. +static int cros_ec_wdt_probe(struct platform_device *pdev) +{ [...] + arg.req.command = EC_HANG_DETECT_CMD_GET_STATUS; + ret = cros_ec_wdt_send_cmd(cros_ec, &arg); [...] + if (arg.resp.status == EC_HANG_DETECT_AP_BOOT_EC_WDT) + wdd->bootstatus = WDIOF_CARDRESET;
diff --git a/MAINTAINERS b/MAINTAINERS index ef90ddc0fda6..aaae581aae70 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -4981,6 +4981,12 @@ R: Sami Kyöstilä <skyostil@chromium.org> S: Maintained F: drivers/platform/chrome/cros_hps_i2c.c +CHROMEOS EC WATCHDOG +M: Lukasz Majczak <lma@chromium.org> +L: chrome-platform@lists.linux.dev +S: Maintained +F: drivers/watchdog/cros_ec_wdt.c + CHRONTEL CH7322 CEC DRIVER M: Joe Tessler <jrt@google.com> L: linux-media@vger.kernel.org diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig index 7d22051b15a2..4700b218340f 100644 --- a/drivers/watchdog/Kconfig +++ b/drivers/watchdog/Kconfig @@ -181,6 +181,17 @@ config BD957XMUF_WATCHDOG watchdog. Alternatively say M to compile the driver as a module, which will be called bd9576_wdt. +config CROS_EC_WATCHDOG + tristate "ChromeOS EC-based watchdog" + select WATCHDOG_CORE + depends on CROS_EC + help + Watchdog driver for Chromebook devices equipped with embedded controller. + Trigger event is recorded in EC and checked on the subsequent boot. + + To compile this driver as a module, choose M here: the + module will be called cros_ec_wdt. + config DA9052_WATCHDOG tristate "Dialog DA9052 Watchdog" depends on PMIC_DA9052 || COMPILE_TEST diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile index 7cbc34514ec1..3710c218f05e 100644 --- a/drivers/watchdog/Makefile +++ b/drivers/watchdog/Makefile @@ -217,6 +217,7 @@ obj-$(CONFIG_XEN_WDT) += xen_wdt.o # Architecture Independent obj-$(CONFIG_BD957XMUF_WATCHDOG) += bd9576_wdt.o +obj-$(CONFIG_CROS_EC_WATCHDOG) += cros_ec_wdt.o obj-$(CONFIG_DA9052_WATCHDOG) += da9052_wdt.o obj-$(CONFIG_DA9055_WATCHDOG) += da9055_wdt.o obj-$(CONFIG_DA9062_WATCHDOG) += da9062_wdt.o diff --git a/drivers/watchdog/cros_ec_wdt.c b/drivers/watchdog/cros_ec_wdt.c new file mode 100644 index 000000000000..1915b8d55e45 --- /dev/null +++ b/drivers/watchdog/cros_ec_wdt.c @@ -0,0 +1,202 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright 2024 Google LLC. + * Author: Lukasz Majczak <lma@chromium.com> + */ + +#include <linux/err.h> +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/mod_devicetable.h> +#include <linux/platform_data/cros_ec_commands.h> +#include <linux/platform_data/cros_ec_proto.h> +#include <linux/platform_device.h> +#include <linux/watchdog.h> + +#define CROS_EC_WATCHDOG_DEFAULT_TIME 30 /* seconds */ +#define DRV_NAME "cros-ec-wdt-drv" + +union cros_ec_wdt_data { + struct ec_params_hang_detect req; + struct ec_response_hang_detect resp; +} __packed; + +static int cros_ec_wdt_send_cmd(struct cros_ec_device *cros_ec, + union cros_ec_wdt_data *arg) +{ + int ret; + struct { + struct cros_ec_command msg; + union cros_ec_wdt_data data; + } __packed buf = { + .msg = { + .version = 0, + .command = EC_CMD_HANG_DETECT, + .insize = (arg->req.command == EC_HANG_DETECT_CMD_GET_STATUS) ? + sizeof(struct ec_response_hang_detect) : + 0, + .outsize = sizeof(struct ec_params_hang_detect), + }, + .data.req = arg->req + }; + + ret = cros_ec_cmd_xfer_status(cros_ec, &buf.msg); + if (ret < 0) + return ret; + + arg->resp = buf.data.resp; + + return 0; +} + +static int cros_ec_wdt_ping(struct watchdog_device *wdd) +{ + struct cros_ec_device *cros_ec = watchdog_get_drvdata(wdd); + union cros_ec_wdt_data arg; + int ret; + + arg.req.command = EC_HANG_DETECT_CMD_RELOAD; + ret = cros_ec_wdt_send_cmd(cros_ec, &arg); + if (ret < 0) + dev_dbg(wdd->parent, "Failed to ping watchdog (%d)", ret); + + return ret; +} + +static int cros_ec_wdt_start(struct watchdog_device *wdd) +{ + struct cros_ec_device *cros_ec = watchdog_get_drvdata(wdd); + union cros_ec_wdt_data arg; + int ret; + + /* Prepare watchdog on EC side */ + arg.req.command = EC_HANG_DETECT_CMD_SET_TIMEOUT; + arg.req.reboot_timeout_sec = wdd->timeout; + ret = cros_ec_wdt_send_cmd(cros_ec, &arg); + if (ret < 0) + dev_dbg(wdd->parent, "Failed to start watchdog (%d)", ret); + + return ret; +} + +static int cros_ec_wdt_stop(struct watchdog_device *wdd) +{ + struct cros_ec_device *cros_ec = watchdog_get_drvdata(wdd); + union cros_ec_wdt_data arg; + int ret; + + arg.req.command = EC_HANG_DETECT_CMD_CANCEL; + ret = cros_ec_wdt_send_cmd(cros_ec, &arg); + if (ret < 0) + dev_dbg(wdd->parent, "Failed to stop watchdog (%d)", ret); + + return ret; +} + +static int cros_ec_wdt_set_timeout(struct watchdog_device *wdd, unsigned int t) +{ + unsigned int old_timeout = wdd->timeout; + int ret; + + wdd->timeout = t; + ret = cros_ec_wdt_start(wdd); + if (ret < 0) + wdd->timeout = old_timeout; + + return ret; +} + +static const struct watchdog_info cros_ec_wdt_ident = { + .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, + .firmware_version = 0, + .identity = DRV_NAME, +}; + +static const struct watchdog_ops cros_ec_wdt_ops = { + .owner = THIS_MODULE, + .ping = cros_ec_wdt_ping, + .start = cros_ec_wdt_start, + .stop = cros_ec_wdt_stop, + .set_timeout = cros_ec_wdt_set_timeout, +}; + +static int cros_ec_wdt_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct cros_ec_dev *ec_dev = dev_get_drvdata(dev->parent); + struct cros_ec_device *cros_ec = ec_dev->ec_dev; + struct watchdog_device *wdd; + union cros_ec_wdt_data arg; + int ret = 0; + + wdd = devm_kzalloc(&pdev->dev, sizeof(struct watchdog_device), GFP_KERNEL); + if (!wdd) + return -ENOMEM; + + arg.req.command = EC_HANG_DETECT_CMD_GET_STATUS; + ret = cros_ec_wdt_send_cmd(cros_ec, &arg); + if (ret < 0) + return dev_err_probe(dev, ret, "Failed to get watchdog bootstatus"); + + wdd->parent = &pdev->dev; + wdd->info = &cros_ec_wdt_ident; + wdd->ops = &cros_ec_wdt_ops; + wdd->timeout = CROS_EC_WATCHDOG_DEFAULT_TIME; + wdd->min_timeout = EC_HANG_DETECT_MIN_TIMEOUT; + wdd->max_timeout = EC_HANG_DETECT_MAX_TIMEOUT; + if (arg.resp.status == EC_HANG_DETECT_AP_BOOT_EC_WDT) + wdd->bootstatus = WDIOF_CARDRESET; + + arg.req.command = EC_HANG_DETECT_CMD_CLEAR_STATUS; + ret = cros_ec_wdt_send_cmd(cros_ec, &arg); + if (ret < 0) + return dev_err_probe(dev, ret, "Failed to clear watchdog bootstatus"); + + watchdog_stop_on_reboot(wdd); + watchdog_stop_on_unregister(wdd); + watchdog_set_drvdata(wdd, cros_ec); + platform_set_drvdata(pdev, wdd); + + return devm_watchdog_register_device(dev, wdd); +} + +static int __maybe_unused cros_ec_wdt_suspend(struct platform_device *pdev, pm_message_t state) +{ + struct watchdog_device *wdd = platform_get_drvdata(pdev); + int ret = 0; + + if (watchdog_active(wdd)) + ret = cros_ec_wdt_stop(wdd); + + return ret; +} + +static int __maybe_unused cros_ec_wdt_resume(struct platform_device *pdev) +{ + struct watchdog_device *wdd = platform_get_drvdata(pdev); + int ret = 0; + + if (watchdog_active(wdd)) + ret = cros_ec_wdt_start(wdd); + + return ret; +} + +static struct platform_driver cros_ec_wdt_driver = { + .probe = cros_ec_wdt_probe, + .suspend = pm_ptr(cros_ec_wdt_suspend), + .resume = pm_ptr(cros_ec_wdt_resume), + .driver = { + .name = DRV_NAME, + }, +}; + +module_platform_driver(cros_ec_wdt_driver); + +static const struct platform_device_id cros_ec_wdt_id[] = { + { DRV_NAME, 0 }, + {} +}; +MODULE_DEVICE_TABLE(platform, cros_ec_wdt_id); +MODULE_DESCRIPTION("Cros EC Watchdog Device Driver"); +MODULE_LICENSE("GPL");
Embedded Controller (EC) present on Chromebook devices can be used as a watchdog. Implement a driver to support it. Signed-off-by: Lukasz Majczak <lma@chromium.org> --- MAINTAINERS | 6 + drivers/watchdog/Kconfig | 11 ++ drivers/watchdog/Makefile | 1 + drivers/watchdog/cros_ec_wdt.c | 202 +++++++++++++++++++++++++++++++++ 4 files changed, 220 insertions(+) create mode 100644 drivers/watchdog/cros_ec_wdt.c