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