[mirror_ubuntu-kernels.git] / drivers / watchdog / wm831x_wdt.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Watchdog driver for the wm831x PMICs
 *
 * Copyright (C) 2009 Wolfson Microelectronics
 */

#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/mfd/wm831x/core.h>
#include <linux/mfd/wm831x/pdata.h>
#include <linux/mfd/wm831x/watchdog.h>

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) ")");

struct wm831x_wdt_drvdata {
	struct watchdog_device wdt;
	struct wm831x *wm831x;
	struct mutex lock;
	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);

	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);
	}

	wdt_dev->timeout = timeout;

	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 wm831x_wdt_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct wm831x *wm831x = dev_get_drvdata(dev->parent);
	struct wm831x_pdata *chip_pdata = dev_get_platdata(dev->parent);
	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);
		return ret;
	}
	reg = ret;

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

	driver_data = devm_kzalloc(dev, sizeof(*driver_data), GFP_KERNEL);
	if (!driver_data)
		return -ENOMEM;

	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;
	wm831x_wdt->parent = dev;
	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 (chip_pdata)
		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;

		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);
			return ret;
		}
	}

	return devm_watchdog_register_device(dev, &driver_data->wdt);
}

static struct platform_driver wm831x_wdt_driver = {
	.probe = wm831x_wdt_probe,
	.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
2e62c498	1	// SPDX-License-Identifier: GPL-2.0+
502a0106 MB	2	/*
	3	* Watchdog driver for the wm831x PMICs
	4	*
	5	* Copyright (C) 2009 Wolfson Microelectronics
502a0106 MB	6	*/
	7
	8	#include <linux/module.h>
	9	#include <linux/moduleparam.h>
	10	#include <linux/types.h>
	11	#include <linux/kernel.h>
00411ee9	12	#include <linux/slab.h>
502a0106 MB	13	#include <linux/platform_device.h>
	14	#include <linux/watchdog.h>
	15	#include <linux/uaccess.h>
502a0106 MB	16
	17	#include <linux/mfd/wm831x/core.h>
	18	#include <linux/mfd/wm831x/pdata.h>
	19	#include <linux/mfd/wm831x/watchdog.h>
	20
86a1e189 WVS	21	static bool nowayout = WATCHDOG_NOWAYOUT;
86a1e189 WVS	22	module_param(nowayout, bool, 0);
502a0106 MB	23	MODULE_PARM_DESC(nowayout,
	24	"Watchdog cannot be stopped once started (default="
	25	__MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
	26
00411ee9 MB	27	struct wm831x_wdt_drvdata {
	28	struct watchdog_device wdt;
	29	struct wm831x *wm831x;
	30	struct mutex lock;
00411ee9 MB	31	int update_state;
00411ee9 MB	32	};
502a0106 MB	33
	34	/* We can't use the sub-second values here but they're included
	35	* for completeness. */
	36	static struct {
00411ee9 MB	37	unsigned int time; /* Seconds */
00411ee9 MB	38	u16 val; /* WDOG_TO value */
502a0106 MB	39	} wm831x_wdt_cfgs[] = {
	40	{ 1, 2 },
	41	{ 2, 3 },
	42	{ 4, 4 },
	43	{ 8, 5 },
	44	{ 16, 6 },
	45	{ 32, 7 },
	46	{ 33, 7 }, /* Actually 32.768s so include both, others round down */
	47	};
	48
00411ee9	49	static int wm831x_wdt_start(struct watchdog_device *wdt_dev)
502a0106	50	{
00411ee9 MB	51	struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
00411ee9 MB	52	struct wm831x *wm831x = driver_data->wm831x;
502a0106 MB	53	int ret;
502a0106 MB	54
00411ee9	55	mutex_lock(&driver_data->lock);
502a0106 MB	56
	57	ret = wm831x_reg_unlock(wm831x);
	58	if (ret == 0) {
	59	ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
	60	WM831X_WDOG_ENA, WM831X_WDOG_ENA);
	61	wm831x_reg_lock(wm831x);
	62	} else {
	63	dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
	64	ret);
	65	}
	66
00411ee9	67	mutex_unlock(&driver_data->lock);
502a0106 MB	68
	69	return ret;
	70	}
	71
