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