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