Commit | Line | Data |
---|---|---|
dae5f0af | 1 | // SPDX-License-Identifier: GPL-2.0 |
e29482e8 MN |
2 | /* |
3 | * ACPI helpers for GPIO API | |
4 | * | |
5 | * Copyright (C) 2012, Intel Corporation | |
6 | * Authors: Mathias Nyman <mathias.nyman@linux.intel.com> | |
7 | * Mika Westerberg <mika.westerberg@linux.intel.com> | |
e29482e8 MN |
8 | */ |
9 | ||
380c7ba3 | 10 | #include <linux/acpi.h> |
61f7f7c8 | 11 | #include <linux/dmi.h> |
e29482e8 | 12 | #include <linux/errno.h> |
e29482e8 | 13 | #include <linux/export.h> |
0d1c28a4 | 14 | #include <linux/interrupt.h> |
380c7ba3 | 15 | #include <linux/irq.h> |
473ed7be | 16 | #include <linux/mutex.h> |
354567e6 | 17 | #include <linux/pinctrl/pinctrl.h> |
e29482e8 | 18 | |
380c7ba3 AS |
19 | #include <linux/gpio/consumer.h> |
20 | #include <linux/gpio/driver.h> | |
21 | #include <linux/gpio/machine.h> | |
22 | ||
5ccff852 | 23 | #include "gpiolib.h" |
77cb907a | 24 | #include "gpiolib-acpi.h" |
5ccff852 | 25 | |
61f7f7c8 HG |
26 | static int run_edge_events_on_boot = -1; |
27 | module_param(run_edge_events_on_boot, int, 0444); | |
28 | MODULE_PARM_DESC(run_edge_events_on_boot, | |
29 | "Run edge _AEI event-handlers at boot: 0=no, 1=yes, -1=auto"); | |
30 | ||
2ccb21f5 HG |
31 | static char *ignore_wake; |
32 | module_param(ignore_wake, charp, 0444); | |
33 | MODULE_PARM_DESC(ignore_wake, | |
34 | "controller@pin combos on which to ignore the ACPI wake flag " | |
35 | "ignore_wake=controller@pin[,controller@pin[,...]]"); | |
36 | ||
6b6af7bd ML |
37 | static char *ignore_interrupt; |
38 | module_param(ignore_interrupt, charp, 0444); | |
39 | MODULE_PARM_DESC(ignore_interrupt, | |
40 | "controller@pin combos on which to ignore interrupt " | |
41 | "ignore_interrupt=controller@pin[,controller@pin[,...]]"); | |
42 | ||
2ccb21f5 HG |
43 | struct acpi_gpiolib_dmi_quirk { |
44 | bool no_edge_events_on_boot; | |
45 | char *ignore_wake; | |
6b6af7bd | 46 | char *ignore_interrupt; |
2ccb21f5 | 47 | }; |
aa23ca3d | 48 | |
e59f5e08 HG |
49 | /** |
50 | * struct acpi_gpio_event - ACPI GPIO event handler data | |
51 | * | |
52 | * @node: list-entry of the events list of the struct acpi_gpio_chip | |
53 | * @handle: handle of ACPI method to execute when the IRQ triggers | |
85edcd01 AS |
54 | * @handler: handler function to pass to request_irq() when requesting the IRQ |
55 | * @pin: GPIO pin number on the struct gpio_chip | |
56 | * @irq: Linux IRQ number for the event, for request_irq() / free_irq() | |
57 | * @irqflags: flags to pass to request_irq() when requesting the IRQ | |
e59f5e08 | 58 | * @irq_is_wake: If the ACPI flags indicate the IRQ is a wakeup source |
85edcd01 AS |
59 | * @irq_requested:True if request_irq() has been done |
60 | * @desc: struct gpio_desc for the GPIO pin for this event | |
e59f5e08 | 61 | */ |
4b01a14b | 62 | struct acpi_gpio_event { |
7fc7acb9 | 63 | struct list_head node; |
4b01a14b | 64 | acpi_handle handle; |
e59f5e08 | 65 | irq_handler_t handler; |
7fc7acb9 RW |
66 | unsigned int pin; |
67 | unsigned int irq; | |
e59f5e08 HG |
68 | unsigned long irqflags; |
69 | bool irq_is_wake; | |
70 | bool irq_requested; | |
e46cf32c | 71 | struct gpio_desc *desc; |
7fc7acb9 RW |
72 | }; |
73 | ||
473ed7be MW |
74 | struct acpi_gpio_connection { |
75 | struct list_head node; | |
e46cf32c | 76 | unsigned int pin; |
473ed7be MW |
77 | struct gpio_desc *desc; |
78 | }; | |
79 | ||
aa92b6f6 | 80 | struct acpi_gpio_chip { |
473ed7be MW |
81 | /* |
82 | * ACPICA requires that the first field of the context parameter | |
83 | * passed to acpi_install_address_space_handler() is large enough | |
84 | * to hold struct acpi_connection_info. | |
85 | */ | |
86 | struct acpi_connection_info conn_info; | |
87 | struct list_head conns; | |
88 | struct mutex conn_lock; | |
aa92b6f6 | 89 | struct gpio_chip *chip; |
4b01a14b | 90 | struct list_head events; |
78d3a92e | 91 | struct list_head deferred_req_irqs_list_entry; |
aa92b6f6 MW |
92 | }; |
93 | ||
b7452d67 DT |
94 | /** |
95 | * struct acpi_gpio_info - ACPI GPIO specific information | |
96 | * @adev: reference to ACPI device which consumes GPIO resource | |
97 | * @flags: GPIO initialization flags | |
98 | * @gpioint: if %true this GPIO is of type GpioInt otherwise type is GpioIo | |
99 | * @pin_config: pin bias as provided by ACPI | |
100 | * @polarity: interrupt polarity as provided by ACPI | |
101 | * @triggering: triggering type as provided by ACPI | |
102 | * @wake_capable: wake capability as provided by ACPI | |
103 | * @debounce: debounce timeout as provided by ACPI | |
104 | * @quirks: Linux specific quirks as provided by struct acpi_gpio_mapping | |
105 | */ | |
106 | struct acpi_gpio_info { | |
107 | struct acpi_device *adev; | |
108 | enum gpiod_flags flags; | |
109 | bool gpioint; | |
110 | int pin_config; | |
111 | int polarity; | |
112 | int triggering; | |
113 | bool wake_capable; | |
114 | unsigned int debounce; | |
115 | unsigned int quirks; | |
116 | }; | |
117 | ||
78d3a92e | 118 | /* |
85edcd01 | 119 | * For GPIO chips which call acpi_gpiochip_request_interrupts() before late_init |
e59f5e08 | 120 | * (so builtin drivers) we register the ACPI GpioInt IRQ handlers from a |
85edcd01 AS |
121 | * late_initcall_sync() handler, so that other builtin drivers can register their |
122 | * OpRegions before the event handlers can run. This list contains GPIO chips | |
e59f5e08 | 123 | * for which the acpi_gpiochip_request_irqs() call has been deferred. |
78d3a92e HG |
124 | */ |
125 | static DEFINE_MUTEX(acpi_gpio_deferred_req_irqs_lock); | |
126 | static LIST_HEAD(acpi_gpio_deferred_req_irqs_list); | |
127 | static bool acpi_gpio_deferred_req_irqs_done; | |
ca876c74 | 128 | |
faf6efd2 | 129 | static int acpi_gpiochip_find(struct gpio_chip *gc, const void *data) |
e29482e8 | 130 | { |
adbc49a5 DL |
131 | /* First check the actual GPIO device */ |
132 | if (device_match_acpi_handle(&gc->gpiodev->dev, data)) | |
133 | return true; | |
134 | ||
135 | /* | |
136 | * When the ACPI device is artificially split to the banks of GPIOs, | |
137 | * where each of them is represented by a separate GPIO device, | |
138 | * the firmware node of the physical device may not be shared among | |
139 | * the banks as they may require different values for the same property, | |
140 | * e.g., number of GPIOs in a certain bank. In such case the ACPI handle | |
141 | * of a GPIO device is NULL and can not be used. Hence we have to check | |
142 | * the parent device to be sure that there is no match before bailing | |
143 | * out. | |
144 | */ | |
145 | if (gc->parent) | |
146 | return device_match_acpi_handle(gc->parent, data); | |
147 | ||
148 | return false; | |
e29482e8 MN |
149 | } |
150 | ||
151 | /** | |
936e15dd | 152 | * acpi_get_gpiod() - Translate ACPI GPIO pin to GPIO descriptor usable with GPIO API |
e29482e8 MN |
153 | * @path: ACPI GPIO controller full path name, (e.g. "\\_SB.GPO1") |
154 | * @pin: ACPI GPIO pin number (0-based, controller-relative) | |
155 | * | |
f35bbf61 MW |
156 | * Return: GPIO descriptor to use with Linux generic GPIO API, or ERR_PTR |
157 | * error value. Specifically returns %-EPROBE_DEFER if the referenced GPIO | |
85edcd01 | 158 | * controller does not have GPIO chip registered at the moment. This is to |
f35bbf61 | 159 | * support probe deferral. |
e29482e8 | 160 | */ |
0c2cae09 | 161 | static struct gpio_desc *acpi_get_gpiod(char *path, unsigned int pin) |
e29482e8 | 162 | { |
e29482e8 MN |
163 | acpi_handle handle; |
164 | acpi_status status; | |
165 | ||
166 | status = acpi_get_handle(NULL, path, &handle); | |
167 | if (ACPI_FAILURE(status)) | |
936e15dd | 168 | return ERR_PTR(-ENODEV); |
e29482e8 | 169 | |
3c9d5431 BG |
170 | struct gpio_device *gdev __free(gpio_device_put) = |
171 | gpio_device_find(handle, acpi_gpiochip_find); | |
172 | if (!gdev) | |
f35bbf61 | 173 | return ERR_PTR(-EPROBE_DEFER); |
e29482e8 | 174 | |
3c9d5431 BG |
175 | /* |
176 | * FIXME: keep track of the reference to the GPIO device somehow | |
177 | * instead of putting it here. | |
178 | */ | |
179 | return gpio_device_get_desc(gdev, pin); | |
43582f29 | 180 | } |
43582f29 | 181 | |
0d1c28a4 MN |
182 | static irqreturn_t acpi_gpio_irq_handler(int irq, void *data) |
183 | { | |
6072b9dc | 184 | struct acpi_gpio_event *event = data; |
0d1c28a4 | 185 | |
6072b9dc | 186 | acpi_evaluate_object(event->handle, NULL, NULL, NULL); |
0d1c28a4 MN |
187 | |
188 | return IRQ_HANDLED; | |
189 | } | |
190 | ||
7fc7acb9 RW |
191 | static irqreturn_t acpi_gpio_irq_handler_evt(int irq, void *data) |
192 | { | |
4b01a14b | 193 | struct acpi_gpio_event *event = data; |
7fc7acb9 | 194 | |
4b01a14b | 195 | acpi_execute_simple_method(event->handle, NULL, event->pin); |
7fc7acb9 RW |
196 | |
197 | return IRQ_HANDLED; | |
198 | } | |
199 | ||
aa92b6f6 | 200 | static void acpi_gpio_chip_dh(acpi_handle handle, void *data) |
7fc7acb9 RW |
201 | { |
202 | /* The address of this function is used as a key. */ | |
203 | } | |
204 | ||
25e3ef89 AS |
205 | bool acpi_gpio_get_irq_resource(struct acpi_resource *ares, |
206 | struct acpi_resource_gpio **agpio) | |
207 | { | |
208 | struct acpi_resource_gpio *gpio; | |
209 | ||
210 | if (ares->type != ACPI_RESOURCE_TYPE_GPIO) | |
211 | return false; | |
212 | ||
213 | gpio = &ares->data.gpio; | |
214 | if (gpio->connection_type != ACPI_RESOURCE_GPIO_TYPE_INT) | |
215 | return false; | |
216 | ||
217 | *agpio = gpio; | |
218 | return true; | |
219 | } | |
220 | EXPORT_SYMBOL_GPL(acpi_gpio_get_irq_resource); | |
221 | ||
043d7f09 DS |
222 | /** |
223 | * acpi_gpio_get_io_resource - Fetch details of an ACPI resource if it is a GPIO | |
224 | * I/O resource or return False if not. | |
225 | * @ares: Pointer to the ACPI resource to fetch | |
226 | * @agpio: Pointer to a &struct acpi_resource_gpio to store the output pointer | |
227 | */ | |
228 | bool acpi_gpio_get_io_resource(struct acpi_resource *ares, | |
229 | struct acpi_resource_gpio **agpio) | |
230 | { | |
231 | struct acpi_resource_gpio *gpio; | |
232 | ||
233 | if (ares->type != ACPI_RESOURCE_TYPE_GPIO) | |
234 | return false; | |
235 | ||
236 | gpio = &ares->data.gpio; | |
237 | if (gpio->connection_type != ACPI_RESOURCE_GPIO_TYPE_IO) | |
238 | return false; | |
239 | ||
240 | *agpio = gpio; | |
241 | return true; | |
242 | } | |
243 | EXPORT_SYMBOL_GPL(acpi_gpio_get_io_resource); | |
244 | ||
e59f5e08 HG |
245 | static void acpi_gpiochip_request_irq(struct acpi_gpio_chip *acpi_gpio, |
246 | struct acpi_gpio_event *event) | |
247 | { | |
be3dc15f | 248 | struct device *parent = acpi_gpio->chip->parent; |
e59f5e08 HG |
249 | int ret, value; |
250 | ||
251 | ret = request_threaded_irq(event->irq, NULL, event->handler, | |
6e5d5791 | 252 | event->irqflags | IRQF_ONESHOT, "ACPI:Event", event); |
e59f5e08 | 253 | if (ret) { |
be3dc15f | 254 | dev_err(parent, "Failed to setup interrupt handler for %d\n", event->irq); |
e59f5e08 HG |
255 | return; |
256 | } | |
257 | ||
258 | if (event->irq_is_wake) | |
259 | enable_irq_wake(event->irq); | |
260 | ||
261 | event->irq_requested = true; | |
262 | ||
263 | /* Make sure we trigger the initial state of edge-triggered IRQs */ | |
61f7f7c8 HG |
264 | if (run_edge_events_on_boot && |
265 | (event->irqflags & (IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING))) { | |
266 | value = gpiod_get_raw_value_cansleep(event->desc); | |
267 | if (((event->irqflags & IRQF_TRIGGER_RISING) && value == 1) || | |
268 | ((event->irqflags & IRQF_TRIGGER_FALLING) && value == 0)) | |
269 | event->handler(event->irq, event); | |
270 | } | |
e59f5e08 HG |
271 | } |
272 | ||
273 | static void acpi_gpiochip_request_irqs(struct acpi_gpio_chip *acpi_gpio) | |
274 | { | |
275 | struct acpi_gpio_event *event; | |
276 | ||
277 | list_for_each_entry(event, &acpi_gpio->events, node) | |
278 | acpi_gpiochip_request_irq(acpi_gpio, event); | |
279 | } | |
280 | ||
1a81f191 | 281 | static enum gpiod_flags |
56f7058a | 282 | acpi_gpio_to_gpiod_flags(const struct acpi_resource_gpio *agpio, int polarity) |
1a81f191 | 283 | { |
bca40480 AS |
284 | /* GpioInt() implies input configuration */ |
285 | if (agpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT) | |
286 | return GPIOD_IN; | |
287 | ||
1a81f191 AS |
288 | switch (agpio->io_restriction) { |
289 | case ACPI_IO_RESTRICT_INPUT: | |
290 | return GPIOD_IN; | |
291 | case ACPI_IO_RESTRICT_OUTPUT: | |
292 | /* | |
293 | * ACPI GPIO resources don't contain an initial value for the | |
294 | * GPIO. Therefore we deduce that value from the pull field | |
56f7058a VLS |
295 | * and the polarity instead. If the pin is pulled up we assume |
296 | * default to be high, if it is pulled down we assume default | |
297 | * to be low, otherwise we leave pin untouched. For active low | |
298 | * polarity values will be switched. See also | |
299 | * Documentation/firmware-guide/acpi/gpio-properties.rst. | |
1a81f191 AS |
300 | */ |
301 | switch (agpio->pin_config) { | |
302 | case ACPI_PIN_CONFIG_PULLUP: | |
56f7058a | 303 | return polarity == GPIO_ACTIVE_LOW ? GPIOD_OUT_LOW : GPIOD_OUT_HIGH; |
1a81f191 | 304 | case ACPI_PIN_CONFIG_PULLDOWN: |
56f7058a | 305 | return polarity == GPIO_ACTIVE_LOW ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW; |
1a81f191 AS |
306 | default: |
307 | break; | |
308 | } | |
40b37008 | 309 | break; |
1a81f191 AS |
310 | default: |
311 | break; | |
312 | } | |
313 | ||
314 | /* | |
315 | * Assume that the BIOS has configured the direction and pull | |
316 | * accordingly. | |
317 | */ | |
318 | return GPIOD_ASIS; | |
319 | } | |
320 | ||
2e2b496c AS |
321 | static struct gpio_desc *acpi_request_own_gpiod(struct gpio_chip *chip, |
322 | struct acpi_resource_gpio *agpio, | |
323 | unsigned int index, | |
324 | const char *label) | |
325 | { | |
326 | int polarity = GPIO_ACTIVE_HIGH; | |
327 | enum gpiod_flags flags = acpi_gpio_to_gpiod_flags(agpio, polarity); | |
328 | unsigned int pin = agpio->pin_table[index]; | |
329 | struct gpio_desc *desc; | |
330 | int ret; | |
331 | ||
332 | desc = gpiochip_request_own_desc(chip, pin, label, polarity, flags); | |
333 | if (IS_ERR(desc)) | |
334 | return desc; | |
335 | ||
660c619b AS |
336 | /* ACPI uses hundredths of milliseconds units */ |
337 | ret = gpio_set_debounce_timeout(desc, agpio->debounce_timeout * 10); | |
2e2b496c | 338 | if (ret) |
cef0d022 HG |
339 | dev_warn(chip->parent, |
340 | "Failed to set debounce-timeout for pin 0x%04X, err %d\n", | |
341 | pin, ret); | |
2e2b496c | 342 | |
cef0d022 | 343 | return desc; |
2e2b496c AS |
344 | } |
345 | ||
6b6af7bd ML |
346 | static bool acpi_gpio_in_ignore_list(const char *ignore_list, const char *controller_in, |
347 | unsigned int pin_in) | |
2ccb21f5 HG |
348 | { |
349 | const char *controller, *pin_str; | |
0c2cae09 | 350 | unsigned int pin; |
2ccb21f5 | 351 | char *endp; |
0c2cae09 | 352 | int len; |
2ccb21f5 | 353 | |
6b6af7bd | 354 | controller = ignore_list; |
2ccb21f5 HG |
355 | while (controller) { |
356 | pin_str = strchr(controller, '@'); | |
357 | if (!pin_str) | |
358 | goto err; | |
359 | ||
360 | len = pin_str - controller; | |
361 | if (len == strlen(controller_in) && | |
362 | strncmp(controller, controller_in, len) == 0) { | |
363 | pin = simple_strtoul(pin_str + 1, &endp, 10); | |
364 | if (*endp != 0 && *endp != ',') | |
365 | goto err; | |
366 | ||
367 | if (pin == pin_in) | |
368 | return true; | |
369 | } | |
370 | ||
371 | controller = strchr(controller, ','); | |
372 | if (controller) | |
373 | controller++; | |
374 | } | |
375 | ||
376 | return false; | |
377 | err: | |
6b6af7bd | 378 | pr_err_once("Error: Invalid value for gpiolib_acpi.ignore_...: %s\n", ignore_list); |
2ccb21f5 HG |
379 | return false; |
380 | } | |
381 | ||
382 | static bool acpi_gpio_irq_is_wake(struct device *parent, | |
0e3b175f | 383 | const struct acpi_resource_gpio *agpio) |
2ccb21f5 | 384 | { |
0c2cae09 | 385 | unsigned int pin = agpio->pin_table[0]; |
2ccb21f5 HG |
386 | |
387 | if (agpio->wake_capable != ACPI_WAKE_CAPABLE) | |
388 | return false; | |
389 | ||
6b6af7bd | 390 | if (acpi_gpio_in_ignore_list(ignore_wake, dev_name(parent), pin)) { |
0c2cae09 | 391 | dev_info(parent, "Ignoring wakeup on pin %u\n", pin); |
2ccb21f5 HG |
392 | return false; |
393 | } | |
394 | ||
395 | return true; | |
396 | } | |
397 | ||
d4fc46f1 | 398 | /* Always returns AE_OK so that we keep looping over the resources */ |
e59f5e08 HG |
399 | static acpi_status acpi_gpiochip_alloc_event(struct acpi_resource *ares, |
400 | void *context) | |
0d1c28a4 | 401 | { |
6072b9dc | 402 | struct acpi_gpio_chip *acpi_gpio = context; |
aa92b6f6 | 403 | struct gpio_chip *chip = acpi_gpio->chip; |
6072b9dc | 404 | struct acpi_resource_gpio *agpio; |
7fc7acb9 | 405 | acpi_handle handle, evt_handle; |
6072b9dc MW |
406 | struct acpi_gpio_event *event; |
407 | irq_handler_t handler = NULL; | |
408 | struct gpio_desc *desc; | |
0c2cae09 AS |
409 | unsigned int pin; |
410 | int ret, irq; | |
0d1c28a4 | 411 | |
25e3ef89 | 412 | if (!acpi_gpio_get_irq_resource(ares, &agpio)) |
6072b9dc | 413 | return AE_OK; |
0d1c28a4 | 414 | |
58383c78 | 415 | handle = ACPI_HANDLE(chip->parent); |
6072b9dc MW |
416 | pin = agpio->pin_table[0]; |
417 | ||
418 | if (pin <= 255) { | |
213d266e LT |
419 | char ev_name[8]; |
420 | sprintf(ev_name, "_%c%02X", | |
6072b9dc MW |
421 | agpio->triggering == ACPI_EDGE_SENSITIVE ? 'E' : 'L', |
422 | pin); | |
423 | if (ACPI_SUCCESS(acpi_get_handle(handle, ev_name, &evt_handle))) | |
424 | handler = acpi_gpio_irq_handler; | |
425 | } | |
426 | if (!handler) { | |
427 | if (ACPI_SUCCESS(acpi_get_handle(handle, "_EVT", &evt_handle))) | |
428 | handler = acpi_gpio_irq_handler_evt; | |
429 | } | |
430 | if (!handler) | |
c06632ea | 431 | return AE_OK; |
0d1c28a4 | 432 | |
5fb36a8c HG |
433 | if (acpi_gpio_in_ignore_list(ignore_interrupt, dev_name(chip->parent), pin)) { |
434 | dev_info(chip->parent, "Ignoring interrupt on pin %u\n", pin); | |
435 | return AE_OK; | |
436 | } | |
437 | ||
2e2b496c | 438 | desc = acpi_request_own_gpiod(chip, agpio, 0, "ACPI:Event"); |
6072b9dc | 439 | if (IS_ERR(desc)) { |
3f86a7e0 HG |
440 | dev_err(chip->parent, |
441 | "Failed to request GPIO for pin 0x%04X, err %ld\n", | |
442 | pin, PTR_ERR(desc)); | |
d4fc46f1 | 443 | return AE_OK; |
6072b9dc | 444 | } |
0d1c28a4 | 445 | |
e3a2e878 | 446 | ret = gpiochip_lock_as_irq(chip, pin); |
6072b9dc | 447 | if (ret) { |
3f86a7e0 HG |
448 | dev_err(chip->parent, |
449 | "Failed to lock GPIO pin 0x%04X as interrupt, err %d\n", | |
450 | pin, ret); | |
6072b9dc MW |
451 | goto fail_free_desc; |
452 | } | |
0d1c28a4 | 453 | |
6072b9dc MW |
454 | irq = gpiod_to_irq(desc); |
455 | if (irq < 0) { | |
3f86a7e0 HG |
456 | dev_err(chip->parent, |
457 | "Failed to translate GPIO pin 0x%04X to IRQ, err %d\n", | |
458 | pin, irq); | |
6072b9dc MW |
459 | goto fail_unlock_irq; |
460 | } | |
7fc7acb9 | 461 | |
e59f5e08 HG |
462 | event = kzalloc(sizeof(*event), GFP_KERNEL); |
463 | if (!event) | |
464 | goto fail_unlock_irq; | |
465 | ||
466 | event->irqflags = IRQF_ONESHOT; | |
6072b9dc MW |
467 | if (agpio->triggering == ACPI_LEVEL_SENSITIVE) { |
468 | if (agpio->polarity == ACPI_ACTIVE_HIGH) | |
e59f5e08 | 469 | event->irqflags |= IRQF_TRIGGER_HIGH; |
6072b9dc | 470 | else |
e59f5e08 | 471 | event->irqflags |= IRQF_TRIGGER_LOW; |
6072b9dc MW |
472 | } else { |
473 | switch (agpio->polarity) { | |
474 | case ACPI_ACTIVE_HIGH: | |
e59f5e08 | 475 | event->irqflags |= IRQF_TRIGGER_RISING; |
6072b9dc MW |
476 | break; |
477 | case ACPI_ACTIVE_LOW: | |
e59f5e08 | 478 | event->irqflags |= IRQF_TRIGGER_FALLING; |
6072b9dc MW |
479 | break; |
480 | default: | |
e59f5e08 HG |
481 | event->irqflags |= IRQF_TRIGGER_RISING | |
482 | IRQF_TRIGGER_FALLING; | |
6072b9dc | 483 | break; |
7fc7acb9 | 484 | } |
6072b9dc | 485 | } |
aa92b6f6 | 486 | |
6072b9dc | 487 | event->handle = evt_handle; |
e59f5e08 | 488 | event->handler = handler; |
6072b9dc | 489 | event->irq = irq; |
2ccb21f5 | 490 | event->irq_is_wake = acpi_gpio_irq_is_wake(chip->parent, agpio); |
6072b9dc | 491 | event->pin = pin; |
e46cf32c | 492 | event->desc = desc; |
7fc7acb9 | 493 | |
6072b9dc | 494 | list_add_tail(&event->node, &acpi_gpio->events); |
ca876c74 | 495 | |
6072b9dc MW |
496 | return AE_OK; |
497 | ||
6072b9dc | 498 | fail_unlock_irq: |
e3a2e878 | 499 | gpiochip_unlock_as_irq(chip, pin); |
6072b9dc MW |
500 | fail_free_desc: |
501 | gpiochip_free_own_desc(desc); | |
502 | ||
d4fc46f1 | 503 | return AE_OK; |
0d1c28a4 | 504 | } |
7fc7acb9 | 505 | |
70b53411 | 506 | /** |
6072b9dc | 507 | * acpi_gpiochip_request_interrupts() - Register isr for gpio chip ACPI events |
afa82fab | 508 | * @chip: GPIO chip |
70b53411 | 509 | * |
6072b9dc MW |
510 | * ACPI5 platforms can use GPIO signaled ACPI events. These GPIO interrupts are |
511 | * handled by ACPI event methods which need to be called from the GPIO | |
85edcd01 AS |
512 | * chip's interrupt handler. acpi_gpiochip_request_interrupts() finds out which |
513 | * GPIO pins have ACPI event methods and assigns interrupt handlers that calls | |
514 | * the ACPI event methods for those pins. | |
6072b9dc | 515 | */ |
afa82fab | 516 | void acpi_gpiochip_request_interrupts(struct gpio_chip *chip) |
6072b9dc | 517 | { |
afa82fab MW |
518 | struct acpi_gpio_chip *acpi_gpio; |
519 | acpi_handle handle; | |
520 | acpi_status status; | |
78d3a92e | 521 | bool defer; |
afa82fab | 522 | |
58383c78 | 523 | if (!chip->parent || !chip->to_irq) |
afa82fab | 524 | return; |
6072b9dc | 525 | |
58383c78 | 526 | handle = ACPI_HANDLE(chip->parent); |
afa82fab MW |
527 | if (!handle) |
528 | return; | |
529 | ||
530 | status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio); | |
531 | if (ACPI_FAILURE(status)) | |
6072b9dc MW |
532 | return; |
533 | ||
5adc4093 HG |
534 | if (acpi_quirk_skip_gpio_event_handlers()) |
535 | return; | |
536 | ||
eac001bf | 537 | acpi_walk_resources(handle, METHOD_NAME__AEI, |
e59f5e08 HG |
538 | acpi_gpiochip_alloc_event, acpi_gpio); |
539 | ||
78d3a92e HG |
540 | mutex_lock(&acpi_gpio_deferred_req_irqs_lock); |
541 | defer = !acpi_gpio_deferred_req_irqs_done; | |
542 | if (defer) | |
543 | list_add(&acpi_gpio->deferred_req_irqs_list_entry, | |
544 | &acpi_gpio_deferred_req_irqs_list); | |
545 | mutex_unlock(&acpi_gpio_deferred_req_irqs_lock); | |
546 | ||
547 | if (defer) | |
548 | return; | |
549 | ||
e59f5e08 | 550 | acpi_gpiochip_request_irqs(acpi_gpio); |
6072b9dc | 551 | } |
2b528fff | 552 | EXPORT_SYMBOL_GPL(acpi_gpiochip_request_interrupts); |
6072b9dc MW |
553 | |
554 | /** | |
555 | * acpi_gpiochip_free_interrupts() - Free GPIO ACPI event interrupts. | |
afa82fab | 556 | * @chip: GPIO chip |
70b53411 | 557 | * |
6072b9dc MW |
558 | * Free interrupts associated with GPIO ACPI event method for the given |
559 | * GPIO chip. | |
70b53411 | 560 | */ |
afa82fab | 561 | void acpi_gpiochip_free_interrupts(struct gpio_chip *chip) |
70b53411 | 562 | { |
afa82fab | 563 | struct acpi_gpio_chip *acpi_gpio; |
4b01a14b | 564 | struct acpi_gpio_event *event, *ep; |
afa82fab MW |
565 | acpi_handle handle; |
566 | acpi_status status; | |
567 | ||
58383c78 | 568 | if (!chip->parent || !chip->to_irq) |
afa82fab | 569 | return; |
70b53411 | 570 | |
58383c78 | 571 | handle = ACPI_HANDLE(chip->parent); |
afa82fab MW |
572 | if (!handle) |
573 | return; | |
574 | ||
575 | status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio); | |
576 | if (ACPI_FAILURE(status)) | |
70b53411 MW |
577 | return; |
578 | ||
78d3a92e HG |
579 | mutex_lock(&acpi_gpio_deferred_req_irqs_lock); |
580 | if (!list_empty(&acpi_gpio->deferred_req_irqs_list_entry)) | |
581 | list_del_init(&acpi_gpio->deferred_req_irqs_list_entry); | |
582 | mutex_unlock(&acpi_gpio_deferred_req_irqs_lock); | |
583 | ||
4b01a14b | 584 | list_for_each_entry_safe_reverse(event, ep, &acpi_gpio->events, node) { |
e59f5e08 HG |
585 | if (event->irq_requested) { |
586 | if (event->irq_is_wake) | |
587 | disable_irq_wake(event->irq); | |
588 | ||
589 | free_irq(event->irq, event); | |
590 | } | |
8a146fbe | 591 | |
e3a2e878 | 592 | gpiochip_unlock_as_irq(chip, event->pin); |
86252329 | 593 | gpiochip_free_own_desc(event->desc); |
4b01a14b MW |
594 | list_del(&event->node); |
595 | kfree(event); | |
70b53411 | 596 | } |
70b53411 | 597 | } |
2b528fff | 598 | EXPORT_SYMBOL_GPL(acpi_gpiochip_free_interrupts); |
70b53411 | 599 | |
f028d524 RW |
600 | int acpi_dev_add_driver_gpios(struct acpi_device *adev, |
601 | const struct acpi_gpio_mapping *gpios) | |
602 | { | |
603 | if (adev && gpios) { | |
604 | adev->driver_gpios = gpios; | |
605 | return 0; | |
606 | } | |
607 | return -EINVAL; | |
608 | } | |
609 | EXPORT_SYMBOL_GPL(acpi_dev_add_driver_gpios); | |
610 | ||
2838bf94 AS |
611 | void acpi_dev_remove_driver_gpios(struct acpi_device *adev) |
612 | { | |
613 | if (adev) | |
614 | adev->driver_gpios = NULL; | |
615 | } | |
616 | EXPORT_SYMBOL_GPL(acpi_dev_remove_driver_gpios); | |
617 | ||
2ff64a84 | 618 | static void acpi_dev_release_driver_gpios(void *adev) |
85c73d50 | 619 | { |
2ff64a84 | 620 | acpi_dev_remove_driver_gpios(adev); |
85c73d50 AS |
621 | } |
622 | ||
623 | int devm_acpi_dev_add_driver_gpios(struct device *dev, | |
624 | const struct acpi_gpio_mapping *gpios) | |
625 | { | |
2ff64a84 | 626 | struct acpi_device *adev = ACPI_COMPANION(dev); |
85c73d50 AS |
627 | int ret; |
628 | ||
2ff64a84 AS |
629 | ret = acpi_dev_add_driver_gpios(adev, gpios); |
630 | if (ret) | |
85c73d50 | 631 | return ret; |
2ff64a84 AS |
632 | |
633 | return devm_add_action_or_reset(dev, acpi_dev_release_driver_gpios, adev); | |
85c73d50 AS |
634 | } |
635 | EXPORT_SYMBOL_GPL(devm_acpi_dev_add_driver_gpios); | |
636 | ||
f028d524 RW |
637 | static bool acpi_get_driver_gpio_data(struct acpi_device *adev, |
638 | const char *name, int index, | |
977d5ad3 | 639 | struct fwnode_reference_args *args, |
ce0929d2 | 640 | unsigned int *quirks) |
f028d524 RW |
641 | { |
642 | const struct acpi_gpio_mapping *gm; | |
643 | ||
af3b462a | 644 | if (!adev || !adev->driver_gpios) |
f028d524 RW |
645 | return false; |
646 | ||
647 | for (gm = adev->driver_gpios; gm->name; gm++) | |
648 | if (!strcmp(name, gm->name) && gm->data && index < gm->size) { | |
649 | const struct acpi_gpio_params *par = gm->data + index; | |
650 | ||
977d5ad3 | 651 | args->fwnode = acpi_fwnode_handle(adev); |
f028d524 RW |
652 | args->args[0] = par->crs_entry_index; |
653 | args->args[1] = par->line_index; | |
654 | args->args[2] = par->active_low; | |
655 | args->nargs = 3; | |
ce0929d2 AS |
656 | |
657 | *quirks = gm->quirks; | |
f028d524 RW |
658 | return true; |
659 | } | |
660 | ||
661 | return false; | |
662 | } | |
663 | ||
5c34b6c1 AS |
664 | static int |
665 | __acpi_gpio_update_gpiod_flags(enum gpiod_flags *flags, enum gpiod_flags update) | |
a31f5c3a | 666 | { |
72893f0c HG |
667 | const enum gpiod_flags mask = |
668 | GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT | | |
669 | GPIOD_FLAGS_BIT_DIR_VAL; | |
a31f5c3a AS |
670 | int ret = 0; |
671 | ||
672 | /* | |
673 | * Check if the BIOS has IoRestriction with explicitly set direction | |
674 | * and update @flags accordingly. Otherwise use whatever caller asked | |
675 | * for. | |
676 | */ | |
677 | if (update & GPIOD_FLAGS_BIT_DIR_SET) { | |
678 | enum gpiod_flags diff = *flags ^ update; | |
679 | ||
680 | /* | |
681 | * Check if caller supplied incompatible GPIO initialization | |
682 | * flags. | |
683 | * | |
684 | * Return %-EINVAL to notify that firmware has different | |
685 | * settings and we are going to use them. | |
686 | */ | |
687 | if (((*flags & GPIOD_FLAGS_BIT_DIR_SET) && (diff & GPIOD_FLAGS_BIT_DIR_OUT)) || | |
688 | ((*flags & GPIOD_FLAGS_BIT_DIR_OUT) && (diff & GPIOD_FLAGS_BIT_DIR_VAL))) | |
689 | ret = -EINVAL; | |
72893f0c | 690 | *flags = (*flags & ~mask) | (update & mask); |
a31f5c3a AS |
691 | } |
692 | return ret; | |
693 | } | |
694 | ||
b7452d67 DT |
695 | static int acpi_gpio_update_gpiod_flags(enum gpiod_flags *flags, |
696 | struct acpi_gpio_info *info) | |
5c34b6c1 AS |
697 | { |
698 | struct device *dev = &info->adev->dev; | |
1b2ca32a | 699 | enum gpiod_flags old = *flags; |
5c34b6c1 AS |
700 | int ret; |
701 | ||
1b2ca32a AS |
702 | ret = __acpi_gpio_update_gpiod_flags(&old, info->flags); |
703 | if (info->quirks & ACPI_GPIO_QUIRK_NO_IO_RESTRICTION) { | |
704 | if (ret) | |
705 | dev_warn(dev, FW_BUG "GPIO not in correct mode, fixing\n"); | |
706 | } else { | |
707 | if (ret) | |
708 | dev_dbg(dev, "Override GPIO initialization flags\n"); | |
709 | *flags = old; | |
710 | } | |
5c34b6c1 AS |
711 | |
712 | return ret; | |
713 | } | |
714 | ||
b7452d67 DT |
715 | static int acpi_gpio_update_gpiod_lookup_flags(unsigned long *lookupflags, |
716 | struct acpi_gpio_info *info) | |
606be344 | 717 | { |
2d3b6db1 AS |
718 | switch (info->pin_config) { |
719 | case ACPI_PIN_CONFIG_PULLUP: | |
720 | *lookupflags |= GPIO_PULL_UP; | |
721 | break; | |
722 | case ACPI_PIN_CONFIG_PULLDOWN: | |
723 | *lookupflags |= GPIO_PULL_DOWN; | |
724 | break; | |
6fd03f02 NS |
725 | case ACPI_PIN_CONFIG_NOPULL: |
726 | *lookupflags |= GPIO_PULL_DISABLE; | |
727 | break; | |
2d3b6db1 AS |
728 | default: |
729 | break; | |
730 | } | |
731 | ||
606be344 AS |
732 | if (info->polarity == GPIO_ACTIVE_LOW) |
733 | *lookupflags |= GPIO_ACTIVE_LOW; | |
734 | ||
735 | return 0; | |
736 | } | |
737 | ||
12028d2d MW |
738 | struct acpi_gpio_lookup { |
739 | struct acpi_gpio_info info; | |
740 | int index; | |
74301f27 | 741 | u16 pin_index; |
d079524a | 742 | bool active_low; |
936e15dd | 743 | struct gpio_desc *desc; |
12028d2d MW |
744 | int n; |
745 | }; | |
746 | ||
031ba28a | 747 | static int acpi_populate_gpio_lookup(struct acpi_resource *ares, void *data) |
12028d2d MW |
748 | { |
749 | struct acpi_gpio_lookup *lookup = data; | |
750 | ||
751 | if (ares->type != ACPI_RESOURCE_TYPE_GPIO) | |
752 | return 1; | |
753 | ||
4d1f7a6e | 754 | if (!lookup->desc) { |
12028d2d | 755 | const struct acpi_resource_gpio *agpio = &ares->data.gpio; |
4d1f7a6e | 756 | bool gpioint = agpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT; |
62d5247d | 757 | struct gpio_desc *desc; |
74301f27 | 758 | u16 pin_index; |
0d9a693c | 759 | |
4d1f7a6e AS |
760 | if (lookup->info.quirks & ACPI_GPIO_QUIRK_ONLY_GPIOIO && gpioint) |
761 | lookup->index++; | |
762 | ||
763 | if (lookup->n++ != lookup->index) | |
764 | return 1; | |
765 | ||
766 | pin_index = lookup->pin_index; | |
0d9a693c MW |
767 | if (pin_index >= agpio->pin_table_length) |
768 | return 1; | |
12028d2d | 769 | |
62d5247d AS |
770 | if (lookup->info.quirks & ACPI_GPIO_QUIRK_ABSOLUTE_NUMBER) |
771 | desc = gpio_to_desc(agpio->pin_table[pin_index]); | |
772 | else | |
773 | desc = acpi_get_gpiod(agpio->resource_source.string_ptr, | |
0d9a693c | 774 | agpio->pin_table[pin_index]); |
62d5247d | 775 | lookup->desc = desc; |
2d3b6db1 | 776 | lookup->info.pin_config = agpio->pin_config; |
8dcb7a15 | 777 | lookup->info.debounce = agpio->debounce_timeout; |
4d1f7a6e | 778 | lookup->info.gpioint = gpioint; |
0e3b175f | 779 | lookup->info.wake_capable = acpi_gpio_irq_is_wake(&lookup->info.adev->dev, agpio); |
0d9a693c MW |
780 | |
781 | /* | |
e567c35f AS |
782 | * Polarity and triggering are only specified for GpioInt |
783 | * resource. | |
52044723 CR |
784 | * Note: we expect here: |
785 | * - ACPI_ACTIVE_LOW == GPIO_ACTIVE_LOW | |
786 | * - ACPI_ACTIVE_HIGH == GPIO_ACTIVE_HIGH | |
0d9a693c | 787 | */ |
52044723 CR |
788 | if (lookup->info.gpioint) { |
789 | lookup->info.polarity = agpio->polarity; | |
790 | lookup->info.triggering = agpio->triggering; | |
a31f5c3a | 791 | } else { |
f67a6c11 | 792 | lookup->info.polarity = lookup->active_low; |
52044723 | 793 | } |
bca40480 AS |
794 | |
795 | lookup->info.flags = acpi_gpio_to_gpiod_flags(agpio, lookup->info.polarity); | |
12028d2d MW |
796 | } |
797 | ||
798 | return 1; | |
799 | } | |
800 | ||
d079524a RW |
801 | static int acpi_gpio_resource_lookup(struct acpi_gpio_lookup *lookup, |
802 | struct acpi_gpio_info *info) | |
803 | { | |
5870cff4 | 804 | struct acpi_device *adev = lookup->info.adev; |
d079524a RW |
805 | struct list_head res_list; |
806 | int ret; | |
807 | ||
808 | INIT_LIST_HEAD(&res_list); | |
809 | ||
5870cff4 | 810 | ret = acpi_dev_get_resources(adev, &res_list, |
031ba28a | 811 | acpi_populate_gpio_lookup, |
d079524a RW |
812 | lookup); |
813 | if (ret < 0) | |
814 | return ret; | |
815 | ||
816 | acpi_dev_free_resource_list(&res_list); | |
817 | ||
818 | if (!lookup->desc) | |
819 | return -ENOENT; | |
820 | ||
f67a6c11 | 821 | if (info) |
d079524a | 822 | *info = lookup->info; |
d079524a RW |
823 | return 0; |
824 | } | |
825 | ||
504a3374 | 826 | static int acpi_gpio_property_lookup(struct fwnode_handle *fwnode, |
d079524a RW |
827 | const char *propname, int index, |
828 | struct acpi_gpio_lookup *lookup) | |
829 | { | |
977d5ad3 | 830 | struct fwnode_reference_args args; |
ce0929d2 | 831 | unsigned int quirks = 0; |
d079524a RW |
832 | int ret; |
833 | ||
834 | memset(&args, 0, sizeof(args)); | |
6f7194a1 MW |
835 | ret = __acpi_node_get_property_reference(fwnode, propname, index, 3, |
836 | &args); | |
504a3374 | 837 | if (ret) { |
af3b462a | 838 | struct acpi_device *adev; |
504a3374 | 839 | |
af3b462a AS |
840 | adev = to_acpi_device_node(fwnode); |
841 | if (!acpi_get_driver_gpio_data(adev, propname, index, &args, &quirks)) | |
504a3374 RW |
842 | return ret; |
843 | } | |
d079524a RW |
844 | /* |
845 | * The property was found and resolved, so need to lookup the GPIO based | |
846 | * on returned args. | |
847 | */ | |
977d5ad3 SA |
848 | if (!to_acpi_device_node(args.fwnode)) |
849 | return -EINVAL; | |
6f7194a1 MW |
850 | if (args.nargs != 3) |
851 | return -EPROTO; | |
852 | ||
853 | lookup->index = args.args[0]; | |
854 | lookup->pin_index = args.args[1]; | |
855 | lookup->active_low = !!args.args[2]; | |
856 | ||
977d5ad3 | 857 | lookup->info.adev = to_acpi_device_node(args.fwnode); |
ce0929d2 | 858 | lookup->info.quirks = quirks; |
977d5ad3 | 859 | |
d079524a RW |
860 | return 0; |
861 | } | |
862 | ||
12028d2d | 863 | /** |
936e15dd | 864 | * acpi_get_gpiod_by_index() - get a GPIO descriptor from device resources |
0d9a693c MW |
865 | * @adev: pointer to a ACPI device to get GPIO from |
866 | * @propname: Property name of the GPIO (optional) | |
12028d2d MW |
867 | * @index: index of GpioIo/GpioInt resource (starting from %0) |
868 | * @info: info pointer to fill in (optional) | |
869 | * | |
0d9a693c | 870 | * Function goes through ACPI resources for @adev and based on @index looks |
936e15dd | 871 | * up a GpioIo/GpioInt resource, translates it to the Linux GPIO descriptor, |
12028d2d MW |
872 | * and returns it. @index matches GpioIo/GpioInt resources only so if there |
873 | * are total %3 GPIO resources, the index goes from %0 to %2. | |
874 | * | |
0d9a693c MW |
875 | * If @propname is specified the GPIO is looked using device property. In |
876 | * that case @index is used to select the GPIO entry in the property value | |
877 | * (in case of multiple). | |
878 | * | |
85edcd01 | 879 | * If the GPIO cannot be translated or there is an error, an ERR_PTR is |
12028d2d MW |
880 | * returned. |
881 | * | |
882 | * Note: if the GPIO resource has multiple entries in the pin list, this | |
883 | * function only returns the first. | |
884 | */ | |
031ba28a | 885 | static struct gpio_desc *acpi_get_gpiod_by_index(struct acpi_device *adev, |
16ba046e DT |
886 | const char *propname, |
887 | int index, | |
888 | struct acpi_gpio_info *info) | |
12028d2d MW |
889 | { |
890 | struct acpi_gpio_lookup lookup; | |
12028d2d MW |
891 | int ret; |
892 | ||
12028d2d MW |
893 | memset(&lookup, 0, sizeof(lookup)); |
894 | lookup.index = index; | |
12028d2d | 895 | |
0d9a693c | 896 | if (propname) { |
0d9a693c MW |
897 | dev_dbg(&adev->dev, "GPIO: looking up %s\n", propname); |
898 | ||
504a3374 RW |
899 | ret = acpi_gpio_property_lookup(acpi_fwnode_handle(adev), |
900 | propname, index, &lookup); | |
d079524a RW |
901 | if (ret) |
902 | return ERR_PTR(ret); | |
0d9a693c | 903 | |
74301f27 | 904 | dev_dbg(&adev->dev, "GPIO: _DSD returned %s %d %u %u\n", |
5870cff4 | 905 | dev_name(&lookup.info.adev->dev), lookup.index, |
d079524a | 906 | lookup.pin_index, lookup.active_low); |
0d9a693c MW |
907 | } else { |
908 | dev_dbg(&adev->dev, "GPIO: looking up %d in _CRS\n", index); | |
5870cff4 | 909 | lookup.info.adev = adev; |
0d9a693c MW |
910 | } |
911 | ||
d079524a RW |
912 | ret = acpi_gpio_resource_lookup(&lookup, info); |
913 | return ret ? ERR_PTR(ret) : lookup.desc; | |
12028d2d | 914 | } |
664e3e5a | 915 | |
16ba046e DT |
916 | /** |
917 | * acpi_get_gpiod_from_data() - get a GPIO descriptor from ACPI data node | |
918 | * @fwnode: pointer to an ACPI firmware node to get the GPIO information from | |
919 | * @propname: Property name of the GPIO | |
920 | * @index: index of GpioIo/GpioInt resource (starting from %0) | |
921 | * @info: info pointer to fill in (optional) | |
922 | * | |
923 | * This function uses the property-based GPIO lookup to get to the GPIO | |
924 | * resource with the relevant information from a data-only ACPI firmware node | |
925 | * and uses that to obtain the GPIO descriptor to return. | |
926 | * | |
927 | * If the GPIO cannot be translated or there is an error an ERR_PTR is | |
928 | * returned. | |
929 | */ | |
930 | static struct gpio_desc *acpi_get_gpiod_from_data(struct fwnode_handle *fwnode, | |
931 | const char *propname, | |
932 | int index, | |
933 | struct acpi_gpio_info *info) | |
934 | { | |
935 | struct acpi_gpio_lookup lookup; | |
936 | int ret; | |
937 | ||
938 | if (!is_acpi_data_node(fwnode)) | |
939 | return ERR_PTR(-ENODEV); | |
940 | ||
941 | if (!propname) | |
942 | return ERR_PTR(-EINVAL); | |
943 | ||
479ac419 | 944 | memset(&lookup, 0, sizeof(lookup)); |
16ba046e DT |
945 | lookup.index = index; |
946 | ||
947 | ret = acpi_gpio_property_lookup(fwnode, propname, index, &lookup); | |
948 | if (ret) | |
949 | return ERR_PTR(ret); | |
950 | ||
951 | ret = acpi_gpio_resource_lookup(&lookup, info); | |
952 | return ret ? ERR_PTR(ret) : lookup.desc; | |
953 | } | |
954 | ||
4f78d91c DT |
955 | static bool acpi_can_fallback_to_crs(struct acpi_device *adev, |
956 | const char *con_id) | |
957 | { | |
4bcc9bba LN |
958 | /* If there is no ACPI device, there is no _CRS to fall back to */ |
959 | if (!adev) | |
960 | return false; | |
961 | ||
4f78d91c DT |
962 | /* Never allow fallback if the device has properties */ |
963 | if (acpi_dev_has_props(adev) || adev->driver_gpios) | |
964 | return false; | |
965 | ||
966 | return con_id == NULL; | |
967 | } | |
968 | ||
4fa4c499 AS |
969 | static struct gpio_desc * |
970 | __acpi_find_gpio(struct fwnode_handle *fwnode, const char *con_id, unsigned int idx, | |
49c02f6e | 971 | bool can_fallback, struct acpi_gpio_info *info) |
031ba28a | 972 | { |
16ba046e | 973 | struct acpi_device *adev = to_acpi_device_node(fwnode); |
031ba28a LW |
974 | struct gpio_desc *desc; |
975 | char propname[32]; | |
976 | int i; | |
977 | ||
978 | /* Try first from _DSD */ | |
979 | for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) { | |
9e66504a | 980 | if (con_id) { |
031ba28a LW |
981 | snprintf(propname, sizeof(propname), "%s-%s", |
982 | con_id, gpio_suffixes[i]); | |
983 | } else { | |
984 | snprintf(propname, sizeof(propname), "%s", | |
985 | gpio_suffixes[i]); | |
986 | } | |
987 | ||
16ba046e DT |
988 | if (adev) |
989 | desc = acpi_get_gpiod_by_index(adev, | |
4fa4c499 | 990 | propname, idx, info); |
16ba046e DT |
991 | else |
992 | desc = acpi_get_gpiod_from_data(fwnode, | |
4fa4c499 | 993 | propname, idx, info); |
693bdaa1 DT |
994 | if (PTR_ERR(desc) == -EPROBE_DEFER) |
995 | return ERR_CAST(desc); | |
d8a26a18 AS |
996 | |
997 | if (!IS_ERR(desc)) | |
4cd3ef01 | 998 | return desc; |
031ba28a LW |
999 | } |
1000 | ||
1001 | /* Then from plain _CRS GPIOs */ | |
4bcc9bba LN |
1002 | if (can_fallback) |
1003 | return acpi_get_gpiod_by_index(adev, NULL, idx, info); | |
031ba28a | 1004 | |
4bcc9bba | 1005 | return ERR_PTR(-ENOENT); |
4fa4c499 AS |
1006 | } |
1007 | ||
1008 | struct gpio_desc *acpi_find_gpio(struct fwnode_handle *fwnode, | |
1009 | const char *con_id, | |
1010 | unsigned int idx, | |
1011 | enum gpiod_flags *dflags, | |
1012 | unsigned long *lookupflags) | |
1013 | { | |
1014 | struct acpi_device *adev = to_acpi_device_node(fwnode); | |
49c02f6e | 1015 | bool can_fallback = acpi_can_fallback_to_crs(adev, con_id); |
4fa4c499 AS |
1016 | struct acpi_gpio_info info; |
1017 | struct gpio_desc *desc; | |
1018 | ||
49c02f6e | 1019 | desc = __acpi_find_gpio(fwnode, con_id, idx, can_fallback, &info); |
4fa4c499 AS |
1020 | if (IS_ERR(desc)) |
1021 | return desc; | |
1022 | ||
fe06b56c | 1023 | if (info.gpioint && |
a31f5c3a | 1024 | (*dflags == GPIOD_OUT_LOW || *dflags == GPIOD_OUT_HIGH)) { |
be3dc15f | 1025 | dev_dbg(&adev->dev, "refusing GpioInt() entry when doing GPIOD_OUT_* lookup\n"); |
fe06b56c | 1026 | return ERR_PTR(-ENOENT); |
031ba28a LW |
1027 | } |
1028 | ||
5c34b6c1 | 1029 | acpi_gpio_update_gpiod_flags(dflags, &info); |
606be344 | 1030 | acpi_gpio_update_gpiod_lookup_flags(lookupflags, &info); |
031ba28a LW |
1031 | return desc; |
1032 | } | |
1033 | ||
c884fbd4 | 1034 | /** |
4c992560 | 1035 | * acpi_dev_gpio_irq_wake_get_by() - Find GpioInt and translate it to Linux IRQ number |
c884fbd4 | 1036 | * @adev: pointer to a ACPI device to get IRQ from |
57b60ec4 | 1037 | * @con_id: optional name of GpioInt resource |
c884fbd4 | 1038 | * @index: index of GpioInt resource (starting from %0) |
4c992560 | 1039 | * @wake_capable: Set to true if the IRQ is wake capable |
c884fbd4 MW |
1040 | * |
1041 | * If the device has one or more GpioInt resources, this function can be | |
1042 | * used to translate from the GPIO offset in the resource to the Linux IRQ | |
1043 | * number. | |
1044 | * | |
a31f5c3a AS |
1045 | * The function is idempotent, though each time it runs it will configure GPIO |
1046 | * pin direction according to the flags in GpioInt resource. | |
1047 | * | |
57b60ec4 AS |
1048 | * The function takes optional @con_id parameter. If the resource has |
1049 | * a @con_id in a property, then only those will be taken into account. | |
80939021 | 1050 | * |
4c992560 RR |
1051 | * The GPIO is considered wake capable if the GpioInt resource specifies |
1052 | * SharedAndWake or ExclusiveAndWake. | |
1053 | * | |
db05c7ef | 1054 | * Return: Linux IRQ number (> %0) on success, negative errno on failure. |
c884fbd4 | 1055 | */ |
57b60ec4 | 1056 | int acpi_dev_gpio_irq_wake_get_by(struct acpi_device *adev, const char *con_id, int index, |
4c992560 | 1057 | bool *wake_capable) |
c884fbd4 | 1058 | { |
716b5328 | 1059 | struct fwnode_handle *fwnode = acpi_fwnode_handle(adev); |
c884fbd4 | 1060 | int idx, i; |
52044723 | 1061 | unsigned int irq_flags; |
a31f5c3a | 1062 | int ret; |
c884fbd4 MW |
1063 | |
1064 | for (i = 0, idx = 0; idx <= index; i++) { | |
1065 | struct acpi_gpio_info info; | |
1066 | struct gpio_desc *desc; | |
1067 | ||
6798d727 | 1068 | /* Ignore -EPROBE_DEFER, it only matters if idx matches */ |
716b5328 | 1069 | desc = __acpi_find_gpio(fwnode, con_id, i, true, &info); |
6798d727 HG |
1070 | if (IS_ERR(desc) && PTR_ERR(desc) != -EPROBE_DEFER) |
1071 | return PTR_ERR(desc); | |
1072 | ||
52044723 | 1073 | if (info.gpioint && idx++ == index) { |
2d6c06f5 | 1074 | unsigned long lflags = GPIO_LOOKUP_FLAGS_DEFAULT; |
e7b73132 | 1075 | enum gpiod_flags dflags = GPIOD_ASIS; |
a31f5c3a | 1076 | char label[32]; |
6798d727 | 1077 | int irq; |
52044723 | 1078 | |
6798d727 HG |
1079 | if (IS_ERR(desc)) |
1080 | return PTR_ERR(desc); | |
52044723 | 1081 | |
6798d727 | 1082 | irq = gpiod_to_irq(desc); |
52044723 CR |
1083 | if (irq < 0) |
1084 | return irq; | |
1085 | ||
e7b73132 AS |
1086 | acpi_gpio_update_gpiod_flags(&dflags, &info); |
1087 | acpi_gpio_update_gpiod_lookup_flags(&lflags, &info); | |
1088 | ||
716b5328 | 1089 | snprintf(label, sizeof(label), "%pfwP GpioInt(%d)", fwnode, index); |
1736df17 AS |
1090 | ret = gpiod_set_consumer_name(desc, con_id ?: label); |
1091 | if (ret) | |
1092 | return ret; | |
1093 | ||
e7b73132 | 1094 | ret = gpiod_configure_flags(desc, label, lflags, dflags); |
a31f5c3a AS |
1095 | if (ret < 0) |
1096 | return ret; | |
1097 | ||
660c619b AS |
1098 | /* ACPI uses hundredths of milliseconds units */ |
1099 | ret = gpio_set_debounce_timeout(desc, info.debounce * 10); | |
8dcb7a15 AS |
1100 | if (ret) |
1101 | return ret; | |
1102 | ||
52044723 CR |
1103 | irq_flags = acpi_dev_get_irq_type(info.triggering, |
1104 | info.polarity); | |
1105 | ||
bdfd6ab8 HG |
1106 | /* |
1107 | * If the IRQ is not already in use then set type | |
1108 | * if specified and different than the current one. | |
1109 | */ | |
1110 | if (can_request_irq(irq, irq_flags)) { | |
1111 | if (irq_flags != IRQ_TYPE_NONE && | |
1112 | irq_flags != irq_get_trigger_type(irq)) | |
1113 | irq_set_irq_type(irq, irq_flags); | |
1114 | } else { | |
1115 | dev_dbg(&adev->dev, "IRQ %d already in use\n", irq); | |
1116 | } | |
52044723 | 1117 | |
d63f11c0 ML |
1118 | /* avoid suspend issues with GPIOs when systems are using S3 */ |
1119 | if (wake_capable && acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0) | |
4c992560 RR |
1120 | *wake_capable = info.wake_capable; |
1121 | ||
52044723 CR |
1122 | return irq; |
1123 | } | |
1124 | ||
c884fbd4 | 1125 | } |
6798d727 | 1126 | return -ENOENT; |
c884fbd4 | 1127 | } |
4c992560 | 1128 | EXPORT_SYMBOL_GPL(acpi_dev_gpio_irq_wake_get_by); |
c884fbd4 | 1129 | |
473ed7be MW |
1130 | static acpi_status |
1131 | acpi_gpio_adr_space_handler(u32 function, acpi_physical_address address, | |
1132 | u32 bits, u64 *value, void *handler_context, | |
1133 | void *region_context) | |
1134 | { | |
1135 | struct acpi_gpio_chip *achip = region_context; | |
1136 | struct gpio_chip *chip = achip->chip; | |
1137 | struct acpi_resource_gpio *agpio; | |
1138 | struct acpi_resource *ares; | |
74301f27 | 1139 | u16 pin_index = address; |
473ed7be | 1140 | acpi_status status; |
c15d821d | 1141 | int length; |
473ed7be MW |
1142 | int i; |
1143 | ||
1144 | status = acpi_buffer_to_resource(achip->conn_info.connection, | |
1145 | achip->conn_info.length, &ares); | |
1146 | if (ACPI_FAILURE(status)) | |
1147 | return status; | |
1148 | ||
1149 | if (WARN_ON(ares->type != ACPI_RESOURCE_TYPE_GPIO)) { | |
1150 | ACPI_FREE(ares); | |
1151 | return AE_BAD_PARAMETER; | |
1152 | } | |
1153 | ||
1154 | agpio = &ares->data.gpio; | |
473ed7be MW |
1155 | |
1156 | if (WARN_ON(agpio->io_restriction == ACPI_IO_RESTRICT_INPUT && | |
1157 | function == ACPI_WRITE)) { | |
1158 | ACPI_FREE(ares); | |
1159 | return AE_BAD_PARAMETER; | |
1160 | } | |
1161 | ||
74301f27 | 1162 | length = min_t(u16, agpio->pin_table_length, pin_index + bits); |
c15d821d | 1163 | for (i = pin_index; i < length; ++i) { |
0c2cae09 | 1164 | unsigned int pin = agpio->pin_table[i]; |
473ed7be MW |
1165 | struct acpi_gpio_connection *conn; |
1166 | struct gpio_desc *desc; | |
1167 | bool found; | |
1168 | ||
473ed7be MW |
1169 | mutex_lock(&achip->conn_lock); |
1170 | ||
1171 | found = false; | |
1172 | list_for_each_entry(conn, &achip->conns, node) { | |
e46cf32c | 1173 | if (conn->pin == pin) { |
473ed7be | 1174 | found = true; |
e46cf32c | 1175 | desc = conn->desc; |
473ed7be MW |
1176 | break; |
1177 | } | |
1178 | } | |
c103a10f MW |
1179 | |
1180 | /* | |
1181 | * The same GPIO can be shared between operation region and | |
1182 | * event but only if the access here is ACPI_READ. In that | |
1183 | * case we "borrow" the event GPIO instead. | |
1184 | */ | |
c163f90c | 1185 | if (!found && agpio->shareable == ACPI_SHARED && |
c103a10f MW |
1186 | function == ACPI_READ) { |
1187 | struct acpi_gpio_event *event; | |
1188 | ||
1189 | list_for_each_entry(event, &achip->events, node) { | |
1190 | if (event->pin == pin) { | |
1191 | desc = event->desc; | |
1192 | found = true; | |
1193 | break; | |
1194 | } | |
1195 | } | |
1196 | } | |
1197 | ||
473ed7be | 1198 | if (!found) { |
2e2b496c | 1199 | desc = acpi_request_own_gpiod(chip, agpio, i, "ACPI:OpRegion"); |
e46cf32c | 1200 | if (IS_ERR(desc)) { |
473ed7be | 1201 | mutex_unlock(&achip->conn_lock); |
ce698f4e | 1202 | status = AE_ERROR; |
473ed7be MW |
1203 | goto out; |
1204 | } | |
1205 | ||
473ed7be MW |
1206 | conn = kzalloc(sizeof(*conn), GFP_KERNEL); |
1207 | if (!conn) { | |
473ed7be MW |
1208 | gpiochip_free_own_desc(desc); |
1209 | mutex_unlock(&achip->conn_lock); | |
ce698f4e | 1210 | status = AE_NO_MEMORY; |
473ed7be MW |
1211 | goto out; |
1212 | } | |
1213 | ||
e46cf32c | 1214 | conn->pin = pin; |
473ed7be MW |
1215 | conn->desc = desc; |
1216 | list_add_tail(&conn->node, &achip->conns); | |
1217 | } | |
1218 | ||
1219 | mutex_unlock(&achip->conn_lock); | |
1220 | ||
1221 | if (function == ACPI_WRITE) | |
2c4d00cb | 1222 | gpiod_set_raw_value_cansleep(desc, !!(*value & BIT(i))); |
473ed7be | 1223 | else |
dc62b56a | 1224 | *value |= (u64)gpiod_get_raw_value_cansleep(desc) << i; |
473ed7be MW |
1225 | } |
1226 | ||
1227 | out: | |
1228 | ACPI_FREE(ares); | |
1229 | return status; | |
1230 | } | |
1231 | ||
1232 | static void acpi_gpiochip_request_regions(struct acpi_gpio_chip *achip) | |
1233 | { | |
1234 | struct gpio_chip *chip = achip->chip; | |
58383c78 | 1235 | acpi_handle handle = ACPI_HANDLE(chip->parent); |
473ed7be MW |
1236 | acpi_status status; |
1237 | ||
1238 | INIT_LIST_HEAD(&achip->conns); | |
1239 | mutex_init(&achip->conn_lock); | |
1240 | status = acpi_install_address_space_handler(handle, ACPI_ADR_SPACE_GPIO, | |
1241 | acpi_gpio_adr_space_handler, | |
1242 | NULL, achip); | |
1243 | if (ACPI_FAILURE(status)) | |
58383c78 LW |
1244 | dev_err(chip->parent, |
1245 | "Failed to install GPIO OpRegion handler\n"); | |
473ed7be MW |
1246 | } |
1247 | ||
1248 | static void acpi_gpiochip_free_regions(struct acpi_gpio_chip *achip) | |
1249 | { | |
1250 | struct gpio_chip *chip = achip->chip; | |
58383c78 | 1251 | acpi_handle handle = ACPI_HANDLE(chip->parent); |
473ed7be MW |
1252 | struct acpi_gpio_connection *conn, *tmp; |
1253 | acpi_status status; | |
1254 | ||
1255 | status = acpi_remove_address_space_handler(handle, ACPI_ADR_SPACE_GPIO, | |
1256 | acpi_gpio_adr_space_handler); | |
1257 | if (ACPI_FAILURE(status)) { | |
58383c78 LW |
1258 | dev_err(chip->parent, |
1259 | "Failed to remove GPIO OpRegion handler\n"); | |
473ed7be MW |
1260 | return; |
1261 | } | |
1262 | ||
1263 | list_for_each_entry_safe_reverse(conn, tmp, &achip->conns, node) { | |
1264 | gpiochip_free_own_desc(conn->desc); | |
1265 | list_del(&conn->node); | |
1266 | kfree(conn); | |
1267 | } | |
1268 | } | |
1269 | ||
fed7026a AS |
1270 | static struct gpio_desc * |
1271 | acpi_gpiochip_parse_own_gpio(struct acpi_gpio_chip *achip, | |
1272 | struct fwnode_handle *fwnode, | |
1273 | const char **name, | |
1274 | unsigned long *lflags, | |
80c8d927 | 1275 | enum gpiod_flags *dflags) |
c80f1ba7 MW |
1276 | { |
1277 | struct gpio_chip *chip = achip->chip; | |
1278 | struct gpio_desc *desc; | |
1279 | u32 gpios[2]; | |
1280 | int ret; | |
1281 | ||
2d6c06f5 | 1282 | *lflags = GPIO_LOOKUP_FLAGS_DEFAULT; |
32fa6552 | 1283 | *dflags = GPIOD_ASIS; |
c82064f2 AB |
1284 | *name = NULL; |
1285 | ||
c80f1ba7 MW |
1286 | ret = fwnode_property_read_u32_array(fwnode, "gpios", gpios, |
1287 | ARRAY_SIZE(gpios)); | |
1288 | if (ret < 0) | |
1289 | return ERR_PTR(ret); | |
1290 | ||
03c4749d | 1291 | desc = gpiochip_get_desc(chip, gpios[0]); |
c80f1ba7 MW |
1292 | if (IS_ERR(desc)) |
1293 | return desc; | |
1294 | ||
c80f1ba7 MW |
1295 | if (gpios[1]) |
1296 | *lflags |= GPIO_ACTIVE_LOW; | |
1297 | ||
1298 | if (fwnode_property_present(fwnode, "input")) | |
1299 | *dflags |= GPIOD_IN; | |
1300 | else if (fwnode_property_present(fwnode, "output-low")) | |
1301 | *dflags |= GPIOD_OUT_LOW; | |
1302 | else if (fwnode_property_present(fwnode, "output-high")) | |
1303 | *dflags |= GPIOD_OUT_HIGH; | |
1304 | else | |
1305 | return ERR_PTR(-EINVAL); | |
1306 | ||
1307 | fwnode_property_read_string(fwnode, "line-name", name); | |
1308 | ||
1309 | return desc; | |
1310 | } | |
1311 | ||
1312 | static void acpi_gpiochip_scan_gpios(struct acpi_gpio_chip *achip) | |
1313 | { | |
1314 | struct gpio_chip *chip = achip->chip; | |
1315 | struct fwnode_handle *fwnode; | |
1316 | ||
1317 | device_for_each_child_node(chip->parent, fwnode) { | |
fed7026a | 1318 | unsigned long lflags; |
80c8d927 | 1319 | enum gpiod_flags dflags; |
c80f1ba7 MW |
1320 | struct gpio_desc *desc; |
1321 | const char *name; | |
1322 | int ret; | |
1323 | ||
1324 | if (!fwnode_property_present(fwnode, "gpio-hog")) | |
1325 | continue; | |
1326 | ||
1327 | desc = acpi_gpiochip_parse_own_gpio(achip, fwnode, &name, | |
1328 | &lflags, &dflags); | |
1329 | if (IS_ERR(desc)) | |
1330 | continue; | |
1331 | ||
1332 | ret = gpiod_hog(desc, name, lflags, dflags); | |
1333 | if (ret) { | |
1334 | dev_err(chip->parent, "Failed to hog GPIO\n"); | |
1b6998c9 | 1335 | fwnode_handle_put(fwnode); |
c80f1ba7 MW |
1336 | return; |
1337 | } | |
1338 | } | |
1339 | } | |
1340 | ||
664e3e5a MW |
1341 | void acpi_gpiochip_add(struct gpio_chip *chip) |
1342 | { | |
aa92b6f6 | 1343 | struct acpi_gpio_chip *acpi_gpio; |
a9e10e58 | 1344 | struct acpi_device *adev; |
aa92b6f6 MW |
1345 | acpi_status status; |
1346 | ||
58383c78 | 1347 | if (!chip || !chip->parent) |
e9595f84 MW |
1348 | return; |
1349 | ||
a9e10e58 DS |
1350 | adev = ACPI_COMPANION(chip->parent); |
1351 | if (!adev) | |
aa92b6f6 MW |
1352 | return; |
1353 | ||
1354 | acpi_gpio = kzalloc(sizeof(*acpi_gpio), GFP_KERNEL); | |
1355 | if (!acpi_gpio) { | |
58383c78 | 1356 | dev_err(chip->parent, |
aa92b6f6 MW |
1357 | "Failed to allocate memory for ACPI GPIO chip\n"); |
1358 | return; | |
1359 | } | |
1360 | ||
1361 | acpi_gpio->chip = chip; | |
c103a10f | 1362 | INIT_LIST_HEAD(&acpi_gpio->events); |
78d3a92e | 1363 | INIT_LIST_HEAD(&acpi_gpio->deferred_req_irqs_list_entry); |
aa92b6f6 | 1364 | |
a9e10e58 | 1365 | status = acpi_attach_data(adev->handle, acpi_gpio_chip_dh, acpi_gpio); |
aa92b6f6 | 1366 | if (ACPI_FAILURE(status)) { |
58383c78 | 1367 | dev_err(chip->parent, "Failed to attach ACPI GPIO chip\n"); |
aa92b6f6 MW |
1368 | kfree(acpi_gpio); |
1369 | return; | |
1370 | } | |
1371 | ||
473ed7be | 1372 | acpi_gpiochip_request_regions(acpi_gpio); |
c80f1ba7 | 1373 | acpi_gpiochip_scan_gpios(acpi_gpio); |
a9e10e58 | 1374 | acpi_dev_clear_dependencies(adev); |
664e3e5a MW |
1375 | } |
1376 | ||
1377 | void acpi_gpiochip_remove(struct gpio_chip *chip) | |
1378 | { | |
aa92b6f6 MW |
1379 | struct acpi_gpio_chip *acpi_gpio; |
1380 | acpi_handle handle; | |
1381 | acpi_status status; | |
1382 | ||
58383c78 | 1383 | if (!chip || !chip->parent) |
e9595f84 MW |
1384 | return; |
1385 | ||
58383c78 | 1386 | handle = ACPI_HANDLE(chip->parent); |
aa92b6f6 MW |
1387 | if (!handle) |
1388 | return; | |
1389 | ||
1390 | status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio); | |
1391 | if (ACPI_FAILURE(status)) { | |
58383c78 | 1392 | dev_warn(chip->parent, "Failed to retrieve ACPI GPIO chip\n"); |
aa92b6f6 MW |
1393 | return; |
1394 | } | |
1395 | ||
473ed7be | 1396 | acpi_gpiochip_free_regions(acpi_gpio); |
aa92b6f6 MW |
1397 | |
1398 | acpi_detach_data(handle, acpi_gpio_chip_dh); | |
1399 | kfree(acpi_gpio); | |
664e3e5a | 1400 | } |
66858527 | 1401 | |
6f7194a1 | 1402 | static int acpi_gpio_package_count(const union acpi_object *obj) |
66858527 RI |
1403 | { |
1404 | const union acpi_object *element = obj->package.elements; | |
1405 | const union acpi_object *end = element + obj->package.count; | |
1406 | unsigned int count = 0; | |
1407 | ||
1408 | while (element < end) { | |
6f7194a1 MW |
1409 | switch (element->type) { |
1410 | case ACPI_TYPE_LOCAL_REFERENCE: | |
1411 | element += 3; | |
df561f66 | 1412 | fallthrough; |
6f7194a1 MW |
1413 | case ACPI_TYPE_INTEGER: |
1414 | element++; | |
66858527 | 1415 | count++; |
6f7194a1 | 1416 | break; |
66858527 | 1417 | |
6f7194a1 MW |
1418 | default: |
1419 | return -EPROTO; | |
1420 | } | |
66858527 | 1421 | } |
6f7194a1 | 1422 | |
66858527 RI |
1423 | return count; |
1424 | } | |
1425 | ||
1426 | static int acpi_find_gpio_count(struct acpi_resource *ares, void *data) | |
1427 | { | |
1428 | unsigned int *count = data; | |
1429 | ||
1430 | if (ares->type == ACPI_RESOURCE_TYPE_GPIO) | |
1431 | *count += ares->data.gpio.pin_table_length; | |
1432 | ||
1433 | return 1; | |
1434 | } | |
1435 | ||
1436 | /** | |
8122c7c6 AS |
1437 | * acpi_gpio_count - count the GPIOs associated with a firmware node / function |
1438 | * @fwnode: firmware node of the GPIO consumer | |
66858527 | 1439 | * @con_id: function within the GPIO consumer |
85edcd01 AS |
1440 | * |
1441 | * Return: | |
8122c7c6 | 1442 | * The number of GPIOs associated with a firmware node / function or %-ENOENT, |
85edcd01 | 1443 | * if no GPIO has been assigned to the requested function. |
66858527 | 1444 | */ |
8122c7c6 | 1445 | int acpi_gpio_count(const struct fwnode_handle *fwnode, const char *con_id) |
66858527 | 1446 | { |
8122c7c6 | 1447 | struct acpi_device *adev = to_acpi_device_node(fwnode); |
66858527 RI |
1448 | const union acpi_object *obj; |
1449 | const struct acpi_gpio_mapping *gm; | |
1450 | int count = -ENOENT; | |
1451 | int ret; | |
1452 | char propname[32]; | |
1453 | unsigned int i; | |
1454 | ||
1455 | /* Try first from _DSD */ | |
1456 | for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) { | |
9e66504a | 1457 | if (con_id) |
66858527 RI |
1458 | snprintf(propname, sizeof(propname), "%s-%s", |
1459 | con_id, gpio_suffixes[i]); | |
1460 | else | |
1461 | snprintf(propname, sizeof(propname), "%s", | |
1462 | gpio_suffixes[i]); | |
1463 | ||
8122c7c6 | 1464 | ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_ANY, &obj); |
66858527 RI |
1465 | if (ret == 0) { |
1466 | if (obj->type == ACPI_TYPE_LOCAL_REFERENCE) | |
1467 | count = 1; | |
1468 | else if (obj->type == ACPI_TYPE_PACKAGE) | |
1469 | count = acpi_gpio_package_count(obj); | |
1470 | } else if (adev->driver_gpios) { | |
1471 | for (gm = adev->driver_gpios; gm->name; gm++) | |
1472 | if (strcmp(propname, gm->name) == 0) { | |
1473 | count = gm->size; | |
1474 | break; | |
1475 | } | |
1476 | } | |
4ed55016 | 1477 | if (count > 0) |
66858527 RI |
1478 | break; |
1479 | } | |
1480 | ||
1481 | /* Then from plain _CRS GPIOs */ | |
1482 | if (count < 0) { | |
1483 | struct list_head resource_list; | |
1484 | unsigned int crs_count = 0; | |
1485 | ||
6fe9da42 AS |
1486 | if (!acpi_can_fallback_to_crs(adev, con_id)) |
1487 | return count; | |
1488 | ||
66858527 RI |
1489 | INIT_LIST_HEAD(&resource_list); |
1490 | acpi_dev_get_resources(adev, &resource_list, | |
1491 | acpi_find_gpio_count, &crs_count); | |
1492 | acpi_dev_free_resource_list(&resource_list); | |
1493 | if (crs_count > 0) | |
1494 | count = crs_count; | |
1495 | } | |
4ed55016 | 1496 | return count ? count : -ENOENT; |
66858527 | 1497 | } |
10cf4899 | 1498 | |
e59f5e08 | 1499 | /* Run deferred acpi_gpiochip_request_irqs() */ |
04fd1ca7 | 1500 | static int __init acpi_gpio_handle_deferred_request_irqs(void) |
ca876c74 | 1501 | { |
78d3a92e HG |
1502 | struct acpi_gpio_chip *acpi_gpio, *tmp; |
1503 | ||
1504 | mutex_lock(&acpi_gpio_deferred_req_irqs_lock); | |
1505 | list_for_each_entry_safe(acpi_gpio, tmp, | |
1506 | &acpi_gpio_deferred_req_irqs_list, | |
e59f5e08 HG |
1507 | deferred_req_irqs_list_entry) |
1508 | acpi_gpiochip_request_irqs(acpi_gpio); | |
78d3a92e HG |
1509 | |
1510 | acpi_gpio_deferred_req_irqs_done = true; | |
1511 | mutex_unlock(&acpi_gpio_deferred_req_irqs_lock); | |
ca876c74 BT |
1512 | |
1513 | return 0; | |
1514 | } | |
1515 | /* We must use _sync so that this runs after the first deferred_probe run */ | |
e59f5e08 | 1516 | late_initcall_sync(acpi_gpio_handle_deferred_request_irqs); |
61f7f7c8 | 1517 | |
04fd1ca7 | 1518 | static const struct dmi_system_id gpiolib_acpi_quirks[] __initconst = { |
61f7f7c8 | 1519 | { |
2727315d HG |
1520 | /* |
1521 | * The Minix Neo Z83-4 has a micro-USB-B id-pin handler for | |
1522 | * a non existing micro-USB-B connector which puts the HDMI | |
1523 | * DDC pins in GPIO mode, breaking HDMI support. | |
1524 | */ | |
61f7f7c8 HG |
1525 | .matches = { |
1526 | DMI_MATCH(DMI_SYS_VENDOR, "MINIX"), | |
1527 | DMI_MATCH(DMI_PRODUCT_NAME, "Z83-4"), | |
1ad1b540 | 1528 | }, |
2ccb21f5 HG |
1529 | .driver_data = &(struct acpi_gpiolib_dmi_quirk) { |
1530 | .no_edge_events_on_boot = true, | |
1531 | }, | |
61f7f7c8 | 1532 | }, |
2727315d HG |
1533 | { |
1534 | /* | |
1535 | * The Terra Pad 1061 has a micro-USB-B id-pin handler, which | |
1536 | * instead of controlling the actual micro-USB-B turns the 5V | |
1537 | * boost for its USB-A connector off. The actual micro-USB-B | |
1538 | * connector is wired for charging only. | |
1539 | */ | |
1540 | .matches = { | |
1541 | DMI_MATCH(DMI_SYS_VENDOR, "Wortmann_AG"), | |
1542 | DMI_MATCH(DMI_PRODUCT_NAME, "TERRA_PAD_1061"), | |
1ad1b540 | 1543 | }, |
2ccb21f5 HG |
1544 | .driver_data = &(struct acpi_gpiolib_dmi_quirk) { |
1545 | .no_edge_events_on_boot = true, | |
1546 | }, | |
2727315d | 1547 | }, |
da91ece2 HG |
1548 | { |
1549 | /* | |
1550 | * The Dell Venue 10 Pro 5055, with Bay Trail SoC + TI PMIC uses an | |
1551 | * external embedded-controller connected via I2C + an ACPI GPIO | |
1552 | * event handler on INT33FFC:02 pin 12, causing spurious wakeups. | |
1553 | */ | |
1554 | .matches = { | |
1555 | DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), | |
1556 | DMI_MATCH(DMI_PRODUCT_NAME, "Venue 10 Pro 5055"), | |
1557 | }, | |
1558 | .driver_data = &(struct acpi_gpiolib_dmi_quirk) { | |
1559 | .ignore_wake = "INT33FC:02@12", | |
1560 | }, | |
1561 | }, | |
aa23ca3d HG |
1562 | { |
1563 | /* | |
efaa87fa HG |
1564 | * HP X2 10 models with Cherry Trail SoC + TI PMIC use an |
1565 | * external embedded-controller connected via I2C + an ACPI GPIO | |
1566 | * event handler on INT33FF:01 pin 0, causing spurious wakeups. | |
1567 | * When suspending by closing the LID, the power to the USB | |
1568 | * keyboard is turned off, causing INT0002 ACPI events to | |
1569 | * trigger once the XHCI controller notices the keyboard is | |
1570 | * gone. So INT0002 events cause spurious wakeups too. Ignoring | |
1571 | * EC wakes breaks wakeup when opening the lid, the user needs | |
aa23ca3d HG |
1572 | * to press the power-button to wakeup the system. The |
1573 | * alternative is suspend simply not working, which is worse. | |
1574 | */ | |
1575 | .matches = { | |
1576 | DMI_MATCH(DMI_SYS_VENDOR, "HP"), | |
1577 | DMI_MATCH(DMI_PRODUCT_NAME, "HP x2 Detachable 10-p0XX"), | |
1578 | }, | |
2ccb21f5 HG |
1579 | .driver_data = &(struct acpi_gpiolib_dmi_quirk) { |
1580 | .ignore_wake = "INT33FF:01@0,INT0002:00@2", | |
1581 | }, | |
aa23ca3d | 1582 | }, |
0e91506b HG |
1583 | { |
1584 | /* | |
1585 | * HP X2 10 models with Bay Trail SoC + AXP288 PMIC use an | |
1586 | * external embedded-controller connected via I2C + an ACPI GPIO | |
1587 | * event handler on INT33FC:02 pin 28, causing spurious wakeups. | |
1588 | */ | |
1589 | .matches = { | |
1590 | DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), | |
1591 | DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"), | |
1592 | DMI_MATCH(DMI_BOARD_NAME, "815D"), | |
1593 | }, | |
1594 | .driver_data = &(struct acpi_gpiolib_dmi_quirk) { | |
1595 | .ignore_wake = "INT33FC:02@28", | |
1596 | }, | |
1597 | }, | |
0c625ccf HG |
1598 | { |
1599 | /* | |
1600 | * HP X2 10 models with Cherry Trail SoC + AXP288 PMIC use an | |
1601 | * external embedded-controller connected via I2C + an ACPI GPIO | |
1602 | * event handler on INT33FF:01 pin 0, causing spurious wakeups. | |
1603 | */ | |
1604 | .matches = { | |
1605 | DMI_MATCH(DMI_SYS_VENDOR, "HP"), | |
1606 | DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"), | |
1607 | DMI_MATCH(DMI_BOARD_NAME, "813E"), | |
1608 | }, | |
1609 | .driver_data = &(struct acpi_gpiolib_dmi_quirk) { | |
1610 | .ignore_wake = "INT33FF:01@0", | |
1611 | }, | |
1612 | }, | |
0ea76c40 ML |
1613 | { |
1614 | /* | |
1615 | * Interrupt storm caused from edge triggered floating pin | |
1616 | * Found in BIOS UX325UAZ.300 | |
1617 | * https://bugzilla.kernel.org/show_bug.cgi?id=216208 | |
1618 | */ | |
1619 | .matches = { | |
1620 | DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."), | |
1621 | DMI_MATCH(DMI_PRODUCT_NAME, "ZenBook UX325UAZ_UM325UAZ"), | |
1622 | }, | |
1623 | .driver_data = &(struct acpi_gpiolib_dmi_quirk) { | |
1624 | .ignore_interrupt = "AMDI0030:00@18", | |
1625 | }, | |
1626 | }, | |
782eea0c WS |
1627 | { |
1628 | /* | |
1629 | * Spurious wakeups from TP_ATTN# pin | |
1630 | * Found in BIOS 1.7.8 | |
1631 | * https://gitlab.freedesktop.org/drm/amd/-/issues/1722#note_1720627 | |
1632 | */ | |
1633 | .matches = { | |
1634 | DMI_MATCH(DMI_BOARD_NAME, "NL5xNU"), | |
1635 | }, | |
1636 | .driver_data = &(struct acpi_gpiolib_dmi_quirk) { | |
1637 | .ignore_wake = "ELAN0415:00@9", | |
1638 | }, | |
1639 | }, | |
4cb78618 ML |
1640 | { |
1641 | /* | |
1642 | * Spurious wakeups from TP_ATTN# pin | |
1643 | * Found in BIOS 1.7.8 | |
1644 | * https://gitlab.freedesktop.org/drm/amd/-/issues/1722#note_1720627 | |
1645 | */ | |
1646 | .matches = { | |
1647 | DMI_MATCH(DMI_BOARD_NAME, "NL5xRU"), | |
1648 | }, | |
1649 | .driver_data = &(struct acpi_gpiolib_dmi_quirk) { | |
1650 | .ignore_wake = "ELAN0415:00@9", | |
1651 | }, | |
1652 | }, | |
a69982c3 WS |
1653 | { |
1654 | /* | |
1655 | * Spurious wakeups from TP_ATTN# pin | |
1656 | * Found in BIOS 1.7.7 | |
1657 | */ | |
1658 | .matches = { | |
1659 | DMI_MATCH(DMI_BOARD_NAME, "NH5xAx"), | |
1660 | }, | |
1661 | .driver_data = &(struct acpi_gpiolib_dmi_quirk) { | |
1662 | .ignore_wake = "SYNA1202:00@16", | |
1663 | }, | |
1664 | }, | |
6cc64f61 HG |
1665 | { |
1666 | /* | |
1667 | * On the Peaq C1010 2-in-1 INT33FC:00 pin 3 is connected to | |
1668 | * a "dolby" button. At the ACPI level an _AEI event-handler | |
1669 | * is connected which sets an ACPI variable to 1 on both | |
1670 | * edges. This variable can be polled + cleared to 0 using | |
1671 | * WMI. But since the variable is set on both edges the WMI | |
1672 | * interface is pretty useless even when polling. | |
1673 | * So instead the x86-android-tablets code instantiates | |
1674 | * a gpio-keys platform device for it. | |
1675 | * Ignore the _AEI handler for the pin, so that it is not busy. | |
1676 | */ | |
1677 | .matches = { | |
1678 | DMI_MATCH(DMI_SYS_VENDOR, "PEAQ"), | |
1679 | DMI_MATCH(DMI_PRODUCT_NAME, "PEAQ PMM C1010 MD99187"), | |
1680 | }, | |
1681 | .driver_data = &(struct acpi_gpiolib_dmi_quirk) { | |
1682 | .ignore_interrupt = "INT33FC:00@3", | |
1683 | }, | |
1684 | }, | |
805c74ea ML |
1685 | { |
1686 | /* | |
1687 | * Spurious wakeups from TP_ATTN# pin | |
1688 | * Found in BIOS 0.35 | |
1689 | * https://gitlab.freedesktop.org/drm/amd/-/issues/3073 | |
1690 | */ | |
1691 | .matches = { | |
1692 | DMI_MATCH(DMI_SYS_VENDOR, "GPD"), | |
1693 | DMI_MATCH(DMI_PRODUCT_NAME, "G1619-04"), | |
1694 | }, | |
1695 | .driver_data = &(struct acpi_gpiolib_dmi_quirk) { | |
1696 | .ignore_wake = "PNP0C50:00@8", | |
1697 | }, | |
1698 | }, | |
61f7f7c8 HG |
1699 | {} /* Terminating entry */ |
1700 | }; | |
1701 | ||
04fd1ca7 | 1702 | static int __init acpi_gpio_setup_params(void) |
61f7f7c8 | 1703 | { |
2ccb21f5 | 1704 | const struct acpi_gpiolib_dmi_quirk *quirk = NULL; |
1ad1b540 | 1705 | const struct dmi_system_id *id; |
1ad1b540 HG |
1706 | |
1707 | id = dmi_first_match(gpiolib_acpi_quirks); | |
1708 | if (id) | |
2ccb21f5 | 1709 | quirk = id->driver_data; |
1ad1b540 | 1710 | |
61f7f7c8 | 1711 | if (run_edge_events_on_boot < 0) { |
2ccb21f5 | 1712 | if (quirk && quirk->no_edge_events_on_boot) |
61f7f7c8 HG |
1713 | run_edge_events_on_boot = 0; |
1714 | else | |
1715 | run_edge_events_on_boot = 1; | |
1716 | } | |
1717 | ||
2ccb21f5 HG |
1718 | if (ignore_wake == NULL && quirk && quirk->ignore_wake) |
1719 | ignore_wake = quirk->ignore_wake; | |
aa23ca3d | 1720 | |
6b6af7bd ML |
1721 | if (ignore_interrupt == NULL && quirk && quirk->ignore_interrupt) |
1722 | ignore_interrupt = quirk->ignore_interrupt; | |
1723 | ||
61f7f7c8 HG |
1724 | return 0; |
1725 | } | |
1726 | ||
1727 | /* Directly after dmi_setup() which runs as core_initcall() */ | |
1728 | postcore_initcall(acpi_gpio_setup_params); |