watchdog: Convert wm831x driver to watchdog core

Fairly large code churn but not much doing with that and the overall result is a definite win. Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com> Signed-off-by: Wim Van Sebroeck <wim@iguana.be>

watchdog: Convert wm831x driver to watchdog core
Fairly large code churn but not much doing with that and the overall result is a definite win. Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com> Signed-off-by: Wim Van Sebroeck <wim@iguana.be>
Mark Brown · Wim Van Sebroeck
1 parent 25dc46e383
Showing 2 changed files with 106 additions and 213 deletions Side-by-side Diff
drivers/watchdog/Kconfig
drivers/watchdog/wm831x_wdt.c
@@ -66,6 +66,7 @@
 config WM831X_WATCHDOG
 	tristate "WM831x watchdog"
 	depends on MFD_WM831X
+	select WATCHDOG_CORE
 	help
 	  Support for the watchdog in the WM831x AudioPlus PMICs.  When
 	  the watchdog triggers the system will be reset.
@@ -12,8 +12,7 @@
 #include <linux/moduleparam.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/fs.h>
-#include <linux/miscdevice.h>
+#include <linux/slab.h>
 #include <linux/platform_device.h>
 #include <linux/watchdog.h>
 #include <linux/uaccess.h>
  
@@ -29,19 +28,19 @@
 		 "Watchdog cannot be stopped once started (default="
 		 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
  
-static unsigned long wm831x_wdt_users;
-static struct miscdevice wm831x_wdt_miscdev;
-static int wm831x_wdt_expect_close;
-static DEFINE_MUTEX(wdt_mutex);
-static struct wm831x *wm831x;
-static unsigned int update_gpio;
-static unsigned int update_state;
+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 {
-	int time;  /* Seconds */
-	u16 val;   /* WDOG_TO value */
+	unsigned int time;  /* Seconds */
+	u16 val;            /* WDOG_TO value */
 } wm831x_wdt_cfgs[] = {
 	{  1, 2 },
 	{  2, 3 },
  
  
  
@@ -52,36 +51,17 @@
 	{ 33, 7 },  /* Actually 32.768s so include both, others round down */
 };
  
-static int wm831x_wdt_set_timeout(struct wm831x *wm831x, u16 value)
+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(&wdt_mutex);
+	mutex_lock(&driver_data->lock);
  
 	ret = wm831x_reg_unlock(wm831x);
 	if (ret == 0) {
 		ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
-				      WM831X_WDOG_TO_MASK, value);
-		wm831x_reg_lock(wm831x);
-	} else {
-		dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
-			ret);
-	}
-
-	mutex_unlock(&wdt_mutex);
-
-	return ret;
-}
-
-static int wm831x_wdt_start(struct wm831x *wm831x)
-{
-	int ret;
-
-	mutex_lock(&wdt_mutex);
-
-	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 {
  
  
  
@@ -89,16 +69,18 @@
 			ret);
 	}
  
-	mutex_unlock(&wdt_mutex);
+	mutex_unlock(&driver_data->lock);
  
 	return ret;
 }
  
-static int wm831x_wdt_stop(struct wm831x *wm831x)
+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(&wdt_mutex);
+	mutex_lock(&driver_data->lock);
  
 	ret = wm831x_reg_unlock(wm831x);
 	if (ret == 0) {
  
  
  
  
  
@@ -110,26 +92,28 @@
 			ret);
 	}
  
-	mutex_unlock(&wdt_mutex);
+	mutex_unlock(&driver_data->lock);
  
 	return ret;
 }
  
-static int wm831x_wdt_kick(struct wm831x *wm831x)
+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(&wdt_mutex);
+	mutex_lock(&driver_data->lock);
  
-	if (update_gpio) {
-		gpio_set_value_cansleep(update_gpio, update_state);
-		update_state = !update_state;
+	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)) {
  
  
  
  
  
  
  
  
  
  
  
  
@@ -150,183 +134,60 @@
 	}
  
 out:
-	mutex_unlock(&wdt_mutex);
+	mutex_unlock(&driver_data->lock);
  
 	return ret;
 }
  
