mtk_gpio_v1.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * Copyright 2016 Stanislav Galabov
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    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.
   13  *
   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
   24  * SUCH DAMAGE.
   25  */
   26 
   27 #include <sys/cdefs.h>
   28 __FBSDID("$FreeBSD$");
   29         
   30 #include "opt_platform.h"
   31 
   32 #include <sys/param.h>
   33 #include <sys/systm.h>
   34 #include <sys/conf.h>
   35 #include <sys/bus.h>
   36 #include <sys/kernel.h>
   37 #include <sys/module.h>
   38 #include <sys/lock.h>
   39 #include <sys/mutex.h>
   40 #include <sys/proc.h>
   41 #include <sys/resource.h>
   42 #include <sys/gpio.h>
   43                 
   44 #include <machine/bus.h>
   45 #include <machine/intr.h>
   46 
   47 #include <mips/mediatek/mtk_soc.h>
   48                 
   49 #include <dev/gpio/gpiobusvar.h>
   50                 
   51 #include <dev/fdt/fdt_common.h>
   52 #include <dev/ofw/ofw_bus.h>
   53 #include <dev/ofw/ofw_bus_subr.h>
   54 
   55 #include <gnu/dts/include/dt-bindings/interrupt-controller/irq.h>
   56 
   57 #include "gpio_if.h"
   58 #include "pic_if.h"
   59 
   60 #define MTK_GPIO_PINS 32
   61 
   62 enum mtk_gpio_regs {
   63         GPIO_PIOINT = 0,
   64         GPIO_PIOEDGE,
   65         GPIO_PIORENA,
   66         GPIO_PIOFENA,
   67         GPIO_PIODATA,
   68         GPIO_PIODIR,
   69         GPIO_PIOPOL,
   70         GPIO_PIOSET,
   71         GPIO_PIORESET,
   72         GPIO_PIOTOG,
   73         GPIO_PIOMAX
   74 };
   75 
   76 struct mtk_gpio_pin_irqsrc {
   77         struct intr_irqsrc      isrc;
   78         u_int                   irq;
   79 };
   80 
   81 struct mtk_gpio_pin {
   82         uint32_t                        pin_caps;
   83         uint32_t                        pin_flags;
   84         enum intr_trigger               intr_trigger;
   85         enum intr_polarity              intr_polarity;
   86         char                            pin_name[GPIOMAXNAME];
   87         struct mtk_gpio_pin_irqsrc      pin_irqsrc;
   88 };
   89 
   90 struct mtk_gpio_softc {
   91         device_t                dev;
   92         device_t                busdev;
   93         struct resource         *res[2];
   94         struct mtx              mtx;
   95         struct mtk_gpio_pin     pins[MTK_GPIO_PINS];
   96         void                    *intrhand;
   97 
   98         uint8_t         regs[GPIO_PIOMAX];
   99         uint32_t                num_pins;
  100         uint8_t                 do_remap;
  101 };
  102 
  103 #define PIC_INTR_ISRC(sc, irq)  (&(sc)->pins[(irq)].pin_irqsrc.isrc)
  104 
  105 static struct resource_spec mtk_gpio_spec[] = {
  106         { SYS_RES_MEMORY, 0, RF_ACTIVE },
  107         { SYS_RES_IRQ,    0, RF_ACTIVE | RF_SHAREABLE },
  108         { -1, 0 }
  109 };
  110 
  111 static int mtk_gpio_probe(device_t dev);
  112 static int mtk_gpio_attach(device_t dev);
  113 static int mtk_gpio_detach(device_t dev);
  114 static int mtk_gpio_intr(void *arg);
  115 
  116 #define MTK_GPIO_LOCK(sc)               mtx_lock_spin(&(sc)->mtx)
  117 #define MTK_GPIO_UNLOCK(sc)             mtx_unlock_spin(&(sc)->mtx)
  118 #define MTK_GPIO_LOCK_INIT(sc)          \
  119     mtx_init(&(sc)->mtx, device_get_nameunit((sc)->dev),        \
  120     "mtk_gpio", MTX_SPIN)
  121 #define MTK_GPIO_LOCK_DESTROY(sc)       mtx_destroy(&(sc)->mtx)
  122 
  123 #define MTK_WRITE_4(sc, reg, val)       \
  124     bus_write_4((sc)->res[0], (sc)->regs[(reg)], (val))
  125 #define MTK_READ_4(sc, reg)             \
  126     bus_read_4((sc)->res[0], (sc)->regs[(reg)])
  127 
  128 static struct ofw_compat_data compat_data[] = {
  129         { "ralink,rt2880-gpio",         1 },
  130         { "ralink,rt3050-gpio",         1 },
  131         { "ralink,rt3352-gpio",         1 },
  132         { "ralink,rt3883-gpio",         1 },
  133         { "ralink,rt5350-gpio",         1 },
  134         { "ralink,mt7620a-gpio",        1 },
  135         { NULL,                         0 }
  136 };
  137 
  138 static int
  139 mtk_gpio_probe(device_t dev)
  140 {
  141         phandle_t node;
  142 
  143         if (!ofw_bus_status_okay(dev))
  144                 return (ENXIO);
  145 
  146         if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
  147                 return (ENXIO);
  148 
  149         node = ofw_bus_get_node(dev);
  150         if (!OF_hasprop(node, "gpio-controller"))
  151                 return (ENXIO);
  152 
  153         device_set_desc(dev, "MTK GPIO Controller (v1)");
  154 
  155         return (BUS_PROBE_DEFAULT);
  156 }
  157 
  158 static int
  159 mtk_pic_register_isrcs(struct mtk_gpio_softc *sc)
  160 {
  161         int error;
  162         uint32_t irq;
  163         struct intr_irqsrc *isrc;
  164         const char *name;
  165 
  166         name = device_get_nameunit(sc->dev);
  167         for (irq = 0; irq < sc->num_pins; irq++) {
  168                 sc->pins[irq].pin_irqsrc.irq = irq;
  169                 isrc = PIC_INTR_ISRC(sc, irq);
  170                 error = intr_isrc_register(isrc, sc->dev, 0, "%s", name);
  171                 if (error != 0) {
  172                         /* XXX call intr_isrc_deregister */
  173                         device_printf(sc->dev, "%s failed", __func__);
  174                         return (error);
  175                 }
  176         }
  177 
  178         return (0);
  179 }
  180 
  181 static int
  182 mtk_gpio_pin_set_direction(struct mtk_gpio_softc *sc, uint32_t pin,
  183     uint32_t dir)
  184 {
  185         uint32_t regval, mask = (1u << pin);
  186 
  187         if (!(sc->pins[pin].pin_caps & dir))
  188                 return (EINVAL);
  189 
  190         regval = MTK_READ_4(sc, GPIO_PIODIR);
  191         if (dir == GPIO_PIN_INPUT)
  192                 regval &= ~mask;
  193         else
  194                 regval |= mask;
  195         MTK_WRITE_4(sc, GPIO_PIODIR, regval);
  196 
  197         sc->pins[pin].pin_flags &= ~(GPIO_PIN_INPUT | GPIO_PIN_OUTPUT);
  198         sc->pins[pin].pin_flags |= dir;
  199 
  200         return (0);
  201 }
  202 
  203 static int
  204 mtk_gpio_pin_set_invert(struct mtk_gpio_softc *sc, uint32_t pin, uint32_t val)
  205 {
  206         uint32_t regval, mask = (1u << pin);
  207 
  208         regval = MTK_READ_4(sc, GPIO_PIOPOL);
  209         if (val)
  210                 regval |= mask;
  211         else
  212                 regval &= ~mask;
  213         MTK_WRITE_4(sc, GPIO_PIOPOL, regval);
  214         sc->pins[pin].pin_flags &= ~(GPIO_PIN_INVIN | GPIO_PIN_INVOUT);
  215         sc->pins[pin].pin_flags |= val;
  216 
  217         return (0);
  218 }
  219 
  220 static void
  221 mtk_gpio_pin_probe(struct mtk_gpio_softc *sc, uint32_t pin)
  222 {
  223         uint32_t mask = (1u << pin);
  224         uint32_t val;
  225 
  226         /* Clear cached gpio config */
  227         sc->pins[pin].pin_flags = 0;
  228 
  229         val = MTK_READ_4(sc, GPIO_PIORENA) |
  230             MTK_READ_4(sc, GPIO_PIOFENA);
  231         if (val & mask) {
  232                 /* Pin is in interrupt mode */
  233                 sc->pins[pin].intr_trigger = INTR_TRIGGER_EDGE;
  234                 val = MTK_READ_4(sc, GPIO_PIORENA);
  235                 if (val & mask)
  236                         sc->pins[pin].intr_polarity = INTR_POLARITY_HIGH;
  237                 else
  238                         sc->pins[pin].intr_polarity = INTR_POLARITY_LOW;
  239         }
  240 
  241         val = MTK_READ_4(sc, GPIO_PIODIR);
  242         if (val & mask)
  243                 sc->pins[pin].pin_flags |= GPIO_PIN_OUTPUT;
  244         else
  245                 sc->pins[pin].pin_flags |= GPIO_PIN_INPUT;
  246 
  247         val = MTK_READ_4(sc, GPIO_PIOPOL);
  248         if (val & mask) {
  249                 if (sc->pins[pin].pin_flags & GPIO_PIN_INPUT) {
  250                         sc->pins[pin].pin_flags |= GPIO_PIN_INVIN;
  251                 } else {
  252                         sc->pins[pin].pin_flags |= GPIO_PIN_INVOUT;
  253                 }
  254         }
  255 }
  256 
  257 static int
  258 mtk_gpio_attach(device_t dev)
  259 {
  260         struct mtk_gpio_softc *sc;
  261         phandle_t node;
  262         uint32_t i, num_pins;
  263 
  264         sc = device_get_softc(dev);
  265         sc->dev = dev;
  266 
  267         if (bus_alloc_resources(dev, mtk_gpio_spec, sc->res)) {
  268                 device_printf(dev, "could not allocate resources for device\n");
  269                 return (ENXIO);
  270         }
  271 
  272         MTK_GPIO_LOCK_INIT(sc);
  273 
  274         node = ofw_bus_get_node(dev);
  275 
  276         if (OF_hasprop(node, "clocks"))
  277                 mtk_soc_start_clock(dev);
  278         if (OF_hasprop(node, "resets"))
  279                 mtk_soc_reset_device(dev);
  280 
  281         if (OF_getprop(node, "ralink,register-map", sc->regs,
  282             GPIO_PIOMAX) <= 0) {
  283                 device_printf(dev, "Failed to read register map\n");
  284                 return (ENXIO);
  285         }
  286 
  287         if (OF_hasprop(node, "ralink,num-gpios") && (OF_getencprop(node,
  288             "ralink,num-gpios", &num_pins, sizeof(num_pins)) >= 0))
  289                 sc->num_pins = num_pins;
  290         else
  291                 sc->num_pins = MTK_GPIO_PINS;
  292 
  293         for (i = 0; i < sc->num_pins; i++) {
  294                 sc->pins[i].pin_caps |= GPIO_PIN_INPUT | GPIO_PIN_OUTPUT |
  295                     GPIO_PIN_INVIN | GPIO_PIN_INVOUT |
  296                     GPIO_INTR_EDGE_RISING | GPIO_INTR_EDGE_FALLING;
  297                 sc->pins[i].intr_polarity = INTR_POLARITY_HIGH;
  298                 sc->pins[i].intr_trigger = INTR_TRIGGER_EDGE;
  299 
  300                 snprintf(sc->pins[i].pin_name, GPIOMAXNAME - 1, "gpio%c%d",
  301                     device_get_unit(dev) + 'a', i);
  302                 sc->pins[i].pin_name[GPIOMAXNAME - 1] = '\0';
  303 
  304                 mtk_gpio_pin_probe(sc, i);
  305         }
  306 
  307         if (mtk_pic_register_isrcs(sc) != 0) {
  308                 device_printf(dev, "could not register PIC ISRCs\n");
  309                 goto fail;
  310         }
  311 
  312         if (intr_pic_register(dev, OF_xref_from_node(node)) == NULL) {
  313                 device_printf(dev, "could not register PIC\n");
  314                 goto fail;
  315         }
  316 
  317         if (bus_setup_intr(dev, sc->res[1], INTR_TYPE_MISC | INTR_MPSAFE,
  318             mtk_gpio_intr, NULL, sc, &sc->intrhand) != 0)
  319                 goto fail_pic;
  320 
  321         sc->busdev = gpiobus_attach_bus(dev);
  322         if (sc->busdev == NULL)
  323                 goto fail_pic;
  324 
  325         return (0);
  326 fail_pic:
  327         intr_pic_deregister(dev, OF_xref_from_node(node));
  328 fail:
  329         if(sc->intrhand != NULL)
  330                 bus_teardown_intr(dev, sc->res[1], sc->intrhand);
  331         bus_release_resources(dev, mtk_gpio_spec, sc->res);
  332         MTK_GPIO_LOCK_DESTROY(sc);
  333         return (ENXIO);
  334 }
  335 
  336 static int
  337 mtk_gpio_detach(device_t dev)
  338 {
  339         struct mtk_gpio_softc *sc = device_get_softc(dev);
  340         phandle_t node;
  341 
  342         node = ofw_bus_get_node(dev);
  343         intr_pic_deregister(dev, OF_xref_from_node(node));
  344         if (sc->intrhand != NULL)
  345                 bus_teardown_intr(dev, sc->res[1], sc->intrhand);
  346         bus_release_resources(dev, mtk_gpio_spec, sc->res);
  347         MTK_GPIO_LOCK_DESTROY(sc);
  348         return (0);
  349 }
  350 
  351 static device_t
  352 mtk_gpio_get_bus(device_t dev)
  353 {
  354         struct mtk_gpio_softc *sc = device_get_softc(dev);
  355 
  356         return (sc->busdev);
  357 }
  358 
  359 static int
  360 mtk_gpio_pin_max(device_t dev, int *maxpin)
  361 {
  362         struct mtk_gpio_softc *sc = device_get_softc(dev);
  363 
  364         *maxpin = sc->num_pins - 1;
  365 
  366         return (0);
  367 }
  368 
  369 static int
  370 mtk_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps)
  371 {
  372         struct mtk_gpio_softc *sc = device_get_softc(dev);
  373 
  374         if (pin >= sc->num_pins)
  375                 return (EINVAL);
  376 
  377         MTK_GPIO_LOCK(sc);
  378         *caps = sc->pins[pin].pin_caps;
  379         MTK_GPIO_UNLOCK(sc);
  380 
  381         return (0);
  382 }
  383 
  384 static int
  385 mtk_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags)
  386 {
  387         struct mtk_gpio_softc *sc = device_get_softc(dev);
  388 
  389         if (pin >= sc->num_pins)
  390                 return (EINVAL);
  391 
  392         MTK_GPIO_LOCK(sc);
  393         *flags = sc->pins[pin].pin_flags;
  394         MTK_GPIO_UNLOCK(sc);
  395 
  396         return (0);
  397 }
  398 
  399 static int
  400 mtk_gpio_pin_getname(device_t dev, uint32_t pin, char *name)
  401 {
  402         struct mtk_gpio_softc *sc = device_get_softc(dev);
  403 
  404         if (pin >= sc->num_pins)
  405                 return (EINVAL);
  406 
  407         strncpy(name, sc->pins[pin].pin_name, GPIOMAXNAME - 1);
  408         name[GPIOMAXNAME - 1] = '\0';
  409 
  410         return (0);
  411 }
  412 
  413 static int
  414 mtk_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags)
  415 {
  416         struct mtk_gpio_softc *sc;
  417         int retval;
  418 
  419         sc = device_get_softc(dev);
  420 
  421         if (pin >= sc->num_pins)
  422                 return (EINVAL);
  423 
  424         MTK_GPIO_LOCK(sc);
  425         retval = mtk_gpio_pin_set_direction(sc, pin,
  426             flags & (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT));
  427         if (retval == 0)
  428                 retval = mtk_gpio_pin_set_invert(sc, pin,
  429                     flags & (GPIO_PIN_INVIN | GPIO_PIN_INVOUT));
  430         MTK_GPIO_UNLOCK(sc);
  431 
  432         return (retval);
  433 }
  434 
  435 static int
  436 mtk_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value)
  437 {
  438         struct mtk_gpio_softc *sc;
  439         int ret;
  440 
  441         sc = device_get_softc(dev);
  442         ret = 0;
  443 
  444         if (pin >= sc->num_pins)
  445                 return (EINVAL);
  446 
  447         MTK_GPIO_LOCK(sc);
  448         if (value)
  449                 MTK_WRITE_4(sc, GPIO_PIOSET, (1u << pin));
  450         else
  451                 MTK_WRITE_4(sc, GPIO_PIORESET, (1u << pin));
  452         MTK_GPIO_UNLOCK(sc);
  453 
  454         return (ret);
  455 }
  456 
  457 static int
  458 mtk_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val)
  459 {
  460         struct mtk_gpio_softc *sc;
  461         uint32_t data;
  462         int ret;
  463 
  464         sc = device_get_softc(dev);
  465         ret = 0;
  466 
  467         if (pin >= sc->num_pins)
  468                 return (EINVAL);
  469 
  470         MTK_GPIO_LOCK(sc);
  471         data = MTK_READ_4(sc, GPIO_PIODATA);
  472         *val = (data & (1u << pin)) ? 1 : 0;
  473         MTK_GPIO_UNLOCK(sc);
  474 
  475         return (ret);
  476 }
  477 
  478 static int
  479 mtk_gpio_pin_toggle(device_t dev, uint32_t pin)
  480 {
  481         struct mtk_gpio_softc *sc;
  482         int ret;
  483 
  484         sc = device_get_softc(dev);
  485         ret = 0;
  486 
  487         if (pin >= sc->num_pins)
  488                 return (EINVAL);
  489 
  490         MTK_GPIO_LOCK(sc);
  491         if (!(sc->pins[pin].pin_flags & GPIO_PIN_OUTPUT)) {
  492                 ret = EINVAL;
  493                 goto out;
  494         }
  495         MTK_WRITE_4(sc, GPIO_PIOTOG, (1u << pin));
  496 
  497 out:
  498         MTK_GPIO_UNLOCK(sc);
  499 
  500         return (ret);
  501 }
  502 
  503 static int
  504 mtk_gpio_pic_map_fdt(struct mtk_gpio_softc *sc,
  505     struct intr_map_data_fdt *daf, u_int *irqp, uint32_t *modep)
  506 {
  507         u_int irq;
  508 
  509         if (daf->ncells != 1) {
  510                 device_printf(sc->dev, "Invalid #interrupt-cells\n");
  511                 return (EINVAL);
  512         }
  513 
  514         irq = daf->cells[0];
  515 
  516         if (irq >= sc->num_pins) {
  517                 device_printf(sc->dev, "Invalid interrupt number %u\n", irq);
  518                 return (EINVAL);
  519         }
  520 
  521         *irqp = irq;
  522         if (modep != NULL)
  523                 *modep = GPIO_INTR_EDGE_BOTH;
  524 
  525         return (0);
  526 }
  527 
  528 static int
  529 mtk_gpio_pic_map_gpio(struct mtk_gpio_softc *sc,
  530     struct intr_map_data_gpio *dag, u_int *irqp, uint32_t *modep)
  531 {
  532         u_int irq;
  533 
  534         irq = dag->gpio_pin_num;
  535         if (irq >= sc->num_pins) {
  536                 device_printf(sc->dev, "Invalid interrupt number %u\n", irq);
  537                 return (EINVAL);
  538         }
  539 
  540         *irqp = irq;
  541         if (modep != NULL)
  542                 *modep = dag->gpio_intr_mode;
  543 
  544         return (0);
  545 }
  546 
  547 static int
  548 mtk_gpio_pic_map_intr(device_t dev, struct intr_map_data *data,
  549     struct intr_irqsrc **isrcp)
  550 {
  551         int error;
  552         u_int irq;
  553         struct mtk_gpio_softc *sc;
  554 
  555         sc = device_get_softc(dev);
  556         switch (data->type) {
  557         case INTR_MAP_DATA_FDT:
  558                 error = (mtk_gpio_pic_map_fdt(sc, 
  559                     (struct intr_map_data_fdt *)data, &irq, NULL));
  560                 break;
  561         case INTR_MAP_DATA_GPIO:
  562                 error = (mtk_gpio_pic_map_gpio(sc, 
  563                     (struct intr_map_data_gpio *)data, &irq, NULL));
  564                 break;
  565         default:
  566                 error = EINVAL;
  567                 break;
  568         }
  569 
  570         if (error != 0) {
  571                 device_printf(dev, "Invalid map type\n");
  572                 return (error);
  573         }
  574 
  575         *isrcp = PIC_INTR_ISRC(sc, irq);
  576         return (0);
  577 }
  578 
  579 static void
  580 mtk_gpio_pic_enable_intr(device_t dev, struct intr_irqsrc *isrc)
  581 {
  582         struct mtk_gpio_softc *sc;
  583         struct mtk_gpio_pin_irqsrc *pisrc;
  584         uint32_t pin, mask, val;
  585 
  586         sc = device_get_softc(dev);
  587 
  588         pisrc = (struct mtk_gpio_pin_irqsrc *)isrc;
  589         pin = pisrc->irq;
  590         mask = 1u << pin;
  591 
  592         MTK_GPIO_LOCK(sc);
  593 
  594         if (sc->pins[pin].intr_polarity == INTR_POLARITY_LOW) {
  595                 val = MTK_READ_4(sc, GPIO_PIORENA) & ~mask;
  596                 MTK_WRITE_4(sc, GPIO_PIORENA, val);
  597                 val = MTK_READ_4(sc, GPIO_PIOFENA) | mask;
  598                 MTK_WRITE_4(sc, GPIO_PIOFENA, val);
  599         } else {
  600                 val = MTK_READ_4(sc, GPIO_PIOFENA) & ~mask;
  601                 MTK_WRITE_4(sc, GPIO_PIOFENA, val);
  602                 val = MTK_READ_4(sc, GPIO_PIORENA) | mask;
  603                 MTK_WRITE_4(sc, GPIO_PIORENA, val);
  604         }
  605 
  606         MTK_GPIO_UNLOCK(sc);
  607 }
  608 
  609 static void
  610 mtk_gpio_pic_disable_intr(device_t dev, struct intr_irqsrc *isrc)
  611 {
  612         struct mtk_gpio_softc *sc;
  613         struct mtk_gpio_pin_irqsrc *pisrc;
  614         uint32_t pin, mask, val;
  615 
  616         sc = device_get_softc(dev);
  617 
  618         pisrc = (struct mtk_gpio_pin_irqsrc *)isrc;
  619         pin = pisrc->irq;
  620         mask = 1u << pin;
  621 
  622         MTK_GPIO_LOCK(sc);
  623 
  624         val = MTK_READ_4(sc, GPIO_PIORENA) & ~mask;
  625         MTK_WRITE_4(sc, GPIO_PIORENA, val);
  626         val = MTK_READ_4(sc, GPIO_PIOFENA) & ~mask;
  627         MTK_WRITE_4(sc, GPIO_PIOFENA, val);
  628 
  629         MTK_GPIO_UNLOCK(sc);
  630 }
  631 
  632 static void
  633 mtk_gpio_pic_pre_ithread(device_t dev, struct intr_irqsrc *isrc)
  634 {
  635 
  636         mtk_gpio_pic_disable_intr(dev, isrc);
  637 }
  638 
  639 static void
  640 mtk_gpio_pic_post_ithread(device_t dev, struct intr_irqsrc *isrc)
  641 {
  642 
  643         mtk_gpio_pic_enable_intr(dev, isrc);
  644 }
  645 
  646 static void
  647 mtk_gpio_pic_post_filter(device_t dev, struct intr_irqsrc *isrc)
  648 {
  649         struct mtk_gpio_softc *sc;
  650         struct mtk_gpio_pin_irqsrc *pisrc;
  651 
  652         pisrc = (struct mtk_gpio_pin_irqsrc *)isrc;
  653         sc = device_get_softc(dev);
  654         MTK_GPIO_LOCK(sc);
  655         MTK_WRITE_4(sc, GPIO_PIOINT, 1u << pisrc->irq);
  656         MTK_GPIO_UNLOCK(sc);
  657 }
  658 
  659 static int
  660 mtk_gpio_pic_setup_intr(device_t dev, struct intr_irqsrc *isrc,
  661     struct resource *res, struct intr_map_data *data)
  662 {
  663         struct mtk_gpio_softc *sc;
  664         uint32_t val;
  665         int error;
  666         uint32_t mode;
  667         u_int irq;
  668 
  669         if (data == NULL)
  670                 return (ENOTSUP);
  671 
  672         sc = device_get_softc(dev);
  673 
  674         switch (data->type) {
  675         case INTR_MAP_DATA_FDT:
  676                 error = mtk_gpio_pic_map_fdt(sc, 
  677                     (struct intr_map_data_fdt *)data, &irq, &mode);
  678                 break;
  679         case INTR_MAP_DATA_GPIO:
  680                 error = mtk_gpio_pic_map_gpio(sc, 
  681                     (struct intr_map_data_gpio *)data, &irq, &mode);
  682                 break;
  683         default:
  684                 error = ENOTSUP;
  685                 break;
  686         }
  687 
  688         if (error != 0)
  689                 return (error);
  690         
  691         MTK_GPIO_LOCK(sc);
  692         if (mode == GPIO_INTR_EDGE_BOTH || mode == GPIO_INTR_EDGE_RISING) {
  693                 val = MTK_READ_4(sc, GPIO_PIORENA) | (1u << irq);
  694                 MTK_WRITE_4(sc, GPIO_PIORENA, val);
  695         }
  696         if (mode == GPIO_INTR_EDGE_BOTH || mode == GPIO_INTR_EDGE_FALLING) {
  697                 val = MTK_READ_4(sc, GPIO_PIOFENA) | (1u << irq);
  698                 MTK_WRITE_4(sc, GPIO_PIOFENA, val);
  699         }
  700         MTK_GPIO_UNLOCK(sc);
  701         return (0);
  702 }
  703 
  704 static int
  705 mtk_gpio_intr(void *arg)
  706 {
  707         struct mtk_gpio_softc *sc;
  708         uint32_t i, interrupts;
  709 
  710         sc = arg;
  711         interrupts = MTK_READ_4(sc, GPIO_PIOINT);
  712         MTK_WRITE_4(sc, GPIO_PIOINT, interrupts);
  713 
  714         for (i = 0; interrupts != 0; i++, interrupts >>= 1) {
  715                 if ((interrupts & 0x1) == 0)
  716                         continue;
  717                 if (intr_isrc_dispatch(PIC_INTR_ISRC(sc, i),
  718                     curthread->td_intr_frame) != 0) {
  719                         device_printf(sc->dev, "spurious interrupt %d\n", i);
  720                 }
  721         }       
  722 
  723         return (FILTER_HANDLED);
  724 }
  725 
  726 static phandle_t
  727 mtk_gpio_get_node(device_t bus, device_t dev)
  728 {
  729 
  730         /* We only have one child, the GPIO bus, which needs our own node. */
  731         return (ofw_bus_get_node(bus));
  732 }
  733 
  734 static device_method_t mtk_gpio_methods[] = {
  735         /* Device interface */
  736         DEVMETHOD(device_probe,         mtk_gpio_probe),
  737         DEVMETHOD(device_attach,        mtk_gpio_attach),
  738         DEVMETHOD(device_detach,        mtk_gpio_detach),
  739         
  740         /* GPIO protocol */
  741         DEVMETHOD(gpio_get_bus,         mtk_gpio_get_bus),
  742         DEVMETHOD(gpio_pin_max,         mtk_gpio_pin_max),
  743         DEVMETHOD(gpio_pin_getname,     mtk_gpio_pin_getname),
  744         DEVMETHOD(gpio_pin_getflags,    mtk_gpio_pin_getflags),
  745         DEVMETHOD(gpio_pin_getcaps,     mtk_gpio_pin_getcaps),
  746         DEVMETHOD(gpio_pin_setflags,    mtk_gpio_pin_setflags),
  747         DEVMETHOD(gpio_pin_get,         mtk_gpio_pin_get),
  748         DEVMETHOD(gpio_pin_set,         mtk_gpio_pin_set),
  749         DEVMETHOD(gpio_pin_toggle,      mtk_gpio_pin_toggle),
  750 
  751         /* Interrupt controller interface */
  752         DEVMETHOD(pic_disable_intr,     mtk_gpio_pic_disable_intr),
  753         DEVMETHOD(pic_enable_intr,      mtk_gpio_pic_enable_intr),
  754         DEVMETHOD(pic_map_intr,         mtk_gpio_pic_map_intr),
  755         DEVMETHOD(pic_setup_intr,       mtk_gpio_pic_setup_intr),
  756         DEVMETHOD(pic_post_filter,      mtk_gpio_pic_post_filter),
  757         DEVMETHOD(pic_post_ithread,     mtk_gpio_pic_post_ithread),
  758         DEVMETHOD(pic_pre_ithread,      mtk_gpio_pic_pre_ithread),
  759 
  760         /* ofw_bus interface */
  761         DEVMETHOD(ofw_bus_get_node,     mtk_gpio_get_node),
  762 
  763         DEVMETHOD_END
  764 };
  765 
  766 static driver_t mtk_gpio_driver = {
  767         "gpio",
  768         mtk_gpio_methods,
  769         sizeof(struct mtk_gpio_softc),
  770 };
  771 
  772 static devclass_t mtk_gpio_devclass;
  773 
  774 EARLY_DRIVER_MODULE(mtk_gpio_v1, simplebus, mtk_gpio_driver,
  775     mtk_gpio_devclass, 0, 0, BUS_PASS_INTERRUPT + BUS_PASS_ORDER_LATE);
Cache object: 4f04f820145fc40bbfe636ba3c01ef79
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/mips/mediatek/mtk_gpio_v1.c

FreeBSD/Linux Kernel Cross Reference
sys/mips/mediatek/mtk_gpio_v1.c
