1724 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * ACPI helpers for GPIO API4 *5 * Copyright (C) 2012, Intel Corporation6 * 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 data51 *52 * @node: list-entry of the events list of the struct acpi_gpio_chip53 * @handle: handle of ACPI method to execute when the IRQ triggers54 * @handler: handler function to pass to request_irq() when requesting the IRQ55 * @pin: GPIO pin number on the struct gpio_chip56 * @irq: Linux IRQ number for the event, for request_irq() / free_irq()57 * @irqflags: flags to pass to request_irq() when requesting the IRQ58 * @irq_is_wake: If the ACPI flags indicate the IRQ is a wakeup source59 * @irq_requested:True if request_irq() has been done60 * @desc: struct gpio_desc for the GPIO pin for this event61 */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 parameter83 * passed to acpi_install_address_space_handler() is large enough84 * 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 information96 * @adev: reference to ACPI device which consumes GPIO resource97 * @flags: GPIO initialization flags98 * @gpioint: if %true this GPIO is of type GpioInt otherwise type is GpioIo99 * @pin_config: pin bias as provided by ACPI100 * @polarity: interrupt polarity as provided by ACPI101 * @triggering: triggering type as provided by ACPI102 * @wake_capable: wake capability as provided by ACPI103 * @debounce: debounce timeout as provided by ACPI104 * @quirks: Linux specific quirks as provided by struct acpi_gpio_mapping105 */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_init120 * (so builtin drivers) we register the ACPI GpioInt IRQ handlers from a121 * late_initcall_sync() handler, so that other builtin drivers can register their122 * OpRegions before the event handlers can run. This list contains GPIO chips123 * for which the acpi_gpiochip_request_irqs() call has been deferred.124 */125static DEFINE_MUTEX(acpi_gpio_deferred_req_irqs_lock);126static LIST_HEAD(acpi_gpio_deferred_req_irqs_list);127static bool acpi_gpio_deferred_req_irqs_done;128 129static int acpi_gpiochip_find(struct gpio_chip *gc, const void *data)130{131 /* First check the actual GPIO device */132 if (device_match_acpi_handle(&gc->gpiodev->dev, data))133 return true;134 135 /*136 * When the ACPI device is artificially split to the banks of GPIOs,137 * where each of them is represented by a separate GPIO device,138 * the firmware node of the physical device may not be shared among139 * the banks as they may require different values for the same property,140 * e.g., number of GPIOs in a certain bank. In such case the ACPI handle141 * of a GPIO device is NULL and can not be used. Hence we have to check142 * the parent device to be sure that there is no match before bailing143 * out.144 */145 if (gc->parent)146 return device_match_acpi_handle(gc->parent, data);147 148 return false;149}150 151/**152 * acpi_get_gpiod() - Translate ACPI GPIO pin to GPIO descriptor usable with GPIO API153 * @path: ACPI GPIO controller full path name, (e.g. "\\_SB.GPO1")154 * @pin: ACPI GPIO pin number (0-based, controller-relative)155 *156 * Returns:157 * GPIO descriptor to use with Linux generic GPIO API.158 * If the GPIO cannot be translated or there is an error an ERR_PTR is159 * returned.160 *161 * Specifically returns %-EPROBE_DEFER if the referenced GPIO162 * controller does not have GPIO chip registered at the moment. This is to163 * support probe deferral.164 */165static struct gpio_desc *acpi_get_gpiod(char *path, unsigned int pin)166{167 acpi_handle handle;168 acpi_status status;169 170 status = acpi_get_handle(NULL, path, &handle);171 if (ACPI_FAILURE(status))172 return ERR_PTR(-ENODEV);173 174 struct gpio_device *gdev __free(gpio_device_put) =175 gpio_device_find(handle, acpi_gpiochip_find);176 if (!gdev)177 return ERR_PTR(-EPROBE_DEFER);178 179 /*180 * FIXME: keep track of the reference to the GPIO device somehow181 * instead of putting it here.182 */183 return gpio_device_get_desc(gdev, pin);184}185 186static irqreturn_t acpi_gpio_irq_handler(int irq, void *data)187{188 struct acpi_gpio_event *event = data;189 190 acpi_evaluate_object(event->handle, NULL, NULL, NULL);191 192 return IRQ_HANDLED;193}194 195static irqreturn_t acpi_gpio_irq_handler_evt(int irq, void *data)196{197 struct acpi_gpio_event *event = data;198 199 acpi_execute_simple_method(event->handle, NULL, event->pin);200 201 return IRQ_HANDLED;202}203 204static void acpi_gpio_chip_dh(acpi_handle handle, void *data)205{206 /* The address of this function is used as a key. */207}208 209bool acpi_gpio_get_irq_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_INT)219 return false;220 221 *agpio = gpio;222 return true;223}224EXPORT_SYMBOL_GPL(acpi_gpio_get_irq_resource);225 226/**227 * acpi_gpio_get_io_resource - Fetch details of an ACPI resource if it is a GPIO228 * I/O resource or return False if not.229 * @ares: Pointer to the ACPI resource to fetch230 * @agpio: Pointer to a &struct acpi_resource_gpio to store the output pointer231 *232 * Returns:233 * %true if GpioIo resource is found, %false otherwise.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_flags289acpi_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 the301 * GPIO. Therefore we deduce that value from the pull field302 * and the polarity instead. If the pin is pulled up we assume303 * default to be high, if it is pulled down we assume default304 * to be low, otherwise we leave pin untouched. For active low305 * polarity values will be switched. See also306 * 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 pull323 * 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 if (acpi_gpio_in_ignore_list(ignore_interrupt, dev_name(chip->parent), pin)) {441 dev_info(chip->parent, "Ignoring interrupt on pin %u\n", pin);442 return AE_OK;443 }444 445 desc = acpi_request_own_gpiod(chip, agpio, 0, "ACPI:Event");446 if (IS_ERR(desc)) {447 dev_err(chip->parent,448 "Failed to request GPIO for pin 0x%04X, err %ld\n",449 pin, PTR_ERR(desc));450 return AE_OK;451 }452 453 ret = gpiochip_lock_as_irq(chip, pin);454 if (ret) {455 dev_err(chip->parent,456 "Failed to lock GPIO pin 0x%04X as interrupt, err %d\n",457 pin, ret);458 goto fail_free_desc;459 }460 461 irq = gpiod_to_irq(desc);462 if (irq < 0) {463 dev_err(chip->parent,464 "Failed to translate GPIO pin 0x%04X to IRQ, err %d\n",465 pin, irq);466 goto fail_unlock_irq;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 else478 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 events515 * @chip: GPIO chip516 *517 * ACPI5 platforms can use GPIO signaled ACPI events. These GPIO interrupts are518 * handled by ACPI event methods which need to be called from the GPIO519 * chip's interrupt handler. acpi_gpiochip_request_interrupts() finds out which520 * GPIO pins have ACPI event methods and assigns interrupt handlers that calls521 * 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 chip564 *565 * Free interrupts associated with GPIO ACPI event method for the given566 * 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 int672__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 direction681 * and update @flags accordingly. Otherwise use whatever caller asked682 * 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 initialization689 * flags.690 *691 * Return %-EINVAL to notify that firmware has different692 * 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 else780 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 GpioInt790 * resource.791 * Note: we expect here:792 * - ACPI_ACTIVE_LOW == GPIO_ACTIVE_LOW793 * - ACPI_ACTIVE_HIGH == GPIO_ACTIVE_HIGH794 */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 based853 * 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 resources872 * @adev: pointer to a ACPI device to get GPIO from873 * @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 looks878 * up a GpioIo/GpioInt resource, translates it to the Linux GPIO descriptor,879 * and returns it. @index matches GpioIo/GpioInt resources only so if there880 * 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. In883 * that case @index is used to select the GPIO entry in the property value884 * (in case of multiple).885 *886 * Returns:887 * GPIO descriptor to use with Linux generic GPIO API.888 * If the GPIO cannot be translated or there is an error an ERR_PTR is889 * returned.890 *891 * Note: if the GPIO resource has multiple entries in the pin list, this892 * function only returns the first.893 */894static struct gpio_desc *acpi_get_gpiod_by_index(struct acpi_device *adev,895 const char *propname,896 int index,897 struct acpi_gpio_info *info)898{899 struct acpi_gpio_lookup lookup;900 int ret;901 902 memset(&lookup, 0, sizeof(lookup));903 lookup.index = index;904 905 if (propname) {906 dev_dbg(&adev->dev, "GPIO: looking up %s\n", propname);907 908 ret = acpi_gpio_property_lookup(acpi_fwnode_handle(adev),909 propname, index, &lookup);910 if (ret)911 return ERR_PTR(ret);912 913 dev_dbg(&adev->dev, "GPIO: _DSD returned %s %d %u %u\n",914 dev_name(&lookup.info.adev->dev), lookup.index,915 lookup.pin_index, lookup.active_low);916 } else {917 dev_dbg(&adev->dev, "GPIO: looking up %d in _CRS\n", index);918 lookup.info.adev = adev;919 }920 921 ret = acpi_gpio_resource_lookup(&lookup, info);922 return ret ? ERR_PTR(ret) : lookup.desc;923}924 925/**926 * acpi_get_gpiod_from_data() - get a GPIO descriptor from ACPI data node927 * @fwnode: pointer to an ACPI firmware node to get the GPIO information from928 * @propname: Property name of the GPIO929 * @index: index of GpioIo/GpioInt resource (starting from %0)930 * @info: info pointer to fill in (optional)931 *932 * This function uses the property-based GPIO lookup to get to the GPIO933 * resource with the relevant information from a data-only ACPI firmware node934 * and uses that to obtain the GPIO descriptor to return.935 *936 * Returns:937 * GPIO descriptor to use with Linux generic GPIO API.938 * If the GPIO cannot be translated or there is an error an ERR_PTR is939 * returned.940 */941static struct gpio_desc *acpi_get_gpiod_from_data(struct fwnode_handle *fwnode,942 const char *propname,943 int index,944 struct acpi_gpio_info *info)945{946 struct acpi_gpio_lookup lookup;947 int ret;948 949 if (!is_acpi_data_node(fwnode))950 return ERR_PTR(-ENODEV);951 952 if (!propname)953 return ERR_PTR(-EINVAL);954 955 memset(&lookup, 0, sizeof(lookup));956 lookup.index = index;957 958 ret = acpi_gpio_property_lookup(fwnode, propname, index, &lookup);959 if (ret)960 return ERR_PTR(ret);961 962 ret = acpi_gpio_resource_lookup(&lookup, info);963 return ret ? ERR_PTR(ret) : lookup.desc;964}965 966static bool acpi_can_fallback_to_crs(struct acpi_device *adev,967 const char *con_id)968{969 /* If there is no ACPI device, there is no _CRS to fall back to */970 if (!adev)971 return false;972 973 /* Never allow fallback if the device has properties */974 if (acpi_dev_has_props(adev) || adev->driver_gpios)975 return false;976 977 return con_id == NULL;978}979 980static struct gpio_desc *981__acpi_find_gpio(struct fwnode_handle *fwnode, const char *con_id, unsigned int idx,982 bool can_fallback, struct acpi_gpio_info *info)983{984 struct acpi_device *adev = to_acpi_device_node(fwnode);985 struct gpio_desc *desc;986 char propname[32];987 988 /* Try first from _DSD */989 for_each_gpio_property_name(propname, con_id) {990 if (adev)991 desc = acpi_get_gpiod_by_index(adev,992 propname, idx, info);993 else994 desc = acpi_get_gpiod_from_data(fwnode,995 propname, idx, info);996 if (PTR_ERR(desc) == -EPROBE_DEFER)997 return ERR_CAST(desc);998 999 if (!IS_ERR(desc))1000 return desc;1001 }1002 1003 /* Then from plain _CRS GPIOs */1004 if (can_fallback)1005 return acpi_get_gpiod_by_index(adev, NULL, idx, info);1006 1007 return ERR_PTR(-ENOENT);1008}1009 1010struct gpio_desc *acpi_find_gpio(struct fwnode_handle *fwnode,1011 const char *con_id,1012 unsigned int idx,1013 enum gpiod_flags *dflags,1014 unsigned long *lookupflags)1015{1016 struct acpi_device *adev = to_acpi_device_node(fwnode);1017 bool can_fallback = acpi_can_fallback_to_crs(adev, con_id);1018 struct acpi_gpio_info info;1019 struct gpio_desc *desc;1020 1021 desc = __acpi_find_gpio(fwnode, con_id, idx, can_fallback, &info);1022 if (IS_ERR(desc))1023 return desc;1024 1025 if (info.gpioint &&1026 (*dflags == GPIOD_OUT_LOW || *dflags == GPIOD_OUT_HIGH)) {1027 dev_dbg(&adev->dev, "refusing GpioInt() entry when doing GPIOD_OUT_* lookup\n");1028 return ERR_PTR(-ENOENT);1029 }1030 1031 acpi_gpio_update_gpiod_flags(dflags, &info);1032 acpi_gpio_update_gpiod_lookup_flags(lookupflags, &info);1033 return desc;1034}1035 1036/**1037 * acpi_dev_gpio_irq_wake_get_by() - Find GpioInt and translate it to Linux IRQ number1038 * @adev: pointer to a ACPI device to get IRQ from1039 * @con_id: optional name of GpioInt resource1040 * @index: index of GpioInt resource (starting from %0)1041 * @wake_capable: Set to true if the IRQ is wake capable1042 *1043 * If the device has one or more GpioInt resources, this function can be1044 * used to translate from the GPIO offset in the resource to the Linux IRQ1045 * number.1046 *1047 * The function is idempotent, though each time it runs it will configure GPIO1048 * pin direction according to the flags in GpioInt resource.1049 *1050 * The function takes optional @con_id parameter. If the resource has1051 * a @con_id in a property, then only those will be taken into account.1052 *1053 * The GPIO is considered wake capable if the GpioInt resource specifies1054 * SharedAndWake or ExclusiveAndWake.1055 *1056 * Returns:1057 * Linux IRQ number (> 0) on success, negative errno on failure.1058 */1059int acpi_dev_gpio_irq_wake_get_by(struct acpi_device *adev, const char *con_id, int index,1060 bool *wake_capable)1061{1062 struct fwnode_handle *fwnode = acpi_fwnode_handle(adev);1063 int idx, i;1064 unsigned int irq_flags;1065 int ret;1066 1067 for (i = 0, idx = 0; idx <= index; i++) {1068 struct acpi_gpio_info info;1069 struct gpio_desc *desc;1070 1071 /* Ignore -EPROBE_DEFER, it only matters if idx matches */1072 desc = __acpi_find_gpio(fwnode, con_id, i, true, &info);1073 if (IS_ERR(desc) && PTR_ERR(desc) != -EPROBE_DEFER)1074 return PTR_ERR(desc);1075 1076 if (info.gpioint && idx++ == index) {1077 unsigned long lflags = GPIO_LOOKUP_FLAGS_DEFAULT;1078 enum gpiod_flags dflags = GPIOD_ASIS;1079 char label[32];1080 int irq;1081 1082 if (IS_ERR(desc))1083 return PTR_ERR(desc);1084 1085 irq = gpiod_to_irq(desc);1086 if (irq < 0)1087 return irq;1088 1089 acpi_gpio_update_gpiod_flags(&dflags, &info);1090 acpi_gpio_update_gpiod_lookup_flags(&lflags, &info);1091 1092 snprintf(label, sizeof(label), "%pfwP GpioInt(%d)", fwnode, index);1093 ret = gpiod_set_consumer_name(desc, con_id ?: label);1094 if (ret)1095 return ret;1096 1097 ret = gpiod_configure_flags(desc, label, lflags, dflags);1098 if (ret < 0)1099 return ret;1100 1101 /* ACPI uses hundredths of milliseconds units */1102 ret = gpio_set_debounce_timeout(desc, info.debounce * 10);1103 if (ret)1104 return ret;1105 1106 irq_flags = acpi_dev_get_irq_type(info.triggering,1107 info.polarity);1108 1109 /*1110 * If the IRQ is not already in use then set type1111 * if specified and different than the current one.1112 */1113 if (can_request_irq(irq, irq_flags)) {1114 if (irq_flags != IRQ_TYPE_NONE &&1115 irq_flags != irq_get_trigger_type(irq))1116 irq_set_irq_type(irq, irq_flags);1117 } else {1118 dev_dbg(&adev->dev, "IRQ %d already in use\n", irq);1119 }1120 1121 /* avoid suspend issues with GPIOs when systems are using S3 */1122 if (wake_capable && acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0)1123 *wake_capable = info.wake_capable;1124 1125 return irq;1126 }1127 1128 }1129 return -ENOENT;1130}1131EXPORT_SYMBOL_GPL(acpi_dev_gpio_irq_wake_get_by);1132 1133static acpi_status1134acpi_gpio_adr_space_handler(u32 function, acpi_physical_address address,1135 u32 bits, u64 *value, void *handler_context,1136 void *region_context)1137{1138 struct acpi_gpio_chip *achip = region_context;1139 struct gpio_chip *chip = achip->chip;1140 struct acpi_resource_gpio *agpio;1141 struct acpi_resource *ares;1142 u16 pin_index = address;1143 acpi_status status;1144 int length;1145 int i;1146 1147 status = acpi_buffer_to_resource(achip->conn_info.connection,1148 achip->conn_info.length, &ares);1149 if (ACPI_FAILURE(status))1150 return status;1151 1152 if (WARN_ON(ares->type != ACPI_RESOURCE_TYPE_GPIO)) {1153 ACPI_FREE(ares);1154 return AE_BAD_PARAMETER;1155 }1156 1157 agpio = &ares->data.gpio;1158 1159 if (WARN_ON(agpio->io_restriction == ACPI_IO_RESTRICT_INPUT &&1160 function == ACPI_WRITE)) {1161 ACPI_FREE(ares);1162 return AE_BAD_PARAMETER;1163 }1164 1165 length = min_t(u16, agpio->pin_table_length, pin_index + bits);1166 for (i = pin_index; i < length; ++i) {1167 unsigned int pin = agpio->pin_table[i];1168 struct acpi_gpio_connection *conn;1169 struct gpio_desc *desc;1170 bool found;1171 1172 mutex_lock(&achip->conn_lock);1173 1174 found = false;1175 list_for_each_entry(conn, &achip->conns, node) {1176 if (conn->pin == pin) {1177 found = true;1178 desc = conn->desc;1179 break;1180 }1181 }1182 1183 /*1184 * The same GPIO can be shared between operation region and1185 * event but only if the access here is ACPI_READ. In that1186 * case we "borrow" the event GPIO instead.1187 */1188 if (!found && agpio->shareable == ACPI_SHARED &&1189 function == ACPI_READ) {1190 struct acpi_gpio_event *event;1191 1192 list_for_each_entry(event, &achip->events, node) {1193 if (event->pin == pin) {1194 desc = event->desc;1195 found = true;1196 break;1197 }1198 }1199 }1200 1201 if (!found) {1202 desc = acpi_request_own_gpiod(chip, agpio, i, "ACPI:OpRegion");1203 if (IS_ERR(desc)) {1204 mutex_unlock(&achip->conn_lock);1205 status = AE_ERROR;1206 goto out;1207 }1208 1209 conn = kzalloc(sizeof(*conn), GFP_KERNEL);1210 if (!conn) {1211 gpiochip_free_own_desc(desc);1212 mutex_unlock(&achip->conn_lock);1213 status = AE_NO_MEMORY;1214 goto out;1215 }1216 1217 conn->pin = pin;1218 conn->desc = desc;1219 list_add_tail(&conn->node, &achip->conns);1220 }1221 1222 mutex_unlock(&achip->conn_lock);1223 1224 if (function == ACPI_WRITE)1225 gpiod_set_raw_value_cansleep(desc, !!(*value & BIT(i)));1226 else1227 *value |= (u64)gpiod_get_raw_value_cansleep(desc) << i;1228 }1229 1230out:1231 ACPI_FREE(ares);1232 return status;1233}1234 1235static void acpi_gpiochip_request_regions(struct acpi_gpio_chip *achip)1236{1237 struct gpio_chip *chip = achip->chip;1238 acpi_handle handle = ACPI_HANDLE(chip->parent);1239 acpi_status status;1240 1241 INIT_LIST_HEAD(&achip->conns);1242 mutex_init(&achip->conn_lock);1243 status = acpi_install_address_space_handler(handle, ACPI_ADR_SPACE_GPIO,1244 acpi_gpio_adr_space_handler,1245 NULL, achip);1246 if (ACPI_FAILURE(status))1247 dev_err(chip->parent,1248 "Failed to install GPIO OpRegion handler\n");1249}1250 1251static void acpi_gpiochip_free_regions(struct acpi_gpio_chip *achip)1252{1253 struct gpio_chip *chip = achip->chip;1254 acpi_handle handle = ACPI_HANDLE(chip->parent);1255 struct acpi_gpio_connection *conn, *tmp;1256 acpi_status status;1257 1258 status = acpi_remove_address_space_handler(handle, ACPI_ADR_SPACE_GPIO,1259 acpi_gpio_adr_space_handler);1260 if (ACPI_FAILURE(status)) {1261 dev_err(chip->parent,1262 "Failed to remove GPIO OpRegion handler\n");1263 return;1264 }1265 1266 list_for_each_entry_safe_reverse(conn, tmp, &achip->conns, node) {1267 gpiochip_free_own_desc(conn->desc);1268 list_del(&conn->node);1269 kfree(conn);1270 }1271}1272 1273static struct gpio_desc *1274acpi_gpiochip_parse_own_gpio(struct acpi_gpio_chip *achip,1275 struct fwnode_handle *fwnode,1276 const char **name,1277 unsigned long *lflags,1278 enum gpiod_flags *dflags)1279{1280 struct gpio_chip *chip = achip->chip;1281 struct gpio_desc *desc;1282 u32 gpios[2];1283 int ret;1284 1285 *lflags = GPIO_LOOKUP_FLAGS_DEFAULT;1286 *dflags = GPIOD_ASIS;1287 *name = NULL;1288 1289 ret = fwnode_property_read_u32_array(fwnode, "gpios", gpios,1290 ARRAY_SIZE(gpios));1291 if (ret < 0)1292 return ERR_PTR(ret);1293 1294 desc = gpiochip_get_desc(chip, gpios[0]);1295 if (IS_ERR(desc))1296 return desc;1297 1298 if (gpios[1])1299 *lflags |= GPIO_ACTIVE_LOW;1300 1301 if (fwnode_property_present(fwnode, "input"))1302 *dflags |= GPIOD_IN;1303 else if (fwnode_property_present(fwnode, "output-low"))1304 *dflags |= GPIOD_OUT_LOW;1305 else if (fwnode_property_present(fwnode, "output-high"))1306 *dflags |= GPIOD_OUT_HIGH;1307 else1308 return ERR_PTR(-EINVAL);1309 1310 fwnode_property_read_string(fwnode, "line-name", name);1311 1312 return desc;1313}1314 1315static void acpi_gpiochip_scan_gpios(struct acpi_gpio_chip *achip)1316{1317 struct gpio_chip *chip = achip->chip;1318 struct fwnode_handle *fwnode;1319 1320 device_for_each_child_node(chip->parent, fwnode) {1321 unsigned long lflags;1322 enum gpiod_flags dflags;1323 struct gpio_desc *desc;1324 const char *name;1325 int ret;1326 1327 if (!fwnode_property_present(fwnode, "gpio-hog"))1328 continue;1329 1330 desc = acpi_gpiochip_parse_own_gpio(achip, fwnode, &name,1331 &lflags, &dflags);1332 if (IS_ERR(desc))1333 continue;1334 1335 ret = gpiod_hog(desc, name, lflags, dflags);1336 if (ret) {1337 dev_err(chip->parent, "Failed to hog GPIO\n");1338 fwnode_handle_put(fwnode);1339 return;1340 }1341 }1342}1343 1344void acpi_gpiochip_add(struct gpio_chip *chip)1345{1346 struct acpi_gpio_chip *acpi_gpio;1347 struct acpi_device *adev;1348 acpi_status status;1349 1350 if (!chip || !chip->parent)1351 return;1352 1353 adev = ACPI_COMPANION(chip->parent);1354 if (!adev)1355 return;1356 1357 acpi_gpio = kzalloc(sizeof(*acpi_gpio), GFP_KERNEL);1358 if (!acpi_gpio) {1359 dev_err(chip->parent,1360 "Failed to allocate memory for ACPI GPIO chip\n");1361 return;1362 }1363 1364 acpi_gpio->chip = chip;1365 INIT_LIST_HEAD(&acpi_gpio->events);1366 INIT_LIST_HEAD(&acpi_gpio->deferred_req_irqs_list_entry);1367 1368 status = acpi_attach_data(adev->handle, acpi_gpio_chip_dh, acpi_gpio);1369 if (ACPI_FAILURE(status)) {1370 dev_err(chip->parent, "Failed to attach ACPI GPIO chip\n");1371 kfree(acpi_gpio);1372 return;1373 }1374 1375 acpi_gpiochip_request_regions(acpi_gpio);1376 acpi_gpiochip_scan_gpios(acpi_gpio);1377 acpi_dev_clear_dependencies(adev);1378}1379 1380void acpi_gpiochip_remove(struct gpio_chip *chip)1381{1382 struct acpi_gpio_chip *acpi_gpio;1383 acpi_handle handle;1384 acpi_status status;1385 1386 if (!chip || !chip->parent)1387 return;1388 1389 handle = ACPI_HANDLE(chip->parent);1390 if (!handle)1391 return;1392 1393 status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);1394 if (ACPI_FAILURE(status)) {1395 dev_warn(chip->parent, "Failed to retrieve ACPI GPIO chip\n");1396 return;1397 }1398 1399 acpi_gpiochip_free_regions(acpi_gpio);1400 1401 acpi_detach_data(handle, acpi_gpio_chip_dh);1402 kfree(acpi_gpio);1403}1404 1405static int acpi_gpio_package_count(const union acpi_object *obj)1406{1407 const union acpi_object *element = obj->package.elements;1408 const union acpi_object *end = element + obj->package.count;1409 unsigned int count = 0;1410 1411 while (element < end) {1412 switch (element->type) {1413 case ACPI_TYPE_LOCAL_REFERENCE:1414 element += 3;1415 fallthrough;1416 case ACPI_TYPE_INTEGER:1417 element++;1418 count++;1419 break;1420 1421 default:1422 return -EPROTO;1423 }1424 }1425 1426 return count;1427}1428 1429static int acpi_find_gpio_count(struct acpi_resource *ares, void *data)1430{1431 unsigned int *count = data;1432 1433 if (ares->type == ACPI_RESOURCE_TYPE_GPIO)1434 *count += ares->data.gpio.pin_table_length;1435 1436 return 1;1437}1438 1439/**1440 * acpi_gpio_count - count the GPIOs associated with a firmware node / function1441 * @fwnode: firmware node of the GPIO consumer1442 * @con_id: function within the GPIO consumer1443 *1444 * Returns:1445 * The number of GPIOs associated with a firmware node / function or %-ENOENT,1446 * if no GPIO has been assigned to the requested function.1447 */1448int acpi_gpio_count(const struct fwnode_handle *fwnode, const char *con_id)1449{1450 struct acpi_device *adev = to_acpi_device_node(fwnode);1451 const union acpi_object *obj;1452 const struct acpi_gpio_mapping *gm;1453 int count = -ENOENT;1454 int ret;1455 char propname[32];1456 1457 /* Try first from _DSD */1458 for_each_gpio_property_name(propname, con_id) {1459 ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_ANY, &obj);1460 if (ret == 0) {1461 if (obj->type == ACPI_TYPE_LOCAL_REFERENCE)1462 count = 1;1463 else if (obj->type == ACPI_TYPE_PACKAGE)1464 count = acpi_gpio_package_count(obj);1465 } else if (adev->driver_gpios) {1466 for (gm = adev->driver_gpios; gm->name; gm++)1467 if (strcmp(propname, gm->name) == 0) {1468 count = gm->size;1469 break;1470 }1471 }1472 if (count > 0)1473 break;1474 }1475 1476 /* Then from plain _CRS GPIOs */1477 if (count < 0) {1478 struct list_head resource_list;1479 unsigned int crs_count = 0;1480 1481 if (!acpi_can_fallback_to_crs(adev, con_id))1482 return count;1483 1484 INIT_LIST_HEAD(&resource_list);1485 acpi_dev_get_resources(adev, &resource_list,1486 acpi_find_gpio_count, &crs_count);1487 acpi_dev_free_resource_list(&resource_list);1488 if (crs_count > 0)1489 count = crs_count;1490 }1491 return count ? count : -ENOENT;1492}1493 1494/* Run deferred acpi_gpiochip_request_irqs() */1495static int __init acpi_gpio_handle_deferred_request_irqs(void)1496{1497 struct acpi_gpio_chip *acpi_gpio, *tmp;1498 1499 mutex_lock(&acpi_gpio_deferred_req_irqs_lock);1500 list_for_each_entry_safe(acpi_gpio, tmp,1501 &acpi_gpio_deferred_req_irqs_list,1502 deferred_req_irqs_list_entry)1503 acpi_gpiochip_request_irqs(acpi_gpio);1504 1505 acpi_gpio_deferred_req_irqs_done = true;1506 mutex_unlock(&acpi_gpio_deferred_req_irqs_lock);1507 1508 return 0;1509}1510/* We must use _sync so that this runs after the first deferred_probe run */1511late_initcall_sync(acpi_gpio_handle_deferred_request_irqs);1512 1513static const struct dmi_system_id gpiolib_acpi_quirks[] __initconst = {1514 {1515 /*1516 * The Minix Neo Z83-4 has a micro-USB-B id-pin handler for1517 * a non existing micro-USB-B connector which puts the HDMI1518 * DDC pins in GPIO mode, breaking HDMI support.1519 */1520 .matches = {1521 DMI_MATCH(DMI_SYS_VENDOR, "MINIX"),1522 DMI_MATCH(DMI_PRODUCT_NAME, "Z83-4"),1523 },1524 .driver_data = &(struct acpi_gpiolib_dmi_quirk) {1525 .no_edge_events_on_boot = true,1526 },1527 },1528 {1529 /*1530 * The Terra Pad 1061 has a micro-USB-B id-pin handler, which1531 * instead of controlling the actual micro-USB-B turns the 5V1532 * boost for its USB-A connector off. The actual micro-USB-B1533 * connector is wired for charging only.1534 */1535 .matches = {1536 DMI_MATCH(DMI_SYS_VENDOR, "Wortmann_AG"),1537 DMI_MATCH(DMI_PRODUCT_NAME, "TERRA_PAD_1061"),1538 },1539 .driver_data = &(struct acpi_gpiolib_dmi_quirk) {1540 .no_edge_events_on_boot = true,1541 },1542 },1543 {1544 /*1545 * The Dell Venue 10 Pro 5055, with Bay Trail SoC + TI PMIC uses an1546 * external embedded-controller connected via I2C + an ACPI GPIO1547 * event handler on INT33FFC:02 pin 12, causing spurious wakeups.1548 */1549 .matches = {1550 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),1551 DMI_MATCH(DMI_PRODUCT_NAME, "Venue 10 Pro 5055"),1552 },1553 .driver_data = &(struct acpi_gpiolib_dmi_quirk) {1554 .ignore_wake = "INT33FC:02@12",1555 },1556 },1557 {1558 /*1559 * HP X2 10 models with Cherry Trail SoC + TI PMIC use an1560 * external embedded-controller connected via I2C + an ACPI GPIO1561 * event handler on INT33FF:01 pin 0, causing spurious wakeups.1562 * When suspending by closing the LID, the power to the USB1563 * keyboard is turned off, causing INT0002 ACPI events to1564 * trigger once the XHCI controller notices the keyboard is1565 * gone. So INT0002 events cause spurious wakeups too. Ignoring1566 * EC wakes breaks wakeup when opening the lid, the user needs1567 * to press the power-button to wakeup the system. The1568 * alternative is suspend simply not working, which is worse.1569 */1570 .matches = {1571 DMI_MATCH(DMI_SYS_VENDOR, "HP"),1572 DMI_MATCH(DMI_PRODUCT_NAME, "HP x2 Detachable 10-p0XX"),1573 },1574 .driver_data = &(struct acpi_gpiolib_dmi_quirk) {1575 .ignore_wake = "INT33FF:01@0,INT0002:00@2",1576 },1577 },1578 {1579 /*1580 * HP X2 10 models with Bay Trail SoC + AXP288 PMIC use an1581 * external embedded-controller connected via I2C + an ACPI GPIO1582 * event handler on INT33FC:02 pin 28, causing spurious wakeups.1583 */1584 .matches = {1585 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),1586 DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"),1587 DMI_MATCH(DMI_BOARD_NAME, "815D"),1588 },1589 .driver_data = &(struct acpi_gpiolib_dmi_quirk) {1590 .ignore_wake = "INT33FC:02@28",1591 },1592 },1593 {1594 /*1595 * HP X2 10 models with Cherry Trail SoC + AXP288 PMIC use an1596 * external embedded-controller connected via I2C + an ACPI GPIO1597 * event handler on INT33FF:01 pin 0, causing spurious wakeups.1598 */1599 .matches = {1600 DMI_MATCH(DMI_SYS_VENDOR, "HP"),1601 DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"),1602 DMI_MATCH(DMI_BOARD_NAME, "813E"),1603 },1604 .driver_data = &(struct acpi_gpiolib_dmi_quirk) {1605 .ignore_wake = "INT33FF:01@0",1606 },1607 },1608 {1609 /*1610 * Interrupt storm caused from edge triggered floating pin1611 * Found in BIOS UX325UAZ.3001612 * https://bugzilla.kernel.org/show_bug.cgi?id=2162081613 */1614 .matches = {1615 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),1616 DMI_MATCH(DMI_PRODUCT_NAME, "ZenBook UX325UAZ_UM325UAZ"),1617 },1618 .driver_data = &(struct acpi_gpiolib_dmi_quirk) {1619 .ignore_interrupt = "AMDI0030:00@18",1620 },1621 },1622 {1623 /*1624 * Spurious wakeups from TP_ATTN# pin1625 * Found in BIOS 1.7.81626 * https://gitlab.freedesktop.org/drm/amd/-/issues/1722#note_17206271627 */1628 .matches = {1629 DMI_MATCH(DMI_BOARD_NAME, "NL5xNU"),1630 },1631 .driver_data = &(struct acpi_gpiolib_dmi_quirk) {1632 .ignore_wake = "ELAN0415:00@9",1633 },1634 },1635 {1636 /*1637 * Spurious wakeups from TP_ATTN# pin1638 * Found in BIOS 1.7.81639 * https://gitlab.freedesktop.org/drm/amd/-/issues/1722#note_17206271640 */1641 .matches = {1642 DMI_MATCH(DMI_BOARD_NAME, "NL5xRU"),1643 },1644 .driver_data = &(struct acpi_gpiolib_dmi_quirk) {1645 .ignore_wake = "ELAN0415:00@9",1646 },1647 },1648 {1649 /*1650 * Spurious wakeups from TP_ATTN# pin1651 * Found in BIOS 1.7.71652 */1653 .matches = {1654 DMI_MATCH(DMI_BOARD_NAME, "NH5xAx"),1655 },1656 .driver_data = &(struct acpi_gpiolib_dmi_quirk) {1657 .ignore_wake = "SYNA1202:00@16",1658 },1659 },1660 {1661 /*1662 * On the Peaq C1010 2-in-1 INT33FC:00 pin 3 is connected to1663 * a "dolby" button. At the ACPI level an _AEI event-handler1664 * is connected which sets an ACPI variable to 1 on both1665 * edges. This variable can be polled + cleared to 0 using1666 * WMI. But since the variable is set on both edges the WMI1667 * interface is pretty useless even when polling.1668 * So instead the x86-android-tablets code instantiates1669 * a gpio-keys platform device for it.1670 * Ignore the _AEI handler for the pin, so that it is not busy.1671 */1672 .matches = {1673 DMI_MATCH(DMI_SYS_VENDOR, "PEAQ"),1674 DMI_MATCH(DMI_PRODUCT_NAME, "PEAQ PMM C1010 MD99187"),1675 },1676 .driver_data = &(struct acpi_gpiolib_dmi_quirk) {1677 .ignore_interrupt = "INT33FC:00@3",1678 },1679 },1680 {1681 /*1682 * Spurious wakeups from TP_ATTN# pin1683 * Found in BIOS 0.351684 * https://gitlab.freedesktop.org/drm/amd/-/issues/30731685 */1686 .matches = {1687 DMI_MATCH(DMI_SYS_VENDOR, "GPD"),1688 DMI_MATCH(DMI_PRODUCT_NAME, "G1619-04"),1689 },1690 .driver_data = &(struct acpi_gpiolib_dmi_quirk) {1691 .ignore_wake = "PNP0C50:00@8",1692 },1693 },1694 {} /* Terminating entry */1695};1696 1697static int __init acpi_gpio_setup_params(void)1698{1699 const struct acpi_gpiolib_dmi_quirk *quirk = NULL;1700 const struct dmi_system_id *id;1701 1702 id = dmi_first_match(gpiolib_acpi_quirks);1703 if (id)1704 quirk = id->driver_data;1705 1706 if (run_edge_events_on_boot < 0) {1707 if (quirk && quirk->no_edge_events_on_boot)1708 run_edge_events_on_boot = 0;1709 else1710 run_edge_events_on_boot = 1;1711 }1712 1713 if (ignore_wake == NULL && quirk && quirk->ignore_wake)1714 ignore_wake = quirk->ignore_wake;1715 1716 if (ignore_interrupt == NULL && quirk && quirk->ignore_interrupt)1717 ignore_interrupt = quirk->ignore_interrupt;1718 1719 return 0;1720}1721 1722/* Directly after dmi_setup() which runs as core_initcall() */1723postcore_initcall(acpi_gpio_setup_params);1724