Commit 6072b9dc authored by Mika Westerberg's avatar Mika Westerberg Committed by Linus Walleij
Browse files

gpio / ACPI: Rework ACPI GPIO event handling 



The current ACPI GPIO event handling code was never tested against real
hardware with functioning GPIO triggered events (at the time such hardware
wasn't available). Thus it misses certain things like requesting the GPIOs
properly, passing correct flags to the interrupt handler and so on.

This patch reworks ACPI GPIO event handling so that we:

 1) Use struct acpi_gpio_event for all GPIO signaled events.
 2) Switch to use GPIO descriptor API and request GPIOs by calling
    gpiochip_request_own_desc() that we added in a previous patch.
 3) Pass proper flags from ACPI GPIO resource to request_threaded_irq().

Also instead of open-coding the _AEI iteration loop we can use
acpi_walk_resources(). This simplifies the code a bit and fixes memory leak
that was caused by missing kfree() for buffer returned by
acpi_get_event_resources().

Since the remove path now calls gpiochip_free_own_desc() which takes GPIO
spinlock we need to call acpi_gpiochip_remove() outside of that lock
(analogous to acpi_gpiochip_add() path where the lock is released before
those funtions are called).

Signed-off-by: default avatarMika Westerberg <mika.westerberg@linux.intel.com>
Reviewed-by: default avatarRafael J. Wysocki <rafael.j.wysocki@intel.com>
Signed-off-by: default avatarLinus Walleij <linus.walleij@linaro.org>
parent 4b01a14b

drivers/gpio/gpiolib-acpi.c

+129 −85
Original line number Original line Diff line number Diff line
@@ -70,9 +70,9 @@ static struct gpio_desc *acpi_get_gpiod(char *path, int pin) 




static irqreturn_t acpi_gpio_irq_handler(int irq, void *data)

static irqreturn_t acpi_gpio_irq_handler(int irq, void *data)

{

{

	acpi_handle handle = data;

	struct acpi_gpio_event *event = data;





	acpi_evaluate_object(handle, NULL, NULL, NULL);

	acpi_evaluate_object(event->handle, NULL, NULL, NULL);





	return IRQ_HANDLED;

	return IRQ_HANDLED;

}

}
@@ -91,111 +91,148 @@ static void acpi_gpio_chip_dh(acpi_handle handle, void *data) 
	/* The address of this function is used as a key. */

	/* The address of this function is used as a key. */

}

}





/**

static acpi_status acpi_gpiochip_request_interrupt(struct acpi_resource *ares,

 * acpi_gpiochip_request_interrupts() - Register isr for gpio chip ACPI events

						   void *context)

 * @acpi_gpio:      ACPI GPIO chip

 *

 * ACPI5 platforms can use GPIO signaled ACPI events. These GPIO interrupts are

 * handled by ACPI event methods which need to be called from the GPIO

 * 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.

 */

static void acpi_gpiochip_request_interrupts(struct acpi_gpio_chip *acpi_gpio)