-static int wm831x_wdt_open(struct inode *inode, struct file *file)
+static int wm831x_wdt_set_timeout(struct watchdog_device *wdt_dev,
+				  unsigned int timeout)
 {
-	int ret;
+	struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
+	struct wm831x *wm831x = driver_data->wm831x;
+	int ret, i;
  
-	if (!wm831x)
-		return -ENODEV;
+	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))
+		ret = -EINVAL;
  
-	if (test_and_set_bit(0, &wm831x_wdt_users))
-		return -EBUSY;
-
-	ret = wm831x_wdt_start(wm831x);
-	if (ret != 0)
-		return ret;
-
-	return nonseekable_open(inode, file);
-}
-
-static int wm831x_wdt_release(struct inode *inode, struct file *file)
-{
-	if (wm831x_wdt_expect_close)
-		wm831x_wdt_stop(wm831x);
-	else {
-		dev_warn(wm831x->dev, "Watchdog device closed uncleanly\n");
-		wm831x_wdt_kick(wm831x);
+	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);
 	}
  
-	clear_bit(0, &wm831x_wdt_users);
-
-	return 0;
+	return ret;
 }
  
-static ssize_t wm831x_wdt_write(struct file *file,
-				const char __user *data, size_t count,
-				loff_t *ppos)
-{
-	size_t i;
-
-	if (count) {
-		wm831x_wdt_kick(wm831x);
-
-		if (!nowayout) {
-			/* In case it was set long ago */
-			wm831x_wdt_expect_close = 0;
-
-			/* scan to see whether or not we got the magic
-			   character */
-			for (i = 0; i != count; i++) {
-				char c;
-				if (get_user(c, data + i))
-					return -EFAULT;
-				if (c == 'V')
-					wm831x_wdt_expect_close = 42;
-			}
-		}
-	}
-	return count;
-}
-
-static const struct watchdog_info ident = {
+static const struct watchdog_info wm831x_wdt_info = {
 	.options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
 	.identity = "WM831x Watchdog",
 };
  
-static long wm831x_wdt_ioctl(struct file *file, unsigned int cmd,
-			     unsigned long arg)
-{
-	int ret = -ENOTTY, time, i;
-	void __user *argp = (void __user *)arg;
-	int __user *p = argp;
-	u16 reg;
-
-	switch (cmd) {
-	case WDIOC_GETSUPPORT:
-		ret = copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
-		break;
-
-	case WDIOC_GETSTATUS:
-	case WDIOC_GETBOOTSTATUS:
-		ret = put_user(0, p);
-		break;
-
-	case WDIOC_SETOPTIONS:
-	{
-		int options;
-
-		if (get_user(options, p))
-			return -EFAULT;
-
-		ret = -EINVAL;
-
-		/* Setting both simultaneously means at least one must fail */
-		if (options == WDIOS_DISABLECARD)
-			ret = wm831x_wdt_start(wm831x);
-
-		if (options == WDIOS_ENABLECARD)
-			ret = wm831x_wdt_stop(wm831x);
-		break;
-	}
-
-	case WDIOC_KEEPALIVE:
-		ret = wm831x_wdt_kick(wm831x);
-		break;
-
-	case WDIOC_SETTIMEOUT:
-		ret = get_user(time, p);
-		if (ret)
-			break;
-
-		if (time == 0) {
-			if (nowayout)
-				ret = -EINVAL;
-			else
-				wm831x_wdt_stop(wm831x);
-			break;
-		}
-
-		for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++)
-			if (wm831x_wdt_cfgs[i].time == time)
-				break;
-		if (i == ARRAY_SIZE(wm831x_wdt_cfgs))
-			ret = -EINVAL;
-		else
-			ret = wm831x_wdt_set_timeout(wm831x,
-						     wm831x_wdt_cfgs[i].val);
-		break;
-
-	case WDIOC_GETTIMEOUT:
-		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 configuration: %x\n", reg);
-			ret = -EINVAL;
-		} else
-			ret = put_user(wm831x_wdt_cfgs[i].time, p);
-
-	}
-
-	return ret;
-}
-
-static const struct file_operations wm831x_wdt_fops = {
+static const struct watchdog_ops wm831x_wdt_ops = {
 	.owner = THIS_MODULE,
-	.llseek = no_llseek,
-	.write = wm831x_wdt_write,
-	.unlocked_ioctl = wm831x_wdt_ioctl,
-	.open = wm831x_wdt_open,
-	.release = wm831x_wdt_release,
+	.start = wm831x_wdt_start,
+	.stop = wm831x_wdt_stop,
+	.ping = wm831x_wdt_ping,
+	.set_timeout = wm831x_wdt_set_timeout,
 };
  
-static struct miscdevice wm831x_wdt_miscdev = {
-	.minor = WATCHDOG_MINOR,
-	.name = "watchdog",
-	.fops = &wm831x_wdt_fops,
-};
-
 static int __devinit wm831x_wdt_probe(struct platform_device *pdev)
 {
+	struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
 	struct wm831x_pdata *chip_pdata;
 	struct wm831x_watchdog_pdata *pdata;
-	int reg, ret;
+	struct wm831x_wdt_drvdata *driver_data;
+	struct watchdog_device *wm831x_wdt;
+	int reg, ret, i;
  
-	if (wm831x) {
-		dev_err(&pdev->dev, "wm831x watchdog already registered\n");
-		return -EBUSY;
-	}
-
-	wm831x = dev_get_drvdata(pdev->dev.parent);
-
 	ret = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
 	if (ret < 0) {
 		dev_err(wm831x->dev, "Failed to read watchdog status: %d\n",
@@ -338,6 +199,36 @@
 	if (reg & WM831X_WDOG_DEBUG)
 		dev_warn(wm831x->dev, "Watchdog is paused\n");
  
+	driver_data = kzalloc(sizeof(*driver_data), GFP_KERNEL);
+	if (!driver_data) {
+		dev_err(wm831x->dev, "Unable to alloacate watchdog device\n");
+		ret = -ENOMEM;
+		goto err;
+	}
+
+	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;
+	watchdog_set_drvdata(wm831x_wdt, driver_data);
+
+	if (nowayout)
+		wm831x_wdt->status |= WDOG_NO_WAY_OUT;
+
+	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 (pdev->dev.parent->platform_data) {
 		chip_pdata = pdev->dev.parent->platform_data;
@@ -361,7 +252,7 @@
 				dev_err(wm831x->dev,
 					"Failed to request update GPIO: %d\n",
 					ret);
-				goto err;
+				goto err_alloc;
 			}
  
 			ret = gpio_direction_output(pdata->update_gpio, 0);
@@ -372,7 +263,7 @@
 				goto err_gpio;
 			}
  
-			update_gpio = pdata->update_gpio;
+			driver_data->update_gpio = pdata->update_gpio;
  
 			/* Make sure the watchdog takes hardware updates */
 			reg |= WM831X_WDOG_RST_SRC;
  
  
  
  
  
@@ -389,33 +280,34 @@
 		}
 	}
  
-	wm831x_wdt_miscdev.parent = &pdev->dev;
-
-	ret = misc_register(&wm831x_wdt_miscdev);
+	ret = watchdog_register_device(&driver_data->wdt);
 	if (ret != 0) {
-		dev_err(wm831x->dev, "Failed to register miscdev: %d\n", ret);
+		dev_err(wm831x->dev, "watchdog_register_device() failed: %d\n",
+			ret);
 		goto err_gpio;
 	}
  
+	dev_set_drvdata(&pdev->dev, driver_data);
+
 	return 0;
  
 err_gpio:
-	if (update_gpio) {
-		gpio_free(update_gpio);
-		update_gpio = 0;
-	}
+	if (driver_data->update_gpio)
+		gpio_free(driver_data->update_gpio);
+err_alloc:
+	kfree(driver_data);
 err:
 	return ret;
 }
  
 static int __devexit wm831x_wdt_remove(struct platform_device *pdev)
 {
-	if (update_gpio) {
-		gpio_free(update_gpio);
-		update_gpio = 0;
-	}
+	struct wm831x_wdt_drvdata *driver_data = dev_get_drvdata(&pdev->dev);
  
-	misc_deregister(&wm831x_wdt_miscdev);
+	watchdog_unregister_device(&driver_data->wdt);
+
+	if (driver_data->update_gpio)
+		gpio_free(driver_data->update_gpio);
  
 	return 0;
 }
