[deliverable/linux.git] / drivers / watchdog / wm831x_wdt.c

/*
 * Watchdog driver for the wm831x PMICs
 *
 * Copyright (C) 2009 Wolfson Microelectronics
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/watchdog.h>
#include <linux/uaccess.h>
#include <linux/gpio.h>

#include <linux/mfd/wm831x/core.h>
#include <linux/mfd/wm831x/pdata.h>
#include <linux/mfd/wm831x/watchdog.h>

static int nowayout = WATCHDOG_NOWAYOUT;
module_param(nowayout, int, 0);
MODULE_PARM_DESC(nowayout,
		 "Watchdog cannot be stopped once started (default="
		 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");

struct wm831x_wdt_drvdata {
	struct watchdog_device wdt;
	struct wm831x *wm831x;
	struct mutex lock;
	int update_gpio;
	int update_state;
};

/* We can't use the sub-second values here but they're included
 * for completeness.  */
static struct {
	unsigned int time;  /* Seconds */
	u16 val;            /* WDOG_TO value */
} wm831x_wdt_cfgs[] = {
	{  1, 2 },
	{  2, 3 },
	{  4, 4 },
	{  8, 5 },
	{ 16, 6 },
	{ 32, 7 },
	{ 33, 7 },  /* Actually 32.768s so include both, others round down */
};

static int wm831x_wdt_start(struct watchdog_device *wdt_dev)
{
	struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
	struct wm831x *wm831x = driver_data->wm831x;
	int ret;

	mutex_lock(&driver_data->lock);

	ret = wm831x_reg_unlock(wm831x);
	if (ret == 0) {
		ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
				      WM831X_WDOG_ENA, WM831X_WDOG_ENA);
		wm831x_reg_lock(wm831x);
	} else {
		dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
			ret);
	}

	mutex_unlock(&driver_data->lock);

	return ret;
}

static int wm831x_wdt_stop(struct watchdog_device *wdt_dev)
{
	struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
	struct wm831x *wm831x = driver_data->wm831x;
	int ret;

	mutex_lock(&driver_data->lock);

	ret = wm831x_reg_unlock(wm831x);
	if (ret == 0) {
		ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
				      WM831X_WDOG_ENA, 0);
		wm831x_reg_lock(wm831x);
	} else {
		dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
			ret);
	}

	mutex_unlock(&driver_data->lock);

	return ret;
}

static int wm831x_wdt_ping(struct watchdog_device *wdt_dev)
{
	struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
	struct wm831x *wm831x = driver_data->wm831x;
	int ret;
	u16 reg;

	mutex_lock(&driver_data->lock);

	if (driver_data->update_gpio) {
		gpio_set_value_cansleep(driver_data->update_gpio,
					driver_data->update_state);
		driver_data->update_state = !driver_data->update_state;
		ret = 0;
		goto out;
	}

	reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG);

	if (!(reg & WM831X_WDOG_RST_SRC)) {
		dev_err(wm831x->dev, "Hardware watchdog update unsupported\n");
		ret = -EINVAL;
		goto out;
	}

	reg |= WM831X_WDOG_RESET;

	ret = wm831x_reg_unlock(wm831x);
	if (ret == 0) {
		ret = wm831x_reg_write(wm831x, WM831X_WATCHDOG, reg);
		wm831x_reg_lock(wm831x);
	} else {
		dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
			ret);
	}

out:
	mutex_unlock(&driver_data->lock);

	return ret;
}

static int wm831x_wdt_set_timeout(struct watchdog_device *wdt_dev,
				  unsigned int timeout)
{
	struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
	struct wm831x *wm831x = driver_data->wm831x;
	int ret, i;

	for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++)
		if (wm831x_wdt_cfgs[i].time == timeout)
			break;
	if (i == ARRAY_SIZE(wm831x_wdt_cfgs))
		return -EINVAL;

	ret = wm831x_reg_unlock(wm831x);
	if (ret == 0) {
		ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
				      WM831X_WDOG_TO_MASK,
				      wm831x_wdt_cfgs[i].val);
		wm831x_reg_lock(wm831x);
	} else {
		dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
			ret);
	}

	return ret;
}

static const struct watchdog_info wm831x_wdt_info = {
	.options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
	.identity = "WM831x Watchdog",
};

static const struct watchdog_ops wm831x_wdt_ops = {
	.owner = THIS_MODULE,
	.start = wm831x_wdt_start,
	.stop = wm831x_wdt_stop,
	.ping = wm831x_wdt_ping,
	.set_timeout = wm831x_wdt_set_timeout,
};

