1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * ACPI helpers for GPIO API 4 * 5 * Copyright (C) 2012, Intel Corporation 6 * Authors: Mathias Nyman <mathias.nyman@linux.intel.com> 7 * Mika Westerberg <mika.westerberg@linux.intel.com> 8 */ 9 10 #include <linux/dmi.h> 11 #include <linux/errno.h> 12 #include <linux/gpio/consumer.h> 13 #include <linux/gpio/driver.h> 14 #include <linux/gpio/machine.h> 15 #include <linux/export.h> 16 #include <linux/acpi.h> 17 #include <linux/interrupt.h> 18 #include <linux/mutex.h> 19 #include <linux/pinctrl/pinctrl.h> 20 21 #include "gpiolib.h" 22 #include "gpiolib-acpi.h" 23 24 static int run_edge_events_on_boot = -1; 25 module_param(run_edge_events_on_boot, int, 0444); 26 MODULE_PARM_DESC(run_edge_events_on_boot, 27 "Run edge _AEI event-handlers at boot: 0=no, 1=yes, -1=auto"); 28 29 static char *ignore_wake; 30 module_param(ignore_wake, charp, 0444); 31 MODULE_PARM_DESC(ignore_wake, 32 "controller@pin combos on which to ignore the ACPI wake flag " 33 "ignore_wake=controller@pin[,controller@pin[,...]]"); 34 35 struct acpi_gpiolib_dmi_quirk { 36 bool no_edge_events_on_boot; 37 char *ignore_wake; 38 }; 39 40 /** 41 * struct acpi_gpio_event - ACPI GPIO event handler data 42 * 43 * @node: list-entry of the events list of the struct acpi_gpio_chip 44 * @handle: handle of ACPI method to execute when the IRQ triggers 45 * @handler: handler function to pass to request_irq() when requesting the IRQ 46 * @pin: GPIO pin number on the struct gpio_chip 47 * @irq: Linux IRQ number for the event, for request_irq() / free_irq() 48 * @irqflags: flags to pass to request_irq() when requesting the IRQ 49 * @irq_is_wake: If the ACPI flags indicate the IRQ is a wakeup source 50 * @irq_requested:True if request_irq() has been done 51 * @desc: struct gpio_desc for the GPIO pin for this event 52 */ 53 struct acpi_gpio_event { 54 struct list_head node; 55 acpi_handle handle; 56 irq_handler_t handler; 57 unsigned int pin; 58 unsigned int irq; 59 unsigned long irqflags; 60 bool irq_is_wake; 61 bool irq_requested; 62 struct gpio_desc *desc; 63 }; 64 65 struct acpi_gpio_connection { 66 struct list_head node; 67 unsigned int pin; 68 struct gpio_desc *desc; 69 }; 70 71 struct acpi_gpio_chip { 72 /* 73 * ACPICA requires that the first field of the context parameter 74 * passed to acpi_install_address_space_handler() is large enough 75 * to hold struct acpi_connection_info. 76 */ 77 struct acpi_connection_info conn_info; 78 struct list_head conns; 79 struct mutex conn_lock; 80 struct gpio_chip *chip; 81 struct list_head events; 82 struct list_head deferred_req_irqs_list_entry; 83 }; 84 85 /* 86 * For GPIO chips which call acpi_gpiochip_request_interrupts() before late_init 87 * (so builtin drivers) we register the ACPI GpioInt IRQ handlers from a 88 * late_initcall_sync() handler, so that other builtin drivers can register their 89 * OpRegions before the event handlers can run. This list contains GPIO chips 90 * for which the acpi_gpiochip_request_irqs() call has been deferred. 91 */ 92 static DEFINE_MUTEX(acpi_gpio_deferred_req_irqs_lock); 93 static LIST_HEAD(acpi_gpio_deferred_req_irqs_list); 94 static bool acpi_gpio_deferred_req_irqs_done; 95 96 static int acpi_gpiochip_find(struct gpio_chip *gc, void *data) 97 { 98 if (!gc->parent) 99 return false; 100 101 return ACPI_HANDLE(gc->parent) == data; 102 } 103 104 /** 105 * acpi_get_gpiod() - Translate ACPI GPIO pin to GPIO descriptor usable with GPIO API 106 * @path: ACPI GPIO controller full path name, (e.g. "\\_SB.GPO1") 107 * @pin: ACPI GPIO pin number (0-based, controller-relative) 108 * 109 * Return: GPIO descriptor to use with Linux generic GPIO API, or ERR_PTR 110 * error value. Specifically returns %-EPROBE_DEFER if the referenced GPIO 111 * controller does not have GPIO chip registered at the moment. This is to 112 * support probe deferral. 113 */ 114 static struct gpio_desc *acpi_get_gpiod(char *path, int pin) 115 { 116 struct gpio_chip *chip; 117 acpi_handle handle; 118 acpi_status status; 119 120 status = acpi_get_handle(NULL, path, &handle); 121 if (ACPI_FAILURE(status)) 122 return ERR_PTR(-ENODEV); 123 124 chip = gpiochip_find(handle, acpi_gpiochip_find); 125 if (!chip) 126 return ERR_PTR(-EPROBE_DEFER); 127 128 return gpiochip_get_desc(chip, pin); 129 } 130 131 static irqreturn_t acpi_gpio_irq_handler(int irq, void *data) 132 { 133 struct acpi_gpio_event *event = data; 134 135 acpi_evaluate_object(event->handle, NULL, NULL, NULL); 136 137 return IRQ_HANDLED; 138 } 139 140 static irqreturn_t acpi_gpio_irq_handler_evt(int irq, void *data) 141 { 142 struct acpi_gpio_event *event = data; 143 144 acpi_execute_simple_method(event->handle, NULL, event->pin); 145 146 return IRQ_HANDLED; 147 } 148 149 static void acpi_gpio_chip_dh(acpi_handle handle, void *data) 150 { 151 /* The address of this function is used as a key. */ 152 } 153 154 bool acpi_gpio_get_irq_resource(struct acpi_resource *ares, 155 struct acpi_resource_gpio **agpio) 156 { 157 struct acpi_resource_gpio *gpio; 158 159 if (ares->type != ACPI_RESOURCE_TYPE_GPIO) 160 return false; 161 162 gpio = &ares->data.gpio; 163 if (gpio->connection_type != ACPI_RESOURCE_GPIO_TYPE_INT) 164 return false; 165 166 *agpio = gpio; 167 return true; 168 } 169 EXPORT_SYMBOL_GPL(acpi_gpio_get_irq_resource); 170 171 static void acpi_gpiochip_request_irq(struct acpi_gpio_chip *acpi_gpio, 172 struct acpi_gpio_event *event) 173 { 174 int ret, value; 175 176 ret = request_threaded_irq(event->irq, NULL, event->handler, 177 event->irqflags | IRQF_ONESHOT, "ACPI:Event", event); 178 if (ret) { 179 dev_err(acpi_gpio->chip->parent, 180 "Failed to setup interrupt handler for %d\n", 181 event->irq); 182 return; 183 } 184 185 if (event->irq_is_wake) 186 enable_irq_wake(event->irq); 187 188 event->irq_requested = true; 189 190 /* Make sure we trigger the initial state of edge-triggered IRQs */ 191 if (run_edge_events_on_boot && 192 (event->irqflags & (IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING))) { 193 value = gpiod_get_raw_value_cansleep(event->desc); 194 if (((event->irqflags & IRQF_TRIGGER_RISING) && value == 1) || 195 ((event->irqflags & IRQF_TRIGGER_FALLING) && value == 0)) 196 event->handler(event->irq, event); 197 } 198 } 199 200 static void acpi_gpiochip_request_irqs(struct acpi_gpio_chip *acpi_gpio) 201 { 202 struct acpi_gpio_event *event; 203 204 list_for_each_entry(event, &acpi_gpio->events, node) 205 acpi_gpiochip_request_irq(acpi_gpio, event); 206 } 207 208 static enum gpiod_flags 209 acpi_gpio_to_gpiod_flags(const struct acpi_resource_gpio *agpio, int polarity) 210 { 211 /* GpioInt() implies input configuration */ 212 if (agpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT) 213 return GPIOD_IN; 214 215 switch (agpio->io_restriction) { 216 case ACPI_IO_RESTRICT_INPUT: 217 return GPIOD_IN; 218 case ACPI_IO_RESTRICT_OUTPUT: 219 /* 220 * ACPI GPIO resources don't contain an initial value for the 221 * GPIO. Therefore we deduce that value from the pull field 222 * and the polarity instead. If the pin is pulled up we assume 223 * default to be high, if it is pulled down we assume default 224 * to be low, otherwise we leave pin untouched. For active low 225 * polarity values will be switched. See also 226 * Documentation/firmware-guide/acpi/gpio-properties.rst. 227 */ 228 switch (agpio->pin_config) { 229 case ACPI_PIN_CONFIG_PULLUP: 230 return polarity == GPIO_ACTIVE_LOW ? GPIOD_OUT_LOW : GPIOD_OUT_HIGH; 231 case ACPI_PIN_CONFIG_PULLDOWN: 232 return polarity == GPIO_ACTIVE_LOW ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW; 233 default: 234 break; 235 } 236 break; 237 default: 238 break; 239 } 240 241 /* 242 * Assume that the BIOS has configured the direction and pull 243 * accordingly. 244 */ 245 return GPIOD_ASIS; 246 } 247 248 static struct gpio_desc *acpi_request_own_gpiod(struct gpio_chip *chip, 249 struct acpi_resource_gpio *agpio, 250 unsigned int index, 251 const char *label) 252 { 253 int polarity = GPIO_ACTIVE_HIGH; 254 enum gpiod_flags flags = acpi_gpio_to_gpiod_flags(agpio, polarity); 255 unsigned int pin = agpio->pin_table[index]; 256 struct gpio_desc *desc; 257 int ret; 258 259 desc = gpiochip_request_own_desc(chip, pin, label, polarity, flags); 260 if (IS_ERR(desc)) 261 return desc; 262 263 ret = gpio_set_debounce_timeout(desc, agpio->debounce_timeout); 264 if (ret) 265 gpiochip_free_own_desc(desc); 266 267 return ret ? ERR_PTR(ret) : desc; 268 } 269 270 static bool acpi_gpio_in_ignore_list(const char *controller_in, int pin_in) 271 { 272 const char *controller, *pin_str; 273 int len, pin; 274 char *endp; 275 276 controller = ignore_wake; 277 while (controller) { 278 pin_str = strchr(controller, '@'); 279 if (!pin_str) 280 goto err; 281 282 len = pin_str - controller; 283 if (len == strlen(controller_in) && 284 strncmp(controller, controller_in, len) == 0) { 285 pin = simple_strtoul(pin_str + 1, &endp, 10); 286 if (*endp != 0 && *endp != ',') 287 goto err; 288 289 if (pin == pin_in) 290 return true; 291 } 292 293 controller = strchr(controller, ','); 294 if (controller) 295 controller++; 296 } 297 298 return false; 299 err: 300 pr_err_once("Error invalid value for gpiolib_acpi.ignore_wake: %s\n", 301 ignore_wake); 302 return false; 303 } 304 305 static bool acpi_gpio_irq_is_wake(struct device *parent, 306 struct acpi_resource_gpio *agpio) 307 { 308 int pin = agpio->pin_table[0]; 309 310 if (agpio->wake_capable != ACPI_WAKE_CAPABLE) 311 return false; 312 313 if (acpi_gpio_in_ignore_list(dev_name(parent), pin)) { 314 dev_info(parent, "Ignoring wakeup on pin %d\n", pin); 315 return false; 316 } 317 318 return true; 319 } 320 321 /* Always returns AE_OK so that we keep looping over the resources */ 322 static acpi_status acpi_gpiochip_alloc_event(struct acpi_resource *ares, 323 void *context) 324 { 325 struct acpi_gpio_chip *acpi_gpio = context; 326 struct gpio_chip *chip = acpi_gpio->chip; 327 struct acpi_resource_gpio *agpio; 328 acpi_handle handle, evt_handle; 329 struct acpi_gpio_event *event; 330 irq_handler_t handler = NULL; 331 struct gpio_desc *desc; 332 int ret, pin, irq; 333 334 if (!acpi_gpio_get_irq_resource(ares, &agpio)) 335 return AE_OK; 336 337 handle = ACPI_HANDLE(chip->parent); 338 pin = agpio->pin_table[0]; 339 340 if (pin <= 255) { 341 char ev_name[5]; 342 sprintf(ev_name, "_%c%02hhX", 343 agpio->triggering == ACPI_EDGE_SENSITIVE ? 'E' : 'L', 344 pin); 345 if (ACPI_SUCCESS(acpi_get_handle(handle, ev_name, &evt_handle))) 346 handler = acpi_gpio_irq_handler; 347 } 348 if (!handler) { 349 if (ACPI_SUCCESS(acpi_get_handle(handle, "_EVT", &evt_handle))) 350 handler = acpi_gpio_irq_handler_evt; 351 } 352 if (!handler) 353 return AE_OK; 354 355 desc = acpi_request_own_gpiod(chip, agpio, 0, "ACPI:Event"); 356 if (IS_ERR(desc)) { 357 dev_err(chip->parent, 358 "Failed to request GPIO for pin 0x%04X, err %ld\n", 359 pin, PTR_ERR(desc)); 360 return AE_OK; 361 } 362 363 ret = gpiochip_lock_as_irq(chip, pin); 364 if (ret) { 365 dev_err(chip->parent, 366 "Failed to lock GPIO pin 0x%04X as interrupt, err %d\n", 367 pin, ret); 368 goto fail_free_desc; 369 } 370 371 irq = gpiod_to_irq(desc); 372 if (irq < 0) { 373 dev_err(chip->parent, 374 "Failed to translate GPIO pin 0x%04X to IRQ, err %d\n", 375 pin, irq); 376 goto fail_unlock_irq; 377 } 378 379 event = kzalloc(sizeof(*event), GFP_KERNEL); 380 if (!event) 381 goto fail_unlock_irq; 382 383 event->irqflags = IRQF_ONESHOT; 384 if (agpio->triggering == ACPI_LEVEL_SENSITIVE) { 385 if (agpio->polarity == ACPI_ACTIVE_HIGH) 386 event->irqflags |= IRQF_TRIGGER_HIGH; 387 else 388 event->irqflags |= IRQF_TRIGGER_LOW; 389 } else { 390 switch (agpio->polarity) { 391 case ACPI_ACTIVE_HIGH: 392 event->irqflags |= IRQF_TRIGGER_RISING; 393 break; 394 case ACPI_ACTIVE_LOW: 395 event->irqflags |= IRQF_TRIGGER_FALLING; 396 break; 397 default: 398 event->irqflags |= IRQF_TRIGGER_RISING | 399 IRQF_TRIGGER_FALLING; 400 break; 401 } 402 } 403 404 event->handle = evt_handle; 405 event->handler = handler; 406 event->irq = irq; 407 event->irq_is_wake = acpi_gpio_irq_is_wake(chip->parent, agpio); 408 event->pin = pin; 409 event->desc = desc; 410 411 list_add_tail(&event->node, &acpi_gpio->events); 412 413 return AE_OK; 414 415 fail_unlock_irq: 416 gpiochip_unlock_as_irq(chip, pin); 417 fail_free_desc: 418 gpiochip_free_own_desc(desc); 419 420 return AE_OK; 421 } 422 423 /** 424 * acpi_gpiochip_request_interrupts() - Register isr for gpio chip ACPI events 425 * @chip: GPIO chip 426 * 427 * ACPI5 platforms can use GPIO signaled ACPI events. These GPIO interrupts are 428 * handled by ACPI event methods which need to be called from the GPIO 429 * chip's interrupt handler. acpi_gpiochip_request_interrupts() finds out which 430 * GPIO pins have ACPI event methods and assigns interrupt handlers that calls 431 * the ACPI event methods for those pins. 432 */ 433 void acpi_gpiochip_request_interrupts(struct gpio_chip *chip) 434 { 435 struct acpi_gpio_chip *acpi_gpio; 436 acpi_handle handle; 437 acpi_status status; 438 bool defer; 439 440 if (!chip->parent || !chip->to_irq) 441 return; 442 443 handle = ACPI_HANDLE(chip->parent); 444 if (!handle) 445 return; 446 447 status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio); 448 if (ACPI_FAILURE(status)) 449 return; 450 451 acpi_walk_resources(handle, "_AEI", 452 acpi_gpiochip_alloc_event, acpi_gpio); 453 454 mutex_lock(&acpi_gpio_deferred_req_irqs_lock); 455 defer = !acpi_gpio_deferred_req_irqs_done; 456 if (defer) 457 list_add(&acpi_gpio->deferred_req_irqs_list_entry, 458 &acpi_gpio_deferred_req_irqs_list); 459 mutex_unlock(&acpi_gpio_deferred_req_irqs_lock); 460 461 if (defer) 462 return; 463 464 acpi_gpiochip_request_irqs(acpi_gpio); 465 } 466 EXPORT_SYMBOL_GPL(acpi_gpiochip_request_interrupts); 467 468 /** 469 * acpi_gpiochip_free_interrupts() - Free GPIO ACPI event interrupts. 470 * @chip: GPIO chip 471 * 472 * Free interrupts associated with GPIO ACPI event method for the given 473 * GPIO chip. 474 */ 475 void acpi_gpiochip_free_interrupts(struct gpio_chip *chip) 476 { 477 struct acpi_gpio_chip *acpi_gpio; 478 struct acpi_gpio_event *event, *ep; 479 acpi_handle handle; 480 acpi_status status; 481 482 if (!chip->parent || !chip->to_irq) 483 return; 484 485 handle = ACPI_HANDLE(chip->parent); 486 if (!handle) 487 return; 488 489 status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio); 490 if (ACPI_FAILURE(status)) 491 return; 492 493 mutex_lock(&acpi_gpio_deferred_req_irqs_lock); 494 if (!list_empty(&acpi_gpio->deferred_req_irqs_list_entry)) 495 list_del_init(&acpi_gpio->deferred_req_irqs_list_entry); 496 mutex_unlock(&acpi_gpio_deferred_req_irqs_lock); 497 498 list_for_each_entry_safe_reverse(event, ep, &acpi_gpio->events, node) { 499 if (event->irq_requested) { 500 if (event->irq_is_wake) 501 disable_irq_wake(event->irq); 502 503 free_irq(event->irq, event); 504 } 505 506 gpiochip_unlock_as_irq(chip, event->pin); 507 gpiochip_free_own_desc(event->desc); 508 list_del(&event->node); 509 kfree(event); 510 } 511 } 512 EXPORT_SYMBOL_GPL(acpi_gpiochip_free_interrupts); 513 514 int acpi_dev_add_driver_gpios(struct acpi_device *adev, 515 const struct acpi_gpio_mapping *gpios) 516 { 517 if (adev && gpios) { 518 adev->driver_gpios = gpios; 519 return 0; 520 } 521 return -EINVAL; 522 } 523 EXPORT_SYMBOL_GPL(acpi_dev_add_driver_gpios); 524 525 void acpi_dev_remove_driver_gpios(struct acpi_device *adev) 526 { 527 if (adev) 528 adev->driver_gpios = NULL; 529 } 530 EXPORT_SYMBOL_GPL(acpi_dev_remove_driver_gpios); 531 532 static void devm_acpi_dev_release_driver_gpios(struct device *dev, void *res) 533 { 534 acpi_dev_remove_driver_gpios(ACPI_COMPANION(dev)); 535 } 536 537 int devm_acpi_dev_add_driver_gpios(struct device *dev, 538 const struct acpi_gpio_mapping *gpios) 539 { 540 void *res; 541 int ret; 542 543 res = devres_alloc(devm_acpi_dev_release_driver_gpios, 0, GFP_KERNEL); 544 if (!res) 545 return -ENOMEM; 546 547 ret = acpi_dev_add_driver_gpios(ACPI_COMPANION(dev), gpios); 548 if (ret) { 549 devres_free(res); 550 return ret; 551 } 552 devres_add(dev, res); 553 return 0; 554 } 555 EXPORT_SYMBOL_GPL(devm_acpi_dev_add_driver_gpios); 556 557 void devm_acpi_dev_remove_driver_gpios(struct device *dev) 558 { 559 WARN_ON(devres_release(dev, devm_acpi_dev_release_driver_gpios, NULL, NULL)); 560 } 561 EXPORT_SYMBOL_GPL(devm_acpi_dev_remove_driver_gpios); 562 563 static bool acpi_get_driver_gpio_data(struct acpi_device *adev, 564 const char *name, int index, 565 struct fwnode_reference_args *args, 566 unsigned int *quirks) 567 { 568 const struct acpi_gpio_mapping *gm; 569 570 if (!adev->driver_gpios) 571 return false; 572 573 for (gm = adev->driver_gpios; gm->name; gm++) 574 if (!strcmp(name, gm->name) && gm->data && index < gm->size) { 575 const struct acpi_gpio_params *par = gm->data + index; 576 577 args->fwnode = acpi_fwnode_handle(adev); 578 args->args[0] = par->crs_entry_index; 579 args->args[1] = par->line_index; 580 args->args[2] = par->active_low; 581 args->nargs = 3; 582 583 *quirks = gm->quirks; 584 return true; 585 } 586 587 return false; 588 } 589 590 static int 591 __acpi_gpio_update_gpiod_flags(enum gpiod_flags *flags, enum gpiod_flags update) 592 { 593 const enum gpiod_flags mask = 594 GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT | 595 GPIOD_FLAGS_BIT_DIR_VAL; 596 int ret = 0; 597 598 /* 599 * Check if the BIOS has IoRestriction with explicitly set direction 600 * and update @flags accordingly. Otherwise use whatever caller asked 601 * for. 602 */ 603 if (update & GPIOD_FLAGS_BIT_DIR_SET) { 604 enum gpiod_flags diff = *flags ^ update; 605 606 /* 607 * Check if caller supplied incompatible GPIO initialization 608 * flags. 609 * 610 * Return %-EINVAL to notify that firmware has different 611 * settings and we are going to use them. 612 */ 613 if (((*flags & GPIOD_FLAGS_BIT_DIR_SET) && (diff & GPIOD_FLAGS_BIT_DIR_OUT)) || 614 ((*flags & GPIOD_FLAGS_BIT_DIR_OUT) && (diff & GPIOD_FLAGS_BIT_DIR_VAL))) 615 ret = -EINVAL; 616 *flags = (*flags & ~mask) | (update & mask); 617 } 618 return ret; 619 } 620 621 int 622 acpi_gpio_update_gpiod_flags(enum gpiod_flags *flags, struct acpi_gpio_info *info) 623 { 624 struct device *dev = &info->adev->dev; 625 enum gpiod_flags old = *flags; 626 int ret; 627 628 ret = __acpi_gpio_update_gpiod_flags(&old, info->flags); 629 if (info->quirks & ACPI_GPIO_QUIRK_NO_IO_RESTRICTION) { 630 if (ret) 631 dev_warn(dev, FW_BUG "GPIO not in correct mode, fixing\n"); 632 } else { 633 if (ret) 634 dev_dbg(dev, "Override GPIO initialization flags\n"); 635 *flags = old; 636 } 637 638 return ret; 639 } 640 641 int acpi_gpio_update_gpiod_lookup_flags(unsigned long *lookupflags, 642 struct acpi_gpio_info *info) 643 { 644 switch (info->pin_config) { 645 case ACPI_PIN_CONFIG_PULLUP: 646 *lookupflags |= GPIO_PULL_UP; 647 break; 648 case ACPI_PIN_CONFIG_PULLDOWN: 649 *lookupflags |= GPIO_PULL_DOWN; 650 break; 651 default: 652 break; 653 } 654 655 if (info->polarity == GPIO_ACTIVE_LOW) 656 *lookupflags |= GPIO_ACTIVE_LOW; 657 658 return 0; 659 } 660 661 struct acpi_gpio_lookup { 662 struct acpi_gpio_info info; 663 int index; 664 u16 pin_index; 665 bool active_low; 666 struct gpio_desc *desc; 667 int n; 668 }; 669 670 static int acpi_populate_gpio_lookup(struct acpi_resource *ares, void *data) 671 { 672 struct acpi_gpio_lookup *lookup = data; 673 674 if (ares->type != ACPI_RESOURCE_TYPE_GPIO) 675 return 1; 676 677 if (!lookup->desc) { 678 const struct acpi_resource_gpio *agpio = &ares->data.gpio; 679 bool gpioint = agpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT; 680 struct gpio_desc *desc; 681 u16 pin_index; 682 683 if (lookup->info.quirks & ACPI_GPIO_QUIRK_ONLY_GPIOIO && gpioint) 684 lookup->index++; 685 686 if (lookup->n++ != lookup->index) 687 return 1; 688 689 pin_index = lookup->pin_index; 690 if (pin_index >= agpio->pin_table_length) 691 return 1; 692 693 if (lookup->info.quirks & ACPI_GPIO_QUIRK_ABSOLUTE_NUMBER) 694 desc = gpio_to_desc(agpio->pin_table[pin_index]); 695 else 696 desc = acpi_get_gpiod(agpio->resource_source.string_ptr, 697 agpio->pin_table[pin_index]); 698 lookup->desc = desc; 699 lookup->info.pin_config = agpio->pin_config; 700 lookup->info.debounce = agpio->debounce_timeout; 701 lookup->info.gpioint = gpioint; 702 703 /* 704 * Polarity and triggering are only specified for GpioInt 705 * resource. 706 * Note: we expect here: 707 * - ACPI_ACTIVE_LOW == GPIO_ACTIVE_LOW 708 * - ACPI_ACTIVE_HIGH == GPIO_ACTIVE_HIGH 709 */ 710 if (lookup->info.gpioint) { 711 lookup->info.polarity = agpio->polarity; 712 lookup->info.triggering = agpio->triggering; 713 } else { 714 lookup->info.polarity = lookup->active_low; 715 } 716 717 lookup->info.flags = acpi_gpio_to_gpiod_flags(agpio, lookup->info.polarity); 718 } 719 720 return 1; 721 } 722 723 static int acpi_gpio_resource_lookup(struct acpi_gpio_lookup *lookup, 724 struct acpi_gpio_info *info) 725 { 726 struct acpi_device *adev = lookup->info.adev; 727 struct list_head res_list; 728 int ret; 729 730 INIT_LIST_HEAD(&res_list); 731 732 ret = acpi_dev_get_resources(adev, &res_list, 733 acpi_populate_gpio_lookup, 734 lookup); 735 if (ret < 0) 736 return ret; 737 738 acpi_dev_free_resource_list(&res_list); 739 740 if (!lookup->desc) 741 return -ENOENT; 742 743 if (info) 744 *info = lookup->info; 745 return 0; 746 } 747 748 static int acpi_gpio_property_lookup(struct fwnode_handle *fwnode, 749 const char *propname, int index, 750 struct acpi_gpio_lookup *lookup) 751 { 752 struct fwnode_reference_args args; 753 unsigned int quirks = 0; 754 int ret; 755 756 memset(&args, 0, sizeof(args)); 757 ret = __acpi_node_get_property_reference(fwnode, propname, index, 3, 758 &args); 759 if (ret) { 760 struct acpi_device *adev = to_acpi_device_node(fwnode); 761 762 if (!adev) 763 return ret; 764 765 if (!acpi_get_driver_gpio_data(adev, propname, index, &args, 766 &quirks)) 767 return ret; 768 } 769 /* 770 * The property was found and resolved, so need to lookup the GPIO based 771 * on returned args. 772 */ 773 if (!to_acpi_device_node(args.fwnode)) 774 return -EINVAL; 775 if (args.nargs != 3) 776 return -EPROTO; 777 778 lookup->index = args.args[0]; 779 lookup->pin_index = args.args[1]; 780 lookup->active_low = !!args.args[2]; 781 782 lookup->info.adev = to_acpi_device_node(args.fwnode); 783 lookup->info.quirks = quirks; 784 785 return 0; 786 } 787 788 /** 789 * acpi_get_gpiod_by_index() - get a GPIO descriptor from device resources 790 * @adev: pointer to a ACPI device to get GPIO from 791 * @propname: Property name of the GPIO (optional) 792 * @index: index of GpioIo/GpioInt resource (starting from %0) 793 * @info: info pointer to fill in (optional) 794 * 795 * Function goes through ACPI resources for @adev and based on @index looks 796 * up a GpioIo/GpioInt resource, translates it to the Linux GPIO descriptor, 797 * and returns it. @index matches GpioIo/GpioInt resources only so if there 798 * are total %3 GPIO resources, the index goes from %0 to %2. 799 * 800 * If @propname is specified the GPIO is looked using device property. In 801 * that case @index is used to select the GPIO entry in the property value 802 * (in case of multiple). 803 * 804 * If the GPIO cannot be translated or there is an error, an ERR_PTR is 805 * returned. 806 * 807 * Note: if the GPIO resource has multiple entries in the pin list, this 808 * function only returns the first. 809 */ 810 static struct gpio_desc *acpi_get_gpiod_by_index(struct acpi_device *adev, 811 const char *propname, int index, 812 struct acpi_gpio_info *info) 813 { 814 struct acpi_gpio_lookup lookup; 815 int ret; 816 817 if (!adev) 818 return ERR_PTR(-ENODEV); 819 820 memset(&lookup, 0, sizeof(lookup)); 821 lookup.index = index; 822 823 if (propname) { 824 dev_dbg(&adev->dev, "GPIO: looking up %s\n", propname); 825 826 ret = acpi_gpio_property_lookup(acpi_fwnode_handle(adev), 827 propname, index, &lookup); 828 if (ret) 829 return ERR_PTR(ret); 830 831 dev_dbg(&adev->dev, "GPIO: _DSD returned %s %d %u %u\n", 832 dev_name(&lookup.info.adev->dev), lookup.index, 833 lookup.pin_index, lookup.active_low); 834 } else { 835 dev_dbg(&adev->dev, "GPIO: looking up %d in _CRS\n", index); 836 lookup.info.adev = adev; 837 } 838 839 ret = acpi_gpio_resource_lookup(&lookup, info); 840 return ret ? ERR_PTR(ret) : lookup.desc; 841 } 842 843 static bool acpi_can_fallback_to_crs(struct acpi_device *adev, 844 const char *con_id) 845 { 846 /* Never allow fallback if the device has properties */ 847 if (acpi_dev_has_props(adev) || adev->driver_gpios) 848 return false; 849 850 return con_id == NULL; 851 } 852 853 struct gpio_desc *acpi_find_gpio(struct device *dev, 854 const char *con_id, 855 unsigned int idx, 856 enum gpiod_flags *dflags, 857 unsigned long *lookupflags) 858 { 859 struct acpi_device *adev = ACPI_COMPANION(dev); 860 struct acpi_gpio_info info; 861 struct gpio_desc *desc; 862 char propname[32]; 863 int i; 864 865 /* Try first from _DSD */ 866 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) { 867 if (con_id) { 868 snprintf(propname, sizeof(propname), "%s-%s", 869 con_id, gpio_suffixes[i]); 870 } else { 871 snprintf(propname, sizeof(propname), "%s", 872 gpio_suffixes[i]); 873 } 874 875 desc = acpi_get_gpiod_by_index(adev, propname, idx, &info); 876 if (!IS_ERR(desc)) 877 break; 878 if (PTR_ERR(desc) == -EPROBE_DEFER) 879 return ERR_CAST(desc); 880 } 881 882 /* Then from plain _CRS GPIOs */ 883 if (IS_ERR(desc)) { 884 if (!acpi_can_fallback_to_crs(adev, con_id)) 885 return ERR_PTR(-ENOENT); 886 887 desc = acpi_get_gpiod_by_index(adev, NULL, idx, &info); 888 if (IS_ERR(desc)) 889 return desc; 890 } 891 892 if (info.gpioint && 893 (*dflags == GPIOD_OUT_LOW || *dflags == GPIOD_OUT_HIGH)) { 894 dev_dbg(dev, "refusing GpioInt() entry when doing GPIOD_OUT_* lookup\n"); 895 return ERR_PTR(-ENOENT); 896 } 897 898 acpi_gpio_update_gpiod_flags(dflags, &info); 899 acpi_gpio_update_gpiod_lookup_flags(lookupflags, &info); 900 return desc; 901 } 902 903 /** 904 * acpi_node_get_gpiod() - get a GPIO descriptor from ACPI resources 905 * @fwnode: pointer to an ACPI firmware node to get the GPIO information from 906 * @propname: Property name of the GPIO 907 * @index: index of GpioIo/GpioInt resource (starting from %0) 908 * @info: info pointer to fill in (optional) 909 * 910 * If @fwnode is an ACPI device object, call acpi_get_gpiod_by_index() for it. 911 * Otherwise (i.e. it is a data-only non-device object), use the property-based 912 * GPIO lookup to get to the GPIO resource with the relevant information and use 913 * that to obtain the GPIO descriptor to return. 914 * 915 * If the GPIO cannot be translated or there is an error an ERR_PTR is 916 * returned. 917 */ 918 struct gpio_desc *acpi_node_get_gpiod(struct fwnode_handle *fwnode, 919 const char *propname, int index, 920 struct acpi_gpio_info *info) 921 { 922 struct acpi_gpio_lookup lookup; 923 struct acpi_device *adev; 924 int ret; 925 926 adev = to_acpi_device_node(fwnode); 927 if (adev) 928 return acpi_get_gpiod_by_index(adev, propname, index, info); 929 930 if (!is_acpi_data_node(fwnode)) 931 return ERR_PTR(-ENODEV); 932 933 if (!propname) 934 return ERR_PTR(-EINVAL); 935 936 memset(&lookup, 0, sizeof(lookup)); 937 lookup.index = index; 938 939 ret = acpi_gpio_property_lookup(fwnode, propname, index, &lookup); 940 if (ret) 941 return ERR_PTR(ret); 942 943 ret = acpi_gpio_resource_lookup(&lookup, info); 944 return ret ? ERR_PTR(ret) : lookup.desc; 945 } 946 947 /** 948 * acpi_dev_gpio_irq_get_by() - Find GpioInt and translate it to Linux IRQ number 949 * @adev: pointer to a ACPI device to get IRQ from 950 * @name: optional name of GpioInt resource 951 * @index: index of GpioInt resource (starting from %0) 952 * 953 * If the device has one or more GpioInt resources, this function can be 954 * used to translate from the GPIO offset in the resource to the Linux IRQ 955 * number. 956 * 957 * The function is idempotent, though each time it runs it will configure GPIO 958 * pin direction according to the flags in GpioInt resource. 959 * 960 * The function takes optional @name parameter. If the resource has a property 961 * name, then only those will be taken into account. 962 * 963 * Return: Linux IRQ number (> %0) on success, negative errno on failure. 964 */ 965 int acpi_dev_gpio_irq_get_by(struct acpi_device *adev, const char *name, int index) 966 { 967 int idx, i; 968 unsigned int irq_flags; 969 int ret; 970 971 for (i = 0, idx = 0; idx <= index; i++) { 972 struct acpi_gpio_info info; 973 struct gpio_desc *desc; 974 975 desc = acpi_get_gpiod_by_index(adev, name, i, &info); 976 977 /* Ignore -EPROBE_DEFER, it only matters if idx matches */ 978 if (IS_ERR(desc) && PTR_ERR(desc) != -EPROBE_DEFER) 979 return PTR_ERR(desc); 980 981 if (info.gpioint && idx++ == index) { 982 unsigned long lflags = GPIO_LOOKUP_FLAGS_DEFAULT; 983 enum gpiod_flags dflags = GPIOD_ASIS; 984 char label[32]; 985 int irq; 986 987 if (IS_ERR(desc)) 988 return PTR_ERR(desc); 989 990 irq = gpiod_to_irq(desc); 991 if (irq < 0) 992 return irq; 993 994 acpi_gpio_update_gpiod_flags(&dflags, &info); 995 acpi_gpio_update_gpiod_lookup_flags(&lflags, &info); 996 997 snprintf(label, sizeof(label), "GpioInt() %d", index); 998 ret = gpiod_configure_flags(desc, label, lflags, dflags); 999 if (ret < 0) 1000 return ret; 1001 1002 ret = gpio_set_debounce_timeout(desc, info.debounce); 1003 if (ret) 1004 return ret; 1005 1006 irq_flags = acpi_dev_get_irq_type(info.triggering, 1007 info.polarity); 1008 1009 /* Set type if specified and different than the current one */ 1010 if (irq_flags != IRQ_TYPE_NONE && 1011 irq_flags != irq_get_trigger_type(irq)) 1012 irq_set_irq_type(irq, irq_flags); 1013 1014 return irq; 1015 } 1016 1017 } 1018 return -ENOENT; 1019 } 1020 EXPORT_SYMBOL_GPL(acpi_dev_gpio_irq_get_by); 1021 1022 static acpi_status 1023 acpi_gpio_adr_space_handler(u32 function, acpi_physical_address address, 1024 u32 bits, u64 *value, void *handler_context, 1025 void *region_context) 1026 { 1027 struct acpi_gpio_chip *achip = region_context; 1028 struct gpio_chip *chip = achip->chip; 1029 struct acpi_resource_gpio *agpio; 1030 struct acpi_resource *ares; 1031 u16 pin_index = address; 1032 acpi_status status; 1033 int length; 1034 int i; 1035 1036 status = acpi_buffer_to_resource(achip->conn_info.connection, 1037 achip->conn_info.length, &ares); 1038 if (ACPI_FAILURE(status)) 1039 return status; 1040 1041 if (WARN_ON(ares->type != ACPI_RESOURCE_TYPE_GPIO)) { 1042 ACPI_FREE(ares); 1043 return AE_BAD_PARAMETER; 1044 } 1045 1046 agpio = &ares->data.gpio; 1047 1048 if (WARN_ON(agpio->io_restriction == ACPI_IO_RESTRICT_INPUT && 1049 function == ACPI_WRITE)) { 1050 ACPI_FREE(ares); 1051 return AE_BAD_PARAMETER; 1052 } 1053 1054 length = min_t(u16, agpio->pin_table_length, pin_index + bits); 1055 for (i = pin_index; i < length; ++i) { 1056 int pin = agpio->pin_table[i]; 1057 struct acpi_gpio_connection *conn; 1058 struct gpio_desc *desc; 1059 bool found; 1060 1061 mutex_lock(&achip->conn_lock); 1062 1063 found = false; 1064 list_for_each_entry(conn, &achip->conns, node) { 1065 if (conn->pin == pin) { 1066 found = true; 1067 desc = conn->desc; 1068 break; 1069 } 1070 } 1071 1072 /* 1073 * The same GPIO can be shared between operation region and 1074 * event but only if the access here is ACPI_READ. In that 1075 * case we "borrow" the event GPIO instead. 1076 */ 1077 if (!found && agpio->shareable == ACPI_SHARED && 1078 function == ACPI_READ) { 1079 struct acpi_gpio_event *event; 1080 1081 list_for_each_entry(event, &achip->events, node) { 1082 if (event->pin == pin) { 1083 desc = event->desc; 1084 found = true; 1085 break; 1086 } 1087 } 1088 } 1089 1090 if (!found) { 1091 desc = acpi_request_own_gpiod(chip, agpio, i, "ACPI:OpRegion"); 1092 if (IS_ERR(desc)) { 1093 mutex_unlock(&achip->conn_lock); 1094 status = AE_ERROR; 1095 goto out; 1096 } 1097 1098 conn = kzalloc(sizeof(*conn), GFP_KERNEL); 1099 if (!conn) { 1100 gpiochip_free_own_desc(desc); 1101 mutex_unlock(&achip->conn_lock); 1102 status = AE_NO_MEMORY; 1103 goto out; 1104 } 1105 1106 conn->pin = pin; 1107 conn->desc = desc; 1108 list_add_tail(&conn->node, &achip->conns); 1109 } 1110 1111 mutex_unlock(&achip->conn_lock); 1112 1113 if (function == ACPI_WRITE) 1114 gpiod_set_raw_value_cansleep(desc, !!(*value & BIT(i))); 1115 else 1116 *value |= (u64)gpiod_get_raw_value_cansleep(desc) << i; 1117 } 1118 1119 out: 1120 ACPI_FREE(ares); 1121 return status; 1122 } 1123 1124 static void acpi_gpiochip_request_regions(struct acpi_gpio_chip *achip) 1125 { 1126 struct gpio_chip *chip = achip->chip; 1127 acpi_handle handle = ACPI_HANDLE(chip->parent); 1128 acpi_status status; 1129 1130 INIT_LIST_HEAD(&achip->conns); 1131 mutex_init(&achip->conn_lock); 1132 status = acpi_install_address_space_handler(handle, ACPI_ADR_SPACE_GPIO, 1133 acpi_gpio_adr_space_handler, 1134 NULL, achip); 1135 if (ACPI_FAILURE(status)) 1136 dev_err(chip->parent, 1137 "Failed to install GPIO OpRegion handler\n"); 1138 } 1139 1140 static void acpi_gpiochip_free_regions(struct acpi_gpio_chip *achip) 1141 { 1142 struct gpio_chip *chip = achip->chip; 1143 acpi_handle handle = ACPI_HANDLE(chip->parent); 1144 struct acpi_gpio_connection *conn, *tmp; 1145 acpi_status status; 1146 1147 status = acpi_remove_address_space_handler(handle, ACPI_ADR_SPACE_GPIO, 1148 acpi_gpio_adr_space_handler); 1149 if (ACPI_FAILURE(status)) { 1150 dev_err(chip->parent, 1151 "Failed to remove GPIO OpRegion handler\n"); 1152 return; 1153 } 1154 1155 list_for_each_entry_safe_reverse(conn, tmp, &achip->conns, node) { 1156 gpiochip_free_own_desc(conn->desc); 1157 list_del(&conn->node); 1158 kfree(conn); 1159 } 1160 } 1161 1162 static struct gpio_desc * 1163 acpi_gpiochip_parse_own_gpio(struct acpi_gpio_chip *achip, 1164 struct fwnode_handle *fwnode, 1165 const char **name, 1166 unsigned long *lflags, 1167 enum gpiod_flags *dflags) 1168 { 1169 struct gpio_chip *chip = achip->chip; 1170 struct gpio_desc *desc; 1171 u32 gpios[2]; 1172 int ret; 1173 1174 *lflags = GPIO_LOOKUP_FLAGS_DEFAULT; 1175 *dflags = GPIOD_ASIS; 1176 *name = NULL; 1177 1178 ret = fwnode_property_read_u32_array(fwnode, "gpios", gpios, 1179 ARRAY_SIZE(gpios)); 1180 if (ret < 0) 1181 return ERR_PTR(ret); 1182 1183 desc = gpiochip_get_desc(chip, gpios[0]); 1184 if (IS_ERR(desc)) 1185 return desc; 1186 1187 if (gpios[1]) 1188 *lflags |= GPIO_ACTIVE_LOW; 1189 1190 if (fwnode_property_present(fwnode, "input")) 1191 *dflags |= GPIOD_IN; 1192 else if (fwnode_property_present(fwnode, "output-low")) 1193 *dflags |= GPIOD_OUT_LOW; 1194 else if (fwnode_property_present(fwnode, "output-high")) 1195 *dflags |= GPIOD_OUT_HIGH; 1196 else 1197 return ERR_PTR(-EINVAL); 1198 1199 fwnode_property_read_string(fwnode, "line-name", name); 1200 1201 return desc; 1202 } 1203 1204 static void acpi_gpiochip_scan_gpios(struct acpi_gpio_chip *achip) 1205 { 1206 struct gpio_chip *chip = achip->chip; 1207 struct fwnode_handle *fwnode; 1208 1209 device_for_each_child_node(chip->parent, fwnode) { 1210 unsigned long lflags; 1211 enum gpiod_flags dflags; 1212 struct gpio_desc *desc; 1213 const char *name; 1214 int ret; 1215 1216 if (!fwnode_property_present(fwnode, "gpio-hog")) 1217 continue; 1218 1219 desc = acpi_gpiochip_parse_own_gpio(achip, fwnode, &name, 1220 &lflags, &dflags); 1221 if (IS_ERR(desc)) 1222 continue; 1223 1224 ret = gpiod_hog(desc, name, lflags, dflags); 1225 if (ret) { 1226 dev_err(chip->parent, "Failed to hog GPIO\n"); 1227 fwnode_handle_put(fwnode); 1228 return; 1229 } 1230 } 1231 } 1232 1233 void acpi_gpiochip_add(struct gpio_chip *chip) 1234 { 1235 struct acpi_gpio_chip *acpi_gpio; 1236 acpi_handle handle; 1237 acpi_status status; 1238 1239 if (!chip || !chip->parent) 1240 return; 1241 1242 handle = ACPI_HANDLE(chip->parent); 1243 if (!handle) 1244 return; 1245 1246 acpi_gpio = kzalloc(sizeof(*acpi_gpio), GFP_KERNEL); 1247 if (!acpi_gpio) { 1248 dev_err(chip->parent, 1249 "Failed to allocate memory for ACPI GPIO chip\n"); 1250 return; 1251 } 1252 1253 acpi_gpio->chip = chip; 1254 INIT_LIST_HEAD(&acpi_gpio->events); 1255 INIT_LIST_HEAD(&acpi_gpio->deferred_req_irqs_list_entry); 1256 1257 status = acpi_attach_data(handle, acpi_gpio_chip_dh, acpi_gpio); 1258 if (ACPI_FAILURE(status)) { 1259 dev_err(chip->parent, "Failed to attach ACPI GPIO chip\n"); 1260 kfree(acpi_gpio); 1261 return; 1262 } 1263 1264 acpi_gpiochip_request_regions(acpi_gpio); 1265 acpi_gpiochip_scan_gpios(acpi_gpio); 1266 acpi_walk_dep_device_list(handle); 1267 } 1268 1269 void acpi_gpiochip_remove(struct gpio_chip *chip) 1270 { 1271 struct acpi_gpio_chip *acpi_gpio; 1272 acpi_handle handle; 1273 acpi_status status; 1274 1275 if (!chip || !chip->parent) 1276 return; 1277 1278 handle = ACPI_HANDLE(chip->parent); 1279 if (!handle) 1280 return; 1281 1282 status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio); 1283 if (ACPI_FAILURE(status)) { 1284 dev_warn(chip->parent, "Failed to retrieve ACPI GPIO chip\n"); 1285 return; 1286 } 1287 1288 acpi_gpiochip_free_regions(acpi_gpio); 1289 1290 acpi_detach_data(handle, acpi_gpio_chip_dh); 1291 kfree(acpi_gpio); 1292 } 1293 1294 static int acpi_gpio_package_count(const union acpi_object *obj) 1295 { 1296 const union acpi_object *element = obj->package.elements; 1297 const union acpi_object *end = element + obj->package.count; 1298 unsigned int count = 0; 1299 1300 while (element < end) { 1301 switch (element->type) { 1302 case ACPI_TYPE_LOCAL_REFERENCE: 1303 element += 3; 1304 fallthrough; 1305 case ACPI_TYPE_INTEGER: 1306 element++; 1307 count++; 1308 break; 1309 1310 default: 1311 return -EPROTO; 1312 } 1313 } 1314 1315 return count; 1316 } 1317 1318 static int acpi_find_gpio_count(struct acpi_resource *ares, void *data) 1319 { 1320 unsigned int *count = data; 1321 1322 if (ares->type == ACPI_RESOURCE_TYPE_GPIO) 1323 *count += ares->data.gpio.pin_table_length; 1324 1325 return 1; 1326 } 1327 1328 /** 1329 * acpi_gpio_count - count the GPIOs associated with a device / function 1330 * @dev: GPIO consumer, can be %NULL for system-global GPIOs 1331 * @con_id: function within the GPIO consumer 1332 * 1333 * Return: 1334 * The number of GPIOs associated with a device / function or %-ENOENT, 1335 * if no GPIO has been assigned to the requested function. 1336 */ 1337 int acpi_gpio_count(struct device *dev, const char *con_id) 1338 { 1339 struct acpi_device *adev = ACPI_COMPANION(dev); 1340 const union acpi_object *obj; 1341 const struct acpi_gpio_mapping *gm; 1342 int count = -ENOENT; 1343 int ret; 1344 char propname[32]; 1345 unsigned int i; 1346 1347 /* Try first from _DSD */ 1348 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) { 1349 if (con_id) 1350 snprintf(propname, sizeof(propname), "%s-%s", 1351 con_id, gpio_suffixes[i]); 1352 else 1353 snprintf(propname, sizeof(propname), "%s", 1354 gpio_suffixes[i]); 1355 1356 ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_ANY, 1357 &obj); 1358 if (ret == 0) { 1359 if (obj->type == ACPI_TYPE_LOCAL_REFERENCE) 1360 count = 1; 1361 else if (obj->type == ACPI_TYPE_PACKAGE) 1362 count = acpi_gpio_package_count(obj); 1363 } else if (adev->driver_gpios) { 1364 for (gm = adev->driver_gpios; gm->name; gm++) 1365 if (strcmp(propname, gm->name) == 0) { 1366 count = gm->size; 1367 break; 1368 } 1369 } 1370 if (count > 0) 1371 break; 1372 } 1373 1374 /* Then from plain _CRS GPIOs */ 1375 if (count < 0) { 1376 struct list_head resource_list; 1377 unsigned int crs_count = 0; 1378 1379 if (!acpi_can_fallback_to_crs(adev, con_id)) 1380 return count; 1381 1382 INIT_LIST_HEAD(&resource_list); 1383 acpi_dev_get_resources(adev, &resource_list, 1384 acpi_find_gpio_count, &crs_count); 1385 acpi_dev_free_resource_list(&resource_list); 1386 if (crs_count > 0) 1387 count = crs_count; 1388 } 1389 return count ? count : -ENOENT; 1390 } 1391 1392 /* Run deferred acpi_gpiochip_request_irqs() */ 1393 static int __init acpi_gpio_handle_deferred_request_irqs(void) 1394 { 1395 struct acpi_gpio_chip *acpi_gpio, *tmp; 1396 1397 mutex_lock(&acpi_gpio_deferred_req_irqs_lock); 1398 list_for_each_entry_safe(acpi_gpio, tmp, 1399 &acpi_gpio_deferred_req_irqs_list, 1400 deferred_req_irqs_list_entry) 1401 acpi_gpiochip_request_irqs(acpi_gpio); 1402 1403 acpi_gpio_deferred_req_irqs_done = true; 1404 mutex_unlock(&acpi_gpio_deferred_req_irqs_lock); 1405 1406 return 0; 1407 } 1408 /* We must use _sync so that this runs after the first deferred_probe run */ 1409 late_initcall_sync(acpi_gpio_handle_deferred_request_irqs); 1410 1411 static const struct dmi_system_id gpiolib_acpi_quirks[] __initconst = { 1412 { 1413 /* 1414 * The Minix Neo Z83-4 has a micro-USB-B id-pin handler for 1415 * a non existing micro-USB-B connector which puts the HDMI 1416 * DDC pins in GPIO mode, breaking HDMI support. 1417 */ 1418 .matches = { 1419 DMI_MATCH(DMI_SYS_VENDOR, "MINIX"), 1420 DMI_MATCH(DMI_PRODUCT_NAME, "Z83-4"), 1421 }, 1422 .driver_data = &(struct acpi_gpiolib_dmi_quirk) { 1423 .no_edge_events_on_boot = true, 1424 }, 1425 }, 1426 { 1427 /* 1428 * The Terra Pad 1061 has a micro-USB-B id-pin handler, which 1429 * instead of controlling the actual micro-USB-B turns the 5V 1430 * boost for its USB-A connector off. The actual micro-USB-B 1431 * connector is wired for charging only. 1432 */ 1433 .matches = { 1434 DMI_MATCH(DMI_SYS_VENDOR, "Wortmann_AG"), 1435 DMI_MATCH(DMI_PRODUCT_NAME, "TERRA_PAD_1061"), 1436 }, 1437 .driver_data = &(struct acpi_gpiolib_dmi_quirk) { 1438 .no_edge_events_on_boot = true, 1439 }, 1440 }, 1441 { 1442 /* 1443 * HP X2 10 models with Cherry Trail SoC + TI PMIC use an 1444 * external embedded-controller connected via I2C + an ACPI GPIO 1445 * event handler on INT33FF:01 pin 0, causing spurious wakeups. 1446 * When suspending by closing the LID, the power to the USB 1447 * keyboard is turned off, causing INT0002 ACPI events to 1448 * trigger once the XHCI controller notices the keyboard is 1449 * gone. So INT0002 events cause spurious wakeups too. Ignoring 1450 * EC wakes breaks wakeup when opening the lid, the user needs 1451 * to press the power-button to wakeup the system. The 1452 * alternative is suspend simply not working, which is worse. 1453 */ 1454 .matches = { 1455 DMI_MATCH(DMI_SYS_VENDOR, "HP"), 1456 DMI_MATCH(DMI_PRODUCT_NAME, "HP x2 Detachable 10-p0XX"), 1457 }, 1458 .driver_data = &(struct acpi_gpiolib_dmi_quirk) { 1459 .ignore_wake = "INT33FF:01@0,INT0002:00@2", 1460 }, 1461 }, 1462 { 1463 /* 1464 * HP X2 10 models with Bay Trail SoC + AXP288 PMIC use an 1465 * external embedded-controller connected via I2C + an ACPI GPIO 1466 * event handler on INT33FC:02 pin 28, causing spurious wakeups. 1467 */ 1468 .matches = { 1469 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 1470 DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"), 1471 DMI_MATCH(DMI_BOARD_NAME, "815D"), 1472 }, 1473 .driver_data = &(struct acpi_gpiolib_dmi_quirk) { 1474 .ignore_wake = "INT33FC:02@28", 1475 }, 1476 }, 1477 { 1478 /* 1479 * HP X2 10 models with Cherry Trail SoC + AXP288 PMIC use an 1480 * external embedded-controller connected via I2C + an ACPI GPIO 1481 * event handler on INT33FF:01 pin 0, causing spurious wakeups. 1482 */ 1483 .matches = { 1484 DMI_MATCH(DMI_SYS_VENDOR, "HP"), 1485 DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"), 1486 DMI_MATCH(DMI_BOARD_NAME, "813E"), 1487 }, 1488 .driver_data = &(struct acpi_gpiolib_dmi_quirk) { 1489 .ignore_wake = "INT33FF:01@0", 1490 }, 1491 }, 1492 {} /* Terminating entry */ 1493 }; 1494 1495 static int __init acpi_gpio_setup_params(void) 1496 { 1497 const struct acpi_gpiolib_dmi_quirk *quirk = NULL; 1498 const struct dmi_system_id *id; 1499 1500 id = dmi_first_match(gpiolib_acpi_quirks); 1501 if (id) 1502 quirk = id->driver_data; 1503 1504 if (run_edge_events_on_boot < 0) { 1505 if (quirk && quirk->no_edge_events_on_boot) 1506 run_edge_events_on_boot = 0; 1507 else 1508 run_edge_events_on_boot = 1; 1509 } 1510 1511 if (ignore_wake == NULL && quirk && quirk->ignore_wake) 1512 ignore_wake = quirk->ignore_wake; 1513 1514 return 0; 1515 } 1516 1517 /* Directly after dmi_setup() which runs as core_initcall() */ 1518 postcore_initcall(acpi_gpio_setup_params); 1519