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