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>
14 #define GPIO_IRQF_TRIGGER_FALLING BIT(0)
15 #define GPIO_IRQF_TRIGGER_RISING BIT(1)
16 #define GPIO_IRQF_TRIGGER_BOTH (GPIO_IRQF_TRIGGER_FALLING | \
17 GPIO_IRQF_TRIGGER_RISING)
20 struct gpio_desc
*desc
;
23 struct kernfs_node
*value_kn
;
25 unsigned char irq_flags
;
27 bool direction_can_change
;
31 * Lock to serialise gpiod export and unexport, and prevent re-export of
32 * gpiod whose chip is being unregistered.
34 static DEFINE_MUTEX(sysfs_lock
);
37 * /sys/class/gpio/gpioN... only for GPIOs that are exported
39 * * MAY BE OMITTED if kernel won't allow direction changes
40 * * is read/write as "in" or "out"
41 * * may also be written as "high" or "low", initializing
42 * output value as specified ("out" implies "low")
44 * * always readable, subject to hardware behavior
45 * * may be writable, as zero/nonzero
47 * * configures behavior of poll(2) on /value
48 * * available only if pin can generate IRQs on input
49 * * is read/write as "none", "falling", "rising", or "both"
51 * * configures polarity of /value
52 * * is read/write as zero/nonzero
53 * * also affects existing and subsequent "falling" and "rising"
57 static ssize_t
direction_show(struct device
*dev
,
58 struct device_attribute
*attr
, char *buf
)
60 struct gpiod_data
*data
= dev_get_drvdata(dev
);
61 struct gpio_desc
*desc
= data
->desc
;
64 mutex_lock(&data
->mutex
);
66 gpiod_get_direction(desc
);
67 status
= sprintf(buf
, "%s\n",
68 test_bit(FLAG_IS_OUT
, &desc
->flags
)
71 mutex_unlock(&data
->mutex
);
76 static ssize_t
direction_store(struct device
*dev
,
77 struct device_attribute
*attr
, const char *buf
, size_t size
)
79 struct gpiod_data
*data
= dev_get_drvdata(dev
);
80 struct gpio_desc
*desc
= data
->desc
;
83 mutex_lock(&data
->mutex
);
85 if (sysfs_streq(buf
, "high"))
86 status
= gpiod_direction_output_raw(desc
, 1);
87 else if (sysfs_streq(buf
, "out") || sysfs_streq(buf
, "low"))
88 status
= gpiod_direction_output_raw(desc
, 0);
89 else if (sysfs_streq(buf
, "in"))
90 status
= gpiod_direction_input(desc
);
94 mutex_unlock(&data
->mutex
);
96 return status
? : size
;
98 static DEVICE_ATTR_RW(direction
);
100 static ssize_t
value_show(struct device
*dev
,
101 struct device_attribute
*attr
, char *buf
)
103 struct gpiod_data
*data
= dev_get_drvdata(dev
);
104 struct gpio_desc
*desc
= data
->desc
;
107 mutex_lock(&data
->mutex
);
109 status
= gpiod_get_value_cansleep(desc
);
113 status
= sprintf(buf
, "%d\n", status
);
115 mutex_unlock(&data
->mutex
);
120 static ssize_t
value_store(struct device
*dev
,
121 struct device_attribute
*attr
, const char *buf
, size_t size
)
123 struct gpiod_data
*data
= dev_get_drvdata(dev
);
124 struct gpio_desc
*desc
= data
->desc
;
127 mutex_lock(&data
->mutex
);
129 if (!test_bit(FLAG_IS_OUT
, &desc
->flags
)) {
134 status
= kstrtol(buf
, 0, &value
);
136 gpiod_set_value_cansleep(desc
, value
);
141 mutex_unlock(&data
->mutex
);
145 static DEVICE_ATTR_PREALLOC(value
, S_IWUSR
| S_IRUGO
, value_show
, value_store
);
147 static irqreturn_t
gpio_sysfs_irq(int irq
, void *priv
)
149 struct gpiod_data
*data
= priv
;
151 sysfs_notify_dirent(data
->value_kn
);
156 /* Caller holds gpiod-data mutex. */
157 static int gpio_sysfs_request_irq(struct device
*dev
, unsigned char flags
)
159 struct gpiod_data
*data
= dev_get_drvdata(dev
);
160 struct gpio_desc
*desc
= data
->desc
;
161 unsigned long irq_flags
;
164 data
->irq
= gpiod_to_irq(desc
);
168 data
->value_kn
= sysfs_get_dirent(dev
->kobj
.sd
, "value");
172 irq_flags
= IRQF_SHARED
;
173 if (flags
& GPIO_IRQF_TRIGGER_FALLING
)
174 irq_flags
|= test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
) ?
175 IRQF_TRIGGER_RISING
: IRQF_TRIGGER_FALLING
;
176 if (flags
& GPIO_IRQF_TRIGGER_RISING
)
177 irq_flags
|= test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
) ?
178 IRQF_TRIGGER_FALLING
: IRQF_TRIGGER_RISING
;
181 * FIXME: This should be done in the irq_request_resources callback
182 * when the irq is requested, but a few drivers currently fail
185 * Remove this redundant call (along with the corresponding
186 * unlock) when those drivers have been fixed.
188 ret
= gpiochip_lock_as_irq(desc
->gdev
->chip
, gpio_chip_hwgpio(desc
));
192 ret
= request_any_context_irq(data
->irq
, gpio_sysfs_irq
, irq_flags
,
197 data
->irq_flags
= flags
;
202 gpiochip_unlock_as_irq(desc
->gdev
->chip
, gpio_chip_hwgpio(desc
));
204 sysfs_put(data
->value_kn
);
210 * Caller holds gpiod-data mutex (unless called after class-device
213 static void gpio_sysfs_free_irq(struct device
*dev
)
215 struct gpiod_data
*data
= dev_get_drvdata(dev
);
216 struct gpio_desc
*desc
= data
->desc
;
219 free_irq(data
->irq
, data
);
220 gpiochip_unlock_as_irq(desc
->gdev
->chip
, gpio_chip_hwgpio(desc
));
221 sysfs_put(data
->value_kn
);
224 static const struct {
227 } trigger_types
[] = {
229 { "falling", GPIO_IRQF_TRIGGER_FALLING
},
230 { "rising", GPIO_IRQF_TRIGGER_RISING
},
231 { "both", GPIO_IRQF_TRIGGER_BOTH
},
234 static ssize_t
edge_show(struct device
*dev
,
235 struct device_attribute
*attr
, char *buf
)
237 struct gpiod_data
*data
= dev_get_drvdata(dev
);
241 mutex_lock(&data
->mutex
);
243 for (i
= 0; i
< ARRAY_SIZE(trigger_types
); i
++) {
244 if (data
->irq_flags
== trigger_types
[i
].flags
) {
245 status
= sprintf(buf
, "%s\n", trigger_types
[i
].name
);
250 mutex_unlock(&data
->mutex
);
255 static ssize_t
edge_store(struct device
*dev
,
256 struct device_attribute
*attr
, const char *buf
, size_t size
)
258 struct gpiod_data
*data
= dev_get_drvdata(dev
);
260 ssize_t status
= size
;
263 for (i
= 0; i
< ARRAY_SIZE(trigger_types
); i
++) {
264 if (sysfs_streq(trigger_types
[i
].name
, buf
))
268 if (i
== ARRAY_SIZE(trigger_types
))
271 flags
= trigger_types
[i
].flags
;
273 mutex_lock(&data
->mutex
);
275 if (flags
== data
->irq_flags
) {
281 gpio_sysfs_free_irq(dev
);
284 status
= gpio_sysfs_request_irq(dev
, flags
);
290 mutex_unlock(&data
->mutex
);
294 static DEVICE_ATTR_RW(edge
);
296 /* Caller holds gpiod-data mutex. */
297 static int gpio_sysfs_set_active_low(struct device
*dev
, int value
)
299 struct gpiod_data
*data
= dev_get_drvdata(dev
);
300 struct gpio_desc
*desc
= data
->desc
;
302 unsigned int flags
= data
->irq_flags
;
304 if (!!test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
) == !!value
)
308 set_bit(FLAG_ACTIVE_LOW
, &desc
->flags
);
310 clear_bit(FLAG_ACTIVE_LOW
, &desc
->flags
);
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
= sprintf(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
= container_of(kobj
, struct device
, 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 sprintf(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 sprintf(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 sprintf(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
);
440 static struct gpio_desc
*gpio_to_valid_desc(int gpio
)
442 return gpio_is_valid(gpio
) ? gpio_to_desc(gpio
) : NULL
;
446 * /sys/class/gpio/export ... write-only
447 * integer N ... number of GPIO to export (full access)
448 * /sys/class/gpio/unexport ... write-only
449 * integer N ... number of GPIO to unexport
451 static ssize_t
export_store(struct class *class,
452 struct class_attribute
*attr
,
453 const char *buf
, size_t len
)
456 struct gpio_desc
*desc
;
459 status
= kstrtol(buf
, 0, &gpio
);
463 desc
= gpio_to_valid_desc(gpio
);
464 /* reject invalid GPIOs */
466 pr_warn("%s: invalid GPIO %ld\n", __func__
, gpio
);
470 /* No extra locking here; FLAG_SYSFS just signifies that the
471 * request and export were done by on behalf of userspace, so
472 * they may be undone on its behalf too.
475 status
= gpiod_request(desc
, "sysfs");
477 if (status
== -EPROBE_DEFER
)
482 status
= gpiod_set_transitory(desc
, false);
484 status
= gpiod_export(desc
, true);
488 set_bit(FLAG_SYSFS
, &desc
->flags
);
493 pr_debug("%s: status %d\n", __func__
, status
);
494 return status
? : len
;
496 static CLASS_ATTR_WO(export
);
498 static ssize_t
unexport_store(struct class *class,
499 struct class_attribute
*attr
,
500 const char *buf
, size_t len
)
503 struct gpio_desc
*desc
;
506 status
= kstrtol(buf
, 0, &gpio
);
510 desc
= gpio_to_valid_desc(gpio
);
511 /* reject bogus commands (gpio_unexport ignores them) */
513 pr_warn("%s: invalid GPIO %ld\n", __func__
, gpio
);
519 /* No extra locking here; FLAG_SYSFS just signifies that the
520 * request and export were done by on behalf of userspace, so
521 * they may be undone on its behalf too.
523 if (test_and_clear_bit(FLAG_SYSFS
, &desc
->flags
)) {
529 pr_debug("%s: status %d\n", __func__
, status
);
530 return status
? : len
;
532 static CLASS_ATTR_WO(unexport
);
534 static struct attribute
*gpio_class_attrs
[] = {
535 &class_attr_export
.attr
,
536 &class_attr_unexport
.attr
,
539 ATTRIBUTE_GROUPS(gpio_class
);
541 static struct class gpio_class
= {
543 .owner
= THIS_MODULE
,
545 .class_groups
= gpio_class_groups
,
550 * gpiod_export - export a GPIO through sysfs
551 * @desc: GPIO to make available, already requested
552 * @direction_may_change: true if userspace may change GPIO direction
553 * Context: arch_initcall or later
555 * When drivers want to make a GPIO accessible to userspace after they
556 * have requested it -- perhaps while debugging, or as part of their
557 * public interface -- they may use this routine. If the GPIO can
558 * change direction (some can't) and the caller allows it, userspace
559 * will see "direction" sysfs attribute which may be used to change
560 * the gpio's direction. A "value" attribute will always be provided.
562 * Returns zero on success, else an error.
564 int gpiod_export(struct gpio_desc
*desc
, bool direction_may_change
)
566 struct gpio_chip
*chip
;
567 struct gpio_device
*gdev
;
568 struct gpiod_data
*data
;
571 const char *ioname
= NULL
;
575 /* can't export until sysfs is available ... */
577 pr_debug("%s: called too early!\n", __func__
);
582 pr_debug("%s: invalid gpio descriptor\n", __func__
);
589 mutex_lock(&sysfs_lock
);
591 /* check if chip is being removed */
592 if (!chip
|| !gdev
->mockdev
) {
597 spin_lock_irqsave(&gpio_lock
, flags
);
598 if (!test_bit(FLAG_REQUESTED
, &desc
->flags
) ||
599 test_bit(FLAG_EXPORT
, &desc
->flags
)) {
600 spin_unlock_irqrestore(&gpio_lock
, flags
);
601 gpiod_dbg(desc
, "%s: unavailable (requested=%d, exported=%d)\n",
603 test_bit(FLAG_REQUESTED
, &desc
->flags
),
604 test_bit(FLAG_EXPORT
, &desc
->flags
));
608 spin_unlock_irqrestore(&gpio_lock
, flags
);
610 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
617 mutex_init(&data
->mutex
);
618 if (chip
->direction_input
&& chip
->direction_output
)
619 data
->direction_can_change
= direction_may_change
;
621 data
->direction_can_change
= false;
623 offset
= gpio_chip_hwgpio(desc
);
624 if (chip
->names
&& chip
->names
[offset
])
625 ioname
= chip
->names
[offset
];
627 dev
= device_create_with_groups(&gpio_class
, &gdev
->dev
,
628 MKDEV(0, 0), data
, gpio_groups
,
629 ioname
? ioname
: "gpio%u",
632 status
= PTR_ERR(dev
);
636 set_bit(FLAG_EXPORT
, &desc
->flags
);
637 mutex_unlock(&sysfs_lock
);
643 mutex_unlock(&sysfs_lock
);
644 gpiod_dbg(desc
, "%s: status %d\n", __func__
, status
);
647 EXPORT_SYMBOL_GPL(gpiod_export
);
649 static int match_export(struct device
*dev
, const void *desc
)
651 struct gpiod_data
*data
= dev_get_drvdata(dev
);
653 return data
->desc
== desc
;
657 * gpiod_export_link - create a sysfs link to an exported GPIO node
658 * @dev: device under which to create symlink
659 * @name: name of the symlink
660 * @desc: GPIO to create symlink to, already exported
662 * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
663 * node. Caller is responsible for unlinking.
665 * Returns zero on success, else an error.
667 int gpiod_export_link(struct device
*dev
, const char *name
,
668 struct gpio_desc
*desc
)
674 pr_warn("%s: invalid GPIO\n", __func__
);
678 cdev
= class_find_device(&gpio_class
, NULL
, desc
, match_export
);
682 ret
= sysfs_create_link(&dev
->kobj
, &cdev
->kobj
, name
);
687 EXPORT_SYMBOL_GPL(gpiod_export_link
);
690 * gpiod_unexport - reverse effect of gpiod_export()
691 * @desc: GPIO to make unavailable
693 * This is implicit on gpiod_free().
695 void gpiod_unexport(struct gpio_desc
*desc
)
697 struct gpiod_data
*data
;
701 pr_warn("%s: invalid GPIO\n", __func__
);
705 mutex_lock(&sysfs_lock
);
707 if (!test_bit(FLAG_EXPORT
, &desc
->flags
))
710 dev
= class_find_device(&gpio_class
, NULL
, desc
, match_export
);
714 data
= dev_get_drvdata(dev
);
716 clear_bit(FLAG_EXPORT
, &desc
->flags
);
718 device_unregister(dev
);
721 * Release irq after deregistration to prevent race with edge_store.
724 gpio_sysfs_free_irq(dev
);
726 mutex_unlock(&sysfs_lock
);
734 mutex_unlock(&sysfs_lock
);
736 EXPORT_SYMBOL_GPL(gpiod_unexport
);
738 int gpiochip_sysfs_register(struct gpio_device
*gdev
)
741 struct device
*parent
;
742 struct gpio_chip
*chip
= gdev
->chip
;
745 * Many systems add gpio chips for SOC support very early,
746 * before driver model support is available. In those cases we
747 * register later, in gpiolib_sysfs_init() ... here we just
748 * verify that _some_ field of gpio_class got initialized.
754 * For sysfs backward compatibility we need to preserve this
755 * preferred parenting to the gpio_chip parent field, if set.
758 parent
= chip
->parent
;
762 /* use chip->base for the ID; it's already known to be unique */
763 dev
= device_create_with_groups(&gpio_class
, parent
,
765 chip
, gpiochip_groups
,
766 "gpiochip%d", chip
->base
);
770 mutex_lock(&sysfs_lock
);
772 mutex_unlock(&sysfs_lock
);
777 void gpiochip_sysfs_unregister(struct gpio_device
*gdev
)
779 struct gpio_desc
*desc
;
780 struct gpio_chip
*chip
= gdev
->chip
;
786 device_unregister(gdev
->mockdev
);
788 /* prevent further gpiod exports */
789 mutex_lock(&sysfs_lock
);
790 gdev
->mockdev
= NULL
;
791 mutex_unlock(&sysfs_lock
);
793 /* unregister gpiod class devices owned by sysfs */
794 for (i
= 0; i
< chip
->ngpio
; i
++) {
795 desc
= &gdev
->descs
[i
];
796 if (test_and_clear_bit(FLAG_SYSFS
, &desc
->flags
))
801 static int __init
gpiolib_sysfs_init(void)
805 struct gpio_device
*gdev
;
807 status
= class_register(&gpio_class
);
811 /* Scan and register the gpio_chips which registered very
812 * early (e.g. before the class_register above was called).
814 * We run before arch_initcall() so chip->dev nodes can have
815 * registered, and so arch_initcall() can always gpio_export().
817 spin_lock_irqsave(&gpio_lock
, flags
);
818 list_for_each_entry(gdev
, &gpio_devices
, list
) {
823 * TODO we yield gpio_lock here because
824 * gpiochip_sysfs_register() acquires a mutex. This is unsafe
825 * and needs to be fixed.
827 * Also it would be nice to use gpiochip_find() here so we
828 * can keep gpio_chips local to gpiolib.c, but the yield of
829 * gpio_lock prevents us from doing this.
831 spin_unlock_irqrestore(&gpio_lock
, flags
);
832 status
= gpiochip_sysfs_register(gdev
);
833 spin_lock_irqsave(&gpio_lock
, flags
);
835 spin_unlock_irqrestore(&gpio_lock
, flags
);
839 postcore_initcall(gpiolib_sysfs_init
);