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