static int __devinit wm831x_wdt_probe(struct platform_device *pdev)
{
	struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
	struct wm831x_pdata *chip_pdata;
	struct wm831x_watchdog_pdata *pdata;
	struct wm831x_wdt_drvdata *driver_data;
	struct watchdog_device *wm831x_wdt;
	int reg, ret, i;

	ret = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
	if (ret < 0) {
		dev_err(wm831x->dev, "Failed to read watchdog status: %d\n",
			ret);
		goto err;
	}
	reg = ret;

	if (reg & WM831X_WDOG_DEBUG)
		dev_warn(wm831x->dev, "Watchdog is paused\n");

	driver_data = kzalloc(sizeof(*driver_data), GFP_KERNEL);
	if (!driver_data) {
		dev_err(wm831x->dev, "Unable to alloacate watchdog device\n");
		ret = -ENOMEM;
		goto err;
	}

	mutex_init(&driver_data->lock);
	driver_data->wm831x = wm831x;

	wm831x_wdt = &driver_data->wdt;

	wm831x_wdt->info = &wm831x_wdt_info;
	wm831x_wdt->ops = &wm831x_wdt_ops;
	watchdog_set_nowayout(wm831x_wdt, nowayout);
	watchdog_set_drvdata(wm831x_wdt, driver_data);

	reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
	reg &= WM831X_WDOG_TO_MASK;
	for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++)
		if (wm831x_wdt_cfgs[i].val == reg)
			break;
	if (i == ARRAY_SIZE(wm831x_wdt_cfgs))
		dev_warn(wm831x->dev,
			 "Unknown watchdog timeout: %x\n", reg);
	else
		wm831x_wdt->timeout = wm831x_wdt_cfgs[i].time;

	/* Apply any configuration */
	if (pdev->dev.parent->platform_data) {
		chip_pdata = pdev->dev.parent->platform_data;
		pdata = chip_pdata->watchdog;
	} else {
		pdata = NULL;
	}

	if (pdata) {
		reg &= ~(WM831X_WDOG_SECACT_MASK | WM831X_WDOG_PRIMACT_MASK |
			 WM831X_WDOG_RST_SRC);

		reg |= pdata->primary << WM831X_WDOG_PRIMACT_SHIFT;
		reg |= pdata->secondary << WM831X_WDOG_SECACT_SHIFT;
		reg |= pdata->software << WM831X_WDOG_RST_SRC_SHIFT;

		if (pdata->update_gpio) {
			ret = gpio_request(pdata->update_gpio,
					   "Watchdog update");
			if (ret < 0) {
				dev_err(wm831x->dev,
					"Failed to request update GPIO: %d\n",
					ret);
				goto err_alloc;
			}

			ret = gpio_direction_output(pdata->update_gpio, 0);
			if (ret != 0) {
				dev_err(wm831x->dev,
					"gpio_direction_output returned: %d\n",
					ret);
				goto err_gpio;
			}

			driver_data->update_gpio = pdata->update_gpio;

			/* Make sure the watchdog takes hardware updates */
			reg |= WM831X_WDOG_RST_SRC;
		}

		ret = wm831x_reg_unlock(wm831x);
		if (ret == 0) {
			ret = wm831x_reg_write(wm831x, WM831X_WATCHDOG, reg);
			wm831x_reg_lock(wm831x);
		} else {
			dev_err(wm831x->dev,
				"Failed to unlock security key: %d\n", ret);
			goto err_gpio;
		}
	}

	ret = watchdog_register_device(&driver_data->wdt);
	if (ret != 0) {
		dev_err(wm831x->dev, "watchdog_register_device() failed: %d\n",
			ret);
		goto err_gpio;
	}

	dev_set_drvdata(&pdev->dev, driver_data);

	return 0;

err_gpio:
	if (driver_data->update_gpio)
		gpio_free(driver_data->update_gpio);
err_alloc:
	kfree(driver_data);
err:
	return ret;
}

static int __devexit wm831x_wdt_remove(struct platform_device *pdev)
{
	struct wm831x_wdt_drvdata *driver_data = dev_get_drvdata(&pdev->dev);

	watchdog_unregister_device(&driver_data->wdt);

	if (driver_data->update_gpio)
		gpio_free(driver_data->update_gpio);

	return 0;
}

