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>
12 static DEFINE_IDR(dirent_idr
);
15 /* lock protects against unexport_gpio() being called while
16 * sysfs files are active.
18 static DEFINE_MUTEX(sysfs_lock
);
21 * /sys/class/gpio/gpioN... only for GPIOs that are exported
23 * * MAY BE OMITTED if kernel won't allow direction changes
24 * * is read/write as "in" or "out"
25 * * may also be written as "high" or "low", initializing
26 * output value as specified ("out" implies "low")
28 * * always readable, subject to hardware behavior
29 * * may be writable, as zero/nonzero
31 * * configures behavior of poll(2) on /value
32 * * available only if pin can generate IRQs on input
33 * * is read/write as "none", "falling", "rising", or "both"
35 * * configures polarity of /value
36 * * is read/write as zero/nonzero
37 * * also affects existing and subsequent "falling" and "rising"
41 static ssize_t
gpio_direction_show(struct device
*dev
,
42 struct device_attribute
*attr
, char *buf
)
44 const struct gpio_desc
*desc
= dev_get_drvdata(dev
);
47 mutex_lock(&sysfs_lock
);
49 if (!test_bit(FLAG_EXPORT
, &desc
->flags
)) {
52 gpiod_get_direction(desc
);
53 status
= sprintf(buf
, "%s\n",
54 test_bit(FLAG_IS_OUT
, &desc
->flags
)
58 mutex_unlock(&sysfs_lock
);
62 static ssize_t
gpio_direction_store(struct device
*dev
,
63 struct device_attribute
*attr
, const char *buf
, size_t size
)
65 struct gpio_desc
*desc
= dev_get_drvdata(dev
);
68 mutex_lock(&sysfs_lock
);
70 if (!test_bit(FLAG_EXPORT
, &desc
->flags
))
72 else if (sysfs_streq(buf
, "high"))
73 status
= gpiod_direction_output_raw(desc
, 1);
74 else if (sysfs_streq(buf
, "out") || sysfs_streq(buf
, "low"))
75 status
= gpiod_direction_output_raw(desc
, 0);
76 else if (sysfs_streq(buf
, "in"))
77 status
= gpiod_direction_input(desc
);
81 mutex_unlock(&sysfs_lock
);
82 return status
? : size
;
85 static /* const */ DEVICE_ATTR(direction
, 0644,
86 gpio_direction_show
, gpio_direction_store
);
88 static ssize_t
gpio_value_show(struct device
*dev
,
89 struct device_attribute
*attr
, char *buf
)
91 struct gpio_desc
*desc
= dev_get_drvdata(dev
);
94 mutex_lock(&sysfs_lock
);
96 if (!test_bit(FLAG_EXPORT
, &desc
->flags
))
99 status
= sprintf(buf
, "%d\n", gpiod_get_value_cansleep(desc
));
101 mutex_unlock(&sysfs_lock
);
105 static ssize_t
gpio_value_store(struct device
*dev
,
106 struct device_attribute
*attr
, const char *buf
, size_t size
)
108 struct gpio_desc
*desc
= dev_get_drvdata(dev
);
111 mutex_lock(&sysfs_lock
);
113 if (!test_bit(FLAG_EXPORT
, &desc
->flags
))
115 else if (!test_bit(FLAG_IS_OUT
, &desc
->flags
))
120 status
= kstrtol(buf
, 0, &value
);
122 gpiod_set_value_cansleep(desc
, value
);
127 mutex_unlock(&sysfs_lock
);
131 static const DEVICE_ATTR(value
, 0644,
132 gpio_value_show
, gpio_value_store
);
134 static irqreturn_t
gpio_sysfs_irq(int irq
, void *priv
)
136 struct kernfs_node
*value_sd
= priv
;
138 sysfs_notify_dirent(value_sd
);
142 static int gpio_setup_irq(struct gpio_desc
*desc
, struct device
*dev
,
143 unsigned long gpio_flags
)
145 struct kernfs_node
*value_sd
;
146 unsigned long irq_flags
;
149 if ((desc
->flags
& GPIO_TRIGGER_MASK
) == gpio_flags
)
152 irq
= gpiod_to_irq(desc
);
156 id
= desc
->flags
>> ID_SHIFT
;
157 value_sd
= idr_find(&dirent_idr
, id
);
159 free_irq(irq
, value_sd
);
161 desc
->flags
&= ~GPIO_TRIGGER_MASK
;
164 gpio_unlock_as_irq(desc
->chip
, gpio_chip_hwgpio(desc
));
169 irq_flags
= IRQF_SHARED
;
170 if (test_bit(FLAG_TRIG_FALL
, &gpio_flags
))
171 irq_flags
|= test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
) ?
172 IRQF_TRIGGER_RISING
: IRQF_TRIGGER_FALLING
;
173 if (test_bit(FLAG_TRIG_RISE
, &gpio_flags
))
174 irq_flags
|= test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
) ?
175 IRQF_TRIGGER_FALLING
: IRQF_TRIGGER_RISING
;
178 value_sd
= sysfs_get_dirent(dev
->kobj
.sd
, "value");
184 ret
= idr_alloc(&dirent_idr
, value_sd
, 1, 0, GFP_KERNEL
);
189 desc
->flags
&= GPIO_FLAGS_MASK
;
190 desc
->flags
|= (unsigned long)id
<< ID_SHIFT
;
192 if (desc
->flags
>> ID_SHIFT
!= id
) {
198 ret
= request_any_context_irq(irq
, gpio_sysfs_irq
, irq_flags
,
199 "gpiolib", value_sd
);
203 ret
= gpio_lock_as_irq(desc
->chip
, gpio_chip_hwgpio(desc
));
205 gpiod_warn(desc
, "failed to flag the GPIO for IRQ\n");
209 desc
->flags
|= gpio_flags
;
213 idr_remove(&dirent_idr
, id
);
214 desc
->flags
&= GPIO_FLAGS_MASK
;
222 static const struct {
225 } trigger_types
[] = {
227 { "falling", BIT(FLAG_TRIG_FALL
) },
228 { "rising", BIT(FLAG_TRIG_RISE
) },
229 { "both", BIT(FLAG_TRIG_FALL
) | BIT(FLAG_TRIG_RISE
) },
232 static ssize_t
gpio_edge_show(struct device
*dev
,
233 struct device_attribute
*attr
, char *buf
)
235 const struct gpio_desc
*desc
= dev_get_drvdata(dev
);
238 mutex_lock(&sysfs_lock
);
240 if (!test_bit(FLAG_EXPORT
, &desc
->flags
))
246 for (i
= 0; i
< ARRAY_SIZE(trigger_types
); i
++)
247 if ((desc
->flags
& GPIO_TRIGGER_MASK
)
248 == trigger_types
[i
].flags
) {
249 status
= sprintf(buf
, "%s\n",
250 trigger_types
[i
].name
);
255 mutex_unlock(&sysfs_lock
);
259 static ssize_t
gpio_edge_store(struct device
*dev
,
260 struct device_attribute
*attr
, const char *buf
, size_t size
)
262 struct gpio_desc
*desc
= dev_get_drvdata(dev
);
266 for (i
= 0; i
< ARRAY_SIZE(trigger_types
); i
++)
267 if (sysfs_streq(trigger_types
[i
].name
, buf
))
272 mutex_lock(&sysfs_lock
);
274 if (!test_bit(FLAG_EXPORT
, &desc
->flags
))
277 status
= gpio_setup_irq(desc
, dev
, trigger_types
[i
].flags
);
282 mutex_unlock(&sysfs_lock
);
287 static DEVICE_ATTR(edge
, 0644, gpio_edge_show
, gpio_edge_store
);
289 static int sysfs_set_active_low(struct gpio_desc
*desc
, struct device
*dev
,
294 if (!!test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
) == !!value
)
298 set_bit(FLAG_ACTIVE_LOW
, &desc
->flags
);
300 clear_bit(FLAG_ACTIVE_LOW
, &desc
->flags
);
302 /* reconfigure poll(2) support if enabled on one edge only */
303 if (dev
!= NULL
&& (!!test_bit(FLAG_TRIG_RISE
, &desc
->flags
) ^
304 !!test_bit(FLAG_TRIG_FALL
, &desc
->flags
))) {
305 unsigned long trigger_flags
= desc
->flags
& GPIO_TRIGGER_MASK
;
307 gpio_setup_irq(desc
, dev
, 0);
308 status
= gpio_setup_irq(desc
, dev
, trigger_flags
);
314 static ssize_t
gpio_active_low_show(struct device
*dev
,
315 struct device_attribute
*attr
, char *buf
)
317 const struct gpio_desc
*desc
= dev_get_drvdata(dev
);
320 mutex_lock(&sysfs_lock
);
322 if (!test_bit(FLAG_EXPORT
, &desc
->flags
))
325 status
= sprintf(buf
, "%d\n",
326 !!test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
));
328 mutex_unlock(&sysfs_lock
);
333 static ssize_t
gpio_active_low_store(struct device
*dev
,
334 struct device_attribute
*attr
, const char *buf
, size_t size
)
336 struct gpio_desc
*desc
= dev_get_drvdata(dev
);
339 mutex_lock(&sysfs_lock
);
341 if (!test_bit(FLAG_EXPORT
, &desc
->flags
)) {
346 status
= kstrtol(buf
, 0, &value
);
348 status
= sysfs_set_active_low(desc
, dev
, value
!= 0);
351 mutex_unlock(&sysfs_lock
);
353 return status
? : size
;
356 static const DEVICE_ATTR(active_low
, 0644,
357 gpio_active_low_show
, gpio_active_low_store
);
359 static const struct attribute
*gpio_attrs
[] = {
360 &dev_attr_value
.attr
,
361 &dev_attr_active_low
.attr
,
365 static const struct attribute_group gpio_attr_group
= {
366 .attrs
= (struct attribute
**) gpio_attrs
,
370 * /sys/class/gpio/gpiochipN/
371 * /base ... matching gpio_chip.base (N)
372 * /label ... matching gpio_chip.label
373 * /ngpio ... matching gpio_chip.ngpio
376 static ssize_t
chip_base_show(struct device
*dev
,
377 struct device_attribute
*attr
, char *buf
)
379 const struct gpio_chip
*chip
= dev_get_drvdata(dev
);
381 return sprintf(buf
, "%d\n", chip
->base
);
383 static DEVICE_ATTR(base
, 0444, chip_base_show
, NULL
);
385 static ssize_t
chip_label_show(struct device
*dev
,
386 struct device_attribute
*attr
, char *buf
)
388 const struct gpio_chip
*chip
= dev_get_drvdata(dev
);
390 return sprintf(buf
, "%s\n", chip
->label
? : "");
392 static DEVICE_ATTR(label
, 0444, chip_label_show
, NULL
);
394 static ssize_t
chip_ngpio_show(struct device
*dev
,
395 struct device_attribute
*attr
, char *buf
)
397 const struct gpio_chip
*chip
= dev_get_drvdata(dev
);
399 return sprintf(buf
, "%u\n", chip
->ngpio
);
401 static DEVICE_ATTR(ngpio
, 0444, chip_ngpio_show
, NULL
);
403 static const struct attribute
*gpiochip_attrs
[] = {
405 &dev_attr_label
.attr
,
406 &dev_attr_ngpio
.attr
,
410 static const struct attribute_group gpiochip_attr_group
= {
411 .attrs
= (struct attribute
**) gpiochip_attrs
,
415 * /sys/class/gpio/export ... write-only
416 * integer N ... number of GPIO to export (full access)
417 * /sys/class/gpio/unexport ... write-only
418 * integer N ... number of GPIO to unexport
420 static ssize_t
export_store(struct class *class,
421 struct class_attribute
*attr
,
422 const char *buf
, size_t len
)
425 struct gpio_desc
*desc
;
428 status
= kstrtol(buf
, 0, &gpio
);
432 desc
= gpio_to_desc(gpio
);
433 /* reject invalid GPIOs */
435 pr_warn("%s: invalid GPIO %ld\n", __func__
, gpio
);
439 /* No extra locking here; FLAG_SYSFS just signifies that the
440 * request and export were done by on behalf of userspace, so
441 * they may be undone on its behalf too.
444 status
= gpiod_request(desc
, "sysfs");
446 if (status
== -EPROBE_DEFER
)
450 status
= gpiod_export(desc
, true);
454 set_bit(FLAG_SYSFS
, &desc
->flags
);
458 pr_debug("%s: status %d\n", __func__
, status
);
459 return status
? : len
;
462 static ssize_t
unexport_store(struct class *class,
463 struct class_attribute
*attr
,
464 const char *buf
, size_t len
)
467 struct gpio_desc
*desc
;
470 status
= kstrtol(buf
, 0, &gpio
);
474 desc
= gpio_to_desc(gpio
);
475 /* reject bogus commands (gpio_unexport ignores them) */
477 pr_warn("%s: invalid GPIO %ld\n", __func__
, gpio
);
483 /* No extra locking here; FLAG_SYSFS just signifies that the
484 * request and export were done by on behalf of userspace, so
485 * they may be undone on its behalf too.
487 if (test_and_clear_bit(FLAG_SYSFS
, &desc
->flags
)) {
493 pr_debug("%s: status %d\n", __func__
, status
);
494 return status
? : len
;
497 static struct class_attribute gpio_class_attrs
[] = {
498 __ATTR(export
, 0200, NULL
, export_store
),
499 __ATTR(unexport
, 0200, NULL
, unexport_store
),
503 static struct class gpio_class
= {
505 .owner
= THIS_MODULE
,
507 .class_attrs
= gpio_class_attrs
,
512 * gpiod_export - export a GPIO through sysfs
513 * @gpio: gpio to make available, already requested
514 * @direction_may_change: true if userspace may change gpio direction
515 * Context: arch_initcall or later
517 * When drivers want to make a GPIO accessible to userspace after they
518 * have requested it -- perhaps while debugging, or as part of their
519 * public interface -- they may use this routine. If the GPIO can
520 * change direction (some can't) and the caller allows it, userspace
521 * will see "direction" sysfs attribute which may be used to change
522 * the gpio's direction. A "value" attribute will always be provided.
524 * Returns zero on success, else an error.
526 int gpiod_export(struct gpio_desc
*desc
, bool direction_may_change
)
530 const char *ioname
= NULL
;
534 /* can't export until sysfs is available ... */
536 pr_debug("%s: called too early!\n", __func__
);
541 pr_debug("%s: invalid gpio descriptor\n", __func__
);
545 mutex_lock(&sysfs_lock
);
547 spin_lock_irqsave(&gpio_lock
, flags
);
548 if (!test_bit(FLAG_REQUESTED
, &desc
->flags
) ||
549 test_bit(FLAG_EXPORT
, &desc
->flags
)) {
550 spin_unlock_irqrestore(&gpio_lock
, flags
);
551 gpiod_dbg(desc
, "%s: unavailable (requested=%d, exported=%d)\n",
553 test_bit(FLAG_REQUESTED
, &desc
->flags
),
554 test_bit(FLAG_EXPORT
, &desc
->flags
));
559 if (!desc
->chip
->direction_input
|| !desc
->chip
->direction_output
)
560 direction_may_change
= false;
561 spin_unlock_irqrestore(&gpio_lock
, flags
);
563 offset
= gpio_chip_hwgpio(desc
);
564 if (desc
->chip
->names
&& desc
->chip
->names
[offset
])
565 ioname
= desc
->chip
->names
[offset
];
567 dev
= device_create(&gpio_class
, desc
->chip
->dev
, MKDEV(0, 0),
568 desc
, ioname
? ioname
: "gpio%u",
571 status
= PTR_ERR(dev
);
575 status
= sysfs_create_group(&dev
->kobj
, &gpio_attr_group
);
577 goto fail_unregister_device
;
579 if (direction_may_change
) {
580 status
= device_create_file(dev
, &dev_attr_direction
);
582 goto fail_unregister_device
;
585 if (gpiod_to_irq(desc
) >= 0 && (direction_may_change
||
586 !test_bit(FLAG_IS_OUT
, &desc
->flags
))) {
587 status
= device_create_file(dev
, &dev_attr_edge
);
589 goto fail_unregister_device
;
592 set_bit(FLAG_EXPORT
, &desc
->flags
);
593 mutex_unlock(&sysfs_lock
);
596 fail_unregister_device
:
597 device_unregister(dev
);
599 mutex_unlock(&sysfs_lock
);
600 gpiod_dbg(desc
, "%s: status %d\n", __func__
, status
);
603 EXPORT_SYMBOL_GPL(gpiod_export
);
605 static int match_export(struct device
*dev
, const void *data
)
607 return dev_get_drvdata(dev
) == data
;
611 * gpiod_export_link - create a sysfs link to an exported GPIO node
612 * @dev: device under which to create symlink
613 * @name: name of the symlink
614 * @gpio: gpio to create symlink to, already exported
616 * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
617 * node. Caller is responsible for unlinking.
619 * Returns zero on success, else an error.
621 int gpiod_export_link(struct device
*dev
, const char *name
,
622 struct gpio_desc
*desc
)
624 int status
= -EINVAL
;
627 pr_warn("%s: invalid GPIO\n", __func__
);
631 mutex_lock(&sysfs_lock
);
633 if (test_bit(FLAG_EXPORT
, &desc
->flags
)) {
636 tdev
= class_find_device(&gpio_class
, NULL
, desc
, match_export
);
638 status
= sysfs_create_link(&dev
->kobj
, &tdev
->kobj
,
645 mutex_unlock(&sysfs_lock
);
648 gpiod_dbg(desc
, "%s: status %d\n", __func__
, status
);
652 EXPORT_SYMBOL_GPL(gpiod_export_link
);
655 * gpiod_sysfs_set_active_low - set the polarity of gpio sysfs value
656 * @gpio: gpio to change
657 * @value: non-zero to use active low, i.e. inverted values
659 * Set the polarity of /sys/class/gpio/gpioN/value sysfs attribute.
660 * The GPIO does not have to be exported yet. If poll(2) support has
661 * been enabled for either rising or falling edge, it will be
662 * reconfigured to follow the new polarity.
664 * Returns zero on success, else an error.
666 int gpiod_sysfs_set_active_low(struct gpio_desc
*desc
, int value
)
668 struct device
*dev
= NULL
;
669 int status
= -EINVAL
;
672 pr_warn("%s: invalid GPIO\n", __func__
);
676 mutex_lock(&sysfs_lock
);
678 if (test_bit(FLAG_EXPORT
, &desc
->flags
)) {
679 dev
= class_find_device(&gpio_class
, NULL
, desc
, match_export
);
686 status
= sysfs_set_active_low(desc
, dev
, value
);
689 mutex_unlock(&sysfs_lock
);
692 gpiod_dbg(desc
, "%s: status %d\n", __func__
, status
);
696 EXPORT_SYMBOL_GPL(gpiod_sysfs_set_active_low
);
699 * gpiod_unexport - reverse effect of gpio_export()
700 * @gpio: gpio to make unavailable
702 * This is implicit on gpio_free().
704 void gpiod_unexport(struct gpio_desc
*desc
)
707 struct device
*dev
= NULL
;
710 pr_warn("%s: invalid GPIO\n", __func__
);
714 mutex_lock(&sysfs_lock
);
716 if (test_bit(FLAG_EXPORT
, &desc
->flags
)) {
718 dev
= class_find_device(&gpio_class
, NULL
, desc
, match_export
);
720 gpio_setup_irq(desc
, dev
, 0);
721 clear_bit(FLAG_EXPORT
, &desc
->flags
);
726 mutex_unlock(&sysfs_lock
);
729 device_unregister(dev
);
734 gpiod_dbg(desc
, "%s: status %d\n", __func__
, status
);
736 EXPORT_SYMBOL_GPL(gpiod_unexport
);
738 int gpiochip_export(struct gpio_chip
*chip
)
743 /* Many systems register gpio chips for SOC support very early,
744 * before driver model support is available. In those cases we
745 * export this later, in gpiolib_sysfs_init() ... here we just
746 * verify that _some_ field of gpio_class got initialized.
751 /* use chip->base for the ID; it's already known to be unique */
752 mutex_lock(&sysfs_lock
);
753 dev
= device_create(&gpio_class
, chip
->dev
, MKDEV(0, 0), chip
,
754 "gpiochip%d", chip
->base
);
756 status
= sysfs_create_group(&dev
->kobj
,
757 &gpiochip_attr_group
);
759 status
= PTR_ERR(dev
);
760 chip
->exported
= (status
== 0);
761 mutex_unlock(&sysfs_lock
);
764 chip_dbg(chip
, "%s: status %d\n", __func__
, status
);
769 void gpiochip_unexport(struct gpio_chip
*chip
)
774 mutex_lock(&sysfs_lock
);
775 dev
= class_find_device(&gpio_class
, NULL
, chip
, match_export
);
778 device_unregister(dev
);
779 chip
->exported
= false;
783 mutex_unlock(&sysfs_lock
);
786 chip_dbg(chip
, "%s: status %d\n", __func__
, status
);
789 static int __init
gpiolib_sysfs_init(void)
793 struct gpio_chip
*chip
;
795 status
= class_register(&gpio_class
);
799 /* Scan and register the gpio_chips which registered very
800 * early (e.g. before the class_register above was called).
802 * We run before arch_initcall() so chip->dev nodes can have
803 * registered, and so arch_initcall() can always gpio_export().
805 spin_lock_irqsave(&gpio_lock
, flags
);
806 list_for_each_entry(chip
, &gpio_chips
, list
) {
811 * TODO we yield gpio_lock here because gpiochip_export()
812 * acquires a mutex. This is unsafe and needs to be fixed.
814 * Also it would be nice to use gpiochip_find() here so we
815 * can keep gpio_chips local to gpiolib.c, but the yield of
816 * gpio_lock prevents us from doing this.
818 spin_unlock_irqrestore(&gpio_lock
, flags
);
819 status
= gpiochip_export(chip
);
820 spin_lock_irqsave(&gpio_lock
, flags
);
822 spin_unlock_irqrestore(&gpio_lock
, flags
);
827 postcore_initcall(gpiolib_sysfs_init
);