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