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