[linux.git] / drivers / watchdog / bd9576_wdt.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C) 2020 ROHM Semiconductors
 *
 * ROHM BD9576MUF and BD9573MUF Watchdog driver
 */

#include <linux/err.h>
#include <linux/gpio/consumer.h>
#include <linux/mfd/rohm-bd957x.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/watchdog.h>

static bool nowayout;
module_param(nowayout, bool, 0);
MODULE_PARM_DESC(nowayout,
		"Watchdog cannot be stopped once started (default=\"false\")");

#define HW_MARGIN_MIN 2
#define HW_MARGIN_MAX 4416
#define BD957X_WDT_DEFAULT_MARGIN 4416
#define WATCHDOG_TIMEOUT 30

struct bd9576_wdt_priv {
	struct gpio_desc	*gpiod_ping;
	struct gpio_desc	*gpiod_en;
	struct device		*dev;
	struct regmap		*regmap;
	bool			always_running;
	struct watchdog_device	wdd;
};

static void bd9576_wdt_disable(struct bd9576_wdt_priv *priv)
{
	gpiod_set_value_cansleep(priv->gpiod_en, 0);
}

static int bd9576_wdt_ping(struct watchdog_device *wdd)
{
	struct bd9576_wdt_priv *priv = watchdog_get_drvdata(wdd);

	/* Pulse */
	gpiod_set_value_cansleep(priv->gpiod_ping, 1);
	gpiod_set_value_cansleep(priv->gpiod_ping, 0);

	return 0;
}

static int bd9576_wdt_start(struct watchdog_device *wdd)
{
	struct bd9576_wdt_priv *priv = watchdog_get_drvdata(wdd);

	gpiod_set_value_cansleep(priv->gpiod_en, 1);

	return bd9576_wdt_ping(wdd);
}

static int bd9576_wdt_stop(struct watchdog_device *wdd)
{
	struct bd9576_wdt_priv *priv = watchdog_get_drvdata(wdd);

	if (!priv->always_running)
		bd9576_wdt_disable(priv);
	else
		set_bit(WDOG_HW_RUNNING, &wdd->status);

	return 0;
}

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

static const struct watchdog_ops bd957x_wdt_ops = {
	.owner		= THIS_MODULE,
	.start		= bd9576_wdt_start,
	.stop		= bd9576_wdt_stop,
	.ping		= bd9576_wdt_ping,
};

/* Unit is hundreds of uS */
#define FASTNG_MIN 23

static int find_closest_fast(int target, int *sel, int *val)
{
	int i;
	int window = FASTNG_MIN;

	for (i = 0; i < 8 && window < target; i++)
		window <<= 1;

	*val = window;
	*sel = i;

	if (i == 8)
		return -EINVAL;

	return 0;

}

static int find_closest_slow_by_fast(int fast_val, int target, int *slowsel)
{
	int sel;
	static const int multipliers[] = {2, 3, 7, 15};

	for (sel = 0; sel < ARRAY_SIZE(multipliers) &&
	     multipliers[sel] * fast_val < target; sel++)
		;

	if (sel == ARRAY_SIZE(multipliers))
		return -EINVAL;

	*slowsel = sel;

	return 0;
}

static int find_closest_slow(int target, int *slow_sel, int *fast_sel)
{
	static const int multipliers[] = {2, 3, 7, 15};
	int i, j;
	int val = 0;
	int window = FASTNG_MIN;

	for (i = 0; i < 8; i++) {
		for (j = 0; j < ARRAY_SIZE(multipliers); j++) {
			int slow;

			slow = window * multipliers[j];
			if (slow >= target && (!val || slow < val)) {
				val = slow;
				*fast_sel = i;
				*slow_sel = j;
			}
		}
		window <<= 1;
	}
	if (!val)
		return -EINVAL;

	return 0;
}

