gpio / ACPI: Handle ACPI events in accordance with the spec

Commit 0d1c28a (gpiolib-acpi: Add ACPI5 event model support to gpio.)
that added support for ACPI events signalled through GPIO interrupts
covered only GPIO pins whose numbers are less than or equal to 255.
However, there may be GPIO pins with numbers greater than 255 and
the ACPI spec (ACPI 5.0, Section 5.6.5.1) requires the _EVT method
to be used for handling events corresponding to those pins.

Moreover, according to the spec, _EVT is the default mechanism
for handling all ACPI events signalled through GPIO interrupts,
so if the _Exx/_Lxx method is not present for the given pin,
_EVT should be used instead.  If present, though, _Exx/_Lxx take
precedence over _EVT which shouldn't be executed in that case
(ACPI 5.0, Section 5.6.5.3).

Modify acpi_gpiochip_request_interrupts() to follow the spec as
described above and add acpi_gpiochip_free_interrupts() needed
to free interrupts associated with _EVT.

Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>

1 files changed, 120 insertions, 20 deletions

diff --git a/drivers/gpio/gpiolib-acpi.c b/drivers/gpio/gpiolib-acpi.c
index a063eb04b6ce..89336c4f82cd 100644
--- a/drivers/gpio/gpiolib-acpi.c
+++ b/drivers/gpio/gpiolib-acpi.c
@@ -17,6 +17,13 @@
 #include <linux/acpi.h>
 #include <linux/interrupt.h>
 
+struct acpi_gpio_evt_pin {
+        struct list_head node;
+        acpi_handle *evt_handle;
+        unsigned int pin;
+        unsigned int irq;
+};
+
 static int acpi_gpiochip_find(struct gpio_chip *gc, void *data)
 {
         if (!gc->dev)
@@ -54,7 +61,6 @@ int acpi_get_gpio(char *path, int pin)
 }
 EXPORT_SYMBOL_GPL(acpi_get_gpio);
 
-
 static irqreturn_t acpi_gpio_irq_handler(int irq, void *data)
 {
         acpi_handle handle = data;
@@ -64,6 +70,27 @@ static irqreturn_t acpi_gpio_irq_handler(int irq, void *data)
         return IRQ_HANDLED;
 }
 
+static irqreturn_t acpi_gpio_irq_handler_evt(int irq, void *data)
+{
+        struct acpi_gpio_evt_pin *evt_pin = data;
+        struct acpi_object_list args;
+        union acpi_object arg;
+
+        arg.type = ACPI_TYPE_INTEGER;
+        arg.integer.value = evt_pin->pin;
+        args.count = 1;
+        args.pointer = &arg;
+
+        acpi_evaluate_object(evt_pin->evt_handle, NULL, &args, NULL);
+
+        return IRQ_HANDLED;
+}
+
+static void acpi_gpio_evt_dh(acpi_handle handle, void *data)
+{
+        /* The address of this function is used as a key. */
+}
+
 /**
  * acpi_gpiochip_request_interrupts() - Register isr for gpio chip ACPI events
  * @chip:      gpio chip
@@ -73,15 +100,13 @@ static irqreturn_t acpi_gpio_irq_handler(int irq, void *data)
  * chip's interrupt handler. acpi_gpiochip_request_interrupts finds out which
  * gpio pins have acpi event methods and assigns interrupt handlers that calls
  * the acpi event methods for those pins.
- *
- * Interrupts are automatically freed on driver detach
  */
