1 /*
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2023 Jari Sihvola <jsihv@gmx.com>
5 */
6
7 #include <sys/cdefs.h>
8
9 #include <sys/param.h>
10 #include <sys/systm.h>
11 #include <sys/bus.h>
12
13 #include <sys/gpio.h>
14 #include <sys/kernel.h>
15 #include <sys/lock.h>
16 #include <sys/module.h>
17 #include <sys/mutex.h>
18 #include <sys/rman.h>
19
20 #include <machine/bus.h>
21 #include <machine/intr.h>
22 #include <machine/resource.h>
23
24 #include <dev/clk/clk.h>
25 #include <dev/gpio/gpiobusvar.h>
26 #include <dev/ofw/ofw_bus.h>
27 #include <dev/ofw/ofw_bus_subr.h>
28
29 #include "gpio_if.h"
30
31 #define GPIO_PINS 64
32 #define GPIO_REGS 2
33
34 #define GP0_DOEN_CFG 0x0
35 #define GP0_DOUT_CFG 0x40
36 #define GPIOEN 0xdc
37 #define GPIOE_0 0x100
38 #define GPIOE_1 0x104
39 #define GPIO_DIN_LOW 0x118
40 #define GPIO_DIN_HIGH 0x11c
41 #define IOMUX_SYSCFG_288 0x120
42
43 #define PAD_INPUT_EN (1 << 0)
44 #define PAD_PULLUP (1 << 3)
45 #define PAD_PULLDOWN (1 << 4)
46 #define PAD_HYST (1 << 6)
47
48 #define ENABLE_MASK 0x3f
49 #define DATA_OUT_MASK 0x7f
50 #define DIROUT_DISABLE 1
51
52 struct jh7110_gpio_softc {
53 device_t dev;
54 device_t busdev;
55 struct mtx mtx;
56 struct resource *res;
57 clk_t clk;
58 };
59
60 static struct ofw_compat_data compat_data[] = {
61 {"starfive,jh7110-sys-pinctrl", 1},
62 {NULL, 0}
63 };
64
65 static struct resource_spec jh7110_gpio_spec[] = {
66 { SYS_RES_MEMORY, 0, RF_ACTIVE },
67 { -1, 0 }
68 };
69
70 #define GPIO_RW_OFFSET(_val) (_val & ~3)
71 #define GPIO_SHIFT(_val) ((_val & 3) * 8)
72 #define PAD_OFFSET(_val) (_val * 4)
73
74 #define JH7110_GPIO_LOCK(_sc) mtx_lock(&(_sc)->mtx)
75 #define JH7110_GPIO_UNLOCK(_sc) mtx_unlock(&(_sc)->mtx)
76
77 #define JH7110_GPIO_READ(sc, reg) bus_read_4((sc)->res, (reg))
78 #define JH7110_GPIO_WRITE(sc, reg, val) bus_write_4((sc)->res, (reg), (val))
79
80 static device_t
jh7110_gpio_get_bus(device_t dev)81 jh7110_gpio_get_bus(device_t dev)
82 {
83 struct jh7110_gpio_softc *sc;
84
85 sc = device_get_softc(dev);
86
87 return (sc->busdev);
88 }
89
90 static int
jh7110_gpio_pin_max(device_t dev,int * maxpin)91 jh7110_gpio_pin_max(device_t dev, int *maxpin)
92 {
93 *maxpin = GPIO_PINS - 1;
94
95 return (0);
96 }
97
98 static int
jh7110_gpio_pin_get(device_t dev,uint32_t pin,unsigned int * val)99 jh7110_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val)
100 {
101 struct jh7110_gpio_softc *sc;
102 uint32_t reg;
103
104 sc = device_get_softc(dev);
105
106 if (pin >= GPIO_PINS)
107 return (EINVAL);
108
109 JH7110_GPIO_LOCK(sc);
110 if (pin < GPIO_PINS / GPIO_REGS) {
111 reg = JH7110_GPIO_READ(sc, GPIO_DIN_LOW);
112 *val = (reg >> pin) & 0x1;
113 } else {
114 reg = JH7110_GPIO_READ(sc, GPIO_DIN_HIGH);
115 *val = (reg >> (pin - GPIO_PINS / GPIO_REGS)) & 0x1;
116 }
117 JH7110_GPIO_UNLOCK(sc);
118
119 return (0);
120 }
121
122 static int
jh7110_gpio_pin_set(device_t dev,uint32_t pin,unsigned int value)123 jh7110_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value)
124 {
125 struct jh7110_gpio_softc *sc;
126 uint32_t reg;
127
128 sc = device_get_softc(dev);
129
130 if (pin >= GPIO_PINS)
131 return (EINVAL);
132
133 JH7110_GPIO_LOCK(sc);
134 reg = JH7110_GPIO_READ(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin));
135 reg &= ~(DATA_OUT_MASK << GPIO_SHIFT(pin));
136 if (value)
137 reg |= 0x1 << GPIO_SHIFT(pin);
138 JH7110_GPIO_WRITE(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin), reg);
139 JH7110_GPIO_UNLOCK(sc);
140
141 return (0);
142 }
143
144 static int
jh7110_gpio_pin_toggle(device_t dev,uint32_t pin)145 jh7110_gpio_pin_toggle(device_t dev, uint32_t pin)
146 {
147 struct jh7110_gpio_softc *sc;
148 uint32_t reg;
149
150 sc = device_get_softc(dev);
151
152 if (pin >= GPIO_PINS)
153 return (EINVAL);
154
155 JH7110_GPIO_LOCK(sc);
156 reg = JH7110_GPIO_READ(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin));
157 if (reg & 0x1 << GPIO_SHIFT(pin)) {
158 reg &= ~(DATA_OUT_MASK << GPIO_SHIFT(pin));
159 } else {
160 reg &= ~(DATA_OUT_MASK << GPIO_SHIFT(pin));
161 reg |= 0x1 << GPIO_SHIFT(pin);
162 }
163 JH7110_GPIO_WRITE(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin), reg);
164 JH7110_GPIO_UNLOCK(sc);
165
166 return (0);
167 }
168
169 static int
jh7110_gpio_pin_getcaps(device_t dev,uint32_t pin,uint32_t * caps)170 jh7110_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps)
171 {
172 if (pin >= GPIO_PINS)
173 return (EINVAL);
174
175 *caps = (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT);
176
177 return (0);
178 }
179
180 static int
jh7110_gpio_pin_getname(device_t dev,uint32_t pin,char * name)181 jh7110_gpio_pin_getname(device_t dev, uint32_t pin, char *name)
182 {
183 if (pin >= GPIO_PINS)
184 return (EINVAL);
185
186 snprintf(name, GPIOMAXNAME, "GPIO%d", pin);
187
188 return (0);
189 }
190
191 static int
jh7110_gpio_pin_getflags(device_t dev,uint32_t pin,uint32_t * flags)192 jh7110_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags)
193 {
194 struct jh7110_gpio_softc *sc;
195 uint32_t reg;
196
197 sc = device_get_softc(dev);
198
199 if (pin >= GPIO_PINS)
200 return (EINVAL);
201
202 /* Reading the direction */
203 JH7110_GPIO_LOCK(sc);
204 reg = JH7110_GPIO_READ(sc, GP0_DOEN_CFG + GPIO_RW_OFFSET(pin));
205 if ((reg & ENABLE_MASK << GPIO_SHIFT(pin)) == 0)
206 *flags |= GPIO_PIN_OUTPUT;
207 else
208 *flags |= GPIO_PIN_INPUT;
209 JH7110_GPIO_UNLOCK(sc);
210
211 return (0);
212 }
213
214 static int
jh7110_gpio_pin_setflags(device_t dev,uint32_t pin,uint32_t flags)215 jh7110_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags)
216 {
217 struct jh7110_gpio_softc *sc;
218 uint32_t reg;
219
220 sc = device_get_softc(dev);
221
222 if (pin >= GPIO_PINS)
223 return (EINVAL);
224
225 /* Setting the direction, enable or disable output, configuring pads */
226
227 JH7110_GPIO_LOCK(sc);
228
229 if (flags & GPIO_PIN_INPUT) {
230 reg = JH7110_GPIO_READ(sc, IOMUX_SYSCFG_288 + PAD_OFFSET(pin));
231 reg |= (PAD_INPUT_EN | PAD_HYST);
232 JH7110_GPIO_WRITE(sc, IOMUX_SYSCFG_288 + PAD_OFFSET(pin), reg);
233 }
234
235 reg = JH7110_GPIO_READ(sc, GP0_DOEN_CFG + GPIO_RW_OFFSET(pin));
236 reg &= ~(ENABLE_MASK << GPIO_SHIFT(pin));
237 if (flags & GPIO_PIN_INPUT) {
238 reg |= DIROUT_DISABLE << GPIO_SHIFT(pin);
239 }
240 JH7110_GPIO_WRITE(sc, GP0_DOEN_CFG + GPIO_RW_OFFSET(pin), reg);
241
242 if (flags & GPIO_PIN_OUTPUT) {
243 reg = JH7110_GPIO_READ(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin));
244 reg &= ~(ENABLE_MASK << GPIO_SHIFT(pin));
245 reg |= 0x1 << GPIO_SHIFT(pin);
246 JH7110_GPIO_WRITE(sc, GP0_DOUT_CFG + GPIO_RW_OFFSET(pin), reg);
247
248 reg = JH7110_GPIO_READ(sc, IOMUX_SYSCFG_288 + PAD_OFFSET(pin));
249 reg &= ~(PAD_INPUT_EN | PAD_PULLUP | PAD_PULLDOWN | PAD_HYST);
250 JH7110_GPIO_WRITE(sc, IOMUX_SYSCFG_288 + PAD_OFFSET(pin), reg);
251 }
252
253 JH7110_GPIO_UNLOCK(sc);
254
255 return (0);
256 }
257
258 static int
jh7110_gpio_probe(device_t dev)259 jh7110_gpio_probe(device_t dev)
260 {
261 if (!ofw_bus_status_okay(dev))
262 return (ENXIO);
263
264 if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
265 return (ENXIO);
266
267 device_set_desc(dev, "StarFive JH7110 GPIO controller");
268
269 return (BUS_PROBE_DEFAULT);
270 }
271
272 static int
jh7110_gpio_detach(device_t dev)273 jh7110_gpio_detach(device_t dev)
274 {
275 struct jh7110_gpio_softc *sc;
276
277 sc = device_get_softc(dev);
278
279 bus_release_resources(dev, jh7110_gpio_spec, &sc->res);
280 if (sc->busdev != NULL)
281 gpiobus_detach_bus(dev);
282 if (sc->clk != NULL)
283 clk_release(sc->clk);
284 mtx_destroy(&sc->mtx);
285
286 return (0);
287 }
288
289 static int
jh7110_gpio_attach(device_t dev)290 jh7110_gpio_attach(device_t dev)
291 {
292 struct jh7110_gpio_softc *sc;
293
294 sc = device_get_softc(dev);
295 sc->dev = dev;
296
297 mtx_init(&sc->mtx, device_get_nameunit(sc->dev), NULL, MTX_DEF);
298
299 if (bus_alloc_resources(dev, jh7110_gpio_spec, &sc->res) != 0) {
300 device_printf(dev, "Could not allocate resources\n");
301 bus_release_resources(dev, jh7110_gpio_spec, &sc->res);
302 mtx_destroy(&sc->mtx);
303 return (ENXIO);
304 }
305
306 if (clk_get_by_ofw_index(dev, 0, 0, &sc->clk) != 0) {
307 device_printf(dev, "Cannot get clock\n");
308 jh7110_gpio_detach(dev);
309 return (ENXIO);
310 }
311
312 if (clk_enable(sc->clk) != 0) {
313 device_printf(dev, "Could not enable clock %s\n",
314 clk_get_name(sc->clk));
315 jh7110_gpio_detach(dev);
316 return (ENXIO);
317 }
318
319 /* Reseting GPIO interrupts */
320 JH7110_GPIO_WRITE(sc, GPIOE_0, 0);
321 JH7110_GPIO_WRITE(sc, GPIOE_1, 0);
322 JH7110_GPIO_WRITE(sc, GPIOEN, 1);
323
324 sc->busdev = gpiobus_add_bus(dev);
325 if (sc->busdev == NULL) {
326 device_printf(dev, "Cannot attach gpiobus\n");
327 jh7110_gpio_detach(dev);
328 return (ENXIO);
329 }
330
331 bus_attach_children(dev);
332 return (0);
333 }
334
335 static phandle_t
jh7110_gpio_get_node(device_t bus,device_t dev)336 jh7110_gpio_get_node(device_t bus, device_t dev)
337 {
338 return (ofw_bus_get_node(bus));
339 }
340
341 static device_method_t jh7110_gpio_methods[] = {
342 /* Device interface */
343 DEVMETHOD(device_probe, jh7110_gpio_probe),
344 DEVMETHOD(device_attach, jh7110_gpio_attach),
345 DEVMETHOD(device_detach, jh7110_gpio_detach),
346
347 /* GPIO protocol */
348 DEVMETHOD(gpio_get_bus, jh7110_gpio_get_bus),
349 DEVMETHOD(gpio_pin_max, jh7110_gpio_pin_max),
350 DEVMETHOD(gpio_pin_get, jh7110_gpio_pin_get),
351 DEVMETHOD(gpio_pin_set, jh7110_gpio_pin_set),
352 DEVMETHOD(gpio_pin_toggle, jh7110_gpio_pin_toggle),
353 DEVMETHOD(gpio_pin_getflags, jh7110_gpio_pin_getflags),
354 DEVMETHOD(gpio_pin_setflags, jh7110_gpio_pin_setflags),
355 DEVMETHOD(gpio_pin_getcaps, jh7110_gpio_pin_getcaps),
356 DEVMETHOD(gpio_pin_getname, jh7110_gpio_pin_getname),
357
358 /* ofw_bus interface */
359 DEVMETHOD(ofw_bus_get_node, jh7110_gpio_get_node),
360
361 DEVMETHOD_END
362 };
363
364 DEFINE_CLASS_0(gpio, jh7110_gpio_driver, jh7110_gpio_methods,
365 sizeof(struct jh7110_gpio_softc));
366 EARLY_DRIVER_MODULE(jh7110_gpio, simplebus, jh7110_gpio_driver, 0, 0,
367 BUS_PASS_INTERRUPT + BUS_PASS_ORDER_MIDDLE);
368 MODULE_DEPEND(jh7110_gpio, gpiobus, 1, 1, 1);
369