1#include <linux/idr.h>
2#include <linux/mutex.h>
3#include <linux/device.h>
4#include <linux/sysfs.h>
5#include <linux/gpio/consumer.h>
6#include <linux/gpio/driver.h>
7#include <linux/interrupt.h>
8#include <linux/kdev_t.h>
9#include <linux/slab.h>
10
11#include "gpiolib.h"
12
13#define GPIO_IRQF_TRIGGER_FALLING	BIT(0)
14#define GPIO_IRQF_TRIGGER_RISING	BIT(1)
15#define GPIO_IRQF_TRIGGER_BOTH		(GPIO_IRQF_TRIGGER_FALLING | \
16					 GPIO_IRQF_TRIGGER_RISING)
17
18struct gpiod_data {
19	struct gpio_desc *desc;
20
21	struct mutex mutex;
22	struct kernfs_node *value_kn;
23	int irq;
24	unsigned char irq_flags;
25
26	bool direction_can_change;
27};
28
29/*
30 * Lock to serialise gpiod export and unexport, and prevent re-export of
31 * gpiod whose chip is being unregistered.
32 */
33static DEFINE_MUTEX(sysfs_lock);
34
35/*
36 * /sys/class/gpio/gpioN... only for GPIOs that are exported
37 *   /direction
38 *      * MAY BE OMITTED if kernel won't allow direction changes
39 *      * is read/write as "in" or "out"
40 *      * may also be written as "high" or "low", initializing
41 *        output value as specified ("out" implies "low")
42 *   /value
43 *      * always readable, subject to hardware behavior
44 *      * may be writable, as zero/nonzero
45 *   /edge
46 *      * configures behavior of poll(2) on /value
47 *      * available only if pin can generate IRQs on input
48 *      * is read/write as "none", "falling", "rising", or "both"
49 *   /active_low
50 *      * configures polarity of /value
51 *      * is read/write as zero/nonzero
52 *      * also affects existing and subsequent "falling" and "rising"
53 *        /edge configuration
54 */
55
56static ssize_t direction_show(struct device *dev,
57		struct device_attribute *attr, char *buf)
58{
59	struct gpiod_data *data = dev_get_drvdata(dev);
60	struct gpio_desc *desc = data->desc;
61	ssize_t			status;
62
63	mutex_lock(&data->mutex);
64
65	gpiod_get_direction(desc);
66	status = sprintf(buf, "%s\n",
67			test_bit(FLAG_IS_OUT, &desc->flags)
68				? "out" : "in");
69
70	mutex_unlock(&data->mutex);
71
72	return status;
73}
74
75static ssize_t direction_store(struct device *dev,
76		struct device_attribute *attr, const char *buf, size_t size)
77{
78	struct gpiod_data *data = dev_get_drvdata(dev);
79	struct gpio_desc *desc = data->desc;
80	ssize_t			status;
81
82	mutex_lock(&data->mutex);
83
84	if (sysfs_streq(buf, "high"))
85		status = gpiod_direction_output_raw(desc, 1);
86	else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
87		status = gpiod_direction_output_raw(desc, 0);
88	else if (sysfs_streq(buf, "in"))
89		status = gpiod_direction_input(desc);
90	else
91		status = -EINVAL;
92
93	mutex_unlock(&data->mutex);
94
95	return status ? : size;
96}
97static DEVICE_ATTR_RW(direction);
98
99static ssize_t value_show(struct device *dev,
100		struct device_attribute *attr, char *buf)
101{
102	struct gpiod_data *data = dev_get_drvdata(dev);
103	struct gpio_desc *desc = data->desc;
104	ssize_t			status;
105
106	mutex_lock(&data->mutex);
107
108	status = sprintf(buf, "%d\n", gpiod_get_value_cansleep(desc));
109
110	mutex_unlock(&data->mutex);
111
112	return status;
113}
114
115static ssize_t value_store(struct device *dev,
116		struct device_attribute *attr, const char *buf, size_t size)
117{
118	struct gpiod_data *data = dev_get_drvdata(dev);
119	struct gpio_desc *desc = data->desc;
120	ssize_t			status;
121
122	mutex_lock(&data->mutex);
123
124	if (!test_bit(FLAG_IS_OUT, &desc->flags)) {
125		status = -EPERM;
126	} else {
127		long		value;
128
129		status = kstrtol(buf, 0, &value);
130		if (status == 0) {
131			gpiod_set_value_cansleep(desc, value);
132			status = size;
133		}
134	}
135
136	mutex_unlock(&data->mutex);
137
138	return status;
139}
140static DEVICE_ATTR_RW(value);
141
142static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
143{
144	struct gpiod_data *data = priv;
145
146	sysfs_notify_dirent(data->value_kn);
147
148	return IRQ_HANDLED;
149}
150
151/* Caller holds gpiod-data mutex. */
152static int gpio_sysfs_request_irq(struct device *dev, unsigned char flags)
153{
154	struct gpiod_data	*data = dev_get_drvdata(dev);
155	struct gpio_desc	*desc = data->desc;
156	unsigned long		irq_flags;
157	int			ret;
158
159	data->irq = gpiod_to_irq(desc);
160	if (data->irq < 0)
161		return -EIO;
162
163	data->value_kn = sysfs_get_dirent(dev->kobj.sd, "value");
164	if (!data->value_kn)
165		return -ENODEV;
166
167	irq_flags = IRQF_SHARED;
168	if (flags & GPIO_IRQF_TRIGGER_FALLING)
169		irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
170			IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
171	if (flags & GPIO_IRQF_TRIGGER_RISING)
172		irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
173			IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
174
175	/*
176	 * FIXME: This should be done in the irq_request_resources callback
177	 *        when the irq is requested, but a few drivers currently fail
178	 *        to do so.
179	 *
180	 *        Remove this redundant call (along with the corresponding
181	 *        unlock) when those drivers have been fixed.
182	 */
183	ret = gpiochip_lock_as_irq(desc->chip, gpio_chip_hwgpio(desc));
184	if (ret < 0)
185		goto err_put_kn;
186
187	ret = request_any_context_irq(data->irq, gpio_sysfs_irq, irq_flags,
188				"gpiolib", data);
189	if (ret < 0)
190		goto err_unlock;
191
192	data->irq_flags = flags;
193
194	return 0;
195
196err_unlock:
197	gpiochip_unlock_as_irq(desc->chip, gpio_chip_hwgpio(desc));
198err_put_kn:
199	sysfs_put(data->value_kn);
200
201	return ret;
202}
203
204/*
205 * Caller holds gpiod-data mutex (unless called after class-device
206 * deregistration).
207 */
208static void gpio_sysfs_free_irq(struct device *dev)
209{
210	struct gpiod_data *data = dev_get_drvdata(dev);
211	struct gpio_desc *desc = data->desc;
212
213	data->irq_flags = 0;
214	free_irq(data->irq, data);
215	gpiochip_unlock_as_irq(desc->chip, gpio_chip_hwgpio(desc));
216	sysfs_put(data->value_kn);
217}
218
219static const struct {
220	const char *name;
221	unsigned char flags;
222} trigger_types[] = {
223	{ "none",    0 },
224	{ "falling", GPIO_IRQF_TRIGGER_FALLING },
225	{ "rising",  GPIO_IRQF_TRIGGER_RISING },
226	{ "both",    GPIO_IRQF_TRIGGER_BOTH },
227};
228
229static ssize_t edge_show(struct device *dev,
230		struct device_attribute *attr, char *buf)
231{
232	struct gpiod_data *data = dev_get_drvdata(dev);
233	ssize_t	status = 0;
234	int i;
235
236	mutex_lock(&data->mutex);
237
238	for (i = 0; i < ARRAY_SIZE(trigger_types); i++) {
239		if (data->irq_flags == trigger_types[i].flags) {
240			status = sprintf(buf, "%s\n", trigger_types[i].name);
241			break;
242		}
243	}
244
245	mutex_unlock(&data->mutex);
246
247	return status;
248}
249
250static ssize_t edge_store(struct device *dev,
251		struct device_attribute *attr, const char *buf, size_t size)
252{
253	struct gpiod_data *data = dev_get_drvdata(dev);
254	unsigned char flags;
255	ssize_t	status = size;
256	int i;
257
258	for (i = 0; i < ARRAY_SIZE(trigger_types); i++) {
259		if (sysfs_streq(trigger_types[i].name, buf))
260			break;
261	}
262
263	if (i == ARRAY_SIZE(trigger_types))
264		return -EINVAL;
265
266	flags = trigger_types[i].flags;
267
268	mutex_lock(&data->mutex);
269
270	if (flags == data->irq_flags) {
271		status = size;
272		goto out_unlock;
273	}
274
275	if (data->irq_flags)
276		gpio_sysfs_free_irq(dev);
277
278	if (flags) {
279		status = gpio_sysfs_request_irq(dev, flags);
280		if (!status)
281			status = size;
282	}
283
284out_unlock:
285	mutex_unlock(&data->mutex);
286
287	return status;
288}
289static DEVICE_ATTR_RW(edge);
290
291/* Caller holds gpiod-data mutex. */
292static int gpio_sysfs_set_active_low(struct device *dev, int value)
293{
294	struct gpiod_data	*data = dev_get_drvdata(dev);
295	struct gpio_desc	*desc = data->desc;
296	int			status = 0;
297	unsigned int		flags = data->irq_flags;
298
299	if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value)
300		return 0;
301
302	if (value)
303		set_bit(FLAG_ACTIVE_LOW, &desc->flags);
304	else
305		clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
306
307	/* reconfigure poll(2) support if enabled on one edge only */
308	if (flags == GPIO_IRQF_TRIGGER_FALLING ||
309					flags == GPIO_IRQF_TRIGGER_RISING) {
310		gpio_sysfs_free_irq(dev);
311		status = gpio_sysfs_request_irq(dev, flags);
312	}
313
314	return status;
315}
316
317static ssize_t active_low_show(struct device *dev,
318		struct device_attribute *attr, char *buf)
319{
320	struct gpiod_data *data = dev_get_drvdata(dev);
321	struct gpio_desc *desc = data->desc;
322	ssize_t			status;
323
324	mutex_lock(&data->mutex);
325
326	status = sprintf(buf, "%d\n",
327				!!test_bit(FLAG_ACTIVE_LOW, &desc->flags));
328
329	mutex_unlock(&data->mutex);
330
331	return status;
332}
333
334static ssize_t active_low_store(struct device *dev,
335		struct device_attribute *attr, const char *buf, size_t size)
336{
337	struct gpiod_data	*data = dev_get_drvdata(dev);
338	ssize_t			status;
339	long			value;
340
341	mutex_lock(&data->mutex);
342
343	status = kstrtol(buf, 0, &value);
344	if (status == 0)
345		status = gpio_sysfs_set_active_low(dev, value);
346
347	mutex_unlock(&data->mutex);
348
349	return status ? : size;
350}
351static DEVICE_ATTR_RW(active_low);
352
353static umode_t gpio_is_visible(struct kobject *kobj, struct attribute *attr,
354			       int n)
355{
356	struct device *dev = container_of(kobj, struct device, kobj);
357	struct gpiod_data *data = dev_get_drvdata(dev);
358	struct gpio_desc *desc = data->desc;
359	umode_t mode = attr->mode;
360	bool show_direction = data->direction_can_change;
361
362	if (attr == &dev_attr_direction.attr) {
363		if (!show_direction)
364			mode = 0;
365	} else if (attr == &dev_attr_edge.attr) {
366		if (gpiod_to_irq(desc) < 0)
367			mode = 0;
368		if (!show_direction && test_bit(FLAG_IS_OUT, &desc->flags))
369			mode = 0;
370	}
371
372	return mode;
373}
374
375static struct attribute *gpio_attrs[] = {
376	&dev_attr_direction.attr,
377	&dev_attr_edge.attr,
378	&dev_attr_value.attr,
379	&dev_attr_active_low.attr,
380	NULL,
381};
382
383static const struct attribute_group gpio_group = {
384	.attrs = gpio_attrs,
385	.is_visible = gpio_is_visible,
386};
387
388static const struct attribute_group *gpio_groups[] = {
389	&gpio_group,
390	NULL
391};
392
393/*
394 * /sys/class/gpio/gpiochipN/
395 *   /base ... matching gpio_chip.base (N)
396 *   /label ... matching gpio_chip.label
397 *   /ngpio ... matching gpio_chip.ngpio
398 */
399
400static ssize_t base_show(struct device *dev,
401			       struct device_attribute *attr, char *buf)
402{
403	const struct gpio_chip	*chip = dev_get_drvdata(dev);
404
405	return sprintf(buf, "%d\n", chip->base);
406}
407static DEVICE_ATTR_RO(base);
408
409static ssize_t label_show(struct device *dev,
410			       struct device_attribute *attr, char *buf)
411{
412	const struct gpio_chip	*chip = dev_get_drvdata(dev);
413
414	return sprintf(buf, "%s\n", chip->label ? : "");
415}
416static DEVICE_ATTR_RO(label);
417
418static ssize_t ngpio_show(struct device *dev,
419			       struct device_attribute *attr, char *buf)
420{
421	const struct gpio_chip	*chip = dev_get_drvdata(dev);
422
423	return sprintf(buf, "%u\n", chip->ngpio);
424}
425static DEVICE_ATTR_RO(ngpio);
426
427static struct attribute *gpiochip_attrs[] = {
428	&dev_attr_base.attr,
429	&dev_attr_label.attr,
430	&dev_attr_ngpio.attr,
431	NULL,
432};
433ATTRIBUTE_GROUPS(gpiochip);
434
435/*
436 * /sys/class/gpio/export ... write-only
437 *	integer N ... number of GPIO to export (full access)
438 * /sys/class/gpio/unexport ... write-only
439 *	integer N ... number of GPIO to unexport
440 */
441static ssize_t export_store(struct class *class,
442				struct class_attribute *attr,
443				const char *buf, size_t len)
444{
445	long			gpio;
446	struct gpio_desc	*desc;
447	int			status;
448
449	status = kstrtol(buf, 0, &gpio);
450	if (status < 0)
451		goto done;
452
453	desc = gpio_to_desc(gpio);
454	/* reject invalid GPIOs */
455	if (!desc) {
456		pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
457		return -EINVAL;
458	}
459
460	/* No extra locking here; FLAG_SYSFS just signifies that the
461	 * request and export were done by on behalf of userspace, so
462	 * they may be undone on its behalf too.
463	 */
464
465	status = gpiod_request(desc, "sysfs");
466	if (status < 0) {
467		if (status == -EPROBE_DEFER)
468			status = -ENODEV;
469		goto done;
470	}
471	status = gpiod_export(desc, true);
472	if (status < 0)
473		gpiod_free(desc);
474	else
475		set_bit(FLAG_SYSFS, &desc->flags);
476
477done:
478	if (status)
479		pr_debug("%s: status %d\n", __func__, status);
480	return status ? : len;
481}
482
483static ssize_t unexport_store(struct class *class,
484				struct class_attribute *attr,
485				const char *buf, size_t len)
486{
487	long			gpio;
488	struct gpio_desc	*desc;
489	int			status;
490
491	status = kstrtol(buf, 0, &gpio);
492	if (status < 0)
493		goto done;
494
495	desc = gpio_to_desc(gpio);
496	/* reject bogus commands (gpio_unexport ignores them) */
497	if (!desc) {
498		pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
499		return -EINVAL;
500	}
501
502	status = -EINVAL;
503
504	/* No extra locking here; FLAG_SYSFS just signifies that the
505	 * request and export were done by on behalf of userspace, so
506	 * they may be undone on its behalf too.
507	 */
508	if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
509		status = 0;
510		gpiod_free(desc);
511	}
512done:
513	if (status)
514		pr_debug("%s: status %d\n", __func__, status);
515	return status ? : len;
516}
517
518static struct class_attribute gpio_class_attrs[] = {
519	__ATTR(export, 0200, NULL, export_store),
520	__ATTR(unexport, 0200, NULL, unexport_store),
521	__ATTR_NULL,
522};
523
524static struct class gpio_class = {
525	.name =		"gpio",
526	.owner =	THIS_MODULE,
527
528	.class_attrs =	gpio_class_attrs,
529};
530
531
532/**
533 * gpiod_export - export a GPIO through sysfs
534 * @gpio: gpio to make available, already requested
535 * @direction_may_change: true if userspace may change gpio direction
536 * Context: arch_initcall or later
537 *
538 * When drivers want to make a GPIO accessible to userspace after they
539 * have requested it -- perhaps while debugging, or as part of their
540 * public interface -- they may use this routine.  If the GPIO can
541 * change direction (some can't) and the caller allows it, userspace
542 * will see "direction" sysfs attribute which may be used to change
543 * the gpio's direction.  A "value" attribute will always be provided.
544 *
545 * Returns zero on success, else an error.
546 */
547int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
548{
549	struct gpio_chip	*chip;
550	struct gpiod_data	*data;
551	unsigned long		flags;
552	int			status;
553	const char		*ioname = NULL;
554	struct device		*dev;
555	int			offset;
556
557	/* can't export until sysfs is available ... */
558	if (!gpio_class.p) {
559		pr_debug("%s: called too early!\n", __func__);
560		return -ENOENT;
561	}
562
563	if (!desc) {
564		pr_debug("%s: invalid gpio descriptor\n", __func__);
565		return -EINVAL;
566	}
567
568	chip = desc->chip;
569
570	mutex_lock(&sysfs_lock);
571
572	/* check if chip is being removed */
573	if (!chip || !chip->cdev) {
574		status = -ENODEV;
575		goto err_unlock;
576	}
577
578	spin_lock_irqsave(&gpio_lock, flags);
579	if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
580	     test_bit(FLAG_EXPORT, &desc->flags)) {
581		spin_unlock_irqrestore(&gpio_lock, flags);
582		gpiod_dbg(desc, "%s: unavailable (requested=%d, exported=%d)\n",
583				__func__,
584				test_bit(FLAG_REQUESTED, &desc->flags),
585				test_bit(FLAG_EXPORT, &desc->flags));
586		status = -EPERM;
587		goto err_unlock;
588	}
589	spin_unlock_irqrestore(&gpio_lock, flags);
590
591	data = kzalloc(sizeof(*data), GFP_KERNEL);
592	if (!data) {
593		status = -ENOMEM;
594		goto err_unlock;
595	}
596
597	data->desc = desc;
598	mutex_init(&data->mutex);
599	if (chip->direction_input && chip->direction_output)
600		data->direction_can_change = direction_may_change;
601	else
602		data->direction_can_change = false;
603
604	offset = gpio_chip_hwgpio(desc);
605	if (chip->names && chip->names[offset])
606		ioname = chip->names[offset];
607
608	dev = device_create_with_groups(&gpio_class, chip->dev,
609					MKDEV(0, 0), data, gpio_groups,
610					ioname ? ioname : "gpio%u",
611					desc_to_gpio(desc));
612	if (IS_ERR(dev)) {
613		status = PTR_ERR(dev);
614		goto err_free_data;
615	}
616
617	set_bit(FLAG_EXPORT, &desc->flags);
618	mutex_unlock(&sysfs_lock);
619	return 0;
620
621err_free_data:
622	kfree(data);
623err_unlock:
624	mutex_unlock(&sysfs_lock);
625	gpiod_dbg(desc, "%s: status %d\n", __func__, status);
626	return status;
627}
628EXPORT_SYMBOL_GPL(gpiod_export);
629
630static int match_export(struct device *dev, const void *desc)
631{
632	struct gpiod_data *data = dev_get_drvdata(dev);
633
634	return data->desc == desc;
635}
636
637/**
638 * gpiod_export_link - create a sysfs link to an exported GPIO node
639 * @dev: device under which to create symlink
640 * @name: name of the symlink
641 * @gpio: gpio to create symlink to, already exported
642 *
643 * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
644 * node. Caller is responsible for unlinking.
645 *
646 * Returns zero on success, else an error.
647 */
648int gpiod_export_link(struct device *dev, const char *name,
649		      struct gpio_desc *desc)
650{
651	struct device *cdev;
652	int ret;
653
654	if (!desc) {
655		pr_warn("%s: invalid GPIO\n", __func__);
656		return -EINVAL;
657	}
658
659	cdev = class_find_device(&gpio_class, NULL, desc, match_export);
660	if (!cdev)
661		return -ENODEV;
662
663	ret = sysfs_create_link(&dev->kobj, &cdev->kobj, name);
664	put_device(cdev);
665
666	return ret;
667}
668EXPORT_SYMBOL_GPL(gpiod_export_link);
669
670/**
671 * gpiod_unexport - reverse effect of gpio_export()
672 * @gpio: gpio to make unavailable
673 *
674 * This is implicit on gpio_free().
675 */
676void gpiod_unexport(struct gpio_desc *desc)
677{
678	struct gpiod_data *data;
679	struct device *dev;
680
681	if (!desc) {
682		pr_warn("%s: invalid GPIO\n", __func__);
683		return;
684	}
685
686	mutex_lock(&sysfs_lock);
687
688	if (!test_bit(FLAG_EXPORT, &desc->flags))
689		goto err_unlock;
690
691	dev = class_find_device(&gpio_class, NULL, desc, match_export);
692	if (!dev)
693		goto err_unlock;
694
695	data = dev_get_drvdata(dev);
696
697	clear_bit(FLAG_EXPORT, &desc->flags);
698
699	device_unregister(dev);
700
701	/*
702	 * Release irq after deregistration to prevent race with edge_store.
703	 */
704	if (data->irq_flags)
705		gpio_sysfs_free_irq(dev);
706
707	mutex_unlock(&sysfs_lock);
708
709	put_device(dev);
710	kfree(data);
711
712	return;
713
714err_unlock:
715	mutex_unlock(&sysfs_lock);
716}
717EXPORT_SYMBOL_GPL(gpiod_unexport);
718
719int gpiochip_sysfs_register(struct gpio_chip *chip)
720{
721	struct device	*dev;
722
723	/*
724	 * Many systems add gpio chips for SOC support very early,
725	 * before driver model support is available.  In those cases we
726	 * register later, in gpiolib_sysfs_init() ... here we just
727	 * verify that _some_ field of gpio_class got initialized.
728	 */
729	if (!gpio_class.p)
730		return 0;
731
732	/* use chip->base for the ID; it's already known to be unique */
733	dev = device_create_with_groups(&gpio_class, chip->dev, MKDEV(0, 0),
734					chip, gpiochip_groups,
735					"gpiochip%d", chip->base);
736	if (IS_ERR(dev))
737		return PTR_ERR(dev);
738
739	mutex_lock(&sysfs_lock);
740	chip->cdev = dev;
741	mutex_unlock(&sysfs_lock);
742
743	return 0;
744}
745
746void gpiochip_sysfs_unregister(struct gpio_chip *chip)
747{
748	struct gpio_desc *desc;
749	unsigned int i;
750
751	if (!chip->cdev)
752		return;
753
754	device_unregister(chip->cdev);
755
756	/* prevent further gpiod exports */
757	mutex_lock(&sysfs_lock);
758	chip->cdev = NULL;
759	mutex_unlock(&sysfs_lock);
760
761	/* unregister gpiod class devices owned by sysfs */
762	for (i = 0; i < chip->ngpio; i++) {
763		desc = &chip->desc[i];
764		if (test_and_clear_bit(FLAG_SYSFS, &desc->flags))
765			gpiod_free(desc);
766	}
767}
768
769static int __init gpiolib_sysfs_init(void)
770{
771	int		status;
772	unsigned long	flags;
773	struct gpio_chip *chip;
774
775	status = class_register(&gpio_class);
776	if (status < 0)
777		return status;
778
779	/* Scan and register the gpio_chips which registered very
780	 * early (e.g. before the class_register above was called).
781	 *
782	 * We run before arch_initcall() so chip->dev nodes can have
783	 * registered, and so arch_initcall() can always gpio_export().
784	 */
785	spin_lock_irqsave(&gpio_lock, flags);
786	list_for_each_entry(chip, &gpio_chips, list) {
787		if (chip->cdev)
788			continue;
789
790		/*
791		 * TODO we yield gpio_lock here because
792		 * gpiochip_sysfs_register() acquires a mutex. This is unsafe
793		 * and needs to be fixed.
794		 *
795		 * Also it would be nice to use gpiochip_find() here so we
796		 * can keep gpio_chips local to gpiolib.c, but the yield of
797		 * gpio_lock prevents us from doing this.
798		 */
799		spin_unlock_irqrestore(&gpio_lock, flags);
800		status = gpiochip_sysfs_register(chip);
801		spin_lock_irqsave(&gpio_lock, flags);
802	}
803	spin_unlock_irqrestore(&gpio_lock, flags);
804
805
806	return status;
807}
808postcore_initcall(gpiolib_sysfs_init);
809