[GitHub/LineageOS/android_kernel_motorola_exynos9610.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 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_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);
	}

	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 wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
	struct wm831x_pdata *chip_pdata = dev_get_platdata(pdev->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(&pdev->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 = &pdev->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;

		if (pdata->update_gpio) {
			ret = devm_gpio_request_one(&pdev->dev,
						pdata->update_gpio,
						GPIOF_OUT_INIT_LOW,
						"Watchdog update");
			if (ret < 0) {
				dev_err(wm831x->dev,
					"Failed to request update GPIO: %d\n",
					ret);
				return ret;
			}

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

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

	return 0;
}

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
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
86a1e189 WVS	25	static bool nowayout = WATCHDOG_NOWAYOUT;
86a1e189 WVS	26	module_param(nowayout, bool, 0);
502a0106 MB	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
0197c1c4 WVS	166	wdt_dev->timeout = timeout;
0197c1c4 WVS	167
00411ee9	168	return ret;
502a0106 MB	169	}
502a0106 MB	170
00411ee9	171	static const struct watchdog_info wm831x_wdt_info = {
502a0106 MB	172	.options = WDIOF_SETTIMEOUT \| WDIOF_KEEPALIVEPING \| WDIOF_MAGICCLOSE,
	173	.identity = "WM831x Watchdog",
	174	};
	175
00411ee9	176	static const struct watchdog_ops wm831x_wdt_ops = {
502a0106	177	.owner = THIS_MODULE,
00411ee9 MB	178	.start = wm831x_wdt_start,
	179	.stop = wm831x_wdt_stop,
	180	.ping = wm831x_wdt_ping,
	181	.set_timeout = wm831x_wdt_set_timeout,
502a0106 MB	182	};
502a0106 MB	183
2d991a16	184	static int wm831x_wdt_probe(struct platform_device *pdev)
502a0106	185	{
00411ee9	186	struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
bc8fdfbe	187	struct wm831x_pdata *chip_pdata = dev_get_platdata(pdev->dev.parent);
502a0106	188	struct wm831x_watchdog_pdata *pdata;
00411ee9 MB	189	struct wm831x_wdt_drvdata *driver_data;
	190	struct watchdog_device *wm831x_wdt;
	191	int reg, ret, i;
502a0106 MB	192
	193	ret = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
	194	if (ret < 0) {
	195	dev_err(wm831x->dev, "Failed to read watchdog status: %d\n",
	196	ret);
30cba9a1	197	return ret;
502a0106 MB	198	}
	199	reg = ret;
	200
	201	if (reg & WM831X_WDOG_DEBUG)
	202	dev_warn(wm831x->dev, "Watchdog is paused\n");
	203
7b9bb6d8 MB	204	driver_data = devm_kzalloc(&pdev->dev, sizeof(*driver_data),
7b9bb6d8 MB	205	GFP_KERNEL);
30cba9a1 GR	206	if (!driver_data)
30cba9a1 GR	207	return -ENOMEM;
00411ee9 MB	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;
6551881c	216	wm831x_wdt->parent = &pdev->dev;
ff0b3cd4	217	watchdog_set_nowayout(wm831x_wdt, nowayout);
00411ee9 MB	218	watchdog_set_drvdata(wm831x_wdt, driver_data);
00411ee9 MB	219
00411ee9 MB	220	reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
	221	reg &= WM831X_WDOG_TO_MASK;
	222	for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++)
	223	if (wm831x_wdt_cfgs[i].val == reg)
	224	break;
	225	if (i == ARRAY_SIZE(wm831x_wdt_cfgs))
	226	dev_warn(wm831x->dev,
	227	"Unknown watchdog timeout: %x\n", reg);
	228	else
	229	wm831x_wdt->timeout = wm831x_wdt_cfgs[i].time;
	230
502a0106	231	/* Apply any configuration */
bc8fdfbe	232	if (chip_pdata)
502a0106	233	pdata = chip_pdata->watchdog;
bc8fdfbe	234	else
502a0106	235	pdata = NULL;
502a0106 MB	236
	237	if (pdata) {
	238	reg &= ~(WM831X_WDOG_SECACT_MASK \| WM831X_WDOG_PRIMACT_MASK \|
	239	WM831X_WDOG_RST_SRC);
	240
	241	reg \|= pdata->primary << WM831X_WDOG_PRIMACT_SHIFT;
	242	reg \|= pdata->secondary << WM831X_WDOG_SECACT_SHIFT;
	243	reg \|= pdata->software << WM831X_WDOG_RST_SRC_SHIFT;
	244
	245	if (pdata->update_gpio) {
7a5da030 JH	246	ret = devm_gpio_request_one(&pdev->dev,
	247	pdata->update_gpio,
	248	GPIOF_OUT_INIT_LOW,
	249	"Watchdog update");
502a0106 MB	250	if (ret < 0) {
	251	dev_err(wm831x->dev,
	252	"Failed to request update GPIO: %d\n",
	253	ret);
30cba9a1	254	return ret;
502a0106 MB	255	}
502a0106 MB	256
00411ee9	257	driver_data->update_gpio = pdata->update_gpio;
502a0106 MB	258
	259	/* Make sure the watchdog takes hardware updates */
	260	reg \|= WM831X_WDOG_RST_SRC;
	261	}
	262
	263	ret = wm831x_reg_unlock(wm831x);
	264	if (ret == 0) {
	265	ret = wm831x_reg_write(wm831x, WM831X_WATCHDOG, reg);
	266	wm831x_reg_lock(wm831x);
	267	} else {
	268	dev_err(wm831x->dev,
	269	"Failed to unlock security key: %d\n", ret);
30cba9a1	270	return ret;
502a0106 MB	271	}
	272	}
	273
30cba9a1	274	ret = devm_watchdog_register_device(&pdev->dev, &driver_data->wdt);
502a0106	275	if (ret != 0) {
00411ee9 MB	276	dev_err(wm831x->dev, "watchdog_register_device() failed: %d\n",
00411ee9 MB	277	ret);
30cba9a1	278	return ret;
502a0106 MB	279	}
502a0106 MB	280
502a0106 MB	281	return 0;
	282	}
	283
	284	static struct platform_driver wm831x_wdt_driver = {
	285	.probe = wm831x_wdt_probe,
502a0106 MB	286	.driver = {
	287	.name = "wm831x-watchdog",
	288	},
	289	};
	290
216f3ad9	291	module_platform_driver(wm831x_wdt_driver);
502a0106 MB	292
	293	MODULE_AUTHOR("Mark Brown");
	294	MODULE_DESCRIPTION("WM831x Watchdog");
	295	MODULE_LICENSE("GPL");
	296	MODULE_ALIAS("platform:wm831x-watchdog");