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