xref: /freebsd/sys/arm64/rockchip/rk_gpio.c (revision 9768746b)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2018 Emmanuel Vadot <manu@FreeBSD.org>
5  * Copyright (c) 2021 Soren Schmidt <sos@deepcore.dk>
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  *
28  */
29 
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
32 
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/bus.h>
36 
37 #include <sys/kernel.h>
38 #include <sys/module.h>
39 #include <sys/proc.h>
40 #include <sys/rman.h>
41 #include <sys/lock.h>
42 #include <sys/mutex.h>
43 #include <sys/gpio.h>
44 
45 #include <machine/bus.h>
46 #include <machine/resource.h>
47 #include <machine/intr.h>
48 
49 #include <dev/gpio/gpiobusvar.h>
50 #include <dev/ofw/ofw_bus.h>
51 #include <dev/ofw/ofw_bus_subr.h>
52 #include <dev/extres/clk/clk.h>
53 
54 #include "gpio_if.h"
55 #include "pic_if.h"
56 
57 #include "fdt_pinctrl_if.h"
58 
59 enum gpio_regs {
60 	RK_GPIO_SWPORTA_DR = 1,	/* Data register */
61 	RK_GPIO_SWPORTA_DDR,	/* Data direction register */
62 	RK_GPIO_INTEN,		/* Interrupt enable register */
63 	RK_GPIO_INTMASK,	/* Interrupt mask register */
64 	RK_GPIO_INTTYPE_LEVEL,	/* Interrupt level register */
65 	RK_GPIO_INTTYPE_BOTH,	/* Both rise and falling edge */
66 	RK_GPIO_INT_POLARITY,	/* Interrupt polarity register */
67 	RK_GPIO_INT_STATUS,	/* Interrupt status register */
68 	RK_GPIO_INT_RAWSTATUS,	/* Raw Interrupt status register */
69 	RK_GPIO_DEBOUNCE,	/* Debounce enable register */
70 	RK_GPIO_PORTA_EOI,	/* Clear interrupt register */
71 	RK_GPIO_EXT_PORTA,	/* External port register */
72 	RK_GPIO_REGNUM
73 };
74 
75 #define	RK_GPIO_LS_SYNC		0x60	/* Level sensitive syncronization enable register */
76 
77 #define	RK_GPIO_DEFAULT_CAPS	(GPIO_PIN_INPUT | GPIO_PIN_OUTPUT |	\
78     GPIO_PIN_PULLUP | GPIO_PIN_PULLDOWN | GPIO_INTR_EDGE_BOTH | \
79     GPIO_INTR_EDGE_RISING | GPIO_INTR_EDGE_FALLING | \
80     GPIO_INTR_LEVEL_HIGH | GPIO_INTR_LEVEL_LOW)
81 
82 #define	GPIO_FLAGS_PINCTRL	GPIO_PIN_PULLUP | GPIO_PIN_PULLDOWN
83 #define	RK_GPIO_MAX_PINS	32
84 
85 struct pin_cached {
86 	uint8_t		is_gpio;
87 	uint32_t	flags;
88 };
89 
90 struct rk_pin_irqsrc {
91 	struct intr_irqsrc	isrc;
92 	uint32_t		irq;
93 	uint32_t		mode;
94 };
95 
96 struct rk_gpio_softc {
97 	device_t		sc_dev;
98 	device_t		sc_busdev;
99 	struct mtx		sc_mtx;
100 	struct resource		*sc_res[2];
101 	bus_space_tag_t		sc_bst;
102 	bus_space_handle_t	sc_bsh;
103 	clk_t			clk;
104 	device_t		pinctrl;
105 	uint32_t		swporta;
106 	uint32_t		swporta_ddr;
107 	uint32_t		version;
108 	struct pin_cached	pin_cached[RK_GPIO_MAX_PINS];
109 	uint8_t			regs[RK_GPIO_REGNUM];
110 	void			*ihandle;
111 	struct rk_pin_irqsrc	isrcs[RK_GPIO_MAX_PINS];
112 };
113 
114 static struct ofw_compat_data compat_data[] = {
115 	{"rockchip,gpio-bank", 1},
116 	{NULL,             0}
117 };
118 
119 static struct resource_spec rk_gpio_spec[] = {
120 	{ SYS_RES_MEMORY,	0,	RF_ACTIVE },
121 	{ SYS_RES_IRQ,		0,	RF_ACTIVE },
122 	{ -1, 0 }
123 };
124 
125 #define	RK_GPIO_VERSION		0x78
126 #define	RK_GPIO_TYPE_V1		0x00000000
127 #define	RK_GPIO_TYPE_V2		0x01000c2b
128 #define	RK_GPIO_ISRC(sc, irq)	(&(sc->isrcs[irq].isrc))
129 
130 static int rk_gpio_detach(device_t dev);
131 
132 #define	RK_GPIO_LOCK(_sc)		mtx_lock_spin(&(_sc)->sc_mtx)
133 #define	RK_GPIO_UNLOCK(_sc)		mtx_unlock_spin(&(_sc)->sc_mtx)
134 #define	RK_GPIO_LOCK_ASSERT(_sc)	mtx_assert(&(_sc)->sc_mtx, MA_OWNED)
135 
136 #define	RK_GPIO_WRITE(_sc, _off, _val)		\
137     bus_space_write_4(_sc->sc_bst, _sc->sc_bsh, _off, _val)
138 #define	RK_GPIO_READ(_sc, _off)		\
139     bus_space_read_4(_sc->sc_bst, _sc->sc_bsh, _off)
140 
141 static int
142 rk_gpio_read_bit(struct rk_gpio_softc *sc, int reg, int bit)
143 {
144 	int offset = sc->regs[reg];
145 	uint32_t value;
146 
147 	if (sc->version == RK_GPIO_TYPE_V1) {
148 		value = RK_GPIO_READ(sc, offset);
149 		value >>= bit;
150 	} else {
151 		value = RK_GPIO_READ(sc, bit > 15 ? offset + 4 : offset);
152 		value >>= (bit % 16);
153 	}
154 	return (value & 1);
155 }
156 
157 static void
158 rk_gpio_write_bit(struct rk_gpio_softc *sc, int reg, int bit, int data)
159 {
160 	int offset = sc->regs[reg];
161 	uint32_t value;
162 
163 	if (sc->version == RK_GPIO_TYPE_V1) {
164 		value = RK_GPIO_READ(sc, offset);
165 		if (data)
166 			value |= (1 << bit);
167 		else
168 			value &= ~(1 << bit);
169 		RK_GPIO_WRITE(sc, offset, value);
170 	} else {
171 		if (data)
172 			value = (1 << (bit % 16));
173 		else
174 			value = 0;
175 		value |= (1 << ((bit % 16) + 16));
176 		RK_GPIO_WRITE(sc, bit > 15 ? offset + 4 : offset, value);
177 	}
178 }
179 
180 static uint32_t
181 rk_gpio_read_4(struct rk_gpio_softc *sc, int reg)
182 {
183 	int offset = sc->regs[reg];
184 	uint32_t value;
185 
186 	if (sc->version == RK_GPIO_TYPE_V1)
187 		value = RK_GPIO_READ(sc, offset);
188 	else
189 		value = (RK_GPIO_READ(sc, offset) & 0xffff) |
190 		    (RK_GPIO_READ(sc, offset + 4) << 16);
191 	return (value);
192 }
193 
194 static void
195 rk_gpio_write_4(struct rk_gpio_softc *sc, int reg, uint32_t value)
196 {
197 	int offset = sc->regs[reg];
198 
199 	if (sc->version == RK_GPIO_TYPE_V1)
200 		RK_GPIO_WRITE(sc, offset, value);
201 	else {
202 		RK_GPIO_WRITE(sc, offset, (value & 0xffff) | 0xffff0000);
203 		RK_GPIO_WRITE(sc, offset + 4, (value >> 16) | 0xffff0000);
204 	}
205 }
206 
207 static int
208 rk_gpio_intr(void *arg)
209 {
210 	struct rk_gpio_softc *sc = (struct rk_gpio_softc *)arg;;
211 	struct trapframe *tf = curthread->td_intr_frame;
212 	uint32_t status;
213 
214 	RK_GPIO_LOCK(sc);
215 	status = rk_gpio_read_4(sc, RK_GPIO_INT_STATUS);
216 	rk_gpio_write_4(sc, RK_GPIO_PORTA_EOI, status);
217 	RK_GPIO_UNLOCK(sc);
218 
219 	while (status) {
220 		int pin = ffs(status) - 1;
221 
222 		status &= ~(1 << pin);
223 		if (intr_isrc_dispatch(RK_GPIO_ISRC(sc, pin), tf)) {
224 			device_printf(sc->sc_dev, "Interrupt pin=%d unhandled\n",
225 			    pin);
226 			continue;
227 		}
228 
229 		if ((sc->version == RK_GPIO_TYPE_V1) &&
230 		    (sc->isrcs[pin].mode & GPIO_INTR_EDGE_BOTH)) {
231 			RK_GPIO_LOCK(sc);
232 			if (rk_gpio_read_bit(sc, RK_GPIO_EXT_PORTA, pin))
233 				rk_gpio_write_bit(sc, RK_GPIO_INT_POLARITY,
234 				    (1 << pin), 0);
235 			else
236 				rk_gpio_write_bit(sc, RK_GPIO_INT_POLARITY,
237 				    (1 << pin), 1);
238 			RK_GPIO_UNLOCK(sc);
239 		}
240 	}
241 	return (FILTER_HANDLED);
242 }
243 
244 static int
245 rk_gpio_probe(device_t dev)
246 {
247 
248 	if (!ofw_bus_status_okay(dev))
249 		return (ENXIO);
250 
251 	if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
252 		return (ENXIO);
253 
254 	device_set_desc(dev, "RockChip GPIO Bank controller");
255 	return (BUS_PROBE_DEFAULT);
256 }
257 
258 static int
259 rk_gpio_attach(device_t dev)
260 {
261 	struct rk_gpio_softc *sc;
262 	phandle_t parent_node, node;
263 	int err, i;
264 
265 	sc = device_get_softc(dev);
266 	sc->sc_dev = dev;
267 	sc->pinctrl = device_get_parent(dev);
268 	parent_node = ofw_bus_get_node(sc->pinctrl);
269 
270 	node = ofw_bus_get_node(sc->sc_dev);
271 	if (!OF_hasprop(node, "gpio-controller"))
272 		return (ENXIO);
273 
274 	mtx_init(&sc->sc_mtx, "rk gpio", "gpio", MTX_SPIN);
275 
276 	if (bus_alloc_resources(dev, rk_gpio_spec, sc->sc_res)) {
277 		device_printf(dev, "could not allocate resources\n");
278 		bus_release_resources(dev, rk_gpio_spec, sc->sc_res);
279 		mtx_destroy(&sc->sc_mtx);
280 		return (ENXIO);
281 	}
282 
283 	sc->sc_bst = rman_get_bustag(sc->sc_res[0]);
284 	sc->sc_bsh = rman_get_bushandle(sc->sc_res[0]);
285 
286 	if (clk_get_by_ofw_index(dev, 0, 0, &sc->clk) != 0) {
287 		device_printf(dev, "Cannot get clock\n");
288 		rk_gpio_detach(dev);
289 		return (ENXIO);
290 	}
291 	err = clk_enable(sc->clk);
292 	if (err != 0) {
293 		device_printf(dev, "Could not enable clock %s\n",
294 		    clk_get_name(sc->clk));
295 		rk_gpio_detach(dev);
296 		return (ENXIO);
297 	}
298 
299 	if ((err = bus_setup_intr(dev, sc->sc_res[1],
300 	    INTR_TYPE_MISC | INTR_MPSAFE, rk_gpio_intr, NULL,
301 	    sc, &sc->ihandle))) {
302 		device_printf(dev, "Can not setup IRQ\n");
303 		rk_gpio_detach(dev);
304 		return (ENXIO);
305 	}
306 
307 	/*
308 	 * RK3568 has GPIO_VER_ID register, however both
309 	 * RK3328 and RK3399 doesn't have. So choose the
310 	 * version based on parent's compat string.
311 	 */
312 	if (ofw_bus_node_is_compatible(parent_node, "rockchip,rk3568-pinctrl"))
313 		sc->version = RK_GPIO_TYPE_V2;
314 	else
315 		sc->version = RK_GPIO_TYPE_V1;
316 
317 	switch (sc->version) {
318 	case RK_GPIO_TYPE_V1:
319 		sc->regs[RK_GPIO_SWPORTA_DR] = 0x00;
320 		sc->regs[RK_GPIO_SWPORTA_DDR] = 0x04;
321 		sc->regs[RK_GPIO_INTEN] = 0x30;
322 		sc->regs[RK_GPIO_INTMASK] = 0x34;
323 		sc->regs[RK_GPIO_INTTYPE_LEVEL] = 0x38;
324 		sc->regs[RK_GPIO_INT_POLARITY] = 0x3c;
325 		sc->regs[RK_GPIO_INT_STATUS] = 0x40;
326 		sc->regs[RK_GPIO_INT_RAWSTATUS] = 0x44;
327 		sc->regs[RK_GPIO_DEBOUNCE] = 0x48;
328 		sc->regs[RK_GPIO_PORTA_EOI] = 0x4c;
329 		sc->regs[RK_GPIO_EXT_PORTA] = 0x50;
330 		break;
331 	case RK_GPIO_TYPE_V2:
332 		sc->regs[RK_GPIO_SWPORTA_DR] = 0x00;
333 		sc->regs[RK_GPIO_SWPORTA_DDR] = 0x08;
334 		sc->regs[RK_GPIO_INTEN] = 0x10;
335 		sc->regs[RK_GPIO_INTMASK] = 0x18;
336 		sc->regs[RK_GPIO_INTTYPE_LEVEL] = 0x20;
337 		sc->regs[RK_GPIO_INTTYPE_BOTH] = 0x30;
338 		sc->regs[RK_GPIO_INT_POLARITY] = 0x28;
339 		sc->regs[RK_GPIO_INT_STATUS] = 0x50;
340 		sc->regs[RK_GPIO_INT_RAWSTATUS] = 0x58;
341 		sc->regs[RK_GPIO_DEBOUNCE] = 0x38;
342 		sc->regs[RK_GPIO_PORTA_EOI] = 0x60;
343 		sc->regs[RK_GPIO_EXT_PORTA] = 0x70;
344 		break;
345 	default:
346 		device_printf(dev, "Unknown gpio version %08x\n", sc->version);
347 		rk_gpio_detach(dev);
348 		return (ENXIO);
349 	}
350 
351 	for (i = 0; i < RK_GPIO_MAX_PINS; i++) {
352 		sc->isrcs[i].irq = i;
353 		sc->isrcs[i].mode = GPIO_INTR_CONFORM;
354 		if ((err = intr_isrc_register(RK_GPIO_ISRC(sc, i),
355 		    dev, 0, "%s", device_get_nameunit(dev)))) {
356 			device_printf(dev, "Can not register isrc %d\n", err);
357 			rk_gpio_detach(dev);
358 			return (ENXIO);
359 		}
360 	}
361 
362 	if (intr_pic_register(dev, OF_xref_from_node(node)) == NULL) {
363 		device_printf(dev, "Can not register pic\n");
364 		rk_gpio_detach(dev);
365 		return (ENXIO);
366 	}
367 
368 	sc->sc_busdev = gpiobus_attach_bus(dev);
369 	if (sc->sc_busdev == NULL) {
370 		rk_gpio_detach(dev);
371 		return (ENXIO);
372 	}
373 
374 	/* Set the cached value to unknown */
375 	for (i = 0; i < RK_GPIO_MAX_PINS; i++)
376 		sc->pin_cached[i].is_gpio = 2;
377 
378 	RK_GPIO_LOCK(sc);
379 	sc->swporta = rk_gpio_read_4(sc, RK_GPIO_SWPORTA_DR);
380 	sc->swporta_ddr = rk_gpio_read_4(sc, RK_GPIO_SWPORTA_DDR);
381 	RK_GPIO_UNLOCK(sc);
382 
383 	return (0);
384 }
385 
386 static int
387 rk_gpio_detach(device_t dev)
388 {
389 	struct rk_gpio_softc *sc;
390 
391 	sc = device_get_softc(dev);
392 
393 	if (sc->sc_busdev)
394 		gpiobus_detach_bus(dev);
395 	bus_release_resources(dev, rk_gpio_spec, sc->sc_res);
396 	mtx_destroy(&sc->sc_mtx);
397 	clk_disable(sc->clk);
398 
399 	return(0);
400 }
401 
402 static device_t
403 rk_gpio_get_bus(device_t dev)
404 {
405 	struct rk_gpio_softc *sc;
406 
407 	sc = device_get_softc(dev);
408 
409 	return (sc->sc_busdev);
410 }
411 
412 static int
413 rk_gpio_pin_max(device_t dev, int *maxpin)
414 {
415 
416 	/* Each bank have always 32 pins */
417 	/* XXX not true*/
418 	*maxpin = 31;
419 	return (0);
420 }
421 
422 static int
423 rk_gpio_pin_getname(device_t dev, uint32_t pin, char *name)
424 {
425 	struct rk_gpio_softc *sc;
426 	uint32_t bank;
427 
428 	sc = device_get_softc(dev);
429 
430 	if (pin >= 32)
431 		return (EINVAL);
432 
433 	bank = pin / 8;
434 	pin = pin - (bank * 8);
435 	RK_GPIO_LOCK(sc);
436 	snprintf(name, GPIOMAXNAME, "P%c%d", bank + 'A', pin);
437 	RK_GPIO_UNLOCK(sc);
438 
439 	return (0);
440 }
441 
442 static int
443 rk_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags)
444 {
445 	struct rk_gpio_softc *sc;
446 	int rv;
447 
448 	sc = device_get_softc(dev);
449 
450 	if (__predict_false(sc->pin_cached[pin].is_gpio != 1)) {
451 		rv = FDT_PINCTRL_IS_GPIO(sc->pinctrl, dev, pin, (bool *)&sc->pin_cached[pin].is_gpio);
452 		if (rv != 0)
453 			return (rv);
454 		if (sc->pin_cached[pin].is_gpio == 0)
455 			return (EINVAL);
456 	}
457 	*flags = 0;
458 	rv = FDT_PINCTRL_GET_FLAGS(sc->pinctrl, dev, pin, flags);
459 	if (rv != 0)
460 		return (rv);
461 	sc->pin_cached[pin].flags = *flags;
462 
463 	if (sc->swporta_ddr & (1 << pin))
464 		*flags |= GPIO_PIN_OUTPUT;
465 	else
466 		*flags |= GPIO_PIN_INPUT;
467 
468 	return (0);
469 }
470 
471 static int
472 rk_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps)
473 {
474 
475 	if (pin >= RK_GPIO_MAX_PINS)
476 		return EINVAL;
477 
478 	*caps = RK_GPIO_DEFAULT_CAPS;
479 	return (0);
480 }
481 
482 static int
483 rk_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags)
484 {
485 	struct rk_gpio_softc *sc;
486 	int rv;
487 
488 	sc = device_get_softc(dev);
489 
490 	if (pin >= RK_GPIO_MAX_PINS)
491 		return (EINVAL);
492 
493 	if (__predict_false(sc->pin_cached[pin].is_gpio != 1)) {
494 		rv = FDT_PINCTRL_IS_GPIO(sc->pinctrl, dev, pin, (bool *)&sc->pin_cached[pin].is_gpio);
495 		if (rv != 0)
496 			return (rv);
497 		if (sc->pin_cached[pin].is_gpio == 0)
498 			return (EINVAL);
499 	}
500 
501 	if (__predict_false((flags & GPIO_PIN_INPUT) && ((flags & GPIO_FLAGS_PINCTRL) != sc->pin_cached[pin].flags))) {
502 		rv = FDT_PINCTRL_SET_FLAGS(sc->pinctrl, dev, pin, flags);
503 		sc->pin_cached[pin].flags = flags & GPIO_FLAGS_PINCTRL;
504 		if (rv != 0)
505 			return (rv);
506 	}
507 
508 	RK_GPIO_LOCK(sc);
509 	if (flags & GPIO_PIN_INPUT)
510 		sc->swporta_ddr &= ~(1 << pin);
511 	else if (flags & GPIO_PIN_OUTPUT)
512 		sc->swporta_ddr |= (1 << pin);
513 
514 	rk_gpio_write_4(sc, RK_GPIO_SWPORTA_DDR, sc->swporta_ddr);
515 	RK_GPIO_UNLOCK(sc);
516 
517 	return (0);
518 }
519 
520 static int
521 rk_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val)
522 {
523 	struct rk_gpio_softc *sc;
524 
525 	sc = device_get_softc(dev);
526 
527 	if (pin >= RK_GPIO_MAX_PINS)
528 		return (EINVAL);
529 
530 	RK_GPIO_LOCK(sc);
531 	*val = rk_gpio_read_bit(sc, RK_GPIO_EXT_PORTA, pin);
532 	RK_GPIO_UNLOCK(sc);
533 
534 	return (0);
535 }
536 
537 static int
538 rk_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value)
539 {
540 	struct rk_gpio_softc *sc;
541 
542 	sc = device_get_softc(dev);
543 
544 	if (pin >= RK_GPIO_MAX_PINS)
545 		return (EINVAL);
546 
547 	RK_GPIO_LOCK(sc);
548 	if (value)
549 		sc->swporta |= (1 << pin);
550 	else
551 		sc->swporta &= ~(1 << pin);
552 	rk_gpio_write_4(sc, RK_GPIO_SWPORTA_DR, sc->swporta);
553 	RK_GPIO_UNLOCK(sc);
554 
555 	return (0);
556 }
557 
558 static int
559 rk_gpio_pin_toggle(device_t dev, uint32_t pin)
560 {
561 	struct rk_gpio_softc *sc;
562 
563 	sc = device_get_softc(dev);
564 
565 	if (pin >= RK_GPIO_MAX_PINS)
566 		return (EINVAL);
567 
568 	RK_GPIO_LOCK(sc);
569 	if (sc->swporta & (1 << pin))
570 		sc->swporta &= ~(1 << pin);
571 	else
572 		sc->swporta |= (1 << pin);
573 	rk_gpio_write_4(sc, RK_GPIO_SWPORTA_DR, sc->swporta);
574 	RK_GPIO_UNLOCK(sc);
575 
576 	return (0);
577 }
578 
579 static int
580 rk_gpio_pin_access_32(device_t dev, uint32_t first_pin, uint32_t clear_pins,
581     uint32_t change_pins, uint32_t *orig_pins)
582 {
583 	struct rk_gpio_softc *sc;
584 	uint32_t reg;
585 
586 	sc = device_get_softc(dev);
587 
588 	RK_GPIO_LOCK(sc);
589 	reg = rk_gpio_read_4(sc, RK_GPIO_SWPORTA_DR);
590 	if (orig_pins)
591 		*orig_pins = reg;
592 	sc->swporta = reg;
593 
594 	if ((clear_pins | change_pins) != 0) {
595 		reg = (reg & ~clear_pins) ^ change_pins;
596 		rk_gpio_write_4(sc, RK_GPIO_SWPORTA_DR, reg);
597 	}
598 	RK_GPIO_UNLOCK(sc);
599 
600 	return (0);
601 }
602 
603 static int
604 rk_gpio_pin_config_32(device_t dev, uint32_t first_pin, uint32_t num_pins,
605     uint32_t *pin_flags)
606 {
607 	struct rk_gpio_softc *sc;
608 	uint32_t reg, set, mask, flags;
609 	int i;
610 
611 	sc = device_get_softc(dev);
612 
613 	if (first_pin != 0 || num_pins > 32)
614 		return (EINVAL);
615 
616 	set = 0;
617 	mask = 0;
618 	for (i = 0; i < num_pins; i++) {
619 		mask = (mask << 1) | 1;
620 		flags = pin_flags[i];
621 		if (flags & GPIO_PIN_INPUT) {
622 			set &= ~(1 << i);
623 		} else if (flags & GPIO_PIN_OUTPUT) {
624 			set |= (1 << i);
625 		}
626 	}
627 
628 	RK_GPIO_LOCK(sc);
629 	reg = rk_gpio_read_4(sc, RK_GPIO_SWPORTA_DDR);
630 	reg &= ~mask;
631 	reg |= set;
632 	rk_gpio_write_4(sc, RK_GPIO_SWPORTA_DDR, reg);
633 	sc->swporta_ddr = reg;
634 	RK_GPIO_UNLOCK(sc);
635 
636 	return (0);
637 }
638 
639 static int
640 rk_gpio_map_gpios(device_t bus, phandle_t dev, phandle_t gparent, int gcells,
641     pcell_t *gpios, uint32_t *pin, uint32_t *flags)
642 {
643 
644 	/* The gpios are mapped as <pin flags> */
645 	*pin = gpios[0];
646 	*flags = gpios[1];
647 	return (0);
648 }
649 
650 static phandle_t
651 rk_gpio_get_node(device_t bus, device_t dev)
652 {
653 
654 	/* We only have one child, the GPIO bus, which needs our own node. */
655 	return (ofw_bus_get_node(bus));
656 }
657 
658 static int
659 rk_pic_map_intr(device_t dev, struct intr_map_data *data,
660     struct intr_irqsrc **isrcp)
661 {
662 	struct rk_gpio_softc *sc = device_get_softc(dev);
663 	struct intr_map_data_gpio *gdata;
664 	uint32_t irq;
665 
666 	if (data->type != INTR_MAP_DATA_GPIO) {
667 		device_printf(dev, "Wrong type\n");
668 		return (ENOTSUP);
669 	}
670 	gdata = (struct intr_map_data_gpio *)data;
671 	irq = gdata->gpio_pin_num;
672 	if (irq >= RK_GPIO_MAX_PINS) {
673 		device_printf(dev, "Invalid interrupt %u\n", irq);
674 		return (EINVAL);
675 	}
676 	*isrcp = RK_GPIO_ISRC(sc, irq);
677 	return (0);
678 }
679 
680 static int
681 rk_pic_setup_intr(device_t dev, struct intr_irqsrc *isrc,
682     struct resource *res, struct intr_map_data *data)
683 {
684 	struct rk_gpio_softc *sc = device_get_softc(dev);
685 	struct rk_pin_irqsrc *rkisrc = (struct rk_pin_irqsrc *)isrc;
686 	struct intr_map_data_gpio *gdata;
687 	uint32_t mode;
688 	uint8_t pin;
689 
690 	if (!data) {
691 		device_printf(dev, "No map data\n");
692 		return (ENOTSUP);
693 	}
694 	gdata = (struct intr_map_data_gpio *)data;
695 	mode = gdata->gpio_intr_mode;
696 	pin = gdata->gpio_pin_num;
697 
698 	if (rkisrc->irq != gdata->gpio_pin_num) {
699 		device_printf(dev, "Interrupts don't match\n");
700 		return (EINVAL);
701 	}
702 
703 	if (isrc->isrc_handlers != 0) {
704 		device_printf(dev, "Handler already attached\n");
705 		return (rkisrc->mode == mode ? 0 : EINVAL);
706 	}
707 	rkisrc->mode = mode;
708 
709 	RK_GPIO_LOCK(sc);
710 
711 	switch (mode & GPIO_INTR_MASK) {
712 	case GPIO_INTR_EDGE_RISING:
713 		rk_gpio_write_bit(sc, RK_GPIO_SWPORTA_DDR, pin, 0);
714 		rk_gpio_write_bit(sc, RK_GPIO_INTTYPE_LEVEL, pin, 1);
715 		rk_gpio_write_bit(sc, RK_GPIO_INT_POLARITY, pin, 1);
716 		break;
717 	case GPIO_INTR_EDGE_FALLING:
718 		rk_gpio_write_bit(sc, RK_GPIO_SWPORTA_DDR, pin, 0);
719 		rk_gpio_write_bit(sc, RK_GPIO_INTTYPE_LEVEL, pin, 1);
720 		rk_gpio_write_bit(sc, RK_GPIO_INT_POLARITY, pin, 0);
721 		break;
722 	case GPIO_INTR_EDGE_BOTH:
723 		rk_gpio_write_bit(sc, RK_GPIO_SWPORTA_DDR, pin, 0);
724 		rk_gpio_write_bit(sc, RK_GPIO_INTTYPE_LEVEL, pin, 1);
725 		if (sc->version == RK_GPIO_TYPE_V1) {
726 			if (rk_gpio_read_bit(sc, RK_GPIO_EXT_PORTA, pin))
727 				rk_gpio_write_bit(sc, RK_GPIO_INT_POLARITY,
728 				    pin, 0);
729 			else
730 				rk_gpio_write_bit(sc, RK_GPIO_INT_POLARITY,
731 				    pin, 1);
732 		} else
733 			rk_gpio_write_bit(sc, RK_GPIO_INTTYPE_BOTH, pin, 1);
734 		break;
735 	case GPIO_INTR_LEVEL_HIGH:
736 		rk_gpio_write_bit(sc, RK_GPIO_SWPORTA_DDR, pin, 0);
737 		rk_gpio_write_bit(sc, RK_GPIO_INTTYPE_LEVEL, pin, 0);
738 		rk_gpio_write_bit(sc, RK_GPIO_INT_POLARITY, pin, 1);
739 		break;
740 	case GPIO_INTR_LEVEL_LOW:
741 		rk_gpio_write_bit(sc, RK_GPIO_SWPORTA_DDR, pin, 0);
742 		rk_gpio_write_bit(sc, RK_GPIO_INTTYPE_LEVEL, pin, 0);
743 		rk_gpio_write_bit(sc, RK_GPIO_INT_POLARITY, pin, 0);
744 		break;
745 	default:
746 		rk_gpio_write_bit(sc, RK_GPIO_INTMASK, pin, 1);
747 		rk_gpio_write_bit(sc, RK_GPIO_INTEN, pin, 0);
748 		RK_GPIO_UNLOCK(sc);
749 		return (EINVAL);
750 	}
751 	rk_gpio_write_bit(sc, RK_GPIO_DEBOUNCE, pin, 1);
752 	rk_gpio_write_bit(sc, RK_GPIO_INTMASK, pin, 0);
753 	rk_gpio_write_bit(sc, RK_GPIO_INTEN, pin, 1);
754 	RK_GPIO_UNLOCK(sc);
755 
756 	return (0);
757 }
758 
759 static int
760 rk_pic_teardown_intr(device_t dev, struct intr_irqsrc *isrc,
761     struct resource *res, struct intr_map_data *data)
762 {
763 	struct rk_gpio_softc *sc = device_get_softc(dev);
764 	struct rk_pin_irqsrc *irqsrc;
765 
766 	irqsrc = (struct rk_pin_irqsrc *)isrc;
767 
768 	if (isrc->isrc_handlers == 0) {
769 		irqsrc->mode = GPIO_INTR_CONFORM;
770 		RK_GPIO_LOCK(sc);
771 		rk_gpio_write_bit(sc, RK_GPIO_INTEN, irqsrc->irq, 0);
772 		rk_gpio_write_bit(sc, RK_GPIO_INTMASK, irqsrc->irq, 0);
773 		rk_gpio_write_bit(sc, RK_GPIO_DEBOUNCE, irqsrc->irq, 0);
774 		RK_GPIO_UNLOCK(sc);
775 	}
776 	return (0);
777 }
778 
779 static device_method_t rk_gpio_methods[] = {
780 	/* Device interface */
781 	DEVMETHOD(device_probe,		rk_gpio_probe),
782 	DEVMETHOD(device_attach,	rk_gpio_attach),
783 	DEVMETHOD(device_detach,	rk_gpio_detach),
784 
785 	/* GPIO protocol */
786 	DEVMETHOD(gpio_get_bus,		rk_gpio_get_bus),
787 	DEVMETHOD(gpio_pin_max,		rk_gpio_pin_max),
788 	DEVMETHOD(gpio_pin_getname,	rk_gpio_pin_getname),
789 	DEVMETHOD(gpio_pin_getflags,	rk_gpio_pin_getflags),
790 	DEVMETHOD(gpio_pin_getcaps,	rk_gpio_pin_getcaps),
791 	DEVMETHOD(gpio_pin_setflags,	rk_gpio_pin_setflags),
792 	DEVMETHOD(gpio_pin_get,		rk_gpio_pin_get),
793 	DEVMETHOD(gpio_pin_set,		rk_gpio_pin_set),
794 	DEVMETHOD(gpio_pin_toggle,	rk_gpio_pin_toggle),
795 	DEVMETHOD(gpio_pin_access_32,	rk_gpio_pin_access_32),
796 	DEVMETHOD(gpio_pin_config_32,	rk_gpio_pin_config_32),
797 	DEVMETHOD(gpio_map_gpios,	rk_gpio_map_gpios),
798 
799 	/* Interrupt controller interface */
800 	DEVMETHOD(pic_map_intr,		rk_pic_map_intr),
801 	DEVMETHOD(pic_setup_intr,	rk_pic_setup_intr),
802 	DEVMETHOD(pic_teardown_intr,	rk_pic_teardown_intr),
803 
804 	/* ofw_bus interface */
805 	DEVMETHOD(ofw_bus_get_node,	rk_gpio_get_node),
806 
807 	DEVMETHOD_END
808 };
809 
810 static driver_t rk_gpio_driver = {
811 	"gpio",
812 	rk_gpio_methods,
813 	sizeof(struct rk_gpio_softc),
814 };
815 
816 /*
817  * GPIO driver is always a child of rk_pinctrl driver and should be probed
818  * and attached within rk_pinctrl_attach function. Due to this, bus pass order
819  * must be same as bus pass order of rk_pinctrl driver.
820  */
821 EARLY_DRIVER_MODULE(rk_gpio, simplebus, rk_gpio_driver, 0, 0,
822     BUS_PASS_INTERRUPT + BUS_PASS_ORDER_MIDDLE);
823