Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * ACPI helpers for GPIO API
0004  *
0005  * Copyright (C) 2012, Intel Corporation
0006  * Authors: Mathias Nyman <mathias.nyman@linux.intel.com>
0007  *          Mika Westerberg <mika.westerberg@linux.intel.com>
0008  */
0009 
0010 #include <linux/dmi.h>
0011 #include <linux/errno.h>
0012 #include <linux/gpio/consumer.h>
0013 #include <linux/gpio/driver.h>
0014 #include <linux/gpio/machine.h>
0015 #include <linux/export.h>
0016 #include <linux/acpi.h>
0017 #include <linux/interrupt.h>
0018 #include <linux/mutex.h>
0019 #include <linux/pinctrl/pinctrl.h>
0020 
0021 #include "gpiolib.h"
0022 #include "gpiolib-acpi.h"
0023 
0024 static int run_edge_events_on_boot = -1;
0025 module_param(run_edge_events_on_boot, int, 0444);
0026 MODULE_PARM_DESC(run_edge_events_on_boot,
0027          "Run edge _AEI event-handlers at boot: 0=no, 1=yes, -1=auto");
0028 
0029 static char *ignore_wake;
0030 module_param(ignore_wake, charp, 0444);
0031 MODULE_PARM_DESC(ignore_wake,
0032          "controller@pin combos on which to ignore the ACPI wake flag "
0033          "ignore_wake=controller@pin[,controller@pin[,...]]");
0034 
0035 static char *ignore_interrupt;
0036 module_param(ignore_interrupt, charp, 0444);
0037 MODULE_PARM_DESC(ignore_interrupt,
0038          "controller@pin combos on which to ignore interrupt "
0039          "ignore_interrupt=controller@pin[,controller@pin[,...]]");
0040 
0041 struct acpi_gpiolib_dmi_quirk {
0042     bool no_edge_events_on_boot;
0043     char *ignore_wake;
0044     char *ignore_interrupt;
0045 };
0046 
0047 /**
0048  * struct acpi_gpio_event - ACPI GPIO event handler data
0049  *
0050  * @node:     list-entry of the events list of the struct acpi_gpio_chip
0051  * @handle:   handle of ACPI method to execute when the IRQ triggers
0052  * @handler:      handler function to pass to request_irq() when requesting the IRQ
0053  * @pin:      GPIO pin number on the struct gpio_chip
0054  * @irq:      Linux IRQ number for the event, for request_irq() / free_irq()
0055  * @irqflags:     flags to pass to request_irq() when requesting the IRQ
0056  * @irq_is_wake:  If the ACPI flags indicate the IRQ is a wakeup source
0057  * @irq_requested:True if request_irq() has been done
0058  * @desc:     struct gpio_desc for the GPIO pin for this event
0059  */
0060 struct acpi_gpio_event {
0061     struct list_head node;
0062     acpi_handle handle;
0063     irq_handler_t handler;
0064     unsigned int pin;
0065     unsigned int irq;
0066     unsigned long irqflags;
0067     bool irq_is_wake;
0068     bool irq_requested;
0069     struct gpio_desc *desc;
0070 };
0071 
0072 struct acpi_gpio_connection {
0073     struct list_head node;
0074     unsigned int pin;
0075     struct gpio_desc *desc;
0076 };
0077 
0078 struct acpi_gpio_chip {
0079     /*
0080      * ACPICA requires that the first field of the context parameter
0081      * passed to acpi_install_address_space_handler() is large enough
0082      * to hold struct acpi_connection_info.
0083      */
0084     struct acpi_connection_info conn_info;
0085     struct list_head conns;
0086     struct mutex conn_lock;
0087     struct gpio_chip *chip;
0088     struct list_head events;
0089     struct list_head deferred_req_irqs_list_entry;
0090 };
0091 
0092 /*
0093  * For GPIO chips which call acpi_gpiochip_request_interrupts() before late_init
0094  * (so builtin drivers) we register the ACPI GpioInt IRQ handlers from a
0095  * late_initcall_sync() handler, so that other builtin drivers can register their
0096  * OpRegions before the event handlers can run. This list contains GPIO chips
0097  * for which the acpi_gpiochip_request_irqs() call has been deferred.
0098  */
0099 static DEFINE_MUTEX(acpi_gpio_deferred_req_irqs_lock);
0100 static LIST_HEAD(acpi_gpio_deferred_req_irqs_list);
0101 static bool acpi_gpio_deferred_req_irqs_done;
0102 
0103 static int acpi_gpiochip_find(struct gpio_chip *gc, void *data)
0104 {
0105     return gc->parent && device_match_acpi_handle(gc->parent, data);
0106 }
0107 
0108 /**
0109  * acpi_get_gpiod() - Translate ACPI GPIO pin to GPIO descriptor usable with GPIO API
0110  * @path:   ACPI GPIO controller full path name, (e.g. "\\_SB.GPO1")
0111  * @pin:    ACPI GPIO pin number (0-based, controller-relative)
0112  *
0113  * Return: GPIO descriptor to use with Linux generic GPIO API, or ERR_PTR
0114  * error value. Specifically returns %-EPROBE_DEFER if the referenced GPIO
0115  * controller does not have GPIO chip registered at the moment. This is to
0116  * support probe deferral.
0117  */
0118 static struct gpio_desc *acpi_get_gpiod(char *path, unsigned int pin)
0119 {
0120     struct gpio_chip *chip;
0121     acpi_handle handle;
0122     acpi_status status;
0123 
0124     status = acpi_get_handle(NULL, path, &handle);
0125     if (ACPI_FAILURE(status))
0126         return ERR_PTR(-ENODEV);
0127 
0128     chip = gpiochip_find(handle, acpi_gpiochip_find);
0129     if (!chip)
0130         return ERR_PTR(-EPROBE_DEFER);
0131 
0132     return gpiochip_get_desc(chip, pin);
0133 }
0134 
0135 /**
0136  * acpi_get_and_request_gpiod - Translate ACPI GPIO pin to GPIO descriptor and
0137  *                              hold a refcount to the GPIO device.
0138  * @path:      ACPI GPIO controller full path name, (e.g. "\\_SB.GPO1")
0139  * @pin:       ACPI GPIO pin number (0-based, controller-relative)
0140  * @label:     Label to pass to gpiod_request()
0141  *
0142  * This function is a simple pass-through to acpi_get_gpiod(), except that
0143  * as it is intended for use outside of the GPIO layer (in a similar fashion to
0144  * gpiod_get_index() for example) it also holds a reference to the GPIO device.
0145  */
0146 struct gpio_desc *acpi_get_and_request_gpiod(char *path, unsigned int pin, char *label)
0147 {
0148     struct gpio_desc *gpio;
0149     int ret;
0150 
0151     gpio = acpi_get_gpiod(path, pin);
0152     if (IS_ERR(gpio))
0153         return gpio;
0154 
0155     ret = gpiod_request(gpio, label);
0156     if (ret)
0157         return ERR_PTR(ret);
0158 
0159     return gpio;
0160 }
0161 EXPORT_SYMBOL_GPL(acpi_get_and_request_gpiod);
0162 
0163 static irqreturn_t acpi_gpio_irq_handler(int irq, void *data)
0164 {
0165     struct acpi_gpio_event *event = data;
0166 
0167     acpi_evaluate_object(event->handle, NULL, NULL, NULL);
0168 
0169     return IRQ_HANDLED;
0170 }
0171 
0172 static irqreturn_t acpi_gpio_irq_handler_evt(int irq, void *data)
0173 {
0174     struct acpi_gpio_event *event = data;
0175 
0176     acpi_execute_simple_method(event->handle, NULL, event->pin);
0177 
0178     return IRQ_HANDLED;
0179 }
0180 
0181 static void acpi_gpio_chip_dh(acpi_handle handle, void *data)
0182 {
0183     /* The address of this function is used as a key. */
0184 }
0185 
0186 bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,
0187                 struct acpi_resource_gpio **agpio)
0188 {
0189     struct acpi_resource_gpio *gpio;
0190 
0191     if (ares->type != ACPI_RESOURCE_TYPE_GPIO)
0192         return false;
0193 
0194     gpio = &ares->data.gpio;
0195     if (gpio->connection_type != ACPI_RESOURCE_GPIO_TYPE_INT)
0196         return false;
0197 
0198     *agpio = gpio;
0199     return true;
0200 }
0201 EXPORT_SYMBOL_GPL(acpi_gpio_get_irq_resource);
0202 
0203 /**
0204  * acpi_gpio_get_io_resource - Fetch details of an ACPI resource if it is a GPIO
0205  *                 I/O resource or return False if not.
0206  * @ares:   Pointer to the ACPI resource to fetch
0207  * @agpio:  Pointer to a &struct acpi_resource_gpio to store the output pointer
0208  */
0209 bool acpi_gpio_get_io_resource(struct acpi_resource *ares,
0210                    struct acpi_resource_gpio **agpio)
0211 {
0212     struct acpi_resource_gpio *gpio;
0213 
0214     if (ares->type != ACPI_RESOURCE_TYPE_GPIO)
0215         return false;
0216 
0217     gpio = &ares->data.gpio;
0218     if (gpio->connection_type != ACPI_RESOURCE_GPIO_TYPE_IO)
0219         return false;
0220 
0221     *agpio = gpio;
0222     return true;
0223 }
0224 EXPORT_SYMBOL_GPL(acpi_gpio_get_io_resource);
0225 
0226 static void acpi_gpiochip_request_irq(struct acpi_gpio_chip *acpi_gpio,
0227                       struct acpi_gpio_event *event)
0228 {
0229     struct device *parent = acpi_gpio->chip->parent;
0230     int ret, value;
0231 
0232     ret = request_threaded_irq(event->irq, NULL, event->handler,
0233                    event->irqflags | IRQF_ONESHOT, "ACPI:Event", event);
0234     if (ret) {
0235         dev_err(parent, "Failed to setup interrupt handler for %d\n", event->irq);
0236         return;
0237     }
0238 
0239     if (event->irq_is_wake)
0240         enable_irq_wake(event->irq);
0241 
0242     event->irq_requested = true;
0243 
0244     /* Make sure we trigger the initial state of edge-triggered IRQs */
0245     if (run_edge_events_on_boot &&
0246         (event->irqflags & (IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING))) {
0247         value = gpiod_get_raw_value_cansleep(event->desc);
0248         if (((event->irqflags & IRQF_TRIGGER_RISING) && value == 1) ||
0249             ((event->irqflags & IRQF_TRIGGER_FALLING) && value == 0))
0250             event->handler(event->irq, event);
0251     }
0252 }
0253 
0254 static void acpi_gpiochip_request_irqs(struct acpi_gpio_chip *acpi_gpio)
0255 {
0256     struct acpi_gpio_event *event;
0257 
0258     list_for_each_entry(event, &acpi_gpio->events, node)
0259         acpi_gpiochip_request_irq(acpi_gpio, event);
0260 }
0261 
0262 static enum gpiod_flags
0263 acpi_gpio_to_gpiod_flags(const struct acpi_resource_gpio *agpio, int polarity)
0264 {
0265     /* GpioInt() implies input configuration */
0266     if (agpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT)
0267         return GPIOD_IN;
0268 
0269     switch (agpio->io_restriction) {
0270     case ACPI_IO_RESTRICT_INPUT:
0271         return GPIOD_IN;
0272     case ACPI_IO_RESTRICT_OUTPUT:
0273         /*
0274          * ACPI GPIO resources don't contain an initial value for the
0275          * GPIO. Therefore we deduce that value from the pull field
0276          * and the polarity instead. If the pin is pulled up we assume
0277          * default to be high, if it is pulled down we assume default
0278          * to be low, otherwise we leave pin untouched. For active low
0279          * polarity values will be switched. See also
0280          * Documentation/firmware-guide/acpi/gpio-properties.rst.
0281          */
0282         switch (agpio->pin_config) {
0283         case ACPI_PIN_CONFIG_PULLUP:
0284             return polarity == GPIO_ACTIVE_LOW ? GPIOD_OUT_LOW : GPIOD_OUT_HIGH;
0285         case ACPI_PIN_CONFIG_PULLDOWN:
0286             return polarity == GPIO_ACTIVE_LOW ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW;
0287         default:
0288             break;
0289         }
0290         break;
0291     default:
0292         break;
0293     }
0294 
0295     /*
0296      * Assume that the BIOS has configured the direction and pull
0297      * accordingly.
0298      */
0299     return GPIOD_ASIS;
0300 }
0301 
0302 static struct gpio_desc *acpi_request_own_gpiod(struct gpio_chip *chip,
0303                         struct acpi_resource_gpio *agpio,
0304                         unsigned int index,
0305                         const char *label)
0306 {
0307     int polarity = GPIO_ACTIVE_HIGH;
0308     enum gpiod_flags flags = acpi_gpio_to_gpiod_flags(agpio, polarity);
0309     unsigned int pin = agpio->pin_table[index];
0310     struct gpio_desc *desc;
0311     int ret;
0312 
0313     desc = gpiochip_request_own_desc(chip, pin, label, polarity, flags);
0314     if (IS_ERR(desc))
0315         return desc;
0316 
0317     /* ACPI uses hundredths of milliseconds units */
0318     ret = gpio_set_debounce_timeout(desc, agpio->debounce_timeout * 10);
0319     if (ret)
0320         dev_warn(chip->parent,
0321              "Failed to set debounce-timeout for pin 0x%04X, err %d\n",
0322              pin, ret);
0323 
0324     return desc;
0325 }
0326 
0327 static bool acpi_gpio_in_ignore_list(const char *ignore_list, const char *controller_in,
0328                      unsigned int pin_in)
0329 {
0330     const char *controller, *pin_str;
0331     unsigned int pin;
0332     char *endp;
0333     int len;
0334 
0335     controller = ignore_list;
0336     while (controller) {
0337         pin_str = strchr(controller, '@');
0338         if (!pin_str)
0339             goto err;
0340 
0341         len = pin_str - controller;
0342         if (len == strlen(controller_in) &&
0343             strncmp(controller, controller_in, len) == 0) {
0344             pin = simple_strtoul(pin_str + 1, &endp, 10);
0345             if (*endp != 0 && *endp != ',')
0346                 goto err;
0347 
0348             if (pin == pin_in)
0349                 return true;
0350         }
0351 
0352         controller = strchr(controller, ',');
0353         if (controller)
0354             controller++;
0355     }
0356 
0357     return false;
0358 err:
0359     pr_err_once("Error: Invalid value for gpiolib_acpi.ignore_...: %s\n", ignore_list);
0360     return false;
0361 }
0362 
0363 static bool acpi_gpio_irq_is_wake(struct device *parent,
0364                   struct acpi_resource_gpio *agpio)
0365 {
0366     unsigned int pin = agpio->pin_table[0];
0367 
0368     if (agpio->wake_capable != ACPI_WAKE_CAPABLE)
0369         return false;
0370 
0371     if (acpi_gpio_in_ignore_list(ignore_wake, dev_name(parent), pin)) {
0372         dev_info(parent, "Ignoring wakeup on pin %u\n", pin);
0373         return false;
0374     }
0375 
0376     return true;
0377 }
0378 
0379 /* Always returns AE_OK so that we keep looping over the resources */
0380 static acpi_status acpi_gpiochip_alloc_event(struct acpi_resource *ares,
0381                          void *context)
0382 {
0383     struct acpi_gpio_chip *acpi_gpio = context;
0384     struct gpio_chip *chip = acpi_gpio->chip;
0385     struct acpi_resource_gpio *agpio;
0386     acpi_handle handle, evt_handle;
0387     struct acpi_gpio_event *event;
0388     irq_handler_t handler = NULL;
0389     struct gpio_desc *desc;
0390     unsigned int pin;
0391     int ret, irq;
0392 
0393     if (!acpi_gpio_get_irq_resource(ares, &agpio))
0394         return AE_OK;
0395 
0396     handle = ACPI_HANDLE(chip->parent);
0397     pin = agpio->pin_table[0];
0398 
0399     if (pin <= 255) {
0400         char ev_name[8];
0401         sprintf(ev_name, "_%c%02X",
0402             agpio->triggering == ACPI_EDGE_SENSITIVE ? 'E' : 'L',
0403             pin);
0404         if (ACPI_SUCCESS(acpi_get_handle(handle, ev_name, &evt_handle)))
0405             handler = acpi_gpio_irq_handler;
0406     }
0407     if (!handler) {
0408         if (ACPI_SUCCESS(acpi_get_handle(handle, "_EVT", &evt_handle)))
0409             handler = acpi_gpio_irq_handler_evt;
0410     }
0411     if (!handler)
0412         return AE_OK;
0413 
0414     desc = acpi_request_own_gpiod(chip, agpio, 0, "ACPI:Event");
0415     if (IS_ERR(desc)) {
0416         dev_err(chip->parent,
0417             "Failed to request GPIO for pin 0x%04X, err %ld\n",
0418             pin, PTR_ERR(desc));
0419         return AE_OK;
0420     }
0421 
0422     ret = gpiochip_lock_as_irq(chip, pin);
0423     if (ret) {
0424         dev_err(chip->parent,
0425             "Failed to lock GPIO pin 0x%04X as interrupt, err %d\n",
0426             pin, ret);
0427         goto fail_free_desc;
0428     }
0429 
0430     irq = gpiod_to_irq(desc);
0431     if (irq < 0) {
0432         dev_err(chip->parent,
0433             "Failed to translate GPIO pin 0x%04X to IRQ, err %d\n",
0434             pin, irq);
0435         goto fail_unlock_irq;
0436     }
0437 
0438     if (acpi_gpio_in_ignore_list(ignore_interrupt, dev_name(chip->parent), pin)) {
0439         dev_info(chip->parent, "Ignoring interrupt on pin %u\n", pin);
0440         return AE_OK;
0441     }
0442 
0443     event = kzalloc(sizeof(*event), GFP_KERNEL);
0444     if (!event)
0445         goto fail_unlock_irq;
0446 
0447     event->irqflags = IRQF_ONESHOT;
0448     if (agpio->triggering == ACPI_LEVEL_SENSITIVE) {
0449         if (agpio->polarity == ACPI_ACTIVE_HIGH)
0450             event->irqflags |= IRQF_TRIGGER_HIGH;
0451         else
0452             event->irqflags |= IRQF_TRIGGER_LOW;
0453     } else {
0454         switch (agpio->polarity) {
0455         case ACPI_ACTIVE_HIGH:
0456             event->irqflags |= IRQF_TRIGGER_RISING;
0457             break;
0458         case ACPI_ACTIVE_LOW:
0459             event->irqflags |= IRQF_TRIGGER_FALLING;
0460             break;
0461         default:
0462             event->irqflags |= IRQF_TRIGGER_RISING |
0463                        IRQF_TRIGGER_FALLING;
0464             break;
0465         }
0466     }
0467 
0468     event->handle = evt_handle;
0469     event->handler = handler;
0470     event->irq = irq;
0471     event->irq_is_wake = acpi_gpio_irq_is_wake(chip->parent, agpio);
0472     event->pin = pin;
0473     event->desc = desc;
0474 
0475     list_add_tail(&event->node, &acpi_gpio->events);
0476 
0477     return AE_OK;
0478 
0479 fail_unlock_irq:
0480     gpiochip_unlock_as_irq(chip, pin);
0481 fail_free_desc:
0482     gpiochip_free_own_desc(desc);
0483 
0484     return AE_OK;
0485 }
0486 
0487 /**
0488  * acpi_gpiochip_request_interrupts() - Register isr for gpio chip ACPI events
0489  * @chip:      GPIO chip
0490  *
0491  * ACPI5 platforms can use GPIO signaled ACPI events. These GPIO interrupts are
0492  * handled by ACPI event methods which need to be called from the GPIO
0493  * chip's interrupt handler. acpi_gpiochip_request_interrupts() finds out which
0494  * GPIO pins have ACPI event methods and assigns interrupt handlers that calls
0495  * the ACPI event methods for those pins.
0496  */
0497 void acpi_gpiochip_request_interrupts(struct gpio_chip *chip)
0498 {
0499     struct acpi_gpio_chip *acpi_gpio;
0500     acpi_handle handle;
0501     acpi_status status;
0502     bool defer;
0503 
0504     if (!chip->parent || !chip->to_irq)
0505         return;
0506 
0507     handle = ACPI_HANDLE(chip->parent);
0508     if (!handle)
0509         return;
0510 
0511     status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);
0512     if (ACPI_FAILURE(status))
0513         return;
0514 
0515     acpi_walk_resources(handle, "_AEI",
0516                 acpi_gpiochip_alloc_event, acpi_gpio);
0517 
0518     mutex_lock(&acpi_gpio_deferred_req_irqs_lock);
0519     defer = !acpi_gpio_deferred_req_irqs_done;
0520     if (defer)
0521         list_add(&acpi_gpio->deferred_req_irqs_list_entry,
0522              &acpi_gpio_deferred_req_irqs_list);
0523     mutex_unlock(&acpi_gpio_deferred_req_irqs_lock);
0524 
0525     if (defer)
0526         return;
0527 
0528     acpi_gpiochip_request_irqs(acpi_gpio);
0529 }
0530 EXPORT_SYMBOL_GPL(acpi_gpiochip_request_interrupts);
0531 
0532 /**
0533  * acpi_gpiochip_free_interrupts() - Free GPIO ACPI event interrupts.
0534  * @chip:      GPIO chip
0535  *
0536  * Free interrupts associated with GPIO ACPI event method for the given
0537  * GPIO chip.
0538  */
0539 void acpi_gpiochip_free_interrupts(struct gpio_chip *chip)
0540 {
0541     struct acpi_gpio_chip *acpi_gpio;
0542     struct acpi_gpio_event *event, *ep;
0543     acpi_handle handle;
0544     acpi_status status;
0545 
0546     if (!chip->parent || !chip->to_irq)
0547         return;
0548 
0549     handle = ACPI_HANDLE(chip->parent);
0550     if (!handle)
0551         return;
0552 
0553     status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);
0554     if (ACPI_FAILURE(status))
0555         return;
0556 
0557     mutex_lock(&acpi_gpio_deferred_req_irqs_lock);
0558     if (!list_empty(&acpi_gpio->deferred_req_irqs_list_entry))
0559         list_del_init(&acpi_gpio->deferred_req_irqs_list_entry);
0560     mutex_unlock(&acpi_gpio_deferred_req_irqs_lock);
0561 
0562     list_for_each_entry_safe_reverse(event, ep, &acpi_gpio->events, node) {
0563         if (event->irq_requested) {
0564             if (event->irq_is_wake)
0565                 disable_irq_wake(event->irq);
0566 
0567             free_irq(event->irq, event);
0568         }
0569 
0570         gpiochip_unlock_as_irq(chip, event->pin);
0571         gpiochip_free_own_desc(event->desc);
0572         list_del(&event->node);
0573         kfree(event);
0574     }
0575 }
0576 EXPORT_SYMBOL_GPL(acpi_gpiochip_free_interrupts);
0577 
0578 int acpi_dev_add_driver_gpios(struct acpi_device *adev,
0579                   const struct acpi_gpio_mapping *gpios)
0580 {
0581     if (adev && gpios) {
0582         adev->driver_gpios = gpios;
0583         return 0;
0584     }
0585     return -EINVAL;
0586 }
0587 EXPORT_SYMBOL_GPL(acpi_dev_add_driver_gpios);
0588 
0589 void acpi_dev_remove_driver_gpios(struct acpi_device *adev)
0590 {
0591     if (adev)
0592         adev->driver_gpios = NULL;
0593 }
0594 EXPORT_SYMBOL_GPL(acpi_dev_remove_driver_gpios);
0595 
0596 static void acpi_dev_release_driver_gpios(void *adev)
0597 {
0598     acpi_dev_remove_driver_gpios(adev);
0599 }
0600 
0601 int devm_acpi_dev_add_driver_gpios(struct device *dev,
0602                    const struct acpi_gpio_mapping *gpios)
0603 {
0604     struct acpi_device *adev = ACPI_COMPANION(dev);
0605     int ret;
0606 
0607     ret = acpi_dev_add_driver_gpios(adev, gpios);
0608     if (ret)
0609         return ret;
0610 
0611     return devm_add_action_or_reset(dev, acpi_dev_release_driver_gpios, adev);
0612 }
0613 EXPORT_SYMBOL_GPL(devm_acpi_dev_add_driver_gpios);
0614 
0615 static bool acpi_get_driver_gpio_data(struct acpi_device *adev,
0616                       const char *name, int index,
0617                       struct fwnode_reference_args *args,
0618                       unsigned int *quirks)
0619 {
0620     const struct acpi_gpio_mapping *gm;
0621 
0622     if (!adev->driver_gpios)
0623         return false;
0624 
0625     for (gm = adev->driver_gpios; gm->name; gm++)
0626         if (!strcmp(name, gm->name) && gm->data && index < gm->size) {
0627             const struct acpi_gpio_params *par = gm->data + index;
0628 
0629             args->fwnode = acpi_fwnode_handle(adev);
0630             args->args[0] = par->crs_entry_index;
0631             args->args[1] = par->line_index;
0632             args->args[2] = par->active_low;
0633             args->nargs = 3;
0634 
0635             *quirks = gm->quirks;
0636             return true;
0637         }
0638 
0639     return false;
0640 }
0641 
0642 static int
0643 __acpi_gpio_update_gpiod_flags(enum gpiod_flags *flags, enum gpiod_flags update)
0644 {
0645     const enum gpiod_flags mask =
0646         GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT |
0647         GPIOD_FLAGS_BIT_DIR_VAL;
0648     int ret = 0;
0649 
0650     /*
0651      * Check if the BIOS has IoRestriction with explicitly set direction
0652      * and update @flags accordingly. Otherwise use whatever caller asked
0653      * for.
0654      */
0655     if (update & GPIOD_FLAGS_BIT_DIR_SET) {
0656         enum gpiod_flags diff = *flags ^ update;
0657 
0658         /*
0659          * Check if caller supplied incompatible GPIO initialization
0660          * flags.
0661          *
0662          * Return %-EINVAL to notify that firmware has different
0663          * settings and we are going to use them.
0664          */
0665         if (((*flags & GPIOD_FLAGS_BIT_DIR_SET) && (diff & GPIOD_FLAGS_BIT_DIR_OUT)) ||
0666             ((*flags & GPIOD_FLAGS_BIT_DIR_OUT) && (diff & GPIOD_FLAGS_BIT_DIR_VAL)))
0667             ret = -EINVAL;
0668         *flags = (*flags & ~mask) | (update & mask);
0669     }
0670     return ret;
0671 }
0672 
0673 int
0674 acpi_gpio_update_gpiod_flags(enum gpiod_flags *flags, struct acpi_gpio_info *info)
0675 {
0676     struct device *dev = &info->adev->dev;
0677     enum gpiod_flags old = *flags;
0678     int ret;
0679 
0680     ret = __acpi_gpio_update_gpiod_flags(&old, info->flags);
0681     if (info->quirks & ACPI_GPIO_QUIRK_NO_IO_RESTRICTION) {
0682         if (ret)
0683             dev_warn(dev, FW_BUG "GPIO not in correct mode, fixing\n");
0684     } else {
0685         if (ret)
0686             dev_dbg(dev, "Override GPIO initialization flags\n");
0687         *flags = old;
0688     }
0689 
0690     return ret;
0691 }
0692 
0693 int acpi_gpio_update_gpiod_lookup_flags(unsigned long *lookupflags,
0694                     struct acpi_gpio_info *info)
0695 {
0696     switch (info->pin_config) {
0697     case ACPI_PIN_CONFIG_PULLUP:
0698         *lookupflags |= GPIO_PULL_UP;
0699         break;
0700     case ACPI_PIN_CONFIG_PULLDOWN:
0701         *lookupflags |= GPIO_PULL_DOWN;
0702         break;
0703     case ACPI_PIN_CONFIG_NOPULL:
0704         *lookupflags |= GPIO_PULL_DISABLE;
0705         break;
0706     default:
0707         break;
0708     }
0709 
0710     if (info->polarity == GPIO_ACTIVE_LOW)
0711         *lookupflags |= GPIO_ACTIVE_LOW;
0712 
0713     return 0;
0714 }
0715 
0716 struct acpi_gpio_lookup {
0717     struct acpi_gpio_info info;
0718     int index;
0719     u16 pin_index;
0720     bool active_low;
0721     struct gpio_desc *desc;
0722     int n;
0723 };
0724 
0725 static int acpi_populate_gpio_lookup(struct acpi_resource *ares, void *data)
0726 {
0727     struct acpi_gpio_lookup *lookup = data;
0728 
0729     if (ares->type != ACPI_RESOURCE_TYPE_GPIO)
0730         return 1;
0731 
0732     if (!lookup->desc) {
0733         const struct acpi_resource_gpio *agpio = &ares->data.gpio;
0734         bool gpioint = agpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT;
0735         struct gpio_desc *desc;
0736         u16 pin_index;
0737 
0738         if (lookup->info.quirks & ACPI_GPIO_QUIRK_ONLY_GPIOIO && gpioint)
0739             lookup->index++;
0740 
0741         if (lookup->n++ != lookup->index)
0742             return 1;
0743 
0744         pin_index = lookup->pin_index;
0745         if (pin_index >= agpio->pin_table_length)
0746             return 1;
0747 
0748         if (lookup->info.quirks & ACPI_GPIO_QUIRK_ABSOLUTE_NUMBER)
0749             desc = gpio_to_desc(agpio->pin_table[pin_index]);
0750         else
0751             desc = acpi_get_gpiod(agpio->resource_source.string_ptr,
0752                           agpio->pin_table[pin_index]);
0753         lookup->desc = desc;
0754         lookup->info.pin_config = agpio->pin_config;
0755         lookup->info.debounce = agpio->debounce_timeout;
0756         lookup->info.gpioint = gpioint;
0757 
0758         /*
0759          * Polarity and triggering are only specified for GpioInt
0760          * resource.
0761          * Note: we expect here:
0762          * - ACPI_ACTIVE_LOW == GPIO_ACTIVE_LOW
0763          * - ACPI_ACTIVE_HIGH == GPIO_ACTIVE_HIGH
0764          */
0765         if (lookup->info.gpioint) {
0766             lookup->info.polarity = agpio->polarity;
0767             lookup->info.triggering = agpio->triggering;
0768         } else {
0769             lookup->info.polarity = lookup->active_low;
0770         }
0771 
0772         lookup->info.flags = acpi_gpio_to_gpiod_flags(agpio, lookup->info.polarity);
0773     }
0774 
0775     return 1;
0776 }
0777 
0778 static int acpi_gpio_resource_lookup(struct acpi_gpio_lookup *lookup,
0779                      struct acpi_gpio_info *info)
0780 {
0781     struct acpi_device *adev = lookup->info.adev;
0782     struct list_head res_list;
0783     int ret;
0784 
0785     INIT_LIST_HEAD(&res_list);
0786 
0787     ret = acpi_dev_get_resources(adev, &res_list,
0788                      acpi_populate_gpio_lookup,
0789                      lookup);
0790     if (ret < 0)
0791         return ret;
0792 
0793     acpi_dev_free_resource_list(&res_list);
0794 
0795     if (!lookup->desc)
0796         return -ENOENT;
0797 
0798     if (info)
0799         *info = lookup->info;
0800     return 0;
0801 }
0802 
0803 static int acpi_gpio_property_lookup(struct fwnode_handle *fwnode,
0804                      const char *propname, int index,
0805                      struct acpi_gpio_lookup *lookup)
0806 {
0807     struct fwnode_reference_args args;
0808     unsigned int quirks = 0;
0809     int ret;
0810 
0811     memset(&args, 0, sizeof(args));
0812     ret = __acpi_node_get_property_reference(fwnode, propname, index, 3,
0813                          &args);
0814     if (ret) {
0815         struct acpi_device *adev = to_acpi_device_node(fwnode);
0816 
0817         if (!adev)
0818             return ret;
0819 
0820         if (!acpi_get_driver_gpio_data(adev, propname, index, &args,
0821                            &quirks))
0822             return ret;
0823     }
0824     /*
0825      * The property was found and resolved, so need to lookup the GPIO based
0826      * on returned args.
0827      */
0828     if (!to_acpi_device_node(args.fwnode))
0829         return -EINVAL;
0830     if (args.nargs != 3)
0831         return -EPROTO;
0832 
0833     lookup->index = args.args[0];
0834     lookup->pin_index = args.args[1];
0835     lookup->active_low = !!args.args[2];
0836 
0837     lookup->info.adev = to_acpi_device_node(args.fwnode);
0838     lookup->info.quirks = quirks;
0839 
0840     return 0;
0841 }
0842 
0843 /**
0844  * acpi_get_gpiod_by_index() - get a GPIO descriptor from device resources
0845  * @adev: pointer to a ACPI device to get GPIO from
0846  * @propname: Property name of the GPIO (optional)
0847  * @index: index of GpioIo/GpioInt resource (starting from %0)
0848  * @info: info pointer to fill in (optional)
0849  *
0850  * Function goes through ACPI resources for @adev and based on @index looks
0851  * up a GpioIo/GpioInt resource, translates it to the Linux GPIO descriptor,
0852  * and returns it. @index matches GpioIo/GpioInt resources only so if there
0853  * are total %3 GPIO resources, the index goes from %0 to %2.
0854  *
0855  * If @propname is specified the GPIO is looked using device property. In
0856  * that case @index is used to select the GPIO entry in the property value
0857  * (in case of multiple).
0858  *
0859  * If the GPIO cannot be translated or there is an error, an ERR_PTR is
0860  * returned.
0861  *
0862  * Note: if the GPIO resource has multiple entries in the pin list, this
0863  * function only returns the first.
0864  */
0865 static struct gpio_desc *acpi_get_gpiod_by_index(struct acpi_device *adev,
0866                       const char *propname, int index,
0867                       struct acpi_gpio_info *info)
0868 {
0869     struct acpi_gpio_lookup lookup;
0870     int ret;
0871 
0872     if (!adev)
0873         return ERR_PTR(-ENODEV);
0874 
0875     memset(&lookup, 0, sizeof(lookup));
0876     lookup.index = index;
0877 
0878     if (propname) {
0879         dev_dbg(&adev->dev, "GPIO: looking up %s\n", propname);
0880 
0881         ret = acpi_gpio_property_lookup(acpi_fwnode_handle(adev),
0882                         propname, index, &lookup);
0883         if (ret)
0884             return ERR_PTR(ret);
0885 
0886         dev_dbg(&adev->dev, "GPIO: _DSD returned %s %d %u %u\n",
0887             dev_name(&lookup.info.adev->dev), lookup.index,
0888             lookup.pin_index, lookup.active_low);
0889     } else {
0890         dev_dbg(&adev->dev, "GPIO: looking up %d in _CRS\n", index);
0891         lookup.info.adev = adev;
0892     }
0893 
0894     ret = acpi_gpio_resource_lookup(&lookup, info);
0895     return ret ? ERR_PTR(ret) : lookup.desc;
0896 }
0897 
0898 static bool acpi_can_fallback_to_crs(struct acpi_device *adev,
0899                      const char *con_id)
0900 {
0901     /* Never allow fallback if the device has properties */
0902     if (acpi_dev_has_props(adev) || adev->driver_gpios)
0903         return false;
0904 
0905     return con_id == NULL;
0906 }
0907 
0908 struct gpio_desc *acpi_find_gpio(struct device *dev,
0909                  const char *con_id,
0910                  unsigned int idx,
0911                  enum gpiod_flags *dflags,
0912                  unsigned long *lookupflags)
0913 {
0914     struct acpi_device *adev = ACPI_COMPANION(dev);
0915     struct acpi_gpio_info info;
0916     struct gpio_desc *desc;
0917     char propname[32];
0918     int i;
0919 
0920     /* Try first from _DSD */
0921     for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
0922         if (con_id) {
0923             snprintf(propname, sizeof(propname), "%s-%s",
0924                  con_id, gpio_suffixes[i]);
0925         } else {
0926             snprintf(propname, sizeof(propname), "%s",
0927                  gpio_suffixes[i]);
0928         }
0929 
0930         desc = acpi_get_gpiod_by_index(adev, propname, idx, &info);
0931         if (!IS_ERR(desc))
0932             break;
0933         if (PTR_ERR(desc) == -EPROBE_DEFER)
0934             return ERR_CAST(desc);
0935     }
0936 
0937     /* Then from plain _CRS GPIOs */
0938     if (IS_ERR(desc)) {
0939         if (!acpi_can_fallback_to_crs(adev, con_id))
0940             return ERR_PTR(-ENOENT);
0941 
0942         desc = acpi_get_gpiod_by_index(adev, NULL, idx, &info);
0943         if (IS_ERR(desc))
0944             return desc;
0945     }
0946 
0947     if (info.gpioint &&
0948         (*dflags == GPIOD_OUT_LOW || *dflags == GPIOD_OUT_HIGH)) {
0949         dev_dbg(&adev->dev, "refusing GpioInt() entry when doing GPIOD_OUT_* lookup\n");
0950         return ERR_PTR(-ENOENT);
0951     }
0952 
0953     acpi_gpio_update_gpiod_flags(dflags, &info);
0954     acpi_gpio_update_gpiod_lookup_flags(lookupflags, &info);
0955     return desc;
0956 }
0957 
0958 /**
0959  * acpi_node_get_gpiod() - get a GPIO descriptor from ACPI resources
0960  * @fwnode: pointer to an ACPI firmware node to get the GPIO information from
0961  * @propname: Property name of the GPIO
0962  * @index: index of GpioIo/GpioInt resource (starting from %0)
0963  * @info: info pointer to fill in (optional)
0964  *
0965  * If @fwnode is an ACPI device object, call acpi_get_gpiod_by_index() for it.
0966  * Otherwise (i.e. it is a data-only non-device object), use the property-based
0967  * GPIO lookup to get to the GPIO resource with the relevant information and use
0968  * that to obtain the GPIO descriptor to return.
0969  *
0970  * If the GPIO cannot be translated or there is an error an ERR_PTR is
0971  * returned.
0972  */
0973 struct gpio_desc *acpi_node_get_gpiod(struct fwnode_handle *fwnode,
0974                       const char *propname, int index,
0975                       struct acpi_gpio_info *info)
0976 {
0977     struct acpi_gpio_lookup lookup;
0978     struct acpi_device *adev;
0979     int ret;
0980 
0981     adev = to_acpi_device_node(fwnode);
0982     if (adev)
0983         return acpi_get_gpiod_by_index(adev, propname, index, info);
0984 
0985     if (!is_acpi_data_node(fwnode))
0986         return ERR_PTR(-ENODEV);
0987 
0988     if (!propname)
0989         return ERR_PTR(-EINVAL);
0990 
0991     memset(&lookup, 0, sizeof(lookup));
0992     lookup.index = index;
0993 
0994     ret = acpi_gpio_property_lookup(fwnode, propname, index, &lookup);
0995     if (ret)
0996         return ERR_PTR(ret);
0997 
0998     ret = acpi_gpio_resource_lookup(&lookup, info);
0999     return ret ? ERR_PTR(ret) : lookup.desc;
1000 }
1001 
1002 /**
1003  * acpi_dev_gpio_irq_get_by() - Find GpioInt and translate it to Linux IRQ number
1004  * @adev: pointer to a ACPI device to get IRQ from
1005  * @name: optional name of GpioInt resource
1006  * @index: index of GpioInt resource (starting from %0)
1007  *
1008  * If the device has one or more GpioInt resources, this function can be
1009  * used to translate from the GPIO offset in the resource to the Linux IRQ
1010  * number.
1011  *
1012  * The function is idempotent, though each time it runs it will configure GPIO
1013  * pin direction according to the flags in GpioInt resource.
1014  *
1015  * The function takes optional @name parameter. If the resource has a property
1016  * name, then only those will be taken into account.
1017  *
1018  * Return: Linux IRQ number (> %0) on success, negative errno on failure.
1019  */
1020 int acpi_dev_gpio_irq_get_by(struct acpi_device *adev, const char *name, int index)
1021 {
1022     int idx, i;
1023     unsigned int irq_flags;
1024     int ret;
1025 
1026     for (i = 0, idx = 0; idx <= index; i++) {
1027         struct acpi_gpio_info info;
1028         struct gpio_desc *desc;
1029 
1030         desc = acpi_get_gpiod_by_index(adev, name, i, &info);
1031 
1032         /* Ignore -EPROBE_DEFER, it only matters if idx matches */
1033         if (IS_ERR(desc) && PTR_ERR(desc) != -EPROBE_DEFER)
1034             return PTR_ERR(desc);
1035 
1036         if (info.gpioint && idx++ == index) {
1037             unsigned long lflags = GPIO_LOOKUP_FLAGS_DEFAULT;
1038             enum gpiod_flags dflags = GPIOD_ASIS;
1039             char label[32];
1040             int irq;
1041 
1042             if (IS_ERR(desc))
1043                 return PTR_ERR(desc);
1044 
1045             irq = gpiod_to_irq(desc);
1046             if (irq < 0)
1047                 return irq;
1048 
1049             acpi_gpio_update_gpiod_flags(&dflags, &info);
1050             acpi_gpio_update_gpiod_lookup_flags(&lflags, &info);
1051 
1052             snprintf(label, sizeof(label), "GpioInt() %d", index);
1053             ret = gpiod_configure_flags(desc, label, lflags, dflags);
1054             if (ret < 0)
1055                 return ret;
1056 
1057             /* ACPI uses hundredths of milliseconds units */
1058             ret = gpio_set_debounce_timeout(desc, info.debounce * 10);
1059             if (ret)
1060                 return ret;
1061 
1062             irq_flags = acpi_dev_get_irq_type(info.triggering,
1063                               info.polarity);
1064 
1065             /*
1066              * If the IRQ is not already in use then set type
1067              * if specified and different than the current one.
1068              */
1069             if (can_request_irq(irq, irq_flags)) {
1070                 if (irq_flags != IRQ_TYPE_NONE &&
1071                     irq_flags != irq_get_trigger_type(irq))
1072                     irq_set_irq_type(irq, irq_flags);
1073             } else {
1074                 dev_dbg(&adev->dev, "IRQ %d already in use\n", irq);
1075             }
1076 
1077             return irq;
1078         }
1079 
1080     }
1081     return -ENOENT;
1082 }
1083 EXPORT_SYMBOL_GPL(acpi_dev_gpio_irq_get_by);
1084 
1085 static acpi_status
1086 acpi_gpio_adr_space_handler(u32 function, acpi_physical_address address,
1087                 u32 bits, u64 *value, void *handler_context,
1088                 void *region_context)
1089 {
1090     struct acpi_gpio_chip *achip = region_context;
1091     struct gpio_chip *chip = achip->chip;
1092     struct acpi_resource_gpio *agpio;
1093     struct acpi_resource *ares;
1094     u16 pin_index = address;
1095     acpi_status status;
1096     int length;
1097     int i;
1098 
1099     status = acpi_buffer_to_resource(achip->conn_info.connection,
1100                      achip->conn_info.length, &ares);
1101     if (ACPI_FAILURE(status))
1102         return status;
1103 
1104     if (WARN_ON(ares->type != ACPI_RESOURCE_TYPE_GPIO)) {
1105         ACPI_FREE(ares);
1106         return AE_BAD_PARAMETER;
1107     }
1108 
1109     agpio = &ares->data.gpio;
1110 
1111     if (WARN_ON(agpio->io_restriction == ACPI_IO_RESTRICT_INPUT &&
1112         function == ACPI_WRITE)) {
1113         ACPI_FREE(ares);
1114         return AE_BAD_PARAMETER;
1115     }
1116 
1117     length = min_t(u16, agpio->pin_table_length, pin_index + bits);
1118     for (i = pin_index; i < length; ++i) {
1119         unsigned int pin = agpio->pin_table[i];
1120         struct acpi_gpio_connection *conn;
1121         struct gpio_desc *desc;
1122         bool found;
1123 
1124         mutex_lock(&achip->conn_lock);
1125 
1126         found = false;
1127         list_for_each_entry(conn, &achip->conns, node) {
1128             if (conn->pin == pin) {
1129                 found = true;
1130                 desc = conn->desc;
1131                 break;
1132             }
1133         }
1134 
1135         /*
1136          * The same GPIO can be shared between operation region and
1137          * event but only if the access here is ACPI_READ. In that
1138          * case we "borrow" the event GPIO instead.
1139          */
1140         if (!found && agpio->shareable == ACPI_SHARED &&
1141              function == ACPI_READ) {
1142             struct acpi_gpio_event *event;
1143 
1144             list_for_each_entry(event, &achip->events, node) {
1145                 if (event->pin == pin) {
1146                     desc = event->desc;
1147                     found = true;
1148                     break;
1149                 }
1150             }
1151         }
1152 
1153         if (!found) {
1154             desc = acpi_request_own_gpiod(chip, agpio, i, "ACPI:OpRegion");
1155             if (IS_ERR(desc)) {
1156                 mutex_unlock(&achip->conn_lock);
1157                 status = AE_ERROR;
1158                 goto out;
1159             }
1160 
1161             conn = kzalloc(sizeof(*conn), GFP_KERNEL);
1162             if (!conn) {
1163                 gpiochip_free_own_desc(desc);
1164                 mutex_unlock(&achip->conn_lock);
1165                 status = AE_NO_MEMORY;
1166                 goto out;
1167             }
1168 
1169             conn->pin = pin;
1170             conn->desc = desc;
1171             list_add_tail(&conn->node, &achip->conns);
1172         }
1173 
1174         mutex_unlock(&achip->conn_lock);
1175 
1176         if (function == ACPI_WRITE)
1177             gpiod_set_raw_value_cansleep(desc, !!(*value & BIT(i)));
1178         else
1179             *value |= (u64)gpiod_get_raw_value_cansleep(desc) << i;
1180     }
1181 
1182 out:
1183     ACPI_FREE(ares);
1184     return status;
1185 }
1186 
1187 static void acpi_gpiochip_request_regions(struct acpi_gpio_chip *achip)
1188 {
1189     struct gpio_chip *chip = achip->chip;
1190     acpi_handle handle = ACPI_HANDLE(chip->parent);
1191     acpi_status status;
1192 
1193     INIT_LIST_HEAD(&achip->conns);
1194     mutex_init(&achip->conn_lock);
1195     status = acpi_install_address_space_handler(handle, ACPI_ADR_SPACE_GPIO,
1196                             acpi_gpio_adr_space_handler,
1197                             NULL, achip);
1198     if (ACPI_FAILURE(status))
1199         dev_err(chip->parent,
1200                 "Failed to install GPIO OpRegion handler\n");
1201 }
1202 
1203 static void acpi_gpiochip_free_regions(struct acpi_gpio_chip *achip)
1204 {
1205     struct gpio_chip *chip = achip->chip;
1206     acpi_handle handle = ACPI_HANDLE(chip->parent);
1207     struct acpi_gpio_connection *conn, *tmp;
1208     acpi_status status;
1209 
1210     status = acpi_remove_address_space_handler(handle, ACPI_ADR_SPACE_GPIO,
1211                            acpi_gpio_adr_space_handler);
1212     if (ACPI_FAILURE(status)) {
1213         dev_err(chip->parent,
1214             "Failed to remove GPIO OpRegion handler\n");
1215         return;
1216     }
1217 
1218     list_for_each_entry_safe_reverse(conn, tmp, &achip->conns, node) {
1219         gpiochip_free_own_desc(conn->desc);
1220         list_del(&conn->node);
1221         kfree(conn);
1222     }
1223 }
1224 
1225 static struct gpio_desc *
1226 acpi_gpiochip_parse_own_gpio(struct acpi_gpio_chip *achip,
1227                  struct fwnode_handle *fwnode,
1228                  const char **name,
1229                  unsigned long *lflags,
1230                  enum gpiod_flags *dflags)
1231 {
1232     struct gpio_chip *chip = achip->chip;
1233     struct gpio_desc *desc;
1234     u32 gpios[2];
1235     int ret;
1236 
1237     *lflags = GPIO_LOOKUP_FLAGS_DEFAULT;
1238     *dflags = GPIOD_ASIS;
1239     *name = NULL;
1240 
1241     ret = fwnode_property_read_u32_array(fwnode, "gpios", gpios,
1242                          ARRAY_SIZE(gpios));
1243     if (ret < 0)
1244         return ERR_PTR(ret);
1245 
1246     desc = gpiochip_get_desc(chip, gpios[0]);
1247     if (IS_ERR(desc))
1248         return desc;
1249 
1250     if (gpios[1])
1251         *lflags |= GPIO_ACTIVE_LOW;
1252 
1253     if (fwnode_property_present(fwnode, "input"))
1254         *dflags |= GPIOD_IN;
1255     else if (fwnode_property_present(fwnode, "output-low"))
1256         *dflags |= GPIOD_OUT_LOW;
1257     else if (fwnode_property_present(fwnode, "output-high"))
1258         *dflags |= GPIOD_OUT_HIGH;
1259     else
1260         return ERR_PTR(-EINVAL);
1261 
1262     fwnode_property_read_string(fwnode, "line-name", name);
1263 
1264     return desc;
1265 }
1266 
1267 static void acpi_gpiochip_scan_gpios(struct acpi_gpio_chip *achip)
1268 {
1269     struct gpio_chip *chip = achip->chip;
1270     struct fwnode_handle *fwnode;
1271 
1272     device_for_each_child_node(chip->parent, fwnode) {
1273         unsigned long lflags;
1274         enum gpiod_flags dflags;
1275         struct gpio_desc *desc;
1276         const char *name;
1277         int ret;
1278 
1279         if (!fwnode_property_present(fwnode, "gpio-hog"))
1280             continue;
1281 
1282         desc = acpi_gpiochip_parse_own_gpio(achip, fwnode, &name,
1283                             &lflags, &dflags);
1284         if (IS_ERR(desc))
1285             continue;
1286 
1287         ret = gpiod_hog(desc, name, lflags, dflags);
1288         if (ret) {
1289             dev_err(chip->parent, "Failed to hog GPIO\n");
1290             fwnode_handle_put(fwnode);
1291             return;
1292         }
1293     }
1294 }
1295 
1296 void acpi_gpiochip_add(struct gpio_chip *chip)
1297 {
1298     struct acpi_gpio_chip *acpi_gpio;
1299     struct acpi_device *adev;
1300     acpi_status status;
1301 
1302     if (!chip || !chip->parent)
1303         return;
1304 
1305     adev = ACPI_COMPANION(chip->parent);
1306     if (!adev)
1307         return;
1308 
1309     acpi_gpio = kzalloc(sizeof(*acpi_gpio), GFP_KERNEL);
1310     if (!acpi_gpio) {
1311         dev_err(chip->parent,
1312             "Failed to allocate memory for ACPI GPIO chip\n");
1313         return;
1314     }
1315 
1316     acpi_gpio->chip = chip;
1317     INIT_LIST_HEAD(&acpi_gpio->events);
1318     INIT_LIST_HEAD(&acpi_gpio->deferred_req_irqs_list_entry);
1319 
1320     status = acpi_attach_data(adev->handle, acpi_gpio_chip_dh, acpi_gpio);
1321     if (ACPI_FAILURE(status)) {
1322         dev_err(chip->parent, "Failed to attach ACPI GPIO chip\n");
1323         kfree(acpi_gpio);
1324         return;
1325     }
1326 
1327     acpi_gpiochip_request_regions(acpi_gpio);
1328     acpi_gpiochip_scan_gpios(acpi_gpio);
1329     acpi_dev_clear_dependencies(adev);
1330 }
1331 
1332 void acpi_gpiochip_remove(struct gpio_chip *chip)
1333 {
1334     struct acpi_gpio_chip *acpi_gpio;
1335     acpi_handle handle;
1336     acpi_status status;
1337 
1338     if (!chip || !chip->parent)
1339         return;
1340 
1341     handle = ACPI_HANDLE(chip->parent);
1342     if (!handle)
1343         return;
1344 
1345     status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);
1346     if (ACPI_FAILURE(status)) {
1347         dev_warn(chip->parent, "Failed to retrieve ACPI GPIO chip\n");
1348         return;
1349     }
1350 
1351     acpi_gpiochip_free_regions(acpi_gpio);
1352 
1353     acpi_detach_data(handle, acpi_gpio_chip_dh);
1354     kfree(acpi_gpio);
1355 }
1356 
1357 void acpi_gpio_dev_init(struct gpio_chip *gc, struct gpio_device *gdev)
1358 {
1359     /* Set default fwnode to parent's one if present */
1360     if (gc->parent)
1361         ACPI_COMPANION_SET(&gdev->dev, ACPI_COMPANION(gc->parent));
1362 
1363     if (gc->fwnode)
1364         device_set_node(&gdev->dev, gc->fwnode);
1365 }
1366 
1367 static int acpi_gpio_package_count(const union acpi_object *obj)
1368 {
1369     const union acpi_object *element = obj->package.elements;
1370     const union acpi_object *end = element + obj->package.count;
1371     unsigned int count = 0;
1372 
1373     while (element < end) {
1374         switch (element->type) {
1375         case ACPI_TYPE_LOCAL_REFERENCE:
1376             element += 3;
1377             fallthrough;
1378         case ACPI_TYPE_INTEGER:
1379             element++;
1380             count++;
1381             break;
1382 
1383         default:
1384             return -EPROTO;
1385         }
1386     }
1387 
1388     return count;
1389 }
1390 
1391 static int acpi_find_gpio_count(struct acpi_resource *ares, void *data)
1392 {
1393     unsigned int *count = data;
1394 
1395     if (ares->type == ACPI_RESOURCE_TYPE_GPIO)
1396         *count += ares->data.gpio.pin_table_length;
1397 
1398     return 1;
1399 }
1400 
1401 /**
1402  * acpi_gpio_count - count the GPIOs associated with a device / function
1403  * @dev:    GPIO consumer, can be %NULL for system-global GPIOs
1404  * @con_id: function within the GPIO consumer
1405  *
1406  * Return:
1407  * The number of GPIOs associated with a device / function or %-ENOENT,
1408  * if no GPIO has been assigned to the requested function.
1409  */
1410 int acpi_gpio_count(struct device *dev, const char *con_id)
1411 {
1412     struct acpi_device *adev = ACPI_COMPANION(dev);
1413     const union acpi_object *obj;
1414     const struct acpi_gpio_mapping *gm;
1415     int count = -ENOENT;
1416     int ret;
1417     char propname[32];
1418     unsigned int i;
1419 
1420     /* Try first from _DSD */
1421     for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
1422         if (con_id)
1423             snprintf(propname, sizeof(propname), "%s-%s",
1424                  con_id, gpio_suffixes[i]);
1425         else
1426             snprintf(propname, sizeof(propname), "%s",
1427                  gpio_suffixes[i]);
1428 
1429         ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_ANY,
1430                         &obj);
1431         if (ret == 0) {
1432             if (obj->type == ACPI_TYPE_LOCAL_REFERENCE)
1433                 count = 1;
1434             else if (obj->type == ACPI_TYPE_PACKAGE)
1435                 count = acpi_gpio_package_count(obj);
1436         } else if (adev->driver_gpios) {
1437             for (gm = adev->driver_gpios; gm->name; gm++)
1438                 if (strcmp(propname, gm->name) == 0) {
1439                     count = gm->size;
1440                     break;
1441                 }
1442         }
1443         if (count > 0)
1444             break;
1445     }
1446 
1447     /* Then from plain _CRS GPIOs */
1448     if (count < 0) {
1449         struct list_head resource_list;
1450         unsigned int crs_count = 0;
1451 
1452         if (!acpi_can_fallback_to_crs(adev, con_id))
1453             return count;
1454 
1455         INIT_LIST_HEAD(&resource_list);
1456         acpi_dev_get_resources(adev, &resource_list,
1457                        acpi_find_gpio_count, &crs_count);
1458         acpi_dev_free_resource_list(&resource_list);
1459         if (crs_count > 0)
1460             count = crs_count;
1461     }
1462     return count ? count : -ENOENT;
1463 }
1464 
1465 /* Run deferred acpi_gpiochip_request_irqs() */
1466 static int __init acpi_gpio_handle_deferred_request_irqs(void)
1467 {
1468     struct acpi_gpio_chip *acpi_gpio, *tmp;
1469 
1470     mutex_lock(&acpi_gpio_deferred_req_irqs_lock);
1471     list_for_each_entry_safe(acpi_gpio, tmp,
1472                  &acpi_gpio_deferred_req_irqs_list,
1473                  deferred_req_irqs_list_entry)
1474         acpi_gpiochip_request_irqs(acpi_gpio);
1475 
1476     acpi_gpio_deferred_req_irqs_done = true;
1477     mutex_unlock(&acpi_gpio_deferred_req_irqs_lock);
1478 
1479     return 0;
1480 }
1481 /* We must use _sync so that this runs after the first deferred_probe run */
1482 late_initcall_sync(acpi_gpio_handle_deferred_request_irqs);
1483 
1484 static const struct dmi_system_id gpiolib_acpi_quirks[] __initconst = {
1485     {
1486         /*
1487          * The Minix Neo Z83-4 has a micro-USB-B id-pin handler for
1488          * a non existing micro-USB-B connector which puts the HDMI
1489          * DDC pins in GPIO mode, breaking HDMI support.
1490          */
1491         .matches = {
1492             DMI_MATCH(DMI_SYS_VENDOR, "MINIX"),
1493             DMI_MATCH(DMI_PRODUCT_NAME, "Z83-4"),
1494         },
1495         .driver_data = &(struct acpi_gpiolib_dmi_quirk) {
1496             .no_edge_events_on_boot = true,
1497         },
1498     },
1499     {
1500         /*
1501          * The Terra Pad 1061 has a micro-USB-B id-pin handler, which
1502          * instead of controlling the actual micro-USB-B turns the 5V
1503          * boost for its USB-A connector off. The actual micro-USB-B
1504          * connector is wired for charging only.
1505          */
1506         .matches = {
1507             DMI_MATCH(DMI_SYS_VENDOR, "Wortmann_AG"),
1508             DMI_MATCH(DMI_PRODUCT_NAME, "TERRA_PAD_1061"),
1509         },
1510         .driver_data = &(struct acpi_gpiolib_dmi_quirk) {
1511             .no_edge_events_on_boot = true,
1512         },
1513     },
1514     {
1515         /*
1516          * The Dell Venue 10 Pro 5055, with Bay Trail SoC + TI PMIC uses an
1517          * external embedded-controller connected via I2C + an ACPI GPIO
1518          * event handler on INT33FFC:02 pin 12, causing spurious wakeups.
1519          */
1520         .matches = {
1521             DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
1522             DMI_MATCH(DMI_PRODUCT_NAME, "Venue 10 Pro 5055"),
1523         },
1524         .driver_data = &(struct acpi_gpiolib_dmi_quirk) {
1525             .ignore_wake = "INT33FC:02@12",
1526         },
1527     },
1528     {
1529         /*
1530          * HP X2 10 models with Cherry Trail SoC + TI PMIC use an
1531          * external embedded-controller connected via I2C + an ACPI GPIO
1532          * event handler on INT33FF:01 pin 0, causing spurious wakeups.
1533          * When suspending by closing the LID, the power to the USB
1534          * keyboard is turned off, causing INT0002 ACPI events to
1535          * trigger once the XHCI controller notices the keyboard is
1536          * gone. So INT0002 events cause spurious wakeups too. Ignoring
1537          * EC wakes breaks wakeup when opening the lid, the user needs
1538          * to press the power-button to wakeup the system. The
1539          * alternative is suspend simply not working, which is worse.
1540          */
1541         .matches = {
1542             DMI_MATCH(DMI_SYS_VENDOR, "HP"),
1543             DMI_MATCH(DMI_PRODUCT_NAME, "HP x2 Detachable 10-p0XX"),
1544         },
1545         .driver_data = &(struct acpi_gpiolib_dmi_quirk) {
1546             .ignore_wake = "INT33FF:01@0,INT0002:00@2",
1547         },
1548     },
1549     {
1550         /*
1551          * HP X2 10 models with Bay Trail SoC + AXP288 PMIC use an
1552          * external embedded-controller connected via I2C + an ACPI GPIO
1553          * event handler on INT33FC:02 pin 28, causing spurious wakeups.
1554          */
1555         .matches = {
1556             DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1557             DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"),
1558             DMI_MATCH(DMI_BOARD_NAME, "815D"),
1559         },
1560         .driver_data = &(struct acpi_gpiolib_dmi_quirk) {
1561             .ignore_wake = "INT33FC:02@28",
1562         },
1563     },
1564     {
1565         /*
1566          * HP X2 10 models with Cherry Trail SoC + AXP288 PMIC use an
1567          * external embedded-controller connected via I2C + an ACPI GPIO
1568          * event handler on INT33FF:01 pin 0, causing spurious wakeups.
1569          */
1570         .matches = {
1571             DMI_MATCH(DMI_SYS_VENDOR, "HP"),
1572             DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"),
1573             DMI_MATCH(DMI_BOARD_NAME, "813E"),
1574         },
1575         .driver_data = &(struct acpi_gpiolib_dmi_quirk) {
1576             .ignore_wake = "INT33FF:01@0",
1577         },
1578     },
1579     {
1580         /*
1581          * Interrupt storm caused from edge triggered floating pin
1582          * Found in BIOS UX325UAZ.300
1583          * https://bugzilla.kernel.org/show_bug.cgi?id=216208
1584          */
1585         .matches = {
1586             DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1587             DMI_MATCH(DMI_PRODUCT_NAME, "ZenBook UX325UAZ_UM325UAZ"),
1588         },
1589         .driver_data = &(struct acpi_gpiolib_dmi_quirk) {
1590             .ignore_interrupt = "AMDI0030:00@18",
1591         },
1592     },
1593     {} /* Terminating entry */
1594 };
1595 
1596 static int __init acpi_gpio_setup_params(void)
1597 {
1598     const struct acpi_gpiolib_dmi_quirk *quirk = NULL;
1599     const struct dmi_system_id *id;
1600 
1601     id = dmi_first_match(gpiolib_acpi_quirks);
1602     if (id)
1603         quirk = id->driver_data;
1604 
1605     if (run_edge_events_on_boot < 0) {
1606         if (quirk && quirk->no_edge_events_on_boot)
1607             run_edge_events_on_boot = 0;
1608         else
1609             run_edge_events_on_boot = 1;
1610     }
1611 
1612     if (ignore_wake == NULL && quirk && quirk->ignore_wake)
1613         ignore_wake = quirk->ignore_wake;
1614 
1615     if (ignore_interrupt == NULL && quirk && quirk->ignore_interrupt)
1616         ignore_interrupt = quirk->ignore_interrupt;
1617 
1618     return 0;
1619 }
1620 
1621 /* Directly after dmi_setup() which runs as core_initcall() */
1622 postcore_initcall(acpi_gpio_setup_params);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!