#define BD957X_WDG_TYPE_WINDOW BIT(5)
#define BD957X_WDG_TYPE_SLOW 0
#define BD957X_WDG_TYPE_MASK BIT(5)
#define BD957X_WDG_NG_RATIO_MASK 0x18
#define BD957X_WDG_FASTNG_MASK 0x7

static int bd957x_set_wdt_mode(struct bd9576_wdt_priv *priv, int hw_margin,
			       int hw_margin_min)
{
	int ret, fastng, slowng, type, reg, mask;
	struct device *dev = priv->dev;

	/* convert to 100uS */
	hw_margin *= 10;
	hw_margin_min *= 10;
	if (hw_margin_min) {
		int min;

		type = BD957X_WDG_TYPE_WINDOW;
		dev_dbg(dev, "Setting type WINDOW 0x%x\n", type);
		ret = find_closest_fast(hw_margin_min, &fastng, &min);
		if (ret) {
			dev_err(dev, "bad WDT window for fast timeout\n");
			return ret;
		}

		ret = find_closest_slow_by_fast(min, hw_margin, &slowng);
		if (ret) {
			dev_err(dev, "bad WDT window\n");
			return ret;
		}

	} else {
		type = BD957X_WDG_TYPE_SLOW;
		dev_dbg(dev, "Setting type SLOW 0x%x\n", type);
		ret = find_closest_slow(hw_margin, &slowng, &fastng);
		if (ret) {
			dev_err(dev, "bad WDT window\n");
			return ret;
		}
	}

	slowng <<= ffs(BD957X_WDG_NG_RATIO_MASK) - 1;
	reg = type | slowng | fastng;
	mask = BD957X_WDG_TYPE_MASK | BD957X_WDG_NG_RATIO_MASK |
	       BD957X_WDG_FASTNG_MASK;
	ret = regmap_update_bits(priv->regmap, BD957X_REG_WDT_CONF,
				 mask, reg);

	return ret;
}

static int bd9576_wdt_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct device_node *np = dev->parent->of_node;
	struct bd9576_wdt_priv *priv;
	u32 hw_margin[2];
	u32 hw_margin_max = BD957X_WDT_DEFAULT_MARGIN, hw_margin_min = 0;
	int ret;

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

	platform_set_drvdata(pdev, priv);

	priv->dev = dev;
	priv->regmap = dev_get_regmap(dev->parent, NULL);
	if (!priv->regmap) {
		dev_err(dev, "No regmap found\n");
		return -ENODEV;
	}

	priv->gpiod_en = devm_gpiod_get_from_of_node(dev, dev->parent->of_node,
						     "rohm,watchdog-enable-gpios",
						     0, GPIOD_OUT_LOW,
						     "watchdog-enable");
	if (IS_ERR(priv->gpiod_en))
		return dev_err_probe(dev, PTR_ERR(priv->gpiod_en),
			      "getting watchdog-enable GPIO failed\n");

	priv->gpiod_ping = devm_gpiod_get_from_of_node(dev, dev->parent->of_node,
						     "rohm,watchdog-ping-gpios",
						     0, GPIOD_OUT_LOW,
						     "watchdog-ping");
	if (IS_ERR(priv->gpiod_ping))
		return dev_err_probe(dev, PTR_ERR(priv->gpiod_ping),
				     "getting watchdog-ping GPIO failed\n");

	ret = of_property_read_variable_u32_array(np, "rohm,hw-timeout-ms",
						  &hw_margin[0], 1, 2);
	if (ret < 0 && ret != -EINVAL)
		return ret;

	if (ret == 1)
		hw_margin_max = hw_margin[0];

	if (ret == 2) {
		hw_margin_max = hw_margin[1];
		hw_margin_min = hw_margin[0];
	}

	ret = bd957x_set_wdt_mode(priv, hw_margin_max, hw_margin_min);
	if (ret)
		return ret;

	priv->always_running = of_property_read_bool(np, "always-running");

	watchdog_set_drvdata(&priv->wdd, priv);

	priv->wdd.info			= &bd957x_wdt_ident;
	priv->wdd.ops			= &bd957x_wdt_ops;
	priv->wdd.min_hw_heartbeat_ms	= hw_margin_min;
	priv->wdd.max_hw_heartbeat_ms	= hw_margin_max;
	priv->wdd.parent		= dev;
	priv->wdd.timeout		= WATCHDOG_TIMEOUT;

	watchdog_init_timeout(&priv->wdd, 0, dev);
	watchdog_set_nowayout(&priv->wdd, nowayout);

	watchdog_stop_on_reboot(&priv->wdd);

	if (priv->always_running)
		bd9576_wdt_start(&priv->wdd);

	return devm_watchdog_register_device(dev, &priv->wdd);
}