-
 void acpi_gpiochip_request_interrupts(struct gpio_chip *chip)
 {
         struct acpi_buffer buf = {ACPI_ALLOCATE_BUFFER, NULL};
         struct acpi_resource *res;
-        acpi_handle handle, ev_handle;
+        acpi_handle handle, evt_handle;
+        struct list_head *evt_pins = NULL;
         acpi_status status;
         unsigned int pin;
         int irq, ret;
@@ -98,13 +123,30 @@ void acpi_gpiochip_request_interrupts(struct gpio_chip *chip)
         if (ACPI_FAILURE(status))
                 return;
 
-        /* If a gpio interrupt has an acpi event handler method, then
-         * set up an interrupt handler that calls the acpi event handler
-         */
+        status = acpi_get_handle(handle, "_EVT", &evt_handle);
+        if (ACPI_SUCCESS(status)) {
+                evt_pins = kzalloc(sizeof(*evt_pins), GFP_KERNEL);
+                if (evt_pins) {
+                        INIT_LIST_HEAD(evt_pins);
+                        status = acpi_attach_data(handle, acpi_gpio_evt_dh,
+                                                  evt_pins);
+                        if (ACPI_FAILURE(status)) {
+                                kfree(evt_pins);
+                                evt_pins = NULL;
+                        }
+                }
+        }
 
+        /*
+         * If a GPIO interrupt has an ACPI event handler method, or _EVT is
+         * present, set up an interrupt handler that calls the ACPI event
+         * handler.
+         */
         for (res = buf.pointer;
              res && (res->type != ACPI_RESOURCE_TYPE_END_TAG);
              res = ACPI_NEXT_RESOURCE(res)) {
+                irq_handler_t handler = NULL;
+                void *data;
 
                 if (res->type != ACPI_RESOURCE_TYPE_GPIO ||
                     res->data.gpio.connection_type !=
@@ -115,23 +157,42 @@ void acpi_gpiochip_request_interrupts(struct gpio_chip *chip)
                 if (pin > chip->ngpio)
                         continue;
 
-                sprintf(ev_name, "_%c%02X",
-                res->data.gpio.triggering ? 'E' : 'L', pin);
-
-                status = acpi_get_handle(handle, ev_name, &ev_handle);
-                if (ACPI_FAILURE(status))
-                        continue;
-
                 irq = chip->to_irq(chip, pin);
                 if (irq < 0)
                         continue;
 
+                if (pin <= 255) {
+                        acpi_handle ev_handle;
+
+                        sprintf(ev_name, "_%c%02X",
+                                res->data.gpio.triggering ? 'E' : 'L', pin);
+                        status = acpi_get_handle(handle, ev_name, &ev_handle);
+                        if (ACPI_SUCCESS(status)) {
+                                handler = acpi_gpio_irq_handler;
+                                data = ev_handle;
+                        }
+                }
+                if (!handler && evt_pins) {
+                        struct acpi_gpio_evt_pin *evt_pin;
+
+                        evt_pin = kzalloc(sizeof(*evt_pin), GFP_KERNEL);
+                        if (!evt_pin)
+                                continue;
+
+                        list_add_tail(&evt_pin->node, evt_pins);
+                        evt_pin->evt_handle = evt_handle;
+                        evt_pin->pin = pin;
+                        evt_pin->irq = irq;
+                        handler = acpi_gpio_irq_handler_evt;
+                        data = evt_pin;
+                }
+                if (!handler)
+                        continue;
+
                 /* Assume BIOS sets the triggering, so no flags */
-                ret = devm_request_threaded_irq(chip->dev, irq, NULL,
-                                          acpi_gpio_irq_handler,
-                                          0,
-                                          "GPIO-signaled-ACPI-event",
-                                          ev_handle);
+                ret = devm_request_threaded_irq(chip->dev, irq, NULL, handler,
+                                                0, "GPIO-signaled-ACPI-event",
+                                                data);
                 if (ret)
                         dev_err(chip->dev,
                                 "Failed to request IRQ %d ACPI event handler\n",
@@ -139,3 +200,42 @@ void acpi_gpiochip_request_interrupts(struct gpio_chip *chip)
         }
 }
 EXPORT_SYMBOL(acpi_gpiochip_request_interrupts);
+
+
+/**
+ * acpi_gpiochip_free_interrupts() - Free GPIO _EVT ACPI event interrupts.
+ * @chip:      gpio chip
+ *
+ * Free interrupts associated with the _EVT method for the given GPIO chip.
+ *
+ * The remaining ACPI event interrupts associated with the chip are freed
+ * automatically.
+ */
+void acpi_gpiochip_free_interrupts(struct gpio_chip *chip)
+{
+        acpi_handle handle;
+        acpi_status status;
+        struct list_head *evt_pins;
+        struct acpi_gpio_evt_pin *evt_pin, *ep;
+
+        if (!chip->dev || !chip->to_irq)
+                return;
+
+        handle = ACPI_HANDLE(chip->dev);
+        if (!handle)
+                return;
+
+        status = acpi_get_data(handle, acpi_gpio_evt_dh, (void **)&evt_pins);
+        if (ACPI_FAILURE(status))
+                return;
+
+        list_for_each_entry_safe_reverse(evt_pin, ep, evt_pins, node) {
+                devm_free_irq(chip->dev, evt_pin->irq, evt_pin);
+                list_del(&evt_pin->node);
+                kfree(evt_pin);
+        }
+
+        acpi_detach_data(handle, acpi_gpio_evt_dh);
+        kfree(evt_pins);
+}
+EXPORT_SYMBOL(acpi_gpiochip_free_interrupts);