sys/arm/ti/ti_gpio.c

   1 /*-
   2  * Copyright (c) 2011
   3  *      Ben Gray <ben.r.gray@gmail.com>.
   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  *      Very simple GPIO (general purpose IO) driver module for TI OMAP SoC's.
  30  *
  31  *      Currently this driver only does the basics, get a value on a pin & set a
  32  *      value on a pin. Hopefully over time I'll expand this to be a bit more generic
  33  *      and support interrupts and other various bits on the SoC can do ... in the
  34  *      meantime this is all you get.
  35  *
  36  *      Beware the OMA datasheet(s) lists GPIO banks 1-6, whereas I've used 0-5 here
  37  *      in the code.
  38  *
  39  *
  40  */
  41
  42 #include <sys/cdefs.h>
  43 __FBSDID("$FreeBSD$");
  44
  45 #include <sys/param.h>
  46 #include <sys/systm.h>
  47 #include <sys/bus.h>
  48
  49 #include <sys/kernel.h>
  50 #include <sys/module.h>
  51 #include <sys/rman.h>
  52 #include <sys/lock.h>
  53 #include <sys/mutex.h>
  54 #include <sys/gpio.h>
  55
  56 #include <machine/bus.h>
  57 #include <machine/resource.h>
  58
  59 #include <arm/ti/ti_scm.h>
  60 #include <arm/ti/ti_prcm.h>
  61
  62 #include <dev/fdt/fdt_common.h>
  63 #include <dev/ofw/openfirm.h>
  64 #include <dev/ofw/ofw_bus.h>
  65 #include <dev/ofw/ofw_bus_subr.h>
  66
  67 #include "gpio_if.h"
  68
  69  /* Register definitions */
  70 #define TI_GPIO_REVISION                0x0000
  71 #define TI_GPIO_SYSCONFIG               0x0010
  72 #if defined(SOC_OMAP3)
  73 #define TI_GPIO_REVISION                0x0000
  74 #define TI_GPIO_SYSCONFIG               0x0010
  75 #define TI_GPIO_SYSSTATUS               0x0014
  76 #define TI_GPIO_IRQSTATUS1              0x0018
  77 #define TI_GPIO_IRQENABLE1              0x001C
  78 #define TI_GPIO_WAKEUPENABLE            0x0020
  79 #define TI_GPIO_IRQSTATUS2              0x0028
  80 #define TI_GPIO_IRQENABLE2              0x002C
  81 #define TI_GPIO_CTRL                    0x0030
  82 #define TI_GPIO_OE                      0x0034
  83 #define TI_GPIO_DATAIN                  0x0038
  84 #define TI_GPIO_DATAOUT                 0x003C
  85 #define TI_GPIO_LEVELDETECT0            0x0040
  86 #define TI_GPIO_LEVELDETECT1            0x0044
  87 #define TI_GPIO_RISINGDETECT            0x0048
  88 #define TI_GPIO_FALLINGDETECT           0x004C
  89 #define TI_GPIO_DEBOUNCENABLE           0x0050
  90 #define TI_GPIO_DEBOUNCINGTIME          0x0054
  91 #define TI_GPIO_CLEARIRQENABLE1         0x0060
  92 #define TI_GPIO_SETIRQENABLE1           0x0064
  93 #define TI_GPIO_CLEARIRQENABLE2         0x0070
  94 #define TI_GPIO_SETIRQENABLE2           0x0074
  95 #define TI_GPIO_CLEARWKUENA             0x0080
  96 #define TI_GPIO_SETWKUENA               0x0084
  97 #define TI_GPIO_CLEARDATAOUT            0x0090
  98 #define TI_GPIO_SETDATAOUT              0x0094
  99 #elif defined(SOC_OMAP4) || defined(SOC_TI_AM335X)
 100 #define TI_GPIO_IRQSTATUS_RAW_0         0x0024
 101 #define TI_GPIO_IRQSTATUS_RAW_1         0x0028
 102 #define TI_GPIO_IRQSTATUS_0             0x002C
 103 #define TI_GPIO_IRQSTATUS_1             0x0030
 104 #define TI_GPIO_IRQSTATUS_SET_0         0x0034
 105 #define TI_GPIO_IRQSTATUS_SET_1         0x0038
 106 #define TI_GPIO_IRQSTATUS_CLR_0         0x003C
 107 #define TI_GPIO_IRQSTATUS_CLR_1         0x0040
 108 #define TI_GPIO_IRQWAKEN_0              0x0044
 109 #define TI_GPIO_IRQWAKEN_1              0x0048
 110 #define TI_GPIO_SYSSTATUS               0x0114
 111 #define TI_GPIO_IRQSTATUS1              0x0118
 112 #define TI_GPIO_IRQENABLE1              0x011C
 113 #define TI_GPIO_WAKEUPENABLE            0x0120
 114 #define TI_GPIO_IRQSTATUS2              0x0128
 115 #define TI_GPIO_IRQENABLE2              0x012C
 116 #define TI_GPIO_CTRL                    0x0130
 117 #define TI_GPIO_OE                      0x0134
 118 #define TI_GPIO_DATAIN                  0x0138
 119 #define TI_GPIO_DATAOUT                 0x013C
 120 #define TI_GPIO_LEVELDETECT0            0x0140
 121 #define TI_GPIO_LEVELDETECT1            0x0144
 122 #define TI_GPIO_RISINGDETECT            0x0148
 123 #define TI_GPIO_FALLINGDETECT           0x014C
 124 #define TI_GPIO_DEBOUNCENABLE           0x0150
 125 #define TI_GPIO_DEBOUNCINGTIME          0x0154
 126 #define TI_GPIO_CLEARIRQENABLE1         0x0160
 127 #define TI_GPIO_SETIRQENABLE1           0x0164
 128 #define TI_GPIO_CLEARIRQENABLE2         0x0170
 129 #define TI_GPIO_SETIRQENABLE2           0x0174
 130 #define TI_GPIO_CLEARWKUPENA            0x0180
 131 #define TI_GPIO_SETWKUENA               0x0184
 132 #define TI_GPIO_CLEARDATAOUT            0x0190
 133 #define TI_GPIO_SETDATAOUT              0x0194
 134 #else
 135 #error "Unknown SoC"
 136 #endif
 137
 138  /*Other SoC Specific definitions*/
 139 #if defined(SOC_OMAP3)
 140 #define MAX_GPIO_BANKS                  6
 141 #define FIRST_GPIO_BANK                 1
 142 #define PINS_PER_BANK                   32
 143 #define TI_GPIO_REV                     0x00000025
 144 #elif defined(SOC_OMAP4)
 145 #define MAX_GPIO_BANKS                  6
 146 #define FIRST_GPIO_BANK                 1
 147 #define PINS_PER_BANK                   32
 148 #define TI_GPIO_REV                     0x50600801
 149 #elif defined(SOC_TI_AM335X)
 150 #define MAX_GPIO_BANKS                  4
 151 #define FIRST_GPIO_BANK                 0
 152 #define PINS_PER_BANK                   32
 153 #define TI_GPIO_REV                     0x50600801
 154 #endif
 155
 156 /**
 157  *      ti_gpio_mem_spec - Resource specification used when allocating resources
 158  *      ti_gpio_irq_spec - Resource specification used when allocating resources
 159  *
 160  *      This driver module can have up to six independent memory regions, each
 161  *      region typically controls 32 GPIO pins.
 162  */
 163 static struct resource_spec ti_gpio_mem_spec[] = {
 164         { SYS_RES_MEMORY,   0,  RF_ACTIVE },
 165         { SYS_RES_MEMORY,   1,  RF_ACTIVE | RF_OPTIONAL },
 166         { SYS_RES_MEMORY,   2,  RF_ACTIVE | RF_OPTIONAL },
 167         { SYS_RES_MEMORY,   3,  RF_ACTIVE | RF_OPTIONAL },
 168 #if !defined(SOC_TI_AM335X)
 169         { SYS_RES_MEMORY,   4,  RF_ACTIVE | RF_OPTIONAL },
 170         { SYS_RES_MEMORY,   5,  RF_ACTIVE | RF_OPTIONAL },
 171 #endif
 172         { -1,               0,  0 }
 173 };
 174 static struct resource_spec ti_gpio_irq_spec[] = {
 175         { SYS_RES_IRQ,      0,  RF_ACTIVE },
 176         { SYS_RES_IRQ,      1,  RF_ACTIVE | RF_OPTIONAL },
 177         { SYS_RES_IRQ,      2,  RF_ACTIVE | RF_OPTIONAL },
 178         { SYS_RES_IRQ,      3,  RF_ACTIVE | RF_OPTIONAL },
 179 #if !defined(SOC_TI_AM335X)
 180         { SYS_RES_IRQ,      4,  RF_ACTIVE | RF_OPTIONAL },
 181         { SYS_RES_IRQ,      5,  RF_ACTIVE | RF_OPTIONAL },
 182 #endif
 183         { -1,               0,  0 }
 184 };
 185
 186 /**
 187  *      Structure that stores the driver context.
 188  *
 189  *      This structure is allocated during driver attach.
 190  */
 191 struct ti_gpio_softc {
 192         device_t                        sc_dev;
 193
 194         /* The memory resource(s) for the PRCM register set, when the device is
 195          * created the caller can assign up to 4 memory regions.
 196          */
 197         struct resource*    sc_mem_res[MAX_GPIO_BANKS];
 198         struct resource*    sc_irq_res[MAX_GPIO_BANKS];
 199
 200         /* The handle for the register IRQ handlers */
 201         void*               sc_irq_hdl[MAX_GPIO_BANKS];
 202
 203         /* The following describes the H/W revision of each of the GPIO banks */
 204         uint32_t            sc_revision[MAX_GPIO_BANKS];
 205
 206         struct mtx                      sc_mtx;
 207 };
 208
 209 /**
 210  *      Macros for driver mutex locking
 211  */
 212 #define TI_GPIO_LOCK(_sc)             mtx_lock(&(_sc)->sc_mtx)
 213 #define TI_GPIO_UNLOCK(_sc)           mtx_unlock(&(_sc)->sc_mtx)
 214 #define TI_GPIO_LOCK_INIT(_sc) \
 215         mtx_init(&_sc->sc_mtx, device_get_nameunit(_sc->sc_dev), \
 216                  "ti_gpio", MTX_DEF)
 217 #define TI_GPIO_LOCK_DESTROY(_sc)     mtx_destroy(&_sc->sc_mtx);
 218 #define TI_GPIO_ASSERT_LOCKED(_sc)    mtx_assert(&_sc->sc_mtx, MA_OWNED);
 219 #define TI_GPIO_ASSERT_UNLOCKED(_sc)  mtx_assert(&_sc->sc_mtx, MA_NOTOWNED);
 220
 221 /**
 222  *      ti_gpio_read_4 - reads a 16-bit value from one of the PADCONFS registers
 223  *      @sc: GPIO device context
 224  *      @bank: The bank to read from
 225  *      @off: The offset of a register from the GPIO register address range
 226  *
 227  *
 228  *      RETURNS:
 229  *      32-bit value read from the register.
 230  */
 231 static inline uint32_t
 232 ti_gpio_read_4(struct ti_gpio_softc *sc, unsigned int bank, bus_size_t off)
 233 {
 234         return (bus_read_4(sc->sc_mem_res[bank], off));
 235 }
 236
 237 /**
 238  *      ti_gpio_write_4 - writes a 32-bit value to one of the PADCONFS registers
 239  *      @sc: GPIO device context
 240  *      @bank: The bank to write to
 241  *      @off: The offset of a register from the GPIO register address range
 242  *      @val: The value to write into the register
 243  *
 244  *      RETURNS:
 245  *      nothing
 246  */
 247 static inline void
 248 ti_gpio_write_4(struct ti_gpio_softc *sc, unsigned int bank, bus_size_t off,
 249                  uint32_t val)
 250 {
 251         bus_write_4(sc->sc_mem_res[bank], off, val);
 252 }
 253
 254 /**
 255  *      ti_gpio_pin_max - Returns the maximum number of GPIO pins
 256  *      @dev: gpio device handle
 257  *      @maxpin: pointer to a value that upon return will contain the maximum number
 258  *               of pins in the device.
 259  *
 260  *
 261  *      LOCKING:
 262  *      Internally locks the context
 263  *
 264  *      RETURNS:
 265  *      Returns 0 on success otherwise an error code
 266  */
 267 static int
 268 ti_gpio_pin_max(device_t dev, int *maxpin)
 269 {
 270         struct ti_gpio_softc *sc = device_get_softc(dev);
 271         unsigned int i;
 272         unsigned int banks = 0;
 273
 274         TI_GPIO_LOCK(sc);
 275
 276         /* Calculate how many valid banks we have and then multiply that by 32 to
 277          * give use the total number of pins.
 278          */
 279         for (i = 0; i < MAX_GPIO_BANKS; i++) {
 280                 if (sc->sc_mem_res[i] != NULL)
 281                         banks++;
 282         }
 283
 284         *maxpin = (banks * PINS_PER_BANK) - 1;
 285
 286         TI_GPIO_UNLOCK(sc);
 287
 288         return (0);
 289 }
 290
 291 /**
 292  *      ti_gpio_pin_getcaps - Gets the capabilties of a given pin
 293  *      @dev: gpio device handle
 294  *      @pin: the number of the pin
 295  *      @caps: pointer to a value that upon return will contain the capabilities
 296  *
 297  *      Currently all pins have the same capability, notably:
 298  *        - GPIO_PIN_INPUT
 299  *        - GPIO_PIN_OUTPUT
 300  *        - GPIO_PIN_PULLUP
 301  *        - GPIO_PIN_PULLDOWN
 302  *
 303  *      LOCKING:
 304  *      Internally locks the context
 305  *
 306  *      RETURNS:
 307  *      Returns 0 on success otherwise an error code
 308  */
 309 static int
 310 ti_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps)
 311 {
 312         struct ti_gpio_softc *sc = device_get_softc(dev);
 313         uint32_t bank = (pin / PINS_PER_BANK);
 314
 315         TI_GPIO_LOCK(sc);
 316
 317         /* Sanity check the pin number is valid */
 318         if ((bank >= MAX_GPIO_BANKS) || (sc->sc_mem_res[bank] == NULL)) {
 319                 TI_GPIO_UNLOCK(sc);
 320                 return (EINVAL);
 321         }
 322
 323         *caps = (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT |GPIO_PIN_PULLUP |
 324             GPIO_PIN_PULLDOWN);
 325
 326         TI_GPIO_UNLOCK(sc);
 327
 328         return (0);
 329 }
 330
 331 /**
 332  *      ti_gpio_pin_getflags - Gets the current flags of a given pin
 333  *      @dev: gpio device handle
 334  *      @pin: the number of the pin
 335  *      @flags: upon return will contain the current flags of the pin
 336  *
 337  *      Reads the current flags of a given pin, here we actually read the H/W
 338  *      registers to determine the flags, rather than storing the value in the
 339  *      setflags call.
 340  *
 341  *      LOCKING:
 342  *      Internally locks the context
 343  *
 344  *      RETURNS:
 345  *      Returns 0 on success otherwise an error code
 346  */
 347 static int
 348 ti_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags)
 349 {
 350         struct ti_gpio_softc *sc = device_get_softc(dev);
 351         uint32_t bank = (pin / PINS_PER_BANK);
 352
 353         TI_GPIO_LOCK(sc);
 354
 355         /* Sanity check the pin number is valid */
 356         if ((bank >= MAX_GPIO_BANKS) || (sc->sc_mem_res[bank] == NULL)) {
 357                 TI_GPIO_UNLOCK(sc);
 358                 return (EINVAL);
 359         }
 360
 361         /* Get the current pin state */
 362         ti_scm_padconf_get_gpioflags(pin, flags);
 363
 364         TI_GPIO_UNLOCK(sc);
 365
 366         return (0);
 367 }
 368
 369 /**
 370  *      ti_gpio_pin_getname - Gets the name of a given pin
 371  *      @dev: gpio device handle
 372  *      @pin: the number of the pin
 373  *      @name: buffer to put the name in
 374  *
 375  *      The driver simply calls the pins gpio_n, where 'n' is obviously the number
 376  *      of the pin.
 377  *
 378  *      LOCKING:
 379  *      Internally locks the context
 380  *
 381  *      RETURNS:
 382  *      Returns 0 on success otherwise an error code
 383  */
 384 static int
 385 ti_gpio_pin_getname(device_t dev, uint32_t pin, char *name)
 386 {
 387         struct ti_gpio_softc *sc = device_get_softc(dev);
 388         uint32_t bank = (pin / PINS_PER_BANK);
 389
 390         TI_GPIO_LOCK(sc);
 391
 392         /* Sanity check the pin number is valid */
 393         if ((bank >= MAX_GPIO_BANKS) || (sc->sc_mem_res[bank] == NULL)) {
 394                 TI_GPIO_UNLOCK(sc);
 395                 return (EINVAL);
 396         }
 397
 398         /* Set a very simple name */
 399         snprintf(name, GPIOMAXNAME, "gpio_%u", pin);
 400         name[GPIOMAXNAME - 1] = '\0';
 401
 402         TI_GPIO_UNLOCK(sc);
 403
 404         return (0);
 405 }
 406
 407 /**
 408  *      ti_gpio_pin_setflags - Sets the flags for a given pin
 409  *      @dev: gpio device handle
 410  *      @pin: the number of the pin
 411  *      @flags: the flags to set
 412  *
 413  *      The flags of the pin correspond to things like input/output mode, pull-ups,
 414  *      pull-downs, etc.  This driver doesn't support all flags, only the following:
 415  *        - GPIO_PIN_INPUT
 416  *        - GPIO_PIN_OUTPUT
 417  *        - GPIO_PIN_PULLUP
 418  *        - GPIO_PIN_PULLDOWN
 419  *
 420  *      LOCKING:
 421  *      Internally locks the context
 422  *
 423  *      RETURNS:
 424  *      Returns 0 on success otherwise an error code
 425  */
 426 static int
 427 ti_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags)
 428 {
 429         struct ti_gpio_softc *sc = device_get_softc(dev);
 430         uint32_t bank = (pin / PINS_PER_BANK);
 431         uint32_t mask = (1UL << (pin % PINS_PER_BANK));
 432         uint32_t reg_val;
 433
 434         /* Sanity check the flags supplied are valid, i.e. not input and output */
 435         if ((flags & (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) == 0x0000)
 436                 return (EINVAL);
 437         if ((flags & (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) ==
 438             (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT))
 439                 return (EINVAL);
 440         if ((flags & (GPIO_PIN_PULLUP|GPIO_PIN_PULLDOWN)) ==
 441             (GPIO_PIN_PULLUP|GPIO_PIN_PULLDOWN))
 442                 return (EINVAL);
 443
 444
 445         TI_GPIO_LOCK(sc);
 446
 447         /* Sanity check the pin number is valid */
 448         if ((bank >= MAX_GPIO_BANKS) || (sc->sc_mem_res[bank] == NULL)) {
 449                 TI_GPIO_UNLOCK(sc);
 450                 return (EINVAL);
 451         }
 452
 453         /* Set the GPIO mode and state */
 454         if (ti_scm_padconf_set_gpioflags(pin, flags) != 0) {
 455                 TI_GPIO_UNLOCK(sc);
 456                 return (EINVAL);
 457         }
 458
 459         /* If configuring as an output set the "output enable" bit */
 460         reg_val = ti_gpio_read_4(sc, bank, TI_GPIO_OE);
 461         if (flags & GPIO_PIN_INPUT)
 462                 reg_val |= mask;
 463         else
 464                 reg_val &= ~mask;
 465         ti_gpio_write_4(sc, bank, TI_GPIO_OE, reg_val);
 466
 467
 468         TI_GPIO_UNLOCK(sc);
 469
 470         return (0);
 471 }
 472
 473 /**
 474  *      ti_gpio_pin_set - Sets the current level on a GPIO pin
 475  *      @dev: gpio device handle
 476  *      @pin: the number of the pin
 477  *      @value: non-zero value will drive the pin high, otherwise the pin is
 478  *              driven low.
 479  *
 480  *
 481  *      LOCKING:
 482  *      Internally locks the context
 483  *
 484  *      RETURNS:
 485  *      Returns 0 on success otherwise a error code
 486  */
 487 static int
 488 ti_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value)
 489 {
 490         struct ti_gpio_softc *sc = device_get_softc(dev);
 491         uint32_t bank = (pin / PINS_PER_BANK);
 492         uint32_t mask = (1UL << (pin % PINS_PER_BANK));
 493
 494         TI_GPIO_LOCK(sc);
 495
 496         /* Sanity check the pin number is valid */
 497         if ((bank >= MAX_GPIO_BANKS) || (sc->sc_mem_res[bank] == NULL)) {
 498                 TI_GPIO_UNLOCK(sc);
 499                 return (EINVAL);
 500         }
 501
 502         ti_gpio_write_4(sc, bank, (value == GPIO_PIN_LOW) ? TI_GPIO_CLEARDATAOUT
 503             : TI_GPIO_SETDATAOUT, mask);
 504
 505         TI_GPIO_UNLOCK(sc);
 506
 507         return (0);
 508 }
 509
 510 /**
 511  *      ti_gpio_pin_get - Gets the current level on a GPIO pin
 512  *      @dev: gpio device handle
 513  *      @pin: the number of the pin
 514  *      @value: pointer to a value that upond return will contain the pin value
 515  *
 516  *      The pin must be configured as an input pin beforehand, otherwise this
 517  *      function will fail.
 518  *
 519  *      LOCKING:
 520  *      Internally locks the context
 521  *
 522  *      RETURNS:
 523  *      Returns 0 on success otherwise a error code
 524  */
 525 static int
 526 ti_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *value)
 527 {
 528         struct ti_gpio_softc *sc = device_get_softc(dev);
 529         uint32_t bank = (pin / PINS_PER_BANK);
 530         uint32_t mask = (1UL << (pin % PINS_PER_BANK));
 531         uint32_t val = 0;
 532
 533         TI_GPIO_LOCK(sc);
 534
 535         /* Sanity check the pin number is valid */
 536         if ((bank >= MAX_GPIO_BANKS) || (sc->sc_mem_res[bank] == NULL)) {
 537                 TI_GPIO_UNLOCK(sc);
 538                 return (EINVAL);
 539         }
 540
 541         /* Sanity check the pin is not configured as an output */
 542         val = ti_gpio_read_4(sc, bank, TI_GPIO_OE);
 543
 544         /* Read the value on the pin */
 545         if (val & mask)
 546                 *value = (ti_gpio_read_4(sc, bank, TI_GPIO_DATAOUT) & mask) ? 1 : 0;
 547         else
 548                 *value = (ti_gpio_read_4(sc, bank, TI_GPIO_DATAIN) & mask) ? 1 : 0;
 549
 550         TI_GPIO_UNLOCK(sc);
 551
 552         return (0);
 553 }
 554
 555 /**
 556  *      ti_gpio_pin_toggle - Toggles a given GPIO pin
 557  *      @dev: gpio device handle
 558  *      @pin: the number of the pin
 559  *
 560  *
 561  *      LOCKING:
 562  *      Internally locks the context
 563  *
 564  *      RETURNS:
 565  *      Returns 0 on success otherwise a error code
 566  */
 567 static int
 568 ti_gpio_pin_toggle(device_t dev, uint32_t pin)
 569 {
 570         struct ti_gpio_softc *sc = device_get_softc(dev);
 571         uint32_t bank = (pin / PINS_PER_BANK);
 572         uint32_t mask = (1UL << (pin % PINS_PER_BANK));
 573         uint32_t val;
 574
 575         TI_GPIO_LOCK(sc);
 576
 577         /* Sanity check the pin number is valid */
 578         if ((bank >= MAX_GPIO_BANKS) || (sc->sc_mem_res[bank] == NULL)) {
 579                 TI_GPIO_UNLOCK(sc);
 580                 return (EINVAL);
 581         }
 582
 583         /* Toggle the pin */
 584         val = ti_gpio_read_4(sc, bank, TI_GPIO_DATAOUT);
 585         if (val & mask)
 586                 ti_gpio_write_4(sc, bank, TI_GPIO_CLEARDATAOUT, mask);
 587         else
 588                 ti_gpio_write_4(sc, bank, TI_GPIO_SETDATAOUT, mask);
 589
 590         TI_GPIO_UNLOCK(sc);
 591
 592         return (0);
 593 }
 594
 595 /**
 596  *      ti_gpio_intr - ISR for all GPIO modules
 597  *      @arg: the soft context pointer
 598  *
 599  *      Unsused
 600  *
 601  *      LOCKING:
 602  *      Internally locks the context
 603  *
 604  */
 605 static void
 606 ti_gpio_intr(void *arg)
 607 {
 608         struct ti_gpio_softc *sc = arg;
 609
 610         TI_GPIO_LOCK(sc);
 611         /* TODO: something useful */
 612         TI_GPIO_UNLOCK(sc);
 613 }
 614
 615 /**
 616  *      ti_gpio_probe - probe function for the driver
 617  *      @dev: gpio device handle
 618  *
 619  *      Simply sets the name of the driver
 620  *
 621  *      LOCKING:
 622  *      None
 623  *
 624  *      RETURNS:
 625  *      Always returns 0
 626  */
 627 static int
 628 ti_gpio_probe(device_t dev)
 629 {
 630         if (!ofw_bus_is_compatible(dev, "ti,gpio"))
 631                 return (ENXIO);
 632
 633         device_set_desc(dev, "TI General Purpose I/O (GPIO)");
 634         return (0);
 635 }
 636
 637 /**
 638  *      ti_gpio_attach - attach function for the driver
 639  *      @dev: gpio device handle
 640  *
 641  *      Allocates and sets up the driver context for all GPIO banks.  This function
 642  *      expects the memory ranges and IRQs to already be allocated to the driver.
 643  *
 644  *      LOCKING:
 645  *      None
 646  *
 647  *      RETURNS:
 648  *      Always returns 0
 649  */
 650 static int
 651 ti_gpio_attach(device_t dev)
 652 {
 653         struct ti_gpio_softc *sc = device_get_softc(dev);
 654         unsigned int i;
 655         int err = 0;
 656         int pin;
 657         uint32_t flags;
 658         uint32_t reg_oe;
 659
 660         sc->sc_dev = dev;
 661
 662         TI_GPIO_LOCK_INIT(sc);
 663
 664
 665         /* There are up to 6 different GPIO register sets located in different
 666          * memory areas on the chip.  The memory range should have been set for
 667          * the driver when it was added as a child.
 668          */
 669         err = bus_alloc_resources(dev, ti_gpio_mem_spec, sc->sc_mem_res);
 670         if (err) {
 671                 device_printf(dev, "Error: could not allocate mem resources\n");
 672                 return (ENXIO);
 673         }
 674
 675         /* Request the IRQ resources */
 676         err = bus_alloc_resources(dev, ti_gpio_irq_spec, sc->sc_irq_res);
 677         if (err) {
 678                 device_printf(dev, "Error: could not allocate irq resources\n");
 679                 return (ENXIO);
 680         }
 681
 682         /* Setup the IRQ resources */
 683         for (i = 0;  i < MAX_GPIO_BANKS; i++) {
 684                 if (sc->sc_irq_res[i] == NULL)
 685                         break;
 686
 687                 /* Register an interrupt handler for each of the IRQ resources */
 688                 if ((bus_setup_intr(dev, sc->sc_irq_res[i], INTR_TYPE_MISC | INTR_MPSAFE,
 689                                     NULL, ti_gpio_intr, sc, &(sc->sc_irq_hdl[i])))) {
 690                         device_printf(dev, "WARNING: unable to register interrupt handler\n");
 691                         return (ENXIO);
 692                 }
 693         }
 694
 695         /* Store the device handle back in the sc */
 696         sc->sc_dev = dev;
 697
 698         /* We need to go through each block and ensure the clocks are running and
 699          * the module is enabled.  It might be better to do this only when the
 700          * pins are configured which would result in less power used if the GPIO
 701          * pins weren't used ...
 702          */
 703         for (i = 0;  i < MAX_GPIO_BANKS; i++) {
 704                 if (sc->sc_mem_res[i] != NULL) {
 705
 706                         /* Enable the interface and functional clocks for the module */
 707                         ti_prcm_clk_enable(GPIO0_CLK + FIRST_GPIO_BANK + i);
 708
 709                         /* Read the revision number of the module. TI don't publish the
 710                          * actual revision numbers, so instead the values have been
 711                          * determined by experimentation.
 712                          */
 713                         sc->sc_revision[i] = ti_gpio_read_4(sc, i, TI_GPIO_REVISION);
 714
 715                         /* Check the revision */
 716                         if (sc->sc_revision[i] != TI_GPIO_REV) {
 717                                 device_printf(dev, "Warning: could not determine the revision"
 718                                               "of %u GPIO module (revision:0x%08x)\n",
 719                                               i, sc->sc_revision[i]);
 720                                 continue;
 721                         }
 722
 723                         /* Disable interrupts for all pins */
 724                         ti_gpio_write_4(sc, i, TI_GPIO_CLEARIRQENABLE1, 0xffffffff);
 725                         ti_gpio_write_4(sc, i, TI_GPIO_CLEARIRQENABLE2, 0xffffffff);
 726
 727                         /* Init OE register based on pads configuration */
 728                         reg_oe = 0xffffffff;
 729                         for (pin = 0; pin < 32; pin++) {
 730                                 ti_scm_padconf_get_gpioflags(
 731                                     PINS_PER_BANK*i + pin, &flags);
 732                                 if (flags & GPIO_PIN_OUTPUT)
 733                                         reg_oe &= ~(1U << pin);
 734                         }
 735
 736                         ti_gpio_write_4(sc, i, TI_GPIO_OE, reg_oe);
 737                 }
 738         }
 739
 740         /* Finish of the probe call */
 741         device_add_child(dev, "gpioc", device_get_unit(dev));
 742         device_add_child(dev, "gpiobus", device_get_unit(dev));
 743
 744         return (bus_generic_attach(dev));
 745 }
 746
 747 /**
 748  *      ti_gpio_detach - detach function for the driver
 749  *      @dev: scm device handle
 750  *
 751  *      Allocates and sets up the driver context, this simply entails creating a
 752  *      bus mappings for the SCM register set.
 753  *
 754  *      LOCKING:
 755  *      None
 756  *
 757  *      RETURNS:
 758  *      Always returns 0
 759  */
 760 static int
 761 ti_gpio_detach(device_t dev)
 762 {
 763         struct ti_gpio_softc *sc = device_get_softc(dev);
 764         unsigned int i;
 765
 766         KASSERT(mtx_initialized(&sc->sc_mtx), ("gpio mutex not initialized"));
 767
 768         /* Disable all interrupts */
 769         for (i = 0;  i < MAX_GPIO_BANKS; i++) {
 770                 if (sc->sc_mem_res[i] != NULL) {
 771                         ti_gpio_write_4(sc, i, TI_GPIO_CLEARIRQENABLE1, 0xffffffff);
 772                         ti_gpio_write_4(sc, i, TI_GPIO_CLEARIRQENABLE2, 0xffffffff);
 773                 }
 774         }
 775
 776         bus_generic_detach(dev);
 777
 778         /* Release the memory and IRQ resources */
 779         for (i = 0;  i < MAX_GPIO_BANKS; i++) {
 780                 if (sc->sc_mem_res[i] != NULL)
 781                         bus_release_resource(dev, SYS_RES_MEMORY, i, sc->sc_mem_res[i]);
 782                 if (sc->sc_irq_res[i] != NULL)
 783                         bus_release_resource(dev, SYS_RES_IRQ, i, sc->sc_irq_res[i]);
 784         }
 785
 786         TI_GPIO_LOCK_DESTROY(sc);
 787
 788         return(0);
 789 }
 790
 791 static device_method_t ti_gpio_methods[] = {
 792         DEVMETHOD(device_probe, ti_gpio_probe),
 793         DEVMETHOD(device_attach, ti_gpio_attach),
 794         DEVMETHOD(device_detach, ti_gpio_detach),
 795
 796         /* GPIO protocol */
 797         DEVMETHOD(gpio_pin_max, ti_gpio_pin_max),
 798         DEVMETHOD(gpio_pin_getname, ti_gpio_pin_getname),
 799         DEVMETHOD(gpio_pin_getflags, ti_gpio_pin_getflags),
 800         DEVMETHOD(gpio_pin_getcaps, ti_gpio_pin_getcaps),
 801         DEVMETHOD(gpio_pin_setflags, ti_gpio_pin_setflags),
 802         DEVMETHOD(gpio_pin_get, ti_gpio_pin_get),
 803         DEVMETHOD(gpio_pin_set, ti_gpio_pin_set),
 804         DEVMETHOD(gpio_pin_toggle, ti_gpio_pin_toggle),
 805         {0, 0},
 806 };
 807
 808 static driver_t ti_gpio_driver = {
 809         "gpio",
 810         ti_gpio_methods,
 811         sizeof(struct ti_gpio_softc),
 812 };
 813 static devclass_t ti_gpio_devclass;
 814
 815 DRIVER_MODULE(ti_gpio, simplebus, ti_gpio_driver, ti_gpio_devclass, 0, 0);