[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / watchdog / retu_wdt.c

/*
 * Retu watchdog driver
 *
 * Copyright (C) 2004, 2005 Nokia Corporation
 *
 * Based on code written by Amit Kucheria and Michael Buesch.
 * Rewritten by Aaro Koskinen.
 *
 * This file is subject to the terms and conditions of the GNU General
 * Public License. See the file "COPYING" in the main directory of this
 * archive for more details.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */

#include <linux/init.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_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;

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