...	...	@@ -66,6 +66,7 @@
66	66	config WM831X_WATCHDOG
67	67	tristate "WM831x watchdog"
68	68	depends on MFD_WM831X
	69	+ select WATCHDOG_CORE
69	70	help
70	71	Support for the watchdog in the WM831x AudioPlus PMICs. When
71	72	the watchdog triggers the system will be reset.
...	...	@@ -12,8 +12,7 @@
12	12	#include <linux/moduleparam.h>
13	13	#include <linux/types.h>
14	14	#include <linux/kernel.h>
15		-#include <linux/fs.h>
16		-#include <linux/miscdevice.h>
	15	+#include <linux/slab.h>
17	16	#include <linux/platform_device.h>
18	17	#include <linux/watchdog.h>
19	18	#include <linux/uaccess.h>
20	19
...	...	@@ -29,19 +28,19 @@
29	28	"Watchdog cannot be stopped once started (default="
30	29	__MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
31	30
32		-static unsigned long wm831x_wdt_users;
33		-static struct miscdevice wm831x_wdt_miscdev;
34		-static int wm831x_wdt_expect_close;
35		-static DEFINE_MUTEX(wdt_mutex);
36		-static struct wm831x *wm831x;
37		-static unsigned int update_gpio;
38		-static unsigned int update_state;
	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	+};
