xref: /freebsd/sys/riscv/starfive/jh7110_gpio.c (revision c063fb7accae4cbe5e0fb808a1382600dc1b4249)
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