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