39	38
40	39	/* We can't use the sub-second values here but they're included
41	40	* for completeness. */
42	41	static struct {
43		- int time; /* Seconds */
44		- u16 val; /* WDOG_TO value */
	42	+ unsigned int time; /* Seconds */
	43	+ u16 val; /* WDOG_TO value */
45	44	} wm831x_wdt_cfgs[] = {
46	45	{ 1, 2 },
47	46	{ 2, 3 },
48	47
49	48
50	49
...	...	@@ -52,36 +51,17 @@
52	51	{ 33, 7 }, /* Actually 32.768s so include both, others round down */
53	52	};
54	53
55		-static int wm831x_wdt_set_timeout(struct wm831x *wm831x, u16 value)
	54	+static int wm831x_wdt_start(struct watchdog_device *wdt_dev)
56	55	{
	56	+ struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
	57	+ struct wm831x *wm831x = driver_data->wm831x;
57	58	int ret;
58	59
59		- mutex_lock(&wdt_mutex);
	60	+ mutex_lock(&driver_data->lock);
60	61
61	62	ret = wm831x_reg_unlock(wm831x);
62	63	if (ret == 0) {
63	64	ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
64		- WM831X_WDOG_TO_MASK, value);
65		- wm831x_reg_lock(wm831x);
66		- } else {
67		- dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
68		- ret);
69		- }
70		-
71		- mutex_unlock(&wdt_mutex);
72		-
73		- return ret;
74		-}
75		-
76		-static int wm831x_wdt_start(struct wm831x *wm831x)
77		-{
78		- int ret;
79		-
80		- mutex_lock(&wdt_mutex);
81		-
82		- ret = wm831x_reg_unlock(wm831x);
83		- if (ret == 0) {
84		- ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
85	65	WM831X_WDOG_ENA, WM831X_WDOG_ENA);
86	66	wm831x_reg_lock(wm831x);
87	67	} else {
88	68
89	69
90	70
...	...	@@ -89,16 +69,18 @@
89	69	ret);
90	70	}
91	71
92		- mutex_unlock(&wdt_mutex);
	72	+ mutex_unlock(&driver_data->lock);
93	73
94	74	return ret;
95	75	}
96	76
97		-static int wm831x_wdt_stop(struct wm831x *wm831x)
	77	+static int wm831x_wdt_stop(struct watchdog_device *wdt_dev)
