[linux-2.6-block.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/devm-helpers.h>
#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;

	ret = devm_delayed_work_autocancel(&pdev->dev, &wdev->ping_work,
					   retu_wdt_ping_work);
	if (ret)
		return ret;

	ret = devm_watchdog_register_device(&pdev->dev, retu_wdt);
	if (ret < 0)
		return ret;

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

	return 0;
}

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