Commit | Line | Data |
---|---|---|
2e62c498 | 1 | // SPDX-License-Identifier: GPL-2.0+ |
26c57ef1 JT |
2 | /* |
3 | * Watchdog driver for the A21 VME CPU Boards | |
4 | * | |
5 | * Copyright (C) 2013 MEN Mikro Elektronik Nuernberg GmbH | |
6 | * | |
26c57ef1 JT |
7 | */ |
8 | #include <linux/module.h> | |
9 | #include <linux/moduleparam.h> | |
10 | #include <linux/types.h> | |
11 | #include <linux/kernel.h> | |
12 | #include <linux/slab.h> | |
13 | #include <linux/platform_device.h> | |
14 | #include <linux/watchdog.h> | |
15 | #include <linux/uaccess.h> | |
22ec9bb1 | 16 | #include <linux/gpio/consumer.h> |
26c57ef1 JT |
17 | #include <linux/delay.h> |
18 | #include <linux/bitops.h> | |
22ec9bb1 | 19 | #include <linux/of.h> |
26c57ef1 JT |
20 | |
21 | #define NUM_GPIOS 6 | |
22 | ||
23 | enum a21_wdt_gpios { | |
24 | GPIO_WD_ENAB, | |
25 | GPIO_WD_FAST, | |
26 | GPIO_WD_TRIG, | |
27 | GPIO_WD_RST0, | |
28 | GPIO_WD_RST1, | |
29 | GPIO_WD_RST2, | |
30 | }; | |
31 | ||
32 | struct a21_wdt_drv { | |
33 | struct watchdog_device wdt; | |
22ec9bb1 | 34 | struct gpio_desc *gpios[NUM_GPIOS]; |
26c57ef1 JT |
35 | }; |
36 | ||
37 | static bool nowayout = WATCHDOG_NOWAYOUT; | |
38 | module_param(nowayout, bool, 0); | |
39 | MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" | |
40 | __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); | |
41 | ||
42 | static unsigned int a21_wdt_get_bootstatus(struct a21_wdt_drv *drv) | |
43 | { | |
44 | int reset = 0; | |
45 | ||
22ec9bb1 LW |
46 | reset |= gpiod_get_value(drv->gpios[GPIO_WD_RST0]) ? (1 << 0) : 0; |
47 | reset |= gpiod_get_value(drv->gpios[GPIO_WD_RST1]) ? (1 << 1) : 0; | |
48 | reset |= gpiod_get_value(drv->gpios[GPIO_WD_RST2]) ? (1 << 2) : 0; | |
26c57ef1 JT |
49 | |
50 | return reset; | |
51 | } | |
52 | ||
53 | static int a21_wdt_start(struct watchdog_device *wdt) | |
54 | { | |
55 | struct a21_wdt_drv *drv = watchdog_get_drvdata(wdt); | |
56 | ||
22ec9bb1 | 57 | gpiod_set_value(drv->gpios[GPIO_WD_ENAB], 1); |
26c57ef1 | 58 | |
26c57ef1 JT |
59 | return 0; |
60 | } | |
61 | ||
62 | static int a21_wdt_stop(struct watchdog_device *wdt) | |
63 | { | |
64 | struct a21_wdt_drv *drv = watchdog_get_drvdata(wdt); | |
65 | ||
22ec9bb1 | 66 | gpiod_set_value(drv->gpios[GPIO_WD_ENAB], 0); |
26c57ef1 | 67 | |
26c57ef1 JT |
68 | return 0; |
69 | } | |
70 | ||
71 | static int a21_wdt_ping(struct watchdog_device *wdt) | |
72 | { | |
73 | struct a21_wdt_drv *drv = watchdog_get_drvdata(wdt); | |
74 | ||
22ec9bb1 | 75 | gpiod_set_value(drv->gpios[GPIO_WD_TRIG], 0); |
26c57ef1 | 76 | ndelay(10); |
22ec9bb1 | 77 | gpiod_set_value(drv->gpios[GPIO_WD_TRIG], 1); |
26c57ef1 | 78 | |
26c57ef1 JT |
79 | return 0; |
80 | } | |
81 | ||
82 | static int a21_wdt_set_timeout(struct watchdog_device *wdt, | |
83 | unsigned int timeout) | |
84 | { | |
85 | struct a21_wdt_drv *drv = watchdog_get_drvdata(wdt); | |
86 | ||
87 | if (timeout != 1 && timeout != 30) { | |
07352366 | 88 | dev_err(wdt->parent, "Only 1 and 30 allowed as timeout\n"); |
26c57ef1 JT |
89 | return -EINVAL; |
90 | } | |
91 | ||
92 | if (timeout == 30 && wdt->timeout == 1) { | |
07352366 | 93 | dev_err(wdt->parent, |
26c57ef1 JT |
94 | "Transition from fast to slow mode not allowed\n"); |
95 | return -EINVAL; | |
96 | } | |
97 | ||
26c57ef1 | 98 | if (timeout == 1) |
22ec9bb1 | 99 | gpiod_set_value(drv->gpios[GPIO_WD_FAST], 1); |
26c57ef1 | 100 | else |
22ec9bb1 | 101 | gpiod_set_value(drv->gpios[GPIO_WD_FAST], 0); |
26c57ef1 JT |
102 | |
103 | wdt->timeout = timeout; | |
104 | ||
26c57ef1 JT |
105 | return 0; |
106 | } | |
107 | ||
108 | static const struct watchdog_info a21_wdt_info = { | |
109 | .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, | |
110 | .identity = "MEN A21 Watchdog", | |
111 | }; | |
112 | ||
113 | static const struct watchdog_ops a21_wdt_ops = { | |
114 | .owner = THIS_MODULE, | |
115 | .start = a21_wdt_start, | |
116 | .stop = a21_wdt_stop, | |
117 | .ping = a21_wdt_ping, | |
118 | .set_timeout = a21_wdt_set_timeout, | |
119 | }; | |
120 | ||
121 | static struct watchdog_device a21_wdt = { | |
122 | .info = &a21_wdt_info, | |
123 | .ops = &a21_wdt_ops, | |
124 | .min_timeout = 1, | |
125 | .max_timeout = 30, | |
126 | }; | |
127 | ||
128 | static int a21_wdt_probe(struct platform_device *pdev) | |
129 | { | |
94ac20d8 | 130 | struct device *dev = &pdev->dev; |
26c57ef1 JT |
131 | struct a21_wdt_drv *drv; |
132 | unsigned int reset = 0; | |
133 | int num_gpios; | |
134 | int ret; | |
135 | int i; | |
136 | ||
94ac20d8 | 137 | drv = devm_kzalloc(dev, sizeof(struct a21_wdt_drv), GFP_KERNEL); |
26c57ef1 JT |
138 | if (!drv) |
139 | return -ENOMEM; | |
140 | ||
94ac20d8 | 141 | num_gpios = gpiod_count(dev, NULL); |
26c57ef1 | 142 | if (num_gpios != NUM_GPIOS) { |
94ac20d8 | 143 | dev_err(dev, "gpios DT property wrong, got %d want %d", |
26c57ef1 JT |
144 | num_gpios, NUM_GPIOS); |
145 | return -ENODEV; | |
146 | } | |
147 | ||
26c57ef1 JT |
148 | /* Request the used GPIOs */ |
149 | for (i = 0; i < num_gpios; i++) { | |
22ec9bb1 | 150 | enum gpiod_flags gflags; |
26c57ef1 JT |
151 | |
152 | if (i < GPIO_WD_RST0) | |
22ec9bb1 LW |
153 | gflags = GPIOD_ASIS; |
154 | else | |
155 | gflags = GPIOD_IN; | |
94ac20d8 GR |
156 | drv->gpios[i] = devm_gpiod_get_index(dev, NULL, i, gflags); |
157 | if (IS_ERR(drv->gpios[i])) | |
158 | return PTR_ERR(drv->gpios[i]); | |
22ec9bb1 LW |
159 | |
160 | gpiod_set_consumer_name(drv->gpios[i], "MEN A21 Watchdog"); | |
161 | ||
162 | /* | |
163 | * Retrieve the initial value from the GPIOs that should be | |
164 | * output, then set up the line as output with that value. | |
165 | */ | |
166 | if (i < GPIO_WD_RST0) { | |
167 | int val; | |
168 | ||
169 | val = gpiod_get_value(drv->gpios[i]); | |
170 | gpiod_direction_output(drv->gpios[i], val); | |
171 | } | |
26c57ef1 JT |
172 | } |
173 | ||
94ac20d8 | 174 | watchdog_init_timeout(&a21_wdt, 30, dev); |
26c57ef1 JT |
175 | watchdog_set_nowayout(&a21_wdt, nowayout); |
176 | watchdog_set_drvdata(&a21_wdt, drv); | |
94ac20d8 | 177 | a21_wdt.parent = dev; |
26c57ef1 JT |
178 | |
179 | reset = a21_wdt_get_bootstatus(drv); | |
180 | if (reset == 2) | |
181 | a21_wdt.bootstatus |= WDIOF_EXTERN1; | |
182 | else if (reset == 4) | |
183 | a21_wdt.bootstatus |= WDIOF_CARDRESET; | |
184 | else if (reset == 5) | |
185 | a21_wdt.bootstatus |= WDIOF_POWERUNDER; | |
186 | else if (reset == 7) | |
187 | a21_wdt.bootstatus |= WDIOF_EXTERN2; | |
188 | ||
57337db1 | 189 | drv->wdt = a21_wdt; |
94ac20d8 | 190 | dev_set_drvdata(dev, drv); |
57337db1 | 191 | |
94ac20d8 | 192 | ret = devm_watchdog_register_device(dev, &a21_wdt); |
eddeb07b | 193 | if (ret) |
cb5c14ea | 194 | return ret; |
26c57ef1 | 195 | |
94ac20d8 | 196 | dev_info(dev, "MEN A21 watchdog timer driver enabled\n"); |
26c57ef1 | 197 | |
26c57ef1 JT |
198 | return 0; |
199 | } | |
200 | ||
201 | static void a21_wdt_shutdown(struct platform_device *pdev) | |
202 | { | |
203 | struct a21_wdt_drv *drv = dev_get_drvdata(&pdev->dev); | |
204 | ||
22ec9bb1 | 205 | gpiod_set_value(drv->gpios[GPIO_WD_ENAB], 0); |
26c57ef1 JT |
206 | } |
207 | ||
208 | static const struct of_device_id a21_wdt_ids[] = { | |
209 | { .compatible = "men,a021-wdt" }, | |
210 | { }, | |
211 | }; | |
c73318f4 | 212 | MODULE_DEVICE_TABLE(of, a21_wdt_ids); |
26c57ef1 JT |
213 | |
214 | static struct platform_driver a21_wdt_driver = { | |
215 | .probe = a21_wdt_probe, | |
26c57ef1 JT |
216 | .shutdown = a21_wdt_shutdown, |
217 | .driver = { | |
218 | .name = "a21-watchdog", | |
219 | .of_match_table = a21_wdt_ids, | |
220 | }, | |
221 | }; | |
222 | ||
223 | module_platform_driver(a21_wdt_driver); | |
224 | ||
225 | MODULE_AUTHOR("MEN Mikro Elektronik"); | |
226 | MODULE_DESCRIPTION("MEN A21 Watchdog"); | |
227 | MODULE_LICENSE("GPL"); | |
228 | MODULE_ALIAS("platform:a21-watchdog"); |