98	78	{
	79	+ struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
	80	+ struct wm831x *wm831x = driver_data->wm831x;
99	81	int ret;
100	82
101		- mutex_lock(&wdt_mutex);
	83	+ mutex_lock(&driver_data->lock);
102	84
103	85	ret = wm831x_reg_unlock(wm831x);
104	86	if (ret == 0) {
105	87
106	88
107	89
108	90
109	91
...	...	@@ -110,26 +92,28 @@
110	92	ret);
111	93	}
112	94
113		- mutex_unlock(&wdt_mutex);
	95	+ mutex_unlock(&driver_data->lock);
114	96
115	97	return ret;
116	98	}
117	99
118		-static int wm831x_wdt_kick(struct wm831x *wm831x)
	100	+static int wm831x_wdt_ping(struct watchdog_device *wdt_dev)
119	101	{
	102	+ struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
	103	+ struct wm831x *wm831x = driver_data->wm831x;
120	104	int ret;
121	105	u16 reg;
122	106
123		- mutex_lock(&wdt_mutex);
	107	+ mutex_lock(&driver_data->lock);
124	108
125		- if (update_gpio) {
126		- gpio_set_value_cansleep(update_gpio, update_state);
127		- update_state = !update_state;
	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;
128	113	ret = 0;
129	114	goto out;
130	115	}
131	116
132		-
133	117	reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
134	118
135	119	if (!(reg & WM831X_WDOG_RST_SRC)) {
136	120
137	121
138	122
139	123
140	124
141	125
142	126
143	127
144	128
145	129
146	130
147	131
...	...	@@ -150,183 +134,60 @@
150	134	}
151	135
152	136	out:
153		- mutex_unlock(&wdt_mutex);
	137	+ mutex_unlock(&driver_data->lock);
154	138
155	139	return ret;
156	140	}
157	141
158		-static int wm831x_wdt_open(struct inode inode, struct file file)
	142	+static int wm831x_wdt_set_timeout(struct watchdog_device *wdt_dev,
	143	+ unsigned int timeout)
159	144	{
160		- int ret;
	145	+ struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
	146	+ struct wm831x *wm831x = driver_data->wm831x;
	147	+ int ret, i;
161	148
162		- if (!wm831x)
163		- return -ENODEV;
	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))
	153	+ ret = -EINVAL;
164	154
165		- if (test_and_set_bit(0, &wm831x_wdt_users))
166		- return -EBUSY;
167		-
168		- ret = wm831x_wdt_start(wm831x);
169		- if (ret != 0)
170		- return ret;
171		-
172		- return nonseekable_open(inode, file);
173		-}
174		-
175		-static int wm831x_wdt_release(struct inode inode, struct file file)
176		-{
177		- if (wm831x_wdt_expect_close)
178		- wm831x_wdt_stop(wm831x);
179		- else {
180		- dev_warn(wm831x->dev, "Watchdog device closed uncleanly\n");
181		- wm831x_wdt_kick(wm831x);
	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);
182	164	}
183	165
184		- clear_bit(0, &wm831x_wdt_users);
185		-
186		- return 0;
	166	+ return ret;