{

{

	struct acpi_buffer buf = {ACPI_ALLOCATE_BUFFER, NULL};

	struct acpi_gpio_chip *acpi_gpio = context;

	struct gpio_chip *chip = acpi_gpio->chip;

	struct gpio_chip *chip = acpi_gpio->chip;

	struct acpi_resource *res;

	struct acpi_resource_gpio *agpio;

	acpi_handle handle, evt_handle;

	acpi_handle handle, evt_handle;

	acpi_status status;

	struct acpi_gpio_event *event;

	unsigned int pin;

	irq_handler_t handler = NULL;

	int irq, ret;

	struct gpio_desc *desc;

	char ev_name[5];

	unsigned long irqflags;

	int ret, pin, irq;





	if (!chip->dev || !chip->to_irq)

	if (ares->type != ACPI_RESOURCE_TYPE_GPIO)

		return;

		return AE_OK;



	agpio = &ares->data.gpio;

	if (agpio->connection_type != ACPI_RESOURCE_GPIO_TYPE_INT)

		return AE_OK;





	handle = ACPI_HANDLE(chip->dev);

	handle = ACPI_HANDLE(chip->dev);

	if (!handle)

	pin = agpio->pin_table[0];

		return;





	INIT_LIST_HEAD(&acpi_gpio->events);

	if (pin <= 255) {

		char ev_name[5];

		sprintf(ev_name, "_%c%02X",

			agpio->triggering == ACPI_EDGE_SENSITIVE ? 'E' : 'L',

			pin);

		if (ACPI_SUCCESS(acpi_get_handle(handle, ev_name, &evt_handle)))

			handler = acpi_gpio_irq_handler;

	}

	if (!handler) {

		if (ACPI_SUCCESS(acpi_get_handle(handle, "_EVT", &evt_handle)))

			handler = acpi_gpio_irq_handler_evt;

	}

	if (!handler)

		return AE_BAD_PARAMETER;





	/*

	desc = gpiochip_get_desc(chip, pin);

	 * If a GPIO interrupt has an ACPI event handler method, or _EVT is

	if (IS_ERR(desc)) {

	 * present, set up an interrupt handler that calls the ACPI event

		dev_err(chip->dev, "Failed to get GPIO descriptor\n");

	 * handler.

		return AE_ERROR;

	 */

	}

	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 ||

	ret = gpiochip_request_own_desc(desc, "ACPI:Event");

		    res->data.gpio.connection_type !=

	if (ret) {

		    ACPI_RESOURCE_GPIO_TYPE_INT)

		dev_err(chip->dev, "Failed to request GPIO\n");

			continue;

		return AE_ERROR;

	}





		pin = res->data.gpio.pin_table[0];

	gpiod_direction_input(desc);

		if (pin > chip->ngpio)

			continue;





		irq = chip->to_irq(chip, pin);

	ret = gpiod_lock_as_irq(desc);

		if (irq < 0)

	if (ret) {

			continue;

		dev_err(chip->dev, "Failed to lock GPIO as interrupt\n");

		goto fail_free_desc;

	}





		if (pin <= 255) {

	irq = gpiod_to_irq(desc);

			acpi_handle ev_handle;

	if (irq < 0) {

		dev_err(chip->dev, "Failed to translate GPIO to IRQ\n");

		goto fail_unlock_irq;

	}





			sprintf(ev_name, "_%c%02X",

	irqflags = IRQF_ONESHOT;

				res->data.gpio.triggering ? 'E' : 'L', pin);

	if (agpio->triggering == ACPI_LEVEL_SENSITIVE) {

			status = acpi_get_handle(handle, ev_name, &ev_handle);

		if (agpio->polarity == ACPI_ACTIVE_HIGH)

			if (ACPI_SUCCESS(status)) {

			irqflags |= IRQF_TRIGGER_HIGH;

				handler = acpi_gpio_irq_handler;

		else

				data = ev_handle;

			irqflags |= IRQF_TRIGGER_LOW;

	} else {

		switch (agpio->polarity) {

		case ACPI_ACTIVE_HIGH:

			irqflags |= IRQF_TRIGGER_RISING;

			break;

		case ACPI_ACTIVE_LOW:

			irqflags |= IRQF_TRIGGER_FALLING;

			break;

		default:

			irqflags |= IRQF_TRIGGER_RISING |

				    IRQF_TRIGGER_FALLING;

			break;

		}

		}

	}

	}

		if (!handler) {

			struct acpi_gpio_event *event;



			status = acpi_get_handle(handle, "_EVT", &evt_handle);

			if (ACPI_FAILURE(status))

				continue





	event = kzalloc(sizeof(*event), GFP_KERNEL);

	event = kzalloc(sizeof(*event), GFP_KERNEL);

	if (!event)

	if (!event)

				continue;

		goto fail_unlock_irq;





			list_add_tail(&event->node, &acpi_gpio->events);

	event->handle = evt_handle;

	event->handle = evt_handle;

			event->pin = pin;

	event->irq = irq;

	event->irq = irq;

			handler = acpi_gpio_irq_handler_evt;

	event->pin = pin;

			data = event;

		}

		if (!handler)

			continue;





		/* Assume BIOS sets the triggering, so no flags */

	ret = request_threaded_irq(event->irq, NULL, handler, irqflags,

		ret = devm_request_threaded_irq(chip->dev, irq, NULL, handler,

				   "ACPI:Event", event);

						0, "GPIO-signaled-ACPI-event",

	if (ret) {

						data);

		dev_err(chip->dev, "Failed to setup interrupt handler for %d\n",

		if (ret)

			event->irq);

			dev_err(chip->dev,

		goto fail_free_event;

				"Failed to request IRQ %d ACPI event handler\n",

				irq);

	}

	}



	list_add_tail(&event->node, &acpi_gpio->events);

	return AE_OK;



