sys/arm/xscale/ixp425/avila_gpio.c

   1 /*-
   2  * Copyright (c) 2009, Oleksandr Tymoshenko <gonzo@FreeBSD.org>
   3  * Copyright (c) 2009, Luiz Otavio O Souza.
   4  * Copyright (c) 2010, Andrew Thompson <thompsa@FreeBSD.org>
   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 Gateworks Avilia
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  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 <arm/xscale/ixp425/ixp425reg.h>
  51 #include <arm/xscale/ixp425/ixp425var.h>
  52 #include <dev/gpio/gpiobusvar.h>
  53
  54 #include "gpio_if.h"
  55
  56 #define GPIO_SET_BITS(sc, reg, bits)    \
  57         GPIO_CONF_WRITE_4(sc, reg, GPIO_CONF_READ_4(sc, (reg)) | (bits))
  58
  59 #define GPIO_CLEAR_BITS(sc, reg, bits)  \
  60         GPIO_CONF_WRITE_4(sc, reg, GPIO_CONF_READ_4(sc, (reg)) & ~(bits))
  61
  62 struct avila_gpio_softc {
  63         device_t                sc_dev;
  64         device_t                sc_busdev;
  65         bus_space_tag_t         sc_iot;
  66         bus_space_handle_t      sc_gpio_ioh;
  67         uint32_t                sc_valid;
  68         struct gpio_pin         sc_pins[IXP4XX_GPIO_PINS];
  69 };
  70
  71 struct avila_gpio_pin {
  72         const char *name;
  73         int pin;
  74         int caps;
  75 };
  76
  77 #define GPIO_PIN_IO     (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)
  78 static struct avila_gpio_pin avila_gpio_pins[] = {
  79         { "GPIO0", 0, GPIO_PIN_IO },
  80         { "GPIO1", 1, GPIO_PIN_IO },
  81         { "GPIO2", 2, GPIO_PIN_IO },
  82         { "GPIO3", 3, GPIO_PIN_IO },
  83         { "GPIO4", 4, GPIO_PIN_IO },
  84         /*
  85          * The following pins are connected to system devices and should not
  86          * really be frobbed.
  87          */
  88 #if 0
  89         { "SER_ENA", 5, GPIO_PIN_IO },
  90         { "I2C_SCL", 6, GPIO_PIN_IO },
  91         { "I2C_SDA", 7, GPIO_PIN_IO },
  92         { "PCI_INTD", 8, GPIO_PIN_IO },
  93         { "PCI_INTC", 9, GPIO_PIN_IO },
  94         { "PCI_INTB", 10, GPIO_PIN_IO },
  95         { "PCI_INTA", 11, GPIO_PIN_IO },
  96         { "ATA_INT", 12, GPIO_PIN_IO },
  97         { "PCI_RST", 13, GPIO_PIN_IO },
  98         { "PCI_CLK", 14, GPIO_PIN_OUTPUT },
  99         { "EX_CLK", 15, GPIO_PIN_OUTPUT },
 100 #endif
 101 };
 102 #undef GPIO_PIN_IO
 103
 104 /*
 105  * Helpers
 106  */
 107 static void avila_gpio_pin_configure(struct avila_gpio_softc *sc,
 108     struct gpio_pin *pin, uint32_t flags);
 109 static int  avila_gpio_pin_flags(struct avila_gpio_softc *sc, uint32_t pin);
 110
 111 /*
 112  * Driver stuff
 113  */
 114 static int avila_gpio_probe(device_t dev);
 115 static int avila_gpio_attach(device_t dev);
 116 static int avila_gpio_detach(device_t dev);
 117
 118 /*
 119  * GPIO interface
 120  */
 121 static device_t avila_gpio_get_bus(device_t);
 122 static int avila_gpio_pin_max(device_t dev, int *maxpin);
 123 static int avila_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps);
 124 static int avila_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t
 125     *flags);
 126 static int avila_gpio_pin_getname(device_t dev, uint32_t pin, char *name);
 127 static int avila_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags);
 128 static int avila_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value);
 129 static int avila_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val);
 130 static int avila_gpio_pin_toggle(device_t dev, uint32_t pin);
 131
 132 static int
 133 avila_gpio_pin_flags(struct avila_gpio_softc *sc, uint32_t pin)
 134 {
 135         uint32_t v;
 136
 137         v = GPIO_CONF_READ_4(sc, IXP425_GPIO_GPINR) & (1 << pin);
 138
 139         return (v ? GPIO_PIN_INPUT : GPIO_PIN_OUTPUT);
 140 }
 141
 142 static void
 143 avila_gpio_pin_configure(struct avila_gpio_softc *sc, struct gpio_pin *pin,
 144     unsigned int flags)
 145 {
 146         uint32_t mask;
 147
 148         mask = 1 << pin->gp_pin;
 149
 150         /*
 151          * Manage input/output
 152          */
 153         if (flags & (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) {
 154                 IXP4XX_GPIO_LOCK();
 155                 pin->gp_flags &= ~(GPIO_PIN_INPUT|GPIO_PIN_OUTPUT);
 156                 if (flags & GPIO_PIN_OUTPUT) {
 157                         pin->gp_flags |= GPIO_PIN_OUTPUT;
 158                         GPIO_CLEAR_BITS(sc, IXP425_GPIO_GPOER, mask);
 159                 }
 160                 else {
 161                         pin->gp_flags |= GPIO_PIN_INPUT;
 162                         GPIO_SET_BITS(sc, IXP425_GPIO_GPOER, mask);
 163                 }
 164                 IXP4XX_GPIO_UNLOCK();
 165         }
 166 }
 167
 168 static device_t
 169 avila_gpio_get_bus(device_t dev)
 170 {
 171         struct avila_gpio_softc *sc;
 172
 173         sc = device_get_softc(dev);
 174
 175         return (sc->sc_busdev);
 176 }
 177
 178 static int
 179 avila_gpio_pin_max(device_t dev, int *maxpin)
 180 {
 181
 182         *maxpin = IXP4XX_GPIO_PINS - 1;
 183         return (0);
 184 }
 185
 186 static int
 187 avila_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps)
 188 {
 189         struct avila_gpio_softc *sc = device_get_softc(dev);
 190
 191         if (pin >= IXP4XX_GPIO_PINS || !(sc->sc_valid & (1 << pin)))
 192                 return (EINVAL);
 193
 194         *caps = sc->sc_pins[pin].gp_caps;
 195         return (0);
 196 }
 197
 198 static int
 199 avila_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags)
 200 {
 201         struct avila_gpio_softc *sc = device_get_softc(dev);
 202
 203         if (pin >= IXP4XX_GPIO_PINS || !(sc->sc_valid & (1 << pin)))
 204                 return (EINVAL);
 205
 206         IXP4XX_GPIO_LOCK();
 207         /* refresh since we do not own all the pins */
 208         sc->sc_pins[pin].gp_flags = avila_gpio_pin_flags(sc, pin);
 209         *flags = sc->sc_pins[pin].gp_flags;
 210         IXP4XX_GPIO_UNLOCK();
 211
 212         return (0);
 213 }
 214
 215 static int
 216 avila_gpio_pin_getname(device_t dev, uint32_t pin, char *name)
 217 {
 218         struct avila_gpio_softc *sc = device_get_softc(dev);
 219
 220         if (pin >= IXP4XX_GPIO_PINS || !(sc->sc_valid & (1 << pin)))
 221                 return (EINVAL);
 222
 223         memcpy(name, sc->sc_pins[pin].gp_name, GPIOMAXNAME);
 224         return (0);
 225 }
 226
 227 static int
 228 avila_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags)
 229 {
 230         struct avila_gpio_softc *sc = device_get_softc(dev);
 231         uint32_t mask = 1 << pin;
 232
 233         if (pin >= IXP4XX_GPIO_PINS || !(sc->sc_valid & mask))
 234                 return (EINVAL);
 235
 236         avila_gpio_pin_configure(sc, &sc->sc_pins[pin], flags);
 237
 238         return (0);
 239 }
 240
 241 static int
 242 avila_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value)
 243 {
 244         struct avila_gpio_softc *sc = device_get_softc(dev);
 245         uint32_t mask = 1 << pin;
 246
 247         if (pin >= IXP4XX_GPIO_PINS || !(sc->sc_valid & mask))
 248                 return (EINVAL);
 249
 250         IXP4XX_GPIO_LOCK();
 251         if (value)
 252                 GPIO_SET_BITS(sc, IXP425_GPIO_GPOUTR, mask);
 253         else
 254                 GPIO_CLEAR_BITS(sc, IXP425_GPIO_GPOUTR, mask);
 255         IXP4XX_GPIO_UNLOCK();
 256
 257         return (0);
 258 }
 259
 260 static int
 261 avila_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val)
 262 {
 263         struct avila_gpio_softc *sc = device_get_softc(dev);
 264
 265         if (pin >= IXP4XX_GPIO_PINS || !(sc->sc_valid & (1 << pin)))
 266                 return (EINVAL);
 267
 268         IXP4XX_GPIO_LOCK();
 269         *val = (GPIO_CONF_READ_4(sc, IXP425_GPIO_GPINR) & (1 << pin)) ? 1 : 0;
 270         IXP4XX_GPIO_UNLOCK();
 271
 272         return (0);
 273 }
 274
 275 static int
 276 avila_gpio_pin_toggle(device_t dev, uint32_t pin)
 277 {
 278         struct avila_gpio_softc *sc = device_get_softc(dev);
 279         uint32_t mask = 1 << pin;
 280         int res;
 281
 282         if (pin >= IXP4XX_GPIO_PINS || !(sc->sc_valid & mask))
 283                 return (EINVAL);
 284
 285         IXP4XX_GPIO_LOCK();
 286         res = GPIO_CONF_READ_4(sc, IXP425_GPIO_GPINR) & mask;
 287         if (res)
 288                 GPIO_CLEAR_BITS(sc, IXP425_GPIO_GPOUTR, mask);
 289         else
 290                 GPIO_SET_BITS(sc, IXP425_GPIO_GPOUTR, mask);
 291         IXP4XX_GPIO_UNLOCK();
 292
 293         return (0);
 294 }
 295
 296 static int
 297 avila_gpio_probe(device_t dev)
 298 {
 299
 300         device_set_desc(dev, "Gateworks Avila GPIO driver");
 301         return (0);
 302 }
 303
 304 static int
 305 avila_gpio_attach(device_t dev)
 306 {
 307 #define N(a)    (sizeof(a) / sizeof(a[0]))
 308         struct avila_gpio_softc *sc = device_get_softc(dev);
 309         struct ixp425_softc *sa = device_get_softc(device_get_parent(dev));
 310         int i;
 311
 312         sc->sc_dev = dev;
 313         sc->sc_iot = sa->sc_iot;
 314         sc->sc_gpio_ioh = sa->sc_gpio_ioh;
 315
 316         for (i = 0; i < N(avila_gpio_pins); i++) {
 317                 struct avila_gpio_pin *p = &avila_gpio_pins[i];
 318
 319                 strncpy(sc->sc_pins[p->pin].gp_name, p->name, GPIOMAXNAME);
 320                 sc->sc_pins[p->pin].gp_pin = p->pin;
 321                 sc->sc_pins[p->pin].gp_caps = p->caps;
 322                 sc->sc_pins[p->pin].gp_flags = avila_gpio_pin_flags(sc, p->pin);
 323                 sc->sc_valid |= 1 << p->pin;
 324         }
 325
 326         sc->sc_busdev = gpiobus_attach_bus(dev);
 327         if (sc->sc_busdev == NULL)
 328                 return (ENXIO);
 329
 330         return (0);
 331 #undef N
 332 }
 333
 334 static int
 335 avila_gpio_detach(device_t dev)
 336 {
 337
 338         gpiobus_detach_bus(dev);
 339
 340         return(0);
 341 }
 342
 343 static device_method_t gpio_avila_methods[] = {
 344         DEVMETHOD(device_probe, avila_gpio_probe),
 345         DEVMETHOD(device_attach, avila_gpio_attach),
 346         DEVMETHOD(device_detach, avila_gpio_detach),
 347
 348         /* GPIO protocol */
 349         DEVMETHOD(gpio_get_bus, avila_gpio_get_bus),
 350         DEVMETHOD(gpio_pin_max, avila_gpio_pin_max),
 351         DEVMETHOD(gpio_pin_getname, avila_gpio_pin_getname),
 352         DEVMETHOD(gpio_pin_getflags, avila_gpio_pin_getflags),
 353         DEVMETHOD(gpio_pin_getcaps, avila_gpio_pin_getcaps),
 354         DEVMETHOD(gpio_pin_setflags, avila_gpio_pin_setflags),
 355         DEVMETHOD(gpio_pin_get, avila_gpio_pin_get),
 356         DEVMETHOD(gpio_pin_set, avila_gpio_pin_set),
 357         DEVMETHOD(gpio_pin_toggle, avila_gpio_pin_toggle),
 358         {0, 0},
 359 };
 360
 361 static driver_t gpio_avila_driver = {
 362         "gpio",
 363         gpio_avila_methods,
 364         sizeof(struct avila_gpio_softc),
 365 };
 366 static devclass_t gpio_avila_devclass;
 367
 368 DRIVER_MODULE(gpio_avila, ixp, gpio_avila_driver, gpio_avila_devclass, 0, 0);
 369 MODULE_VERSION(gpio_avila, 1);