187	167	}
188	168
189		-static ssize_t wm831x_wdt_write(struct file *file,
190		- const char __user *data, size_t count,
191		- loff_t *ppos)
192		-{
193		- size_t i;
194		-
195		- if (count) {
196		- wm831x_wdt_kick(wm831x);
197		-
198		- if (!nowayout) {
199		- /* In case it was set long ago */
200		- wm831x_wdt_expect_close = 0;
201		-
202		- /* scan to see whether or not we got the magic
203		- character */
204		- for (i = 0; i != count; i++) {
205		- char c;
206		- if (get_user(c, data + i))
207		- return -EFAULT;
208		- if (c == 'V')
209		- wm831x_wdt_expect_close = 42;
210		- }
211		- }
212		- }
213		- return count;
214		-}
215		-
216		-static const struct watchdog_info ident = {
	169	+static const struct watchdog_info wm831x_wdt_info = {
217	170	.options = WDIOF_SETTIMEOUT \| WDIOF_KEEPALIVEPING \| WDIOF_MAGICCLOSE,
218	171	.identity = "WM831x Watchdog",
219	172	};
220	173
221		-static long wm831x_wdt_ioctl(struct file *file, unsigned int cmd,
222		- unsigned long arg)
223		-{
224		- int ret = -ENOTTY, time, i;
225		- void __user argp = (void __user )arg;
226		- int __user *p = argp;
227		- u16 reg;
228		-
229		- switch (cmd) {
230		- case WDIOC_GETSUPPORT:
231		- ret = copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
232		- break;
233		-
234		- case WDIOC_GETSTATUS:
235		- case WDIOC_GETBOOTSTATUS:
236		- ret = put_user(0, p);
237		- break;
238		-
239		- case WDIOC_SETOPTIONS:
240		- {
241		- int options;
242		-
243		- if (get_user(options, p))
244		- return -EFAULT;
245		-
246		- ret = -EINVAL;
247		-
248		- /* Setting both simultaneously means at least one must fail */
249		- if (options == WDIOS_DISABLECARD)
250		- ret = wm831x_wdt_start(wm831x);
251		-
252		- if (options == WDIOS_ENABLECARD)
253		- ret = wm831x_wdt_stop(wm831x);
254		- break;
255		- }
256		-
257		- case WDIOC_KEEPALIVE:
258		- ret = wm831x_wdt_kick(wm831x);
259		- break;
260		-
261		- case WDIOC_SETTIMEOUT:
262		- ret = get_user(time, p);
263		- if (ret)
264		- break;
265		-
266		- if (time == 0) {
267		- if (nowayout)
268		- ret = -EINVAL;
269		- else
270		- wm831x_wdt_stop(wm831x);
271		- break;
272		- }
273		-
274		- for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++)
275		- if (wm831x_wdt_cfgs[i].time == time)
276		- break;
277		- if (i == ARRAY_SIZE(wm831x_wdt_cfgs))
278		- ret = -EINVAL;
279		- else
280		- ret = wm831x_wdt_set_timeout(wm831x,
281		- wm831x_wdt_cfgs[i].val);
282		- break;
283		-
284		- case WDIOC_GETTIMEOUT:
285		- reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
286		- reg &= WM831X_WDOG_TO_MASK;
287		- for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++)
288		- if (wm831x_wdt_cfgs[i].val == reg)
289		- break;
290		- if (i == ARRAY_SIZE(wm831x_wdt_cfgs)) {
291		- dev_warn(wm831x->dev,
292		- "Unknown watchdog configuration: %x\n", reg);
293		- ret = -EINVAL;
294		- } else
295		- ret = put_user(wm831x_wdt_cfgs[i].time, p);
296		-
297		- }
298		-
299		- return ret;
300		-}
301		-
302		-static const struct file_operations wm831x_wdt_fops = {
	174	+static const struct watchdog_ops wm831x_wdt_ops = {
303	175	.owner = THIS_MODULE,
304		- .llseek = no_llseek,
305		- .write = wm831x_wdt_write,
306		- .unlocked_ioctl = wm831x_wdt_ioctl,
307		- .open = wm831x_wdt_open,
308		- .release = wm831x_wdt_release,
	176	+ .start = wm831x_wdt_start,
	177	+ .stop = wm831x_wdt_stop,
	178	+ .ping = wm831x_wdt_ping,
	179	+ .set_timeout = wm831x_wdt_set_timeout,
309	180	};
310	181
311		-static struct miscdevice wm831x_wdt_miscdev = {
312		- .minor = WATCHDOG_MINOR,
313		- .name = "watchdog",
314		- .fops = &wm831x_wdt_fops,
315		-};
316		-
317	182	static int __devinit wm831x_wdt_probe(struct platform_device *pdev)
318	183	{
	184	+ struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
319	185	struct wm831x_pdata *chip_pdata;
320	186	struct wm831x_watchdog_pdata *pdata;
321		- int reg, ret;
	187	+ struct wm831x_wdt_drvdata *driver_data;
	188	+ struct watchdog_device *wm831x_wdt;
	189	+ int reg, ret, i;
322	190
323		- if (wm831x) {
324		- dev_err(&pdev->dev, "wm831x watchdog already registered\n");
325		- return -EBUSY;
326		- }
327		-
328		- wm831x = dev_get_drvdata(pdev->dev.parent);
329		-
330	191	ret = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
331	192	if (ret < 0) {
332	193	dev_err(wm831x->dev, "Failed to read watchdog status: %d\n",
...	...	@@ -338,6 +199,36 @@
338	199	if (reg & WM831X_WDOG_DEBUG)
339	200	dev_warn(wm831x->dev, "Watchdog is paused\n");
340	201
	202	+ driver_data = kzalloc(sizeof(*driver_data), GFP_KERNEL);
	203	+ if (!driver_data) {
	204	+ dev_err(wm831x->dev, "Unable to alloacate watchdog device\n");
	205	+ ret = -ENOMEM;
	206	+ goto err;
	207	+ }
	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;
	216	+ watchdog_set_drvdata(wm831x_wdt, driver_data);
	217	+
	218	+ if (nowayout)
	219	+ wm831x_wdt->status \|= WDOG_NO_WAY_OUT;
	220	+
	221	+ reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
	222	+ reg &= WM831X_WDOG_TO_MASK;
	223	+ for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++)
	224	+ if (wm831x_wdt_cfgs[i].val == reg)
	225	+ break;
	226	+ if (i == ARRAY_SIZE(wm831x_wdt_cfgs))
	227	+ dev_warn(wm831x->dev,
	228	+ "Unknown watchdog timeout: %x\n", reg);
	229	+ else
	230	+ wm831x_wdt->timeout = wm831x_wdt_cfgs[i].time;
	231	+
341	232	/* Apply any configuration */
342	233	if (pdev->dev.parent->platform_data) {
343	234	chip_pdata = pdev->dev.parent->platform_data;
...	...	@@ -361,7 +252,7 @@
361	252	dev_err(wm831x->dev,
362	253	"Failed to request update GPIO: %d\n",
363	254	ret);
364		- goto err;
	255	+ goto err_alloc;
365	256	}
366	257
367	258	ret = gpio_direction_output(pdata->update_gpio, 0);
...	...	@@ -372,7 +263,7 @@
372	263	goto err_gpio;
373	264	}
374	265
375		- update_gpio = pdata->update_gpio;
	266	+ driver_data->update_gpio = pdata->update_gpio;
376	267
377	268	/* Make sure the watchdog takes hardware updates */
378	269	reg \|= WM831X_WDOG_RST_SRC;
379	270
380	271
381	272
382	273
383	274
...	...	@@ -389,33 +280,34 @@
389	280	}
390	281	}
391	282
392		- wm831x_wdt_miscdev.parent = &pdev->dev;
393		-
394		- ret = misc_register(&wm831x_wdt_miscdev);
	283	+ ret = watchdog_register_device(&driver_data->wdt);