static struct platform_driver wm831x_wdt_driver = {
	.probe = wm831x_wdt_probe,
	.remove = __devexit_p(wm831x_wdt_remove),
	.driver = {
		.name = "wm831x-watchdog",
	},
};

module_platform_driver(wm831x_wdt_driver);

MODULE_AUTHOR("Mark Brown");
MODULE_DESCRIPTION("WM831x Watchdog");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:wm831x-watchdog");
Commit	Line	Data
502a0106 MB	1	/*
	2	* Watchdog driver for the wm831x PMICs
	3	*
	4	* Copyright (C) 2009 Wolfson Microelectronics
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation
	9	*/
	10
	11	#include <linux/module.h>
	12	#include <linux/moduleparam.h>
	13	#include <linux/types.h>
	14	#include <linux/kernel.h>
00411ee9	15	#include <linux/slab.h>
502a0106 MB	16	#include <linux/platform_device.h>
	17	#include <linux/watchdog.h>
	18	#include <linux/uaccess.h>
	19	#include <linux/gpio.h>
	20
	21	#include <linux/mfd/wm831x/core.h>
	22	#include <linux/mfd/wm831x/pdata.h>
	23	#include <linux/mfd/wm831x/watchdog.h>
	24
	25	static int nowayout = WATCHDOG_NOWAYOUT;
	26	module_param(nowayout, int, 0);
	27	MODULE_PARM_DESC(nowayout,
	28	"Watchdog cannot be stopped once started (default="
	29	__MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
	30
00411ee9 MB	31	struct wm831x_wdt_drvdata {
	32	struct watchdog_device wdt;
	33	struct wm831x *wm831x;
	34	struct mutex lock;
	35	int update_gpio;
	36	int update_state;
	37	};
502a0106 MB	38
	39	/* We can't use the sub-second values here but they're included
	40	* for completeness. */
	41	static struct {
00411ee9 MB	42	unsigned int time; /* Seconds */
00411ee9 MB	43	u16 val; /* WDOG_TO value */
502a0106 MB	44	} wm831x_wdt_cfgs[] = {
	45	{ 1, 2 },
	46	{ 2, 3 },
	47	{ 4, 4 },
	48	{ 8, 5 },
	49	{ 16, 6 },
	50	{ 32, 7 },
	51	{ 33, 7 }, /* Actually 32.768s so include both, others round down */
	52	};
	53
00411ee9	54	static int wm831x_wdt_start(struct watchdog_device *wdt_dev)
502a0106	55	{
00411ee9 MB	56	struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
00411ee9 MB	57	struct wm831x *wm831x = driver_data->wm831x;
502a0106 MB	58	int ret;
502a0106 MB	59
00411ee9	60	mutex_lock(&driver_data->lock);
502a0106 MB	61
	62	ret = wm831x_reg_unlock(wm831x);
	63	if (ret == 0) {
	64	ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
	65	WM831X_WDOG_ENA, WM831X_WDOG_ENA);
	66	wm831x_reg_lock(wm831x);
	67	} else {
	68	dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
	69	ret);
	70	}
	71
00411ee9	72	mutex_unlock(&driver_data->lock);
502a0106 MB	73
	74	return ret;
	75	}
	76
00411ee9	77	static int wm831x_wdt_stop(struct watchdog_device *wdt_dev)
502a0106	78	{
00411ee9 MB	79	struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
00411ee9 MB	80	struct wm831x *wm831x = driver_data->wm831x;
502a0106 MB	81	int ret;
502a0106 MB	82
00411ee9	83	mutex_lock(&driver_data->lock);
502a0106 MB	84
	85	ret = wm831x_reg_unlock(wm831x);
	86	if (ret == 0) {
	87	ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
	88	WM831X_WDOG_ENA, 0);
	89	wm831x_reg_lock(wm831x);
	90	} else {
	91	dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
	92	ret);
	93	}
	94
00411ee9	95	mutex_unlock(&driver_data->lock);
502a0106 MB	96
	97	return ret;
	98	}
	99
