1/*- 2 * Copyright (c) 2016 Oleksandr Tymoshenko <gonzo@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27#include <sys/cdefs.h> 28#include "opt_acpi.h" 29 30#include <sys/param.h> 31#include <sys/bus.h> 32#include <sys/gpio.h> 33#include <sys/kernel.h> 34#include <sys/module.h> 35#include <sys/proc.h> 36#include <sys/rman.h> 37 38#include <machine/bus.h> 39#include <machine/resource.h> 40 41#include <contrib/dev/acpica/include/acpi.h> 42#include <contrib/dev/acpica/include/accommon.h> 43 44#include <dev/acpica/acpivar.h> 45#include <dev/gpio/gpiobusvar.h> 46 47#include "gpio_if.h" 48 49/** 50 * Macros for driver mutex locking 51 */ 52#define BYTGPIO_LOCK(_sc) mtx_lock_spin(&(_sc)->sc_mtx) 53#define BYTGPIO_UNLOCK(_sc) mtx_unlock_spin(&(_sc)->sc_mtx) 54#define BYTGPIO_LOCK_INIT(_sc) \ 55 mtx_init(&_sc->sc_mtx, device_get_nameunit((_sc)->sc_dev), \ 56 "bytgpio", MTX_SPIN) 57#define BYTGPIO_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->sc_mtx) 58#define BYTGPIO_ASSERT_LOCKED(_sc) mtx_assert(&(_sc)->sc_mtx, MA_OWNED) 59#define BYTGPIO_ASSERT_UNLOCKED(_sc) mtx_assert(&(_sc)->sc_mtx, MA_NOTOWNED) 60 61struct pinmap_info { 62 int reg; 63 int pad_func; 64}; 65 66/* Ignore function check, no info is available at the moment */ 67#define PADCONF_FUNC_ANY -1 68 69#define GPIO_PIN_MAP(r, f) { .reg = (r), .pad_func = (f) } 70 71struct bytgpio_softc { 72 ACPI_HANDLE sc_handle; 73 device_t sc_dev; 74 device_t sc_busdev; 75 struct mtx sc_mtx; 76 int sc_mem_rid; 77 struct resource *sc_mem_res; 78 int sc_npins; 79 const char* sc_bank_prefix; 80 const struct pinmap_info *sc_pinpad_map; 81 /* List of current functions for pads shared by GPIO */ 82 int *sc_pad_funcs; 83}; 84 85static int bytgpio_probe(device_t dev); 86static int bytgpio_attach(device_t dev); 87static int bytgpio_detach(device_t dev); 88 89#define SCORE_UID 1 90#define SCORE_BANK_PREFIX "GPIO_S0_SC" 91const struct pinmap_info bytgpio_score_pins[] = { 92 GPIO_PIN_MAP(85, 0), 93 GPIO_PIN_MAP(89, 0), 94 GPIO_PIN_MAP(93, 0), 95 GPIO_PIN_MAP(96, 0), 96 GPIO_PIN_MAP(99, 0), 97 GPIO_PIN_MAP(102, 0), 98 GPIO_PIN_MAP(98, 0), 99 GPIO_PIN_MAP(101, 0), 100 GPIO_PIN_MAP(34, 0), 101 GPIO_PIN_MAP(37, 0), 102 GPIO_PIN_MAP(36, 0), 103 GPIO_PIN_MAP(38, 0), 104 GPIO_PIN_MAP(39, 0), 105 GPIO_PIN_MAP(35, 0), 106 GPIO_PIN_MAP(40, 0), 107 GPIO_PIN_MAP(84, 0), 108 GPIO_PIN_MAP(62, 0), 109 GPIO_PIN_MAP(61, 0), 110 GPIO_PIN_MAP(64, 0), 111 GPIO_PIN_MAP(59, 0), 112 GPIO_PIN_MAP(54, 0), 113 GPIO_PIN_MAP(56, 0), 114 GPIO_PIN_MAP(60, 0), 115 GPIO_PIN_MAP(55, 0), 116 GPIO_PIN_MAP(63, 0), 117 GPIO_PIN_MAP(57, 0), 118 GPIO_PIN_MAP(51, 0), 119 GPIO_PIN_MAP(50, 0), 120 GPIO_PIN_MAP(53, 0), 121 GPIO_PIN_MAP(47, 0), 122 GPIO_PIN_MAP(52, 0), 123 GPIO_PIN_MAP(49, 0), 124 GPIO_PIN_MAP(48, 0), 125 GPIO_PIN_MAP(43, 0), 126 GPIO_PIN_MAP(46, 0), 127 GPIO_PIN_MAP(41, 0), 128 GPIO_PIN_MAP(45, 0), 129 GPIO_PIN_MAP(42, 0), 130 GPIO_PIN_MAP(58, 0), 131 GPIO_PIN_MAP(44, 0), 132 GPIO_PIN_MAP(95, 0), 133 GPIO_PIN_MAP(105, 0), 134 GPIO_PIN_MAP(70, 0), 135 GPIO_PIN_MAP(68, 0), 136 GPIO_PIN_MAP(67, 0), 137 GPIO_PIN_MAP(66, 0), 138 GPIO_PIN_MAP(69, 0), 139 GPIO_PIN_MAP(71, 0), 140 GPIO_PIN_MAP(65, 0), 141 GPIO_PIN_MAP(72, 0), 142 GPIO_PIN_MAP(86, 0), 143 GPIO_PIN_MAP(90, 0), 144 GPIO_PIN_MAP(88, 0), 145 GPIO_PIN_MAP(92, 0), 146 GPIO_PIN_MAP(103, 0), 147 GPIO_PIN_MAP(77, 0), 148 GPIO_PIN_MAP(79, 0), 149 GPIO_PIN_MAP(83, 0), 150 GPIO_PIN_MAP(78, 0), 151 GPIO_PIN_MAP(81, 0), 152 GPIO_PIN_MAP(80, 0), 153 GPIO_PIN_MAP(82, 0), 154 GPIO_PIN_MAP(13, 0), 155 GPIO_PIN_MAP(12, 0), 156 GPIO_PIN_MAP(15, 0), 157 GPIO_PIN_MAP(14, 0), 158 GPIO_PIN_MAP(17, 0), 159 GPIO_PIN_MAP(18, 0), 160 GPIO_PIN_MAP(19, 0), 161 GPIO_PIN_MAP(16, 0), 162 GPIO_PIN_MAP(2, 0), 163 GPIO_PIN_MAP(1, 0), 164 GPIO_PIN_MAP(0, 0), 165 GPIO_PIN_MAP(4, 0), 166 GPIO_PIN_MAP(6, 0), 167 GPIO_PIN_MAP(7, 0), 168 GPIO_PIN_MAP(9, 0), 169 GPIO_PIN_MAP(8, 0), 170 GPIO_PIN_MAP(33, 0), 171 GPIO_PIN_MAP(32, 0), 172 GPIO_PIN_MAP(31, 0), 173 GPIO_PIN_MAP(30, 0), 174 GPIO_PIN_MAP(29, 0), 175 GPIO_PIN_MAP(27, 0), 176 GPIO_PIN_MAP(25, 0), 177 GPIO_PIN_MAP(28, 0), 178 GPIO_PIN_MAP(26, 0), 179 GPIO_PIN_MAP(23, 0), 180 GPIO_PIN_MAP(21, 0), 181 GPIO_PIN_MAP(20, 0), 182 GPIO_PIN_MAP(24, 0), 183 GPIO_PIN_MAP(22, 0), 184 GPIO_PIN_MAP(5, 1), 185 GPIO_PIN_MAP(3, 1), 186 GPIO_PIN_MAP(10, 0), 187 GPIO_PIN_MAP(11, 0), 188 GPIO_PIN_MAP(106, 0), 189 GPIO_PIN_MAP(87, 0), 190 GPIO_PIN_MAP(91, 0), 191 GPIO_PIN_MAP(104, 0), 192 GPIO_PIN_MAP(97, 0), 193 GPIO_PIN_MAP(100, 0) 194}; 195 196#define SCORE_PINS nitems(bytgpio_score_pins) 197 198#define NCORE_UID 2 199#define NCORE_BANK_PREFIX "GPIO_S0_NC" 200const struct pinmap_info bytgpio_ncore_pins[] = { 201 GPIO_PIN_MAP(19, PADCONF_FUNC_ANY), 202 GPIO_PIN_MAP(18, PADCONF_FUNC_ANY), 203 GPIO_PIN_MAP(17, PADCONF_FUNC_ANY), 204 GPIO_PIN_MAP(20, PADCONF_FUNC_ANY), 205 GPIO_PIN_MAP(21, PADCONF_FUNC_ANY), 206 GPIO_PIN_MAP(22, PADCONF_FUNC_ANY), 207 GPIO_PIN_MAP(24, PADCONF_FUNC_ANY), 208 GPIO_PIN_MAP(25, PADCONF_FUNC_ANY), 209 GPIO_PIN_MAP(23, PADCONF_FUNC_ANY), 210 GPIO_PIN_MAP(16, PADCONF_FUNC_ANY), 211 GPIO_PIN_MAP(14, PADCONF_FUNC_ANY), 212 GPIO_PIN_MAP(15, PADCONF_FUNC_ANY), 213 GPIO_PIN_MAP(12, PADCONF_FUNC_ANY), 214 GPIO_PIN_MAP(26, PADCONF_FUNC_ANY), 215 GPIO_PIN_MAP(27, PADCONF_FUNC_ANY), 216 GPIO_PIN_MAP(1, PADCONF_FUNC_ANY), 217 GPIO_PIN_MAP(4, PADCONF_FUNC_ANY), 218 GPIO_PIN_MAP(8, PADCONF_FUNC_ANY), 219 GPIO_PIN_MAP(11, PADCONF_FUNC_ANY), 220 GPIO_PIN_MAP(0, PADCONF_FUNC_ANY), 221 GPIO_PIN_MAP(3, PADCONF_FUNC_ANY), 222 GPIO_PIN_MAP(6, PADCONF_FUNC_ANY), 223 GPIO_PIN_MAP(10, PADCONF_FUNC_ANY), 224 GPIO_PIN_MAP(13, PADCONF_FUNC_ANY), 225 GPIO_PIN_MAP(2, PADCONF_FUNC_ANY), 226 GPIO_PIN_MAP(5, PADCONF_FUNC_ANY), 227 GPIO_PIN_MAP(9, PADCONF_FUNC_ANY), 228 GPIO_PIN_MAP(7, PADCONF_FUNC_ANY) 229}; 230#define NCORE_PINS nitems(bytgpio_ncore_pins) 231 232#define SUS_UID 3 233#define SUS_BANK_PREFIX "GPIO_S5_" 234const struct pinmap_info bytgpio_sus_pins[] = { 235 GPIO_PIN_MAP(29, 0), 236 GPIO_PIN_MAP(33, 0), 237 GPIO_PIN_MAP(30, 0), 238 GPIO_PIN_MAP(31, 0), 239 GPIO_PIN_MAP(32, 0), 240 GPIO_PIN_MAP(34, 0), 241 GPIO_PIN_MAP(36, 0), 242 GPIO_PIN_MAP(35, 0), 243 GPIO_PIN_MAP(38, 0), 244 GPIO_PIN_MAP(37, 0), 245 GPIO_PIN_MAP(18, 0), 246 GPIO_PIN_MAP(7, 1), 247 GPIO_PIN_MAP(11, 1), 248 GPIO_PIN_MAP(20, 1), 249 GPIO_PIN_MAP(17, 1), 250 GPIO_PIN_MAP(1, 1), 251 GPIO_PIN_MAP(8, 1), 252 GPIO_PIN_MAP(10, 1), 253 GPIO_PIN_MAP(19, 1), 254 GPIO_PIN_MAP(12, 1), 255 GPIO_PIN_MAP(0, 1), 256 GPIO_PIN_MAP(2, 1), 257 GPIO_PIN_MAP(23, 0), 258 GPIO_PIN_MAP(39, 0), 259 GPIO_PIN_MAP(28, 0), 260 GPIO_PIN_MAP(27, 0), 261 GPIO_PIN_MAP(22, 0), 262 GPIO_PIN_MAP(21, 0), 263 GPIO_PIN_MAP(24, 0), 264 GPIO_PIN_MAP(25, 0), 265 GPIO_PIN_MAP(26, 0), 266 GPIO_PIN_MAP(51, 0), 267 GPIO_PIN_MAP(56, 0), 268 GPIO_PIN_MAP(54, 0), 269 GPIO_PIN_MAP(49, 0), 270 GPIO_PIN_MAP(55, 0), 271 GPIO_PIN_MAP(48, 0), 272 GPIO_PIN_MAP(57, 0), 273 GPIO_PIN_MAP(50, 0), 274 GPIO_PIN_MAP(58, 0), 275 GPIO_PIN_MAP(52, 0), 276 GPIO_PIN_MAP(53, 0), 277 GPIO_PIN_MAP(59, 0), 278 GPIO_PIN_MAP(40, 0) 279}; 280 281#define SUS_PINS nitems(bytgpio_sus_pins) 282 283#define BYGPIO_PIN_REGISTER(sc, pin, r) ((sc)->sc_pinpad_map[(pin)].reg * 16 + (r)) 284#define BYTGPIO_PCONF0 0x0000 285#define BYTGPIO_PCONF0_FUNC_MASK 7 286#define BYTGPIO_PAD_VAL 0x0008 287#define BYTGPIO_PAD_VAL_LEVEL (1 << 0) 288#define BYTGPIO_PAD_VAL_I_OUTPUT_ENABLED (1 << 1) 289#define BYTGPIO_PAD_VAL_I_INPUT_ENABLED (1 << 2) 290#define BYTGPIO_PAD_VAL_DIR_MASK (3 << 1) 291 292static inline uint32_t 293bytgpio_read_4(struct bytgpio_softc *sc, bus_size_t off) 294{ 295 return (bus_read_4(sc->sc_mem_res, off)); 296} 297 298static inline void 299bytgpio_write_4(struct bytgpio_softc *sc, bus_size_t off, 300 uint32_t val) 301{ 302 bus_write_4(sc->sc_mem_res, off, val); 303} 304 305static device_t 306bytgpio_get_bus(device_t dev) 307{ 308 struct bytgpio_softc *sc; 309 310 sc = device_get_softc(dev); 311 312 return (sc->sc_busdev); 313} 314 315static int 316bytgpio_pin_max(device_t dev, int *maxpin) 317{ 318 struct bytgpio_softc *sc; 319 320 sc = device_get_softc(dev); 321 322 *maxpin = sc->sc_npins - 1; 323 324 return (0); 325} 326 327static int 328bytgpio_valid_pin(struct bytgpio_softc *sc, int pin) 329{ 330 331 if (pin >= sc->sc_npins || sc->sc_mem_res == NULL) 332 return (EINVAL); 333 334 return (0); 335} 336 337/* 338 * Returns true if pad configured to be used as GPIO 339 */ 340static bool 341bytgpio_pad_is_gpio(struct bytgpio_softc *sc, int pin) 342{ 343 if ((sc->sc_pinpad_map[pin].pad_func == PADCONF_FUNC_ANY) || 344 (sc->sc_pad_funcs[pin] == sc->sc_pinpad_map[pin].pad_func)) 345 return (true); 346 else 347 return (false); 348} 349 350static int 351bytgpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps) 352{ 353 struct bytgpio_softc *sc; 354 355 sc = device_get_softc(dev); 356 if (bytgpio_valid_pin(sc, pin) != 0) 357 return (EINVAL); 358 359 *caps = 0; 360 if (bytgpio_pad_is_gpio(sc, pin)) 361 *caps = GPIO_PIN_INPUT | GPIO_PIN_OUTPUT; 362 363 return (0); 364} 365 366static int 367bytgpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags) 368{ 369 struct bytgpio_softc *sc; 370 uint32_t reg, val; 371 372 sc = device_get_softc(dev); 373 if (bytgpio_valid_pin(sc, pin) != 0) 374 return (EINVAL); 375 376 *flags = 0; 377 if (!bytgpio_pad_is_gpio(sc, pin)) 378 return (0); 379 380 /* Get the current pin state */ 381 BYTGPIO_LOCK(sc); 382 reg = BYGPIO_PIN_REGISTER(sc, pin, BYTGPIO_PAD_VAL); 383 val = bytgpio_read_4(sc, reg); 384 if ((val & BYTGPIO_PAD_VAL_I_OUTPUT_ENABLED) == 0) 385 *flags |= GPIO_PIN_OUTPUT; 386 /* 387 * this bit can be cleared to read current output value 388 * sou output bit takes precedense 389 */ 390 else if ((val & BYTGPIO_PAD_VAL_I_INPUT_ENABLED) == 0) 391 *flags |= GPIO_PIN_INPUT; 392 BYTGPIO_UNLOCK(sc); 393 394 return (0); 395} 396 397static int 398bytgpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags) 399{ 400 struct bytgpio_softc *sc; 401 uint32_t reg, val; 402 uint32_t allowed; 403 404 sc = device_get_softc(dev); 405 if (bytgpio_valid_pin(sc, pin) != 0) 406 return (EINVAL); 407 408 if (bytgpio_pad_is_gpio(sc, pin)) 409 allowed = GPIO_PIN_INPUT | GPIO_PIN_OUTPUT; 410 else 411 allowed = 0; 412 413 /* 414 * Only directtion flag allowed 415 */ 416 if (flags & ~allowed) 417 return (EINVAL); 418 419 /* 420 * Not both directions simultaneously 421 */ 422 if ((flags & allowed) == allowed) 423 return (EINVAL); 424 425 /* Set the GPIO mode and state */ 426 BYTGPIO_LOCK(sc); 427 reg = BYGPIO_PIN_REGISTER(sc, pin, BYTGPIO_PAD_VAL); 428 val = bytgpio_read_4(sc, reg); 429 val = val | BYTGPIO_PAD_VAL_DIR_MASK; 430 if (flags & GPIO_PIN_INPUT) 431 val = val & ~BYTGPIO_PAD_VAL_I_INPUT_ENABLED; 432 if (flags & GPIO_PIN_OUTPUT) 433 val = val & ~BYTGPIO_PAD_VAL_I_OUTPUT_ENABLED; 434 bytgpio_write_4(sc, reg, val); 435 BYTGPIO_UNLOCK(sc); 436 437 return (0); 438} 439 440static int 441bytgpio_pin_getname(device_t dev, uint32_t pin, char *name) 442{ 443 struct bytgpio_softc *sc; 444 445 sc = device_get_softc(dev); 446 if (bytgpio_valid_pin(sc, pin) != 0) 447 return (EINVAL); 448 449 /* Set a very simple name */ 450 snprintf(name, GPIOMAXNAME, "%s%u", sc->sc_bank_prefix, pin); 451 name[GPIOMAXNAME - 1] = '\0'; 452 453 return (0); 454} 455 456static int 457bytgpio_pin_set(device_t dev, uint32_t pin, unsigned int value) 458{ 459 struct bytgpio_softc *sc; 460 uint32_t reg, val; 461 462 sc = device_get_softc(dev); 463 if (bytgpio_valid_pin(sc, pin) != 0) 464 return (EINVAL); 465 466 if (!bytgpio_pad_is_gpio(sc, pin)) 467 return (EINVAL); 468 469 BYTGPIO_LOCK(sc); 470 reg = BYGPIO_PIN_REGISTER(sc, pin, BYTGPIO_PAD_VAL); 471 val = bytgpio_read_4(sc, reg); 472 if (value == GPIO_PIN_LOW) 473 val = val & ~BYTGPIO_PAD_VAL_LEVEL; 474 else 475 val = val | BYTGPIO_PAD_VAL_LEVEL; 476 bytgpio_write_4(sc, reg, val); 477 BYTGPIO_UNLOCK(sc); 478 479 return (0); 480} 481 482static int 483bytgpio_pin_get(device_t dev, uint32_t pin, unsigned int *value) 484{ 485 struct bytgpio_softc *sc; 486 uint32_t reg, val; 487 488 sc = device_get_softc(dev); 489 if (bytgpio_valid_pin(sc, pin) != 0) 490 return (EINVAL); 491 /* 492 * Report non-GPIO pads as pin LOW 493 */ 494 if (!bytgpio_pad_is_gpio(sc, pin)) { 495 *value = GPIO_PIN_LOW; 496 return (0); 497 } 498 499 BYTGPIO_LOCK(sc); 500 reg = BYGPIO_PIN_REGISTER(sc, pin, BYTGPIO_PAD_VAL); 501 /* 502 * And read actual value 503 */ 504 val = bytgpio_read_4(sc, reg); 505 if (val & BYTGPIO_PAD_VAL_LEVEL) 506 *value = GPIO_PIN_HIGH; 507 else 508 *value = GPIO_PIN_LOW; 509 BYTGPIO_UNLOCK(sc); 510 511 return (0); 512} 513 514static int 515bytgpio_pin_toggle(device_t dev, uint32_t pin) 516{ 517 struct bytgpio_softc *sc; 518 uint32_t reg, val; 519 520 sc = device_get_softc(dev); 521 if (bytgpio_valid_pin(sc, pin) != 0) 522 return (EINVAL); 523 524 if (!bytgpio_pad_is_gpio(sc, pin)) 525 return (EINVAL); 526 527 /* Toggle the pin */ 528 BYTGPIO_LOCK(sc); 529 reg = BYGPIO_PIN_REGISTER(sc, pin, BYTGPIO_PAD_VAL); 530 val = bytgpio_read_4(sc, reg); 531 val = val ^ BYTGPIO_PAD_VAL_LEVEL; 532 bytgpio_write_4(sc, reg, val); 533 BYTGPIO_UNLOCK(sc); 534 535 return (0); 536} 537 538static int 539bytgpio_probe(device_t dev) 540{ 541 static char *gpio_ids[] = { "INT33FC", NULL }; 542 int rv; 543 544 if (acpi_disabled("gpio")) 545 return (ENXIO); 546 rv = ACPI_ID_PROBE(device_get_parent(dev), dev, gpio_ids, NULL); 547 if (rv <= 0) 548 device_set_desc(dev, "Intel Baytrail GPIO Controller"); 549 return (rv); 550} 551 552static int 553bytgpio_attach(device_t dev) 554{ 555 struct bytgpio_softc *sc; 556 ACPI_STATUS status; 557 int uid; 558 int pin; 559 uint32_t reg, val; 560 561 sc = device_get_softc(dev); 562 sc->sc_dev = dev; 563 sc->sc_handle = acpi_get_handle(dev); 564 status = acpi_GetInteger(sc->sc_handle, "_UID", &uid); 565 if (ACPI_FAILURE(status)) { 566 device_printf(dev, "failed to read _UID\n"); 567 return (ENXIO); 568 } 569 570 BYTGPIO_LOCK_INIT(sc); 571 572 switch (uid) { 573 case SCORE_UID: 574 sc->sc_npins = SCORE_PINS; 575 sc->sc_bank_prefix = SCORE_BANK_PREFIX; 576 sc->sc_pinpad_map = bytgpio_score_pins; 577 break; 578 case NCORE_UID: 579 sc->sc_npins = NCORE_PINS; 580 sc->sc_bank_prefix = NCORE_BANK_PREFIX; 581 sc->sc_pinpad_map = bytgpio_ncore_pins; 582 break; 583 case SUS_UID: 584 sc->sc_npins = SUS_PINS; 585 sc->sc_bank_prefix = SUS_BANK_PREFIX; 586 sc->sc_pinpad_map = bytgpio_sus_pins; 587 break; 588 default: 589 device_printf(dev, "invalid _UID value: %d\n", uid); 590 goto error; 591 } 592 593 sc->sc_pad_funcs = malloc(sizeof(int)*sc->sc_npins, M_DEVBUF, 594 M_WAITOK | M_ZERO); 595 596 sc->sc_mem_rid = 0; 597 sc->sc_mem_res = bus_alloc_resource_any(sc->sc_dev, 598 SYS_RES_MEMORY, &sc->sc_mem_rid, RF_ACTIVE); 599 if (sc->sc_mem_res == NULL) { 600 device_printf(dev, "can't allocate resource\n"); 601 goto error; 602 } 603 604 for (pin = 0; pin < sc->sc_npins; pin++) { 605 reg = BYGPIO_PIN_REGISTER(sc, pin, BYTGPIO_PCONF0); 606 val = bytgpio_read_4(sc, reg); 607 sc->sc_pad_funcs[pin] = val & BYTGPIO_PCONF0_FUNC_MASK; 608 } 609 610 sc->sc_busdev = gpiobus_attach_bus(dev); 611 if (sc->sc_busdev == NULL) { 612 BYTGPIO_LOCK_DESTROY(sc); 613 bus_release_resource(dev, SYS_RES_MEMORY, 614 sc->sc_mem_rid, sc->sc_mem_res); 615 return (ENXIO); 616 } 617 618 return (0); 619 620error: 621 BYTGPIO_LOCK_DESTROY(sc); 622 623 return (ENXIO); 624} 625 626 627static int 628bytgpio_detach(device_t dev) 629{ 630 struct bytgpio_softc *sc; 631 632 sc = device_get_softc(dev); 633 634 if (sc->sc_busdev) 635 gpiobus_detach_bus(dev); 636 637 BYTGPIO_LOCK_DESTROY(sc); 638 639 if (sc->sc_pad_funcs) 640 free(sc->sc_pad_funcs, M_DEVBUF); 641 642 if (sc->sc_mem_res != NULL) 643 bus_release_resource(dev, SYS_RES_MEMORY, 644 sc->sc_mem_rid, sc->sc_mem_res); 645 646 return (0); 647} 648 649static device_method_t bytgpio_methods[] = { 650 /* Device interface */ 651 DEVMETHOD(device_probe, bytgpio_probe), 652 DEVMETHOD(device_attach, bytgpio_attach), 653 DEVMETHOD(device_detach, bytgpio_detach), 654 655 /* GPIO protocol */ 656 DEVMETHOD(gpio_get_bus, bytgpio_get_bus), 657 DEVMETHOD(gpio_pin_max, bytgpio_pin_max), 658 DEVMETHOD(gpio_pin_getname, bytgpio_pin_getname), 659 DEVMETHOD(gpio_pin_getflags, bytgpio_pin_getflags), 660 DEVMETHOD(gpio_pin_getcaps, bytgpio_pin_getcaps), 661 DEVMETHOD(gpio_pin_setflags, bytgpio_pin_setflags), 662 DEVMETHOD(gpio_pin_get, bytgpio_pin_get), 663 DEVMETHOD(gpio_pin_set, bytgpio_pin_set), 664 DEVMETHOD(gpio_pin_toggle, bytgpio_pin_toggle), 665 666 DEVMETHOD_END 667}; 668 669static driver_t bytgpio_driver = { 670 "gpio", 671 bytgpio_methods, 672 sizeof(struct bytgpio_softc), 673}; 674 675DRIVER_MODULE(bytgpio, acpi, bytgpio_driver, 0, 0); 676MODULE_DEPEND(bytgpio, acpi, 1, 1, 1); 677MODULE_DEPEND(bytgpio, gpiobus, 1, 1, 1); 678