395	284	if (ret != 0) {
396		- dev_err(wm831x->dev, "Failed to register miscdev: %d\n", ret);
	285	+ dev_err(wm831x->dev, "watchdog_register_device() failed: %d\n",
	286	+ ret);
397	287	goto err_gpio;
398	288	}
399	289
	290	+ dev_set_drvdata(&pdev->dev, driver_data);
	291	+
400	292	return 0;
401	293
402	294	err_gpio:
403		- if (update_gpio) {
404		- gpio_free(update_gpio);
405		- update_gpio = 0;
406		- }
	295	+ if (driver_data->update_gpio)
	296	+ gpio_free(driver_data->update_gpio);
	297	+err_alloc:
	298	+ kfree(driver_data);
407	299	err:
408	300	return ret;
409	301	}
410	302
411	303	static int __devexit wm831x_wdt_remove(struct platform_device *pdev)
412	304	{
413		- if (update_gpio) {
414		- gpio_free(update_gpio);
415		- update_gpio = 0;
416		- }
	305	+ struct wm831x_wdt_drvdata *driver_data = dev_get_drvdata(&pdev->dev);
417	306
418		- misc_deregister(&wm831x_wdt_miscdev);
	307	+ watchdog_unregister_device(&driver_data->wdt);
	308	+
	309	+ if (driver_data->update_gpio)
	310	+ gpio_free(driver_data->update_gpio);
419	311
420	312	return 0;
421	313	}