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