static struct platform_driver bd9576_wdt_driver = {
	.driver	= {
		.name = "bd9576-wdt",
	},
	.probe	= bd9576_wdt_probe,
};

module_platform_driver(bd9576_wdt_driver);

MODULE_AUTHOR("Matti Vaittinen <[email protected]>");
MODULE_DESCRIPTION("ROHM BD9576/BD9573 Watchdog driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:bd9576-wdt");
Commit	Line	Data
b237bcac MV	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* Copyright (C) 2020 ROHM Semiconductors
	4	*
	5	* ROHM BD9576MUF and BD9573MUF Watchdog driver
	6	*/
	7
	8	#include <linux/err.h>
	9	#include <linux/gpio/consumer.h>
	10	#include <linux/mfd/rohm-bd957x.h>
	11	#include <linux/module.h>
	12	#include <linux/of.h>
	13	#include <linux/platform_device.h>
	14	#include <linux/regmap.h>
	15	#include <linux/watchdog.h>
	16
	17	static bool nowayout;
	18	module_param(nowayout, bool, 0);
	19	MODULE_PARM_DESC(nowayout,
	20	"Watchdog cannot be stopped once started (default=\"false\")");
	21
	22	#define HW_MARGIN_MIN 2
	23	#define HW_MARGIN_MAX 4416
	24	#define BD957X_WDT_DEFAULT_MARGIN 4416
	25	#define WATCHDOG_TIMEOUT 30
	26
	27	struct bd9576_wdt_priv {
	28	struct gpio_desc *gpiod_ping;
	29	struct gpio_desc *gpiod_en;
	30	struct device *dev;
	31	struct regmap *regmap;
	32	bool always_running;
	33	struct watchdog_device wdd;
	34	};
	35
	36	static void bd9576_wdt_disable(struct bd9576_wdt_priv *priv)
	37	{
	38	gpiod_set_value_cansleep(priv->gpiod_en, 0);
	39	}
	40
	41	static int bd9576_wdt_ping(struct watchdog_device *wdd)
	42	{
	43	struct bd9576_wdt_priv *priv = watchdog_get_drvdata(wdd);
	44
	45	/* Pulse */
	46	gpiod_set_value_cansleep(priv->gpiod_ping, 1);
	47	gpiod_set_value_cansleep(priv->gpiod_ping, 0);
	48
	49	return 0;
	50	}
	51
	52	static int bd9576_wdt_start(struct watchdog_device *wdd)
	53	{
	54	struct bd9576_wdt_priv *priv = watchdog_get_drvdata(wdd);
	55
	56	gpiod_set_value_cansleep(priv->gpiod_en, 1);
	57
	58	return bd9576_wdt_ping(wdd);
	59	}
	60
	61	static int bd9576_wdt_stop(struct watchdog_device *wdd)
	62	{
	63	struct bd9576_wdt_priv *priv = watchdog_get_drvdata(wdd);
	64
65	if (!priv->always_running)
66	bd9576_wdt_disable(priv);
67	else
68	set_bit(WDOG_HW_RUNNING, &wdd->status);
69
70	return 0;
71	}
72
73	static const struct watchdog_info bd957x_wdt_ident = {
74	.options = WDIOF_MAGICCLOSE \| WDIOF_KEEPALIVEPING \|
75	WDIOF_SETTIMEOUT,
76	.identity = "BD957x Watchdog",
77	};
78
79	static const struct watchdog_ops bd957x_wdt_ops = {
80	.owner = THIS_MODULE,
81	.start = bd9576_wdt_start,
82	.stop = bd9576_wdt_stop,
83	.ping = bd9576_wdt_ping,
84	};
85
86	/* Unit is hundreds of uS */
87	#define FASTNG_MIN 23
88
89	static int find_closest_fast(int target, int sel, int val)
90	{
91	int i;
92	int window = FASTNG_MIN;
93
94	for (i = 0; i < 8 && window < target; i++)
95	window <<= 1;
96
97	*val = window;
98	*sel = i;
99
100	if (i == 8)
101	return -EINVAL;
102
103	return 0;
104
105	}
106
107	static int find_closest_slow_by_fast(int fast_val, int target, int *slowsel)
108	{
109	int sel;
110	static const int multipliers[] = {2, 3, 7, 15};
111
112	for (sel = 0; sel < ARRAY_SIZE(multipliers) &&
113	multipliers[sel] * fast_val < target; sel++)
114	;
115
116	if (sel == ARRAY_SIZE(multipliers))
117	return -EINVAL;
118
119	*slowsel = sel;
120
121	return 0;
122	}
123
124	static int find_closest_slow(int target, int slow_sel, int fast_sel)
125	{
126	static const int multipliers[] = {2, 3, 7, 15};
127	int i, j;
128	int val = 0;
129	int window = FASTNG_MIN;
130
131	for (i = 0; i < 8; i++) {
132	for (j = 0; j < ARRAY_SIZE(multipliers); j++) {
133	int slow;
134
135	slow = window * multipliers[j];
136	if (slow >= target && (!val \|\| slow < val)) {
137	val = slow;
138	*fast_sel = i;
139	*slow_sel = j;
140	}
141	}
142	window <<= 1;
143	}
144	if (!val)
145	return -EINVAL;
146
147	return 0;
148	}
149
150	#define BD957X_WDG_TYPE_WINDOW BIT(5)
151	#define BD957X_WDG_TYPE_SLOW 0
152	#define BD957X_WDG_TYPE_MASK BIT(5)
153	#define BD957X_WDG_NG_RATIO_MASK 0x18
154	#define BD957X_WDG_FASTNG_MASK 0x7
155
156	static int bd957x_set_wdt_mode(struct bd9576_wdt_priv *priv, int hw_margin,
157	int hw_margin_min)
158	{
159	int ret, fastng, slowng, type, reg, mask;
160	struct device *dev = priv->dev;
161
162	/* convert to 100uS */
163	hw_margin *= 10;
164	hw_margin_min *= 10;
165	if (hw_margin_min) {
166	int min;
167
168	type = BD957X_WDG_TYPE_WINDOW;
169	dev_dbg(dev, "Setting type WINDOW 0x%x\n", type);
170	ret = find_closest_fast(hw_margin_min, &fastng, &min);
171	if (ret) {
172	dev_err(dev, "bad WDT window for fast timeout\n");
173	return ret;
174	}
175
176	ret = find_closest_slow_by_fast(min, hw_margin, &slowng);
177	if (ret) {
178	dev_err(dev, "bad WDT window\n");
179	return ret;
180	}
181
182	} else {
183	type = BD957X_WDG_TYPE_SLOW;
184	dev_dbg(dev, "Setting type SLOW 0x%x\n", type);
185	ret = find_closest_slow(hw_margin, &slowng, &fastng);
186	if (ret) {
187	dev_err(dev, "bad WDT window\n");
188	return ret;
189	}
190	}
191
192	slowng <<= ffs(BD957X_WDG_NG_RATIO_MASK) - 1;
193	reg = type \| slowng \| fastng;
194	mask = BD957X_WDG_TYPE_MASK \| BD957X_WDG_NG_RATIO_MASK \|
195	BD957X_WDG_FASTNG_MASK;
196	ret = regmap_update_bits(priv->regmap, BD957X_REG_WDT_CONF,
197	mask, reg);
198
199	return ret;
200	}
201
202	static int bd9576_wdt_probe(struct platform_device *pdev)
203	{
204	struct device *dev = &pdev->dev;
205	struct device_node *np = dev->parent->of_node;
206	struct bd9576_wdt_priv *priv;
207	u32 hw_margin[2];
208	u32 hw_margin_max = BD957X_WDT_DEFAULT_MARGIN, hw_margin_min = 0;
209	int ret;
210
211	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
212	if (!priv)
213	return -ENOMEM;
214
215	platform_set_drvdata(pdev, priv);
216
217	priv->dev = dev;
218	priv->regmap = dev_get_regmap(dev->parent, NULL);
219	if (!priv->regmap) {
220	dev_err(dev, "No regmap found\n");
221	return -ENODEV;
222	}
223
224	priv->gpiod_en = devm_gpiod_get_from_of_node(dev, dev->parent->of_node,
225	"rohm,watchdog-enable-gpios",
226	0, GPIOD_OUT_LOW,
227	"watchdog-enable");
228	if (IS_ERR(priv->gpiod_en))
229	return dev_err_probe(dev, PTR_ERR(priv->gpiod_en),
230	"getting watchdog-enable GPIO failed\n");
231
232	priv->gpiod_ping = devm_gpiod_get_from_of_node(dev, dev->parent->of_node,
233	"rohm,watchdog-ping-gpios",
234	0, GPIOD_OUT_LOW,
235	"watchdog-ping");
236	if (IS_ERR(priv->gpiod_ping))
237	return dev_err_probe(dev, PTR_ERR(priv->gpiod_ping),
238	"getting watchdog-ping GPIO failed\n");
239
240	ret = of_property_read_variable_u32_array(np, "rohm,hw-timeout-ms",
241	&hw_margin[0], 1, 2);
242	if (ret < 0 && ret != -EINVAL)
243	return ret;
244
245	if (ret == 1)
246	hw_margin_max = hw_margin[0];
247
248	if (ret == 2) {
249	hw_margin_max = hw_margin[1];
250	hw_margin_min = hw_margin[0];
251	}
252
253	ret = bd957x_set_wdt_mode(priv, hw_margin_max, hw_margin_min);
254	if (ret)
255	return ret;
256
257	priv->always_running = of_property_read_bool(np, "always-running");
258
259	watchdog_set_drvdata(&priv->wdd, priv);
260
261	priv->wdd.info = &bd957x_wdt_ident;
262	priv->wdd.ops = &bd957x_wdt_ops;
263	priv->wdd.min_hw_heartbeat_ms = hw_margin_min;
264	priv->wdd.max_hw_heartbeat_ms = hw_margin_max;
265	priv->wdd.parent = dev;
266	priv->wdd.timeout = WATCHDOG_TIMEOUT;
267
268	watchdog_init_timeout(&priv->wdd, 0, dev);
269	watchdog_set_nowayout(&priv->wdd, nowayout);
270
271	watchdog_stop_on_reboot(&priv->wdd);
272
273	if (priv->always_running)
274	bd9576_wdt_start(&priv->wdd);
275
276	return devm_watchdog_register_device(dev, &priv->wdd);
277	}
278
279	static struct platform_driver bd9576_wdt_driver = {
280	.driver = {
281	.name = "bd9576-wdt",
282	},
283	.probe = bd9576_wdt_probe,
284	};
285
286	module_platform_driver(bd9576_wdt_driver);
287
288	MODULE_AUTHOR("Matti Vaittinen <[email protected]>");
289	MODULE_DESCRIPTION("ROHM BD9576/BD9573 Watchdog driver");
290	MODULE_LICENSE("GPL");
291	MODULE_ALIAS("platform:bd9576-wdt");