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