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