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> |
e29482e8 | 17 | #include <linux/export.h> |
e29482e8 | 18 | #include <linux/acpi.h> |
0d1c28a4 | 19 | #include <linux/interrupt.h> |
473ed7be | 20 | #include <linux/mutex.h> |
354567e6 | 21 | #include <linux/pinctrl/pinctrl.h> |
e29482e8 | 22 | |
5ccff852 MW |
23 | #include "gpiolib.h" |
24 | ||
4b01a14b | 25 | struct acpi_gpio_event { |
7fc7acb9 | 26 | struct list_head node; |
4b01a14b | 27 | acpi_handle handle; |
7fc7acb9 RW |
28 | unsigned int pin; |
29 | unsigned int irq; | |
e46cf32c | 30 | struct gpio_desc *desc; |
7fc7acb9 RW |
31 | }; |
32 | ||
473ed7be MW |
33 | struct acpi_gpio_connection { |
34 | struct list_head node; | |
e46cf32c | 35 | unsigned int pin; |
473ed7be MW |
36 | struct gpio_desc *desc; |
37 | }; | |
38 | ||
aa92b6f6 | 39 | struct acpi_gpio_chip { |
473ed7be MW |
40 | /* |
41 | * ACPICA requires that the first field of the context parameter | |
42 | * passed to acpi_install_address_space_handler() is large enough | |
43 | * to hold struct acpi_connection_info. | |
44 | */ | |
45 | struct acpi_connection_info conn_info; | |
46 | struct list_head conns; | |
47 | struct mutex conn_lock; | |
aa92b6f6 | 48 | struct gpio_chip *chip; |
4b01a14b | 49 | struct list_head events; |
aa92b6f6 MW |
50 | }; |
51 | ||
e29482e8 MN |
52 | static int acpi_gpiochip_find(struct gpio_chip *gc, void *data) |
53 | { | |
54 | if (!gc->dev) | |
55 | return false; | |
56 | ||
57 | return ACPI_HANDLE(gc->dev) == data; | |
58 | } | |
59 | ||
354567e6 MW |
60 | #ifdef CONFIG_PINCTRL |
61 | /** | |
62 | * acpi_gpiochip_pin_to_gpio_offset() - translates ACPI GPIO to Linux GPIO | |
63 | * @chip: GPIO chip | |
64 | * @pin: ACPI GPIO pin number from GpioIo/GpioInt resource | |
65 | * | |
66 | * Function takes ACPI GpioIo/GpioInt pin number as a parameter and | |
67 | * translates it to a corresponding offset suitable to be passed to a | |
68 | * GPIO controller driver. | |
69 | * | |
70 | * Typically the returned offset is same as @pin, but if the GPIO | |
71 | * controller uses pin controller and the mapping is not contigous the | |
72 | * offset might be different. | |
73 | */ | |
74 | static int acpi_gpiochip_pin_to_gpio_offset(struct gpio_chip *chip, int pin) | |
75 | { | |
76 | struct gpio_pin_range *pin_range; | |
77 | ||
78 | /* If there are no ranges in this chip, use 1:1 mapping */ | |
79 | if (list_empty(&chip->pin_ranges)) | |
80 | return pin; | |
81 | ||
82 | list_for_each_entry(pin_range, &chip->pin_ranges, node) { | |
83 | const struct pinctrl_gpio_range *range = &pin_range->range; | |
84 | int i; | |
85 | ||
86 | if (range->pins) { | |
87 | for (i = 0; i < range->npins; i++) { | |
88 | if (range->pins[i] == pin) | |
89 | return range->base + i - chip->base; | |
90 | } | |
91 | } else { | |
92 | if (pin >= range->pin_base && | |
93 | pin < range->pin_base + range->npins) { | |
94 | unsigned gpio_base; | |
95 | ||
96 | gpio_base = range->base - chip->base; | |
97 | return gpio_base + pin - range->pin_base; | |
98 | } | |
99 | } | |
100 | } | |
101 | ||
102 | return -EINVAL; | |
103 | } | |
104 | #else | |
105 | static inline int acpi_gpiochip_pin_to_gpio_offset(struct gpio_chip *chip, | |
106 | int pin) | |
107 | { | |
108 | return pin; | |
109 | } | |
110 | #endif | |
111 | ||
e29482e8 | 112 | /** |
936e15dd | 113 | * acpi_get_gpiod() - Translate ACPI GPIO pin to GPIO descriptor usable with GPIO API |
e29482e8 MN |
114 | * @path: ACPI GPIO controller full path name, (e.g. "\\_SB.GPO1") |
115 | * @pin: ACPI GPIO pin number (0-based, controller-relative) | |
116 | * | |
936e15dd MW |
117 | * Returns GPIO descriptor to use with Linux generic GPIO API, or ERR_PTR |
118 | * error value | |
e29482e8 MN |
119 | */ |
120 | ||
936e15dd | 121 | static struct gpio_desc *acpi_get_gpiod(char *path, int pin) |
e29482e8 MN |
122 | { |
123 | struct gpio_chip *chip; | |
124 | acpi_handle handle; | |
125 | acpi_status status; | |
354567e6 | 126 | int offset; |
e29482e8 MN |
127 | |
128 | status = acpi_get_handle(NULL, path, &handle); | |
129 | if (ACPI_FAILURE(status)) | |
936e15dd | 130 | return ERR_PTR(-ENODEV); |
e29482e8 MN |
131 | |
132 | chip = gpiochip_find(handle, acpi_gpiochip_find); | |
133 | if (!chip) | |
936e15dd | 134 | return ERR_PTR(-ENODEV); |
e29482e8 | 135 | |
354567e6 MW |
136 | offset = acpi_gpiochip_pin_to_gpio_offset(chip, pin); |
137 | if (offset < 0) | |
138 | return ERR_PTR(offset); | |
e29482e8 | 139 | |
354567e6 | 140 | return gpiochip_get_desc(chip, offset); |
e29482e8 | 141 | } |
0d1c28a4 | 142 | |
0d1c28a4 MN |
143 | static irqreturn_t acpi_gpio_irq_handler(int irq, void *data) |
144 | { | |
6072b9dc | 145 | struct acpi_gpio_event *event = data; |
0d1c28a4 | 146 | |
6072b9dc | 147 | acpi_evaluate_object(event->handle, NULL, NULL, NULL); |
0d1c28a4 MN |
148 | |
149 | return IRQ_HANDLED; | |
150 | } | |
151 | ||
7fc7acb9 RW |
152 | static irqreturn_t acpi_gpio_irq_handler_evt(int irq, void *data) |
153 | { | |
4b01a14b | 154 | struct acpi_gpio_event *event = data; |
7fc7acb9 | 155 | |
4b01a14b | 156 | acpi_execute_simple_method(event->handle, NULL, event->pin); |
7fc7acb9 RW |
157 | |
158 | return IRQ_HANDLED; | |
159 | } | |
160 | ||
aa92b6f6 | 161 | static void acpi_gpio_chip_dh(acpi_handle handle, void *data) |
7fc7acb9 RW |
162 | { |
163 | /* The address of this function is used as a key. */ | |
164 | } | |
165 | ||
6072b9dc MW |
166 | static acpi_status acpi_gpiochip_request_interrupt(struct acpi_resource *ares, |
167 | void *context) | |
0d1c28a4 | 168 | { |
6072b9dc | 169 | struct acpi_gpio_chip *acpi_gpio = context; |
aa92b6f6 | 170 | struct gpio_chip *chip = acpi_gpio->chip; |
6072b9dc | 171 | struct acpi_resource_gpio *agpio; |
7fc7acb9 | 172 | acpi_handle handle, evt_handle; |
6072b9dc MW |
173 | struct acpi_gpio_event *event; |
174 | irq_handler_t handler = NULL; | |
175 | struct gpio_desc *desc; | |
176 | unsigned long irqflags; | |
177 | int ret, pin, irq; | |
0d1c28a4 | 178 | |
6072b9dc MW |
179 | if (ares->type != ACPI_RESOURCE_TYPE_GPIO) |
180 | return AE_OK; | |
181 | ||
182 | agpio = &ares->data.gpio; | |
183 | if (agpio->connection_type != ACPI_RESOURCE_GPIO_TYPE_INT) | |
184 | return AE_OK; | |
0d1c28a4 MN |
185 | |
186 | handle = ACPI_HANDLE(chip->dev); | |
6072b9dc MW |
187 | pin = agpio->pin_table[0]; |
188 | ||
189 | if (pin <= 255) { | |
190 | char ev_name[5]; | |
191 | sprintf(ev_name, "_%c%02X", | |
192 | agpio->triggering == ACPI_EDGE_SENSITIVE ? 'E' : 'L', | |
193 | pin); | |
194 | if (ACPI_SUCCESS(acpi_get_handle(handle, ev_name, &evt_handle))) | |
195 | handler = acpi_gpio_irq_handler; | |
196 | } | |
197 | if (!handler) { | |
198 | if (ACPI_SUCCESS(acpi_get_handle(handle, "_EVT", &evt_handle))) | |
199 | handler = acpi_gpio_irq_handler_evt; | |
200 | } | |
201 | if (!handler) | |
202 | return AE_BAD_PARAMETER; | |
0d1c28a4 | 203 | |
4de60970 | 204 | pin = acpi_gpiochip_pin_to_gpio_offset(chip, pin); |
205 | if (pin < 0) | |
206 | return AE_BAD_PARAMETER; | |
207 | ||
abdc08a3 | 208 | desc = gpiochip_request_own_desc(chip, pin, "ACPI:Event"); |
6072b9dc | 209 | if (IS_ERR(desc)) { |
6072b9dc MW |
210 | dev_err(chip->dev, "Failed to request GPIO\n"); |
211 | return AE_ERROR; | |
212 | } | |
0d1c28a4 | 213 | |
6072b9dc | 214 | gpiod_direction_input(desc); |
0d1c28a4 | 215 | |
e3a2e878 | 216 | ret = gpiochip_lock_as_irq(chip, pin); |
6072b9dc MW |
217 | if (ret) { |
218 | dev_err(chip->dev, "Failed to lock GPIO as interrupt\n"); | |
219 | goto fail_free_desc; | |
220 | } | |
0d1c28a4 | 221 | |
6072b9dc MW |
222 | irq = gpiod_to_irq(desc); |
223 | if (irq < 0) { | |
224 | dev_err(chip->dev, "Failed to translate GPIO to IRQ\n"); | |
225 | goto fail_unlock_irq; | |
226 | } | |
7fc7acb9 | 227 | |
6072b9dc MW |
228 | irqflags = IRQF_ONESHOT; |
229 | if (agpio->triggering == ACPI_LEVEL_SENSITIVE) { | |
230 | if (agpio->polarity == ACPI_ACTIVE_HIGH) | |
231 | irqflags |= IRQF_TRIGGER_HIGH; | |
232 | else | |
233 | irqflags |= IRQF_TRIGGER_LOW; | |
234 | } else { | |
235 | switch (agpio->polarity) { | |
236 | case ACPI_ACTIVE_HIGH: | |
237 | irqflags |= IRQF_TRIGGER_RISING; | |
238 | break; | |
239 | case ACPI_ACTIVE_LOW: | |
240 | irqflags |= IRQF_TRIGGER_FALLING; | |
241 | break; | |
242 | default: | |
243 | irqflags |= IRQF_TRIGGER_RISING | | |
244 | IRQF_TRIGGER_FALLING; | |
245 | break; | |
7fc7acb9 | 246 | } |
6072b9dc | 247 | } |
aa92b6f6 | 248 | |
6072b9dc MW |
249 | event = kzalloc(sizeof(*event), GFP_KERNEL); |
250 | if (!event) | |
251 | goto fail_unlock_irq; | |
7fc7acb9 | 252 | |
6072b9dc MW |
253 | event->handle = evt_handle; |
254 | event->irq = irq; | |
255 | event->pin = pin; | |
e46cf32c | 256 | event->desc = desc; |
7fc7acb9 | 257 | |
6072b9dc MW |
258 | ret = request_threaded_irq(event->irq, NULL, handler, irqflags, |
259 | "ACPI:Event", event); | |
260 | if (ret) { | |
261 | dev_err(chip->dev, "Failed to setup interrupt handler for %d\n", | |
262 | event->irq); | |
263 | goto fail_free_event; | |
0d1c28a4 | 264 | } |
6072b9dc MW |
265 | |
266 | list_add_tail(&event->node, &acpi_gpio->events); | |
267 | return AE_OK; | |
268 | ||
269 | fail_free_event: | |
270 | kfree(event); | |
271 | fail_unlock_irq: | |
e3a2e878 | 272 | gpiochip_unlock_as_irq(chip, pin); |
6072b9dc MW |
273 | fail_free_desc: |
274 | gpiochip_free_own_desc(desc); | |
275 | ||
276 | return AE_ERROR; | |
0d1c28a4 | 277 | } |
7fc7acb9 | 278 | |
70b53411 | 279 | /** |
6072b9dc | 280 | * acpi_gpiochip_request_interrupts() - Register isr for gpio chip ACPI events |
afa82fab | 281 | * @chip: GPIO chip |
70b53411 | 282 | * |
6072b9dc MW |
283 | * ACPI5 platforms can use GPIO signaled ACPI events. These GPIO interrupts are |
284 | * handled by ACPI event methods which need to be called from the GPIO | |
285 | * chip's interrupt handler. acpi_gpiochip_request_interrupts finds out which | |
286 | * gpio pins have acpi event methods and assigns interrupt handlers that calls | |
287 | * the acpi event methods for those pins. | |
288 | */ | |
afa82fab | 289 | void acpi_gpiochip_request_interrupts(struct gpio_chip *chip) |
6072b9dc | 290 | { |
afa82fab MW |
291 | struct acpi_gpio_chip *acpi_gpio; |
292 | acpi_handle handle; | |
293 | acpi_status status; | |
294 | ||
295 | if (!chip->dev || !chip->to_irq) | |
296 | return; | |
6072b9dc | 297 | |
afa82fab MW |
298 | handle = ACPI_HANDLE(chip->dev); |
299 | if (!handle) | |
300 | return; | |
301 | ||
302 | status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio); | |
303 | if (ACPI_FAILURE(status)) | |
6072b9dc MW |
304 | return; |
305 | ||
306 | INIT_LIST_HEAD(&acpi_gpio->events); | |
1ecb016e | 307 | acpi_walk_resources(handle, "_AEI", |
6072b9dc MW |
308 | acpi_gpiochip_request_interrupt, acpi_gpio); |
309 | } | |
2b528fff | 310 | EXPORT_SYMBOL_GPL(acpi_gpiochip_request_interrupts); |
6072b9dc MW |
311 | |
312 | /** | |
313 | * acpi_gpiochip_free_interrupts() - Free GPIO ACPI event interrupts. | |
afa82fab | 314 | * @chip: GPIO chip |
70b53411 | 315 | * |
6072b9dc MW |
316 | * Free interrupts associated with GPIO ACPI event method for the given |
317 | * GPIO chip. | |
70b53411 | 318 | */ |
afa82fab | 319 | void acpi_gpiochip_free_interrupts(struct gpio_chip *chip) |
70b53411 | 320 | { |
afa82fab | 321 | struct acpi_gpio_chip *acpi_gpio; |
4b01a14b | 322 | struct acpi_gpio_event *event, *ep; |
afa82fab MW |
323 | acpi_handle handle; |
324 | acpi_status status; | |
325 | ||
326 | if (!chip->dev || !chip->to_irq) | |
327 | return; | |
70b53411 | 328 | |
afa82fab MW |
329 | handle = ACPI_HANDLE(chip->dev); |
330 | if (!handle) | |
331 | return; | |
332 | ||
333 | status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio); | |
334 | if (ACPI_FAILURE(status)) | |
70b53411 MW |
335 | return; |
336 | ||
4b01a14b | 337 | list_for_each_entry_safe_reverse(event, ep, &acpi_gpio->events, node) { |
6072b9dc MW |
338 | struct gpio_desc *desc; |
339 | ||
340 | free_irq(event->irq, event); | |
e46cf32c | 341 | desc = event->desc; |
6072b9dc MW |
342 | if (WARN_ON(IS_ERR(desc))) |
343 | continue; | |
e3a2e878 | 344 | gpiochip_unlock_as_irq(chip, event->pin); |
6072b9dc | 345 | gpiochip_free_own_desc(desc); |
4b01a14b MW |
346 | list_del(&event->node); |
347 | kfree(event); | |
70b53411 | 348 | } |
70b53411 | 349 | } |
2b528fff | 350 | EXPORT_SYMBOL_GPL(acpi_gpiochip_free_interrupts); |
70b53411 | 351 | |
f028d524 RW |
352 | int acpi_dev_add_driver_gpios(struct acpi_device *adev, |
353 | const struct acpi_gpio_mapping *gpios) | |
354 | { | |
355 | if (adev && gpios) { | |
356 | adev->driver_gpios = gpios; | |
357 | return 0; | |
358 | } | |
359 | return -EINVAL; | |
360 | } | |
361 | EXPORT_SYMBOL_GPL(acpi_dev_add_driver_gpios); | |
362 | ||
363 | static bool acpi_get_driver_gpio_data(struct acpi_device *adev, | |
364 | const char *name, int index, | |
365 | struct acpi_reference_args *args) | |
366 | { | |
367 | const struct acpi_gpio_mapping *gm; | |
368 | ||
369 | if (!adev->driver_gpios) | |
370 | return false; | |
371 | ||
372 | for (gm = adev->driver_gpios; gm->name; gm++) | |
373 | if (!strcmp(name, gm->name) && gm->data && index < gm->size) { | |
374 | const struct acpi_gpio_params *par = gm->data + index; | |
375 | ||
376 | args->adev = adev; | |
377 | args->args[0] = par->crs_entry_index; | |
378 | args->args[1] = par->line_index; | |
379 | args->args[2] = par->active_low; | |
380 | args->nargs = 3; | |
381 | return true; | |
382 | } | |
383 | ||
384 | return false; | |
385 | } | |
386 | ||
12028d2d MW |
387 | struct acpi_gpio_lookup { |
388 | struct acpi_gpio_info info; | |
389 | int index; | |
0d9a693c | 390 | int pin_index; |
936e15dd | 391 | struct gpio_desc *desc; |
12028d2d MW |
392 | int n; |
393 | }; | |
394 | ||
395 | static int acpi_find_gpio(struct acpi_resource *ares, void *data) | |
396 | { | |
397 | struct acpi_gpio_lookup *lookup = data; | |
398 | ||
399 | if (ares->type != ACPI_RESOURCE_TYPE_GPIO) | |
400 | return 1; | |
401 | ||
936e15dd | 402 | if (lookup->n++ == lookup->index && !lookup->desc) { |
12028d2d | 403 | const struct acpi_resource_gpio *agpio = &ares->data.gpio; |
0d9a693c MW |
404 | int pin_index = lookup->pin_index; |
405 | ||
406 | if (pin_index >= agpio->pin_table_length) | |
407 | return 1; | |
12028d2d | 408 | |
936e15dd | 409 | lookup->desc = acpi_get_gpiod(agpio->resource_source.string_ptr, |
0d9a693c | 410 | agpio->pin_table[pin_index]); |
12028d2d MW |
411 | lookup->info.gpioint = |
412 | agpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT; | |
0d9a693c MW |
413 | |
414 | /* | |
415 | * ActiveLow is only specified for GpioInt resource. If | |
416 | * GpioIo is used then the only way to set the flag is | |
417 | * to use _DSD "gpios" property. | |
418 | */ | |
419 | if (lookup->info.gpioint) | |
420 | lookup->info.active_low = | |
421 | agpio->polarity == ACPI_ACTIVE_LOW; | |
12028d2d MW |
422 | } |
423 | ||
424 | return 1; | |
425 | } | |
426 | ||
427 | /** | |
936e15dd | 428 | * acpi_get_gpiod_by_index() - get a GPIO descriptor from device resources |
0d9a693c MW |
429 | * @adev: pointer to a ACPI device to get GPIO from |
430 | * @propname: Property name of the GPIO (optional) | |
12028d2d MW |
431 | * @index: index of GpioIo/GpioInt resource (starting from %0) |
432 | * @info: info pointer to fill in (optional) | |
433 | * | |
0d9a693c | 434 | * Function goes through ACPI resources for @adev and based on @index looks |
936e15dd | 435 | * up a GpioIo/GpioInt resource, translates it to the Linux GPIO descriptor, |
12028d2d MW |
436 | * and returns it. @index matches GpioIo/GpioInt resources only so if there |
437 | * are total %3 GPIO resources, the index goes from %0 to %2. | |
438 | * | |
0d9a693c MW |
439 | * If @propname is specified the GPIO is looked using device property. In |
440 | * that case @index is used to select the GPIO entry in the property value | |
441 | * (in case of multiple). | |
442 | * | |
936e15dd | 443 | * If the GPIO cannot be translated or there is an error an ERR_PTR is |
12028d2d MW |
444 | * returned. |
445 | * | |
446 | * Note: if the GPIO resource has multiple entries in the pin list, this | |
447 | * function only returns the first. | |
448 | */ | |
0d9a693c MW |
449 | struct gpio_desc *acpi_get_gpiod_by_index(struct acpi_device *adev, |
450 | const char *propname, int index, | |
936e15dd | 451 | struct acpi_gpio_info *info) |
12028d2d MW |
452 | { |
453 | struct acpi_gpio_lookup lookup; | |
454 | struct list_head resource_list; | |
0d9a693c | 455 | bool active_low = false; |
12028d2d MW |
456 | int ret; |
457 | ||
0d9a693c | 458 | if (!adev) |
936e15dd | 459 | return ERR_PTR(-ENODEV); |
12028d2d MW |
460 | |
461 | memset(&lookup, 0, sizeof(lookup)); | |
462 | lookup.index = index; | |
12028d2d | 463 | |
0d9a693c MW |
464 | if (propname) { |
465 | struct acpi_reference_args args; | |
466 | ||
467 | dev_dbg(&adev->dev, "GPIO: looking up %s\n", propname); | |
468 | ||
469 | memset(&args, 0, sizeof(args)); | |
60ba032e | 470 | ret = acpi_dev_get_property_reference(adev, propname, |
0d9a693c | 471 | index, &args); |
f028d524 RW |
472 | if (ret) { |
473 | bool found = acpi_get_driver_gpio_data(adev, propname, | |
474 | index, &args); | |
475 | if (!found) | |
476 | return ERR_PTR(ret); | |
477 | } | |
0d9a693c MW |
478 | |
479 | /* | |
480 | * The property was found and resolved so need to | |
481 | * lookup the GPIO based on returned args instead. | |
482 | */ | |
483 | adev = args.adev; | |
484 | if (args.nargs >= 2) { | |
485 | lookup.index = args.args[0]; | |
486 | lookup.pin_index = args.args[1]; | |
487 | /* | |
488 | * 3rd argument, if present is used to | |
489 | * specify active_low. | |
490 | */ | |
491 | if (args.nargs >= 3) | |
492 | active_low = !!args.args[2]; | |
493 | } | |
494 | ||
495 | dev_dbg(&adev->dev, "GPIO: _DSD returned %s %zd %llu %llu %llu\n", | |
496 | dev_name(&adev->dev), args.nargs, | |
497 | args.args[0], args.args[1], args.args[2]); | |
498 | } else { | |
499 | dev_dbg(&adev->dev, "GPIO: looking up %d in _CRS\n", index); | |
500 | } | |
501 | ||
12028d2d MW |
502 | INIT_LIST_HEAD(&resource_list); |
503 | ret = acpi_dev_get_resources(adev, &resource_list, acpi_find_gpio, | |
504 | &lookup); | |
505 | if (ret < 0) | |
936e15dd | 506 | return ERR_PTR(ret); |
12028d2d MW |
507 | |
508 | acpi_dev_free_resource_list(&resource_list); | |
509 | ||
0d9a693c | 510 | if (lookup.desc && info) { |
12028d2d | 511 | *info = lookup.info; |
0d9a693c MW |
512 | if (active_low) |
513 | info->active_low = active_low; | |
514 | } | |
12028d2d | 515 | |
a00580c2 | 516 | return lookup.desc ? lookup.desc : ERR_PTR(-ENOENT); |
12028d2d | 517 | } |
664e3e5a | 518 | |
c884fbd4 MW |
519 | /** |
520 | * acpi_dev_gpio_irq_get() - Find GpioInt and translate it to Linux IRQ number | |
521 | * @adev: pointer to a ACPI device to get IRQ from | |
522 | * @index: index of GpioInt resource (starting from %0) | |
523 | * | |
524 | * If the device has one or more GpioInt resources, this function can be | |
525 | * used to translate from the GPIO offset in the resource to the Linux IRQ | |
526 | * number. | |
527 | * | |
528 | * Return: Linux IRQ number (>%0) on success, negative errno on failure. | |
529 | */ | |
530 | int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index) | |
531 | { | |
532 | int idx, i; | |
533 | ||
534 | for (i = 0, idx = 0; idx <= index; i++) { | |
535 | struct acpi_gpio_info info; | |
536 | struct gpio_desc *desc; | |
537 | ||
538 | desc = acpi_get_gpiod_by_index(adev, NULL, i, &info); | |
539 | if (IS_ERR(desc)) | |
540 | break; | |
541 | if (info.gpioint && idx++ == index) | |
542 | return gpiod_to_irq(desc); | |
543 | } | |
544 | return -ENOENT; | |
545 | } | |
546 | EXPORT_SYMBOL_GPL(acpi_dev_gpio_irq_get); | |
547 | ||
473ed7be MW |
548 | static acpi_status |
549 | acpi_gpio_adr_space_handler(u32 function, acpi_physical_address address, | |
550 | u32 bits, u64 *value, void *handler_context, | |
551 | void *region_context) | |
552 | { | |
553 | struct acpi_gpio_chip *achip = region_context; | |
554 | struct gpio_chip *chip = achip->chip; | |
555 | struct acpi_resource_gpio *agpio; | |
556 | struct acpi_resource *ares; | |
c15d821d | 557 | int pin_index = (int)address; |
473ed7be MW |
558 | acpi_status status; |
559 | bool pull_up; | |
c15d821d | 560 | int length; |
473ed7be MW |
561 | int i; |
562 | ||
563 | status = acpi_buffer_to_resource(achip->conn_info.connection, | |
564 | achip->conn_info.length, &ares); | |
565 | if (ACPI_FAILURE(status)) | |
566 | return status; | |
567 | ||
568 | if (WARN_ON(ares->type != ACPI_RESOURCE_TYPE_GPIO)) { | |
569 | ACPI_FREE(ares); | |
570 | return AE_BAD_PARAMETER; | |
571 | } | |
572 | ||
573 | agpio = &ares->data.gpio; | |
574 | pull_up = agpio->pin_config == ACPI_PIN_CONFIG_PULLUP; | |
575 | ||
576 | if (WARN_ON(agpio->io_restriction == ACPI_IO_RESTRICT_INPUT && | |
577 | function == ACPI_WRITE)) { | |
578 | ACPI_FREE(ares); | |
579 | return AE_BAD_PARAMETER; | |
580 | } | |
581 | ||
c15d821d SP |
582 | length = min(agpio->pin_table_length, (u16)(pin_index + bits)); |
583 | for (i = pin_index; i < length; ++i) { | |
a4811622 | 584 | int pin = agpio->pin_table[i]; |
473ed7be MW |
585 | struct acpi_gpio_connection *conn; |
586 | struct gpio_desc *desc; | |
587 | bool found; | |
588 | ||
4de60970 | 589 | pin = acpi_gpiochip_pin_to_gpio_offset(chip, pin); |
590 | if (pin < 0) { | |
591 | status = AE_BAD_PARAMETER; | |
592 | goto out; | |
593 | } | |
594 | ||
473ed7be MW |
595 | mutex_lock(&achip->conn_lock); |
596 | ||
597 | found = false; | |
598 | list_for_each_entry(conn, &achip->conns, node) { | |
e46cf32c | 599 | if (conn->pin == pin) { |
473ed7be | 600 | found = true; |
e46cf32c | 601 | desc = conn->desc; |
473ed7be MW |
602 | break; |
603 | } | |
604 | } | |
605 | if (!found) { | |
abdc08a3 AC |
606 | desc = gpiochip_request_own_desc(chip, pin, |
607 | "ACPI:OpRegion"); | |
e46cf32c | 608 | if (IS_ERR(desc)) { |
473ed7be MW |
609 | status = AE_ERROR; |
610 | mutex_unlock(&achip->conn_lock); | |
611 | goto out; | |
612 | } | |
613 | ||
614 | switch (agpio->io_restriction) { | |
615 | case ACPI_IO_RESTRICT_INPUT: | |
616 | gpiod_direction_input(desc); | |
617 | break; | |
618 | case ACPI_IO_RESTRICT_OUTPUT: | |
619 | /* | |
620 | * ACPI GPIO resources don't contain an | |
621 | * initial value for the GPIO. Therefore we | |
622 | * deduce that value from the pull field | |
623 | * instead. If the pin is pulled up we | |
624 | * assume default to be high, otherwise | |
625 | * low. | |
626 | */ | |
627 | gpiod_direction_output(desc, pull_up); | |
628 | break; | |
629 | default: | |
630 | /* | |
631 | * Assume that the BIOS has configured the | |
632 | * direction and pull accordingly. | |
633 | */ | |
634 | break; | |
635 | } | |
636 | ||
637 | conn = kzalloc(sizeof(*conn), GFP_KERNEL); | |
638 | if (!conn) { | |
639 | status = AE_NO_MEMORY; | |
640 | gpiochip_free_own_desc(desc); | |
641 | mutex_unlock(&achip->conn_lock); | |
642 | goto out; | |
643 | } | |
644 | ||
e46cf32c | 645 | conn->pin = pin; |
473ed7be MW |
646 | conn->desc = desc; |
647 | list_add_tail(&conn->node, &achip->conns); | |
648 | } | |
649 | ||
650 | mutex_unlock(&achip->conn_lock); | |
651 | ||
652 | if (function == ACPI_WRITE) | |
dc62b56a AL |
653 | gpiod_set_raw_value_cansleep(desc, |
654 | !!((1 << i) & *value)); | |
473ed7be | 655 | else |
dc62b56a | 656 | *value |= (u64)gpiod_get_raw_value_cansleep(desc) << i; |
473ed7be MW |
657 | } |
658 | ||
659 | out: | |
660 | ACPI_FREE(ares); | |
661 | return status; | |
662 | } | |
663 | ||
664 | static void acpi_gpiochip_request_regions(struct acpi_gpio_chip *achip) | |
665 | { | |
666 | struct gpio_chip *chip = achip->chip; | |
667 | acpi_handle handle = ACPI_HANDLE(chip->dev); | |
668 | acpi_status status; | |
669 | ||
670 | INIT_LIST_HEAD(&achip->conns); | |
671 | mutex_init(&achip->conn_lock); | |
672 | status = acpi_install_address_space_handler(handle, ACPI_ADR_SPACE_GPIO, | |
673 | acpi_gpio_adr_space_handler, | |
674 | NULL, achip); | |
675 | if (ACPI_FAILURE(status)) | |
676 | dev_err(chip->dev, "Failed to install GPIO OpRegion handler\n"); | |
677 | } | |
678 | ||
679 | static void acpi_gpiochip_free_regions(struct acpi_gpio_chip *achip) | |
680 | { | |
681 | struct gpio_chip *chip = achip->chip; | |
682 | acpi_handle handle = ACPI_HANDLE(chip->dev); | |
683 | struct acpi_gpio_connection *conn, *tmp; | |
684 | acpi_status status; | |
685 | ||
686 | status = acpi_remove_address_space_handler(handle, ACPI_ADR_SPACE_GPIO, | |
687 | acpi_gpio_adr_space_handler); | |
688 | if (ACPI_FAILURE(status)) { | |
689 | dev_err(chip->dev, "Failed to remove GPIO OpRegion handler\n"); | |
690 | return; | |
691 | } | |
692 | ||
693 | list_for_each_entry_safe_reverse(conn, tmp, &achip->conns, node) { | |
694 | gpiochip_free_own_desc(conn->desc); | |
695 | list_del(&conn->node); | |
696 | kfree(conn); | |
697 | } | |
698 | } | |
699 | ||
664e3e5a MW |
700 | void acpi_gpiochip_add(struct gpio_chip *chip) |
701 | { | |
aa92b6f6 MW |
702 | struct acpi_gpio_chip *acpi_gpio; |
703 | acpi_handle handle; | |
704 | acpi_status status; | |
705 | ||
e9595f84 MW |
706 | if (!chip || !chip->dev) |
707 | return; | |
708 | ||
aa92b6f6 MW |
709 | handle = ACPI_HANDLE(chip->dev); |
710 | if (!handle) | |
711 | return; | |
712 | ||
713 | acpi_gpio = kzalloc(sizeof(*acpi_gpio), GFP_KERNEL); | |
714 | if (!acpi_gpio) { | |
715 | dev_err(chip->dev, | |
716 | "Failed to allocate memory for ACPI GPIO chip\n"); | |
717 | return; | |
718 | } | |
719 | ||
720 | acpi_gpio->chip = chip; | |
721 | ||
722 | status = acpi_attach_data(handle, acpi_gpio_chip_dh, acpi_gpio); | |
723 | if (ACPI_FAILURE(status)) { | |
724 | dev_err(chip->dev, "Failed to attach ACPI GPIO chip\n"); | |
725 | kfree(acpi_gpio); | |
726 | return; | |
727 | } | |
728 | ||
473ed7be | 729 | acpi_gpiochip_request_regions(acpi_gpio); |
664e3e5a MW |
730 | } |
731 | ||
732 | void acpi_gpiochip_remove(struct gpio_chip *chip) | |
733 | { | |
aa92b6f6 MW |
734 | struct acpi_gpio_chip *acpi_gpio; |
735 | acpi_handle handle; | |
736 | acpi_status status; | |
737 | ||
e9595f84 MW |
738 | if (!chip || !chip->dev) |
739 | return; | |
740 | ||
aa92b6f6 MW |
741 | handle = ACPI_HANDLE(chip->dev); |
742 | if (!handle) | |
743 | return; | |
744 | ||
745 | status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio); | |
746 | if (ACPI_FAILURE(status)) { | |
747 | dev_warn(chip->dev, "Failed to retrieve ACPI GPIO chip\n"); | |
748 | return; | |
749 | } | |
750 | ||
473ed7be | 751 | acpi_gpiochip_free_regions(acpi_gpio); |
aa92b6f6 MW |
752 | |
753 | acpi_detach_data(handle, acpi_gpio_chip_dh); | |
754 | kfree(acpi_gpio); | |
664e3e5a | 755 | } |
66858527 RI |
756 | |
757 | static unsigned int acpi_gpio_package_count(const union acpi_object *obj) | |
758 | { | |
759 | const union acpi_object *element = obj->package.elements; | |
760 | const union acpi_object *end = element + obj->package.count; | |
761 | unsigned int count = 0; | |
762 | ||
763 | while (element < end) { | |
764 | if (element->type == ACPI_TYPE_LOCAL_REFERENCE) | |
765 | count++; | |
766 | ||
767 | element++; | |
768 | } | |
769 | return count; | |
770 | } | |
771 | ||
772 | static int acpi_find_gpio_count(struct acpi_resource *ares, void *data) | |
773 | { | |
774 | unsigned int *count = data; | |
775 | ||
776 | if (ares->type == ACPI_RESOURCE_TYPE_GPIO) | |
777 | *count += ares->data.gpio.pin_table_length; | |
778 | ||
779 | return 1; | |
780 | } | |
781 | ||
782 | /** | |
783 | * acpi_gpio_count - return the number of GPIOs associated with a | |
784 | * device / function or -ENOENT if no GPIO has been | |
785 | * assigned to the requested function. | |
786 | * @dev: GPIO consumer, can be NULL for system-global GPIOs | |
787 | * @con_id: function within the GPIO consumer | |
788 | */ | |
789 | int acpi_gpio_count(struct device *dev, const char *con_id) | |
790 | { | |
791 | struct acpi_device *adev = ACPI_COMPANION(dev); | |
792 | const union acpi_object *obj; | |
793 | const struct acpi_gpio_mapping *gm; | |
794 | int count = -ENOENT; | |
795 | int ret; | |
796 | char propname[32]; | |
797 | unsigned int i; | |
798 | ||
799 | /* Try first from _DSD */ | |
800 | for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) { | |
801 | if (con_id && strcmp(con_id, "gpios")) | |
802 | snprintf(propname, sizeof(propname), "%s-%s", | |
803 | con_id, gpio_suffixes[i]); | |
804 | else | |
805 | snprintf(propname, sizeof(propname), "%s", | |
806 | gpio_suffixes[i]); | |
807 | ||
808 | ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_ANY, | |
809 | &obj); | |
810 | if (ret == 0) { | |
811 | if (obj->type == ACPI_TYPE_LOCAL_REFERENCE) | |
812 | count = 1; | |
813 | else if (obj->type == ACPI_TYPE_PACKAGE) | |
814 | count = acpi_gpio_package_count(obj); | |
815 | } else if (adev->driver_gpios) { | |
816 | for (gm = adev->driver_gpios; gm->name; gm++) | |
817 | if (strcmp(propname, gm->name) == 0) { | |
818 | count = gm->size; | |
819 | break; | |
820 | } | |
821 | } | |
822 | if (count >= 0) | |
823 | break; | |
824 | } | |
825 | ||
826 | /* Then from plain _CRS GPIOs */ | |
827 | if (count < 0) { | |
828 | struct list_head resource_list; | |
829 | unsigned int crs_count = 0; | |
830 | ||
831 | INIT_LIST_HEAD(&resource_list); | |
832 | acpi_dev_get_resources(adev, &resource_list, | |
833 | acpi_find_gpio_count, &crs_count); | |
834 | acpi_dev_free_resource_list(&resource_list); | |
835 | if (crs_count > 0) | |
836 | count = crs_count; | |
837 | } | |
838 | return count; | |
839 | } |