2 * Copyright (c) 2016 Michal Meloun <mmel@FreeBSD.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
33 #include "opt_platform.h"
34 #include <sys/param.h>
35 #include <sys/systm.h>
38 #include <sys/kernel.h>
42 #include <sys/module.h>
43 #include <sys/mutex.h>
45 #include <machine/bus.h>
46 #include <machine/intr.h>
47 #include <machine/resource.h>
49 #include <dev/gpio/gpiobusvar.h>
50 #include <dev/ofw/openfirm.h>
51 #include <dev/ofw/ofw_bus.h>
52 #include <dev/ofw/ofw_bus_subr.h>
56 #define GPIO_LOCK(_sc) mtx_lock(&(_sc)->mtx)
57 #define GPIO_UNLOCK(_sc) mtx_unlock(&(_sc)->mtx)
58 #define GPIO_LOCK_INIT(_sc) mtx_init(&_sc->mtx, \
59 device_get_nameunit(_sc->dev), "tegra_gpio", MTX_DEF)
60 #define GPIO_LOCK_DESTROY(_sc) mtx_destroy(&_sc->mtx);
61 #define GPIO_ASSERT_LOCKED(_sc) mtx_assert(&_sc->mtx, MA_OWNED);
62 #define GPIO_ASSERT_UNLOCKED(_sc) mtx_assert(&_sc->mtx, MA_NOTOWNED);
64 #define WR4(_sc, _r, _v) bus_write_4((_sc)->mem_res, (_r), (_v))
65 #define RD4(_sc, _r) bus_read_4((_sc)->mem_res, (_r))
67 #define GPIO_BANK_OFFS 0x100 /* Bank offset */
68 #define GPIO_NUM_BANKS 8 /* Total number per bank */
69 #define GPIO_REGS_IN_BANK 4 /* Total registers in bank */
70 #define GPIO_PINS_IN_REG 8 /* Total pin in register */
72 #define GPIO_BANKNUM(n) ((n) / (GPIO_REGS_IN_BANK * GPIO_PINS_IN_REG))
73 #define GPIO_PORTNUM(n) (((n) / GPIO_PINS_IN_REG) % GPIO_REGS_IN_BANK)
74 #define GPIO_BIT(n) ((n) % GPIO_PINS_IN_REG)
76 #define GPIO_REGNUM(n) (GPIO_BANKNUM(n) * GPIO_BANK_OFFS + \
79 #define NGPIO ((GPIO_NUM_BANKS * GPIO_REGS_IN_BANK * GPIO_PINS_IN_REG) - 8)
81 /* Register offsets */
86 #define GPIO_INT_STA 0x40
87 #define GPIO_INT_ENB 0x50
88 #define GPIO_INT_LVL 0x60
89 #define GPIO_INT_LVL_DELTA (1 << 16)
90 #define GPIO_INT_LVL_EDGE (1 << 8)
91 #define GPIO_INT_LVL_HIGH (1 << 0)
92 #define GPIO_INT_LVL_MASK (GPIO_INT_LVL_DELTA | \
93 GPIO_INT_LVL_EDGE | GPIO_INT_LVL_HIGH)
94 #define GPIO_INT_CLR 0x70
95 #define GPIO_MSK_CNF 0x80
96 #define GPIO_MSK_OE 0x90
97 #define GPIO_MSK_OUT 0xA0
98 #define GPIO_MSK_INT_STA 0xC0
99 #define GPIO_MSK_INT_ENB 0xD0
100 #define GPIO_MSK_INT_LVL 0xE0
102 char *tegra_gpio_port_names[] = {
103 "A", "B", "C", "D", /* Bank 0 */
104 "E", "F", "G", "H", /* Bank 1 */
105 "I", "J", "K", "L", /* Bank 2 */
106 "M", "N", "O", "P", /* Bank 3 */
107 "Q", "R", "S", "T", /* Bank 4 */
108 "U", "V", "W", "X", /* Bank 5 */
109 "Y", "Z", "AA", "BB", /* Bank 6 */
110 "CC", "DD", "EE" /* Bank 7 */
113 struct tegra_gpio_irqsrc {
114 struct intr_irqsrc isrc;
119 struct tegra_gpio_softc;
120 struct tegra_gpio_irq_cookie {
121 struct tegra_gpio_softc *sc;
125 struct tegra_gpio_softc {
129 struct resource *mem_res;
130 struct resource *irq_res[GPIO_NUM_BANKS];
131 void *irq_ih[GPIO_NUM_BANKS];
132 struct tegra_gpio_irq_cookie irq_cookies[GPIO_NUM_BANKS];
134 struct gpio_pin gpio_pins[NGPIO];
135 struct tegra_gpio_irqsrc *isrcs;
138 static struct ofw_compat_data compat_data[] = {
139 {"nvidia,tegra124-gpio", 1},
143 /* --------------------------------------------------------------------------
149 gpio_write_masked(struct tegra_gpio_softc *sc, bus_size_t reg,
150 struct gpio_pin *pin, uint32_t val)
155 bit = GPIO_BIT(pin->gp_pin);
156 tmp = 0x100 << bit; /* mask */
157 tmp |= (val & 1) << bit; /* value */
158 bus_write_4(sc->mem_res, reg + GPIO_REGNUM(pin->gp_pin), tmp);
161 static inline uint32_t
162 gpio_read(struct tegra_gpio_softc *sc, bus_size_t reg, struct gpio_pin *pin)
167 bit = GPIO_BIT(pin->gp_pin);
168 val = bus_read_4(sc->mem_res, reg + GPIO_REGNUM(pin->gp_pin));
169 return (val >> bit) & 1;
173 tegra_gpio_pin_configure(struct tegra_gpio_softc *sc, struct gpio_pin *pin,
177 if ((flags & (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) == 0)
180 /* Manage input/output */
181 pin->gp_flags &= ~(GPIO_PIN_INPUT | GPIO_PIN_OUTPUT);
182 if (flags & GPIO_PIN_OUTPUT) {
183 pin->gp_flags |= GPIO_PIN_OUTPUT;
184 gpio_write_masked(sc, GPIO_MSK_OE, pin, 1);
186 pin->gp_flags |= GPIO_PIN_INPUT;
187 gpio_write_masked(sc, GPIO_MSK_OE, pin, 0);
192 tegra_gpio_get_bus(device_t dev)
194 struct tegra_gpio_softc *sc;
196 sc = device_get_softc(dev);
201 tegra_gpio_pin_max(device_t dev, int *maxpin)
209 tegra_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps)
211 struct tegra_gpio_softc *sc;
213 sc = device_get_softc(dev);
214 if (pin >= sc->gpio_npins)
218 *caps = sc->gpio_pins[pin].gp_caps;
225 tegra_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags)
227 struct tegra_gpio_softc *sc;
230 sc = device_get_softc(dev);
231 if (pin >= sc->gpio_npins)
235 cnf = gpio_read(sc, GPIO_CNF, &sc->gpio_pins[pin]);
240 *flags = sc->gpio_pins[pin].gp_flags;
247 tegra_gpio_pin_getname(device_t dev, uint32_t pin, char *name)
249 struct tegra_gpio_softc *sc;
251 sc = device_get_softc(dev);
252 if (pin >= sc->gpio_npins)
256 memcpy(name, sc->gpio_pins[pin].gp_name, GPIOMAXNAME);
263 tegra_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags)
265 struct tegra_gpio_softc *sc;
268 sc = device_get_softc(dev);
269 if (pin >= sc->gpio_npins)
273 cnf = gpio_read(sc, GPIO_CNF, &sc->gpio_pins[pin]);
275 /* XXX - allow this for while ....
279 gpio_write_masked(sc, GPIO_MSK_CNF, &sc->gpio_pins[pin], 1);
281 tegra_gpio_pin_configure(sc, &sc->gpio_pins[pin], flags);
288 tegra_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value)
290 struct tegra_gpio_softc *sc;
292 sc = device_get_softc(dev);
293 if (pin >= sc->gpio_npins)
296 gpio_write_masked(sc, GPIO_MSK_OUT, &sc->gpio_pins[pin], value);
303 tegra_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val)
305 struct tegra_gpio_softc *sc;
307 sc = device_get_softc(dev);
308 if (pin >= sc->gpio_npins)
312 *val = gpio_read(sc, GPIO_IN, &sc->gpio_pins[pin]);
319 tegra_gpio_pin_toggle(device_t dev, uint32_t pin)
321 struct tegra_gpio_softc *sc;
323 sc = device_get_softc(dev);
324 if (pin >= sc->gpio_npins)
328 gpio_write_masked(sc, GPIO_MSK_OE, &sc->gpio_pins[pin],
329 gpio_read(sc, GPIO_IN, &sc->gpio_pins[pin]) ^ 1);
335 /* --------------------------------------------------------------------------
341 intr_write_masked(struct tegra_gpio_softc *sc, bus_addr_t reg,
342 struct tegra_gpio_irqsrc *tgi, uint32_t val)
347 bit = GPIO_BIT(tgi->irq);
348 tmp = 0x100 << bit; /* mask */
349 tmp |= (val & 1) << bit; /* value */
350 bus_write_4(sc->mem_res, reg + GPIO_REGNUM(tgi->irq), tmp);
354 intr_write_modify(struct tegra_gpio_softc *sc, bus_addr_t reg,
355 struct tegra_gpio_irqsrc *tgi, uint32_t val, uint32_t mask)
360 bit = GPIO_BIT(tgi->irq);
362 tmp = bus_read_4(sc->mem_res, reg + GPIO_REGNUM(tgi->irq));
363 tmp &= ~(mask << bit);
365 bus_write_4(sc->mem_res, reg + GPIO_REGNUM(tgi->irq), tmp);
370 tegra_gpio_isrc_mask(struct tegra_gpio_softc *sc,
371 struct tegra_gpio_irqsrc *tgi, uint32_t val)
374 intr_write_masked(sc, GPIO_MSK_INT_ENB, tgi, val);
378 tegra_gpio_isrc_eoi(struct tegra_gpio_softc *sc,
379 struct tegra_gpio_irqsrc *tgi)
382 intr_write_masked(sc, GPIO_INT_CLR, tgi, 1);
386 tegra_gpio_isrc_is_level(struct tegra_gpio_irqsrc *tgi)
389 return (tgi->cfgreg & GPIO_INT_LVL_EDGE);
393 tegra_gpio_intr(void *arg)
395 u_int irq, i, j, val, basepin;
396 struct tegra_gpio_softc *sc;
397 struct trapframe *tf;
398 struct tegra_gpio_irqsrc *tgi;
399 struct tegra_gpio_irq_cookie *cookie;
401 cookie = (struct tegra_gpio_irq_cookie *)arg;
403 tf = curthread->td_intr_frame;
405 for (i = 0; i < GPIO_REGS_IN_BANK; i++) {
406 basepin = cookie->bank_num * GPIO_REGS_IN_BANK *
407 GPIO_PINS_IN_REG + i * GPIO_PINS_IN_REG;
409 val = bus_read_4(sc->mem_res, GPIO_INT_STA +
410 GPIO_REGNUM(basepin));
411 val &= bus_read_4(sc->mem_res, GPIO_INT_ENB +
412 GPIO_REGNUM(basepin));
413 /* Interrupt handling */
414 for (j = 0; j < GPIO_PINS_IN_REG; j++) {
415 if ((val & (1 << j)) == 0)
418 tgi = &sc->isrcs[irq];
419 if (!tegra_gpio_isrc_is_level(tgi))
420 tegra_gpio_isrc_eoi(sc, tgi);
421 if (intr_isrc_dispatch(&tgi->isrc, tf) != 0) {
422 tegra_gpio_isrc_mask(sc, tgi, 0);
423 if (tegra_gpio_isrc_is_level(tgi))
424 tegra_gpio_isrc_eoi(sc, tgi);
425 device_printf(sc->dev,
426 "Stray irq %u disabled\n", irq);
432 return (FILTER_HANDLED);
436 tegra_gpio_pic_attach(struct tegra_gpio_softc *sc)
442 sc->isrcs = malloc(sizeof(*sc->isrcs) * sc->gpio_npins, M_DEVBUF,
445 name = device_get_nameunit(sc->dev);
446 for (irq = 0; irq < sc->gpio_npins; irq++) {
447 sc->isrcs[irq].irq = irq;
448 sc->isrcs[irq].cfgreg = 0;
449 error = intr_isrc_register(&sc->isrcs[irq].isrc,
450 sc->dev, 0, "%s,%u", name, irq);
452 return (error); /* XXX deregister ISRCs */
454 if (intr_pic_register(sc->dev,
455 OF_xref_from_node(ofw_bus_get_node(sc->dev))) == NULL)
462 tegra_gpio_pic_detach(struct tegra_gpio_softc *sc)
466 * There has not been established any procedure yet
467 * how to detach PIC from living system correctly.
469 device_printf(sc->dev, "%s: not implemented yet\n", __func__);
475 tegra_gpio_pic_disable_intr(device_t dev, struct intr_irqsrc *isrc)
477 struct tegra_gpio_softc *sc;
478 struct tegra_gpio_irqsrc *tgi;
480 sc = device_get_softc(dev);
481 tgi = (struct tegra_gpio_irqsrc *)isrc;
482 tegra_gpio_isrc_mask(sc, tgi, 0);
486 tegra_gpio_pic_enable_intr(device_t dev, struct intr_irqsrc *isrc)
488 struct tegra_gpio_softc *sc;
489 struct tegra_gpio_irqsrc *tgi;
491 sc = device_get_softc(dev);
492 tgi = (struct tegra_gpio_irqsrc *)isrc;
493 tegra_gpio_isrc_mask(sc, tgi, 1);
497 tegra_gpio_pic_map_fdt(struct tegra_gpio_softc *sc, u_int ncells,
498 pcell_t *cells, u_int *irqp, uint32_t *regp)
503 * The first cell is the interrupt number.
504 * The second cell is used to specify flags:
505 * bits[3:0] trigger type and level flags:
506 * 1 = low-to-high edge triggered.
507 * 2 = high-to-low edge triggered.
508 * 4 = active high level-sensitive.
509 * 8 = active low level-sensitive.
511 if (ncells != 2 || cells[0] >= sc->gpio_npins)
515 * All interrupt types could be set for an interrupt at one moment.
516 * At least, the combination of 'low-to-high' and 'high-to-low' edge
517 * triggered interrupt types can make a sense.
520 reg = GPIO_INT_LVL_EDGE | GPIO_INT_LVL_HIGH;
521 else if (cells[1] == 2)
522 reg = GPIO_INT_LVL_EDGE;
523 else if (cells[1] == 3)
524 reg = GPIO_INT_LVL_EDGE | GPIO_INT_LVL_DELTA;
525 else if (cells[1] == 4)
526 reg = GPIO_INT_LVL_HIGH;
527 else if (cells[1] == 8)
540 tegra_gpio_pic_map_gpio(struct tegra_gpio_softc *sc, u_int gpio_pin_num,
541 u_int gpio_pin_flags, u_int intr_mode, u_int *irqp, uint32_t *regp)
546 if (gpio_pin_num >= sc->gpio_npins)
549 case GPIO_INTR_CONFORM:
550 case GPIO_INTR_LEVEL_LOW:
553 case GPIO_INTR_LEVEL_HIGH:
554 reg = GPIO_INT_LVL_HIGH;
556 case GPIO_INTR_EDGE_RISING:
557 reg = GPIO_INT_LVL_EDGE | GPIO_INT_LVL_HIGH;
559 case GPIO_INTR_EDGE_FALLING:
560 reg = GPIO_INT_LVL_EDGE;
562 case GPIO_INTR_EDGE_BOTH:
563 reg = GPIO_INT_LVL_EDGE | GPIO_INT_LVL_DELTA;
568 *irqp = gpio_pin_num;
575 tegra_gpio_pic_map_intr(device_t dev, struct intr_map_data *data,
576 struct intr_irqsrc **isrcp)
580 struct tegra_gpio_softc *sc;
582 sc = device_get_softc(dev);
584 if (data->type == INTR_MAP_DATA_FDT) {
585 struct intr_map_data_fdt *daf;
587 daf = (struct intr_map_data_fdt *)data;
588 rv = tegra_gpio_pic_map_fdt(sc, daf->ncells, daf->cells, &irq,
590 } else if (data->type == INTR_MAP_DATA_GPIO) {
591 struct intr_map_data_gpio *dag;
593 dag = (struct intr_map_data_gpio *)data;
594 rv = tegra_gpio_pic_map_gpio(sc, dag->gpio_pin_num,
595 dag->gpio_pin_flags, dag->gpio_intr_mode, &irq, NULL);
600 *isrcp = &sc->isrcs[irq].isrc;
605 tegra_gpio_pic_post_filter(device_t dev, struct intr_irqsrc *isrc)
607 struct tegra_gpio_softc *sc;
608 struct tegra_gpio_irqsrc *tgi;
610 sc = device_get_softc(dev);
611 tgi = (struct tegra_gpio_irqsrc *)isrc;
612 if (tegra_gpio_isrc_is_level(tgi))
613 tegra_gpio_isrc_eoi(sc, tgi);
617 tegra_gpio_pic_post_ithread(device_t dev, struct intr_irqsrc *isrc)
619 struct tegra_gpio_softc *sc;
620 struct tegra_gpio_irqsrc *tgi;
622 sc = device_get_softc(dev);
623 tgi = (struct tegra_gpio_irqsrc *)isrc;
624 tegra_gpio_isrc_mask(sc, tgi, 1);
628 tegra_gpio_pic_pre_ithread(device_t dev, struct intr_irqsrc *isrc)
630 struct tegra_gpio_softc *sc;
631 struct tegra_gpio_irqsrc *tgi;
633 sc = device_get_softc(dev);
634 tgi = (struct tegra_gpio_irqsrc *)isrc;
636 tegra_gpio_isrc_mask(sc, tgi, 0);
637 if (tegra_gpio_isrc_is_level(tgi))
638 tegra_gpio_isrc_eoi(sc, tgi);
642 tegra_gpio_pic_setup_intr(device_t dev, struct intr_irqsrc *isrc,
643 struct resource *res, struct intr_map_data *data)
648 struct tegra_gpio_softc *sc;
649 struct tegra_gpio_irqsrc *tgi;
651 sc = device_get_softc(dev);
652 tgi = (struct tegra_gpio_irqsrc *)isrc;
657 /* Get and check config for an interrupt. */
658 if (data->type == INTR_MAP_DATA_FDT) {
659 struct intr_map_data_fdt *daf;
661 daf = (struct intr_map_data_fdt *)data;
662 rv = tegra_gpio_pic_map_fdt(sc, daf->ncells, daf->cells, &irq,
664 } else if (data->type == INTR_MAP_DATA_GPIO) {
665 struct intr_map_data_gpio *dag;
667 dag = (struct intr_map_data_gpio *)data;
668 rv = tegra_gpio_pic_map_gpio(sc, dag->gpio_pin_num,
669 dag->gpio_pin_flags, dag->gpio_intr_mode, &irq, &cfgreg);
676 * If this is a setup for another handler,
677 * only check that its configuration match.
679 if (isrc->isrc_handlers != 0)
680 return (tgi->cfgreg == cfgreg ? 0 : EINVAL);
682 tgi->cfgreg = cfgreg;
683 intr_write_modify(sc, GPIO_INT_LVL, tgi, cfgreg, GPIO_INT_LVL_MASK);
684 tegra_gpio_pic_enable_intr(dev, isrc);
690 tegra_gpio_pic_teardown_intr(device_t dev, struct intr_irqsrc *isrc,
691 struct resource *res, struct intr_map_data *data)
693 struct tegra_gpio_softc *sc;
694 struct tegra_gpio_irqsrc *tgi;
696 sc = device_get_softc(dev);
697 tgi = (struct tegra_gpio_irqsrc *)isrc;
699 if (isrc->isrc_handlers == 0)
700 tegra_gpio_isrc_mask(sc, tgi, 0);
705 tegra_gpio_probe(device_t dev)
708 if (!ofw_bus_status_okay(dev))
710 if (ofw_bus_search_compatible(dev, compat_data)->ocd_data != 0) {
711 device_set_desc(dev, "Tegra GPIO Controller");
712 return (BUS_PROBE_DEFAULT);
718 /* --------------------------------------------------------------------------
724 tegra_gpio_detach(device_t dev)
726 struct tegra_gpio_softc *sc;
729 sc = device_get_softc(dev);
731 KASSERT(mtx_initialized(&sc->mtx), ("gpio mutex not initialized"));
733 for (i = 0; i < GPIO_NUM_BANKS; i++) {
734 if (sc->irq_ih[i] != NULL)
735 bus_teardown_intr(dev, sc->irq_res[i], sc->irq_ih[i]);
738 if (sc->isrcs != NULL)
739 tegra_gpio_pic_detach(sc);
741 gpiobus_detach_bus(dev);
743 for (i = 0; i < GPIO_NUM_BANKS; i++) {
744 if (sc->irq_res[i] != NULL)
745 bus_release_resource(dev, SYS_RES_IRQ, 0,
748 if (sc->mem_res != NULL)
749 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res);
750 GPIO_LOCK_DESTROY(sc);
756 tegra_gpio_attach(device_t dev)
758 struct tegra_gpio_softc *sc;
761 sc = device_get_softc(dev);
765 /* Allocate bus_space resources. */
767 sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
769 if (sc->mem_res == NULL) {
770 device_printf(dev, "Cannot allocate memory resources\n");
771 tegra_gpio_detach(dev);
775 sc->gpio_npins = NGPIO;
776 for (i = 0; i < sc->gpio_npins; i++) {
777 sc->gpio_pins[i].gp_pin = i;
778 sc->gpio_pins[i].gp_caps = GPIO_PIN_INPUT | GPIO_PIN_OUTPUT |
779 GPIO_INTR_LEVEL_LOW | GPIO_INTR_LEVEL_HIGH |
780 GPIO_INTR_EDGE_RISING | GPIO_INTR_EDGE_FALLING |
782 snprintf(sc->gpio_pins[i].gp_name, GPIOMAXNAME, "gpio_%s.%d",
783 tegra_gpio_port_names[ i / GPIO_PINS_IN_REG],
784 i % GPIO_PINS_IN_REG);
785 sc->gpio_pins[i].gp_flags =
786 gpio_read(sc, GPIO_OE, &sc->gpio_pins[i]) != 0 ?
787 GPIO_PIN_OUTPUT : GPIO_PIN_INPUT;
790 /* Init interrupt related registes. */
791 for (i = 0; i < sc->gpio_npins; i += GPIO_PINS_IN_REG) {
792 bus_write_4(sc->mem_res, GPIO_INT_ENB + GPIO_REGNUM(i), 0);
793 bus_write_4(sc->mem_res, GPIO_INT_STA + GPIO_REGNUM(i), 0xFF);
794 bus_write_4(sc->mem_res, GPIO_INT_CLR + GPIO_REGNUM(i), 0xFF);
797 /* Allocate interrupts. */
798 for (i = 0; i < GPIO_NUM_BANKS; i++) {
799 sc->irq_cookies[i].sc = sc;
800 sc->irq_cookies[i].bank_num = i;
802 sc->irq_res[i] = bus_alloc_resource_any(dev, SYS_RES_IRQ,
804 if (sc->irq_res[i] == NULL) {
805 device_printf(dev, "Cannot allocate IRQ resources\n");
806 tegra_gpio_detach(dev);
809 if ((bus_setup_intr(dev, sc->irq_res[i],
810 INTR_TYPE_MISC | INTR_MPSAFE, tegra_gpio_intr, NULL,
811 &sc->irq_cookies[i], &sc->irq_ih[i]))) {
813 "WARNING: unable to register interrupt handler\n");
814 tegra_gpio_detach(dev);
819 if (tegra_gpio_pic_attach(sc) != 0) {
820 device_printf(dev, "WARNING: unable to attach PIC\n");
821 tegra_gpio_detach(dev);
825 sc->busdev = gpiobus_attach_bus(dev);
826 if (sc->busdev == NULL) {
827 tegra_gpio_detach(dev);
831 return (bus_generic_attach(dev));
835 tegra_map_gpios(device_t dev, phandle_t pdev, phandle_t gparent,
836 int gcells, pcell_t *gpios, uint32_t *pin, uint32_t *flags)
847 tegra_gpio_get_node(device_t bus, device_t dev)
850 /* We only have one child, the GPIO bus, which needs our own node. */
851 return (ofw_bus_get_node(bus));
854 static device_method_t tegra_gpio_methods[] = {
855 DEVMETHOD(device_probe, tegra_gpio_probe),
856 DEVMETHOD(device_attach, tegra_gpio_attach),
857 DEVMETHOD(device_detach, tegra_gpio_detach),
859 /* Interrupt controller interface */
860 DEVMETHOD(pic_disable_intr, tegra_gpio_pic_disable_intr),
861 DEVMETHOD(pic_enable_intr, tegra_gpio_pic_enable_intr),
862 DEVMETHOD(pic_map_intr, tegra_gpio_pic_map_intr),
863 DEVMETHOD(pic_setup_intr, tegra_gpio_pic_setup_intr),
864 DEVMETHOD(pic_teardown_intr, tegra_gpio_pic_teardown_intr),
865 DEVMETHOD(pic_post_filter, tegra_gpio_pic_post_filter),
866 DEVMETHOD(pic_post_ithread, tegra_gpio_pic_post_ithread),
867 DEVMETHOD(pic_pre_ithread, tegra_gpio_pic_pre_ithread),
870 DEVMETHOD(gpio_get_bus, tegra_gpio_get_bus),
871 DEVMETHOD(gpio_pin_max, tegra_gpio_pin_max),
872 DEVMETHOD(gpio_pin_getname, tegra_gpio_pin_getname),
873 DEVMETHOD(gpio_pin_getflags, tegra_gpio_pin_getflags),
874 DEVMETHOD(gpio_pin_getcaps, tegra_gpio_pin_getcaps),
875 DEVMETHOD(gpio_pin_setflags, tegra_gpio_pin_setflags),
876 DEVMETHOD(gpio_pin_get, tegra_gpio_pin_get),
877 DEVMETHOD(gpio_pin_set, tegra_gpio_pin_set),
878 DEVMETHOD(gpio_pin_toggle, tegra_gpio_pin_toggle),
879 DEVMETHOD(gpio_map_gpios, tegra_map_gpios),
881 /* ofw_bus interface */
882 DEVMETHOD(ofw_bus_get_node, tegra_gpio_get_node),
887 static devclass_t tegra_gpio_devclass;
888 static DEFINE_CLASS_0(gpio, tegra_gpio_driver, tegra_gpio_methods,
889 sizeof(struct tegra_gpio_softc));
890 EARLY_DRIVER_MODULE(tegra_gpio, simplebus, tegra_gpio_driver,
891 tegra_gpio_devclass, NULL, NULL, 70);