// SPDX-License-Identifier: GPL-2.0 #include <linux/bitops.h> #include <linux/cleanup.h> #include <linux/device.h> #include <linux/idr.h> #include <linux/init.h> #include <linux/interrupt.h> #include <linux/kdev_t.h> #include <linux/kstrtox.h> #include <linux/list.h> #include <linux/mutex.h> #include <linux/printk.h> #include <linux/slab.h> #include <linux/spinlock.h> #include <linux/string.h> #include <linux/srcu.h> #include <linux/sysfs.h> #include <linux/types.h> #include <linux/gpio/consumer.h> #include <linux/gpio/driver.h> #include "gpiolib.h" #include "gpiolib-sysfs.h" struct kernfs_node; #define GPIO_IRQF_TRIGGER_NONE … #define GPIO_IRQF_TRIGGER_FALLING … #define GPIO_IRQF_TRIGGER_RISING … #define GPIO_IRQF_TRIGGER_BOTH … struct gpiod_data { … }; /* * Lock to serialise gpiod export and unexport, and prevent re-export of * gpiod whose chip is being unregistered. */ static DEFINE_MUTEX(sysfs_lock); /* * /sys/class/gpio/gpioN... only for GPIOs that are exported * /direction * * MAY BE OMITTED if kernel won't allow direction changes * * is read/write as "in" or "out" * * may also be written as "high" or "low", initializing * output value as specified ("out" implies "low") * /value * * always readable, subject to hardware behavior * * may be writable, as zero/nonzero * /edge * * configures behavior of poll(2) on /value * * available only if pin can generate IRQs on input * * is read/write as "none", "falling", "rising", or "both" * /active_low * * configures polarity of /value * * is read/write as zero/nonzero * * also affects existing and subsequent "falling" and "rising" * /edge configuration */ static ssize_t direction_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static ssize_t direction_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { … } static DEVICE_ATTR_RW(direction); static ssize_t value_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static ssize_t value_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { … } static DEVICE_ATTR_PREALLOC(value, S_IWUSR | S_IRUGO, value_show, value_store); static irqreturn_t gpio_sysfs_irq(int irq, void *priv) { … } /* Caller holds gpiod-data mutex. */ static int gpio_sysfs_request_irq(struct device *dev, unsigned char flags) { … } /* * Caller holds gpiod-data mutex (unless called after class-device * deregistration). */ static void gpio_sysfs_free_irq(struct device *dev) { … } static const char * const trigger_names[] = …; static ssize_t edge_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static ssize_t edge_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { … } static DEVICE_ATTR_RW(edge); /* Caller holds gpiod-data mutex. */ static int gpio_sysfs_set_active_low(struct device *dev, int value) { … } static ssize_t active_low_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static ssize_t active_low_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { … } static DEVICE_ATTR_RW(active_low); static umode_t gpio_is_visible(struct kobject *kobj, struct attribute *attr, int n) { … } static struct attribute *gpio_attrs[] = …; static const struct attribute_group gpio_group = …; static const struct attribute_group *gpio_groups[] = …; /* * /sys/class/gpio/gpiochipN/ * /base ... matching gpio_chip.base (N) * /label ... matching gpio_chip.label * /ngpio ... matching gpio_chip.ngpio */ static ssize_t base_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR_RO(base); static ssize_t label_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR_RO(label); static ssize_t ngpio_show(struct device *dev, struct device_attribute *attr, char *buf) { … } static DEVICE_ATTR_RO(ngpio); static struct attribute *gpiochip_attrs[] = …; ATTRIBUTE_GROUPS(…); /* * /sys/class/gpio/export ... write-only * integer N ... number of GPIO to export (full access) * /sys/class/gpio/unexport ... write-only * integer N ... number of GPIO to unexport */ static ssize_t export_store(const struct class *class, const struct class_attribute *attr, const char *buf, size_t len) { … } static CLASS_ATTR_WO(export); static ssize_t unexport_store(const struct class *class, const struct class_attribute *attr, const char *buf, size_t len) { … } static CLASS_ATTR_WO(unexport); static struct attribute *gpio_class_attrs[] = …; ATTRIBUTE_GROUPS(…); static struct class gpio_class = …; /** * gpiod_export - export a GPIO through sysfs * @desc: GPIO to make available, already requested * @direction_may_change: true if userspace may change GPIO direction * Context: arch_initcall or later * * When drivers want to make a GPIO accessible to userspace after they * have requested it -- perhaps while debugging, or as part of their * public interface -- they may use this routine. If the GPIO can * change direction (some can't) and the caller allows it, userspace * will see "direction" sysfs attribute which may be used to change * the gpio's direction. A "value" attribute will always be provided. * * Returns zero on success, else an error. */ int gpiod_export(struct gpio_desc *desc, bool direction_may_change) { … } EXPORT_SYMBOL_GPL(…); static int match_export(struct device *dev, const void *desc) { … } /** * gpiod_export_link - create a sysfs link to an exported GPIO node * @dev: device under which to create symlink * @name: name of the symlink * @desc: GPIO to create symlink to, already exported * * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN * node. Caller is responsible for unlinking. * * Returns zero on success, else an error. */ int gpiod_export_link(struct device *dev, const char *name, struct gpio_desc *desc) { … } EXPORT_SYMBOL_GPL(…); /** * gpiod_unexport - reverse effect of gpiod_export() * @desc: GPIO to make unavailable * * This is implicit on gpiod_free(). */ void gpiod_unexport(struct gpio_desc *desc) { … } EXPORT_SYMBOL_GPL(…); int gpiochip_sysfs_register(struct gpio_device *gdev) { … } void gpiochip_sysfs_unregister(struct gpio_device *gdev) { … } /* * We're not really looking for a device - we just want to iterate over the * list and call this callback for each GPIO device. This is why this function * always returns 0. */ static int gpiofind_sysfs_register(struct gpio_chip *gc, const void *data) { … } static int __init gpiolib_sysfs_init(void) { … } postcore_initcall(gpiolib_sysfs_init);
Codebase Browser
linux