Linux Audio

Check our new training course

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