1 // SPDX-License-Identifier: GPL-2.0
3 #include <linux/mutex.h>
4 #include <linux/device.h>
5 #include <linux/sysfs.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>
14 #include "gpiolib-sysfs.h"
16 #define GPIO_IRQF_TRIGGER_FALLING BIT(0)
17 #define GPIO_IRQF_TRIGGER_RISING BIT(1)
18 #define GPIO_IRQF_TRIGGER_BOTH (GPIO_IRQF_TRIGGER_FALLING | \
19 GPIO_IRQF_TRIGGER_RISING)
22 struct gpio_desc
*desc
;
25 struct kernfs_node
*value_kn
;
27 unsigned char irq_flags
;
29 bool direction_can_change
;
33 * Lock to serialise gpiod export and unexport, and prevent re-export of
34 * gpiod whose chip is being unregistered.
36 static DEFINE_MUTEX(sysfs_lock
);
39 * /sys/class/gpio/gpioN... only for GPIOs that are exported
41 * * MAY BE OMITTED if kernel won't allow direction changes
42 * * is read/write as "in" or "out"
43 * * may also be written as "high" or "low", initializing
44 * output value as specified ("out" implies "low")
46 * * always readable, subject to hardware behavior
47 * * may be writable, as zero/nonzero
49 * * configures behavior of poll(2) on /value
50 * * available only if pin can generate IRQs on input
51 * * is read/write as "none", "falling", "rising", or "both"
53 * * configures polarity of /value
54 * * is read/write as zero/nonzero
55 * * also affects existing and subsequent "falling" and "rising"
59 static ssize_t
direction_show(struct device
*dev
,
60 struct device_attribute
*attr
, char *buf
)
62 struct gpiod_data
*data
= dev_get_drvdata(dev
);
63 struct gpio_desc
*desc
= data
->desc
;
66 mutex_lock(&data
->mutex
);
68 gpiod_get_direction(desc
);
69 status
= sysfs_emit(buf
, "%s\n",
70 test_bit(FLAG_IS_OUT
, &desc
->flags
) ? "out" : "in");
72 mutex_unlock(&data
->mutex
);
77 static ssize_t
direction_store(struct device
*dev
,
78 struct device_attribute
*attr
, const char *buf
, size_t size
)
80 struct gpiod_data
*data
= dev_get_drvdata(dev
);
81 struct gpio_desc
*desc
= data
->desc
;
84 mutex_lock(&data
->mutex
);
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
);
95 mutex_unlock(&data
->mutex
);
97 return status
? : size
;
99 static DEVICE_ATTR_RW(direction
);
101 static ssize_t
value_show(struct device
*dev
,
102 struct device_attribute
*attr
, char *buf
)
104 struct gpiod_data
*data
= dev_get_drvdata(dev
);
105 struct gpio_desc
*desc
= data
->desc
;
108 mutex_lock(&data
->mutex
);
110 status
= gpiod_get_value_cansleep(desc
);
112 status
= sysfs_emit(buf
, "%zd\n", status
);
114 mutex_unlock(&data
->mutex
);
119 static ssize_t
value_store(struct device
*dev
,
120 struct device_attribute
*attr
, const char *buf
, size_t size
)
122 struct gpiod_data
*data
= dev_get_drvdata(dev
);
123 struct gpio_desc
*desc
= data
->desc
;
126 mutex_lock(&data
->mutex
);
128 if (!test_bit(FLAG_IS_OUT
, &desc
->flags
)) {
133 if (size
<= 2 && isdigit(buf
[0]) &&
134 (size
== 1 || buf
[1] == '\n'))
135 value
= buf
[0] - '0';
137 status
= kstrtol(buf
, 0, &value
);
139 gpiod_set_value_cansleep(desc
, value
);
144 mutex_unlock(&data
->mutex
);
148 static DEVICE_ATTR_PREALLOC(value
, S_IWUSR
| S_IRUGO
, value_show
, value_store
);
150 static irqreturn_t
gpio_sysfs_irq(int irq
, void *priv
)
152 struct gpiod_data
*data
= priv
;
154 sysfs_notify_dirent(data
->value_kn
);
159 /* Caller holds gpiod-data mutex. */
160 static int gpio_sysfs_request_irq(struct device
*dev
, unsigned char flags
)
162 struct gpiod_data
*data
= dev_get_drvdata(dev
);
163 struct gpio_desc
*desc
= data
->desc
;
164 unsigned long irq_flags
;
167 data
->irq
= gpiod_to_irq(desc
);
171 data
->value_kn
= sysfs_get_dirent(dev
->kobj
.sd
, "value");
175 irq_flags
= IRQF_SHARED
;
176 if (flags
& GPIO_IRQF_TRIGGER_FALLING
)
177 irq_flags
|= test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
) ?
178 IRQF_TRIGGER_RISING
: IRQF_TRIGGER_FALLING
;
179 if (flags
& GPIO_IRQF_TRIGGER_RISING
)
180 irq_flags
|= test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
) ?
181 IRQF_TRIGGER_FALLING
: IRQF_TRIGGER_RISING
;
184 * FIXME: This should be done in the irq_request_resources callback
185 * when the irq is requested, but a few drivers currently fail
188 * Remove this redundant call (along with the corresponding
189 * unlock) when those drivers have been fixed.
191 ret
= gpiochip_lock_as_irq(desc
->gdev
->chip
, gpio_chip_hwgpio(desc
));
195 ret
= request_any_context_irq(data
->irq
, gpio_sysfs_irq
, irq_flags
,
200 data
->irq_flags
= flags
;
205 gpiochip_unlock_as_irq(desc
->gdev
->chip
, gpio_chip_hwgpio(desc
));
207 sysfs_put(data
->value_kn
);
213 * Caller holds gpiod-data mutex (unless called after class-device
216 static void gpio_sysfs_free_irq(struct device
*dev
)
218 struct gpiod_data
*data
= dev_get_drvdata(dev
);
219 struct gpio_desc
*desc
= data
->desc
;
222 free_irq(data
->irq
, data
);
223 gpiochip_unlock_as_irq(desc
->gdev
->chip
, gpio_chip_hwgpio(desc
));
224 sysfs_put(data
->value_kn
);
227 static const struct {
230 } trigger_types
[] = {
232 { "falling", GPIO_IRQF_TRIGGER_FALLING
},
233 { "rising", GPIO_IRQF_TRIGGER_RISING
},
234 { "both", GPIO_IRQF_TRIGGER_BOTH
},
237 static ssize_t
edge_show(struct device
*dev
,
238 struct device_attribute
*attr
, char *buf
)
240 struct gpiod_data
*data
= dev_get_drvdata(dev
);
244 mutex_lock(&data
->mutex
);
246 for (i
= 0; i
< ARRAY_SIZE(trigger_types
); i
++) {
247 if (data
->irq_flags
== trigger_types
[i
].flags
)
250 if (i
< ARRAY_SIZE(trigger_types
))
251 status
= sysfs_emit(buf
, "%s\n", trigger_types
[i
].name
);
253 mutex_unlock(&data
->mutex
);
258 static ssize_t
edge_store(struct device
*dev
,
259 struct device_attribute
*attr
, const char *buf
, size_t size
)
261 struct gpiod_data
*data
= dev_get_drvdata(dev
);
263 ssize_t status
= size
;
266 for (i
= 0; i
< ARRAY_SIZE(trigger_types
); i
++) {
267 if (sysfs_streq(trigger_types
[i
].name
, buf
))
271 if (i
== ARRAY_SIZE(trigger_types
))
274 flags
= trigger_types
[i
].flags
;
276 mutex_lock(&data
->mutex
);
278 if (flags
== data
->irq_flags
) {
284 gpio_sysfs_free_irq(dev
);
287 status
= gpio_sysfs_request_irq(dev
, flags
);
293 mutex_unlock(&data
->mutex
);
297 static DEVICE_ATTR_RW(edge
);
299 /* Caller holds gpiod-data mutex. */
300 static int gpio_sysfs_set_active_low(struct device
*dev
, int value
)
302 struct gpiod_data
*data
= dev_get_drvdata(dev
);
303 struct gpio_desc
*desc
= data
->desc
;
305 unsigned int flags
= data
->irq_flags
;
307 if (!!test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
) == !!value
)
310 assign_bit(FLAG_ACTIVE_LOW
, &desc
->flags
, value
);
312 /* reconfigure poll(2) support if enabled on one edge only */
313 if (flags
== GPIO_IRQF_TRIGGER_FALLING
||
314 flags
== GPIO_IRQF_TRIGGER_RISING
) {
315 gpio_sysfs_free_irq(dev
);
316 status
= gpio_sysfs_request_irq(dev
, flags
);
322 static ssize_t
active_low_show(struct device
*dev
,
323 struct device_attribute
*attr
, char *buf
)
325 struct gpiod_data
*data
= dev_get_drvdata(dev
);
326 struct gpio_desc
*desc
= data
->desc
;
329 mutex_lock(&data
->mutex
);
331 status
= sysfs_emit(buf
, "%d\n",
332 !!test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
));
334 mutex_unlock(&data
->mutex
);
339 static ssize_t
active_low_store(struct device
*dev
,
340 struct device_attribute
*attr
, const char *buf
, size_t size
)
342 struct gpiod_data
*data
= dev_get_drvdata(dev
);
346 mutex_lock(&data
->mutex
);
348 status
= kstrtol(buf
, 0, &value
);
350 status
= gpio_sysfs_set_active_low(dev
, value
);
352 mutex_unlock(&data
->mutex
);
354 return status
? : size
;
356 static DEVICE_ATTR_RW(active_low
);
358 static umode_t
gpio_is_visible(struct kobject
*kobj
, struct attribute
*attr
,
361 struct device
*dev
= kobj_to_dev(kobj
);
362 struct gpiod_data
*data
= dev_get_drvdata(dev
);
363 struct gpio_desc
*desc
= data
->desc
;
364 umode_t mode
= attr
->mode
;
365 bool show_direction
= data
->direction_can_change
;
367 if (attr
== &dev_attr_direction
.attr
) {
370 } else if (attr
== &dev_attr_edge
.attr
) {
371 if (gpiod_to_irq(desc
) < 0)
373 if (!show_direction
&& test_bit(FLAG_IS_OUT
, &desc
->flags
))
380 static struct attribute
*gpio_attrs
[] = {
381 &dev_attr_direction
.attr
,
383 &dev_attr_value
.attr
,
384 &dev_attr_active_low
.attr
,
388 static const struct attribute_group gpio_group
= {
390 .is_visible
= gpio_is_visible
,
393 static const struct attribute_group
*gpio_groups
[] = {
399 * /sys/class/gpio/gpiochipN/
400 * /base ... matching gpio_chip.base (N)
401 * /label ... matching gpio_chip.label
402 * /ngpio ... matching gpio_chip.ngpio
405 static ssize_t
base_show(struct device
*dev
,
406 struct device_attribute
*attr
, char *buf
)
408 const struct gpio_chip
*chip
= dev_get_drvdata(dev
);
410 return sysfs_emit(buf
, "%d\n", chip
->base
);
412 static DEVICE_ATTR_RO(base
);
414 static ssize_t
label_show(struct device
*dev
,
415 struct device_attribute
*attr
, char *buf
)
417 const struct gpio_chip
*chip
= dev_get_drvdata(dev
);
419 return sysfs_emit(buf
, "%s\n", chip
->label
?: "");
421 static DEVICE_ATTR_RO(label
);
423 static ssize_t
ngpio_show(struct device
*dev
,
424 struct device_attribute
*attr
, char *buf
)
426 const struct gpio_chip
*chip
= dev_get_drvdata(dev
);
428 return sysfs_emit(buf
, "%u\n", chip
->ngpio
);
430 static DEVICE_ATTR_RO(ngpio
);
432 static struct attribute
*gpiochip_attrs
[] = {
434 &dev_attr_label
.attr
,
435 &dev_attr_ngpio
.attr
,
438 ATTRIBUTE_GROUPS(gpiochip
);
441 * /sys/class/gpio/export ... write-only
442 * integer N ... number of GPIO to export (full access)
443 * /sys/class/gpio/unexport ... write-only
444 * integer N ... number of GPIO to unexport
446 static ssize_t
export_store(struct class *class,
447 struct class_attribute
*attr
,
448 const char *buf
, size_t len
)
451 struct gpio_desc
*desc
;
453 struct gpio_chip
*gc
;
456 status
= kstrtol(buf
, 0, &gpio
);
460 desc
= gpio_to_desc(gpio
);
461 /* reject invalid GPIOs */
463 pr_warn("%s: invalid GPIO %ld\n", __func__
, gpio
);
466 gc
= desc
->gdev
->chip
;
467 offset
= gpio_chip_hwgpio(desc
);
468 if (!gpiochip_line_is_valid(gc
, offset
)) {
469 pr_warn("%s: GPIO %ld masked\n", __func__
, gpio
);
473 /* No extra locking here; FLAG_SYSFS just signifies that the
474 * request and export were done by on behalf of userspace, so
475 * they may be undone on its behalf too.
478 status
= gpiod_request(desc
, "sysfs");
480 if (status
== -EPROBE_DEFER
)
485 status
= gpiod_set_transitory(desc
, false);
487 status
= gpiod_export(desc
, true);
491 set_bit(FLAG_SYSFS
, &desc
->flags
);
496 pr_debug("%s: status %d\n", __func__
, status
);
497 return status
? : len
;
499 static CLASS_ATTR_WO(export
);
501 static ssize_t
unexport_store(struct class *class,
502 struct class_attribute
*attr
,
503 const char *buf
, size_t len
)
506 struct gpio_desc
*desc
;
509 status
= kstrtol(buf
, 0, &gpio
);
513 desc
= gpio_to_desc(gpio
);
514 /* reject bogus commands (gpio_unexport ignores them) */
516 pr_warn("%s: invalid GPIO %ld\n", __func__
, gpio
);
522 /* No extra locking here; FLAG_SYSFS just signifies that the
523 * request and export were done by on behalf of userspace, so
524 * they may be undone on its behalf too.
526 if (test_and_clear_bit(FLAG_SYSFS
, &desc
->flags
)) {
532 pr_debug("%s: status %d\n", __func__
, status
);
533 return status
? : len
;
535 static CLASS_ATTR_WO(unexport
);
537 static struct attribute
*gpio_class_attrs
[] = {
538 &class_attr_export
.attr
,
539 &class_attr_unexport
.attr
,
542 ATTRIBUTE_GROUPS(gpio_class
);
544 static struct class gpio_class
= {
546 .owner
= THIS_MODULE
,
548 .class_groups
= gpio_class_groups
,
553 * gpiod_export - export a GPIO through sysfs
554 * @desc: GPIO to make available, already requested
555 * @direction_may_change: true if userspace may change GPIO direction
556 * Context: arch_initcall or later
558 * When drivers want to make a GPIO accessible to userspace after they
559 * have requested it -- perhaps while debugging, or as part of their
560 * public interface -- they may use this routine. If the GPIO can
561 * change direction (some can't) and the caller allows it, userspace
562 * will see "direction" sysfs attribute which may be used to change
563 * the gpio's direction. A "value" attribute will always be provided.
565 * Returns zero on success, else an error.
567 int gpiod_export(struct gpio_desc
*desc
, bool direction_may_change
)
569 struct gpio_chip
*chip
;
570 struct gpio_device
*gdev
;
571 struct gpiod_data
*data
;
574 const char *ioname
= NULL
;
578 /* can't export until sysfs is available ... */
580 pr_debug("%s: called too early!\n", __func__
);
585 pr_debug("%s: invalid gpio descriptor\n", __func__
);
592 mutex_lock(&sysfs_lock
);
594 /* check if chip is being removed */
595 if (!chip
|| !gdev
->mockdev
) {
600 spin_lock_irqsave(&gpio_lock
, flags
);
601 if (!test_bit(FLAG_REQUESTED
, &desc
->flags
) ||
602 test_bit(FLAG_EXPORT
, &desc
->flags
)) {
603 spin_unlock_irqrestore(&gpio_lock
, flags
);
604 gpiod_dbg(desc
, "%s: unavailable (requested=%d, exported=%d)\n",
606 test_bit(FLAG_REQUESTED
, &desc
->flags
),
607 test_bit(FLAG_EXPORT
, &desc
->flags
));
611 spin_unlock_irqrestore(&gpio_lock
, flags
);
613 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
620 mutex_init(&data
->mutex
);
621 if (chip
->direction_input
&& chip
->direction_output
)
622 data
->direction_can_change
= direction_may_change
;
624 data
->direction_can_change
= false;
626 offset
= gpio_chip_hwgpio(desc
);
627 if (chip
->names
&& chip
->names
[offset
])
628 ioname
= chip
->names
[offset
];
630 dev
= device_create_with_groups(&gpio_class
, &gdev
->dev
,
631 MKDEV(0, 0), data
, gpio_groups
,
632 ioname
? ioname
: "gpio%u",
635 status
= PTR_ERR(dev
);
639 set_bit(FLAG_EXPORT
, &desc
->flags
);
640 mutex_unlock(&sysfs_lock
);
646 mutex_unlock(&sysfs_lock
);
647 gpiod_dbg(desc
, "%s: status %d\n", __func__
, status
);
650 EXPORT_SYMBOL_GPL(gpiod_export
);
652 static int match_export(struct device
*dev
, const void *desc
)
654 struct gpiod_data
*data
= dev_get_drvdata(dev
);
656 return data
->desc
== desc
;
660 * gpiod_export_link - create a sysfs link to an exported GPIO node
661 * @dev: device under which to create symlink
662 * @name: name of the symlink
663 * @desc: GPIO to create symlink to, already exported
665 * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
666 * node. Caller is responsible for unlinking.
668 * Returns zero on success, else an error.
670 int gpiod_export_link(struct device
*dev
, const char *name
,
671 struct gpio_desc
*desc
)
677 pr_warn("%s: invalid GPIO\n", __func__
);
681 cdev
= class_find_device(&gpio_class
, NULL
, desc
, match_export
);
685 ret
= sysfs_create_link(&dev
->kobj
, &cdev
->kobj
, name
);
690 EXPORT_SYMBOL_GPL(gpiod_export_link
);
693 * gpiod_unexport - reverse effect of gpiod_export()
694 * @desc: GPIO to make unavailable
696 * This is implicit on gpiod_free().
698 void gpiod_unexport(struct gpio_desc
*desc
)
700 struct gpiod_data
*data
;
704 pr_warn("%s: invalid GPIO\n", __func__
);
708 mutex_lock(&sysfs_lock
);
710 if (!test_bit(FLAG_EXPORT
, &desc
->flags
))
713 dev
= class_find_device(&gpio_class
, NULL
, desc
, match_export
);
717 data
= dev_get_drvdata(dev
);
719 clear_bit(FLAG_EXPORT
, &desc
->flags
);
721 device_unregister(dev
);
724 * Release irq after deregistration to prevent race with edge_store.
727 gpio_sysfs_free_irq(dev
);
729 mutex_unlock(&sysfs_lock
);
737 mutex_unlock(&sysfs_lock
);
739 EXPORT_SYMBOL_GPL(gpiod_unexport
);
741 int gpiochip_sysfs_register(struct gpio_device
*gdev
)
744 struct device
*parent
;
745 struct gpio_chip
*chip
= gdev
->chip
;
748 * Many systems add gpio chips for SOC support very early,
749 * before driver model support is available. In those cases we
750 * register later, in gpiolib_sysfs_init() ... here we just
751 * verify that _some_ field of gpio_class got initialized.
757 * For sysfs backward compatibility we need to preserve this
758 * preferred parenting to the gpio_chip parent field, if set.
761 parent
= chip
->parent
;
765 /* use chip->base for the ID; it's already known to be unique */
766 dev
= device_create_with_groups(&gpio_class
, parent
, MKDEV(0, 0), chip
,
767 gpiochip_groups
, GPIOCHIP_NAME
"%d",
772 mutex_lock(&sysfs_lock
);
774 mutex_unlock(&sysfs_lock
);
779 void gpiochip_sysfs_unregister(struct gpio_device
*gdev
)
781 struct gpio_desc
*desc
;
782 struct gpio_chip
*chip
= gdev
->chip
;
788 device_unregister(gdev
->mockdev
);
790 /* prevent further gpiod exports */
791 mutex_lock(&sysfs_lock
);
792 gdev
->mockdev
= NULL
;
793 mutex_unlock(&sysfs_lock
);
795 /* unregister gpiod class devices owned by sysfs */
796 for (i
= 0; i
< chip
->ngpio
; i
++) {
797 desc
= &gdev
->descs
[i
];
798 if (test_and_clear_bit(FLAG_SYSFS
, &desc
->flags
))
803 static int __init
gpiolib_sysfs_init(void)
807 struct gpio_device
*gdev
;
809 status
= class_register(&gpio_class
);
813 /* Scan and register the gpio_chips which registered very
814 * early (e.g. before the class_register above was called).
816 * We run before arch_initcall() so chip->dev nodes can have
817 * registered, and so arch_initcall() can always gpio_export().
819 spin_lock_irqsave(&gpio_lock
, flags
);
820 list_for_each_entry(gdev
, &gpio_devices
, list
) {
825 * TODO we yield gpio_lock here because
826 * gpiochip_sysfs_register() acquires a mutex. This is unsafe
827 * and needs to be fixed.
829 * Also it would be nice to use gpiochip_find() here so we
830 * can keep gpio_chips local to gpiolib.c, but the yield of
831 * gpio_lock prevents us from doing this.
833 spin_unlock_irqrestore(&gpio_lock
, flags
);
834 status
= gpiochip_sysfs_register(gdev
);
835 spin_lock_irqsave(&gpio_lock
, flags
);
837 spin_unlock_irqrestore(&gpio_lock
, flags
);
841 postcore_initcall(gpiolib_sysfs_init
);