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