[mirror_ubuntu-hirsute-kernel.git] / drivers / watchdog / retu_wdt.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Retu watchdog driver
 *
 * Copyright (C) 2004, 2005 Nokia Corporation
 *
 * Based on code written by Amit Kucheria and Michael Buesch.
 * Rewritten by Aaro Koskinen.
 */

#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mfd/retu.h>
#include <linux/watchdog.h>
#include <linux/platform_device.h>

/* Watchdog timer values in seconds */
#define RETU_WDT_MAX_TIMER	63

struct retu_wdt_dev {
	struct retu_dev		*rdev;
	struct device		*dev;
	struct delayed_work	ping_work;
};

/*
 * Since Retu watchdog cannot be disabled in hardware, we must kick it
 * with a timer until userspace watchdog software takes over. If
 * CONFIG_WATCHDOG_NOWAYOUT is set, we never start the feeding.
 */
static void retu_wdt_ping_enable(struct retu_wdt_dev *wdev)
{
	retu_write(wdev->rdev, RETU_REG_WATCHDOG, RETU_WDT_MAX_TIMER);
	schedule_delayed_work(&wdev->ping_work,
			round_jiffies_relative(RETU_WDT_MAX_TIMER * HZ / 2));
}

static void retu_wdt_ping_disable(struct retu_wdt_dev *wdev)
{
	retu_write(wdev->rdev, RETU_REG_WATCHDOG, RETU_WDT_MAX_TIMER);
	cancel_delayed_work_sync(&wdev->ping_work);
}

static void retu_wdt_ping_work(struct work_struct *work)
{
	struct retu_wdt_dev *wdev = container_of(to_delayed_work(work),
						struct retu_wdt_dev, ping_work);
	retu_wdt_ping_enable(wdev);
}

static int retu_wdt_start(struct watchdog_device *wdog)
{
	struct retu_wdt_dev *wdev = watchdog_get_drvdata(wdog);

	retu_wdt_ping_disable(wdev);

	return retu_write(wdev->rdev, RETU_REG_WATCHDOG, wdog->timeout);
}

static int retu_wdt_stop(struct watchdog_device *wdog)
{
	struct retu_wdt_dev *wdev = watchdog_get_drvdata(wdog);

	retu_wdt_ping_enable(wdev);

	return 0;
}

static int retu_wdt_ping(struct watchdog_device *wdog)
{
	struct retu_wdt_dev *wdev = watchdog_get_drvdata(wdog);

	return retu_write(wdev->rdev, RETU_REG_WATCHDOG, wdog->timeout);
}

static int retu_wdt_set_timeout(struct watchdog_device *wdog,
				unsigned int timeout)
{
	struct retu_wdt_dev *wdev = watchdog_get_drvdata(wdog);

	wdog->timeout = timeout;
	return retu_write(wdev->rdev, RETU_REG_WATCHDOG, wdog->timeout);
}

static const struct watchdog_info retu_wdt_info = {
	.options = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING,
	.identity = "Retu watchdog",
};

static const struct watchdog_ops retu_wdt_ops = {
	.owner		= THIS_MODULE,
	.start		= retu_wdt_start,
	.stop		= retu_wdt_stop,
	.ping		= retu_wdt_ping,
	.set_timeout	= retu_wdt_set_timeout,
};

static int retu_wdt_probe(struct platform_device *pdev)
{
	struct retu_dev *rdev = dev_get_drvdata(pdev->dev.parent);
	bool nowayout = WATCHDOG_NOWAYOUT;
	struct watchdog_device *retu_wdt;
	struct retu_wdt_dev *wdev;
	int ret;

	retu_wdt = devm_kzalloc(&pdev->dev, sizeof(*retu_wdt), GFP_KERNEL);
	if (!retu_wdt)
		return -ENOMEM;

	wdev = devm_kzalloc(&pdev->dev, sizeof(*wdev), GFP_KERNEL);
	if (!wdev)
		return -ENOMEM;

	retu_wdt->info		= &retu_wdt_info;
	retu_wdt->ops		= &retu_wdt_ops;
	retu_wdt->timeout	= RETU_WDT_MAX_TIMER;
	retu_wdt->min_timeout	= 0;
	retu_wdt->max_timeout	= RETU_WDT_MAX_TIMER;
	retu_wdt->parent	= &pdev->dev;

	watchdog_set_drvdata(retu_wdt, wdev);
	watchdog_set_nowayout(retu_wdt, nowayout);

	wdev->rdev		= rdev;
	wdev->dev		= &pdev->dev;

	INIT_DELAYED_WORK(&wdev->ping_work, retu_wdt_ping_work);

	ret = watchdog_register_device(retu_wdt);
	if (ret < 0)
		return ret;

	if (nowayout)
		retu_wdt_ping(retu_wdt);
	else
		retu_wdt_ping_enable(wdev);

	platform_set_drvdata(pdev, retu_wdt);

	return 0;
}

