1 /*- 2 * Copyright (c) 2012 Oleksandr Tymoshenko <gonzo@freebsd.org> 3 * Copyright (c) 2012 Luiz Otavio O Souza. 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 THE 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 THE 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 #include <sys/cdefs.h> 29 __FBSDID("$FreeBSD$"); 30 31 #include <sys/param.h> 32 #include <sys/systm.h> 33 #include <sys/bus.h> 34 35 #include <sys/kernel.h> 36 #include <sys/module.h> 37 #include <sys/rman.h> 38 #include <sys/lock.h> 39 #include <sys/mutex.h> 40 #include <sys/gpio.h> 41 #include <sys/sysctl.h> 42 43 #include <machine/bus.h> 44 #include <machine/cpu.h> 45 #include <machine/cpufunc.h> 46 #include <machine/resource.h> 47 #include <machine/fdt.h> 48 #include <machine/intr.h> 49 50 #include <dev/fdt/fdt_common.h> 51 #include <dev/ofw/ofw_bus.h> 52 #include <dev/ofw/ofw_bus_subr.h> 53 54 #include <arm/broadcom/bcm2835/bcm2835_gpio.h> 55 56 #include "gpio_if.h" 57 58 #ifdef DEBUG 59 #define dprintf(fmt, args...) do { printf("%s(): ", __func__); \ 60 printf(fmt,##args); } while (0) 61 #else 62 #define dprintf(fmt, args...) 63 #endif 64 65 #define BCM_GPIO_PINS 54 66 #define BCM_GPIO_DEFAULT_CAPS (GPIO_PIN_INPUT | GPIO_PIN_OUTPUT | \ 67 GPIO_PIN_PULLUP | GPIO_PIN_PULLDOWN) 68 69 struct bcm_gpio_sysctl { 70 struct bcm_gpio_softc *sc; 71 uint32_t pin; 72 }; 73 74 struct bcm_gpio_softc { 75 device_t sc_dev; 76 struct mtx sc_mtx; 77 struct resource * sc_mem_res; 78 struct resource * sc_irq_res; 79 bus_space_tag_t sc_bst; 80 bus_space_handle_t sc_bsh; 81 void * sc_intrhand; 82 int sc_gpio_npins; 83 int sc_ro_npins; 84 int sc_ro_pins[BCM_GPIO_PINS]; 85 struct gpio_pin sc_gpio_pins[BCM_GPIO_PINS]; 86 struct bcm_gpio_sysctl sc_sysctl[BCM_GPIO_PINS]; 87 }; 88 89 enum bcm_gpio_pud { 90 BCM_GPIO_NONE, 91 BCM_GPIO_PULLDOWN, 92 BCM_GPIO_PULLUP, 93 }; 94 95 #define BCM_GPIO_LOCK(_sc) mtx_lock(&_sc->sc_mtx) 96 #define BCM_GPIO_UNLOCK(_sc) mtx_unlock(&_sc->sc_mtx) 97 #define BCM_GPIO_LOCK_ASSERT(_sc) mtx_assert(&_sc->sc_mtx, MA_OWNED) 98 99 #define BCM_GPIO_GPFSEL(_bank) 0x00 + _bank * 4 100 #define BCM_GPIO_GPSET(_bank) 0x1c + _bank * 4 101 #define BCM_GPIO_GPCLR(_bank) 0x28 + _bank * 4 102 #define BCM_GPIO_GPLEV(_bank) 0x34 + _bank * 4 103 #define BCM_GPIO_GPPUD(_bank) 0x94 104 #define BCM_GPIO_GPPUDCLK(_bank) 0x98 + _bank * 4 105 106 #define BCM_GPIO_WRITE(_sc, _off, _val) \ 107 bus_space_write_4(_sc->sc_bst, _sc->sc_bsh, _off, _val) 108 #define BCM_GPIO_READ(_sc, _off) \ 109 bus_space_read_4(_sc->sc_bst, _sc->sc_bsh, _off) 110 111 static int 112 bcm_gpio_pin_is_ro(struct bcm_gpio_softc *sc, int pin) 113 { 114 int i; 115 116 for (i = 0; i < sc->sc_ro_npins; i++) 117 if (pin == sc->sc_ro_pins[i]) 118 return (1); 119 return (0); 120 } 121 122 static uint32_t 123 bcm_gpio_get_function(struct bcm_gpio_softc *sc, uint32_t pin) 124 { 125 uint32_t bank, func, offset; 126 127 /* Five banks, 10 pins per bank, 3 bits per pin. */ 128 bank = pin / 10; 129 offset = (pin - bank * 10) * 3; 130 131 BCM_GPIO_LOCK(sc); 132 func = (BCM_GPIO_READ(sc, BCM_GPIO_GPFSEL(bank)) >> offset) & 7; 133 BCM_GPIO_UNLOCK(sc); 134 135 return (func); 136 } 137 138 static void 139 bcm_gpio_func_str(uint32_t nfunc, char *buf, int bufsize) 140 { 141 142 switch (nfunc) { 143 case BCM_GPIO_INPUT: 144 strncpy(buf, "input", bufsize); 145 break; 146 case BCM_GPIO_OUTPUT: 147 strncpy(buf, "output", bufsize); 148 break; 149 case BCM_GPIO_ALT0: 150 strncpy(buf, "alt0", bufsize); 151 break; 152 case BCM_GPIO_ALT1: 153 strncpy(buf, "alt1", bufsize); 154 break; 155 case BCM_GPIO_ALT2: 156 strncpy(buf, "alt2", bufsize); 157 break; 158 case BCM_GPIO_ALT3: 159 strncpy(buf, "alt3", bufsize); 160 break; 161 case BCM_GPIO_ALT4: 162 strncpy(buf, "alt4", bufsize); 163 break; 164 case BCM_GPIO_ALT5: 165 strncpy(buf, "alt5", bufsize); 166 break; 167 default: 168 strncpy(buf, "invalid", bufsize); 169 } 170 } 171 172 static int 173 bcm_gpio_str_func(char *func, uint32_t *nfunc) 174 { 175 176 if (strcasecmp(func, "input") == 0) 177 *nfunc = BCM_GPIO_INPUT; 178 else if (strcasecmp(func, "output") == 0) 179 *nfunc = BCM_GPIO_OUTPUT; 180 else if (strcasecmp(func, "alt0") == 0) 181 *nfunc = BCM_GPIO_ALT0; 182 else if (strcasecmp(func, "alt1") == 0) 183 *nfunc = BCM_GPIO_ALT1; 184 else if (strcasecmp(func, "alt2") == 0) 185 *nfunc = BCM_GPIO_ALT2; 186 else if (strcasecmp(func, "alt3") == 0) 187 *nfunc = BCM_GPIO_ALT3; 188 else if (strcasecmp(func, "alt4") == 0) 189 *nfunc = BCM_GPIO_ALT4; 190 else if (strcasecmp(func, "alt5") == 0) 191 *nfunc = BCM_GPIO_ALT5; 192 else 193 return (-1); 194 195 return (0); 196 } 197 198 static uint32_t 199 bcm_gpio_func_flag(uint32_t nfunc) 200 { 201 202 switch (nfunc) { 203 case BCM_GPIO_INPUT: 204 return (GPIO_PIN_INPUT); 205 case BCM_GPIO_OUTPUT: 206 return (GPIO_PIN_OUTPUT); 207 } 208 return (0); 209 } 210 211 static void 212 bcm_gpio_set_function(struct bcm_gpio_softc *sc, uint32_t pin, uint32_t f) 213 { 214 uint32_t bank, data, offset; 215 216 /* Must be called with lock held. */ 217 BCM_GPIO_LOCK_ASSERT(sc); 218 219 /* Five banks, 10 pins per bank, 3 bits per pin. */ 220 bank = pin / 10; 221 offset = (pin - bank * 10) * 3; 222 223 data = BCM_GPIO_READ(sc, BCM_GPIO_GPFSEL(bank)); 224 data &= ~(7 << offset); 225 data |= (f << offset); 226 BCM_GPIO_WRITE(sc, BCM_GPIO_GPFSEL(bank), data); 227 } 228 229 static void 230 bcm_gpio_set_pud(struct bcm_gpio_softc *sc, uint32_t pin, uint32_t state) 231 { 232 uint32_t bank, offset; 233 234 /* Must be called with lock held. */ 235 BCM_GPIO_LOCK_ASSERT(sc); 236 237 bank = pin / 32; 238 offset = pin - 32 * bank; 239 240 BCM_GPIO_WRITE(sc, BCM_GPIO_GPPUD(0), state); 241 BCM_GPIO_WRITE(sc, BCM_GPIO_GPPUDCLK(bank), (1 << offset)); 242 BCM_GPIO_WRITE(sc, BCM_GPIO_GPPUD(0), 0); 243 BCM_GPIO_WRITE(sc, BCM_GPIO_GPPUDCLK(bank), 0); 244 } 245 246 void 247 bcm_gpio_set_alternate(device_t dev, uint32_t pin, uint32_t nfunc) 248 { 249 struct bcm_gpio_softc *sc; 250 int i; 251 252 sc = device_get_softc(dev); 253 BCM_GPIO_LOCK(sc); 254 255 /* Disable pull-up or pull-down on pin. */ 256 bcm_gpio_set_pud(sc, pin, BCM_GPIO_NONE); 257 258 /* And now set the pin function. */ 259 bcm_gpio_set_function(sc, pin, nfunc); 260 261 /* Update the pin flags. */ 262 for (i = 0; i < sc->sc_gpio_npins; i++) { 263 if (sc->sc_gpio_pins[i].gp_pin == pin) 264 break; 265 } 266 if (i < sc->sc_gpio_npins) 267 sc->sc_gpio_pins[i].gp_flags = bcm_gpio_func_flag(nfunc); 268 269 BCM_GPIO_UNLOCK(sc); 270 } 271 272 static void 273 bcm_gpio_pin_configure(struct bcm_gpio_softc *sc, struct gpio_pin *pin, 274 unsigned int flags) 275 { 276 277 BCM_GPIO_LOCK(sc); 278 279 /* 280 * Manage input/output. 281 */ 282 if (flags & (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) { 283 pin->gp_flags &= ~(GPIO_PIN_INPUT|GPIO_PIN_OUTPUT); 284 if (flags & GPIO_PIN_OUTPUT) { 285 pin->gp_flags |= GPIO_PIN_OUTPUT; 286 bcm_gpio_set_function(sc, pin->gp_pin, 287 BCM_GPIO_OUTPUT); 288 } else { 289 pin->gp_flags |= GPIO_PIN_INPUT; 290 bcm_gpio_set_function(sc, pin->gp_pin, 291 BCM_GPIO_INPUT); 292 } 293 } 294 295 /* Manage Pull-up/pull-down. */ 296 pin->gp_flags &= ~(GPIO_PIN_PULLUP|GPIO_PIN_PULLDOWN); 297 if (flags & (GPIO_PIN_PULLUP|GPIO_PIN_PULLDOWN)) { 298 if (flags & GPIO_PIN_PULLUP) { 299 pin->gp_flags |= GPIO_PIN_PULLUP; 300 bcm_gpio_set_pud(sc, pin->gp_pin, BCM_GPIO_PULLUP); 301 } else { 302 pin->gp_flags |= GPIO_PIN_PULLDOWN; 303 bcm_gpio_set_pud(sc, pin->gp_pin, BCM_GPIO_PULLDOWN); 304 } 305 } else 306 bcm_gpio_set_pud(sc, pin->gp_pin, BCM_GPIO_NONE); 307 308 BCM_GPIO_UNLOCK(sc); 309 } 310 311 static int 312 bcm_gpio_pin_max(device_t dev, int *maxpin) 313 { 314 315 *maxpin = BCM_GPIO_PINS - 1; 316 return (0); 317 } 318 319 static int 320 bcm_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps) 321 { 322 struct bcm_gpio_softc *sc = device_get_softc(dev); 323 int i; 324 325 for (i = 0; i < sc->sc_gpio_npins; i++) { 326 if (sc->sc_gpio_pins[i].gp_pin == pin) 327 break; 328 } 329 330 if (i >= sc->sc_gpio_npins) 331 return (EINVAL); 332 333 BCM_GPIO_LOCK(sc); 334 *caps = sc->sc_gpio_pins[i].gp_caps; 335 BCM_GPIO_UNLOCK(sc); 336 337 return (0); 338 } 339 340 static int 341 bcm_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags) 342 { 343 struct bcm_gpio_softc *sc = device_get_softc(dev); 344 int i; 345 346 for (i = 0; i < sc->sc_gpio_npins; i++) { 347 if (sc->sc_gpio_pins[i].gp_pin == pin) 348 break; 349 } 350 351 if (i >= sc->sc_gpio_npins) 352 return (EINVAL); 353 354 BCM_GPIO_LOCK(sc); 355 *flags = sc->sc_gpio_pins[i].gp_flags; 356 BCM_GPIO_UNLOCK(sc); 357 358 return (0); 359 } 360 361 static int 362 bcm_gpio_pin_getname(device_t dev, uint32_t pin, char *name) 363 { 364 struct bcm_gpio_softc *sc = device_get_softc(dev); 365 int i; 366 367 for (i = 0; i < sc->sc_gpio_npins; i++) { 368 if (sc->sc_gpio_pins[i].gp_pin == pin) 369 break; 370 } 371 372 if (i >= sc->sc_gpio_npins) 373 return (EINVAL); 374 375 BCM_GPIO_LOCK(sc); 376 memcpy(name, sc->sc_gpio_pins[i].gp_name, GPIOMAXNAME); 377 BCM_GPIO_UNLOCK(sc); 378 379 return (0); 380 } 381 382 static int 383 bcm_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags) 384 { 385 struct bcm_gpio_softc *sc = device_get_softc(dev); 386 int i; 387 388 for (i = 0; i < sc->sc_gpio_npins; i++) { 389 if (sc->sc_gpio_pins[i].gp_pin == pin) 390 break; 391 } 392 393 if (i >= sc->sc_gpio_npins) 394 return (EINVAL); 395 396 /* We never touch on read-only/reserved pins. */ 397 if (bcm_gpio_pin_is_ro(sc, pin)) 398 return (EINVAL); 399 400 bcm_gpio_pin_configure(sc, &sc->sc_gpio_pins[i], flags); 401 402 return (0); 403 } 404 405 static int 406 bcm_gpio_pin_set(device_t dev, uint32_t pin, unsigned int value) 407 { 408 struct bcm_gpio_softc *sc = device_get_softc(dev); 409 uint32_t bank, offset; 410 int i; 411 412 for (i = 0; i < sc->sc_gpio_npins; i++) { 413 if (sc->sc_gpio_pins[i].gp_pin == pin) 414 break; 415 } 416 417 if (i >= sc->sc_gpio_npins) 418 return (EINVAL); 419 420 /* We never write to read-only/reserved pins. */ 421 if (bcm_gpio_pin_is_ro(sc, pin)) 422 return (EINVAL); 423 424 bank = pin / 32; 425 offset = pin - 32 * bank; 426 427 BCM_GPIO_LOCK(sc); 428 if (value) 429 BCM_GPIO_WRITE(sc, BCM_GPIO_GPSET(bank), (1 << offset)); 430 else 431 BCM_GPIO_WRITE(sc, BCM_GPIO_GPCLR(bank), (1 << offset)); 432 BCM_GPIO_UNLOCK(sc); 433 434 return (0); 435 } 436 437 static int 438 bcm_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val) 439 { 440 struct bcm_gpio_softc *sc = device_get_softc(dev); 441 uint32_t bank, offset, reg_data; 442 int i; 443 444 for (i = 0; i < sc->sc_gpio_npins; i++) { 445 if (sc->sc_gpio_pins[i].gp_pin == pin) 446 break; 447 } 448 449 if (i >= sc->sc_gpio_npins) 450 return (EINVAL); 451 452 bank = pin / 32; 453 offset = pin - 32 * bank; 454 455 BCM_GPIO_LOCK(sc); 456 reg_data = BCM_GPIO_READ(sc, BCM_GPIO_GPLEV(bank)); 457 BCM_GPIO_UNLOCK(sc); 458 *val = (reg_data & (1 << offset)) ? 1 : 0; 459 460 return (0); 461 } 462 463 static int 464 bcm_gpio_pin_toggle(device_t dev, uint32_t pin) 465 { 466 struct bcm_gpio_softc *sc = device_get_softc(dev); 467 uint32_t bank, data, offset; 468 int i; 469 470 for (i = 0; i < sc->sc_gpio_npins; i++) { 471 if (sc->sc_gpio_pins[i].gp_pin == pin) 472 break; 473 } 474 475 if (i >= sc->sc_gpio_npins) 476 return (EINVAL); 477 478 /* We never write to read-only/reserved pins. */ 479 if (bcm_gpio_pin_is_ro(sc, pin)) 480 return (EINVAL); 481 482 bank = pin / 32; 483 offset = pin - 32 * bank; 484 485 BCM_GPIO_LOCK(sc); 486 data = BCM_GPIO_READ(sc, BCM_GPIO_GPLEV(bank)); 487 if (data & (1 << offset)) 488 BCM_GPIO_WRITE(sc, BCM_GPIO_GPCLR(bank), (1 << offset)); 489 else 490 BCM_GPIO_WRITE(sc, BCM_GPIO_GPSET(bank), (1 << offset)); 491 BCM_GPIO_UNLOCK(sc); 492 493 return (0); 494 } 495 496 static int 497 bcm_gpio_get_ro_pins(struct bcm_gpio_softc *sc) 498 { 499 int i, len; 500 pcell_t pins[BCM_GPIO_PINS]; 501 phandle_t gpio; 502 503 /* Find the gpio node to start. */ 504 gpio = ofw_bus_get_node(sc->sc_dev); 505 506 len = OF_getproplen(gpio, "broadcom,read-only"); 507 if (len < 0 || len > sizeof(pins)) 508 return (-1); 509 510 if (OF_getprop(gpio, "broadcom,read-only", &pins, len) < 0) 511 return (-1); 512 513 sc->sc_ro_npins = len / sizeof(pcell_t); 514 515 device_printf(sc->sc_dev, "read-only pins: "); 516 for (i = 0; i < sc->sc_ro_npins; i++) { 517 sc->sc_ro_pins[i] = fdt32_to_cpu(pins[i]); 518 if (i > 0) 519 printf(","); 520 printf("%d", sc->sc_ro_pins[i]); 521 } 522 if (i > 0) 523 printf("."); 524 printf("\n"); 525 526 return (0); 527 } 528 529 static int 530 bcm_gpio_func_proc(SYSCTL_HANDLER_ARGS) 531 { 532 char buf[16]; 533 struct bcm_gpio_softc *sc; 534 struct bcm_gpio_sysctl *sc_sysctl; 535 uint32_t nfunc; 536 int error; 537 538 sc_sysctl = arg1; 539 sc = sc_sysctl->sc; 540 541 /* Get the current pin function. */ 542 nfunc = bcm_gpio_get_function(sc, sc_sysctl->pin); 543 bcm_gpio_func_str(nfunc, buf, sizeof(buf)); 544 545 error = sysctl_handle_string(oidp, buf, sizeof(buf), req); 546 if (error != 0 || req->newptr == NULL) 547 return (error); 548 549 /* Parse the user supplied string and check for a valid pin function. */ 550 if (bcm_gpio_str_func(buf, &nfunc) != 0) 551 return (EINVAL); 552 553 /* Update the pin alternate function. */ 554 bcm_gpio_set_alternate(sc->sc_dev, sc_sysctl->pin, nfunc); 555 556 return (0); 557 } 558 559 static void 560 bcm_gpio_sysctl_init(struct bcm_gpio_softc *sc) 561 { 562 char pinbuf[3]; 563 struct bcm_gpio_sysctl *sc_sysctl; 564 struct sysctl_ctx_list *ctx; 565 struct sysctl_oid *tree_node, *pin_node, *pinN_node; 566 struct sysctl_oid_list *tree, *pin_tree, *pinN_tree; 567 int i; 568 569 /* 570 * Add per-pin sysctl tree/handlers. 571 */ 572 ctx = device_get_sysctl_ctx(sc->sc_dev); 573 tree_node = device_get_sysctl_tree(sc->sc_dev); 574 tree = SYSCTL_CHILDREN(tree_node); 575 pin_node = SYSCTL_ADD_NODE(ctx, tree, OID_AUTO, "pin", 576 CTLFLAG_RD, NULL, "GPIO Pins"); 577 pin_tree = SYSCTL_CHILDREN(pin_node); 578 579 for (i = 0; i < sc->sc_gpio_npins; i++) { 580 581 snprintf(pinbuf, sizeof(pinbuf), "%d", i); 582 pinN_node = SYSCTL_ADD_NODE(ctx, pin_tree, OID_AUTO, pinbuf, 583 CTLFLAG_RD, NULL, "GPIO Pin"); 584 pinN_tree = SYSCTL_CHILDREN(pinN_node); 585 586 sc->sc_sysctl[i].sc = sc; 587 sc_sysctl = &sc->sc_sysctl[i]; 588 sc_sysctl->sc = sc; 589 sc_sysctl->pin = sc->sc_gpio_pins[i].gp_pin; 590 SYSCTL_ADD_PROC(ctx, pinN_tree, OID_AUTO, "function", 591 CTLFLAG_RW | CTLTYPE_STRING, sc_sysctl, 592 sizeof(struct bcm_gpio_sysctl), bcm_gpio_func_proc, 593 "A", "Pin Function"); 594 } 595 } 596 597 static int 598 bcm_gpio_get_reserved_pins(struct bcm_gpio_softc *sc) 599 { 600 int i, j, len, npins; 601 pcell_t pins[BCM_GPIO_PINS]; 602 phandle_t gpio, node, reserved; 603 char name[32]; 604 605 /* Get read-only pins. */ 606 if (bcm_gpio_get_ro_pins(sc) != 0) 607 return (-1); 608 609 /* Find the gpio/reserved pins node to start. */ 610 gpio = ofw_bus_get_node(sc->sc_dev); 611 node = OF_child(gpio); 612 613 /* 614 * Find reserved node 615 */ 616 reserved = 0; 617 while ((node != 0) && (reserved == 0)) { 618 len = OF_getprop(node, "name", name, 619 sizeof(name) - 1); 620 name[len] = 0; 621 if (strcmp(name, "reserved") == 0) 622 reserved = node; 623 node = OF_peer(node); 624 } 625 626 if (reserved == 0) 627 return (-1); 628 629 /* Get the reserved pins. */ 630 len = OF_getproplen(reserved, "broadcom,pins"); 631 if (len < 0 || len > sizeof(pins)) 632 return (-1); 633 634 if (OF_getprop(reserved, "broadcom,pins", &pins, len) < 0) 635 return (-1); 636 637 npins = len / sizeof(pcell_t); 638 639 j = 0; 640 device_printf(sc->sc_dev, "reserved pins: "); 641 for (i = 0; i < npins; i++) { 642 if (i > 0) 643 printf(","); 644 printf("%d", fdt32_to_cpu(pins[i])); 645 /* Some pins maybe already on the list of read-only pins. */ 646 if (bcm_gpio_pin_is_ro(sc, fdt32_to_cpu(pins[i]))) 647 continue; 648 sc->sc_ro_pins[j++ + sc->sc_ro_npins] = fdt32_to_cpu(pins[i]); 649 } 650 sc->sc_ro_npins += j; 651 if (i > 0) 652 printf("."); 653 printf("\n"); 654 655 return (0); 656 } 657 658 static int 659 bcm_gpio_probe(device_t dev) 660 { 661 662 if (!ofw_bus_status_okay(dev)) 663 return (ENXIO); 664 665 if (!ofw_bus_is_compatible(dev, "broadcom,bcm2835-gpio")) 666 return (ENXIO); 667 668 device_set_desc(dev, "BCM2708/2835 GPIO controller"); 669 return (BUS_PROBE_DEFAULT); 670 } 671 672 static int 673 bcm_gpio_attach(device_t dev) 674 { 675 struct bcm_gpio_softc *sc = device_get_softc(dev); 676 uint32_t func; 677 int i, j, rid; 678 phandle_t gpio; 679 680 sc->sc_dev = dev; 681 682 mtx_init(&sc->sc_mtx, "bcm gpio", "gpio", MTX_DEF); 683 684 rid = 0; 685 sc->sc_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 686 RF_ACTIVE); 687 if (!sc->sc_mem_res) { 688 device_printf(dev, "cannot allocate memory window\n"); 689 return (ENXIO); 690 } 691 692 sc->sc_bst = rman_get_bustag(sc->sc_mem_res); 693 sc->sc_bsh = rman_get_bushandle(sc->sc_mem_res); 694 695 rid = 0; 696 sc->sc_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, 697 RF_ACTIVE); 698 if (!sc->sc_irq_res) { 699 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->sc_mem_res); 700 device_printf(dev, "cannot allocate interrupt\n"); 701 return (ENXIO); 702 } 703 704 /* Find our node. */ 705 gpio = ofw_bus_get_node(sc->sc_dev); 706 707 if (!OF_hasprop(gpio, "gpio-controller")) 708 /* Node is not a GPIO controller. */ 709 goto fail; 710 711 /* 712 * Find the read-only pins. These are pins we never touch or bad 713 * things could happen. 714 */ 715 if (bcm_gpio_get_reserved_pins(sc) == -1) 716 goto fail; 717 718 /* Initialize the software controlled pins. */ 719 for (i = 0, j = 0; j < BCM_GPIO_PINS; j++) { 720 if (bcm_gpio_pin_is_ro(sc, j)) 721 continue; 722 snprintf(sc->sc_gpio_pins[i].gp_name, GPIOMAXNAME, 723 "pin %d", j); 724 func = bcm_gpio_get_function(sc, j); 725 sc->sc_gpio_pins[i].gp_pin = j; 726 sc->sc_gpio_pins[i].gp_caps = BCM_GPIO_DEFAULT_CAPS; 727 sc->sc_gpio_pins[i].gp_flags = bcm_gpio_func_flag(func); 728 i++; 729 } 730 sc->sc_gpio_npins = i; 731 732 bcm_gpio_sysctl_init(sc); 733 734 device_add_child(dev, "gpioc", -1); 735 device_add_child(dev, "gpiobus", -1); 736 737 return (bus_generic_attach(dev)); 738 739 fail: 740 if (sc->sc_irq_res) 741 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_irq_res); 742 if (sc->sc_mem_res) 743 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->sc_mem_res); 744 return (ENXIO); 745 } 746 747 static int 748 bcm_gpio_detach(device_t dev) 749 { 750 751 return (EBUSY); 752 } 753 754 static phandle_t 755 bcm_gpio_get_node(device_t bus, device_t dev) 756 { 757 758 /* We only have one child, the GPIO bus, which needs our own node. */ 759 return (ofw_bus_get_node(bus)); 760 } 761 762 static device_method_t bcm_gpio_methods[] = { 763 /* Device interface */ 764 DEVMETHOD(device_probe, bcm_gpio_probe), 765 DEVMETHOD(device_attach, bcm_gpio_attach), 766 DEVMETHOD(device_detach, bcm_gpio_detach), 767 768 /* GPIO protocol */ 769 DEVMETHOD(gpio_pin_max, bcm_gpio_pin_max), 770 DEVMETHOD(gpio_pin_getname, bcm_gpio_pin_getname), 771 DEVMETHOD(gpio_pin_getflags, bcm_gpio_pin_getflags), 772 DEVMETHOD(gpio_pin_getcaps, bcm_gpio_pin_getcaps), 773 DEVMETHOD(gpio_pin_setflags, bcm_gpio_pin_setflags), 774 DEVMETHOD(gpio_pin_get, bcm_gpio_pin_get), 775 DEVMETHOD(gpio_pin_set, bcm_gpio_pin_set), 776 DEVMETHOD(gpio_pin_toggle, bcm_gpio_pin_toggle), 777 778 /* ofw_bus interface */ 779 DEVMETHOD(ofw_bus_get_node, bcm_gpio_get_node), 780 781 DEVMETHOD_END 782 }; 783 784 static devclass_t bcm_gpio_devclass; 785 786 static driver_t bcm_gpio_driver = { 787 "gpio", 788 bcm_gpio_methods, 789 sizeof(struct bcm_gpio_softc), 790 }; 791 792 DRIVER_MODULE(bcm_gpio, simplebus, bcm_gpio_driver, bcm_gpio_devclass, 0, 0); 793