00411ee9	100	static int wm831x_wdt_ping(struct watchdog_device *wdt_dev)
502a0106	101	{
00411ee9 MB	102	struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
00411ee9 MB	103	struct wm831x *wm831x = driver_data->wm831x;
502a0106 MB	104	int ret;
	105	u16 reg;
	106
00411ee9	107	mutex_lock(&driver_data->lock);
502a0106	108
00411ee9 MB	109	if (driver_data->update_gpio) {
	110	gpio_set_value_cansleep(driver_data->update_gpio,
	111	driver_data->update_state);
	112	driver_data->update_state = !driver_data->update_state;
502a0106 MB	113	ret = 0;
	114	goto out;
	115	}
	116
502a0106 MB	117	reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
	118
	119	if (!(reg & WM831X_WDOG_RST_SRC)) {
	120	dev_err(wm831x->dev, "Hardware watchdog update unsupported\n");
	121	ret = -EINVAL;
	122	goto out;
	123	}
	124
	125	reg \|= WM831X_WDOG_RESET;
	126
	127	ret = wm831x_reg_unlock(wm831x);
	128	if (ret == 0) {
	129	ret = wm831x_reg_write(wm831x, WM831X_WATCHDOG, reg);
	130	wm831x_reg_lock(wm831x);
	131	} else {
	132	dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
	133	ret);
	134	}
	135
	136	out:
00411ee9	137	mutex_unlock(&driver_data->lock);
502a0106 MB	138
	139	return ret;
	140	}
	141
00411ee9 MB	142	static int wm831x_wdt_set_timeout(struct watchdog_device *wdt_dev,
00411ee9 MB	143	unsigned int timeout)
502a0106	144	{
00411ee9 MB	145	struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
	146	struct wm831x *wm831x = driver_data->wm831x;
	147	int ret, i;
502a0106	148
00411ee9 MB	149	for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++)
	150	if (wm831x_wdt_cfgs[i].time == timeout)
	151	break;
	152	if (i == ARRAY_SIZE(wm831x_wdt_cfgs))
f9849100	153	return -EINVAL;
502a0106	154
00411ee9 MB	155	ret = wm831x_reg_unlock(wm831x);
	156	if (ret == 0) {
	157	ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
	158	WM831X_WDOG_TO_MASK,
	159	wm831x_wdt_cfgs[i].val);
	160	wm831x_reg_lock(wm831x);
	161	} else {
	162	dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
	163	ret);
502a0106 MB	164	}
502a0106 MB	165
00411ee9	166	return ret;
502a0106 MB	167	}
502a0106 MB	168
00411ee9	169	static const struct watchdog_info wm831x_wdt_info = {
502a0106 MB	170	.options = WDIOF_SETTIMEOUT \| WDIOF_KEEPALIVEPING \| WDIOF_MAGICCLOSE,
	171	.identity = "WM831x Watchdog",
	172	};
	173
00411ee9	174	static const struct watchdog_ops wm831x_wdt_ops = {
502a0106	175	.owner = THIS_MODULE,
00411ee9 MB	176	.start = wm831x_wdt_start,
	177	.stop = wm831x_wdt_stop,
	178	.ping = wm831x_wdt_ping,
	179	.set_timeout = wm831x_wdt_set_timeout,
502a0106 MB	180	};
	181
	182	static int __devinit wm831x_wdt_probe(struct platform_device *pdev)
	183	{
00411ee9	184	struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
502a0106 MB	185	struct wm831x_pdata *chip_pdata;
502a0106 MB	186	struct wm831x_watchdog_pdata *pdata;
00411ee9 MB	187	struct wm831x_wdt_drvdata *driver_data;
	188	struct watchdog_device *wm831x_wdt;
	189	int reg, ret, i;
502a0106 MB	190
	191	ret = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
	192	if (ret < 0) {
	193	dev_err(wm831x->dev, "Failed to read watchdog status: %d\n",
	194	ret);
	195	goto err;
	196	}
	197	reg = ret;
	198
	199	if (reg & WM831X_WDOG_DEBUG)
	200	dev_warn(wm831x->dev, "Watchdog is paused\n");
	201
00411ee9 MB	202	driver_data = kzalloc(sizeof(*driver_data), GFP_KERNEL);
	203	if (!driver_data) {
	204	dev_err(wm831x->dev, "Unable to alloacate watchdog device\n");
	205	ret = -ENOMEM;
	206	goto err;
	207	}
	208
	209	mutex_init(&driver_data->lock);
	210	driver_data->wm831x = wm831x;
	211
	212	wm831x_wdt = &driver_data->wdt;
	213
	214	wm831x_wdt->info = &wm831x_wdt_info;
	215	wm831x_wdt->ops = &wm831x_wdt_ops;
ff0b3cd4	216	watchdog_set_nowayout(wm831x_wdt, nowayout);
00411ee9 MB	217	watchdog_set_drvdata(wm831x_wdt, driver_data);
00411ee9 MB	218
00411ee9 MB	219	reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
	220	reg &= WM831X_WDOG_TO_MASK;
	221	for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++)
	222	if (wm831x_wdt_cfgs[i].val == reg)
	223	break;
	224	if (i == ARRAY_SIZE(wm831x_wdt_cfgs))
	225	dev_warn(wm831x->dev,
	226	"Unknown watchdog timeout: %x\n", reg);
	227	else
	228	wm831x_wdt->timeout = wm831x_wdt_cfgs[i].time;
	229