static int retu_wdt_remove(struct platform_device *pdev)
{
	struct watchdog_device *wdog = platform_get_drvdata(pdev);
	struct retu_wdt_dev *wdev = watchdog_get_drvdata(wdog);

	watchdog_unregister_device(wdog);
	cancel_delayed_work_sync(&wdev->ping_work);

	return 0;
}

static struct platform_driver retu_wdt_driver = {
	.probe		= retu_wdt_probe,
	.remove		= retu_wdt_remove,
	.driver		= {
		.name	= "retu-wdt",
	},
};
module_platform_driver(retu_wdt_driver);

MODULE_ALIAS("platform:retu-wdt");
MODULE_DESCRIPTION("Retu watchdog");
MODULE_AUTHOR("Amit Kucheria");
MODULE_AUTHOR("Aaro Koskinen <aaro.koskinen@iki.fi>");
MODULE_LICENSE("GPL");
Commit	Line	Data
d0173278	1	// SPDX-License-Identifier: GPL-2.0+
3d3a6d18 AK	2	/*
	3	* Retu watchdog driver
	4	*
	5	* Copyright (C) 2004, 2005 Nokia Corporation
	6	*
	7	* Based on code written by Amit Kucheria and Michael Buesch.
	8	* Rewritten by Aaro Koskinen.
3d3a6d18 AK	9	*/
3d3a6d18 AK	10
3d3a6d18 AK	11	#include <linux/slab.h>
	12	#include <linux/errno.h>
	13	#include <linux/device.h>
	14	#include <linux/kernel.h>
	15	#include <linux/module.h>
	16	#include <linux/mfd/retu.h>
	17	#include <linux/watchdog.h>
	18	#include <linux/platform_device.h>
	19
	20	/* Watchdog timer values in seconds */
	21	#define RETU_WDT_MAX_TIMER 63
	22
	23	struct retu_wdt_dev {
	24	struct retu_dev *rdev;
	25	struct device *dev;
	26	struct delayed_work ping_work;
	27	};
	28
	29	/*
	30	* Since Retu watchdog cannot be disabled in hardware, we must kick it
	31	* with a timer until userspace watchdog software takes over. If
	32	* CONFIG_WATCHDOG_NOWAYOUT is set, we never start the feeding.
	33	*/
	34	static void retu_wdt_ping_enable(struct retu_wdt_dev *wdev)
	35	{
	36	retu_write(wdev->rdev, RETU_REG_WATCHDOG, RETU_WDT_MAX_TIMER);
	37	schedule_delayed_work(&wdev->ping_work,
	38	round_jiffies_relative(RETU_WDT_MAX_TIMER * HZ / 2));
	39	}
	40
	41	static void retu_wdt_ping_disable(struct retu_wdt_dev *wdev)
	42	{
	43	retu_write(wdev->rdev, RETU_REG_WATCHDOG, RETU_WDT_MAX_TIMER);
	44	cancel_delayed_work_sync(&wdev->ping_work);
	45	}
	46
	47	static void retu_wdt_ping_work(struct work_struct *work)
	48	{
	49	struct retu_wdt_dev *wdev = container_of(to_delayed_work(work),
	50	struct retu_wdt_dev, ping_work);
	51	retu_wdt_ping_enable(wdev);
	52	}
	53
	54	static int retu_wdt_start(struct watchdog_device *wdog)
	55	{
	56	struct retu_wdt_dev *wdev = watchdog_get_drvdata(wdog);
	57
	58	retu_wdt_ping_disable(wdev);
	59
	60	return retu_write(wdev->rdev, RETU_REG_WATCHDOG, wdog->timeout);
	61	}
	62
	63	static int retu_wdt_stop(struct watchdog_device *wdog)
	64	{
	65	struct retu_wdt_dev *wdev = watchdog_get_drvdata(wdog);
	66
	67	retu_wdt_ping_enable(wdev);
	68
	69	return 0;
	70	}
	71
	72	static int retu_wdt_ping(struct watchdog_device *wdog)
	73	{
	74	struct retu_wdt_dev *wdev = watchdog_get_drvdata(wdog);
75
76	return retu_write(wdev->rdev, RETU_REG_WATCHDOG, wdog->timeout);
77	}
78
79	static int retu_wdt_set_timeout(struct watchdog_device *wdog,
80	unsigned int timeout)
81	{
82	struct retu_wdt_dev *wdev = watchdog_get_drvdata(wdog);
83
84	wdog->timeout = timeout;
85	return retu_write(wdev->rdev, RETU_REG_WATCHDOG, wdog->timeout);
86	}
87
88	static const struct watchdog_info retu_wdt_info = {
fb1cbeae	89	.options = WDIOF_SETTIMEOUT \| WDIOF_MAGICCLOSE \| WDIOF_KEEPALIVEPING,
3d3a6d18 AK	90	.identity = "Retu watchdog",
	91	};
	92
	93	static const struct watchdog_ops retu_wdt_ops = {
	94	.owner = THIS_MODULE,
	95	.start = retu_wdt_start,
	96	.stop = retu_wdt_stop,
	97	.ping = retu_wdt_ping,
	98	.set_timeout = retu_wdt_set_timeout,
	99	};
	100
	101	static int retu_wdt_probe(struct platform_device *pdev)
	102	{
	103	struct retu_dev *rdev = dev_get_drvdata(pdev->dev.parent);
	104	bool nowayout = WATCHDOG_NOWAYOUT;
	105	struct watchdog_device *retu_wdt;
	106	struct retu_wdt_dev *wdev;
	107	int ret;
	108
	109	retu_wdt = devm_kzalloc(&pdev->dev, sizeof(*retu_wdt), GFP_KERNEL);
	110	if (!retu_wdt)
	111	return -ENOMEM;
	112
	113	wdev = devm_kzalloc(&pdev->dev, sizeof(*wdev), GFP_KERNEL);
	114	if (!wdev)
	115	return -ENOMEM;
	116
	117	retu_wdt->info = &retu_wdt_info;
	118	retu_wdt->ops = &retu_wdt_ops;
	119	retu_wdt->timeout = RETU_WDT_MAX_TIMER;
	120	retu_wdt->min_timeout = 0;
	121	retu_wdt->max_timeout = RETU_WDT_MAX_TIMER;
6551881c	122	retu_wdt->parent = &pdev->dev;
3d3a6d18 AK	123
	124	watchdog_set_drvdata(retu_wdt, wdev);
	125	watchdog_set_nowayout(retu_wdt, nowayout);
	126
	127	wdev->rdev = rdev;
	128	wdev->dev = &pdev->dev;
	129
	130	INIT_DELAYED_WORK(&wdev->ping_work, retu_wdt_ping_work);
	131
	132	ret = watchdog_register_device(retu_wdt);
	133	if (ret < 0)
	134	return ret;
	135
	136	if (nowayout)
	137	retu_wdt_ping(retu_wdt);
	138	else
	139	retu_wdt_ping_enable(wdev);
	140
	141	platform_set_drvdata(pdev, retu_wdt);
	142
	143	return 0;
	144	}
	145
	146	static int retu_wdt_remove(struct platform_device *pdev)
	147	{
	148	struct watchdog_device *wdog = platform_get_drvdata(pdev);
	149	struct retu_wdt_dev *wdev = watchdog_get_drvdata(wdog);
	150
	151	watchdog_unregister_device(wdog);
	152	cancel_delayed_work_sync(&wdev->ping_work);
	153
	154	return 0;
	155	}
	156
	157	static struct platform_driver retu_wdt_driver = {
	158	.probe = retu_wdt_probe,
	159	.remove = retu_wdt_remove,
	160	.driver = {
	161	.name = "retu-wdt",
	162	},
	163	};
	164	module_platform_driver(retu_wdt_driver);
	165
	166	MODULE_ALIAS("platform:retu-wdt");
	167	MODULE_DESCRIPTION("Retu watchdog");
	168	MODULE_AUTHOR("Amit Kucheria");
	169	MODULE_AUTHOR("Aaro Koskinen <aaro.koskinen@iki.fi>");
	170	MODULE_LICENSE("GPL");