1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2009 Oleksandr Tymoshenko <gonzo@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, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/param.h> 30 #include <sys/systm.h> 31 #include <sys/bus.h> 32 #include <sys/gpio.h> 33 #ifdef INTRNG 34 #include <sys/intr.h> 35 #endif 36 #include <sys/kernel.h> 37 #include <sys/malloc.h> 38 #include <sys/module.h> 39 #include <sys/sbuf.h> 40 41 #include <dev/gpio/gpiobusvar.h> 42 #include <dev/gpio/gpiobus_internal.h> 43 44 #include "gpiobus_if.h" 45 46 #undef GPIOBUS_DEBUG 47 #ifdef GPIOBUS_DEBUG 48 #define dprintf printf 49 #else 50 #define dprintf(x, arg...) 51 #endif 52 53 static void gpiobus_print_pins(struct gpiobus_ivar *, struct sbuf *); 54 static int gpiobus_parse_pins(struct gpiobus_softc *, device_t, int); 55 static int gpiobus_probe(device_t); 56 static int gpiobus_suspend(device_t); 57 static int gpiobus_resume(device_t); 58 static void gpiobus_probe_nomatch(device_t, device_t); 59 static int gpiobus_print_child(device_t, device_t); 60 static int gpiobus_child_location(device_t, device_t, struct sbuf *); 61 static device_t gpiobus_add_child(device_t, u_int, const char *, int); 62 static void gpiobus_hinted_child(device_t, const char *, int); 63 64 /* 65 * GPIOBUS interface 66 */ 67 static int gpiobus_acquire_bus(device_t, device_t, int); 68 static void gpiobus_release_bus(device_t, device_t); 69 static int gpiobus_pin_setflags(device_t, device_t, uint32_t, uint32_t); 70 static int gpiobus_pin_getflags(device_t, device_t, uint32_t, uint32_t*); 71 static int gpiobus_pin_getcaps(device_t, device_t, uint32_t, uint32_t*); 72 static int gpiobus_pin_set(device_t, device_t, uint32_t, unsigned int); 73 static int gpiobus_pin_get(device_t, device_t, uint32_t, unsigned int*); 74 static int gpiobus_pin_toggle(device_t, device_t, uint32_t); 75 76 /* 77 * gpiobus_pin flags 78 * The flags in struct gpiobus_pin are not related to the flags used by the 79 * low-level controller driver in struct gpio_pin. Currently, only pins 80 * acquired via FDT data have gpiobus_pin.flags set, sourced from the flags in 81 * the FDT properties. In theory, these flags are defined per-platform. In 82 * practice they are always the flags from the dt-bindings/gpio/gpio.h file. 83 * The only one of those flags we currently support is for handling active-low 84 * pins, so we just define that flag here instead of including a GPL'd header. 85 */ 86 #define GPIO_ACTIVE_LOW 1 87 88 /* 89 * XXX -> Move me to better place - gpio_subr.c? 90 * Also, this function must be changed when interrupt configuration 91 * data will be moved into struct resource. 92 */ 93 #ifdef INTRNG 94 95 struct resource * 96 gpio_alloc_intr_resource(device_t consumer_dev, int *rid, u_int alloc_flags, 97 gpio_pin_t pin, uint32_t intr_mode) 98 { 99 u_int irq; 100 struct intr_map_data_gpio *gpio_data; 101 struct resource *res; 102 103 gpio_data = (struct intr_map_data_gpio *)intr_alloc_map_data( 104 INTR_MAP_DATA_GPIO, sizeof(*gpio_data), M_WAITOK | M_ZERO); 105 gpio_data->gpio_pin_num = pin->pin; 106 gpio_data->gpio_pin_flags = pin->flags; 107 gpio_data->gpio_intr_mode = intr_mode; 108 109 irq = intr_map_irq(pin->dev, 0, (struct intr_map_data *)gpio_data); 110 res = bus_alloc_resource(consumer_dev, SYS_RES_IRQ, rid, irq, irq, 1, 111 alloc_flags); 112 if (res == NULL) { 113 intr_unmap_irq(irq); 114 return (NULL); 115 } 116 return (res); 117 } 118 #else 119 struct resource * 120 gpio_alloc_intr_resource(device_t consumer_dev, int *rid, u_int alloc_flags, 121 gpio_pin_t pin, uint32_t intr_mode) 122 { 123 124 return (NULL); 125 } 126 #endif 127 128 int 129 gpio_check_flags(uint32_t caps, uint32_t flags) 130 { 131 132 /* Filter unwanted flags. */ 133 flags &= caps; 134 135 /* Cannot mix input/output together. */ 136 if (flags & GPIO_PIN_INPUT && flags & GPIO_PIN_OUTPUT) 137 return (EINVAL); 138 /* Cannot mix pull-up/pull-down together. */ 139 if (flags & GPIO_PIN_PULLUP && flags & GPIO_PIN_PULLDOWN) 140 return (EINVAL); 141 /* Cannot mix output and interrupt flags together */ 142 if (flags & GPIO_PIN_OUTPUT && flags & GPIO_INTR_MASK) 143 return (EINVAL); 144 /* Only one interrupt flag can be defined at once */ 145 if ((flags & GPIO_INTR_MASK) & ((flags & GPIO_INTR_MASK) - 1)) 146 return (EINVAL); 147 /* The interrupt attached flag cannot be set */ 148 if (flags & GPIO_INTR_ATTACHED) 149 return (EINVAL); 150 151 return (0); 152 } 153 154 int 155 gpio_pin_get_by_bus_pinnum(device_t busdev, uint32_t pinnum, gpio_pin_t *ppin) 156 { 157 gpio_pin_t pin; 158 int err; 159 160 err = gpiobus_acquire_pin(busdev, pinnum); 161 if (err != 0) 162 return (EBUSY); 163 164 pin = malloc(sizeof(*pin), M_DEVBUF, M_WAITOK | M_ZERO); 165 166 pin->dev = device_get_parent(busdev); 167 pin->pin = pinnum; 168 pin->flags = 0; 169 170 *ppin = pin; 171 return (0); 172 } 173 174 int 175 gpio_pin_get_by_child_index(device_t childdev, uint32_t idx, gpio_pin_t *ppin) 176 { 177 struct gpiobus_ivar *devi; 178 179 devi = GPIOBUS_IVAR(childdev); 180 if (idx >= devi->npins) 181 return (EINVAL); 182 183 return (gpio_pin_get_by_bus_pinnum(device_get_parent(childdev), 184 devi->pins[idx], ppin)); 185 } 186 187 int 188 gpio_pin_getcaps(gpio_pin_t pin, uint32_t *caps) 189 { 190 191 KASSERT(pin != NULL, ("GPIO pin is NULL.")); 192 KASSERT(pin->dev != NULL, ("GPIO pin device is NULL.")); 193 return (GPIO_PIN_GETCAPS(pin->dev, pin->pin, caps)); 194 } 195 196 int 197 gpio_pin_is_active(gpio_pin_t pin, bool *active) 198 { 199 int rv; 200 uint32_t tmp; 201 202 KASSERT(pin != NULL, ("GPIO pin is NULL.")); 203 KASSERT(pin->dev != NULL, ("GPIO pin device is NULL.")); 204 rv = GPIO_PIN_GET(pin->dev, pin->pin, &tmp); 205 if (rv != 0) { 206 return (rv); 207 } 208 209 if (pin->flags & GPIO_ACTIVE_LOW) 210 *active = tmp == 0; 211 else 212 *active = tmp != 0; 213 return (0); 214 } 215 216 /* 217 * Note that this function should only 218 * be used in cases where a pre-existing 219 * gpiobus_pin structure exists. In most 220 * cases, the gpio_pin_get_by_* functions 221 * suffice. 222 */ 223 int 224 gpio_pin_acquire(gpio_pin_t gpio) 225 { 226 device_t busdev; 227 228 KASSERT(gpio != NULL, ("GPIO pin is NULL.")); 229 KASSERT(gpio->dev != NULL, ("GPIO pin device is NULL.")); 230 231 busdev = GPIO_GET_BUS(gpio->dev); 232 if (busdev == NULL) 233 return (ENXIO); 234 235 return (gpiobus_acquire_pin(busdev, gpio->pin)); 236 } 237 238 void 239 gpio_pin_release(gpio_pin_t gpio) 240 { 241 device_t busdev; 242 243 KASSERT(gpio != NULL, ("GPIO pin is NULL.")); 244 KASSERT(gpio->dev != NULL, ("GPIO pin device is NULL.")); 245 246 busdev = GPIO_GET_BUS(gpio->dev); 247 KASSERT(busdev != NULL, ("gpiobus dev is NULL.")); 248 249 gpiobus_release_pin(busdev, gpio->pin); 250 free(gpio, M_DEVBUF); 251 } 252 253 int 254 gpio_pin_set_active(gpio_pin_t pin, bool active) 255 { 256 int rv; 257 uint32_t tmp; 258 259 if (pin->flags & GPIO_ACTIVE_LOW) 260 tmp = active ? 0 : 1; 261 else 262 tmp = active ? 1 : 0; 263 264 KASSERT(pin != NULL, ("GPIO pin is NULL.")); 265 KASSERT(pin->dev != NULL, ("GPIO pin device is NULL.")); 266 rv = GPIO_PIN_SET(pin->dev, pin->pin, tmp); 267 return (rv); 268 } 269 270 int 271 gpio_pin_setflags(gpio_pin_t pin, uint32_t flags) 272 { 273 int rv; 274 275 KASSERT(pin != NULL, ("GPIO pin is NULL.")); 276 KASSERT(pin->dev != NULL, ("GPIO pin device is NULL.")); 277 278 rv = GPIO_PIN_SETFLAGS(pin->dev, pin->pin, flags); 279 return (rv); 280 } 281 282 static void 283 gpiobus_print_pins(struct gpiobus_ivar *devi, struct sbuf *sb) 284 { 285 int i, range_start, range_stop, need_coma; 286 287 if (devi->npins == 0) 288 return; 289 290 need_coma = 0; 291 range_start = range_stop = devi->pins[0]; 292 for (i = 1; i < devi->npins; i++) { 293 if (devi->pins[i] != (range_stop + 1)) { 294 if (need_coma) 295 sbuf_cat(sb, ","); 296 if (range_start != range_stop) 297 sbuf_printf(sb, "%d-%d", range_start, range_stop); 298 else 299 sbuf_printf(sb, "%d", range_start); 300 range_start = range_stop = devi->pins[i]; 301 need_coma = 1; 302 } 303 else 304 range_stop++; 305 } 306 307 if (need_coma) 308 sbuf_cat(sb, ","); 309 if (range_start != range_stop) 310 sbuf_printf(sb, "%d-%d", range_start, range_stop); 311 else 312 sbuf_printf(sb, "%d", range_start); 313 } 314 315 device_t 316 gpiobus_add_bus(device_t dev) 317 { 318 device_t busdev; 319 320 busdev = device_add_child(dev, "gpiobus", DEVICE_UNIT_ANY); 321 if (busdev == NULL) 322 return (NULL); 323 if (device_add_child(dev, "gpioc", DEVICE_UNIT_ANY) == NULL) { 324 device_delete_child(dev, busdev); 325 return (NULL); 326 } 327 #ifdef FDT 328 ofw_gpiobus_register_provider(dev); 329 #endif 330 return (busdev); 331 } 332 333 int 334 gpiobus_detach_bus(device_t dev) 335 { 336 #ifdef FDT 337 ofw_gpiobus_unregister_provider(dev); 338 #endif 339 return (bus_generic_detach(dev)); 340 } 341 342 int 343 gpiobus_init_softc(device_t dev) 344 { 345 struct gpiobus_softc *sc; 346 347 sc = GPIOBUS_SOFTC(dev); 348 sc->sc_busdev = dev; 349 sc->sc_dev = device_get_parent(dev); 350 sc->sc_intr_rman.rm_type = RMAN_ARRAY; 351 sc->sc_intr_rman.rm_descr = "GPIO Interrupts"; 352 if (rman_init(&sc->sc_intr_rman) != 0 || 353 rman_manage_region(&sc->sc_intr_rman, 0, ~0) != 0) 354 panic("%s: failed to set up rman.", __func__); 355 356 if (GPIO_PIN_MAX(sc->sc_dev, &sc->sc_npins) != 0) 357 return (ENXIO); 358 359 KASSERT(sc->sc_npins >= 0, ("GPIO device with no pins")); 360 361 /* Pins = GPIO_PIN_MAX() + 1 */ 362 sc->sc_npins++; 363 364 sc->sc_pins = malloc(sizeof(*sc->sc_pins) * sc->sc_npins, M_DEVBUF, 365 M_NOWAIT | M_ZERO); 366 if (sc->sc_pins == NULL) 367 return (ENOMEM); 368 369 /* Initialize the bus lock. */ 370 GPIOBUS_LOCK_INIT(sc); 371 372 return (0); 373 } 374 375 int 376 gpiobus_alloc_ivars(struct gpiobus_ivar *devi) 377 { 378 379 /* Allocate pins and flags memory. */ 380 devi->pins = malloc(sizeof(uint32_t) * devi->npins, M_DEVBUF, 381 M_NOWAIT | M_ZERO); 382 if (devi->pins == NULL) 383 return (ENOMEM); 384 return (0); 385 } 386 387 void 388 gpiobus_free_ivars(struct gpiobus_ivar *devi) 389 { 390 391 if (devi->pins) { 392 free(devi->pins, M_DEVBUF); 393 devi->pins = NULL; 394 } 395 devi->npins = 0; 396 } 397 398 int 399 gpiobus_acquire_pin(device_t bus, uint32_t pin) 400 { 401 struct gpiobus_softc *sc; 402 403 sc = device_get_softc(bus); 404 /* Consistency check. */ 405 if (pin >= sc->sc_npins) { 406 panic("%s: invalid pin %d, max: %d", 407 device_get_nameunit(bus), pin, sc->sc_npins - 1); 408 } 409 /* Mark pin as mapped and give warning if it's already mapped. */ 410 if (sc->sc_pins[pin].mapped) { 411 device_printf(bus, "warning: pin %d is already mapped\n", pin); 412 return (EBUSY); 413 } 414 sc->sc_pins[pin].mapped = 1; 415 416 return (0); 417 } 418 419 /* Release mapped pin */ 420 void 421 gpiobus_release_pin(device_t bus, uint32_t pin) 422 { 423 struct gpiobus_softc *sc; 424 425 sc = device_get_softc(bus); 426 /* Consistency check. */ 427 if (pin >= sc->sc_npins) { 428 panic("%s: invalid pin %d, max: %d", 429 device_get_nameunit(bus), pin, sc->sc_npins - 1); 430 } 431 432 if (!sc->sc_pins[pin].mapped) 433 panic("%s: pin %d is not mapped", device_get_nameunit(bus), 434 pin); 435 436 sc->sc_pins[pin].mapped = 0; 437 } 438 439 static int 440 gpiobus_acquire_child_pins(device_t dev, device_t child) 441 { 442 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); 443 int i; 444 445 for (i = 0; i < devi->npins; i++) { 446 /* Reserve the GPIO pin. */ 447 if (gpiobus_acquire_pin(dev, devi->pins[i]) != 0) { 448 device_printf(child, "cannot acquire pin %d\n", 449 devi->pins[i]); 450 while (--i >= 0) { 451 gpiobus_release_pin(dev, devi->pins[i]); 452 } 453 gpiobus_free_ivars(devi); 454 return (EBUSY); 455 } 456 } 457 for (i = 0; i < devi->npins; i++) { 458 /* Use the child name as pin name. */ 459 GPIOBUS_PIN_SETNAME(dev, devi->pins[i], 460 device_get_nameunit(child)); 461 462 } 463 return (0); 464 } 465 466 static int 467 gpiobus_parse_pins(struct gpiobus_softc *sc, device_t child, int mask) 468 { 469 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); 470 int i, npins; 471 472 npins = 0; 473 for (i = 0; i < 32; i++) { 474 if (mask & (1 << i)) 475 npins++; 476 } 477 if (npins == 0) { 478 device_printf(child, "empty pin mask\n"); 479 return (EINVAL); 480 } 481 devi->npins = npins; 482 if (gpiobus_alloc_ivars(devi) != 0) { 483 device_printf(child, "cannot allocate device ivars\n"); 484 return (EINVAL); 485 } 486 npins = 0; 487 for (i = 0; i < 32; i++) { 488 if ((mask & (1 << i)) == 0) 489 continue; 490 devi->pins[npins++] = i; 491 } 492 493 return (0); 494 } 495 496 static int 497 gpiobus_parse_pin_list(struct gpiobus_softc *sc, device_t child, 498 const char *pins) 499 { 500 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); 501 const char *p; 502 char *endp; 503 unsigned long pin; 504 int i, npins; 505 506 npins = 0; 507 p = pins; 508 for (;;) { 509 pin = strtoul(p, &endp, 0); 510 if (endp == p) 511 break; 512 npins++; 513 if (*endp == '\0') 514 break; 515 p = endp + 1; 516 } 517 518 if (*endp != '\0') { 519 device_printf(child, "garbage in the pin list: %s\n", endp); 520 return (EINVAL); 521 } 522 if (npins == 0) { 523 device_printf(child, "empty pin list\n"); 524 return (EINVAL); 525 } 526 527 devi->npins = npins; 528 if (gpiobus_alloc_ivars(devi) != 0) { 529 device_printf(child, "cannot allocate device ivars\n"); 530 return (EINVAL); 531 } 532 533 i = 0; 534 p = pins; 535 for (;;) { 536 pin = strtoul(p, &endp, 0); 537 538 devi->pins[i] = pin; 539 540 if (*endp == '\0') 541 break; 542 i++; 543 p = endp + 1; 544 } 545 546 return (0); 547 } 548 549 static int 550 gpiobus_probe(device_t dev) 551 { 552 device_set_desc(dev, "GPIO bus"); 553 554 return (BUS_PROBE_GENERIC); 555 } 556 557 int 558 gpiobus_attach(device_t dev) 559 { 560 int err; 561 562 err = gpiobus_init_softc(dev); 563 if (err != 0) 564 return (err); 565 566 /* 567 * Get parent's pins and mark them as unmapped 568 */ 569 bus_identify_children(dev); 570 bus_enumerate_hinted_children(dev); 571 572 bus_attach_children(dev); 573 return (0); 574 } 575 576 /* 577 * Since this is not a self-enumerating bus, and since we always add 578 * children in attach, we have to always delete children here. 579 */ 580 int 581 gpiobus_detach(device_t dev) 582 { 583 struct gpiobus_softc *sc; 584 int i, err; 585 586 sc = GPIOBUS_SOFTC(dev); 587 KASSERT(mtx_initialized(&sc->sc_mtx), 588 ("gpiobus mutex not initialized")); 589 GPIOBUS_LOCK_DESTROY(sc); 590 591 if ((err = bus_detach_children(dev)) != 0) 592 return (err); 593 594 rman_fini(&sc->sc_intr_rman); 595 if (sc->sc_pins) { 596 for (i = 0; i < sc->sc_npins; i++) { 597 if (sc->sc_pins[i].name != NULL) 598 free(sc->sc_pins[i].name, M_DEVBUF); 599 sc->sc_pins[i].name = NULL; 600 } 601 free(sc->sc_pins, M_DEVBUF); 602 sc->sc_pins = NULL; 603 } 604 605 return (0); 606 } 607 608 static int 609 gpiobus_suspend(device_t dev) 610 { 611 612 return (bus_generic_suspend(dev)); 613 } 614 615 static int 616 gpiobus_resume(device_t dev) 617 { 618 619 return (bus_generic_resume(dev)); 620 } 621 622 static void 623 gpiobus_probe_nomatch(device_t dev, device_t child) 624 { 625 char pins[128]; 626 struct sbuf sb; 627 struct gpiobus_ivar *devi; 628 629 devi = GPIOBUS_IVAR(child); 630 sbuf_new(&sb, pins, sizeof(pins), SBUF_FIXEDLEN); 631 gpiobus_print_pins(devi, &sb); 632 sbuf_finish(&sb); 633 device_printf(dev, "<unknown device> at pin%s %s", 634 devi->npins > 1 ? "s" : "", sbuf_data(&sb)); 635 resource_list_print_type(&devi->rl, "irq", SYS_RES_IRQ, "%jd"); 636 printf("\n"); 637 } 638 639 static int 640 gpiobus_print_child(device_t dev, device_t child) 641 { 642 char pins[128]; 643 struct sbuf sb; 644 int retval = 0; 645 struct gpiobus_ivar *devi; 646 647 devi = GPIOBUS_IVAR(child); 648 retval += bus_print_child_header(dev, child); 649 if (devi->npins > 0) { 650 if (devi->npins > 1) 651 retval += printf(" at pins "); 652 else 653 retval += printf(" at pin "); 654 sbuf_new(&sb, pins, sizeof(pins), SBUF_FIXEDLEN); 655 gpiobus_print_pins(devi, &sb); 656 sbuf_finish(&sb); 657 retval += printf("%s", sbuf_data(&sb)); 658 } 659 resource_list_print_type(&devi->rl, "irq", SYS_RES_IRQ, "%jd"); 660 retval += bus_print_child_footer(dev, child); 661 662 return (retval); 663 } 664 665 static int 666 gpiobus_child_location(device_t bus, device_t child, struct sbuf *sb) 667 { 668 struct gpiobus_ivar *devi; 669 670 devi = GPIOBUS_IVAR(child); 671 sbuf_printf(sb, "pins="); 672 gpiobus_print_pins(devi, sb); 673 674 return (0); 675 } 676 677 static device_t 678 gpiobus_add_child(device_t dev, u_int order, const char *name, int unit) 679 { 680 device_t child; 681 struct gpiobus_ivar *devi; 682 683 child = device_add_child_ordered(dev, order, name, unit); 684 if (child == NULL) 685 return (child); 686 devi = malloc(sizeof(struct gpiobus_ivar), M_DEVBUF, M_NOWAIT | M_ZERO); 687 if (devi == NULL) { 688 device_delete_child(dev, child); 689 return (NULL); 690 } 691 resource_list_init(&devi->rl); 692 device_set_ivars(child, devi); 693 694 return (child); 695 } 696 697 static void 698 gpiobus_child_deleted(device_t dev, device_t child) 699 { 700 struct gpiobus_ivar *devi; 701 702 devi = GPIOBUS_IVAR(child); 703 if (devi == NULL) 704 return; 705 gpiobus_free_ivars(devi); 706 resource_list_free(&devi->rl); 707 free(devi, M_DEVBUF); 708 } 709 710 static int 711 gpiobus_rescan(device_t dev) 712 { 713 714 /* 715 * Re-scan is supposed to remove and add children, but if someone has 716 * deleted the hints for a child we attached earlier, we have no easy 717 * way to handle that. So this just attaches new children for whom new 718 * hints or drivers have arrived since we last tried. 719 */ 720 bus_enumerate_hinted_children(dev); 721 bus_attach_children(dev); 722 return (0); 723 } 724 725 static void 726 gpiobus_hinted_child(device_t bus, const char *dname, int dunit) 727 { 728 struct gpiobus_softc *sc = GPIOBUS_SOFTC(bus); 729 device_t child; 730 const char *pins; 731 int irq, pinmask; 732 733 if (device_find_child(bus, dname, dunit) != NULL) { 734 return; 735 } 736 737 child = BUS_ADD_CHILD(bus, 0, dname, dunit); 738 if (resource_int_value(dname, dunit, "pins", &pinmask) == 0) { 739 if (gpiobus_parse_pins(sc, child, pinmask)) { 740 device_delete_child(bus, child); 741 return; 742 } 743 } 744 else if (resource_string_value(dname, dunit, "pin_list", &pins) == 0) { 745 if (gpiobus_parse_pin_list(sc, child, pins)) { 746 device_delete_child(bus, child); 747 return; 748 } 749 } 750 if (resource_int_value(dname, dunit, "irq", &irq) == 0) { 751 if (bus_set_resource(child, SYS_RES_IRQ, 0, irq, 1) != 0) 752 device_printf(bus, 753 "warning: bus_set_resource() failed\n"); 754 } 755 } 756 757 int 758 gpiobus_read_ivar(device_t dev, device_t child, int which, uintptr_t *result) 759 { 760 struct gpiobus_ivar *devi; 761 762 devi = GPIOBUS_IVAR(child); 763 switch (which) { 764 case GPIOBUS_IVAR_NPINS: 765 *result = devi->npins; 766 break; 767 case GPIOBUS_IVAR_PINS: 768 /* Children do not ever need to directly examine this. */ 769 return (ENOTSUP); 770 default: 771 return (ENOENT); 772 } 773 774 return (0); 775 } 776 777 static int 778 gpiobus_write_ivar(device_t dev, device_t child, int which, uintptr_t value) 779 { 780 struct gpiobus_ivar *devi; 781 const uint32_t *ptr; 782 int i; 783 784 devi = GPIOBUS_IVAR(child); 785 switch (which) { 786 case GPIOBUS_IVAR_NPINS: 787 /* GPIO ivars are set once. */ 788 if (devi->npins != 0) { 789 return (EBUSY); 790 } 791 devi->npins = value; 792 if (gpiobus_alloc_ivars(devi) != 0) { 793 device_printf(child, "cannot allocate device ivars\n"); 794 devi->npins = 0; 795 return (ENOMEM); 796 } 797 break; 798 case GPIOBUS_IVAR_PINS: 799 ptr = (const uint32_t *)value; 800 for (i = 0; i < devi->npins; i++) 801 devi->pins[i] = ptr[i]; 802 if (gpiobus_acquire_child_pins(dev, child) != 0) 803 return (EBUSY); 804 break; 805 default: 806 return (ENOENT); 807 } 808 809 return (0); 810 } 811 812 static struct rman * 813 gpiobus_get_rman(device_t bus, int type, u_int flags) 814 { 815 struct gpiobus_softc *sc; 816 817 sc = device_get_softc(bus); 818 switch (type) { 819 case SYS_RES_IRQ: 820 return (&sc->sc_intr_rman); 821 default: 822 return (NULL); 823 } 824 } 825 826 static struct resource * 827 gpiobus_alloc_resource(device_t bus, device_t child, int type, int *rid, 828 rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 829 { 830 struct resource_list *rl; 831 struct resource_list_entry *rle; 832 int isdefault; 833 834 isdefault = (RMAN_IS_DEFAULT_RANGE(start, end) && count == 1); 835 if (isdefault) { 836 rl = BUS_GET_RESOURCE_LIST(bus, child); 837 if (rl == NULL) 838 return (NULL); 839 rle = resource_list_find(rl, type, *rid); 840 if (rle == NULL) 841 return (NULL); 842 start = rle->start; 843 count = rle->count; 844 end = rle->end; 845 } 846 return (bus_generic_rman_alloc_resource(bus, child, type, rid, start, 847 end, count, flags)); 848 } 849 850 static int 851 gpiobus_release_resource(device_t dev, device_t child, struct resource *r) 852 { 853 int err; 854 #ifdef INTRNG 855 u_int irq; 856 857 irq = rman_get_start(r); 858 MPASS(irq == rman_get_end(r)); 859 #endif 860 err = bus_generic_rman_release_resource(dev, child, r); 861 if (err != 0) 862 return (err); 863 #ifdef INTRNG 864 intr_unmap_irq(irq); 865 #endif 866 return (0); 867 } 868 869 static struct resource_list * 870 gpiobus_get_resource_list(device_t bus __unused, device_t child) 871 { 872 struct gpiobus_ivar *ivar; 873 874 ivar = GPIOBUS_IVAR(child); 875 876 return (&ivar->rl); 877 } 878 879 static int 880 gpiobus_acquire_bus(device_t busdev, device_t child, int how) 881 { 882 struct gpiobus_softc *sc; 883 884 sc = device_get_softc(busdev); 885 GPIOBUS_ASSERT_UNLOCKED(sc); 886 GPIOBUS_LOCK(sc); 887 if (sc->sc_owner != NULL) { 888 if (sc->sc_owner == child) 889 panic("%s: %s still owns the bus.", 890 device_get_nameunit(busdev), 891 device_get_nameunit(child)); 892 if (how == GPIOBUS_DONTWAIT) { 893 GPIOBUS_UNLOCK(sc); 894 return (EWOULDBLOCK); 895 } 896 while (sc->sc_owner != NULL) 897 mtx_sleep(sc, &sc->sc_mtx, 0, "gpiobuswait", 0); 898 } 899 sc->sc_owner = child; 900 GPIOBUS_UNLOCK(sc); 901 902 return (0); 903 } 904 905 static void 906 gpiobus_release_bus(device_t busdev, device_t child) 907 { 908 struct gpiobus_softc *sc; 909 910 sc = device_get_softc(busdev); 911 GPIOBUS_ASSERT_UNLOCKED(sc); 912 GPIOBUS_LOCK(sc); 913 if (sc->sc_owner == NULL) 914 panic("%s: %s releasing unowned bus.", 915 device_get_nameunit(busdev), 916 device_get_nameunit(child)); 917 if (sc->sc_owner != child) 918 panic("%s: %s trying to release bus owned by %s", 919 device_get_nameunit(busdev), 920 device_get_nameunit(child), 921 device_get_nameunit(sc->sc_owner)); 922 sc->sc_owner = NULL; 923 wakeup(sc); 924 GPIOBUS_UNLOCK(sc); 925 } 926 927 static int 928 gpiobus_pin_setflags(device_t dev, device_t child, uint32_t pin, 929 uint32_t flags) 930 { 931 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev); 932 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); 933 uint32_t caps; 934 935 if (pin >= devi->npins) 936 return (EINVAL); 937 if (GPIO_PIN_GETCAPS(sc->sc_dev, devi->pins[pin], &caps) != 0) 938 return (EINVAL); 939 if (gpio_check_flags(caps, flags) != 0) 940 return (EINVAL); 941 942 return (GPIO_PIN_SETFLAGS(sc->sc_dev, devi->pins[pin], flags)); 943 } 944 945 static int 946 gpiobus_pin_getflags(device_t dev, device_t child, uint32_t pin, 947 uint32_t *flags) 948 { 949 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev); 950 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); 951 952 if (pin >= devi->npins) 953 return (EINVAL); 954 955 return GPIO_PIN_GETFLAGS(sc->sc_dev, devi->pins[pin], flags); 956 } 957 958 static int 959 gpiobus_pin_getcaps(device_t dev, device_t child, uint32_t pin, 960 uint32_t *caps) 961 { 962 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev); 963 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); 964 965 if (pin >= devi->npins) 966 return (EINVAL); 967 968 return GPIO_PIN_GETCAPS(sc->sc_dev, devi->pins[pin], caps); 969 } 970 971 static int 972 gpiobus_pin_set(device_t dev, device_t child, uint32_t pin, 973 unsigned int value) 974 { 975 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev); 976 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); 977 978 if (pin >= devi->npins) 979 return (EINVAL); 980 981 return GPIO_PIN_SET(sc->sc_dev, devi->pins[pin], value); 982 } 983 984 static int 985 gpiobus_pin_get(device_t dev, device_t child, uint32_t pin, 986 unsigned int *value) 987 { 988 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev); 989 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); 990 991 if (pin >= devi->npins) 992 return (EINVAL); 993 994 return GPIO_PIN_GET(sc->sc_dev, devi->pins[pin], value); 995 } 996 997 static int 998 gpiobus_pin_toggle(device_t dev, device_t child, uint32_t pin) 999 { 1000 struct gpiobus_softc *sc = GPIOBUS_SOFTC(dev); 1001 struct gpiobus_ivar *devi = GPIOBUS_IVAR(child); 1002 1003 if (pin >= devi->npins) 1004 return (EINVAL); 1005 1006 return GPIO_PIN_TOGGLE(sc->sc_dev, devi->pins[pin]); 1007 } 1008 1009 static int 1010 gpiobus_pin_getname(device_t dev, uint32_t pin, char *name) 1011 { 1012 struct gpiobus_softc *sc; 1013 1014 sc = GPIOBUS_SOFTC(dev); 1015 if (pin > sc->sc_npins) 1016 return (EINVAL); 1017 /* Did we have a name for this pin ? */ 1018 if (sc->sc_pins[pin].name != NULL) { 1019 memcpy(name, sc->sc_pins[pin].name, GPIOMAXNAME); 1020 return (0); 1021 } 1022 1023 /* Return the default pin name. */ 1024 return (GPIO_PIN_GETNAME(device_get_parent(dev), pin, name)); 1025 } 1026 1027 static int 1028 gpiobus_pin_setname(device_t dev, uint32_t pin, const char *name) 1029 { 1030 struct gpiobus_softc *sc; 1031 1032 sc = GPIOBUS_SOFTC(dev); 1033 if (pin > sc->sc_npins) 1034 return (EINVAL); 1035 if (name == NULL) 1036 return (EINVAL); 1037 /* Save the pin name. */ 1038 if (sc->sc_pins[pin].name == NULL) 1039 sc->sc_pins[pin].name = malloc(GPIOMAXNAME, M_DEVBUF, 1040 M_WAITOK | M_ZERO); 1041 strlcpy(sc->sc_pins[pin].name, name, GPIOMAXNAME); 1042 1043 return (0); 1044 } 1045 1046 static device_method_t gpiobus_methods[] = { 1047 /* Device interface */ 1048 DEVMETHOD(device_probe, gpiobus_probe), 1049 DEVMETHOD(device_attach, gpiobus_attach), 1050 DEVMETHOD(device_detach, gpiobus_detach), 1051 DEVMETHOD(device_shutdown, bus_generic_shutdown), 1052 DEVMETHOD(device_suspend, gpiobus_suspend), 1053 DEVMETHOD(device_resume, gpiobus_resume), 1054 1055 /* Bus interface */ 1056 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr), 1057 DEVMETHOD(bus_config_intr, bus_generic_config_intr), 1058 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr), 1059 DEVMETHOD(bus_delete_resource, bus_generic_rl_delete_resource), 1060 DEVMETHOD(bus_get_resource, bus_generic_rl_get_resource), 1061 DEVMETHOD(bus_set_resource, bus_generic_rl_set_resource), 1062 DEVMETHOD(bus_alloc_resource, gpiobus_alloc_resource), 1063 DEVMETHOD(bus_release_resource, gpiobus_release_resource), 1064 DEVMETHOD(bus_activate_resource, bus_generic_rman_activate_resource), 1065 DEVMETHOD(bus_deactivate_resource, bus_generic_rman_deactivate_resource), 1066 DEVMETHOD(bus_get_resource_list, gpiobus_get_resource_list), 1067 DEVMETHOD(bus_get_rman, gpiobus_get_rman), 1068 DEVMETHOD(bus_add_child, gpiobus_add_child), 1069 DEVMETHOD(bus_child_deleted, gpiobus_child_deleted), 1070 DEVMETHOD(bus_rescan, gpiobus_rescan), 1071 DEVMETHOD(bus_probe_nomatch, gpiobus_probe_nomatch), 1072 DEVMETHOD(bus_print_child, gpiobus_print_child), 1073 DEVMETHOD(bus_child_location, gpiobus_child_location), 1074 DEVMETHOD(bus_hinted_child, gpiobus_hinted_child), 1075 DEVMETHOD(bus_read_ivar, gpiobus_read_ivar), 1076 DEVMETHOD(bus_write_ivar, gpiobus_write_ivar), 1077 1078 /* GPIO protocol */ 1079 DEVMETHOD(gpiobus_acquire_bus, gpiobus_acquire_bus), 1080 DEVMETHOD(gpiobus_release_bus, gpiobus_release_bus), 1081 DEVMETHOD(gpiobus_pin_getflags, gpiobus_pin_getflags), 1082 DEVMETHOD(gpiobus_pin_getcaps, gpiobus_pin_getcaps), 1083 DEVMETHOD(gpiobus_pin_setflags, gpiobus_pin_setflags), 1084 DEVMETHOD(gpiobus_pin_get, gpiobus_pin_get), 1085 DEVMETHOD(gpiobus_pin_set, gpiobus_pin_set), 1086 DEVMETHOD(gpiobus_pin_toggle, gpiobus_pin_toggle), 1087 DEVMETHOD(gpiobus_pin_getname, gpiobus_pin_getname), 1088 DEVMETHOD(gpiobus_pin_setname, gpiobus_pin_setname), 1089 1090 DEVMETHOD_END 1091 }; 1092 1093 driver_t gpiobus_driver = { 1094 "gpiobus", 1095 gpiobus_methods, 1096 sizeof(struct gpiobus_softc) 1097 }; 1098 1099 EARLY_DRIVER_MODULE(gpiobus, gpio, gpiobus_driver, 0, 0, 1100 BUS_PASS_BUS + BUS_PASS_ORDER_MIDDLE); 1101 MODULE_VERSION(gpiobus, 1); 1102