gpiolib-shared.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright (C) 2025 Linaro Ltd.
  4 */
  5
  6#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  7
  8#include <linux/auxiliary_bus.h>
  9#include <linux/cleanup.h>
 10#include <linux/device.h>
 11#include <linux/fwnode.h>
 12#include <linux/gpio/consumer.h>
 13#include <linux/gpio/machine.h>
 14#include <linux/idr.h>
 15#include <linux/kref.h>
 16#include <linux/list.h>
 17#include <linux/lockdep.h>
 18#include <linux/module.h>
 19#include <linux/mutex.h>
 20#include <linux/of.h>
 21#include <linux/overflow.h>
 22#include <linux/printk.h>
 23#include <linux/property.h>
 24#include <linux/slab.h>
 25#include <linux/string.h>
 26
 27#include "gpiolib.h"
 28#include "gpiolib-shared.h"
 29
 30/* Represents a single reference to a GPIO pin. */
 31struct gpio_shared_ref {
 32	struct list_head list;
 33	/* Firmware node associated with this GPIO's consumer. */
 34	struct fwnode_handle *fwnode;
 35	/* GPIO flags this consumer uses for the request. */
 36	enum gpiod_flags flags;
 37	char *con_id;
 38	int dev_id;
 39	/* Protects the auxiliary device struct and the lookup table. */
 40	struct mutex lock;
 41	struct lock_class_key lock_key;
 42	struct auxiliary_device adev;
 43	struct gpiod_lookup_table *lookup;
 44	bool is_reset_gpio;
 45};
 46
 47/* Represents a single GPIO pin. */
 48struct gpio_shared_entry {
 49	struct list_head list;
 50	/* Firmware node associated with the GPIO controller. */
 51	struct fwnode_handle *fwnode;
 52	/* Hardware offset of the GPIO within its chip. */
 53	unsigned int offset;
 54	/* Index in the property value array. */
 55	size_t index;
 56	/* Synchronizes the modification of shared_desc. */
 57	struct mutex lock;
 58	struct gpio_shared_desc *shared_desc;
 59	struct kref ref;
 60	struct list_head refs;
 61};
 62
 63static LIST_HEAD(gpio_shared_list);
 64static DEFINE_IDA(gpio_shared_ida);
 65
 66#if IS_ENABLED(CONFIG_OF)
 67static struct gpio_shared_entry *
 68gpio_shared_find_entry(struct fwnode_handle *controller_node,
 69		       unsigned int offset)
 70{
 71	struct gpio_shared_entry *entry;
 72
 73	list_for_each_entry(entry, &gpio_shared_list, list) {
 74		if (entry->fwnode == controller_node && entry->offset == offset)
 75			return entry;
 76	}
 77
 78	return NULL;
 79}
 80
 81static struct gpio_shared_ref *gpio_shared_make_ref(struct fwnode_handle *fwnode,
 82						    const char *con_id,
 83						    enum gpiod_flags flags)
 84{
 85	char *con_id_cpy __free(kfree) = NULL;
 86
 87	struct gpio_shared_ref *ref __free(kfree) = kzalloc(sizeof(*ref), GFP_KERNEL);
 88	if (!ref)
 89		return NULL;
 90
 91	if (con_id) {
 92		con_id_cpy = kstrdup(con_id, GFP_KERNEL);
 93		if (!con_id_cpy)
 94			return NULL;
 95	}
 96
 97	ref->dev_id = ida_alloc(&gpio_shared_ida, GFP_KERNEL);
 98	if (ref->dev_id < 0)
 99		return NULL;
100
101	ref->flags = flags;
102	ref->con_id = no_free_ptr(con_id_cpy);
103	ref->fwnode = fwnode;
104	lockdep_register_key(&ref->lock_key);
105	mutex_init_with_key(&ref->lock, &ref->lock_key);
106
107	return no_free_ptr(ref);
108}
109
110static int gpio_shared_setup_reset_proxy(struct gpio_shared_entry *entry,
111					 enum gpiod_flags flags)
112{
113	struct gpio_shared_ref *ref;
114
115	list_for_each_entry(ref, &entry->refs, list) {
116		if (ref->is_reset_gpio)
117			/* Already set-up. */
118			return 0;
119	}
120
121	ref = gpio_shared_make_ref(NULL, "reset", flags);
122	if (!ref)
123		return -ENOMEM;
124
125	ref->is_reset_gpio = true;
126
127	list_add_tail(&ref->list, &entry->refs);
128
129	pr_debug("Created a secondary shared GPIO reference for potential reset-gpio device for GPIO %u at %s\n",
130		 entry->offset, fwnode_get_name(entry->fwnode));
131
132	return 0;
133}
134
135/* Handle all special nodes that we should ignore. */
136static bool gpio_shared_of_node_ignore(struct device_node *node)
137{
138	/* Ignore disabled devices. */
139	if (!of_device_is_available(node))
140		return true;
141
142	/*
143	 * __symbols__ is a special, internal node and should not be considered
144	 * when scanning for shared GPIOs.
145	 */
146	if (of_node_name_eq(node, "__symbols__"))
147		return true;
148
149	/*
150	 * GPIO hogs have a "gpios" property which is not a phandle and can't
151	 * possibly refer to a shared GPIO.
152	 */
153	if (of_property_present(node, "gpio-hog"))
154		return true;
155
156	return false;
157}
158
159static int gpio_shared_of_traverse(struct device_node *curr)
160{
161	struct gpio_shared_entry *entry;
162	size_t con_id_len, suffix_len;
163	struct fwnode_handle *fwnode;
164	struct of_phandle_args args;
165	struct gpio_shared_ref *ref;
166	struct property *prop;
167	unsigned int offset;
168	const char *suffix;
169	int ret, count, i;
170
171	if (gpio_shared_of_node_ignore(curr))
172		return 0;
173
174	for_each_property_of_node(curr, prop) {
175		/*
176		 * The standard name for a GPIO property is "foo-gpios"
177		 * or "foo-gpio". Some bindings also use "gpios" or "gpio".
178		 * There are some legacy device-trees which have a different
179		 * naming convention and for which we have rename quirks in
180		 * place in gpiolib-of.c. I don't think any of them require
181		 * support for shared GPIOs so for now let's just ignore
182		 * them. We can always just export the quirk list and
183		 * iterate over it here.
184		 */
185		if (!strends(prop->name, "-gpios") &&
186		    !strends(prop->name, "-gpio") &&
187		    strcmp(prop->name, "gpios") != 0 &&
188		    strcmp(prop->name, "gpio") != 0)
189			continue;
190
191		count = of_count_phandle_with_args(curr, prop->name,
192						   "#gpio-cells");
193		if (count <= 0)
194			continue;
195
196		for (i = 0; i < count; i++) {
197			struct device_node *np __free(device_node) = NULL;
198			char *con_id __free(kfree) = NULL;
199
200			ret = of_parse_phandle_with_args(curr, prop->name,
201							 "#gpio-cells", i,
202							 &args);
203			if (ret)
204				continue;
205
206			np = args.np;
207
208			if (!of_property_present(np, "gpio-controller"))
209				continue;
210
211			/*
212			 * We support 1, 2 and 3 cell GPIO bindings in the
213			 * kernel currently. There's only one old MIPS dts that
214			 * has a one-cell binding but there's no associated
215			 * consumer so it may as well be an error. There don't
216			 * seem to be any 3-cell users of non-exclusive GPIOs,
217			 * so we can skip this as well. Let's occupy ourselves
218			 * with the predominant 2-cell binding with the first
219			 * cell indicating the hardware offset of the GPIO and
220			 * the second defining the GPIO flags of the request.
221			 */
222			if (args.args_count != 2)
223				continue;
224
225			fwnode = of_fwnode_handle(args.np);
226			offset = args.args[0];
227
228			entry = gpio_shared_find_entry(fwnode, offset);
229			if (!entry) {
230				entry = kzalloc(sizeof(*entry), GFP_KERNEL);
231				if (!entry)
232					return -ENOMEM;
233
234				entry->fwnode = fwnode_handle_get(fwnode);
235				entry->offset = offset;
236				entry->index = count;
237				INIT_LIST_HEAD(&entry->refs);
238				mutex_init(&entry->lock);
239
240				list_add_tail(&entry->list, &gpio_shared_list);
241			}
242
243			if (strends(prop->name, "gpios"))
244				suffix = "-gpios";
245			else if (strends(prop->name, "gpio"))
246				suffix = "-gpio";
247			else
248				suffix = NULL;
249			if (!suffix)
250				continue;
251
252			/* We only set con_id if there's actually one. */
253			if (strcmp(prop->name, "gpios") && strcmp(prop->name, "gpio")) {
254				con_id = kstrdup(prop->name, GFP_KERNEL);
255				if (!con_id)
256					return -ENOMEM;
257
258				con_id_len = strlen(con_id);
259				suffix_len = strlen(suffix);
260
261				con_id[con_id_len - suffix_len] = '\0';
262			}
263
264			ref = gpio_shared_make_ref(fwnode_handle_get(of_fwnode_handle(curr)),
265						   con_id, args.args[1]);
266			if (!ref)
267				return -ENOMEM;
268
269			if (!list_empty(&entry->refs))
270				pr_debug("GPIO %u at %s is shared by multiple firmware nodes\n",
271					 entry->offset, fwnode_get_name(entry->fwnode));
272
273			list_add_tail(&ref->list, &entry->refs);
274
275			if (strcmp(prop->name, "reset-gpios") == 0) {
276				ret = gpio_shared_setup_reset_proxy(entry, args.args[1]);
277				if (ret)
278					return ret;
279			}
280		}
281	}
282
283	for_each_child_of_node_scoped(curr, child) {
284		ret = gpio_shared_of_traverse(child);
285		if (ret)
286			return ret;
287	}
288
289	return 0;
290}
291
292static int gpio_shared_of_scan(void)
293{
294	if (of_root)
295		return gpio_shared_of_traverse(of_root);
296
297	return 0;
298}
299#else
300static int gpio_shared_of_scan(void)
301{
302	return 0;
303}
304#endif /* CONFIG_OF */
305
306static void gpio_shared_adev_release(struct device *dev)
307{
308
309}
310
311static int gpio_shared_make_adev(struct gpio_device *gdev,
312				 struct gpio_shared_entry *entry,
313				 struct gpio_shared_ref *ref)
314{
315	struct auxiliary_device *adev = &ref->adev;
316	int ret;
317
318	guard(mutex)(&ref->lock);
319
320	memset(adev, 0, sizeof(*adev));
321
322	adev->id = ref->dev_id;
323	adev->name = "proxy";
324	adev->dev.parent = gdev->dev.parent;
325	adev->dev.platform_data = entry;
326	adev->dev.release = gpio_shared_adev_release;
327
328	ret = auxiliary_device_init(adev);
329	if (ret)
330		return ret;
331
332	ret = auxiliary_device_add(adev);
333	if (ret) {
334		auxiliary_device_uninit(adev);
335		return ret;
336	}
337
338	pr_debug("Created an auxiliary GPIO proxy %s for GPIO device %s\n",
339		 dev_name(&adev->dev), gpio_device_get_label(gdev));
340
341	return 0;
342}
343
344#if IS_ENABLED(CONFIG_RESET_GPIO)
345/*
346 * Special case: reset-gpio is an auxiliary device that's created dynamically
347 * and put in between the GPIO controller and consumers of shared GPIOs
348 * referred to by the "reset-gpios" property.
349 *
350 * If the supposed consumer of a shared GPIO didn't match any of the mappings
351 * we created when scanning the firmware nodes, it's still possible that it's
352 * the reset-gpio device which didn't exist at the time of the scan.
353 *
354 * This function verifies it an return true if it's the case.
355 */
356static bool gpio_shared_dev_is_reset_gpio(struct device *consumer,
357					  struct gpio_shared_entry *entry,
358					  struct gpio_shared_ref *ref)
359{
360	struct fwnode_handle *reset_fwnode = dev_fwnode(consumer);
361	struct fwnode_reference_args ref_args, aux_args;
362	struct device *parent = consumer->parent;
363	struct gpio_shared_ref *real_ref;
364	bool match;
365	int ret;
366
367	lockdep_assert_held(&ref->lock);
368
369	/* The reset-gpio device must have a parent AND a firmware node. */
370	if (!parent || !reset_fwnode)
371		return false;
372
373	/*
374	 * Parent of the reset-gpio auxiliary device is the GPIO chip whose
375	 * fwnode we stored in the entry structure.
376	 */
377	if (!device_match_fwnode(parent, entry->fwnode))
378		return false;
379
380	/*
381	 * Now we need to find the actual pin we want to assign to this
382	 * reset-gpio device. To that end: iterate over the list of references
383	 * of this entry and see if there's one, whose reset-gpios property's
384	 * arguments match the ones from this consumer's node.
385	 */
386	list_for_each_entry(real_ref, &entry->refs, list) {
387		if (real_ref == ref)
388			continue;
389
390		guard(mutex)(&real_ref->lock);
391
392		if (!real_ref->fwnode)
393			continue;
394
395		/*
396		 * The device associated with the shared reference's firmware
397		 * node is the consumer of the reset control exposed by the
398		 * reset-gpio device. It must have a "reset-gpios" property
399		 * that's referencing the entry's firmware node.
400		 *
401		 * The reference args must agree between the real consumer and
402		 * the auxiliary reset-gpio device.
403		 */
404		ret = fwnode_property_get_reference_args(real_ref->fwnode,
405							 "reset-gpios",
406							 NULL, 2, 0, &ref_args);
407		if (ret)
408			continue;
409
410		ret = fwnode_property_get_reference_args(reset_fwnode, "reset-gpios",
411							 NULL, 2, 0, &aux_args);
412		if (ret) {
413			fwnode_handle_put(ref_args.fwnode);
414			continue;
415		}
416
417		match = ((ref_args.fwnode == entry->fwnode) &&
418			 (aux_args.fwnode == entry->fwnode) &&
419			 (ref_args.args[0] == aux_args.args[0]));
420
421		fwnode_handle_put(ref_args.fwnode);
422		fwnode_handle_put(aux_args.fwnode);
423
424		if (!match)
425			continue;
426
427		/*
428		 * Reuse the fwnode of the real device, next time we'll use it
429		 * in the normal path.
430		 */
431		ref->fwnode = fwnode_handle_get(reset_fwnode);
432		return true;
433	}
434
435	return false;
436}
437#else
438static bool gpio_shared_dev_is_reset_gpio(struct device *consumer,
439					  struct gpio_shared_entry *entry,
440					  struct gpio_shared_ref *ref)
441{
442	return false;
443}
444#endif /* CONFIG_RESET_GPIO */
445
446int gpio_shared_add_proxy_lookup(struct device *consumer, struct fwnode_handle *fwnode,
447				 const char *con_id, unsigned long lflags)
448{
449	const char *dev_id = dev_name(consumer);
450	struct gpiod_lookup_table *lookup;
451	struct gpio_shared_entry *entry;
452	struct gpio_shared_ref *ref;
453
454	list_for_each_entry(entry, &gpio_shared_list, list) {
455		list_for_each_entry(ref, &entry->refs, list) {
456			guard(mutex)(&ref->lock);
457
458			/*
459			 * FIXME: use device_is_compatible() once the reset-gpio
460			 * drivers gains a compatible string which it currently
461			 * does not have.
462			 */
463			if (!ref->fwnode && strstarts(dev_name(consumer), "reset.gpio.")) {
464				if (!gpio_shared_dev_is_reset_gpio(consumer, entry, ref))
465					continue;
466			} else if (fwnode != ref->fwnode) {
467				continue;
468			}
469
470			if ((!con_id && ref->con_id) || (con_id && !ref->con_id) ||
471			    (con_id && ref->con_id && strcmp(con_id, ref->con_id) != 0))
472				continue;
473
474			/* We've already done that on a previous request. */
475			if (ref->lookup)
476				return 0;
477
478			char *key __free(kfree) =
479				kasprintf(GFP_KERNEL,
480					  KBUILD_MODNAME ".proxy.%u",
481					  ref->adev.id);
482			if (!key)
483				return -ENOMEM;
484
485			lookup = kzalloc(struct_size(lookup, table, 2), GFP_KERNEL);
486			if (!lookup)
487				return -ENOMEM;
488
489			pr_debug("Adding machine lookup entry for a shared GPIO for consumer %s, with key '%s' and con_id '%s'\n",
490				 dev_id, key, ref->con_id ?: "none");
491
492			lookup->dev_id = dev_id;
493			lookup->table[0] = GPIO_LOOKUP(no_free_ptr(key), 0,
494						       ref->con_id, lflags);
495
496			ref->lookup = lookup;
497			gpiod_add_lookup_table(ref->lookup);
498
499			return 0;
500		}
501	}
502
503	/* We warn here because this can only happen if the programmer borked. */
504	WARN_ON(1);
505	return -ENOENT;
506}
507
508static void gpio_shared_remove_adev(struct auxiliary_device *adev)
509{
510	auxiliary_device_delete(adev);
511	auxiliary_device_uninit(adev);
512}
513
514int gpiochip_setup_shared(struct gpio_chip *gc)
515{
516	struct gpio_device *gdev = gc->gpiodev;
517	struct gpio_shared_entry *entry;
518	struct gpio_shared_ref *ref;
519	struct gpio_desc *desc;
520	int ret;
521
522	list_for_each_entry(entry, &gpio_shared_list, list) {
523		list_for_each_entry(ref, &entry->refs, list) {
524			if (gdev->dev.parent == &ref->adev.dev) {
525				/*
526				 * This is a shared GPIO proxy. Mark its
527				 * descriptor as such and return here.
528				 */
529				__set_bit(GPIOD_FLAG_SHARED_PROXY,
530					  &gdev->descs[0].flags);
531				return 0;
532			}
533		}
534	}
535
536	/*
537	 * This is not a shared GPIO proxy but it still may be the device
538	 * exposing shared pins. Find them and create the proxy devices.
539	 */
540	list_for_each_entry(entry, &gpio_shared_list, list) {
541		if (!device_match_fwnode(&gdev->dev, entry->fwnode))
542			continue;
543
544		if (list_count_nodes(&entry->refs) <= 1)
545			continue;
546
547		scoped_guard(mutex, &entry->lock) {
548#if IS_ENABLED(CONFIG_OF)
549			if (is_of_node(entry->fwnode) && gc->of_xlate) {
550				/*
551				 * This is the earliest that we can tranlate the
552				 * devicetree offset to the chip offset.
553				 */
554				struct of_phandle_args gpiospec = { };
555
556				gpiospec.np = to_of_node(entry->fwnode);
557				gpiospec.args_count = 2;
558				gpiospec.args[0] = entry->offset;
559
560				ret = gc->of_xlate(gc, &gpiospec, NULL);
561				if (ret < 0)
562					return ret;
563
564				entry->offset = ret;
565			}
566#endif /* CONFIG_OF */
567
568			desc = &gdev->descs[entry->offset];
569
570			__set_bit(GPIOD_FLAG_SHARED, &desc->flags);
571			/*
572			 * Shared GPIOs are not requested via the normal path. Make
573			 * them inaccessible to anyone even before we register the
574			 * chip.
575			 */
576			ret = gpiod_request_commit(desc, "shared");
577			if (ret)
578				return ret;
579
580			pr_debug("GPIO %u owned by %s is shared by multiple consumers\n",
581				 entry->offset, gpio_device_get_label(gdev));
582		}
583
584		list_for_each_entry(ref, &entry->refs, list) {
585			pr_debug("Setting up a shared GPIO entry for %s (con_id: '%s')\n",
586				 fwnode_get_name(ref->fwnode) ?: "(no fwnode)",
587				 ref->con_id ?: "(none)");
588
589			ret = gpio_shared_make_adev(gdev, entry, ref);
590			if (ret) {
591				gpiod_free_commit(desc);
592				return ret;
593			}
594		}
595	}
596
597	return 0;
598}
599
600void gpio_device_teardown_shared(struct gpio_device *gdev)
601{
602	struct gpio_shared_entry *entry;
603	struct gpio_shared_ref *ref;
604
605	list_for_each_entry(entry, &gpio_shared_list, list) {
606		guard(mutex)(&entry->lock);
607
608		if (!device_match_fwnode(&gdev->dev, entry->fwnode))
609			continue;
610
611		gpiod_free_commit(&gdev->descs[entry->offset]);
612
613		list_for_each_entry(ref, &entry->refs, list) {
614			guard(mutex)(&ref->lock);
615
616			if (ref->lookup) {
617				gpiod_remove_lookup_table(ref->lookup);
618				kfree(ref->lookup->table[0].key);
619				kfree(ref->lookup);
620				ref->lookup = NULL;
621			}
622
623			gpio_shared_remove_adev(&ref->adev);
624		}
625	}
626}
627
628static void gpio_shared_release(struct kref *kref)
629{
630	struct gpio_shared_entry *entry =
631		container_of(kref, struct gpio_shared_entry, ref);
632	struct gpio_shared_desc *shared_desc;
633
634	guard(mutex)(&entry->lock);
635
636	shared_desc = entry->shared_desc;
637	gpio_device_put(shared_desc->desc->gdev);
638	if (shared_desc->can_sleep)
639		mutex_destroy(&shared_desc->mutex);
640	kfree(shared_desc);
641	entry->shared_desc = NULL;
642}
643
644static void gpiod_shared_put(void *data)
645{
646	struct gpio_shared_entry *entry = data;
647
648	kref_put(&entry->ref, gpio_shared_release);
649}
650
651static struct gpio_shared_desc *
652gpiod_shared_desc_create(struct gpio_shared_entry *entry)
653{
654	struct gpio_shared_desc *shared_desc;
655	struct gpio_device *gdev;
656
657	lockdep_assert_held(&entry->lock);
658
659	shared_desc = kzalloc(sizeof(*shared_desc), GFP_KERNEL);
660	if (!shared_desc)
661		return ERR_PTR(-ENOMEM);
662
663	gdev = gpio_device_find_by_fwnode(entry->fwnode);
664	if (!gdev) {
665		kfree(shared_desc);
666		return ERR_PTR(-EPROBE_DEFER);
667	}
668
669	shared_desc->desc = &gdev->descs[entry->offset];
670	shared_desc->can_sleep = gpiod_cansleep(shared_desc->desc);
671	if (shared_desc->can_sleep)
672		mutex_init(&shared_desc->mutex);
673	else
674		spin_lock_init(&shared_desc->spinlock);
675
676	return shared_desc;
677}
678
679struct gpio_shared_desc *devm_gpiod_shared_get(struct device *dev)
680{
681	struct gpio_shared_desc *shared_desc;
682	struct gpio_shared_entry *entry;
683	int ret;
684
685	entry = dev_get_platdata(dev);
686	if (WARN_ON(!entry))
687		/* Programmer bug */
688		return ERR_PTR(-ENOENT);
689
690	scoped_guard(mutex, &entry->lock) {
691		if (entry->shared_desc) {
692			kref_get(&entry->ref);
693			shared_desc = entry->shared_desc;
694		} else {
695			shared_desc = gpiod_shared_desc_create(entry);
696			if (IS_ERR(shared_desc))
697				return ERR_CAST(shared_desc);
698
699			kref_init(&entry->ref);
700			entry->shared_desc = shared_desc;
701		}
702
703		pr_debug("Device %s acquired a reference to the shared GPIO %u owned by %s\n",
704			 dev_name(dev), gpiod_hwgpio(shared_desc->desc),
705			 gpio_device_get_label(shared_desc->desc->gdev));
706	}
707
708	ret = devm_add_action_or_reset(dev, gpiod_shared_put, entry);
709	if (ret)
710		return ERR_PTR(ret);
711
712	return shared_desc;
713}
714EXPORT_SYMBOL_GPL(devm_gpiod_shared_get);
715
716static void gpio_shared_drop_ref(struct gpio_shared_ref *ref)
717{
718	list_del(&ref->list);
719	mutex_destroy(&ref->lock);
720	lockdep_unregister_key(&ref->lock_key);
721	kfree(ref->con_id);
722	ida_free(&gpio_shared_ida, ref->dev_id);
723	fwnode_handle_put(ref->fwnode);
724	kfree(ref);
725}
726
727static void gpio_shared_drop_entry(struct gpio_shared_entry *entry)
728{
729	list_del(&entry->list);
730	mutex_destroy(&entry->lock);
731	fwnode_handle_put(entry->fwnode);
732	kfree(entry);
733}
734
735/*
736 * This is only called if gpio_shared_init() fails so it's in fact __init and
737 * not __exit.
738 */
739static void __init gpio_shared_teardown(void)
740{
741	struct gpio_shared_entry *entry, *epos;
742	struct gpio_shared_ref *ref, *rpos;
743
744	list_for_each_entry_safe(entry, epos, &gpio_shared_list, list) {
745		list_for_each_entry_safe(ref, rpos, &entry->refs, list)
746			gpio_shared_drop_ref(ref);
747
748		gpio_shared_drop_entry(entry);
749	}
750}
751
752static bool gpio_shared_entry_is_really_shared(struct gpio_shared_entry *entry)
753{
754	size_t num_nodes = list_count_nodes(&entry->refs);
755	struct gpio_shared_ref *ref;
756
757	if (num_nodes <= 1)
758		return false;
759
760	if (num_nodes > 2)
761		return true;
762
763	/* Exactly two references: */
764	list_for_each_entry(ref, &entry->refs, list) {
765		/*
766		 * Corner-case: the second reference comes from the potential
767		 * reset-gpio instance. However, this pin is not really shared
768		 * as it would have three references in this case. Avoid
769		 * creating unnecessary proxies.
770		 */
771		if (ref->is_reset_gpio)
772			return false;
773	}
774
775	return true;
776}
777
778static void gpio_shared_free_exclusive(void)
779{
780	struct gpio_shared_entry *entry, *epos;
781	struct gpio_shared_ref *ref, *rpos;
782
783	list_for_each_entry_safe(entry, epos, &gpio_shared_list, list) {
784		if (gpio_shared_entry_is_really_shared(entry))
785			continue;
786
787		list_for_each_entry_safe(ref, rpos, &entry->refs, list)
788			gpio_shared_drop_ref(ref);
789		gpio_shared_drop_entry(entry);
790	}
791}
792
793static int __init gpio_shared_init(void)
794{
795	int ret;
796
797	/* Right now, we only support OF-based systems. */
798	ret = gpio_shared_of_scan();
799	if (ret) {
800		gpio_shared_teardown();
801		pr_err("Failed to scan OF nodes for shared GPIOs: %d\n", ret);
802		return ret;
803	}
804
805	gpio_shared_free_exclusive();
806
807	pr_debug("Finished scanning firmware nodes for shared GPIOs\n");
808	return 0;
809}
810postcore_initcall(gpio_shared_init);