sys/arm/ti/ti_gpio.c

   1 /*-
   2  * Copyright (c) 2011 Ben Gray <ben.r.gray@gmail.com>.
   3  * Copyright (c) 2014 Luiz Otavio O Souza <loos@FreeBSD.org>.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 /**
  29  * Beware that the OMAP4 datasheet(s) lists GPIO banks 1-6, whereas the code
  30  * here uses 0-5.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35
  36 #include <sys/param.h>
  37 #include <sys/systm.h>
  38 #include <sys/bus.h>
  39
  40 #include <sys/kernel.h>
  41 #include <sys/module.h>
  42 #include <sys/rman.h>
  43 #include <sys/lock.h>
  44 #include <sys/mutex.h>
  45 #include <sys/gpio.h>
  46 #include <sys/interrupt.h>
  47
  48 #include <machine/bus.h>
  49 #include <machine/resource.h>
  50
  51 #include <arm/ti/ti_cpuid.h>
  52 #include <arm/ti/ti_gpio.h>
  53 #include <arm/ti/ti_scm.h>
  54 #include <arm/ti/ti_prcm.h>
  55 #include <arm/ti/ti_hwmods.h>
  56
  57 #include <dev/fdt/fdt_common.h>
  58 #include <dev/gpio/gpiobusvar.h>
  59 #include <dev/ofw/openfirm.h>
  60 #include <dev/ofw/ofw_bus.h>
  61 #include <dev/ofw/ofw_bus_subr.h>
  62
  63 #include "gpio_if.h"
  64 #include "ti_gpio_if.h"
  65
  66 #if !defined(SOC_OMAP4) && !defined(SOC_TI_AM335X)
  67 #error "Unknown SoC"
  68 #endif
  69
  70 /* Register definitions */
  71 #define TI_GPIO_REVISION                0x0000
  72 #define TI_GPIO_SYSCONFIG               0x0010
  73 #define TI_GPIO_IRQSTATUS_RAW_0         0x0024
  74 #define TI_GPIO_IRQSTATUS_RAW_1         0x0028
  75 #define TI_GPIO_IRQSTATUS_0             0x002C
  76 #define TI_GPIO_IRQSTATUS_1             0x0030
  77 #define TI_GPIO_IRQSTATUS_SET_0         0x0034
  78 #define TI_GPIO_IRQSTATUS_SET_1         0x0038
  79 #define TI_GPIO_IRQSTATUS_CLR_0         0x003C
  80 #define TI_GPIO_IRQSTATUS_CLR_1         0x0040
  81 #define TI_GPIO_IRQWAKEN_0              0x0044
  82 #define TI_GPIO_IRQWAKEN_1              0x0048
  83 #define TI_GPIO_SYSSTATUS               0x0114
  84 #define TI_GPIO_IRQSTATUS1              0x0118
  85 #define TI_GPIO_IRQENABLE1              0x011C
  86 #define TI_GPIO_WAKEUPENABLE            0x0120
  87 #define TI_GPIO_IRQSTATUS2              0x0128
  88 #define TI_GPIO_IRQENABLE2              0x012C
  89 #define TI_GPIO_CTRL                    0x0130
  90 #define TI_GPIO_OE                      0x0134
  91 #define TI_GPIO_DATAIN                  0x0138
  92 #define TI_GPIO_DATAOUT                 0x013C
  93 #define TI_GPIO_LEVELDETECT0            0x0140
  94 #define TI_GPIO_LEVELDETECT1            0x0144
  95 #define TI_GPIO_RISINGDETECT            0x0148
  96 #define TI_GPIO_FALLINGDETECT           0x014C
  97 #define TI_GPIO_DEBOUNCENABLE           0x0150
  98 #define TI_GPIO_DEBOUNCINGTIME          0x0154
  99 #define TI_GPIO_CLEARWKUPENA            0x0180
 100 #define TI_GPIO_SETWKUENA               0x0184
 101 #define TI_GPIO_CLEARDATAOUT            0x0190
 102 #define TI_GPIO_SETDATAOUT              0x0194
 103
 104 /* Other SoC Specific definitions */
 105 #define OMAP4_FIRST_GPIO_BANK           1
 106 #define OMAP4_INTR_PER_BANK             1
 107 #define OMAP4_GPIO_REV                  0x50600801
 108 #define AM335X_FIRST_GPIO_BANK          0
 109 #define AM335X_INTR_PER_BANK            2
 110 #define AM335X_GPIO_REV                 0x50600801
 111 #define PINS_PER_BANK                   32
 112 #define TI_GPIO_MASK(p)                 (1U << ((p) % PINS_PER_BANK))
 113
 114 static int ti_gpio_detach(device_t);
 115
 116 static u_int
 117 ti_first_gpio_bank(void)
 118 {
 119         switch(ti_chip()) {
 120 #ifdef SOC_OMAP4
 121         case CHIP_OMAP_4:
 122                 return (OMAP4_FIRST_GPIO_BANK);
 123 #endif
 124 #ifdef SOC_TI_AM335X
 125         case CHIP_AM335X:
 126                 return (AM335X_FIRST_GPIO_BANK);
 127 #endif
 128         }
 129         return (0);
 130 }
 131
 132 static uint32_t
 133 ti_gpio_rev(void)
 134 {
 135         switch(ti_chip()) {
 136 #ifdef SOC_OMAP4
 137         case CHIP_OMAP_4:
 138                 return (OMAP4_GPIO_REV);
 139 #endif
 140 #ifdef SOC_TI_AM335X
 141         case CHIP_AM335X:
 142                 return (AM335X_GPIO_REV);
 143 #endif
 144         }
 145         return (0);
 146 }
 147
 148 /**
 149  *      Macros for driver mutex locking
 150  */
 151 #define TI_GPIO_LOCK(_sc)               mtx_lock_spin(&(_sc)->sc_mtx)
 152 #define TI_GPIO_UNLOCK(_sc)             mtx_unlock_spin(&(_sc)->sc_mtx)
 153 #define TI_GPIO_LOCK_INIT(_sc)          \
 154         mtx_init(&_sc->sc_mtx, device_get_nameunit((_sc)->sc_dev), \
 155             "ti_gpio", MTX_SPIN)
 156 #define TI_GPIO_LOCK_DESTROY(_sc)       mtx_destroy(&(_sc)->sc_mtx)
 157 #define TI_GPIO_ASSERT_LOCKED(_sc)      mtx_assert(&(_sc)->sc_mtx, MA_OWNED)
 158 #define TI_GPIO_ASSERT_UNLOCKED(_sc)    mtx_assert(&(_sc)->sc_mtx, MA_NOTOWNED)
 159
 160 /**
 161  *      ti_gpio_read_4 - reads a 32-bit value from one of the GPIO registers
 162  *      @sc: GPIO device context
 163  *      @bank: The bank to read from
 164  *      @off: The offset of a register from the GPIO register address range
 165  *
 166  *
 167  *      RETURNS:
 168  *      32-bit value read from the register.
 169  */
 170 static inline uint32_t
 171 ti_gpio_read_4(struct ti_gpio_softc *sc, bus_size_t off)
 172 {
 173         return (bus_read_4(sc->sc_mem_res, off));
 174 }
 175
 176 /**
 177  *      ti_gpio_write_4 - writes a 32-bit value to one of the GPIO registers
 178  *      @sc: GPIO device context
 179  *      @bank: The bank to write to
 180  *      @off: The offset of a register from the GPIO register address range
 181  *      @val: The value to write into the register
 182  *
 183  *      RETURNS:
 184  *      nothing
 185  */
 186 static inline void
 187 ti_gpio_write_4(struct ti_gpio_softc *sc, bus_size_t off,
 188                  uint32_t val)
 189 {
 190         bus_write_4(sc->sc_mem_res, off, val);
 191 }
 192
 193 static inline void
 194 ti_gpio_intr_clr(struct ti_gpio_softc *sc, uint32_t mask)
 195 {
 196
 197         /* We clear both set of registers. */
 198         ti_gpio_write_4(sc, TI_GPIO_IRQSTATUS_CLR_0, mask);
 199         ti_gpio_write_4(sc, TI_GPIO_IRQSTATUS_CLR_1, mask);
 200 }
 201
 202 static inline void
 203 ti_gpio_intr_set(struct ti_gpio_softc *sc, uint32_t mask)
 204 {
 205
 206         /*
 207          * On OMAP4 we unmask only the MPU interrupt and on AM335x we
 208          * also activate only the first interrupt.
 209          */
 210         ti_gpio_write_4(sc, TI_GPIO_IRQSTATUS_SET_0, mask);
 211 }
 212
 213 static inline void
 214 ti_gpio_intr_ack(struct ti_gpio_softc *sc, uint32_t mask)
 215 {
 216
 217         /*
 218          * Acknowledge the interrupt on both registers even if we use only
 219          * the first one.
 220          */
 221         ti_gpio_write_4(sc, TI_GPIO_IRQSTATUS_0, mask);
 222         ti_gpio_write_4(sc, TI_GPIO_IRQSTATUS_1, mask);
 223 }
 224
 225 static inline uint32_t
 226 ti_gpio_intr_status(struct ti_gpio_softc *sc)
 227 {
 228         uint32_t reg;
 229
 230         /* Get the status from both registers. */
 231         reg = ti_gpio_read_4(sc, TI_GPIO_IRQSTATUS_0);
 232         reg |= ti_gpio_read_4(sc, TI_GPIO_IRQSTATUS_1);
 233
 234         return (reg);
 235 }
 236
 237 static device_t
 238 ti_gpio_get_bus(device_t dev)
 239 {
 240         struct ti_gpio_softc *sc;
 241
 242         sc = device_get_softc(dev);
 243
 244         return (sc->sc_busdev);
 245 }
 246
 247 /**
 248  *      ti_gpio_pin_max - Returns the maximum number of GPIO pins
 249  *      @dev: gpio device handle
 250  *      @maxpin: pointer to a value that upon return will contain the maximum number
 251  *               of pins in the device.
 252  *
 253  *
 254  *      LOCKING:
 255  *      No locking required, returns static data.
 256  *
 257  *      RETURNS:
 258  *      Returns 0 on success otherwise an error code
 259  */
 260 static int
 261 ti_gpio_pin_max(device_t dev, int *maxpin)
 262 {
 263
 264         *maxpin = PINS_PER_BANK - 1;
 265
 266         return (0);
 267 }
 268
 269 static int
 270 ti_gpio_valid_pin(struct ti_gpio_softc *sc, int pin)
 271 {
 272
 273         if (pin >= sc->sc_maxpin || sc->sc_mem_res == NULL)
 274                 return (EINVAL);
 275
 276         return (0);
 277 }
 278
 279 /**
 280  *      ti_gpio_pin_getcaps - Gets the capabilties of a given pin
 281  *      @dev: gpio device handle
 282  *      @pin: the number of the pin
 283  *      @caps: pointer to a value that upon return will contain the capabilities
 284  *
 285  *      Currently all pins have the same capability, notably:
 286  *        - GPIO_PIN_INPUT
 287  *        - GPIO_PIN_OUTPUT
 288  *        - GPIO_PIN_PULLUP
 289  *        - GPIO_PIN_PULLDOWN
 290  *
 291  *      LOCKING:
 292  *      No locking required, returns static data.
 293  *
 294  *      RETURNS:
 295  *      Returns 0 on success otherwise an error code
 296  */
 297 static int
 298 ti_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps)
 299 {
 300         struct ti_gpio_softc *sc;
 301
 302         sc = device_get_softc(dev);
 303         if (ti_gpio_valid_pin(sc, pin) != 0)
 304                 return (EINVAL);
 305
 306         *caps = (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT | GPIO_PIN_PULLUP |
 307             GPIO_PIN_PULLDOWN);
 308
 309         return (0);
 310 }
 311
 312 /**
 313  *      ti_gpio_pin_getflags - Gets the current flags of a given pin
 314  *      @dev: gpio device handle
 315  *      @pin: the number of the pin
 316  *      @flags: upon return will contain the current flags of the pin
 317  *
 318  *      Reads the current flags of a given pin, here we actually read the H/W
 319  *      registers to determine the flags, rather than storing the value in the
 320  *      setflags call.
 321  *
 322  *      LOCKING:
 323  *      Internally locks the context
 324  *
 325  *      RETURNS:
 326  *      Returns 0 on success otherwise an error code
 327  */
 328 static int
 329 ti_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags)
 330 {
 331         struct ti_gpio_softc *sc;
 332
 333         sc = device_get_softc(dev);
 334         if (ti_gpio_valid_pin(sc, pin) != 0)
 335                 return (EINVAL);
 336
 337         /* Get the current pin state */
 338         TI_GPIO_LOCK(sc);
 339         TI_GPIO_GET_FLAGS(dev, pin, flags);
 340         TI_GPIO_UNLOCK(sc);
 341
 342         return (0);
 343 }
 344
 345 /**
 346  *      ti_gpio_pin_getname - Gets the name of a given pin
 347  *      @dev: gpio device handle
 348  *      @pin: the number of the pin
 349  *      @name: buffer to put the name in
 350  *
 351  *      The driver simply calls the pins gpio_n, where 'n' is obviously the number
 352  *      of the pin.
 353  *
 354  *      LOCKING:
 355  *      No locking required, returns static data.
 356  *
 357  *      RETURNS:
 358  *      Returns 0 on success otherwise an error code
 359  */
 360 static int
 361 ti_gpio_pin_getname(device_t dev, uint32_t pin, char *name)
 362 {
 363         struct ti_gpio_softc *sc;
 364
 365         sc = device_get_softc(dev);
 366         if (ti_gpio_valid_pin(sc, pin) != 0)
 367                 return (EINVAL);
 368
 369         /* Set a very simple name */
 370         snprintf(name, GPIOMAXNAME, "gpio_%u", pin);
 371         name[GPIOMAXNAME - 1] = '\0';
 372
 373         return (0);
 374 }
 375
 376 /**
 377  *      ti_gpio_pin_setflags - Sets the flags for a given pin
 378  *      @dev: gpio device handle
 379  *      @pin: the number of the pin
 380  *      @flags: the flags to set
 381  *
 382  *      The flags of the pin correspond to things like input/output mode, pull-ups,
 383  *      pull-downs, etc.  This driver doesn't support all flags, only the following:
 384  *        - GPIO_PIN_INPUT
 385  *        - GPIO_PIN_OUTPUT
 386  *        - GPIO_PIN_PULLUP
 387  *        - GPIO_PIN_PULLDOWN
 388  *
 389  *      LOCKING:
 390  *      Internally locks the context
 391  *
 392  *      RETURNS:
 393  *      Returns 0 on success otherwise an error code
 394  */
 395 static int
 396 ti_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags)
 397 {
 398         struct ti_gpio_softc *sc;
 399         uint32_t oe;
 400
 401         sc = device_get_softc(dev);
 402         if (ti_gpio_valid_pin(sc, pin) != 0)
 403                 return (EINVAL);
 404
 405         /* Set the GPIO mode and state */
 406         TI_GPIO_LOCK(sc);
 407         if (TI_GPIO_SET_FLAGS(dev, pin, flags) != 0) {
 408                 TI_GPIO_UNLOCK(sc);
 409                 return (EINVAL);
 410         }
 411
 412         /* If configuring as an output set the "output enable" bit */
 413         oe = ti_gpio_read_4(sc, TI_GPIO_OE);
 414         if (flags & GPIO_PIN_INPUT)
 415                 oe |= TI_GPIO_MASK(pin);
 416         else
 417                 oe &= ~TI_GPIO_MASK(pin);
 418         ti_gpio_write_4(sc, TI_GPIO_OE, oe);
 419         TI_GPIO_UNLOCK(sc);
 420
 421         return (0);
 422 }
 423
 424 /**
 425  *      ti_gpio_pin_set - Sets the current level on a GPIO pin
 426  *      @dev: gpio device handle
 427  *      @pin: the number of the pin
 428  *      @value: non-zero value will drive the pin high, otherwise the pin is
 429  *              driven low.
 430  *
 431  *
 432  *      LOCKING:
 433  *      Internally locks the context
 434  *
 435  *      RETURNS:
 436  *      Returns 0 on success otherwise a error code
 437  */
 438 static int
 439 ti_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value)
 440 {
 441         struct ti_gpio_softc *sc;
 442         uint32_t reg;
 443
 444         sc = device_get_softc(dev);
 445         if (ti_gpio_valid_pin(sc, pin) != 0)
 446                 return (EINVAL);
 447
 448         TI_GPIO_LOCK(sc);
 449         if (value == GPIO_PIN_LOW)
 450                 reg = TI_GPIO_CLEARDATAOUT;
 451         else
 452                 reg = TI_GPIO_SETDATAOUT;
 453         ti_gpio_write_4(sc, reg, TI_GPIO_MASK(pin));
 454         TI_GPIO_UNLOCK(sc);
 455
 456         return (0);
 457 }
 458
 459 /**
 460  *      ti_gpio_pin_get - Gets the current level on a GPIO pin
 461  *      @dev: gpio device handle
 462  *      @pin: the number of the pin
 463  *      @value: pointer to a value that upond return will contain the pin value
 464  *
 465  *      The pin must be configured as an input pin beforehand, otherwise this
 466  *      function will fail.
 467  *
 468  *      LOCKING:
 469  *      Internally locks the context
 470  *
 471  *      RETURNS:
 472  *      Returns 0 on success otherwise a error code
 473  */
 474 static int
 475 ti_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *value)
 476 {
 477         struct ti_gpio_softc *sc;
 478         uint32_t oe, reg, val;
 479
 480         sc = device_get_softc(dev);
 481         if (ti_gpio_valid_pin(sc, pin) != 0)
 482                 return (EINVAL);
 483
 484         /*
 485          * Return data from output latch when set as output and from the
 486          * input register otherwise.
 487          */
 488         TI_GPIO_LOCK(sc);
 489         oe = ti_gpio_read_4(sc, TI_GPIO_OE);
 490         if (oe & TI_GPIO_MASK(pin))
 491                 reg = TI_GPIO_DATAIN;
 492         else
 493                 reg = TI_GPIO_DATAOUT;
 494         val = ti_gpio_read_4(sc, reg);
 495         *value = (val & TI_GPIO_MASK(pin)) ? 1 : 0;
 496         TI_GPIO_UNLOCK(sc);
 497
 498         return (0);
 499 }
 500
 501 /**
 502  *      ti_gpio_pin_toggle - Toggles a given GPIO pin
 503  *      @dev: gpio device handle
 504  *      @pin: the number of the pin
 505  *
 506  *
 507  *      LOCKING:
 508  *      Internally locks the context
 509  *
 510  *      RETURNS:
 511  *      Returns 0 on success otherwise a error code
 512  */
 513 static int
 514 ti_gpio_pin_toggle(device_t dev, uint32_t pin)
 515 {
 516         struct ti_gpio_softc *sc;
 517         uint32_t reg, val;
 518
 519         sc = device_get_softc(dev);
 520         if (ti_gpio_valid_pin(sc, pin) != 0)
 521                 return (EINVAL);
 522
 523         /* Toggle the pin */
 524         TI_GPIO_LOCK(sc);
 525         val = ti_gpio_read_4(sc, TI_GPIO_DATAOUT);
 526         if (val & TI_GPIO_MASK(pin))
 527                 reg = TI_GPIO_CLEARDATAOUT;
 528         else
 529                 reg = TI_GPIO_SETDATAOUT;
 530         ti_gpio_write_4(sc, reg, TI_GPIO_MASK(pin));
 531         TI_GPIO_UNLOCK(sc);
 532
 533         return (0);
 534 }
 535
 536 /**
 537  *      ti_gpio_intr - ISR for all GPIO modules
 538  *      @arg: the soft context pointer
 539  *
 540  *      LOCKING:
 541  *      Internally locks the context
 542  *
 543  */
 544 static int
 545 ti_gpio_intr(void *arg)
 546 {
 547         int bank_last, irq;
 548         struct intr_event *event;
 549         struct ti_gpio_softc *sc;
 550         uint32_t reg;
 551
 552         sc = (struct ti_gpio_softc *)arg;
 553         bank_last = -1;
 554         reg = 0; /* squelch bogus gcc warning */
 555         reg = ti_gpio_intr_status(sc);
 556         for (irq = 0; irq < sc->sc_maxpin; irq++) {
 557                 if ((reg & TI_GPIO_MASK(irq)) == 0)
 558                         continue;
 559                 event = sc->sc_events[irq];
 560                 if (event != NULL && !TAILQ_EMPTY(&event->ie_handlers))
 561                         intr_event_handle(event, NULL);
 562                 else
 563                         device_printf(sc->sc_dev, "Stray IRQ %d\n", irq);
 564                 /* Ack the IRQ Status bit. */
 565                 ti_gpio_intr_ack(sc, TI_GPIO_MASK(irq));
 566         }
 567
 568         return (FILTER_HANDLED);
 569 }
 570
 571 static int
 572 ti_gpio_bank_init(device_t dev)
 573 {
 574         int pin;
 575         struct ti_gpio_softc *sc;
 576         uint32_t flags, reg_oe, rev;
 577         clk_ident_t clk;
 578
 579         sc = device_get_softc(dev);
 580
 581         /* Enable the interface and functional clocks for the module. */
 582         clk = ti_hwmods_get_clock(dev);
 583         if (clk == INVALID_CLK_IDENT) {
 584                 device_printf(dev, "failed to get device id based on ti,hwmods\n");
 585                 return (EINVAL);
 586         }
 587
 588         sc->sc_bank = clk - GPIO1_CLK + ti_first_gpio_bank();
 589         ti_prcm_clk_enable(clk);
 590
 591         /*
 592          * Read the revision number of the module.  TI don't publish the
 593          * actual revision numbers, so instead the values have been
 594          * determined by experimentation.
 595          */
 596         rev = ti_gpio_read_4(sc, TI_GPIO_REVISION);
 597
 598         /* Check the revision. */
 599         if (rev != ti_gpio_rev()) {
 600                 device_printf(dev, "Warning: could not determine the revision "
 601                     "of GPIO module (revision:0x%08x)\n", rev);
 602                 return (EINVAL);
 603         }
 604
 605         /* Disable interrupts for all pins. */
 606         ti_gpio_intr_clr(sc, 0xffffffff);
 607
 608         /* Init OE register based on pads configuration. */
 609         reg_oe = 0xffffffff;
 610         for (pin = 0; pin < PINS_PER_BANK; pin++) {
 611                 TI_GPIO_GET_FLAGS(dev, pin, &flags);
 612                 if (flags & GPIO_PIN_OUTPUT)
 613                         reg_oe &= ~(1UL << pin);
 614         }
 615         ti_gpio_write_4(sc, TI_GPIO_OE, reg_oe);
 616
 617         return (0);
 618 }
 619
 620 /**
 621  *      ti_gpio_attach - attach function for the driver
 622  *      @dev: gpio device handle
 623  *
 624  *      Allocates and sets up the driver context for all GPIO banks.  This function
 625  *      expects the memory ranges and IRQs to already be allocated to the driver.
 626  *
 627  *      LOCKING:
 628  *      None
 629  *
 630  *      RETURNS:
 631  *      Always returns 0
 632  */
 633 static int
 634 ti_gpio_attach(device_t dev)
 635 {
 636         struct ti_gpio_softc *sc;
 637         unsigned int i;
 638         int err;
 639
 640         sc = device_get_softc(dev);
 641         sc->sc_dev = dev;
 642         TI_GPIO_LOCK_INIT(sc);
 643         ti_gpio_pin_max(dev, &sc->sc_maxpin);
 644         sc->sc_maxpin++;
 645
 646         sc->sc_mem_rid = 0;
 647         sc->sc_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
 648             &sc->sc_mem_rid, RF_ACTIVE);
 649         if (!sc->sc_mem_res) {
 650                 device_printf(dev, "Error: could not allocate mem resources\n");
 651                 ti_gpio_detach(dev);
 652                 return (ENXIO);
 653         }
 654
 655         sc->sc_irq_rid = 0;
 656         sc->sc_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ,
 657             &sc->sc_irq_rid, RF_ACTIVE);
 658         if (!sc->sc_irq_res) {
 659                 device_printf(dev, "Error: could not allocate irq resources\n");
 660                 ti_gpio_detach(dev);
 661                 return (ENXIO);
 662         }
 663
 664         /*
 665          * Register our interrupt filter for each of the IRQ resources.
 666          */
 667         if (bus_setup_intr(dev, sc->sc_irq_res,
 668             INTR_TYPE_MISC | INTR_MPSAFE, ti_gpio_intr, NULL, sc,
 669             &sc->sc_irq_hdl) != 0) {
 670                 device_printf(dev,
 671                     "WARNING: unable to register interrupt filter\n");
 672                 ti_gpio_detach(dev);
 673                 return (ENXIO);
 674         }
 675
 676         /*
 677          * Initialize the interrupt settings.  The default is active-low
 678          * interrupts.
 679          */
 680         sc->sc_irq_trigger = malloc(
 681             sizeof(*sc->sc_irq_trigger) * sc->sc_maxpin,
 682             M_DEVBUF, M_WAITOK | M_ZERO);
 683         sc->sc_irq_polarity = malloc(
 684             sizeof(*sc->sc_irq_polarity) * sc->sc_maxpin,
 685             M_DEVBUF, M_WAITOK | M_ZERO);
 686         for (i = 0; i < sc->sc_maxpin; i++) {
 687                 sc->sc_irq_trigger[i] = INTR_TRIGGER_LEVEL;
 688                 sc->sc_irq_polarity[i] = INTR_POLARITY_LOW;
 689         }
 690
 691         sc->sc_events = malloc(sizeof(struct intr_event *) * sc->sc_maxpin,
 692             M_DEVBUF, M_WAITOK | M_ZERO);
 693
 694         sc->sc_mask_args = malloc(sizeof(struct ti_gpio_mask_arg) * sc->sc_maxpin,
 695             M_DEVBUF, M_WAITOK | M_ZERO);
 696
 697         /* We need to go through each block and ensure the clocks are running and
 698          * the module is enabled.  It might be better to do this only when the
 699          * pins are configured which would result in less power used if the GPIO
 700          * pins weren't used ...
 701          */
 702         if (sc->sc_mem_res != NULL) {
 703                 /* Initialize the GPIO module. */
 704                 err = ti_gpio_bank_init(dev);
 705                 if (err != 0) {
 706                         ti_gpio_detach(dev);
 707                         return (err);
 708                 }
 709         }
 710
 711         sc->sc_busdev = gpiobus_attach_bus(dev);
 712         if (sc->sc_busdev == NULL) {
 713                 ti_gpio_detach(dev);
 714                 return (ENXIO);
 715         }
 716
 717         return (0);
 718 }
 719
 720 /**
 721  *      ti_gpio_detach - detach function for the driver
 722  *      @dev: scm device handle
 723  *
 724  *      Allocates and sets up the driver context, this simply entails creating a
 725  *      bus mappings for the SCM register set.
 726  *
 727  *      LOCKING:
 728  *      None
 729  *
 730  *      RETURNS:
 731  *      Always returns 0
 732  */
 733 static int
 734 ti_gpio_detach(device_t dev)
 735 {
 736         struct ti_gpio_softc *sc = device_get_softc(dev);
 737
 738         KASSERT(mtx_initialized(&sc->sc_mtx), ("gpio mutex not initialized"));
 739
 740         /* Disable all interrupts */
 741         if (sc->sc_mem_res != NULL)
 742                 ti_gpio_intr_clr(sc, 0xffffffff);
 743         gpiobus_detach_bus(dev);
 744         if (sc->sc_events)
 745                 free(sc->sc_events, M_DEVBUF);
 746         if (sc->sc_mask_args)
 747                 free(sc->sc_mask_args, M_DEVBUF);
 748         if (sc->sc_irq_polarity)
 749                 free(sc->sc_irq_polarity, M_DEVBUF);
 750         if (sc->sc_irq_trigger)
 751                 free(sc->sc_irq_trigger, M_DEVBUF);
 752         /* Release the memory and IRQ resources. */
 753         if (sc->sc_irq_hdl) {
 754                 bus_teardown_intr(dev, sc->sc_irq_res,
 755                     sc->sc_irq_hdl);
 756         }
 757         bus_release_resource(dev, SYS_RES_IRQ, sc->sc_irq_rid,
 758             sc->sc_irq_res);
 759         bus_release_resource(dev, SYS_RES_MEMORY, sc->sc_mem_rid,
 760             sc->sc_mem_res);
 761         TI_GPIO_LOCK_DESTROY(sc);
 762
 763         return (0);
 764 }
 765
 766 static uint32_t
 767 ti_gpio_intr_reg(struct ti_gpio_softc *sc, int irq)
 768 {
 769
 770         if (ti_gpio_valid_pin(sc, irq) != 0)
 771                 return (0);
 772
 773         if (sc->sc_irq_trigger[irq] == INTR_TRIGGER_LEVEL) {
 774                 if (sc->sc_irq_polarity[irq] == INTR_POLARITY_LOW)
 775                         return (TI_GPIO_LEVELDETECT0);
 776                 else if (sc->sc_irq_polarity[irq] == INTR_POLARITY_HIGH)
 777                         return (TI_GPIO_LEVELDETECT1);
 778         } else if (sc->sc_irq_trigger[irq] == INTR_TRIGGER_EDGE) {
 779                 if (sc->sc_irq_polarity[irq] == INTR_POLARITY_LOW)
 780                         return (TI_GPIO_FALLINGDETECT);
 781                 else if (sc->sc_irq_polarity[irq] == INTR_POLARITY_HIGH)
 782                         return (TI_GPIO_RISINGDETECT);
 783         }
 784
 785         return (0);
 786 }
 787
 788 static void
 789 ti_gpio_mask_irq_internal(struct ti_gpio_softc *sc, int irq)
 790 {
 791         uint32_t reg, val;
 792
 793         if (ti_gpio_valid_pin(sc, irq) != 0)
 794                 return;
 795
 796         TI_GPIO_LOCK(sc);
 797         ti_gpio_intr_clr(sc, TI_GPIO_MASK(irq));
 798         reg = ti_gpio_intr_reg(sc, irq);
 799         if (reg != 0) {
 800                 val = ti_gpio_read_4(sc, reg);
 801                 val &= ~TI_GPIO_MASK(irq);
 802                 ti_gpio_write_4(sc, reg, val);
 803         }
 804         TI_GPIO_UNLOCK(sc);
 805 }
 806
 807 static void
 808 ti_gpio_unmask_irq_internal(struct ti_gpio_softc *sc, int irq)
 809 {
 810         uint32_t reg, val;
 811
 812         if (ti_gpio_valid_pin(sc, irq) != 0)
 813                 return;
 814
 815         TI_GPIO_LOCK(sc);
 816         reg = ti_gpio_intr_reg(sc, irq);
 817         if (reg != 0) {
 818                 val = ti_gpio_read_4(sc, reg);
 819                 val |= TI_GPIO_MASK(irq);
 820                 ti_gpio_write_4(sc, reg, val);
 821                 ti_gpio_intr_set(sc, TI_GPIO_MASK(irq));
 822         }
 823         TI_GPIO_UNLOCK(sc);
 824 }
 825
 826 static void
 827 ti_gpio_mask_irq(void *source)
 828 {
 829         struct ti_gpio_mask_arg *arg = source;
 830
 831         ti_gpio_mask_irq_internal(arg->softc, arg->pin);
 832 }
 833
 834 static void
 835 ti_gpio_unmask_irq(void *source)
 836 {
 837         struct ti_gpio_mask_arg *arg = source;
 838
 839         ti_gpio_unmask_irq_internal(arg->softc, arg->pin);
 840 }
 841
 842 static int
 843 ti_gpio_activate_resource(device_t dev, device_t child, int type, int rid,
 844         struct resource *res)
 845 {
 846         int pin;
 847
 848         if (type != SYS_RES_IRQ)
 849                 return (ENXIO);
 850
 851         /* Unmask the interrupt. */
 852         pin = rman_get_start(res);
 853         ti_gpio_unmask_irq((void *)(uintptr_t)pin);
 854
 855         return (0);
 856 }
 857
 858 static int
 859 ti_gpio_deactivate_resource(device_t dev, device_t child, int type, int rid,
 860         struct resource *res)
 861 {
 862         int pin;
 863
 864         if (type != SYS_RES_IRQ)
 865                 return (ENXIO);
 866
 867         /* Mask the interrupt. */
 868         pin = rman_get_start(res);
 869         ti_gpio_mask_irq((void *)(uintptr_t)pin);
 870
 871         return (0);
 872 }
 873
 874 static int
 875 ti_gpio_config_intr(device_t dev, int irq, enum intr_trigger trig,
 876         enum intr_polarity pol)
 877 {
 878         struct ti_gpio_softc *sc;
 879         uint32_t oldreg, reg, val;
 880
 881         sc = device_get_softc(dev);
 882         if (ti_gpio_valid_pin(sc, irq) != 0)
 883                 return (EINVAL);
 884
 885         /* There is no standard trigger or polarity. */
 886         if (trig == INTR_TRIGGER_CONFORM || pol == INTR_POLARITY_CONFORM)
 887                 return (EINVAL);
 888
 889         TI_GPIO_LOCK(sc);
 890         /*
 891          * TRM recommends add the new event before remove the old one to
 892          * avoid losing interrupts.
 893          */
 894         oldreg = ti_gpio_intr_reg(sc, irq);
 895         sc->sc_irq_trigger[irq] = trig;
 896         sc->sc_irq_polarity[irq] = pol;
 897         reg = ti_gpio_intr_reg(sc, irq);
 898         if (reg != 0) {
 899                 /* Apply the new settings. */
 900                 val = ti_gpio_read_4(sc, reg);
 901                 val |= TI_GPIO_MASK(irq);
 902                 ti_gpio_write_4(sc, reg, val);
 903         }
 904         if (reg != oldreg && oldreg != 0) {
 905                 /* Remove the old settings. */
 906                 val = ti_gpio_read_4(sc, oldreg);
 907                 val &= ~TI_GPIO_MASK(irq);
 908                 ti_gpio_write_4(sc, oldreg, val);
 909         }
 910         TI_GPIO_UNLOCK(sc);
 911
 912         return (0);
 913 }
 914
 915 static int
 916 ti_gpio_setup_intr(device_t dev, device_t child, struct resource *ires,
 917         int flags, driver_filter_t *filt, driver_intr_t *handler,
 918         void *arg, void **cookiep)
 919 {
 920         struct ti_gpio_softc *sc;
 921         struct intr_event *event;
 922         int pin, error;
 923
 924         sc = device_get_softc(dev);
 925         pin = rman_get_start(ires);
 926         if (ti_gpio_valid_pin(sc, pin) != 0)
 927                 panic("%s: bad pin %d", __func__, pin);
 928
 929         event = sc->sc_events[pin];
 930         if (event == NULL) {
 931                 sc->sc_mask_args[pin].softc = sc;
 932                 sc->sc_mask_args[pin].pin = pin;
 933                 error = intr_event_create(&event, (void *)&sc->sc_mask_args[pin], 0,
 934                     pin, ti_gpio_mask_irq, ti_gpio_unmask_irq, NULL, NULL,
 935                     "gpio%d pin%d:", device_get_unit(dev), pin);
 936                 if (error != 0)
 937                         return (error);
 938                 sc->sc_events[pin] = event;
 939         }
 940         intr_event_add_handler(event, device_get_nameunit(child), filt,
 941             handler, arg, intr_priority(flags), flags, cookiep);
 942
 943         return (0);
 944 }
 945
 946 static int
 947 ti_gpio_teardown_intr(device_t dev, device_t child, struct resource *ires,
 948         void *cookie)
 949 {
 950         struct ti_gpio_softc *sc;
 951         int pin, err;
 952
 953         sc = device_get_softc(dev);
 954         pin = rman_get_start(ires);
 955         if (ti_gpio_valid_pin(sc, pin) != 0)
 956                 panic("%s: bad pin %d", __func__, pin);
 957         if (sc->sc_events[pin] == NULL)
 958                 panic("Trying to teardown unoccupied IRQ");
 959         err = intr_event_remove_handler(cookie);
 960         if (!err)
 961                 sc->sc_events[pin] = NULL;
 962
 963         return (err);
 964 }
 965
 966 static phandle_t
 967 ti_gpio_get_node(device_t bus, device_t dev)
 968 {
 969
 970         /* We only have one child, the GPIO bus, which needs our own node. */
 971         return (ofw_bus_get_node(bus));
 972 }
 973
 974 static device_method_t ti_gpio_methods[] = {
 975         DEVMETHOD(device_attach, ti_gpio_attach),
 976         DEVMETHOD(device_detach, ti_gpio_detach),
 977
 978         /* GPIO protocol */
 979         DEVMETHOD(gpio_get_bus, ti_gpio_get_bus),
 980         DEVMETHOD(gpio_pin_max, ti_gpio_pin_max),
 981         DEVMETHOD(gpio_pin_getname, ti_gpio_pin_getname),
 982         DEVMETHOD(gpio_pin_getflags, ti_gpio_pin_getflags),
 983         DEVMETHOD(gpio_pin_getcaps, ti_gpio_pin_getcaps),
 984         DEVMETHOD(gpio_pin_setflags, ti_gpio_pin_setflags),
 985         DEVMETHOD(gpio_pin_get, ti_gpio_pin_get),
 986         DEVMETHOD(gpio_pin_set, ti_gpio_pin_set),
 987         DEVMETHOD(gpio_pin_toggle, ti_gpio_pin_toggle),
 988
 989         /* Bus interface */
 990         DEVMETHOD(bus_activate_resource, ti_gpio_activate_resource),
 991         DEVMETHOD(bus_deactivate_resource, ti_gpio_deactivate_resource),
 992         DEVMETHOD(bus_config_intr, ti_gpio_config_intr),
 993         DEVMETHOD(bus_setup_intr, ti_gpio_setup_intr),
 994         DEVMETHOD(bus_teardown_intr, ti_gpio_teardown_intr),
 995
 996         /* ofw_bus interface */
 997         DEVMETHOD(ofw_bus_get_node, ti_gpio_get_node),
 998
 999         {0, 0},
1000 };
1001
1002 driver_t ti_gpio_driver = {
1003         "gpio",
1004         ti_gpio_methods,
1005         sizeof(struct ti_gpio_softc),
1006 };