00411ee9	72	static int wm831x_wdt_stop(struct watchdog_device *wdt_dev)
502a0106	73	{
00411ee9 MB	74	struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
00411ee9 MB	75	struct wm831x *wm831x = driver_data->wm831x;
502a0106 MB	76	int ret;
502a0106 MB	77
00411ee9	78	mutex_lock(&driver_data->lock);
502a0106 MB	79
	80	ret = wm831x_reg_unlock(wm831x);
	81	if (ret == 0) {
	82	ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
	83	WM831X_WDOG_ENA, 0);
	84	wm831x_reg_lock(wm831x);
	85	} else {
	86	dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
	87	ret);
	88	}
	89
00411ee9	90	mutex_unlock(&driver_data->lock);
502a0106 MB	91
	92	return ret;
	93	}
	94
00411ee9	95	static int wm831x_wdt_ping(struct watchdog_device *wdt_dev)
502a0106	96	{
00411ee9 MB	97	struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
00411ee9 MB	98	struct wm831x *wm831x = driver_data->wm831x;
502a0106 MB	99	int ret;
	100	u16 reg;
	101
00411ee9	102	mutex_lock(&driver_data->lock);
502a0106	103
502a0106 MB	104	reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
	105
	106	if (!(reg & WM831X_WDOG_RST_SRC)) {
	107	dev_err(wm831x->dev, "Hardware watchdog update unsupported\n");
	108	ret = -EINVAL;
	109	goto out;
	110	}
	111
	112	reg \|= WM831X_WDOG_RESET;
	113
	114	ret = wm831x_reg_unlock(wm831x);
	115	if (ret == 0) {
	116	ret = wm831x_reg_write(wm831x, WM831X_WATCHDOG, reg);
	117	wm831x_reg_lock(wm831x);
	118	} else {
	119	dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
	120	ret);
	121	}
	122
	123	out:
00411ee9	124	mutex_unlock(&driver_data->lock);
502a0106 MB	125
	126	return ret;
	127	}
	128
00411ee9 MB	129	static int wm831x_wdt_set_timeout(struct watchdog_device *wdt_dev,
00411ee9 MB	130	unsigned int timeout)
502a0106	131	{
00411ee9 MB	132	struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
	133	struct wm831x *wm831x = driver_data->wm831x;
	134	int ret, i;
502a0106	135
00411ee9 MB	136	for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++)
	137	if (wm831x_wdt_cfgs[i].time == timeout)
	138	break;
	139	if (i == ARRAY_SIZE(wm831x_wdt_cfgs))
f9849100	140	return -EINVAL;
502a0106	141
00411ee9 MB	142	ret = wm831x_reg_unlock(wm831x);
	143	if (ret == 0) {
	144	ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
	145	WM831X_WDOG_TO_MASK,
	146	wm831x_wdt_cfgs[i].val);
	147	wm831x_reg_lock(wm831x);
	148	} else {
	149	dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
	150	ret);
502a0106 MB	151	}
502a0106 MB	152
0197c1c4 WVS	153	wdt_dev->timeout = timeout;
0197c1c4 WVS	154
00411ee9	155	return ret;
502a0106 MB	156	}
502a0106 MB	157
00411ee9	158	static const struct watchdog_info wm831x_wdt_info = {
502a0106 MB	159	.options = WDIOF_SETTIMEOUT \| WDIOF_KEEPALIVEPING \| WDIOF_MAGICCLOSE,
	160	.identity = "WM831x Watchdog",
	161	};
	162
