blob: 986248f7011aa33a7cb8c97860210ab55cb772f7 [file] [log] [blame]
Mathias Nymane29482e2012-11-30 12:37:36 +01001/*
2 * ACPI helpers for GPIO API
3 *
4 * Copyright (C) 2012, Intel Corporation
5 * Authors: Mathias Nyman <mathias.nyman@linux.intel.com>
6 * Mika Westerberg <mika.westerberg@linux.intel.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12
13#include <linux/errno.h>
Mika Westerberg354567e2014-11-03 13:01:32 +020014#include <linux/gpio.h>
Mika Westerberg936e15d2013-10-10 11:01:08 +030015#include <linux/gpio/consumer.h>
Mika Westerberg5ccff852014-01-08 12:40:56 +020016#include <linux/gpio/driver.h>
Linus Walleij031ba282016-10-03 10:40:03 +020017#include <linux/gpio/machine.h>
Mathias Nymane29482e2012-11-30 12:37:36 +010018#include <linux/export.h>
Mathias Nymane29482e2012-11-30 12:37:36 +010019#include <linux/acpi.h>
Mathias Nyman0d1c28a2013-01-28 16:23:10 +020020#include <linux/interrupt.h>
Mika Westerberg473ed7b2014-03-14 17:58:07 +020021#include <linux/mutex.h>
Mika Westerberg354567e2014-11-03 13:01:32 +020022#include <linux/pinctrl/pinctrl.h>
Mathias Nymane29482e2012-11-30 12:37:36 +010023
Mika Westerberg5ccff852014-01-08 12:40:56 +020024#include "gpiolib.h"
25
Mika Westerberg4b01a142014-03-10 14:54:52 +020026struct acpi_gpio_event {
Rafael J. Wysocki7fc7acb2013-04-09 15:57:25 +020027 struct list_head node;
Mika Westerberg4b01a142014-03-10 14:54:52 +020028 acpi_handle handle;
Rafael J. Wysocki7fc7acb2013-04-09 15:57:25 +020029 unsigned int pin;
30 unsigned int irq;
Alexandre Courbote46cf322014-08-19 10:06:08 -070031 struct gpio_desc *desc;
Rafael J. Wysocki7fc7acb2013-04-09 15:57:25 +020032};
33
Mika Westerberg473ed7b2014-03-14 17:58:07 +020034struct acpi_gpio_connection {
35 struct list_head node;
Alexandre Courbote46cf322014-08-19 10:06:08 -070036 unsigned int pin;
Mika Westerberg473ed7b2014-03-14 17:58:07 +020037 struct gpio_desc *desc;
38};
39
Mika Westerbergaa92b6f2014-03-10 14:54:51 +020040struct acpi_gpio_chip {
Mika Westerberg473ed7b2014-03-14 17:58:07 +020041 /*
42 * ACPICA requires that the first field of the context parameter
43 * passed to acpi_install_address_space_handler() is large enough
44 * to hold struct acpi_connection_info.
45 */
46 struct acpi_connection_info conn_info;
47 struct list_head conns;
48 struct mutex conn_lock;
Mika Westerbergaa92b6f2014-03-10 14:54:51 +020049 struct gpio_chip *chip;
Mika Westerberg4b01a142014-03-10 14:54:52 +020050 struct list_head events;
Mika Westerbergaa92b6f2014-03-10 14:54:51 +020051};
52
Mathias Nymane29482e2012-11-30 12:37:36 +010053static int acpi_gpiochip_find(struct gpio_chip *gc, void *data)
54{
Linus Walleij58383c72015-11-04 09:56:26 +010055 if (!gc->parent)
Mathias Nymane29482e2012-11-30 12:37:36 +010056 return false;
57
Linus Walleij58383c72015-11-04 09:56:26 +010058 return ACPI_HANDLE(gc->parent) == data;
Mathias Nymane29482e2012-11-30 12:37:36 +010059}
60
Mika Westerberg354567e2014-11-03 13:01:32 +020061#ifdef CONFIG_PINCTRL
62/**
63 * acpi_gpiochip_pin_to_gpio_offset() - translates ACPI GPIO to Linux GPIO
64 * @chip: GPIO chip
65 * @pin: ACPI GPIO pin number from GpioIo/GpioInt resource
66 *
67 * Function takes ACPI GpioIo/GpioInt pin number as a parameter and
68 * translates it to a corresponding offset suitable to be passed to a
69 * GPIO controller driver.
70 *
71 * Typically the returned offset is same as @pin, but if the GPIO
Masahiro Yamadae1c05062015-07-07 10:14:59 +090072 * controller uses pin controller and the mapping is not contiguous the
Mika Westerberg354567e2014-11-03 13:01:32 +020073 * offset might be different.
74 */
Linus Walleij20ec3e32016-02-11 11:03:06 +010075static int acpi_gpiochip_pin_to_gpio_offset(struct gpio_device *gdev, int pin)
Mika Westerberg354567e2014-11-03 13:01:32 +020076{
77 struct gpio_pin_range *pin_range;
78
79 /* If there are no ranges in this chip, use 1:1 mapping */
Linus Walleij20ec3e32016-02-11 11:03:06 +010080 if (list_empty(&gdev->pin_ranges))
Mika Westerberg354567e2014-11-03 13:01:32 +020081 return pin;
82
Linus Walleij20ec3e32016-02-11 11:03:06 +010083 list_for_each_entry(pin_range, &gdev->pin_ranges, node) {
Mika Westerberg354567e2014-11-03 13:01:32 +020084 const struct pinctrl_gpio_range *range = &pin_range->range;
85 int i;
86
87 if (range->pins) {
88 for (i = 0; i < range->npins; i++) {
89 if (range->pins[i] == pin)
Linus Walleij20ec3e32016-02-11 11:03:06 +010090 return range->base + i - gdev->base;
Mika Westerberg354567e2014-11-03 13:01:32 +020091 }
92 } else {
93 if (pin >= range->pin_base &&
94 pin < range->pin_base + range->npins) {
95 unsigned gpio_base;
96
Linus Walleij20ec3e32016-02-11 11:03:06 +010097 gpio_base = range->base - gdev->base;
Mika Westerberg354567e2014-11-03 13:01:32 +020098 return gpio_base + pin - range->pin_base;
99 }
100 }
101 }
102
103 return -EINVAL;
104}
105#else
Linus Walleij20ec3e32016-02-11 11:03:06 +0100106static inline int acpi_gpiochip_pin_to_gpio_offset(struct gpio_device *gdev,
Mika Westerberg354567e2014-11-03 13:01:32 +0200107 int pin)
108{
109 return pin;
110}
111#endif
112
Mathias Nymane29482e2012-11-30 12:37:36 +0100113/**
Mika Westerberg936e15d2013-10-10 11:01:08 +0300114 * acpi_get_gpiod() - Translate ACPI GPIO pin to GPIO descriptor usable with GPIO API
Mathias Nymane29482e2012-11-30 12:37:36 +0100115 * @path: ACPI GPIO controller full path name, (e.g. "\\_SB.GPO1")
116 * @pin: ACPI GPIO pin number (0-based, controller-relative)
117 *
Mika Westerbergf35bbf62015-06-10 16:05:05 +0300118 * Return: GPIO descriptor to use with Linux generic GPIO API, or ERR_PTR
119 * error value. Specifically returns %-EPROBE_DEFER if the referenced GPIO
120 * controller does not have gpiochip registered at the moment. This is to
121 * support probe deferral.
Mathias Nymane29482e2012-11-30 12:37:36 +0100122 */
Mika Westerberg936e15d2013-10-10 11:01:08 +0300123static struct gpio_desc *acpi_get_gpiod(char *path, int pin)
Mathias Nymane29482e2012-11-30 12:37:36 +0100124{
125 struct gpio_chip *chip;
126 acpi_handle handle;
127 acpi_status status;
Mika Westerberg354567e2014-11-03 13:01:32 +0200128 int offset;
Mathias Nymane29482e2012-11-30 12:37:36 +0100129
130 status = acpi_get_handle(NULL, path, &handle);
131 if (ACPI_FAILURE(status))
Mika Westerberg936e15d2013-10-10 11:01:08 +0300132 return ERR_PTR(-ENODEV);
Mathias Nymane29482e2012-11-30 12:37:36 +0100133
134 chip = gpiochip_find(handle, acpi_gpiochip_find);
135 if (!chip)
Mika Westerbergf35bbf62015-06-10 16:05:05 +0300136 return ERR_PTR(-EPROBE_DEFER);
Mathias Nymane29482e2012-11-30 12:37:36 +0100137
Linus Walleij20ec3e32016-02-11 11:03:06 +0100138 offset = acpi_gpiochip_pin_to_gpio_offset(chip->gpiodev, pin);
Mika Westerberg354567e2014-11-03 13:01:32 +0200139 if (offset < 0)
140 return ERR_PTR(offset);
Mathias Nymane29482e2012-11-30 12:37:36 +0100141
Mika Westerberg354567e2014-11-03 13:01:32 +0200142 return gpiochip_get_desc(chip, offset);
Mathias Nymane29482e2012-11-30 12:37:36 +0100143}
Mathias Nyman0d1c28a2013-01-28 16:23:10 +0200144
Mathias Nyman0d1c28a2013-01-28 16:23:10 +0200145static irqreturn_t acpi_gpio_irq_handler(int irq, void *data)
146{
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200147 struct acpi_gpio_event *event = data;
Mathias Nyman0d1c28a2013-01-28 16:23:10 +0200148
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200149 acpi_evaluate_object(event->handle, NULL, NULL, NULL);
Mathias Nyman0d1c28a2013-01-28 16:23:10 +0200150
151 return IRQ_HANDLED;
152}
153
Rafael J. Wysocki7fc7acb2013-04-09 15:57:25 +0200154static irqreturn_t acpi_gpio_irq_handler_evt(int irq, void *data)
155{
Mika Westerberg4b01a142014-03-10 14:54:52 +0200156 struct acpi_gpio_event *event = data;
Rafael J. Wysocki7fc7acb2013-04-09 15:57:25 +0200157
Mika Westerberg4b01a142014-03-10 14:54:52 +0200158 acpi_execute_simple_method(event->handle, NULL, event->pin);
Rafael J. Wysocki7fc7acb2013-04-09 15:57:25 +0200159
160 return IRQ_HANDLED;
161}
162
Mika Westerbergaa92b6f2014-03-10 14:54:51 +0200163static void acpi_gpio_chip_dh(acpi_handle handle, void *data)
Rafael J. Wysocki7fc7acb2013-04-09 15:57:25 +0200164{
165 /* The address of this function is used as a key. */
166}
167
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200168static acpi_status acpi_gpiochip_request_interrupt(struct acpi_resource *ares,
169 void *context)
170{
171 struct acpi_gpio_chip *acpi_gpio = context;
172 struct gpio_chip *chip = acpi_gpio->chip;
173 struct acpi_resource_gpio *agpio;
174 acpi_handle handle, evt_handle;
175 struct acpi_gpio_event *event;
176 irq_handler_t handler = NULL;
177 struct gpio_desc *desc;
178 unsigned long irqflags;
179 int ret, pin, irq;
180
181 if (ares->type != ACPI_RESOURCE_TYPE_GPIO)
182 return AE_OK;
183
184 agpio = &ares->data.gpio;
185 if (agpio->connection_type != ACPI_RESOURCE_GPIO_TYPE_INT)
186 return AE_OK;
187
Linus Walleij58383c72015-11-04 09:56:26 +0100188 handle = ACPI_HANDLE(chip->parent);
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200189 pin = agpio->pin_table[0];
190
191 if (pin <= 255) {
192 char ev_name[5];
193 sprintf(ev_name, "_%c%02X",
194 agpio->triggering == ACPI_EDGE_SENSITIVE ? 'E' : 'L',
195 pin);
196 if (ACPI_SUCCESS(acpi_get_handle(handle, ev_name, &evt_handle)))
197 handler = acpi_gpio_irq_handler;
198 }
199 if (!handler) {
200 if (ACPI_SUCCESS(acpi_get_handle(handle, "_EVT", &evt_handle)))
201 handler = acpi_gpio_irq_handler_evt;
202 }
203 if (!handler)
204 return AE_BAD_PARAMETER;
205
Linus Walleij20ec3e32016-02-11 11:03:06 +0100206 pin = acpi_gpiochip_pin_to_gpio_offset(chip->gpiodev, pin);
qipeng.zha4de60972015-03-11 01:15:38 +0800207 if (pin < 0)
208 return AE_BAD_PARAMETER;
209
Alexandre Courbotabdc08a2014-08-19 10:06:09 -0700210 desc = gpiochip_request_own_desc(chip, pin, "ACPI:Event");
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200211 if (IS_ERR(desc)) {
Linus Walleij58383c72015-11-04 09:56:26 +0100212 dev_err(chip->parent, "Failed to request GPIO\n");
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200213 return AE_ERROR;
214 }
215
216 gpiod_direction_input(desc);
217
Alexandre Courbote3a2e872014-10-23 17:27:07 +0900218 ret = gpiochip_lock_as_irq(chip, pin);
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200219 if (ret) {
Linus Walleij58383c72015-11-04 09:56:26 +0100220 dev_err(chip->parent, "Failed to lock GPIO as interrupt\n");
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200221 goto fail_free_desc;
222 }
223
224 irq = gpiod_to_irq(desc);
225 if (irq < 0) {
Linus Walleij58383c72015-11-04 09:56:26 +0100226 dev_err(chip->parent, "Failed to translate GPIO to IRQ\n");
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200227 goto fail_unlock_irq;
228 }
229
230 irqflags = IRQF_ONESHOT;
231 if (agpio->triggering == ACPI_LEVEL_SENSITIVE) {
232 if (agpio->polarity == ACPI_ACTIVE_HIGH)
233 irqflags |= IRQF_TRIGGER_HIGH;
234 else
235 irqflags |= IRQF_TRIGGER_LOW;
236 } else {
237 switch (agpio->polarity) {
238 case ACPI_ACTIVE_HIGH:
239 irqflags |= IRQF_TRIGGER_RISING;
240 break;
241 case ACPI_ACTIVE_LOW:
242 irqflags |= IRQF_TRIGGER_FALLING;
243 break;
244 default:
245 irqflags |= IRQF_TRIGGER_RISING |
246 IRQF_TRIGGER_FALLING;
247 break;
248 }
249 }
250
251 event = kzalloc(sizeof(*event), GFP_KERNEL);
252 if (!event)
253 goto fail_unlock_irq;
254
255 event->handle = evt_handle;
256 event->irq = irq;
257 event->pin = pin;
Alexandre Courbote46cf322014-08-19 10:06:08 -0700258 event->desc = desc;
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200259
260 ret = request_threaded_irq(event->irq, NULL, handler, irqflags,
261 "ACPI:Event", event);
262 if (ret) {
Linus Walleij58383c72015-11-04 09:56:26 +0100263 dev_err(chip->parent,
264 "Failed to setup interrupt handler for %d\n",
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200265 event->irq);
266 goto fail_free_event;
267 }
268
269 list_add_tail(&event->node, &acpi_gpio->events);
270 return AE_OK;
271
272fail_free_event:
273 kfree(event);
274fail_unlock_irq:
Alexandre Courbote3a2e872014-10-23 17:27:07 +0900275 gpiochip_unlock_as_irq(chip, pin);
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200276fail_free_desc:
277 gpiochip_free_own_desc(desc);
278
279 return AE_ERROR;
280}
281
Mathias Nyman0d1c28a2013-01-28 16:23:10 +0200282/**
283 * acpi_gpiochip_request_interrupts() - Register isr for gpio chip ACPI events
Mika Westerbergafa82fa2014-07-25 09:54:48 +0300284 * @chip: GPIO chip
Mathias Nyman0d1c28a2013-01-28 16:23:10 +0200285 *
286 * ACPI5 platforms can use GPIO signaled ACPI events. These GPIO interrupts are
287 * handled by ACPI event methods which need to be called from the GPIO
288 * chip's interrupt handler. acpi_gpiochip_request_interrupts finds out which
289 * gpio pins have acpi event methods and assigns interrupt handlers that calls
290 * the acpi event methods for those pins.
Mathias Nyman0d1c28a2013-01-28 16:23:10 +0200291 */
Mika Westerbergafa82fa2014-07-25 09:54:48 +0300292void acpi_gpiochip_request_interrupts(struct gpio_chip *chip)
Mathias Nyman0d1c28a2013-01-28 16:23:10 +0200293{
Mika Westerbergafa82fa2014-07-25 09:54:48 +0300294 struct acpi_gpio_chip *acpi_gpio;
295 acpi_handle handle;
296 acpi_status status;
Mathias Nyman0d1c28a2013-01-28 16:23:10 +0200297
Linus Walleij58383c72015-11-04 09:56:26 +0100298 if (!chip->parent || !chip->to_irq)
Mika Westerbergafa82fa2014-07-25 09:54:48 +0300299 return;
300
Linus Walleij58383c72015-11-04 09:56:26 +0100301 handle = ACPI_HANDLE(chip->parent);
Mika Westerbergafa82fa2014-07-25 09:54:48 +0300302 if (!handle)
303 return;
304
305 status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);
306 if (ACPI_FAILURE(status))
Mathias Nyman0d1c28a2013-01-28 16:23:10 +0200307 return;
308
Rafael J. Wysocki1ecb0162015-03-10 23:10:01 +0100309 acpi_walk_resources(handle, "_AEI",
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200310 acpi_gpiochip_request_interrupt, acpi_gpio);
Mathias Nyman0d1c28a2013-01-28 16:23:10 +0200311}
Hanjun Guo2b528ff2015-06-10 17:12:07 +0800312EXPORT_SYMBOL_GPL(acpi_gpiochip_request_interrupts);
Rafael J. Wysocki7fc7acb2013-04-09 15:57:25 +0200313
Mika Westerberg70b53412013-10-10 11:01:07 +0300314/**
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200315 * acpi_gpiochip_free_interrupts() - Free GPIO ACPI event interrupts.
Mika Westerbergafa82fa2014-07-25 09:54:48 +0300316 * @chip: GPIO chip
Mika Westerberg70b53412013-10-10 11:01:07 +0300317 *
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200318 * Free interrupts associated with GPIO ACPI event method for the given
319 * GPIO chip.
Mika Westerberg70b53412013-10-10 11:01:07 +0300320 */
Mika Westerbergafa82fa2014-07-25 09:54:48 +0300321void acpi_gpiochip_free_interrupts(struct gpio_chip *chip)
Mika Westerberg70b53412013-10-10 11:01:07 +0300322{
Mika Westerbergafa82fa2014-07-25 09:54:48 +0300323 struct acpi_gpio_chip *acpi_gpio;
Mika Westerberg4b01a142014-03-10 14:54:52 +0200324 struct acpi_gpio_event *event, *ep;
Mika Westerbergafa82fa2014-07-25 09:54:48 +0300325 acpi_handle handle;
326 acpi_status status;
Mika Westerberg70b53412013-10-10 11:01:07 +0300327
Linus Walleij58383c72015-11-04 09:56:26 +0100328 if (!chip->parent || !chip->to_irq)
Mika Westerbergafa82fa2014-07-25 09:54:48 +0300329 return;
330
Linus Walleij58383c72015-11-04 09:56:26 +0100331 handle = ACPI_HANDLE(chip->parent);
Mika Westerbergafa82fa2014-07-25 09:54:48 +0300332 if (!handle)
333 return;
334
335 status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);
336 if (ACPI_FAILURE(status))
Mika Westerberg70b53412013-10-10 11:01:07 +0300337 return;
338
Mika Westerberg4b01a142014-03-10 14:54:52 +0200339 list_for_each_entry_safe_reverse(event, ep, &acpi_gpio->events, node) {
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200340 struct gpio_desc *desc;
341
342 free_irq(event->irq, event);
Alexandre Courbote46cf322014-08-19 10:06:08 -0700343 desc = event->desc;
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200344 if (WARN_ON(IS_ERR(desc)))
345 continue;
Alexandre Courbote3a2e872014-10-23 17:27:07 +0900346 gpiochip_unlock_as_irq(chip, event->pin);
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200347 gpiochip_free_own_desc(desc);
Mika Westerberg4b01a142014-03-10 14:54:52 +0200348 list_del(&event->node);
349 kfree(event);
Mika Westerberg70b53412013-10-10 11:01:07 +0300350 }
Mika Westerberg70b53412013-10-10 11:01:07 +0300351}
Hanjun Guo2b528ff2015-06-10 17:12:07 +0800352EXPORT_SYMBOL_GPL(acpi_gpiochip_free_interrupts);
Mika Westerberg70b53412013-10-10 11:01:07 +0300353
Rafael J. Wysockif028d522014-11-03 23:39:41 +0100354int acpi_dev_add_driver_gpios(struct acpi_device *adev,
355 const struct acpi_gpio_mapping *gpios)
356{
357 if (adev && gpios) {
358 adev->driver_gpios = gpios;
359 return 0;
360 }
361 return -EINVAL;
362}
363EXPORT_SYMBOL_GPL(acpi_dev_add_driver_gpios);
364
365static bool acpi_get_driver_gpio_data(struct acpi_device *adev,
366 const char *name, int index,
367 struct acpi_reference_args *args)
368{
369 const struct acpi_gpio_mapping *gm;
370
371 if (!adev->driver_gpios)
372 return false;
373
374 for (gm = adev->driver_gpios; gm->name; gm++)
375 if (!strcmp(name, gm->name) && gm->data && index < gm->size) {
376 const struct acpi_gpio_params *par = gm->data + index;
377
378 args->adev = adev;
379 args->args[0] = par->crs_entry_index;
380 args->args[1] = par->line_index;
381 args->args[2] = par->active_low;
382 args->nargs = 3;
383 return true;
384 }
385
386 return false;
387}
388
Mika Westerberg12028d22013-04-03 13:56:54 +0300389struct acpi_gpio_lookup {
390 struct acpi_gpio_info info;
391 int index;
Mika Westerberg0d9a6932014-10-29 15:41:01 +0100392 int pin_index;
Rafael J. Wysockid0795242015-08-27 04:41:33 +0200393 bool active_low;
394 struct acpi_device *adev;
Mika Westerberg936e15d2013-10-10 11:01:08 +0300395 struct gpio_desc *desc;
Mika Westerberg12028d22013-04-03 13:56:54 +0300396 int n;
397};
398
Linus Walleij031ba282016-10-03 10:40:03 +0200399static int acpi_populate_gpio_lookup(struct acpi_resource *ares, void *data)
Mika Westerberg12028d22013-04-03 13:56:54 +0300400{
401 struct acpi_gpio_lookup *lookup = data;
402
403 if (ares->type != ACPI_RESOURCE_TYPE_GPIO)
404 return 1;
405
Mika Westerberg936e15d2013-10-10 11:01:08 +0300406 if (lookup->n++ == lookup->index && !lookup->desc) {
Mika Westerberg12028d22013-04-03 13:56:54 +0300407 const struct acpi_resource_gpio *agpio = &ares->data.gpio;
Mika Westerberg0d9a6932014-10-29 15:41:01 +0100408 int pin_index = lookup->pin_index;
409
410 if (pin_index >= agpio->pin_table_length)
411 return 1;
Mika Westerberg12028d22013-04-03 13:56:54 +0300412
Mika Westerberg936e15d2013-10-10 11:01:08 +0300413 lookup->desc = acpi_get_gpiod(agpio->resource_source.string_ptr,
Mika Westerberg0d9a6932014-10-29 15:41:01 +0100414 agpio->pin_table[pin_index]);
Mika Westerberg12028d22013-04-03 13:56:54 +0300415 lookup->info.gpioint =
416 agpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT;
Mika Westerberg0d9a6932014-10-29 15:41:01 +0100417
418 /*
419 * ActiveLow is only specified for GpioInt resource. If
420 * GpioIo is used then the only way to set the flag is
421 * to use _DSD "gpios" property.
Christophe RICARD52044722015-12-23 23:25:34 +0100422 * Note: we expect here:
423 * - ACPI_ACTIVE_LOW == GPIO_ACTIVE_LOW
424 * - ACPI_ACTIVE_HIGH == GPIO_ACTIVE_HIGH
Mika Westerberg0d9a6932014-10-29 15:41:01 +0100425 */
Christophe RICARD52044722015-12-23 23:25:34 +0100426 if (lookup->info.gpioint) {
427 lookup->info.polarity = agpio->polarity;
428 lookup->info.triggering = agpio->triggering;
429 }
430
Mika Westerberg12028d22013-04-03 13:56:54 +0300431 }
432
433 return 1;
434}
435
Rafael J. Wysockid0795242015-08-27 04:41:33 +0200436static int acpi_gpio_resource_lookup(struct acpi_gpio_lookup *lookup,
437 struct acpi_gpio_info *info)
438{
439 struct list_head res_list;
440 int ret;
441
442 INIT_LIST_HEAD(&res_list);
443
Linus Walleij031ba282016-10-03 10:40:03 +0200444 ret = acpi_dev_get_resources(lookup->adev, &res_list,
445 acpi_populate_gpio_lookup,
Rafael J. Wysockid0795242015-08-27 04:41:33 +0200446 lookup);
447 if (ret < 0)
448 return ret;
449
450 acpi_dev_free_resource_list(&res_list);
451
452 if (!lookup->desc)
453 return -ENOENT;
454
455 if (info) {
456 *info = lookup->info;
457 if (lookup->active_low)
Christophe RICARD52044722015-12-23 23:25:34 +0100458 info->polarity = lookup->active_low;
Rafael J. Wysockid0795242015-08-27 04:41:33 +0200459 }
460 return 0;
461}
462
Rafael J. Wysocki504a3372015-08-27 04:42:33 +0200463static int acpi_gpio_property_lookup(struct fwnode_handle *fwnode,
Rafael J. Wysockid0795242015-08-27 04:41:33 +0200464 const char *propname, int index,
465 struct acpi_gpio_lookup *lookup)
466{
467 struct acpi_reference_args args;
468 int ret;
469
470 memset(&args, 0, sizeof(args));
Rafael J. Wysocki504a3372015-08-27 04:42:33 +0200471 ret = acpi_node_get_property_reference(fwnode, propname, index, &args);
472 if (ret) {
473 struct acpi_device *adev = to_acpi_device_node(fwnode);
Rafael J. Wysockid0795242015-08-27 04:41:33 +0200474
Rafael J. Wysocki504a3372015-08-27 04:42:33 +0200475 if (!adev)
476 return ret;
477
478 if (!acpi_get_driver_gpio_data(adev, propname, index, &args))
479 return ret;
480 }
Rafael J. Wysockid0795242015-08-27 04:41:33 +0200481 /*
482 * The property was found and resolved, so need to lookup the GPIO based
483 * on returned args.
484 */
485 lookup->adev = args.adev;
486 if (args.nargs >= 2) {
487 lookup->index = args.args[0];
488 lookup->pin_index = args.args[1];
489 /* 3rd argument, if present is used to specify active_low. */
490 if (args.nargs >= 3)
491 lookup->active_low = !!args.args[2];
492 }
493 return 0;
494}
495
Mika Westerberg12028d22013-04-03 13:56:54 +0300496/**
Mika Westerberg936e15d2013-10-10 11:01:08 +0300497 * acpi_get_gpiod_by_index() - get a GPIO descriptor from device resources
Mika Westerberg0d9a6932014-10-29 15:41:01 +0100498 * @adev: pointer to a ACPI device to get GPIO from
499 * @propname: Property name of the GPIO (optional)
Mika Westerberg12028d22013-04-03 13:56:54 +0300500 * @index: index of GpioIo/GpioInt resource (starting from %0)
501 * @info: info pointer to fill in (optional)
502 *
Mika Westerberg0d9a6932014-10-29 15:41:01 +0100503 * Function goes through ACPI resources for @adev and based on @index looks
Mika Westerberg936e15d2013-10-10 11:01:08 +0300504 * up a GpioIo/GpioInt resource, translates it to the Linux GPIO descriptor,
Mika Westerberg12028d22013-04-03 13:56:54 +0300505 * and returns it. @index matches GpioIo/GpioInt resources only so if there
506 * are total %3 GPIO resources, the index goes from %0 to %2.
507 *
Mika Westerberg0d9a6932014-10-29 15:41:01 +0100508 * If @propname is specified the GPIO is looked using device property. In
509 * that case @index is used to select the GPIO entry in the property value
510 * (in case of multiple).
511 *
Mika Westerberg936e15d2013-10-10 11:01:08 +0300512 * If the GPIO cannot be translated or there is an error an ERR_PTR is
Mika Westerberg12028d22013-04-03 13:56:54 +0300513 * returned.
514 *
515 * Note: if the GPIO resource has multiple entries in the pin list, this
516 * function only returns the first.
517 */
Linus Walleij031ba282016-10-03 10:40:03 +0200518static struct gpio_desc *acpi_get_gpiod_by_index(struct acpi_device *adev,
Mika Westerberg0d9a6932014-10-29 15:41:01 +0100519 const char *propname, int index,
Mika Westerberg936e15d2013-10-10 11:01:08 +0300520 struct acpi_gpio_info *info)
Mika Westerberg12028d22013-04-03 13:56:54 +0300521{
522 struct acpi_gpio_lookup lookup;
Mika Westerberg12028d22013-04-03 13:56:54 +0300523 int ret;
524
Mika Westerberg0d9a6932014-10-29 15:41:01 +0100525 if (!adev)
Mika Westerberg936e15d2013-10-10 11:01:08 +0300526 return ERR_PTR(-ENODEV);
Mika Westerberg12028d22013-04-03 13:56:54 +0300527
528 memset(&lookup, 0, sizeof(lookup));
529 lookup.index = index;
Mika Westerberg12028d22013-04-03 13:56:54 +0300530
Mika Westerberg0d9a6932014-10-29 15:41:01 +0100531 if (propname) {
Mika Westerberg0d9a6932014-10-29 15:41:01 +0100532 dev_dbg(&adev->dev, "GPIO: looking up %s\n", propname);
533
Rafael J. Wysocki504a3372015-08-27 04:42:33 +0200534 ret = acpi_gpio_property_lookup(acpi_fwnode_handle(adev),
535 propname, index, &lookup);
Rafael J. Wysockid0795242015-08-27 04:41:33 +0200536 if (ret)
537 return ERR_PTR(ret);
Mika Westerberg0d9a6932014-10-29 15:41:01 +0100538
Rafael J. Wysockid0795242015-08-27 04:41:33 +0200539 dev_dbg(&adev->dev, "GPIO: _DSD returned %s %d %d %u\n",
540 dev_name(&lookup.adev->dev), lookup.index,
541 lookup.pin_index, lookup.active_low);
Mika Westerberg0d9a6932014-10-29 15:41:01 +0100542 } else {
543 dev_dbg(&adev->dev, "GPIO: looking up %d in _CRS\n", index);
Rafael J. Wysockid0795242015-08-27 04:41:33 +0200544 lookup.adev = adev;
Mika Westerberg0d9a6932014-10-29 15:41:01 +0100545 }
546
Rafael J. Wysockid0795242015-08-27 04:41:33 +0200547 ret = acpi_gpio_resource_lookup(&lookup, info);
548 return ret ? ERR_PTR(ret) : lookup.desc;
Mika Westerberg12028d22013-04-03 13:56:54 +0300549}
Mika Westerberg664e3e52014-01-08 12:40:54 +0200550
Linus Walleij031ba282016-10-03 10:40:03 +0200551struct gpio_desc *acpi_find_gpio(struct device *dev,
552 const char *con_id,
553 unsigned int idx,
554 enum gpiod_flags flags,
555 enum gpio_lookup_flags *lookupflags)
556{
557 struct acpi_device *adev = ACPI_COMPANION(dev);
558 struct acpi_gpio_info info;
559 struct gpio_desc *desc;
560 char propname[32];
561 int i;
562
563 /* Try first from _DSD */
564 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
565 if (con_id && strcmp(con_id, "gpios")) {
566 snprintf(propname, sizeof(propname), "%s-%s",
567 con_id, gpio_suffixes[i]);
568 } else {
569 snprintf(propname, sizeof(propname), "%s",
570 gpio_suffixes[i]);
571 }
572
573 desc = acpi_get_gpiod_by_index(adev, propname, idx, &info);
Dmitry Torokhove4a62342017-03-23 13:21:38 -0700574 if (!IS_ERR(desc))
Linus Walleij031ba282016-10-03 10:40:03 +0200575 break;
Dmitry Torokhove4a62342017-03-23 13:21:38 -0700576 if (PTR_ERR(desc) == -EPROBE_DEFER)
577 return ERR_CAST(desc);
Linus Walleij031ba282016-10-03 10:40:03 +0200578 }
579
580 /* Then from plain _CRS GPIOs */
581 if (IS_ERR(desc)) {
582 if (!acpi_can_fallback_to_crs(adev, con_id))
583 return ERR_PTR(-ENOENT);
584
585 desc = acpi_get_gpiod_by_index(adev, NULL, idx, &info);
586 if (IS_ERR(desc))
587 return desc;
588
589 if ((flags == GPIOD_OUT_LOW || flags == GPIOD_OUT_HIGH) &&
590 info.gpioint) {
591 dev_dbg(dev, "refusing GpioInt() entry when doing GPIOD_OUT_* lookup\n");
592 return ERR_PTR(-ENOENT);
593 }
594 }
595
596 if (info.polarity == GPIO_ACTIVE_LOW)
597 *lookupflags |= GPIO_ACTIVE_LOW;
598
599 return desc;
600}
601
Mika Westerbergc884fbd2015-05-06 13:29:06 +0300602/**
Rafael J. Wysocki504a3372015-08-27 04:42:33 +0200603 * acpi_node_get_gpiod() - get a GPIO descriptor from ACPI resources
604 * @fwnode: pointer to an ACPI firmware node to get the GPIO information from
605 * @propname: Property name of the GPIO
606 * @index: index of GpioIo/GpioInt resource (starting from %0)
607 * @info: info pointer to fill in (optional)
608 *
609 * If @fwnode is an ACPI device object, call %acpi_get_gpiod_by_index() for it.
610 * Otherwise (ie. it is a data-only non-device object), use the property-based
611 * GPIO lookup to get to the GPIO resource with the relevant information and use
612 * that to obtain the GPIO descriptor to return.
613 */
614struct gpio_desc *acpi_node_get_gpiod(struct fwnode_handle *fwnode,
615 const char *propname, int index,
616 struct acpi_gpio_info *info)
617{
618 struct acpi_gpio_lookup lookup;
619 struct acpi_device *adev;
620 int ret;
621
622 adev = to_acpi_device_node(fwnode);
623 if (adev)
624 return acpi_get_gpiod_by_index(adev, propname, index, info);
625
626 if (!is_acpi_data_node(fwnode))
627 return ERR_PTR(-ENODEV);
628
629 if (!propname)
630 return ERR_PTR(-EINVAL);
631
632 memset(&lookup, 0, sizeof(lookup));
633 lookup.index = index;
634
635 ret = acpi_gpio_property_lookup(fwnode, propname, index, &lookup);
636 if (ret)
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200637 return ERR_PTR(ret);
638
Rafael J. Wysocki504a3372015-08-27 04:42:33 +0200639 ret = acpi_gpio_resource_lookup(&lookup, info);
640 return ret ? ERR_PTR(ret) : lookup.desc;
Mika Westerberg664e3e52014-01-08 12:40:54 +0200641}
642
Mika Westerbergc884fbd2015-05-06 13:29:06 +0300643/**
644 * acpi_dev_gpio_irq_get() - Find GpioInt and translate it to Linux IRQ number
645 * @adev: pointer to a ACPI device to get IRQ from
646 * @index: index of GpioInt resource (starting from %0)
647 *
648 * If the device has one or more GpioInt resources, this function can be
649 * used to translate from the GPIO offset in the resource to the Linux IRQ
650 * number.
651 *
652 * Return: Linux IRQ number (>%0) on success, negative errno on failure.
653 */
654int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index)
655{
656 int idx, i;
Christophe RICARD52044722015-12-23 23:25:34 +0100657 unsigned int irq_flags;
David Arcari67bf5152016-10-12 18:40:30 +0200658 int ret = -ENOENT;
Mika Westerbergc884fbd2015-05-06 13:29:06 +0300659
660 for (i = 0, idx = 0; idx <= index; i++) {
661 struct acpi_gpio_info info;
662 struct gpio_desc *desc;
663
664 desc = acpi_get_gpiod_by_index(adev, NULL, i, &info);
David Arcari67bf5152016-10-12 18:40:30 +0200665 if (IS_ERR(desc)) {
666 ret = PTR_ERR(desc);
Mika Westerbergc884fbd2015-05-06 13:29:06 +0300667 break;
David Arcari67bf5152016-10-12 18:40:30 +0200668 }
Christophe RICARD52044722015-12-23 23:25:34 +0100669 if (info.gpioint && idx++ == index) {
670 int irq = gpiod_to_irq(desc);
671
672 if (irq < 0)
673 return irq;
674
675 irq_flags = acpi_dev_get_irq_type(info.triggering,
676 info.polarity);
677
678 /* Set type if specified and different than the current one */
679 if (irq_flags != IRQ_TYPE_NONE &&
680 irq_flags != irq_get_trigger_type(irq))
681 irq_set_irq_type(irq, irq_flags);
682
683 return irq;
684 }
685
Mika Westerbergc884fbd2015-05-06 13:29:06 +0300686 }
David Arcari67bf5152016-10-12 18:40:30 +0200687 return ret;
Mika Westerbergc884fbd2015-05-06 13:29:06 +0300688}
689EXPORT_SYMBOL_GPL(acpi_dev_gpio_irq_get);
690
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200691static acpi_status
692acpi_gpio_adr_space_handler(u32 function, acpi_physical_address address,
693 u32 bits, u64 *value, void *handler_context,
694 void *region_context)
695{
696 struct acpi_gpio_chip *achip = region_context;
697 struct gpio_chip *chip = achip->chip;
698 struct acpi_resource_gpio *agpio;
699 struct acpi_resource *ares;
700 int pin_index = (int)address;
701 acpi_status status;
702 bool pull_up;
703 int length;
704 int i;
705
706 status = acpi_buffer_to_resource(achip->conn_info.connection,
707 achip->conn_info.length, &ares);
708 if (ACPI_FAILURE(status))
709 return status;
710
711 if (WARN_ON(ares->type != ACPI_RESOURCE_TYPE_GPIO)) {
712 ACPI_FREE(ares);
713 return AE_BAD_PARAMETER;
714 }
715
716 agpio = &ares->data.gpio;
717 pull_up = agpio->pin_config == ACPI_PIN_CONFIG_PULLUP;
718
719 if (WARN_ON(agpio->io_restriction == ACPI_IO_RESTRICT_INPUT &&
720 function == ACPI_WRITE)) {
721 ACPI_FREE(ares);
722 return AE_BAD_PARAMETER;
723 }
724
725 length = min(agpio->pin_table_length, (u16)(pin_index + bits));
726 for (i = pin_index; i < length; ++i) {
Qipeng Zhaa4811622015-04-10 06:25:10 +0800727 int pin = agpio->pin_table[i];
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200728 struct acpi_gpio_connection *conn;
729 struct gpio_desc *desc;
730 bool found;
731
Linus Walleij20ec3e32016-02-11 11:03:06 +0100732 pin = acpi_gpiochip_pin_to_gpio_offset(chip->gpiodev, pin);
qipeng.zha4de60972015-03-11 01:15:38 +0800733 if (pin < 0) {
734 status = AE_BAD_PARAMETER;
735 goto out;
736 }
737
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200738 mutex_lock(&achip->conn_lock);
739
740 found = false;
741 list_for_each_entry(conn, &achip->conns, node) {
Alexandre Courbote46cf322014-08-19 10:06:08 -0700742 if (conn->pin == pin) {
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200743 found = true;
Alexandre Courbote46cf322014-08-19 10:06:08 -0700744 desc = conn->desc;
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200745 break;
746 }
747 }
Mika Westerbergc103a102015-10-30 12:02:05 +0200748
749 /*
750 * The same GPIO can be shared between operation region and
751 * event but only if the access here is ACPI_READ. In that
752 * case we "borrow" the event GPIO instead.
753 */
754 if (!found && agpio->sharable == ACPI_SHARED &&
755 function == ACPI_READ) {
756 struct acpi_gpio_event *event;
757
758 list_for_each_entry(event, &achip->events, node) {
759 if (event->pin == pin) {
760 desc = event->desc;
761 found = true;
762 break;
763 }
764 }
765 }
766
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200767 if (!found) {
Alexandre Courbotabdc08a2014-08-19 10:06:09 -0700768 desc = gpiochip_request_own_desc(chip, pin,
769 "ACPI:OpRegion");
Alexandre Courbote46cf322014-08-19 10:06:08 -0700770 if (IS_ERR(desc)) {
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200771 status = AE_ERROR;
772 mutex_unlock(&achip->conn_lock);
773 goto out;
774 }
775
776 switch (agpio->io_restriction) {
777 case ACPI_IO_RESTRICT_INPUT:
778 gpiod_direction_input(desc);
779 break;
780 case ACPI_IO_RESTRICT_OUTPUT:
781 /*
782 * ACPI GPIO resources don't contain an
783 * initial value for the GPIO. Therefore we
784 * deduce that value from the pull field
785 * instead. If the pin is pulled up we
786 * assume default to be high, otherwise
787 * low.
788 */
789 gpiod_direction_output(desc, pull_up);
790 break;
791 default:
792 /*
793 * Assume that the BIOS has configured the
794 * direction and pull accordingly.
795 */
796 break;
797 }
798
799 conn = kzalloc(sizeof(*conn), GFP_KERNEL);
800 if (!conn) {
801 status = AE_NO_MEMORY;
802 gpiochip_free_own_desc(desc);
803 mutex_unlock(&achip->conn_lock);
804 goto out;
805 }
806
Alexandre Courbote46cf322014-08-19 10:06:08 -0700807 conn->pin = pin;
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200808 conn->desc = desc;
809 list_add_tail(&conn->node, &achip->conns);
810 }
811
812 mutex_unlock(&achip->conn_lock);
813
814 if (function == ACPI_WRITE)
Aaron Ludc62b562014-05-20 17:07:38 +0800815 gpiod_set_raw_value_cansleep(desc,
816 !!((1 << i) & *value));
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200817 else
Aaron Ludc62b562014-05-20 17:07:38 +0800818 *value |= (u64)gpiod_get_raw_value_cansleep(desc) << i;
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200819 }
820
821out:
822 ACPI_FREE(ares);
823 return status;
824}
825
826static void acpi_gpiochip_request_regions(struct acpi_gpio_chip *achip)
827{
828 struct gpio_chip *chip = achip->chip;
Linus Walleij58383c72015-11-04 09:56:26 +0100829 acpi_handle handle = ACPI_HANDLE(chip->parent);
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200830 acpi_status status;
831
832 INIT_LIST_HEAD(&achip->conns);
833 mutex_init(&achip->conn_lock);
834 status = acpi_install_address_space_handler(handle, ACPI_ADR_SPACE_GPIO,
835 acpi_gpio_adr_space_handler,
836 NULL, achip);
837 if (ACPI_FAILURE(status))
Linus Walleij58383c72015-11-04 09:56:26 +0100838 dev_err(chip->parent,
839 "Failed to install GPIO OpRegion handler\n");
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200840}
841
842static void acpi_gpiochip_free_regions(struct acpi_gpio_chip *achip)
843{
844 struct gpio_chip *chip = achip->chip;
Linus Walleij58383c72015-11-04 09:56:26 +0100845 acpi_handle handle = ACPI_HANDLE(chip->parent);
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200846 struct acpi_gpio_connection *conn, *tmp;
847 acpi_status status;
848
849 status = acpi_remove_address_space_handler(handle, ACPI_ADR_SPACE_GPIO,
850 acpi_gpio_adr_space_handler);
851 if (ACPI_FAILURE(status)) {
Linus Walleij58383c72015-11-04 09:56:26 +0100852 dev_err(chip->parent,
853 "Failed to remove GPIO OpRegion handler\n");
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200854 return;
855 }
856
857 list_for_each_entry_safe_reverse(conn, tmp, &achip->conns, node) {
858 gpiochip_free_own_desc(conn->desc);
859 list_del(&conn->node);
860 kfree(conn);
861 }
862}
863
Mika Westerberg664e3e52014-01-08 12:40:54 +0200864void acpi_gpiochip_add(struct gpio_chip *chip)
865{
Mika Westerbergaa92b6f2014-03-10 14:54:51 +0200866 struct acpi_gpio_chip *acpi_gpio;
867 acpi_handle handle;
868 acpi_status status;
869
Linus Walleij58383c72015-11-04 09:56:26 +0100870 if (!chip || !chip->parent)
Mika Westerberge9595f82014-03-31 15:16:49 +0300871 return;
872
Linus Walleij58383c72015-11-04 09:56:26 +0100873 handle = ACPI_HANDLE(chip->parent);
Mika Westerbergaa92b6f2014-03-10 14:54:51 +0200874 if (!handle)
875 return;
876
877 acpi_gpio = kzalloc(sizeof(*acpi_gpio), GFP_KERNEL);
878 if (!acpi_gpio) {
Linus Walleij58383c72015-11-04 09:56:26 +0100879 dev_err(chip->parent,
Mika Westerbergaa92b6f2014-03-10 14:54:51 +0200880 "Failed to allocate memory for ACPI GPIO chip\n");
881 return;
882 }
883
884 acpi_gpio->chip = chip;
Mika Westerbergc103a102015-10-30 12:02:05 +0200885 INIT_LIST_HEAD(&acpi_gpio->events);
Mika Westerbergaa92b6f2014-03-10 14:54:51 +0200886
887 status = acpi_attach_data(handle, acpi_gpio_chip_dh, acpi_gpio);
888 if (ACPI_FAILURE(status)) {
Linus Walleij58383c72015-11-04 09:56:26 +0100889 dev_err(chip->parent, "Failed to attach ACPI GPIO chip\n");
Mika Westerbergaa92b6f2014-03-10 14:54:51 +0200890 kfree(acpi_gpio);
891 return;
892 }
893
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200894 acpi_gpiochip_request_regions(acpi_gpio);
Rui Zhang3f86a632016-06-15 08:47:51 +0200895 acpi_walk_dep_device_list(handle);
Mika Westerberg664e3e52014-01-08 12:40:54 +0200896}
897
898void acpi_gpiochip_remove(struct gpio_chip *chip)
899{
Mika Westerbergaa92b6f2014-03-10 14:54:51 +0200900 struct acpi_gpio_chip *acpi_gpio;
901 acpi_handle handle;
902 acpi_status status;
903
Linus Walleij58383c72015-11-04 09:56:26 +0100904 if (!chip || !chip->parent)
Mika Westerberge9595f82014-03-31 15:16:49 +0300905 return;
906
Linus Walleij58383c72015-11-04 09:56:26 +0100907 handle = ACPI_HANDLE(chip->parent);
Mika Westerbergaa92b6f2014-03-10 14:54:51 +0200908 if (!handle)
909 return;
910
911 status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);
912 if (ACPI_FAILURE(status)) {
Linus Walleij58383c72015-11-04 09:56:26 +0100913 dev_warn(chip->parent, "Failed to retrieve ACPI GPIO chip\n");
Mika Westerbergaa92b6f2014-03-10 14:54:51 +0200914 return;
915 }
916
Mika Westerberg473ed7b2014-03-14 17:58:07 +0200917 acpi_gpiochip_free_regions(acpi_gpio);
Mika Westerbergaa92b6f2014-03-10 14:54:51 +0200918
919 acpi_detach_data(handle, acpi_gpio_chip_dh);
920 kfree(acpi_gpio);
Mika Westerberg664e3e52014-01-08 12:40:54 +0200921}
Rojhalat Ibrahim66858522015-02-11 17:27:58 +0100922
923static unsigned int acpi_gpio_package_count(const union acpi_object *obj)
924{
925 const union acpi_object *element = obj->package.elements;
926 const union acpi_object *end = element + obj->package.count;
927 unsigned int count = 0;
928
929 while (element < end) {
930 if (element->type == ACPI_TYPE_LOCAL_REFERENCE)
931 count++;
932
933 element++;
934 }
935 return count;
936}
937
938static int acpi_find_gpio_count(struct acpi_resource *ares, void *data)
939{
940 unsigned int *count = data;
941
942 if (ares->type == ACPI_RESOURCE_TYPE_GPIO)
943 *count += ares->data.gpio.pin_table_length;
944
945 return 1;
946}
947
948/**
949 * acpi_gpio_count - return the number of GPIOs associated with a
950 * device / function or -ENOENT if no GPIO has been
951 * assigned to the requested function.
952 * @dev: GPIO consumer, can be NULL for system-global GPIOs
953 * @con_id: function within the GPIO consumer
954 */
955int acpi_gpio_count(struct device *dev, const char *con_id)
956{
957 struct acpi_device *adev = ACPI_COMPANION(dev);
958 const union acpi_object *obj;
959 const struct acpi_gpio_mapping *gm;
960 int count = -ENOENT;
961 int ret;
962 char propname[32];
963 unsigned int i;
964
965 /* Try first from _DSD */
966 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
967 if (con_id && strcmp(con_id, "gpios"))
968 snprintf(propname, sizeof(propname), "%s-%s",
969 con_id, gpio_suffixes[i]);
970 else
971 snprintf(propname, sizeof(propname), "%s",
972 gpio_suffixes[i]);
973
974 ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_ANY,
975 &obj);
976 if (ret == 0) {
977 if (obj->type == ACPI_TYPE_LOCAL_REFERENCE)
978 count = 1;
979 else if (obj->type == ACPI_TYPE_PACKAGE)
980 count = acpi_gpio_package_count(obj);
981 } else if (adev->driver_gpios) {
982 for (gm = adev->driver_gpios; gm->name; gm++)
983 if (strcmp(propname, gm->name) == 0) {
984 count = gm->size;
985 break;
986 }
987 }
988 if (count >= 0)
989 break;
990 }
991
992 /* Then from plain _CRS GPIOs */
993 if (count < 0) {
994 struct list_head resource_list;
995 unsigned int crs_count = 0;
996
997 INIT_LIST_HEAD(&resource_list);
998 acpi_dev_get_resources(adev, &resource_list,
999 acpi_find_gpio_count, &crs_count);
1000 acpi_dev_free_resource_list(&resource_list);
1001 if (crs_count > 0)
1002 count = crs_count;
1003 }
1004 return count;
1005}
Dmitry Torokhov10cf4892015-11-11 11:45:30 -08001006
1007struct acpi_crs_lookup {
1008 struct list_head node;
1009 struct acpi_device *adev;
1010 const char *con_id;
1011};
1012
1013static DEFINE_MUTEX(acpi_crs_lookup_lock);
1014static LIST_HEAD(acpi_crs_lookup_list);
1015
1016bool acpi_can_fallback_to_crs(struct acpi_device *adev, const char *con_id)
1017{
1018 struct acpi_crs_lookup *l, *lookup = NULL;
1019
1020 /* Never allow fallback if the device has properties */
1021 if (adev->data.properties || adev->driver_gpios)
1022 return false;
1023
1024 mutex_lock(&acpi_crs_lookup_lock);
1025
1026 list_for_each_entry(l, &acpi_crs_lookup_list, node) {
1027 if (l->adev == adev) {
1028 lookup = l;
1029 break;
1030 }
1031 }
1032
1033 if (!lookup) {
1034 lookup = kmalloc(sizeof(*lookup), GFP_KERNEL);
1035 if (lookup) {
1036 lookup->adev = adev;
Ville Syrjälä7df89e92016-04-25 16:01:19 +03001037 lookup->con_id = kstrdup(con_id, GFP_KERNEL);
Dmitry Torokhov10cf4892015-11-11 11:45:30 -08001038 list_add_tail(&lookup->node, &acpi_crs_lookup_list);
1039 }
1040 }
1041
1042 mutex_unlock(&acpi_crs_lookup_lock);
1043
1044 return lookup &&
1045 ((!lookup->con_id && !con_id) ||
1046 (lookup->con_id && con_id &&
1047 strcmp(lookup->con_id, con_id) == 0));
1048}