Commit | Line | Data |
---|---|---|
26c57ef1 JT |
1 | /* |
2 | * Watchdog driver for the A21 VME CPU Boards | |
3 | * | |
4 | * Copyright (C) 2013 MEN Mikro Elektronik Nuernberg GmbH | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU General Public License | |
8 | * as published by the Free Software Foundation | |
9 | */ | |
10 | #include <linux/module.h> | |
11 | #include <linux/moduleparam.h> | |
12 | #include <linux/types.h> | |
13 | #include <linux/kernel.h> | |
14 | #include <linux/slab.h> | |
15 | #include <linux/platform_device.h> | |
16 | #include <linux/watchdog.h> | |
17 | #include <linux/uaccess.h> | |
18 | #include <linux/gpio.h> | |
19 | #include <linux/of_gpio.h> | |
20 | #include <linux/delay.h> | |
21 | #include <linux/bitops.h> | |
22 | ||
23 | #define NUM_GPIOS 6 | |
24 | ||
25 | enum a21_wdt_gpios { | |
26 | GPIO_WD_ENAB, | |
27 | GPIO_WD_FAST, | |
28 | GPIO_WD_TRIG, | |
29 | GPIO_WD_RST0, | |
30 | GPIO_WD_RST1, | |
31 | GPIO_WD_RST2, | |
32 | }; | |
33 | ||
34 | struct a21_wdt_drv { | |
35 | struct watchdog_device wdt; | |
36 | struct mutex lock; | |
37 | unsigned gpios[NUM_GPIOS]; | |
38 | }; | |
39 | ||
40 | static bool nowayout = WATCHDOG_NOWAYOUT; | |
41 | module_param(nowayout, bool, 0); | |
42 | MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" | |
43 | __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); | |
44 | ||
45 | static unsigned int a21_wdt_get_bootstatus(struct a21_wdt_drv *drv) | |
46 | { | |
47 | int reset = 0; | |
48 | ||
49 | reset |= gpio_get_value(drv->gpios[GPIO_WD_RST0]) ? (1 << 0) : 0; | |
50 | reset |= gpio_get_value(drv->gpios[GPIO_WD_RST1]) ? (1 << 1) : 0; | |
51 | reset |= gpio_get_value(drv->gpios[GPIO_WD_RST2]) ? (1 << 2) : 0; | |
52 | ||
53 | return reset; | |
54 | } | |
55 | ||
56 | static int a21_wdt_start(struct watchdog_device *wdt) | |
57 | { | |
58 | struct a21_wdt_drv *drv = watchdog_get_drvdata(wdt); | |
59 | ||
60 | mutex_lock(&drv->lock); | |
61 | ||
62 | gpio_set_value(drv->gpios[GPIO_WD_ENAB], 1); | |
63 | ||
64 | mutex_unlock(&drv->lock); | |
65 | ||
66 | return 0; | |
67 | } | |
68 | ||
69 | static int a21_wdt_stop(struct watchdog_device *wdt) | |
70 | { | |
71 | struct a21_wdt_drv *drv = watchdog_get_drvdata(wdt); | |
72 | ||
73 | mutex_lock(&drv->lock); | |
74 | ||
75 | gpio_set_value(drv->gpios[GPIO_WD_ENAB], 0); | |
76 | ||
77 | mutex_unlock(&drv->lock); | |
78 | ||
79 | return 0; | |
80 | } | |
81 | ||
82 | static int a21_wdt_ping(struct watchdog_device *wdt) | |
83 | { | |
84 | struct a21_wdt_drv *drv = watchdog_get_drvdata(wdt); | |
85 | ||
86 | mutex_lock(&drv->lock); | |
87 | ||
88 | gpio_set_value(drv->gpios[GPIO_WD_TRIG], 0); | |
89 | ndelay(10); | |
90 | gpio_set_value(drv->gpios[GPIO_WD_TRIG], 1); | |
91 | ||
92 | mutex_unlock(&drv->lock); | |
93 | ||
94 | return 0; | |
95 | } | |
96 | ||
97 | static int a21_wdt_set_timeout(struct watchdog_device *wdt, | |
98 | unsigned int timeout) | |
99 | { | |
100 | struct a21_wdt_drv *drv = watchdog_get_drvdata(wdt); | |
101 | ||
102 | if (timeout != 1 && timeout != 30) { | |
07352366 | 103 | dev_err(wdt->parent, "Only 1 and 30 allowed as timeout\n"); |
26c57ef1 JT |
104 | return -EINVAL; |
105 | } | |
106 | ||
107 | if (timeout == 30 && wdt->timeout == 1) { | |
07352366 | 108 | dev_err(wdt->parent, |
26c57ef1 JT |
109 | "Transition from fast to slow mode not allowed\n"); |
110 | return -EINVAL; | |
111 | } | |
112 | ||
113 | mutex_lock(&drv->lock); | |
114 | ||
115 | if (timeout == 1) | |
116 | gpio_set_value(drv->gpios[GPIO_WD_FAST], 1); | |
117 | else | |
118 | gpio_set_value(drv->gpios[GPIO_WD_FAST], 0); | |
119 | ||
120 | wdt->timeout = timeout; | |
121 | ||
122 | mutex_unlock(&drv->lock); | |
123 | ||
124 | return 0; | |
125 | } | |
126 | ||
127 | static const struct watchdog_info a21_wdt_info = { | |
128 | .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, | |
129 | .identity = "MEN A21 Watchdog", | |
130 | }; | |
131 | ||
132 | static const struct watchdog_ops a21_wdt_ops = { | |
133 | .owner = THIS_MODULE, | |
134 | .start = a21_wdt_start, | |
135 | .stop = a21_wdt_stop, | |
136 | .ping = a21_wdt_ping, | |
137 | .set_timeout = a21_wdt_set_timeout, | |
138 | }; | |
139 | ||
140 | static struct watchdog_device a21_wdt = { | |
141 | .info = &a21_wdt_info, | |
142 | .ops = &a21_wdt_ops, | |
143 | .min_timeout = 1, | |
144 | .max_timeout = 30, | |
145 | }; | |
146 | ||
147 | static int a21_wdt_probe(struct platform_device *pdev) | |
148 | { | |
149 | struct device_node *node; | |
150 | struct a21_wdt_drv *drv; | |
151 | unsigned int reset = 0; | |
152 | int num_gpios; | |
153 | int ret; | |
154 | int i; | |
155 | ||
156 | drv = devm_kzalloc(&pdev->dev, sizeof(struct a21_wdt_drv), GFP_KERNEL); | |
157 | if (!drv) | |
158 | return -ENOMEM; | |
159 | ||
160 | /* Fill GPIO pin array */ | |
161 | node = pdev->dev.of_node; | |
162 | ||
163 | num_gpios = of_gpio_count(node); | |
164 | if (num_gpios != NUM_GPIOS) { | |
165 | dev_err(&pdev->dev, "gpios DT property wrong, got %d want %d", | |
166 | num_gpios, NUM_GPIOS); | |
167 | return -ENODEV; | |
168 | } | |
169 | ||
170 | for (i = 0; i < num_gpios; i++) { | |
171 | int val; | |
172 | ||
173 | val = of_get_gpio(node, i); | |
174 | if (val < 0) | |
175 | return val; | |
176 | ||
177 | drv->gpios[i] = val; | |
178 | } | |
179 | ||
180 | /* Request the used GPIOs */ | |
181 | for (i = 0; i < num_gpios; i++) { | |
182 | ret = devm_gpio_request(&pdev->dev, drv->gpios[i], | |
183 | "MEN A21 Watchdog"); | |
184 | if (ret) | |
185 | return ret; | |
186 | ||
187 | if (i < GPIO_WD_RST0) | |
188 | ret = gpio_direction_output(drv->gpios[i], | |
189 | gpio_get_value(drv->gpios[i])); | |
190 | else /* GPIO_WD_RST[0..2] are inputs */ | |
191 | ret = gpio_direction_input(drv->gpios[i]); | |
192 | if (ret) | |
193 | return ret; | |
194 | } | |
195 | ||
196 | mutex_init(&drv->lock); | |
197 | watchdog_init_timeout(&a21_wdt, 30, &pdev->dev); | |
198 | watchdog_set_nowayout(&a21_wdt, nowayout); | |
199 | watchdog_set_drvdata(&a21_wdt, drv); | |
6551881c | 200 | a21_wdt.parent = &pdev->dev; |
26c57ef1 JT |
201 | |
202 | reset = a21_wdt_get_bootstatus(drv); | |
203 | if (reset == 2) | |
204 | a21_wdt.bootstatus |= WDIOF_EXTERN1; | |
205 | else if (reset == 4) | |
206 | a21_wdt.bootstatus |= WDIOF_CARDRESET; | |
207 | else if (reset == 5) | |
208 | a21_wdt.bootstatus |= WDIOF_POWERUNDER; | |
209 | else if (reset == 7) | |
210 | a21_wdt.bootstatus |= WDIOF_EXTERN2; | |
211 | ||
57337db1 JT |
212 | drv->wdt = a21_wdt; |
213 | dev_set_drvdata(&pdev->dev, drv); | |
214 | ||
26c57ef1 JT |
215 | ret = watchdog_register_device(&a21_wdt); |
216 | if (ret) { | |
217 | dev_err(&pdev->dev, "Cannot register watchdog device\n"); | |
218 | goto err_register_wd; | |
219 | } | |
220 | ||
26c57ef1 JT |
221 | dev_info(&pdev->dev, "MEN A21 watchdog timer driver enabled\n"); |
222 | ||
223 | return 0; | |
224 | ||
225 | err_register_wd: | |
226 | mutex_destroy(&drv->lock); | |
227 | ||
228 | return ret; | |
229 | } | |
230 | ||
231 | static int a21_wdt_remove(struct platform_device *pdev) | |
232 | { | |
233 | struct a21_wdt_drv *drv = dev_get_drvdata(&pdev->dev); | |
234 | ||
235 | dev_warn(&pdev->dev, | |
236 | "Unregistering A21 watchdog driver, board may reboot\n"); | |
237 | ||
238 | watchdog_unregister_device(&drv->wdt); | |
239 | ||
240 | mutex_destroy(&drv->lock); | |
241 | ||
242 | return 0; | |
243 | } | |
244 | ||
245 | static void a21_wdt_shutdown(struct platform_device *pdev) | |
246 | { | |
247 | struct a21_wdt_drv *drv = dev_get_drvdata(&pdev->dev); | |
248 | ||
249 | gpio_set_value(drv->gpios[GPIO_WD_ENAB], 0); | |
250 | } | |
251 | ||
252 | static const struct of_device_id a21_wdt_ids[] = { | |
253 | { .compatible = "men,a021-wdt" }, | |
254 | { }, | |
255 | }; | |
c73318f4 | 256 | MODULE_DEVICE_TABLE(of, a21_wdt_ids); |
26c57ef1 JT |
257 | |
258 | static struct platform_driver a21_wdt_driver = { | |
259 | .probe = a21_wdt_probe, | |
260 | .remove = a21_wdt_remove, | |
261 | .shutdown = a21_wdt_shutdown, | |
262 | .driver = { | |
263 | .name = "a21-watchdog", | |
264 | .of_match_table = a21_wdt_ids, | |
265 | }, | |
266 | }; | |
267 | ||
268 | module_platform_driver(a21_wdt_driver); | |
269 | ||
270 | MODULE_AUTHOR("MEN Mikro Elektronik"); | |
271 | MODULE_DESCRIPTION("MEN A21 Watchdog"); | |
272 | MODULE_LICENSE("GPL"); | |
273 | MODULE_ALIAS("platform:a21-watchdog"); |