The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/mips/rt305x/rt305x_gpio.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 (c) 2010-2011, Aleksandr Rybalko <ray@ddteam.net>
    3  * Copyright (c) 2009, Oleksandr Tymoshenko <gonzo@FreeBSD.org>
    4  * Copyright (c) 2009, Luiz Otavio O Souza. 
    5  * All rights reserved.
    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 unmodified, this list of conditions, and the following
   12  *    disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  */
   29 
   30 /*
   31  * GPIO driver for RT305X SoC.
   32  */
   33 
   34 #include <sys/cdefs.h>
   35 __FBSDID("$FreeBSD: releng/9.0/sys/mips/rt305x/rt305x_gpio.c 220297 2011-04-03 14:39:55Z adrian $");
   36 
   37 #include <sys/param.h>
   38 #include <sys/systm.h>
   39 #include <sys/bus.h>
   40 
   41 #include <sys/kernel.h>
   42 #include <sys/module.h>
   43 #include <sys/rman.h>
   44 #include <sys/lock.h>
   45 #include <sys/mutex.h>
   46 #include <sys/gpio.h>
   47 
   48 #include <machine/bus.h>
   49 #include <machine/resource.h>
   50 #include <mips/rt305x/rt305xreg.h>
   51 #include <mips/rt305x/rt305x_gpio.h>
   52 #include <mips/rt305x/rt305x_gpiovar.h>
   53 #include <mips/rt305x/rt305x_sysctlvar.h>
   54 
   55 #include "gpio_if.h"
   56 
   57 #ifdef  notyet
   58 #define DEFAULT_CAPS    (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT | GPIO_PIN_INVIN | \
   59                          GPIO_PIN_INVOUT | GPIO_PIN_REPORT )
   60 #else
   61 #define DEFAULT_CAPS    (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT | GPIO_PIN_INVIN | \
   62                          GPIO_PIN_INVOUT )
   63 #endif
   64 
   65 /*
   66  * Helpers
   67  */
   68 static void rt305x_gpio_pin_configure(struct rt305x_gpio_softc *sc, 
   69     struct gpio_pin *pin, uint32_t flags);
   70 
   71 /*
   72  * Driver stuff
   73  */
   74 static int rt305x_gpio_probe(device_t dev);
   75 static int rt305x_gpio_attach(device_t dev);
   76 static int rt305x_gpio_detach(device_t dev);
   77 static int rt305x_gpio_intr(void *arg);
   78 
   79 int     rt305x_get_int_mask  (device_t);
   80 void    rt305x_set_int_mask  (device_t, uint32_t);
   81 int     rt305x_get_int_status(device_t);
   82 void    rt305x_set_int_status(device_t, uint32_t);
   83 
   84 /*
   85  * GPIO interface
   86  */
   87 static int rt305x_gpio_pin_max(device_t dev, int *maxpin);
   88 static int rt305x_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps);
   89 static int rt305x_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t
   90     *flags);
   91 static int rt305x_gpio_pin_getname(device_t dev, uint32_t pin, char *name);
   92 static int rt305x_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags);
   93 static int rt305x_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value);
   94 static int rt305x_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val);
   95 static int rt305x_gpio_pin_toggle(device_t dev, uint32_t pin);
   96 
   97 static void
   98 rt305x_gpio_pin_configure(struct rt305x_gpio_softc *sc, struct gpio_pin *pin,
   99     unsigned int flags)
  100 {
  101         GPIO_LOCK(sc);
  102 
  103         /*
  104          * Manage input/output
  105          */
  106         if (flags & (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) {
  107                 pin->gp_flags &= ~(GPIO_PIN_INPUT|GPIO_PIN_OUTPUT);
  108                 if (flags & GPIO_PIN_OUTPUT) {
  109                         pin->gp_flags |= GPIO_PIN_OUTPUT;
  110                         GPIO_BIT_SET(sc, pin->gp_pin, DIR);
  111                 }
  112                 else {
  113                         pin->gp_flags |= GPIO_PIN_INPUT;
  114                         GPIO_BIT_CLR(sc, pin->gp_pin, DIR);
  115                 }
  116         }
  117 
  118         if (flags & GPIO_PIN_INVOUT) {
  119                 pin->gp_flags |= GPIO_PIN_INVOUT;
  120                 GPIO_BIT_SET(sc, pin->gp_pin, POL);
  121         }
  122         else {
  123                 pin->gp_flags &= ~GPIO_PIN_INVOUT;
  124                 GPIO_BIT_CLR(sc, pin->gp_pin, POL);
  125         }
  126 
  127         if (flags & GPIO_PIN_INVIN) {
  128                 pin->gp_flags |= GPIO_PIN_INVIN;
  129                 GPIO_BIT_SET(sc, pin->gp_pin, POL);
  130         }
  131         else {
  132                 pin->gp_flags &= ~GPIO_PIN_INVIN;
  133                 GPIO_BIT_CLR(sc, pin->gp_pin, POL);
  134         }
  135 
  136 #ifdef  notyet
  137         /* Enable interrupt bits for rising/falling transitions */
  138         if (flags & GPIO_PIN_REPORT) {
  139                 pin->gp_flags |= GPIO_PIN_REPORT;
  140                 GPIO_BIT_SET(sc, pin->gp_pin, RENA);
  141                 GPIO_BIT_SET(sc, pin->gp_pin, FENA);
  142                 device_printf(sc->dev, "Will report interrupt on pin %d\n", 
  143                     pin->gp_pin);
  144 
  145         }
  146         else {
  147                 pin->gp_flags &= ~GPIO_PIN_REPORT;
  148                 GPIO_BIT_CLR(sc, pin->gp_pin, RENA);
  149                 GPIO_BIT_CLR(sc, pin->gp_pin, FENA);
  150         }
  151 #else
  152         /* Disable generating interrupts for now */
  153         GPIO_BIT_CLR(sc, pin->gp_pin, RENA);
  154         GPIO_BIT_CLR(sc, pin->gp_pin, FENA);
  155 #endif
  156 
  157         GPIO_UNLOCK(sc);
  158 }
  159 
  160 static int
  161 rt305x_gpio_pin_max(device_t dev, int *maxpin)
  162 {
  163 
  164         *maxpin = NGPIO - 1;
  165         return (0);
  166 }
  167 
  168 static int
  169 rt305x_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps)
  170 {
  171         struct rt305x_gpio_softc *sc = device_get_softc(dev);
  172         int i;
  173 
  174         for (i = 0; i < sc->gpio_npins; i++) {
  175                 if (sc->gpio_pins[i].gp_pin == pin)
  176                         break;
  177         }
  178 
  179         if (i >= sc->gpio_npins)
  180                 return (EINVAL);
  181 
  182         GPIO_LOCK(sc);
  183         *caps = sc->gpio_pins[i].gp_caps;
  184         GPIO_UNLOCK(sc);
  185 
  186         return (0);
  187 }
  188 
  189 static int
  190 rt305x_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags)
  191 {
  192         struct rt305x_gpio_softc *sc = device_get_softc(dev);
  193         int i;
  194 
  195         for (i = 0; i < sc->gpio_npins; i++) {
  196                 if (sc->gpio_pins[i].gp_pin == pin)
  197                         break;
  198         }
  199 
  200         if (i >= sc->gpio_npins)
  201                 return (EINVAL);
  202 
  203         GPIO_LOCK(sc);
  204         *flags = sc->gpio_pins[i].gp_flags;
  205         GPIO_UNLOCK(sc);
  206 
  207         return (0);
  208 }
  209 
  210 static int
  211 rt305x_gpio_pin_getname(device_t dev, uint32_t pin, char *name)
  212 {
  213         struct rt305x_gpio_softc *sc = device_get_softc(dev);
  214         int i;
  215 
  216         for (i = 0; i < sc->gpio_npins; i++) {
  217                 if (sc->gpio_pins[i].gp_pin == pin)
  218                         break;
  219         }
  220 
  221         if (i >= sc->gpio_npins)
  222                 return (EINVAL);
  223 
  224         GPIO_LOCK(sc);
  225         memcpy(name, sc->gpio_pins[i].gp_name, GPIOMAXNAME);
  226         GPIO_UNLOCK(sc);
  227 
  228         return (0);
  229 }
  230 
  231 static int
  232 rt305x_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags)
  233 {
  234         int i;
  235         struct rt305x_gpio_softc *sc = device_get_softc(dev);
  236 
  237         for (i = 0; i < sc->gpio_npins; i++) {
  238                 if (sc->gpio_pins[i].gp_pin == pin)
  239                         break;
  240         }
  241 
  242         if (i >= sc->gpio_npins)
  243                 return (EINVAL);
  244 
  245         /* Filter out unwanted flags */
  246         if ((flags &= sc->gpio_pins[i].gp_caps) != flags)
  247                 return (EINVAL);
  248 
  249         /* Can't mix input/output together */
  250         if ((flags & (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) ==
  251             (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT))
  252                 return (EINVAL);
  253 
  254         rt305x_gpio_pin_configure(sc, &sc->gpio_pins[i], flags);
  255 
  256 
  257         return (0);
  258 }
  259 
  260 static int
  261 rt305x_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value)
  262 {
  263         struct rt305x_gpio_softc *sc = device_get_softc(dev);
  264         int i;
  265 
  266         for (i = 0; i < sc->gpio_npins; i++) {
  267                 if (sc->gpio_pins[i].gp_pin == pin)
  268                         break;
  269         }
  270 
  271         if (i >= sc->gpio_npins)
  272                 return (EINVAL);
  273 
  274 
  275         GPIO_LOCK(sc);
  276         if (value) GPIO_BIT_SET(sc, i, DATA);
  277         else       GPIO_BIT_CLR(sc, i, DATA);
  278         GPIO_UNLOCK(sc);
  279 
  280         return (0);
  281 }
  282 
  283 static int
  284 rt305x_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val)
  285 {
  286         struct rt305x_gpio_softc *sc = device_get_softc(dev);
  287         int i;
  288 
  289         for (i = 0; i < sc->gpio_npins; i++) {
  290                 if (sc->gpio_pins[i].gp_pin == pin)
  291                         break;
  292         }
  293 
  294         if (i >= sc->gpio_npins)
  295                 return (EINVAL);
  296 
  297         GPIO_LOCK(sc);
  298         *val = GPIO_BIT_GET(sc, i, DATA);
  299         GPIO_UNLOCK(sc);
  300 
  301         return (0);
  302 }
  303 
  304 static int
  305 rt305x_gpio_pin_toggle(device_t dev, uint32_t pin)
  306 {
  307         int i;
  308         struct rt305x_gpio_softc *sc = device_get_softc(dev);
  309 
  310         for (i = 0; i < sc->gpio_npins; i++) {
  311                 if (sc->gpio_pins[i].gp_pin == pin)
  312                         break;
  313         }
  314 
  315         if (i >= sc->gpio_npins)
  316                 return (EINVAL);
  317 
  318         GPIO_LOCK(sc);
  319         GPIO_BIT_SET(sc, i, TOG);
  320         GPIO_UNLOCK(sc);
  321 
  322         return (0);
  323 }
  324 
  325 static int
  326 rt305x_gpio_intr(void *arg)
  327 {
  328         struct rt305x_gpio_softc *sc = arg;
  329 #ifdef  notyet
  330         uint32_t i;
  331 #endif
  332         uint64_t input, value;
  333 #ifdef  notyet
  334         uint64_t reset_pin;
  335         char notify[16];
  336         char pinname[6];
  337 #endif
  338 
  339         /* Read all reported pins */
  340         input  = GPIO_READ_ALL(sc, INT);
  341         /* Clear int status */
  342         GPIO_WRITE_ALL(sc, INT, input);
  343         /* Clear report for OUTs */
  344         input &= ~GPIO_READ_ALL(sc, DIR);
  345         value = input & GPIO_READ_ALL(sc, DATA);
  346 
  347         if (!input) goto intr_done;
  348 
  349 #ifdef  notyet
  350         /* if reset_gpio and this pin is input */
  351         if (sc->reset_gpio >= 0  && (input & (1 << sc->reset_gpio))) {
  352                 /* get reset_gpio pin value */
  353                 reset_pin = (value & (1 << sc->reset_gpio))?1:0;
  354                 if ( sc->reset_gpio_last != reset_pin ) {
  355                         /*
  356                          * if now reset is high, check how long
  357                          * and do reset if less than 2 seconds
  358                          */
  359                         if ( reset_pin && 
  360                             (time_uptime - sc->reset_gpio_ontime) < 2 )
  361                                 shutdown_nice(0);
  362 
  363                         sc->reset_gpio_last = reset_pin;
  364                         sc->reset_gpio_ontime = time_uptime;
  365                 }
  366         }
  367 
  368         for ( i = 0; i < NGPIO; i ++ )
  369         {
  370                 /* Next if output pin */
  371                 if ( !(( input >> i) & 1) ) continue;
  372 
  373                 if ( (((value & input) >> i) & 1) != sc->gpio_pins[i].gp_last )
  374                 {
  375                         /* !system=GPIO subsystem=pin7 type=PIN_HIGH period=3 */
  376                         snprintf(notify , sizeof(notify ), "period=%d", 
  377                             (uint32_t)time_uptime - sc->gpio_pins[i].gp_time);
  378                         snprintf(pinname, sizeof(pinname), "pin%02d", i);
  379                         devctl_notify("GPIO", pinname, 
  380                             (((value & input) >> i) & 1)?"PIN_HIGH":"PIN_LOW", 
  381                             notify);
  382                         printf("GPIO[%s] %s %s\n", pinname, 
  383                             (((value & input) >> i) & 1)?"PIN_HIGH":"PIN_LOW", 
  384                             notify);
  385                         sc->gpio_pins[i].gp_last = ((value & input) >> i) & 1;
  386                         sc->gpio_pins[i].gp_time = time_uptime;
  387                 }
  388 
  389         }
  390 #endif
  391 
  392 intr_done:
  393         return (FILTER_HANDLED);
  394 }
  395 
  396 static int
  397 rt305x_gpio_probe(device_t dev)
  398 {
  399         device_set_desc(dev, "RT305X GPIO driver");
  400         return (0);
  401 }
  402 
  403 static uint64_t
  404 rt305x_gpio_init(device_t dev)
  405 {
  406         uint64_t avl = ~0ULL;
  407         uint32_t gmode = rt305x_sysctl_get(SYSCTL_GPIOMODE);
  408         if (!(gmode & SYSCTL_GPIOMODE_RGMII_GPIO_MODE))
  409                 avl &= ~RGMII_GPIO_MODE_MASK;
  410         if (!(gmode & SYSCTL_GPIOMODE_SDRAM_GPIO_MODE))
  411                 avl &= ~SDRAM_GPIO_MODE_MASK;
  412         if (!(gmode & SYSCTL_GPIOMODE_MDIO_GPIO_MODE))
  413                 avl &= ~MDIO_GPIO_MODE_MASK;
  414         if (!(gmode & SYSCTL_GPIOMODE_JTAG_GPIO_MODE))
  415                 avl &= ~JTAG_GPIO_MODE_MASK;
  416         if (!(gmode & SYSCTL_GPIOMODE_UARTL_GPIO_MODE))
  417                 avl &= ~UARTL_GPIO_MODE_MASK;
  418         if (!(gmode & SYSCTL_GPIOMODE_SPI_GPIO_MODE))
  419                 avl &= ~SPI_GPIO_MODE_MASK;
  420         if (!(gmode & SYSCTL_GPIOMODE_I2C_GPIO_MODE))
  421                 avl &= ~I2C_GPIO_MODE_MASK;
  422         if ((gmode & SYSCTL_GPIOMODE_UARTF_SHARE_MODE_GPIO) != 
  423             SYSCTL_GPIOMODE_UARTF_SHARE_MODE_GPIO)
  424                 avl &= ~I2C_GPIO_MODE_MASK;
  425 /* D-Link DAP-1350 Board have
  426  * MDIO_GPIO_MODE
  427  * UARTF_GPIO_MODE
  428  * SPI_GPIO_MODE
  429  * I2C_GPIO_MODE
  430  * So we have 
  431  * 00000001 10000000 01111111 11111110
  432 */
  433         return (avl);
  434 
  435 }
  436 
  437 #define DAP1350_RESET_GPIO      10
  438 
  439 static int
  440 rt305x_gpio_attach(device_t dev)
  441 {
  442         struct rt305x_gpio_softc *sc = device_get_softc(dev);
  443         int error = 0, i;
  444         uint64_t avlpins = 0;
  445         sc->reset_gpio = DAP1350_RESET_GPIO;
  446 
  447         KASSERT((device_get_unit(dev) == 0),
  448             ("rt305x_gpio_gpio: Only one gpio module supported"));
  449 
  450         mtx_init(&sc->gpio_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK,
  451             MTX_DEF);
  452 
  453         /* Map control/status registers. */
  454         sc->gpio_mem_rid = 0;
  455         sc->gpio_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
  456             &sc->gpio_mem_rid, RF_ACTIVE);
  457 
  458         if (sc->gpio_mem_res == NULL) {
  459                 device_printf(dev, "couldn't map memory\n");
  460                 error = ENXIO;
  461                 rt305x_gpio_detach(dev);
  462                 return(error);
  463         }
  464 
  465         if ((sc->gpio_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, 
  466             &sc->gpio_irq_rid, RF_SHAREABLE | RF_ACTIVE)) == NULL) {
  467                 device_printf(dev, "unable to allocate IRQ resource\n");
  468                 return (ENXIO);
  469         }
  470 
  471         if ((bus_setup_intr(dev, sc->gpio_irq_res, INTR_TYPE_MISC, 
  472             /* rt305x_gpio_filter, */
  473             rt305x_gpio_intr, NULL, sc, &sc->gpio_ih))) {
  474                 device_printf(dev,
  475                     "WARNING: unable to register interrupt handler\n");
  476                 return (ENXIO);
  477         }
  478 
  479         sc->dev = dev;
  480         avlpins = rt305x_gpio_init(dev);
  481 
  482         /* Configure all pins as input */
  483         /* disable interrupts for all pins */
  484         /* TODO */
  485 
  486         sc->gpio_npins = NGPIO;
  487         resource_int_value(device_get_name(dev), device_get_unit(dev), 
  488             "pins", &sc->gpio_npins);
  489 
  490         for (i = 0; i < sc->gpio_npins; i++) {
  491                 sc->gpio_pins[i].gp_pin = i;
  492                 sc->gpio_pins[i].gp_caps = DEFAULT_CAPS;
  493                 sc->gpio_pins[i].gp_flags = 0;
  494         }
  495 
  496         /* Setup reset pin interrupt */
  497         if (TUNABLE_INT_FETCH("reset_gpio", &sc->reset_gpio)) {
  498                 device_printf(dev, "\tHinted reset_gpio %d\n", sc->reset_gpio);
  499         }
  500 #ifdef  notyet
  501         if (sc->reset_gpio != -1) {
  502                 rt305x_gpio_pin_setflags(dev, sc->reset_gpio, 
  503                     GPIO_PIN_INPUT|GPIO_PIN_INVOUT|
  504                     GPIO_PIN_INVOUT|GPIO_PIN_REPORT);
  505                 device_printf(dev, "\tUse reset_gpio %d\n", sc->reset_gpio);
  506         }
  507 #else
  508         if (sc->reset_gpio != -1) {
  509                 rt305x_gpio_pin_setflags(dev, sc->reset_gpio, 
  510                     GPIO_PIN_INPUT|GPIO_PIN_INVOUT);
  511                 device_printf(dev, "\tUse reset_gpio %d\n", sc->reset_gpio);
  512         }
  513 #endif
  514 
  515         device_add_child(dev, "gpioc", device_get_unit(dev));
  516         device_add_child(dev, "gpiobus", device_get_unit(dev));
  517 
  518 
  519         return (bus_generic_attach(dev));
  520 }
  521 
  522 static int
  523 rt305x_gpio_detach(device_t dev)
  524 {
  525         struct rt305x_gpio_softc *sc = device_get_softc(dev);
  526 
  527         KASSERT(mtx_initialized(&sc->gpio_mtx), ("gpio mutex not initialized"));
  528 
  529         bus_generic_detach(dev);
  530 
  531         if (sc->gpio_mem_res)
  532                 bus_release_resource(dev, SYS_RES_MEMORY, sc->gpio_mem_rid,
  533                     sc->gpio_mem_res);
  534 
  535         mtx_destroy(&sc->gpio_mtx);
  536 
  537         return(0);
  538 }
  539 
  540 #ifdef notyet
  541 static struct resource *
  542 rt305x_gpio_alloc_resource(device_t bus, device_t child, int type, int *rid,
  543     u_long start, u_long end, u_long count, u_int flags)
  544 {
  545         struct obio_softc               *sc = device_get_softc(bus);
  546         struct resource                 *rv;
  547         struct rman                     *rm;
  548 
  549         switch (type) {
  550         case SYS_RES_GPIO:
  551                 rm = &sc->gpio_rman;
  552                 break;
  553         default:
  554                 printf("%s: unknown resource type %d\n", __func__, type);
  555                 return (0);
  556         }
  557 
  558         rv = rman_reserve_resource(rm, start, end, count, flags, child);
  559         if (rv == 0) {
  560                 printf("%s: could not reserve resource\n", __func__);
  561                 return (0);
  562         }
  563 
  564         rman_set_rid(rv, *rid);
  565 
  566         return (rv);
  567 }
  568 
  569 static int
  570 rt305x_gpio_activate_resource(device_t bus, device_t child, int type, int rid,
  571     struct resource *r)
  572 {
  573 
  574         return (rman_activate_resource(r));
  575 }
  576 
  577 static int
  578 rt305x_gpio_deactivate_resource(device_t bus, device_t child, int type, int rid,
  579     struct resource *r)
  580 {
  581 
  582         return (rman_deactivate_resource(r));
  583 }
  584 
  585 static int
  586 rt305x_gpio_release_resource(device_t dev, device_t child, int type,
  587     int rid, struct resource *r)
  588 {
  589         rman_release_resource(r);
  590         return (0);
  591 }
  592 #endif
  593 
  594 static device_method_t rt305x_gpio_methods[] = {
  595         DEVMETHOD(device_probe,         rt305x_gpio_probe),
  596         DEVMETHOD(device_attach,        rt305x_gpio_attach),
  597         DEVMETHOD(device_detach,        rt305x_gpio_detach),
  598 
  599         /* GPIO protocol */
  600         DEVMETHOD(gpio_pin_max,         rt305x_gpio_pin_max),
  601         DEVMETHOD(gpio_pin_getname,     rt305x_gpio_pin_getname),
  602         DEVMETHOD(gpio_pin_getflags,    rt305x_gpio_pin_getflags),
  603         DEVMETHOD(gpio_pin_getcaps,     rt305x_gpio_pin_getcaps),
  604         DEVMETHOD(gpio_pin_setflags,    rt305x_gpio_pin_setflags),
  605         DEVMETHOD(gpio_pin_get,         rt305x_gpio_pin_get),
  606         DEVMETHOD(gpio_pin_set,         rt305x_gpio_pin_set),
  607         DEVMETHOD(gpio_pin_toggle,      rt305x_gpio_pin_toggle),
  608         {0, 0},
  609 };
  610 
  611 static driver_t rt305x_gpio_driver = {
  612         "gpio",
  613         rt305x_gpio_methods,
  614         sizeof(struct rt305x_gpio_softc),
  615 };
  616 static devclass_t rt305x_gpio_devclass;
  617 
  618 DRIVER_MODULE(rt305x_gpio, obio, rt305x_gpio_driver, 
  619     rt305x_gpio_devclass, 0, 0);

Cache object: 2e5d373327fcfdfeee711d5a8d99926b


[ 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.