502a0106 MB	230	/* Apply any configuration */
	231	if (pdev->dev.parent->platform_data) {
	232	chip_pdata = pdev->dev.parent->platform_data;
	233	pdata = chip_pdata->watchdog;
	234	} else {
	235	pdata = NULL;
	236	}
	237
	238	if (pdata) {
	239	reg &= ~(WM831X_WDOG_SECACT_MASK \| WM831X_WDOG_PRIMACT_MASK \|
	240	WM831X_WDOG_RST_SRC);
	241
	242	reg \|= pdata->primary << WM831X_WDOG_PRIMACT_SHIFT;
	243	reg \|= pdata->secondary << WM831X_WDOG_SECACT_SHIFT;
	244	reg \|= pdata->software << WM831X_WDOG_RST_SRC_SHIFT;
	245
	246	if (pdata->update_gpio) {
	247	ret = gpio_request(pdata->update_gpio,
	248	"Watchdog update");
	249	if (ret < 0) {
	250	dev_err(wm831x->dev,
	251	"Failed to request update GPIO: %d\n",
	252	ret);
00411ee9	253	goto err_alloc;
502a0106 MB	254	}
	255
	256	ret = gpio_direction_output(pdata->update_gpio, 0);
	257	if (ret != 0) {
	258	dev_err(wm831x->dev,
	259	"gpio_direction_output returned: %d\n",
	260	ret);
	261	goto err_gpio;
	262	}
	263
00411ee9	264	driver_data->update_gpio = pdata->update_gpio;
502a0106 MB	265
	266	/* Make sure the watchdog takes hardware updates */
	267	reg \|= WM831X_WDOG_RST_SRC;
	268	}
	269
	270	ret = wm831x_reg_unlock(wm831x);
	271	if (ret == 0) {
	272	ret = wm831x_reg_write(wm831x, WM831X_WATCHDOG, reg);
	273	wm831x_reg_lock(wm831x);
	274	} else {
	275	dev_err(wm831x->dev,
	276	"Failed to unlock security key: %d\n", ret);
	277	goto err_gpio;
	278	}
	279	}
	280
00411ee9	281	ret = watchdog_register_device(&driver_data->wdt);
502a0106	282	if (ret != 0) {
00411ee9 MB	283	dev_err(wm831x->dev, "watchdog_register_device() failed: %d\n",
00411ee9 MB	284	ret);
502a0106 MB	285	goto err_gpio;
	286	}
	287
00411ee9 MB	288	dev_set_drvdata(&pdev->dev, driver_data);
00411ee9 MB	289
502a0106 MB	290	return 0;
	291
	292	err_gpio:
00411ee9 MB	293	if (driver_data->update_gpio)
	294	gpio_free(driver_data->update_gpio);
	295	err_alloc:
	296	kfree(driver_data);
502a0106 MB	297	err:
	298	return ret;
	299	}
	300
	301	static int __devexit wm831x_wdt_remove(struct platform_device *pdev)
	302	{
00411ee9 MB	303	struct wm831x_wdt_drvdata *driver_data = dev_get_drvdata(&pdev->dev);
	304
	305	watchdog_unregister_device(&driver_data->wdt);
502a0106	306
00411ee9 MB	307	if (driver_data->update_gpio)
00411ee9 MB	308	gpio_free(driver_data->update_gpio);
502a0106 MB	309
	310	return 0;
	311	}
	312
	313	static struct platform_driver wm831x_wdt_driver = {
	314	.probe = wm831x_wdt_probe,
	315	.remove = __devexit_p(wm831x_wdt_remove),
	316	.driver = {
	317	.name = "wm831x-watchdog",
	318	},
	319	};
	320
216f3ad9	321	module_platform_driver(wm831x_wdt_driver);
502a0106 MB	322
	323	MODULE_AUTHOR("Mark Brown");
	324	MODULE_DESCRIPTION("WM831x Watchdog");
	325	MODULE_LICENSE("GPL");
	326	MODULE_ALIAS("platform:wm831x-watchdog");