fail_free_event:

	kfree(event);

fail_unlock_irq:

	gpiod_unlock_as_irq(desc);

fail_free_desc:

	gpiochip_free_own_desc(desc);



	return AE_ERROR;

}

}





/**

/**

 * acpi_gpiochip_free_interrupts() - Free GPIO _EVT ACPI event interrupts.

 * acpi_gpiochip_request_interrupts() - Register isr for gpio chip ACPI events

 * @acpi_gpio:      ACPI GPIO chip

 * @acpi_gpio:      ACPI GPIO chip

 *

 *

 * Free interrupts associated with the _EVT method for the given GPIO chip.

 * ACPI5 platforms can use GPIO signaled ACPI events. These GPIO interrupts are

 * handled by ACPI event methods which need to be called from the GPIO

 * 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.

 */

static void acpi_gpiochip_request_interrupts(struct acpi_gpio_chip *acpi_gpio)

{

	struct gpio_chip *chip = acpi_gpio->chip;



	if (!chip->dev || !chip->to_irq)

		return;



	INIT_LIST_HEAD(&acpi_gpio->events);

	acpi_walk_resources(ACPI_HANDLE(chip->dev), "_AEI",

			    acpi_gpiochip_request_interrupt, acpi_gpio);

}



/**

 * acpi_gpiochip_free_interrupts() - Free GPIO ACPI event interrupts.

 * @acpi_gpio:      ACPI GPIO chip

 *

 *

 * The remaining ACPI event interrupts associated with the chip are freed

 * Free interrupts associated with GPIO ACPI event method for the given

 * automatically.

 * GPIO chip.

 */

 */

static void acpi_gpiochip_free_interrupts(struct acpi_gpio_chip *acpi_gpio)

static void acpi_gpiochip_free_interrupts(struct acpi_gpio_chip *acpi_gpio)

{

{
@@ -206,7 +243,14 @@ static void acpi_gpiochip_free_interrupts(struct acpi_gpio_chip *acpi_gpio) 
		return;

		return;





	list_for_each_entry_safe_reverse(event, ep, &acpi_gpio->events, node) {

	list_for_each_entry_safe_reverse(event, ep, &acpi_gpio->events, node) {

		devm_free_irq(chip->dev, event->irq, event);

		struct gpio_desc *desc;



		free_irq(event->irq, event);

		desc = gpiochip_get_desc(chip, event->pin);

		if (WARN_ON(IS_ERR(desc)))

			continue;

		gpiod_unlock_as_irq(desc);

		gpiochip_free_own_desc(desc);

		list_del(&event->node);

		list_del(&event->node);

		kfree(event);

		kfree(event);

	}

	}

drivers/gpio/gpiolib.c

+2 −1
Original line number Original line Diff line number Diff line
@@ -1266,11 +1266,12 @@ int gpiochip_remove(struct gpio_chip *chip) 
	int		status = 0;

	int		status = 0;

	unsigned	id;

	unsigned	id;





	acpi_gpiochip_remove(chip);



	spin_lock_irqsave(&gpio_lock, flags);

	spin_lock_irqsave(&gpio_lock, flags);





	gpiochip_remove_pin_ranges(chip);

	gpiochip_remove_pin_ranges(chip);

	of_gpiochip_remove(chip);

	of_gpiochip_remove(chip);

	acpi_gpiochip_remove(chip);





	for (id = 0; id < chip->ngpio; id++) {

	for (id = 0; id < chip->ngpio; id++) {

		if (test_bit(FLAG_REQUESTED, &chip->desc[id].flags)) {

		if (test_bit(FLAG_REQUESTED, &chip->desc[id].flags)) {

CRA Git | Maintained and supported by SUSTech CRA and CCSE