00411ee9	163	static const struct watchdog_ops wm831x_wdt_ops = {
502a0106	164	.owner = THIS_MODULE,
00411ee9 MB	165	.start = wm831x_wdt_start,
	166	.stop = wm831x_wdt_stop,
	167	.ping = wm831x_wdt_ping,
	168	.set_timeout = wm831x_wdt_set_timeout,
502a0106 MB	169	};
502a0106 MB	170
2d991a16	171	static int wm831x_wdt_probe(struct platform_device *pdev)
502a0106	172	{
30f57e0f GR	173	struct device *dev = &pdev->dev;
	174	struct wm831x *wm831x = dev_get_drvdata(dev->parent);
	175	struct wm831x_pdata *chip_pdata = dev_get_platdata(dev->parent);
502a0106	176	struct wm831x_watchdog_pdata *pdata;
00411ee9 MB	177	struct wm831x_wdt_drvdata *driver_data;
	178	struct watchdog_device *wm831x_wdt;
	179	int reg, ret, i;
502a0106 MB	180
	181	ret = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
	182	if (ret < 0) {
	183	dev_err(wm831x->dev, "Failed to read watchdog status: %d\n",
	184	ret);
30cba9a1	185	return ret;
502a0106 MB	186	}
	187	reg = ret;
	188
	189	if (reg & WM831X_WDOG_DEBUG)
	190	dev_warn(wm831x->dev, "Watchdog is paused\n");
	191
30f57e0f	192	driver_data = devm_kzalloc(dev, sizeof(*driver_data), GFP_KERNEL);
30cba9a1 GR	193	if (!driver_data)
30cba9a1 GR	194	return -ENOMEM;
00411ee9 MB	195
	196	mutex_init(&driver_data->lock);
	197	driver_data->wm831x = wm831x;
	198
	199	wm831x_wdt = &driver_data->wdt;
	200
	201	wm831x_wdt->info = &wm831x_wdt_info;
	202	wm831x_wdt->ops = &wm831x_wdt_ops;
30f57e0f	203	wm831x_wdt->parent = dev;
ff0b3cd4	204	watchdog_set_nowayout(wm831x_wdt, nowayout);
00411ee9 MB	205	watchdog_set_drvdata(wm831x_wdt, driver_data);
00411ee9 MB	206
00411ee9 MB	207	reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
	208	reg &= WM831X_WDOG_TO_MASK;
	209	for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++)
	210	if (wm831x_wdt_cfgs[i].val == reg)
	211	break;
	212	if (i == ARRAY_SIZE(wm831x_wdt_cfgs))
	213	dev_warn(wm831x->dev,
	214	"Unknown watchdog timeout: %x\n", reg);
	215	else
	216	wm831x_wdt->timeout = wm831x_wdt_cfgs[i].time;
	217
502a0106	218	/* Apply any configuration */
bc8fdfbe	219	if (chip_pdata)
502a0106	220	pdata = chip_pdata->watchdog;
bc8fdfbe	221	else
502a0106	222	pdata = NULL;
502a0106 MB	223
	224	if (pdata) {
	225	reg &= ~(WM831X_WDOG_SECACT_MASK \| WM831X_WDOG_PRIMACT_MASK \|
	226	WM831X_WDOG_RST_SRC);
	227
	228	reg \|= pdata->primary << WM831X_WDOG_PRIMACT_SHIFT;
	229	reg \|= pdata->secondary << WM831X_WDOG_SECACT_SHIFT;
	230	reg \|= pdata->software << WM831X_WDOG_RST_SRC_SHIFT;
	231
502a0106 MB	232	ret = wm831x_reg_unlock(wm831x);
	233	if (ret == 0) {
	234	ret = wm831x_reg_write(wm831x, WM831X_WATCHDOG, reg);
	235	wm831x_reg_lock(wm831x);
	236	} else {
	237	dev_err(wm831x->dev,
	238	"Failed to unlock security key: %d\n", ret);
30cba9a1	239	return ret;
502a0106 MB	240	}
	241	}
	242
f848a153	243	return devm_watchdog_register_device(dev, &driver_data->wdt);
502a0106 MB	244	}
	245
	246	static struct platform_driver wm831x_wdt_driver = {
	247	.probe = wm831x_wdt_probe,
502a0106 MB	248	.driver = {
	249	.name = "wm831x-watchdog",
	250	},
	251	};
	252
216f3ad9	253	module_platform_driver(wm831x_wdt_driver);
502a0106 MB	254
	255	MODULE_AUTHOR("Mark Brown");
	256	MODULE_DESCRIPTION("WM831x Watchdog");
	257	MODULE_LICENSE("GPL");
	258	MODULE_ALIAS("platform:wm831x-watchdog");