1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/bitmap.h>
3 #include <linux/kernel.h>
4 #include <linux/module.h>
5 #include <linux/interrupt.h>
7 #include <linux/spinlock.h>
8 #include <linux/list.h>
9 #include <linux/device.h>
10 #include <linux/err.h>
11 #include <linux/debugfs.h>
12 #include <linux/seq_file.h>
13 #include <linux/gpio.h>
14 #include <linux/of_gpio.h>
15 #include <linux/idr.h>
16 #include <linux/slab.h>
17 #include <linux/acpi.h>
18 #include <linux/gpio/driver.h>
19 #include <linux/gpio/machine.h>
20 #include <linux/pinctrl/consumer.h>
21 #include <linux/cdev.h>
23 #include <linux/uaccess.h>
24 #include <linux/compat.h>
25 #include <linux/anon_inodes.h>
26 #include <linux/file.h>
27 #include <linux/kfifo.h>
28 #include <linux/poll.h>
29 #include <linux/timekeeping.h>
30 #include <uapi/linux/gpio.h>
34 #define CREATE_TRACE_POINTS
35 #include <trace/events/gpio.h>
37 /* Implementation infrastructure for GPIO interfaces.
39 * The GPIO programming interface allows for inlining speed-critical
40 * get/set operations for common cases, so that access to SOC-integrated
41 * GPIOs can sometimes cost only an instruction or two per bit.
45 /* When debugging, extend minimal trust to callers and platform code.
46 * Also emit diagnostic messages that may help initial bringup, when
47 * board setup or driver bugs are most common.
49 * Otherwise, minimize overhead in what may be bitbanging codepaths.
52 #define extra_checks 1
54 #define extra_checks 0
57 /* Device and char device-related information */
58 static DEFINE_IDA(gpio_ida);
59 static dev_t gpio_devt;
60 #define GPIO_DEV_MAX 256 /* 256 GPIO chip devices supported */
61 static struct bus_type gpio_bus_type = {
66 * Number of GPIOs to use for the fast path in set array
68 #define FASTPATH_NGPIO CONFIG_GPIOLIB_FASTPATH_LIMIT
70 /* gpio_lock prevents conflicts during gpio_desc[] table updates.
71 * While any GPIO is requested, its gpio_chip is not removable;
72 * each GPIO's "requested" flag serves as a lock and refcount.
74 DEFINE_SPINLOCK(gpio_lock);
76 static DEFINE_MUTEX(gpio_lookup_lock);
77 static LIST_HEAD(gpio_lookup_list);
78 LIST_HEAD(gpio_devices);
80 static DEFINE_MUTEX(gpio_machine_hogs_mutex);
81 static LIST_HEAD(gpio_machine_hogs);
83 static void gpiochip_free_hogs(struct gpio_chip *chip);
84 static int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
85 struct lock_class_key *lock_key,
86 struct lock_class_key *request_key);
87 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip);
88 static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip);
89 static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip);
91 static bool gpiolib_initialized;
93 static inline void desc_set_label(struct gpio_desc *d, const char *label)
99 * gpio_to_desc - Convert a GPIO number to its descriptor
100 * @gpio: global GPIO number
103 * The GPIO descriptor associated with the given GPIO, or %NULL if no GPIO
104 * with the given number exists in the system.
106 struct gpio_desc *gpio_to_desc(unsigned gpio)
108 struct gpio_device *gdev;
111 spin_lock_irqsave(&gpio_lock, flags);
113 list_for_each_entry(gdev, &gpio_devices, list) {
114 if (gdev->base <= gpio &&
115 gdev->base + gdev->ngpio > gpio) {
116 spin_unlock_irqrestore(&gpio_lock, flags);
117 return &gdev->descs[gpio - gdev->base];
121 spin_unlock_irqrestore(&gpio_lock, flags);
123 if (!gpio_is_valid(gpio))
124 WARN(1, "invalid GPIO %d\n", gpio);
128 EXPORT_SYMBOL_GPL(gpio_to_desc);
131 * gpiochip_get_desc - get the GPIO descriptor corresponding to the given
132 * hardware number for this chip
134 * @hwnum: hardware number of the GPIO for this chip
137 * A pointer to the GPIO descriptor or %ERR_PTR(-EINVAL) if no GPIO exists
138 * in the given chip for the specified hardware number.
140 struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip,
143 struct gpio_device *gdev = chip->gpiodev;
145 if (hwnum >= gdev->ngpio)
146 return ERR_PTR(-EINVAL);
148 return &gdev->descs[hwnum];
152 * desc_to_gpio - convert a GPIO descriptor to the integer namespace
153 * @desc: GPIO descriptor
155 * This should disappear in the future but is needed since we still
156 * use GPIO numbers for error messages and sysfs nodes.
159 * The global GPIO number for the GPIO specified by its descriptor.
161 int desc_to_gpio(const struct gpio_desc *desc)
163 return desc->gdev->base + (desc - &desc->gdev->descs[0]);
165 EXPORT_SYMBOL_GPL(desc_to_gpio);
169 * gpiod_to_chip - Return the GPIO chip to which a GPIO descriptor belongs
170 * @desc: descriptor to return the chip of
172 struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc)
174 if (!desc || !desc->gdev)
176 return desc->gdev->chip;
178 EXPORT_SYMBOL_GPL(gpiod_to_chip);
180 /* dynamic allocation of GPIOs, e.g. on a hotplugged device */
181 static int gpiochip_find_base(int ngpio)
183 struct gpio_device *gdev;
184 int base = ARCH_NR_GPIOS - ngpio;
186 list_for_each_entry_reverse(gdev, &gpio_devices, list) {
187 /* found a free space? */
188 if (gdev->base + gdev->ngpio <= base)
191 /* nope, check the space right before the chip */
192 base = gdev->base - ngpio;
195 if (gpio_is_valid(base)) {
196 pr_debug("%s: found new base at %d\n", __func__, base);
199 pr_err("%s: cannot find free range\n", __func__);
205 * gpiod_get_direction - return the current direction of a GPIO
206 * @desc: GPIO to get the direction of
208 * Returns 0 for output, 1 for input, or an error code in case of error.
210 * This function may sleep if gpiod_cansleep() is true.
212 int gpiod_get_direction(struct gpio_desc *desc)
214 struct gpio_chip *chip;
218 chip = gpiod_to_chip(desc);
219 offset = gpio_chip_hwgpio(desc);
221 if (!chip->get_direction)
224 status = chip->get_direction(chip, offset);
226 /* GPIOF_DIR_IN, or other positive */
228 clear_bit(FLAG_IS_OUT, &desc->flags);
232 set_bit(FLAG_IS_OUT, &desc->flags);
236 EXPORT_SYMBOL_GPL(gpiod_get_direction);
239 * Add a new chip to the global chips list, keeping the list of chips sorted
240 * by range(means [base, base + ngpio - 1]) order.
242 * Return -EBUSY if the new chip overlaps with some other chip's integer
245 static int gpiodev_add_to_list(struct gpio_device *gdev)
247 struct gpio_device *prev, *next;
249 if (list_empty(&gpio_devices)) {
250 /* initial entry in list */
251 list_add_tail(&gdev->list, &gpio_devices);
255 next = list_entry(gpio_devices.next, struct gpio_device, list);
256 if (gdev->base + gdev->ngpio <= next->base) {
257 /* add before first entry */
258 list_add(&gdev->list, &gpio_devices);
262 prev = list_entry(gpio_devices.prev, struct gpio_device, list);
263 if (prev->base + prev->ngpio <= gdev->base) {
264 /* add behind last entry */
265 list_add_tail(&gdev->list, &gpio_devices);
269 list_for_each_entry_safe(prev, next, &gpio_devices, list) {
270 /* at the end of the list */
271 if (&next->list == &gpio_devices)
274 /* add between prev and next */
275 if (prev->base + prev->ngpio <= gdev->base
276 && gdev->base + gdev->ngpio <= next->base) {
277 list_add(&gdev->list, &prev->list);
282 dev_err(&gdev->dev, "GPIO integer space overlap, cannot add chip\n");
287 * Convert a GPIO name to its descriptor
289 static struct gpio_desc *gpio_name_to_desc(const char * const name)
291 struct gpio_device *gdev;
294 spin_lock_irqsave(&gpio_lock, flags);
296 list_for_each_entry(gdev, &gpio_devices, list) {
299 for (i = 0; i != gdev->ngpio; ++i) {
300 struct gpio_desc *desc = &gdev->descs[i];
302 if (!desc->name || !name)
305 if (!strcmp(desc->name, name)) {
306 spin_unlock_irqrestore(&gpio_lock, flags);
312 spin_unlock_irqrestore(&gpio_lock, flags);
318 * Takes the names from gc->names and checks if they are all unique. If they
319 * are, they are assigned to their gpio descriptors.
321 * Warning if one of the names is already used for a different GPIO.
323 static int gpiochip_set_desc_names(struct gpio_chip *gc)
325 struct gpio_device *gdev = gc->gpiodev;
331 /* First check all names if they are unique */
332 for (i = 0; i != gc->ngpio; ++i) {
333 struct gpio_desc *gpio;
335 gpio = gpio_name_to_desc(gc->names[i]);
338 "Detected name collision for GPIO name '%s'\n",
342 /* Then add all names to the GPIO descriptors */
343 for (i = 0; i != gc->ngpio; ++i)
344 gdev->descs[i].name = gc->names[i];
349 static unsigned long *gpiochip_allocate_mask(struct gpio_chip *chip)
353 p = kmalloc_array(BITS_TO_LONGS(chip->ngpio), sizeof(*p), GFP_KERNEL);
357 /* Assume by default all GPIOs are valid */
358 bitmap_fill(p, chip->ngpio);
363 static int gpiochip_init_valid_mask(struct gpio_chip *gpiochip)
365 #ifdef CONFIG_OF_GPIO
367 struct device_node *np = gpiochip->of_node;
369 size = of_property_count_u32_elems(np, "gpio-reserved-ranges");
370 if (size > 0 && size % 2 == 0)
371 gpiochip->need_valid_mask = true;
374 if (!gpiochip->need_valid_mask)
377 gpiochip->valid_mask = gpiochip_allocate_mask(gpiochip);
378 if (!gpiochip->valid_mask)
384 static void gpiochip_free_valid_mask(struct gpio_chip *gpiochip)
386 kfree(gpiochip->valid_mask);
387 gpiochip->valid_mask = NULL;
390 bool gpiochip_line_is_valid(const struct gpio_chip *gpiochip,
393 /* No mask means all valid */
394 if (likely(!gpiochip->valid_mask))
396 return test_bit(offset, gpiochip->valid_mask);
398 EXPORT_SYMBOL_GPL(gpiochip_line_is_valid);
401 * GPIO line handle management
405 * struct linehandle_state - contains the state of a userspace handle
406 * @gdev: the GPIO device the handle pertains to
407 * @label: consumer label used to tag descriptors
408 * @descs: the GPIO descriptors held by this handle
409 * @numdescs: the number of descriptors held in the descs array
411 struct linehandle_state {
412 struct gpio_device *gdev;
414 struct gpio_desc *descs[GPIOHANDLES_MAX];
418 #define GPIOHANDLE_REQUEST_VALID_FLAGS \
419 (GPIOHANDLE_REQUEST_INPUT | \
420 GPIOHANDLE_REQUEST_OUTPUT | \
421 GPIOHANDLE_REQUEST_ACTIVE_LOW | \
422 GPIOHANDLE_REQUEST_OPEN_DRAIN | \
423 GPIOHANDLE_REQUEST_OPEN_SOURCE)
425 static long linehandle_ioctl(struct file *filep, unsigned int cmd,
428 struct linehandle_state *lh = filep->private_data;
429 void __user *ip = (void __user *)arg;
430 struct gpiohandle_data ghd;
431 DECLARE_BITMAP(vals, GPIOHANDLES_MAX);
434 if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
435 /* NOTE: It's ok to read values of output lines. */
436 int ret = gpiod_get_array_value_complex(false,
445 memset(&ghd, 0, sizeof(ghd));
446 for (i = 0; i < lh->numdescs; i++)
447 ghd.values[i] = test_bit(i, vals);
449 if (copy_to_user(ip, &ghd, sizeof(ghd)))
453 } else if (cmd == GPIOHANDLE_SET_LINE_VALUES_IOCTL) {
455 * All line descriptors were created at once with the same
456 * flags so just check if the first one is really output.
458 if (!test_bit(FLAG_IS_OUT, &lh->descs[0]->flags))
461 if (copy_from_user(&ghd, ip, sizeof(ghd)))
464 /* Clamp all values to [0,1] */
465 for (i = 0; i < lh->numdescs; i++)
466 __assign_bit(i, vals, ghd.values[i]);
468 /* Reuse the array setting function */
469 return gpiod_set_array_value_complex(false,
480 static long linehandle_ioctl_compat(struct file *filep, unsigned int cmd,
483 return linehandle_ioctl(filep, cmd, (unsigned long)compat_ptr(arg));
487 static int linehandle_release(struct inode *inode, struct file *filep)
489 struct linehandle_state *lh = filep->private_data;
490 struct gpio_device *gdev = lh->gdev;
493 for (i = 0; i < lh->numdescs; i++)
494 gpiod_free(lh->descs[i]);
497 put_device(&gdev->dev);
501 static const struct file_operations linehandle_fileops = {
502 .release = linehandle_release,
503 .owner = THIS_MODULE,
504 .llseek = noop_llseek,
505 .unlocked_ioctl = linehandle_ioctl,
507 .compat_ioctl = linehandle_ioctl_compat,
511 static int linehandle_create(struct gpio_device *gdev, void __user *ip)
513 struct gpiohandle_request handlereq;
514 struct linehandle_state *lh;
516 int fd, i, count = 0, ret;
519 if (copy_from_user(&handlereq, ip, sizeof(handlereq)))
521 if ((handlereq.lines == 0) || (handlereq.lines > GPIOHANDLES_MAX))
524 lflags = handlereq.flags;
526 /* Return an error if an unknown flag is set */
527 if (lflags & ~GPIOHANDLE_REQUEST_VALID_FLAGS)
531 * Do not allow OPEN_SOURCE & OPEN_DRAIN flags in a single request. If
532 * the hardware actually supports enabling both at the same time the
533 * electrical result would be disastrous.
535 if ((lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN) &&
536 (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE))
539 /* OPEN_DRAIN and OPEN_SOURCE flags only make sense for output mode. */
540 if (!(lflags & GPIOHANDLE_REQUEST_OUTPUT) &&
541 ((lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN) ||
542 (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)))
545 lh = kzalloc(sizeof(*lh), GFP_KERNEL);
549 get_device(&gdev->dev);
551 /* Make sure this is terminated */
552 handlereq.consumer_label[sizeof(handlereq.consumer_label)-1] = '\0';
553 if (strlen(handlereq.consumer_label)) {
554 lh->label = kstrdup(handlereq.consumer_label,
562 /* Request each GPIO */
563 for (i = 0; i < handlereq.lines; i++) {
564 u32 offset = handlereq.lineoffsets[i];
565 struct gpio_desc *desc;
567 if (offset >= gdev->ngpio) {
572 desc = &gdev->descs[offset];
573 ret = gpiod_request(desc, lh->label);
579 if (lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW)
580 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
581 if (lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN)
582 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
583 if (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)
584 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
586 ret = gpiod_set_transitory(desc, false);
591 * Lines have to be requested explicitly for input
592 * or output, else the line will be treated "as is".
594 if (lflags & GPIOHANDLE_REQUEST_OUTPUT) {
595 int val = !!handlereq.default_values[i];
597 ret = gpiod_direction_output(desc, val);
600 } else if (lflags & GPIOHANDLE_REQUEST_INPUT) {
601 ret = gpiod_direction_input(desc);
605 dev_dbg(&gdev->dev, "registered chardev handle for line %d\n",
608 /* Let i point at the last handle */
610 lh->numdescs = handlereq.lines;
612 fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
618 file = anon_inode_getfile("gpio-linehandle",
621 O_RDONLY | O_CLOEXEC);
624 goto out_put_unused_fd;
628 if (copy_to_user(ip, &handlereq, sizeof(handlereq))) {
630 * fput() will trigger the release() callback, so do not go onto
631 * the regular error cleanup path here.
638 fd_install(fd, file);
640 dev_dbg(&gdev->dev, "registered chardev handle for %d lines\n",
648 for (i = 0; i < count; i++)
649 gpiod_free(lh->descs[i]);
653 put_device(&gdev->dev);
658 * GPIO line event management
662 * struct lineevent_state - contains the state of a userspace event
663 * @gdev: the GPIO device the event pertains to
664 * @label: consumer label used to tag descriptors
665 * @desc: the GPIO descriptor held by this event
666 * @eflags: the event flags this line was requested with
667 * @irq: the interrupt that trigger in response to events on this GPIO
668 * @wait: wait queue that handles blocking reads of events
669 * @events: KFIFO for the GPIO events
670 * @read_lock: mutex lock to protect reads from colliding with adding
671 * new events to the FIFO
672 * @timestamp: cache for the timestamp storing it between hardirq
673 * and IRQ thread, used to bring the timestamp close to the actual
676 struct lineevent_state {
677 struct gpio_device *gdev;
679 struct gpio_desc *desc;
682 wait_queue_head_t wait;
683 DECLARE_KFIFO(events, struct gpioevent_data, 16);
684 struct mutex read_lock;
688 #define GPIOEVENT_REQUEST_VALID_FLAGS \
689 (GPIOEVENT_REQUEST_RISING_EDGE | \
690 GPIOEVENT_REQUEST_FALLING_EDGE)
692 static __poll_t lineevent_poll(struct file *filep,
693 struct poll_table_struct *wait)
695 struct lineevent_state *le = filep->private_data;
698 poll_wait(filep, &le->wait, wait);
700 if (!kfifo_is_empty(&le->events))
701 events = EPOLLIN | EPOLLRDNORM;
707 static ssize_t lineevent_read(struct file *filep,
712 struct lineevent_state *le = filep->private_data;
716 if (count < sizeof(struct gpioevent_data))
720 if (kfifo_is_empty(&le->events)) {
721 if (filep->f_flags & O_NONBLOCK)
724 ret = wait_event_interruptible(le->wait,
725 !kfifo_is_empty(&le->events));
730 if (mutex_lock_interruptible(&le->read_lock))
732 ret = kfifo_to_user(&le->events, buf, count, &copied);
733 mutex_unlock(&le->read_lock);
739 * If we couldn't read anything from the fifo (a different
740 * thread might have been faster) we either return -EAGAIN if
741 * the file descriptor is non-blocking, otherwise we go back to
742 * sleep and wait for more data to arrive.
744 if (copied == 0 && (filep->f_flags & O_NONBLOCK))
747 } while (copied == 0);
752 static int lineevent_release(struct inode *inode, struct file *filep)
754 struct lineevent_state *le = filep->private_data;
755 struct gpio_device *gdev = le->gdev;
757 free_irq(le->irq, le);
758 gpiod_free(le->desc);
761 put_device(&gdev->dev);
765 static long lineevent_ioctl(struct file *filep, unsigned int cmd,
768 struct lineevent_state *le = filep->private_data;
769 void __user *ip = (void __user *)arg;
770 struct gpiohandle_data ghd;
773 * We can get the value for an event line but not set it,
774 * because it is input by definition.
776 if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
779 memset(&ghd, 0, sizeof(ghd));
781 val = gpiod_get_value_cansleep(le->desc);
786 if (copy_to_user(ip, &ghd, sizeof(ghd)))
795 static long lineevent_ioctl_compat(struct file *filep, unsigned int cmd,
798 return lineevent_ioctl(filep, cmd, (unsigned long)compat_ptr(arg));
802 static const struct file_operations lineevent_fileops = {
803 .release = lineevent_release,
804 .read = lineevent_read,
805 .poll = lineevent_poll,
806 .owner = THIS_MODULE,
807 .llseek = noop_llseek,
808 .unlocked_ioctl = lineevent_ioctl,
810 .compat_ioctl = lineevent_ioctl_compat,
814 static irqreturn_t lineevent_irq_thread(int irq, void *p)
816 struct lineevent_state *le = p;
817 struct gpioevent_data ge;
820 /* Do not leak kernel stack to userspace */
821 memset(&ge, 0, sizeof(ge));
823 ge.timestamp = le->timestamp;
825 if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE
826 && le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) {
827 int level = gpiod_get_value_cansleep(le->desc);
829 /* Emit low-to-high event */
830 ge.id = GPIOEVENT_EVENT_RISING_EDGE;
832 /* Emit high-to-low event */
833 ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
834 } else if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE) {
835 /* Emit low-to-high event */
836 ge.id = GPIOEVENT_EVENT_RISING_EDGE;
837 } else if (le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) {
838 /* Emit high-to-low event */
839 ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
844 ret = kfifo_put(&le->events, ge);
846 wake_up_poll(&le->wait, EPOLLIN);
851 static irqreturn_t lineevent_irq_handler(int irq, void *p)
853 struct lineevent_state *le = p;
856 * Just store the timestamp in hardirq context so we get it as
857 * close in time as possible to the actual event.
859 le->timestamp = ktime_get_real_ns();
861 return IRQ_WAKE_THREAD;
864 static int lineevent_create(struct gpio_device *gdev, void __user *ip)
866 struct gpioevent_request eventreq;
867 struct lineevent_state *le;
868 struct gpio_desc *desc;
877 if (copy_from_user(&eventreq, ip, sizeof(eventreq)))
880 le = kzalloc(sizeof(*le), GFP_KERNEL);
884 get_device(&gdev->dev);
886 /* Make sure this is terminated */
887 eventreq.consumer_label[sizeof(eventreq.consumer_label)-1] = '\0';
888 if (strlen(eventreq.consumer_label)) {
889 le->label = kstrdup(eventreq.consumer_label,
897 offset = eventreq.lineoffset;
898 lflags = eventreq.handleflags;
899 eflags = eventreq.eventflags;
901 if (offset >= gdev->ngpio) {
906 /* Return an error if a unknown flag is set */
907 if ((lflags & ~GPIOHANDLE_REQUEST_VALID_FLAGS) ||
908 (eflags & ~GPIOEVENT_REQUEST_VALID_FLAGS)) {
913 /* This is just wrong: we don't look for events on output lines */
914 if (lflags & GPIOHANDLE_REQUEST_OUTPUT) {
919 desc = &gdev->descs[offset];
920 ret = gpiod_request(desc, le->label);
926 if (lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW)
927 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
928 if (lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN)
929 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
930 if (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)
931 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
933 ret = gpiod_direction_input(desc);
937 le->irq = gpiod_to_irq(desc);
943 if (eflags & GPIOEVENT_REQUEST_RISING_EDGE)
944 irqflags |= IRQF_TRIGGER_RISING;
945 if (eflags & GPIOEVENT_REQUEST_FALLING_EDGE)
946 irqflags |= IRQF_TRIGGER_FALLING;
947 irqflags |= IRQF_ONESHOT;
949 INIT_KFIFO(le->events);
950 init_waitqueue_head(&le->wait);
951 mutex_init(&le->read_lock);
953 /* Request a thread to read the events */
954 ret = request_threaded_irq(le->irq,
955 lineevent_irq_handler,
956 lineevent_irq_thread,
963 fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
969 file = anon_inode_getfile("gpio-event",
972 O_RDONLY | O_CLOEXEC);
975 goto out_put_unused_fd;
979 if (copy_to_user(ip, &eventreq, sizeof(eventreq))) {
981 * fput() will trigger the release() callback, so do not go onto
982 * the regular error cleanup path here.
989 fd_install(fd, file);
996 free_irq(le->irq, le);
998 gpiod_free(le->desc);
1003 put_device(&gdev->dev);
1008 * gpio_ioctl() - ioctl handler for the GPIO chardev
1010 static long gpio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1012 struct gpio_device *gdev = filp->private_data;
1013 struct gpio_chip *chip = gdev->chip;
1014 void __user *ip = (void __user *)arg;
1016 /* We fail any subsequent ioctl():s when the chip is gone */
1020 /* Fill in the struct and pass to userspace */
1021 if (cmd == GPIO_GET_CHIPINFO_IOCTL) {
1022 struct gpiochip_info chipinfo;
1024 memset(&chipinfo, 0, sizeof(chipinfo));
1026 strncpy(chipinfo.name, dev_name(&gdev->dev),
1027 sizeof(chipinfo.name));
1028 chipinfo.name[sizeof(chipinfo.name)-1] = '\0';
1029 strncpy(chipinfo.label, gdev->label,
1030 sizeof(chipinfo.label));
1031 chipinfo.label[sizeof(chipinfo.label)-1] = '\0';
1032 chipinfo.lines = gdev->ngpio;
1033 if (copy_to_user(ip, &chipinfo, sizeof(chipinfo)))
1036 } else if (cmd == GPIO_GET_LINEINFO_IOCTL) {
1037 struct gpioline_info lineinfo;
1038 struct gpio_desc *desc;
1040 if (copy_from_user(&lineinfo, ip, sizeof(lineinfo)))
1042 if (lineinfo.line_offset >= gdev->ngpio)
1045 desc = &gdev->descs[lineinfo.line_offset];
1047 strncpy(lineinfo.name, desc->name,
1048 sizeof(lineinfo.name));
1049 lineinfo.name[sizeof(lineinfo.name)-1] = '\0';
1051 lineinfo.name[0] = '\0';
1054 strncpy(lineinfo.consumer, desc->label,
1055 sizeof(lineinfo.consumer));
1056 lineinfo.consumer[sizeof(lineinfo.consumer)-1] = '\0';
1058 lineinfo.consumer[0] = '\0';
1062 * Userspace only need to know that the kernel is using
1063 * this GPIO so it can't use it.
1066 if (test_bit(FLAG_REQUESTED, &desc->flags) ||
1067 test_bit(FLAG_IS_HOGGED, &desc->flags) ||
1068 test_bit(FLAG_USED_AS_IRQ, &desc->flags) ||
1069 test_bit(FLAG_EXPORT, &desc->flags) ||
1070 test_bit(FLAG_SYSFS, &desc->flags))
1071 lineinfo.flags |= GPIOLINE_FLAG_KERNEL;
1072 if (test_bit(FLAG_IS_OUT, &desc->flags))
1073 lineinfo.flags |= GPIOLINE_FLAG_IS_OUT;
1074 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
1075 lineinfo.flags |= GPIOLINE_FLAG_ACTIVE_LOW;
1076 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
1077 lineinfo.flags |= GPIOLINE_FLAG_OPEN_DRAIN;
1078 if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
1079 lineinfo.flags |= GPIOLINE_FLAG_OPEN_SOURCE;
1081 if (copy_to_user(ip, &lineinfo, sizeof(lineinfo)))
1084 } else if (cmd == GPIO_GET_LINEHANDLE_IOCTL) {
1085 return linehandle_create(gdev, ip);
1086 } else if (cmd == GPIO_GET_LINEEVENT_IOCTL) {
1087 return lineevent_create(gdev, ip);
1092 #ifdef CONFIG_COMPAT
1093 static long gpio_ioctl_compat(struct file *filp, unsigned int cmd,
1096 return gpio_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
1101 * gpio_chrdev_open() - open the chardev for ioctl operations
1102 * @inode: inode for this chardev
1103 * @filp: file struct for storing private data
1104 * Returns 0 on success
1106 static int gpio_chrdev_open(struct inode *inode, struct file *filp)
1108 struct gpio_device *gdev = container_of(inode->i_cdev,
1109 struct gpio_device, chrdev);
1111 /* Fail on open if the backing gpiochip is gone */
1114 get_device(&gdev->dev);
1115 filp->private_data = gdev;
1117 return nonseekable_open(inode, filp);
1121 * gpio_chrdev_release() - close chardev after ioctl operations
1122 * @inode: inode for this chardev
1123 * @filp: file struct for storing private data
1124 * Returns 0 on success
1126 static int gpio_chrdev_release(struct inode *inode, struct file *filp)
1128 struct gpio_device *gdev = container_of(inode->i_cdev,
1129 struct gpio_device, chrdev);
1131 put_device(&gdev->dev);
1136 static const struct file_operations gpio_fileops = {
1137 .release = gpio_chrdev_release,
1138 .open = gpio_chrdev_open,
1139 .owner = THIS_MODULE,
1140 .llseek = no_llseek,
1141 .unlocked_ioctl = gpio_ioctl,
1142 #ifdef CONFIG_COMPAT
1143 .compat_ioctl = gpio_ioctl_compat,
1147 static void gpiodevice_release(struct device *dev)
1149 struct gpio_device *gdev = dev_get_drvdata(dev);
1151 list_del(&gdev->list);
1152 ida_simple_remove(&gpio_ida, gdev->id);
1153 kfree_const(gdev->label);
1158 static int gpiochip_setup_dev(struct gpio_device *gdev)
1162 cdev_init(&gdev->chrdev, &gpio_fileops);
1163 gdev->chrdev.owner = THIS_MODULE;
1164 gdev->dev.devt = MKDEV(MAJOR(gpio_devt), gdev->id);
1166 status = cdev_device_add(&gdev->chrdev, &gdev->dev);
1170 chip_dbg(gdev->chip, "added GPIO chardev (%d:%d)\n",
1171 MAJOR(gpio_devt), gdev->id);
1173 status = gpiochip_sysfs_register(gdev);
1175 goto err_remove_device;
1177 /* From this point, the .release() function cleans up gpio_device */
1178 gdev->dev.release = gpiodevice_release;
1179 pr_debug("%s: registered GPIOs %d to %d on device: %s (%s)\n",
1180 __func__, gdev->base, gdev->base + gdev->ngpio - 1,
1181 dev_name(&gdev->dev), gdev->chip->label ? : "generic");
1186 cdev_device_del(&gdev->chrdev, &gdev->dev);
1190 static void gpiochip_machine_hog(struct gpio_chip *chip, struct gpiod_hog *hog)
1192 struct gpio_desc *desc;
1195 desc = gpiochip_get_desc(chip, hog->chip_hwnum);
1197 pr_err("%s: unable to get GPIO desc: %ld\n",
1198 __func__, PTR_ERR(desc));
1202 if (test_bit(FLAG_IS_HOGGED, &desc->flags))
1205 rv = gpiod_hog(desc, hog->line_name, hog->lflags, hog->dflags);
1207 pr_err("%s: unable to hog GPIO line (%s:%u): %d\n",
1208 __func__, chip->label, hog->chip_hwnum, rv);
1211 static void machine_gpiochip_add(struct gpio_chip *chip)
1213 struct gpiod_hog *hog;
1215 mutex_lock(&gpio_machine_hogs_mutex);
1217 list_for_each_entry(hog, &gpio_machine_hogs, list) {
1218 if (!strcmp(chip->label, hog->chip_label))
1219 gpiochip_machine_hog(chip, hog);
1222 mutex_unlock(&gpio_machine_hogs_mutex);
1225 static void gpiochip_setup_devs(void)
1227 struct gpio_device *gdev;
1230 list_for_each_entry(gdev, &gpio_devices, list) {
1231 err = gpiochip_setup_dev(gdev);
1233 pr_err("%s: Failed to initialize gpio device (%d)\n",
1234 dev_name(&gdev->dev), err);
1238 int gpiochip_add_data_with_key(struct gpio_chip *chip, void *data,
1239 struct lock_class_key *lock_key,
1240 struct lock_class_key *request_key)
1242 unsigned long flags;
1245 int base = chip->base;
1246 struct gpio_device *gdev;
1249 * First: allocate and populate the internal stat container, and
1250 * set up the struct device.
1252 gdev = kzalloc(sizeof(*gdev), GFP_KERNEL);
1255 gdev->dev.bus = &gpio_bus_type;
1257 chip->gpiodev = gdev;
1259 gdev->dev.parent = chip->parent;
1260 gdev->dev.of_node = chip->parent->of_node;
1263 #ifdef CONFIG_OF_GPIO
1264 /* If the gpiochip has an assigned OF node this takes precedence */
1266 gdev->dev.of_node = chip->of_node;
1268 chip->of_node = gdev->dev.of_node;
1271 gdev->id = ida_simple_get(&gpio_ida, 0, 0, GFP_KERNEL);
1276 dev_set_name(&gdev->dev, "gpiochip%d", gdev->id);
1277 device_initialize(&gdev->dev);
1278 dev_set_drvdata(&gdev->dev, gdev);
1279 if (chip->parent && chip->parent->driver)
1280 gdev->owner = chip->parent->driver->owner;
1281 else if (chip->owner)
1282 /* TODO: remove chip->owner */
1283 gdev->owner = chip->owner;
1285 gdev->owner = THIS_MODULE;
1287 gdev->descs = kcalloc(chip->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
1293 if (chip->ngpio == 0) {
1294 chip_err(chip, "tried to insert a GPIO chip with zero lines\n");
1296 goto err_free_descs;
1299 if (chip->ngpio > FASTPATH_NGPIO)
1300 chip_warn(chip, "line cnt %u is greater than fast path cnt %u\n",
1301 chip->ngpio, FASTPATH_NGPIO);
1303 gdev->label = kstrdup_const(chip->label ?: "unknown", GFP_KERNEL);
1306 goto err_free_descs;
1309 gdev->ngpio = chip->ngpio;
1312 spin_lock_irqsave(&gpio_lock, flags);
1315 * TODO: this allocates a Linux GPIO number base in the global
1316 * GPIO numberspace for this chip. In the long run we want to
1317 * get *rid* of this numberspace and use only descriptors, but
1318 * it may be a pipe dream. It will not happen before we get rid
1319 * of the sysfs interface anyways.
1322 base = gpiochip_find_base(chip->ngpio);
1325 spin_unlock_irqrestore(&gpio_lock, flags);
1326 goto err_free_label;
1329 * TODO: it should not be necessary to reflect the assigned
1330 * base outside of the GPIO subsystem. Go over drivers and
1331 * see if anyone makes use of this, else drop this and assign
1338 status = gpiodev_add_to_list(gdev);
1340 spin_unlock_irqrestore(&gpio_lock, flags);
1341 goto err_free_label;
1344 spin_unlock_irqrestore(&gpio_lock, flags);
1346 for (i = 0; i < chip->ngpio; i++) {
1347 struct gpio_desc *desc = &gdev->descs[i];
1351 /* REVISIT: most hardware initializes GPIOs as inputs (often
1352 * with pullups enabled) so power usage is minimized. Linux
1353 * code should set the gpio direction first thing; but until
1354 * it does, and in case chip->get_direction is not set, we may
1355 * expose the wrong direction in sysfs.
1357 desc->flags = !chip->direction_input ? (1 << FLAG_IS_OUT) : 0;
1360 #ifdef CONFIG_PINCTRL
1361 INIT_LIST_HEAD(&gdev->pin_ranges);
1364 status = gpiochip_set_desc_names(chip);
1366 goto err_remove_from_list;
1368 status = gpiochip_irqchip_init_valid_mask(chip);
1370 goto err_remove_from_list;
1372 status = gpiochip_init_valid_mask(chip);
1374 goto err_remove_irqchip_mask;
1376 status = gpiochip_add_irqchip(chip, lock_key, request_key);
1378 goto err_remove_chip;
1380 status = of_gpiochip_add(chip);
1382 goto err_remove_chip;
1384 acpi_gpiochip_add(chip);
1386 machine_gpiochip_add(chip);
1389 * By first adding the chardev, and then adding the device,
1390 * we get a device node entry in sysfs under
1391 * /sys/bus/gpio/devices/gpiochipN/dev that can be used for
1392 * coldplug of device nodes and other udev business.
1393 * We can do this only if gpiolib has been initialized.
1394 * Otherwise, defer until later.
1396 if (gpiolib_initialized) {
1397 status = gpiochip_setup_dev(gdev);
1399 goto err_remove_chip;
1404 acpi_gpiochip_remove(chip);
1405 gpiochip_free_hogs(chip);
1406 of_gpiochip_remove(chip);
1407 gpiochip_free_valid_mask(chip);
1408 err_remove_irqchip_mask:
1409 gpiochip_irqchip_free_valid_mask(chip);
1410 err_remove_from_list:
1411 spin_lock_irqsave(&gpio_lock, flags);
1412 list_del(&gdev->list);
1413 spin_unlock_irqrestore(&gpio_lock, flags);
1415 kfree_const(gdev->label);
1419 ida_simple_remove(&gpio_ida, gdev->id);
1420 /* failures here can mean systems won't boot... */
1421 pr_err("%s: GPIOs %d..%d (%s) failed to register, %d\n", __func__,
1422 gdev->base, gdev->base + gdev->ngpio - 1,
1423 chip->label ? : "generic", status);
1427 EXPORT_SYMBOL_GPL(gpiochip_add_data_with_key);
1430 * gpiochip_get_data() - get per-subdriver data for the chip
1434 * The per-subdriver data for the chip.
1436 void *gpiochip_get_data(struct gpio_chip *chip)
1438 return chip->gpiodev->data;
1440 EXPORT_SYMBOL_GPL(gpiochip_get_data);
1443 * gpiochip_remove() - unregister a gpio_chip
1444 * @chip: the chip to unregister
1446 * A gpio_chip with any GPIOs still requested may not be removed.
1448 void gpiochip_remove(struct gpio_chip *chip)
1450 struct gpio_device *gdev = chip->gpiodev;
1451 struct gpio_desc *desc;
1452 unsigned long flags;
1454 bool requested = false;
1456 /* FIXME: should the legacy sysfs handling be moved to gpio_device? */
1457 gpiochip_sysfs_unregister(gdev);
1458 gpiochip_free_hogs(chip);
1459 /* Numb the device, cancelling all outstanding operations */
1461 gpiochip_irqchip_remove(chip);
1462 acpi_gpiochip_remove(chip);
1463 gpiochip_remove_pin_ranges(chip);
1464 of_gpiochip_remove(chip);
1465 gpiochip_free_valid_mask(chip);
1467 * We accept no more calls into the driver from this point, so
1468 * NULL the driver data pointer
1472 spin_lock_irqsave(&gpio_lock, flags);
1473 for (i = 0; i < gdev->ngpio; i++) {
1474 desc = &gdev->descs[i];
1475 if (test_bit(FLAG_REQUESTED, &desc->flags))
1478 spin_unlock_irqrestore(&gpio_lock, flags);
1481 dev_crit(&gdev->dev,
1482 "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
1485 * The gpiochip side puts its use of the device to rest here:
1486 * if there are no userspace clients, the chardev and device will
1487 * be removed, else it will be dangling until the last user is
1490 cdev_device_del(&gdev->chrdev, &gdev->dev);
1491 put_device(&gdev->dev);
1493 EXPORT_SYMBOL_GPL(gpiochip_remove);
1495 static void devm_gpio_chip_release(struct device *dev, void *res)
1497 struct gpio_chip *chip = *(struct gpio_chip **)res;
1499 gpiochip_remove(chip);
1502 static int devm_gpio_chip_match(struct device *dev, void *res, void *data)
1505 struct gpio_chip **r = res;
1516 * devm_gpiochip_add_data() - Resource manager gpiochip_add_data()
1517 * @dev: the device pointer on which irq_chip belongs to.
1518 * @chip: the chip to register, with chip->base initialized
1519 * @data: driver-private data associated with this chip
1521 * Context: potentially before irqs will work
1523 * The gpio chip automatically be released when the device is unbound.
1526 * A negative errno if the chip can't be registered, such as because the
1527 * chip->base is invalid or already associated with a different chip.
1528 * Otherwise it returns zero as a success code.
1530 int devm_gpiochip_add_data(struct device *dev, struct gpio_chip *chip,
1533 struct gpio_chip **ptr;
1536 ptr = devres_alloc(devm_gpio_chip_release, sizeof(*ptr),
1541 ret = gpiochip_add_data(chip, data);
1548 devres_add(dev, ptr);
1552 EXPORT_SYMBOL_GPL(devm_gpiochip_add_data);
1555 * devm_gpiochip_remove() - Resource manager of gpiochip_remove()
1556 * @dev: device for which which resource was allocated
1557 * @chip: the chip to remove
1559 * A gpio_chip with any GPIOs still requested may not be removed.
1561 void devm_gpiochip_remove(struct device *dev, struct gpio_chip *chip)
1565 ret = devres_release(dev, devm_gpio_chip_release,
1566 devm_gpio_chip_match, chip);
1569 EXPORT_SYMBOL_GPL(devm_gpiochip_remove);
1572 * gpiochip_find() - iterator for locating a specific gpio_chip
1573 * @data: data to pass to match function
1574 * @match: Callback function to check gpio_chip
1576 * Similar to bus_find_device. It returns a reference to a gpio_chip as
1577 * determined by a user supplied @match callback. The callback should return
1578 * 0 if the device doesn't match and non-zero if it does. If the callback is
1579 * non-zero, this function will return to the caller and not iterate over any
1582 struct gpio_chip *gpiochip_find(void *data,
1583 int (*match)(struct gpio_chip *chip,
1586 struct gpio_device *gdev;
1587 struct gpio_chip *chip = NULL;
1588 unsigned long flags;
1590 spin_lock_irqsave(&gpio_lock, flags);
1591 list_for_each_entry(gdev, &gpio_devices, list)
1592 if (gdev->chip && match(gdev->chip, data)) {
1597 spin_unlock_irqrestore(&gpio_lock, flags);
1601 EXPORT_SYMBOL_GPL(gpiochip_find);
1603 static int gpiochip_match_name(struct gpio_chip *chip, void *data)
1605 const char *name = data;
1607 return !strcmp(chip->label, name);
1610 static struct gpio_chip *find_chip_by_name(const char *name)
1612 return gpiochip_find((void *)name, gpiochip_match_name);
1615 #ifdef CONFIG_GPIOLIB_IRQCHIP
1618 * The following is irqchip helper code for gpiochips.
1621 static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
1623 if (!gpiochip->irq.need_valid_mask)
1626 gpiochip->irq.valid_mask = gpiochip_allocate_mask(gpiochip);
1627 if (!gpiochip->irq.valid_mask)
1633 static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip)
1635 kfree(gpiochip->irq.valid_mask);
1636 gpiochip->irq.valid_mask = NULL;
1639 bool gpiochip_irqchip_irq_valid(const struct gpio_chip *gpiochip,
1640 unsigned int offset)
1642 if (!gpiochip_line_is_valid(gpiochip, offset))
1644 /* No mask means all valid */
1645 if (likely(!gpiochip->irq.valid_mask))
1647 return test_bit(offset, gpiochip->irq.valid_mask);
1649 EXPORT_SYMBOL_GPL(gpiochip_irqchip_irq_valid);
1652 * gpiochip_set_cascaded_irqchip() - connects a cascaded irqchip to a gpiochip
1653 * @gpiochip: the gpiochip to set the irqchip chain to
1654 * @irqchip: the irqchip to chain to the gpiochip
1655 * @parent_irq: the irq number corresponding to the parent IRQ for this
1657 * @parent_handler: the parent interrupt handler for the accumulated IRQ
1658 * coming out of the gpiochip. If the interrupt is nested rather than
1659 * cascaded, pass NULL in this handler argument
1661 static void gpiochip_set_cascaded_irqchip(struct gpio_chip *gpiochip,
1662 struct irq_chip *irqchip,
1663 unsigned int parent_irq,
1664 irq_flow_handler_t parent_handler)
1666 unsigned int offset;
1668 if (!gpiochip->irq.domain) {
1669 chip_err(gpiochip, "called %s before setting up irqchip\n",
1674 if (parent_handler) {
1675 if (gpiochip->can_sleep) {
1677 "you cannot have chained interrupts on a chip that may sleep\n");
1681 * The parent irqchip is already using the chip_data for this
1682 * irqchip, so our callbacks simply use the handler_data.
1684 irq_set_chained_handler_and_data(parent_irq, parent_handler,
1687 gpiochip->irq.parents = &parent_irq;
1688 gpiochip->irq.num_parents = 1;
1691 /* Set the parent IRQ for all affected IRQs */
1692 for (offset = 0; offset < gpiochip->ngpio; offset++) {
1693 if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
1695 irq_set_parent(irq_find_mapping(gpiochip->irq.domain, offset),
1701 * gpiochip_set_chained_irqchip() - connects a chained irqchip to a gpiochip
1702 * @gpiochip: the gpiochip to set the irqchip chain to
1703 * @irqchip: the irqchip to chain to the gpiochip
1704 * @parent_irq: the irq number corresponding to the parent IRQ for this
1706 * @parent_handler: the parent interrupt handler for the accumulated IRQ
1707 * coming out of the gpiochip. If the interrupt is nested rather than
1708 * cascaded, pass NULL in this handler argument
1710 void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
1711 struct irq_chip *irqchip,
1712 unsigned int parent_irq,
1713 irq_flow_handler_t parent_handler)
1715 if (gpiochip->irq.threaded) {
1716 chip_err(gpiochip, "tried to chain a threaded gpiochip\n");
1720 gpiochip_set_cascaded_irqchip(gpiochip, irqchip, parent_irq,
1723 EXPORT_SYMBOL_GPL(gpiochip_set_chained_irqchip);
1726 * gpiochip_set_nested_irqchip() - connects a nested irqchip to a gpiochip
1727 * @gpiochip: the gpiochip to set the irqchip nested handler to
1728 * @irqchip: the irqchip to nest to the gpiochip
1729 * @parent_irq: the irq number corresponding to the parent IRQ for this
1732 void gpiochip_set_nested_irqchip(struct gpio_chip *gpiochip,
1733 struct irq_chip *irqchip,
1734 unsigned int parent_irq)
1736 gpiochip_set_cascaded_irqchip(gpiochip, irqchip, parent_irq,
1739 EXPORT_SYMBOL_GPL(gpiochip_set_nested_irqchip);
1742 * gpiochip_irq_map() - maps an IRQ into a GPIO irqchip
1743 * @d: the irqdomain used by this irqchip
1744 * @irq: the global irq number used by this GPIO irqchip irq
1745 * @hwirq: the local IRQ/GPIO line offset on this gpiochip
1747 * This function will set up the mapping for a certain IRQ line on a
1748 * gpiochip by assigning the gpiochip as chip data, and using the irqchip
1749 * stored inside the gpiochip.
1751 int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
1752 irq_hw_number_t hwirq)
1754 struct gpio_chip *chip = d->host_data;
1757 if (!gpiochip_irqchip_irq_valid(chip, hwirq))
1760 irq_set_chip_data(irq, chip);
1762 * This lock class tells lockdep that GPIO irqs are in a different
1763 * category than their parents, so it won't report false recursion.
1765 irq_set_lockdep_class(irq, chip->irq.lock_key, chip->irq.request_key);
1766 irq_set_chip_and_handler(irq, chip->irq.chip, chip->irq.handler);
1767 /* Chips that use nested thread handlers have them marked */
1768 if (chip->irq.threaded)
1769 irq_set_nested_thread(irq, 1);
1770 irq_set_noprobe(irq);
1772 if (chip->irq.num_parents == 1)
1773 err = irq_set_parent(irq, chip->irq.parents[0]);
1774 else if (chip->irq.map)
1775 err = irq_set_parent(irq, chip->irq.map[hwirq]);
1781 * No set-up of the hardware will happen if IRQ_TYPE_NONE
1782 * is passed as default type.
1784 if (chip->irq.default_type != IRQ_TYPE_NONE)
1785 irq_set_irq_type(irq, chip->irq.default_type);
1789 EXPORT_SYMBOL_GPL(gpiochip_irq_map);
1791 void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
1793 struct gpio_chip *chip = d->host_data;
1795 if (chip->irq.threaded)
1796 irq_set_nested_thread(irq, 0);
1797 irq_set_chip_and_handler(irq, NULL, NULL);
1798 irq_set_chip_data(irq, NULL);
1800 EXPORT_SYMBOL_GPL(gpiochip_irq_unmap);
1802 static const struct irq_domain_ops gpiochip_domain_ops = {
1803 .map = gpiochip_irq_map,
1804 .unmap = gpiochip_irq_unmap,
1805 /* Virtually all GPIO irqchips are twocell:ed */
1806 .xlate = irq_domain_xlate_twocell,
1809 static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset)
1811 if (!gpiochip_irqchip_irq_valid(chip, offset))
1814 return irq_create_mapping(chip->irq.domain, offset);
1817 static int gpiochip_irq_reqres(struct irq_data *d)
1819 struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
1821 return gpiochip_reqres_irq(chip, d->hwirq);
1824 static void gpiochip_irq_relres(struct irq_data *d)
1826 struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
1828 gpiochip_relres_irq(chip, d->hwirq);
1831 static void gpiochip_irq_enable(struct irq_data *d)
1833 struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
1835 gpiochip_enable_irq(chip, d->hwirq);
1836 if (chip->irq.irq_enable)
1837 chip->irq.irq_enable(d);
1839 chip->irq.chip->irq_unmask(d);
1842 static void gpiochip_irq_disable(struct irq_data *d)
1844 struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
1846 if (chip->irq.irq_disable)
1847 chip->irq.irq_disable(d);
1849 chip->irq.chip->irq_mask(d);
1850 gpiochip_disable_irq(chip, d->hwirq);
1853 static void gpiochip_set_irq_hooks(struct gpio_chip *gpiochip)
1855 struct irq_chip *irqchip = gpiochip->irq.chip;
1857 if (!irqchip->irq_request_resources &&
1858 !irqchip->irq_release_resources) {
1859 irqchip->irq_request_resources = gpiochip_irq_reqres;
1860 irqchip->irq_release_resources = gpiochip_irq_relres;
1862 if (WARN_ON(gpiochip->irq.irq_enable))
1864 /* Check if the irqchip already has this hook... */
1865 if (irqchip->irq_enable == gpiochip_irq_enable) {
1867 * ...and if so, give a gentle warning that this is bad
1871 "detected irqchip that is shared with multiple gpiochips: please fix the driver.\n");
1874 gpiochip->irq.irq_enable = irqchip->irq_enable;
1875 gpiochip->irq.irq_disable = irqchip->irq_disable;
1876 irqchip->irq_enable = gpiochip_irq_enable;
1877 irqchip->irq_disable = gpiochip_irq_disable;
1881 * gpiochip_add_irqchip() - adds an IRQ chip to a GPIO chip
1882 * @gpiochip: the GPIO chip to add the IRQ chip to
1883 * @lock_key: lockdep class for IRQ lock
1884 * @request_key: lockdep class for IRQ request
1886 static int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
1887 struct lock_class_key *lock_key,
1888 struct lock_class_key *request_key)
1890 struct irq_chip *irqchip = gpiochip->irq.chip;
1891 const struct irq_domain_ops *ops;
1892 struct device_node *np;
1899 if (gpiochip->irq.parent_handler && gpiochip->can_sleep) {
1900 chip_err(gpiochip, "you cannot have chained interrupts on a chip that may sleep\n");
1904 np = gpiochip->gpiodev->dev.of_node;
1905 type = gpiochip->irq.default_type;
1908 * Specifying a default trigger is a terrible idea if DT or ACPI is
1909 * used to configure the interrupts, as you may end up with
1910 * conflicting triggers. Tell the user, and reset to NONE.
1912 if (WARN(np && type != IRQ_TYPE_NONE,
1913 "%s: Ignoring %u default trigger\n", np->full_name, type))
1914 type = IRQ_TYPE_NONE;
1916 if (has_acpi_companion(gpiochip->parent) && type != IRQ_TYPE_NONE) {
1917 acpi_handle_warn(ACPI_HANDLE(gpiochip->parent),
1918 "Ignoring %u default trigger\n", type);
1919 type = IRQ_TYPE_NONE;
1922 gpiochip->to_irq = gpiochip_to_irq;
1923 gpiochip->irq.default_type = type;
1924 gpiochip->irq.lock_key = lock_key;
1925 gpiochip->irq.request_key = request_key;
1927 if (gpiochip->irq.domain_ops)
1928 ops = gpiochip->irq.domain_ops;
1930 ops = &gpiochip_domain_ops;
1932 gpiochip->irq.domain = irq_domain_add_simple(np, gpiochip->ngpio,
1933 gpiochip->irq.first,
1935 if (!gpiochip->irq.domain)
1938 if (gpiochip->irq.parent_handler) {
1939 void *data = gpiochip->irq.parent_handler_data ?: gpiochip;
1941 for (i = 0; i < gpiochip->irq.num_parents; i++) {
1943 * The parent IRQ chip is already using the chip_data
1944 * for this IRQ chip, so our callbacks simply use the
1947 irq_set_chained_handler_and_data(gpiochip->irq.parents[i],
1948 gpiochip->irq.parent_handler,
1953 gpiochip_set_irq_hooks(gpiochip);
1955 acpi_gpiochip_request_interrupts(gpiochip);
1961 * gpiochip_irqchip_remove() - removes an irqchip added to a gpiochip
1962 * @gpiochip: the gpiochip to remove the irqchip from
1964 * This is called only from gpiochip_remove()
1966 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip)
1968 struct irq_chip *irqchip = gpiochip->irq.chip;
1969 unsigned int offset;
1971 acpi_gpiochip_free_interrupts(gpiochip);
1973 if (irqchip && gpiochip->irq.parent_handler) {
1974 struct gpio_irq_chip *irq = &gpiochip->irq;
1977 for (i = 0; i < irq->num_parents; i++)
1978 irq_set_chained_handler_and_data(irq->parents[i],
1982 /* Remove all IRQ mappings and delete the domain */
1983 if (gpiochip->irq.domain) {
1986 for (offset = 0; offset < gpiochip->ngpio; offset++) {
1987 if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
1990 irq = irq_find_mapping(gpiochip->irq.domain, offset);
1991 irq_dispose_mapping(irq);
1994 irq_domain_remove(gpiochip->irq.domain);
1998 if (irqchip->irq_request_resources == gpiochip_irq_reqres) {
1999 irqchip->irq_request_resources = NULL;
2000 irqchip->irq_release_resources = NULL;
2002 if (irqchip->irq_enable == gpiochip_irq_enable) {
2003 irqchip->irq_enable = gpiochip->irq.irq_enable;
2004 irqchip->irq_disable = gpiochip->irq.irq_disable;
2007 gpiochip->irq.irq_enable = NULL;
2008 gpiochip->irq.irq_disable = NULL;
2009 gpiochip->irq.chip = NULL;
2011 gpiochip_irqchip_free_valid_mask(gpiochip);
2015 * gpiochip_irqchip_add_key() - adds an irqchip to a gpiochip
2016 * @gpiochip: the gpiochip to add the irqchip to
2017 * @irqchip: the irqchip to add to the gpiochip
2018 * @first_irq: if not dynamically assigned, the base (first) IRQ to
2019 * allocate gpiochip irqs from
2020 * @handler: the irq handler to use (often a predefined irq core function)
2021 * @type: the default type for IRQs on this irqchip, pass IRQ_TYPE_NONE
2022 * to have the core avoid setting up any default type in the hardware.
2023 * @threaded: whether this irqchip uses a nested thread handler
2024 * @lock_key: lockdep class for IRQ lock
2025 * @request_key: lockdep class for IRQ request
2027 * This function closely associates a certain irqchip with a certain
2028 * gpiochip, providing an irq domain to translate the local IRQs to
2029 * global irqs in the gpiolib core, and making sure that the gpiochip
2030 * is passed as chip data to all related functions. Driver callbacks
2031 * need to use gpiochip_get_data() to get their local state containers back
2032 * from the gpiochip passed as chip data. An irqdomain will be stored
2033 * in the gpiochip that shall be used by the driver to handle IRQ number
2034 * translation. The gpiochip will need to be initialized and registered
2035 * before calling this function.
2037 * This function will handle two cell:ed simple IRQs and assumes all
2038 * the pins on the gpiochip can generate a unique IRQ. Everything else
2039 * need to be open coded.
2041 int gpiochip_irqchip_add_key(struct gpio_chip *gpiochip,
2042 struct irq_chip *irqchip,
2043 unsigned int first_irq,
2044 irq_flow_handler_t handler,
2047 struct lock_class_key *lock_key,
2048 struct lock_class_key *request_key)
2050 struct device_node *of_node;
2052 if (!gpiochip || !irqchip)
2055 if (!gpiochip->parent) {
2056 pr_err("missing gpiochip .dev parent pointer\n");
2059 gpiochip->irq.threaded = threaded;
2060 of_node = gpiochip->parent->of_node;
2061 #ifdef CONFIG_OF_GPIO
2063 * If the gpiochip has an assigned OF node this takes precedence
2064 * FIXME: get rid of this and use gpiochip->parent->of_node
2067 if (gpiochip->of_node)
2068 of_node = gpiochip->of_node;
2071 * Specifying a default trigger is a terrible idea if DT or ACPI is
2072 * used to configure the interrupts, as you may end-up with
2073 * conflicting triggers. Tell the user, and reset to NONE.
2075 if (WARN(of_node && type != IRQ_TYPE_NONE,
2076 "%pOF: Ignoring %d default trigger\n", of_node, type))
2077 type = IRQ_TYPE_NONE;
2078 if (has_acpi_companion(gpiochip->parent) && type != IRQ_TYPE_NONE) {
2079 acpi_handle_warn(ACPI_HANDLE(gpiochip->parent),
2080 "Ignoring %d default trigger\n", type);
2081 type = IRQ_TYPE_NONE;
2084 gpiochip->irq.chip = irqchip;
2085 gpiochip->irq.handler = handler;
2086 gpiochip->irq.default_type = type;
2087 gpiochip->to_irq = gpiochip_to_irq;
2088 gpiochip->irq.lock_key = lock_key;
2089 gpiochip->irq.request_key = request_key;
2090 gpiochip->irq.domain = irq_domain_add_simple(of_node,
2091 gpiochip->ngpio, first_irq,
2092 &gpiochip_domain_ops, gpiochip);
2093 if (!gpiochip->irq.domain) {
2094 gpiochip->irq.chip = NULL;
2098 gpiochip_set_irq_hooks(gpiochip);
2100 acpi_gpiochip_request_interrupts(gpiochip);
2104 EXPORT_SYMBOL_GPL(gpiochip_irqchip_add_key);
2106 #else /* CONFIG_GPIOLIB_IRQCHIP */
2108 static inline int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
2109 struct lock_class_key *lock_key,
2110 struct lock_class_key *request_key)
2115 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}
2116 static inline int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
2120 static inline void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip)
2123 #endif /* CONFIG_GPIOLIB_IRQCHIP */
2126 * gpiochip_generic_request() - request the gpio function for a pin
2127 * @chip: the gpiochip owning the GPIO
2128 * @offset: the offset of the GPIO to request for GPIO function
2130 int gpiochip_generic_request(struct gpio_chip *chip, unsigned offset)
2132 return pinctrl_gpio_request(chip->gpiodev->base + offset);
2134 EXPORT_SYMBOL_GPL(gpiochip_generic_request);
2137 * gpiochip_generic_free() - free the gpio function from a pin
2138 * @chip: the gpiochip to request the gpio function for
2139 * @offset: the offset of the GPIO to free from GPIO function
2141 void gpiochip_generic_free(struct gpio_chip *chip, unsigned offset)
2143 pinctrl_gpio_free(chip->gpiodev->base + offset);
2145 EXPORT_SYMBOL_GPL(gpiochip_generic_free);
2148 * gpiochip_generic_config() - apply configuration for a pin
2149 * @chip: the gpiochip owning the GPIO
2150 * @offset: the offset of the GPIO to apply the configuration
2151 * @config: the configuration to be applied
2153 int gpiochip_generic_config(struct gpio_chip *chip, unsigned offset,
2154 unsigned long config)
2156 return pinctrl_gpio_set_config(chip->gpiodev->base + offset, config);
2158 EXPORT_SYMBOL_GPL(gpiochip_generic_config);
2160 #ifdef CONFIG_PINCTRL
2163 * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
2164 * @chip: the gpiochip to add the range for
2165 * @pctldev: the pin controller to map to
2166 * @gpio_offset: the start offset in the current gpio_chip number space
2167 * @pin_group: name of the pin group inside the pin controller
2169 * Calling this function directly from a DeviceTree-supported
2170 * pinctrl driver is DEPRECATED. Please see Section 2.1 of
2171 * Documentation/devicetree/bindings/gpio/gpio.txt on how to
2172 * bind pinctrl and gpio drivers via the "gpio-ranges" property.
2174 int gpiochip_add_pingroup_range(struct gpio_chip *chip,
2175 struct pinctrl_dev *pctldev,
2176 unsigned int gpio_offset, const char *pin_group)
2178 struct gpio_pin_range *pin_range;
2179 struct gpio_device *gdev = chip->gpiodev;
2182 pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
2184 chip_err(chip, "failed to allocate pin ranges\n");
2188 /* Use local offset as range ID */
2189 pin_range->range.id = gpio_offset;
2190 pin_range->range.gc = chip;
2191 pin_range->range.name = chip->label;
2192 pin_range->range.base = gdev->base + gpio_offset;
2193 pin_range->pctldev = pctldev;
2195 ret = pinctrl_get_group_pins(pctldev, pin_group,
2196 &pin_range->range.pins,
2197 &pin_range->range.npins);
2203 pinctrl_add_gpio_range(pctldev, &pin_range->range);
2205 chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
2206 gpio_offset, gpio_offset + pin_range->range.npins - 1,
2207 pinctrl_dev_get_devname(pctldev), pin_group);
2209 list_add_tail(&pin_range->node, &gdev->pin_ranges);
2213 EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);
2216 * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
2217 * @chip: the gpiochip to add the range for
2218 * @pinctl_name: the dev_name() of the pin controller to map to
2219 * @gpio_offset: the start offset in the current gpio_chip number space
2220 * @pin_offset: the start offset in the pin controller number space
2221 * @npins: the number of pins from the offset of each pin space (GPIO and
2222 * pin controller) to accumulate in this range
2225 * 0 on success, or a negative error-code on failure.
2227 * Calling this function directly from a DeviceTree-supported
2228 * pinctrl driver is DEPRECATED. Please see Section 2.1 of
2229 * Documentation/devicetree/bindings/gpio/gpio.txt on how to
2230 * bind pinctrl and gpio drivers via the "gpio-ranges" property.
2232 int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
2233 unsigned int gpio_offset, unsigned int pin_offset,
2236 struct gpio_pin_range *pin_range;
2237 struct gpio_device *gdev = chip->gpiodev;
2240 pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
2242 chip_err(chip, "failed to allocate pin ranges\n");
2246 /* Use local offset as range ID */
2247 pin_range->range.id = gpio_offset;
2248 pin_range->range.gc = chip;
2249 pin_range->range.name = chip->label;
2250 pin_range->range.base = gdev->base + gpio_offset;
2251 pin_range->range.pin_base = pin_offset;
2252 pin_range->range.npins = npins;
2253 pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
2255 if (IS_ERR(pin_range->pctldev)) {
2256 ret = PTR_ERR(pin_range->pctldev);
2257 chip_err(chip, "could not create pin range\n");
2261 chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
2262 gpio_offset, gpio_offset + npins - 1,
2264 pin_offset, pin_offset + npins - 1);
2266 list_add_tail(&pin_range->node, &gdev->pin_ranges);
2270 EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
2273 * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
2274 * @chip: the chip to remove all the mappings for
2276 void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
2278 struct gpio_pin_range *pin_range, *tmp;
2279 struct gpio_device *gdev = chip->gpiodev;
2281 list_for_each_entry_safe(pin_range, tmp, &gdev->pin_ranges, node) {
2282 list_del(&pin_range->node);
2283 pinctrl_remove_gpio_range(pin_range->pctldev,
2288 EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
2290 #endif /* CONFIG_PINCTRL */
2292 /* These "optional" allocation calls help prevent drivers from stomping
2293 * on each other, and help provide better diagnostics in debugfs.
2294 * They're called even less than the "set direction" calls.
2296 static int gpiod_request_commit(struct gpio_desc *desc, const char *label)
2298 struct gpio_chip *chip = desc->gdev->chip;
2300 unsigned long flags;
2303 spin_lock_irqsave(&gpio_lock, flags);
2305 /* NOTE: gpio_request() can be called in early boot,
2306 * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
2309 if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
2310 desc_set_label(desc, label ? : "?");
2317 if (chip->request) {
2318 /* chip->request may sleep */
2319 spin_unlock_irqrestore(&gpio_lock, flags);
2320 offset = gpio_chip_hwgpio(desc);
2321 if (gpiochip_line_is_valid(chip, offset))
2322 status = chip->request(chip, offset);
2325 spin_lock_irqsave(&gpio_lock, flags);
2328 desc_set_label(desc, NULL);
2329 clear_bit(FLAG_REQUESTED, &desc->flags);
2333 if (chip->get_direction) {
2334 /* chip->get_direction may sleep */
2335 spin_unlock_irqrestore(&gpio_lock, flags);
2336 gpiod_get_direction(desc);
2337 spin_lock_irqsave(&gpio_lock, flags);
2340 spin_unlock_irqrestore(&gpio_lock, flags);
2345 * This descriptor validation needs to be inserted verbatim into each
2346 * function taking a descriptor, so we need to use a preprocessor
2347 * macro to avoid endless duplication. If the desc is NULL it is an
2348 * optional GPIO and calls should just bail out.
2350 static int validate_desc(const struct gpio_desc *desc, const char *func)
2355 pr_warn("%s: invalid GPIO (errorpointer)\n", func);
2356 return PTR_ERR(desc);
2359 pr_warn("%s: invalid GPIO (no device)\n", func);
2362 if (!desc->gdev->chip) {
2363 dev_warn(&desc->gdev->dev,
2364 "%s: backing chip is gone\n", func);
2370 #define VALIDATE_DESC(desc) do { \
2371 int __valid = validate_desc(desc, __func__); \
2376 #define VALIDATE_DESC_VOID(desc) do { \
2377 int __valid = validate_desc(desc, __func__); \
2382 int gpiod_request(struct gpio_desc *desc, const char *label)
2384 int status = -EPROBE_DEFER;
2385 struct gpio_device *gdev;
2387 VALIDATE_DESC(desc);
2390 if (try_module_get(gdev->owner)) {
2391 status = gpiod_request_commit(desc, label);
2393 module_put(gdev->owner);
2395 get_device(&gdev->dev);
2399 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
2404 static bool gpiod_free_commit(struct gpio_desc *desc)
2407 unsigned long flags;
2408 struct gpio_chip *chip;
2412 gpiod_unexport(desc);
2414 spin_lock_irqsave(&gpio_lock, flags);
2416 chip = desc->gdev->chip;
2417 if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
2419 spin_unlock_irqrestore(&gpio_lock, flags);
2420 might_sleep_if(chip->can_sleep);
2421 chip->free(chip, gpio_chip_hwgpio(desc));
2422 spin_lock_irqsave(&gpio_lock, flags);
2424 desc_set_label(desc, NULL);
2425 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
2426 clear_bit(FLAG_REQUESTED, &desc->flags);
2427 clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
2428 clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
2429 clear_bit(FLAG_IS_HOGGED, &desc->flags);
2433 spin_unlock_irqrestore(&gpio_lock, flags);
2437 void gpiod_free(struct gpio_desc *desc)
2439 if (desc && desc->gdev && gpiod_free_commit(desc)) {
2440 module_put(desc->gdev->owner);
2441 put_device(&desc->gdev->dev);
2443 WARN_ON(extra_checks);
2448 * gpiochip_is_requested - return string iff signal was requested
2449 * @chip: controller managing the signal
2450 * @offset: of signal within controller's 0..(ngpio - 1) range
2452 * Returns NULL if the GPIO is not currently requested, else a string.
2453 * The string returned is the label passed to gpio_request(); if none has been
2454 * passed it is a meaningless, non-NULL constant.
2456 * This function is for use by GPIO controller drivers. The label can
2457 * help with diagnostics, and knowing that the signal is used as a GPIO
2458 * can help avoid accidentally multiplexing it to another controller.
2460 const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
2462 struct gpio_desc *desc;
2464 if (offset >= chip->ngpio)
2467 desc = &chip->gpiodev->descs[offset];
2469 if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
2473 EXPORT_SYMBOL_GPL(gpiochip_is_requested);
2476 * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor
2478 * @hwnum: hardware number of the GPIO for which to request the descriptor
2479 * @label: label for the GPIO
2481 * Function allows GPIO chip drivers to request and use their own GPIO
2482 * descriptors via gpiolib API. Difference to gpiod_request() is that this
2483 * function will not increase reference count of the GPIO chip module. This
2484 * allows the GPIO chip module to be unloaded as needed (we assume that the
2485 * GPIO chip driver handles freeing the GPIOs it has requested).
2488 * A pointer to the GPIO descriptor, or an ERR_PTR()-encoded negative error
2491 struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *chip, u16 hwnum,
2494 struct gpio_desc *desc = gpiochip_get_desc(chip, hwnum);
2498 chip_err(chip, "failed to get GPIO descriptor\n");
2502 err = gpiod_request_commit(desc, label);
2504 return ERR_PTR(err);
2508 EXPORT_SYMBOL_GPL(gpiochip_request_own_desc);
2511 * gpiochip_free_own_desc - Free GPIO requested by the chip driver
2512 * @desc: GPIO descriptor to free
2514 * Function frees the given GPIO requested previously with
2515 * gpiochip_request_own_desc().
2517 void gpiochip_free_own_desc(struct gpio_desc *desc)
2520 gpiod_free_commit(desc);
2522 EXPORT_SYMBOL_GPL(gpiochip_free_own_desc);
2525 * Drivers MUST set GPIO direction before making get/set calls. In
2526 * some cases this is done in early boot, before IRQs are enabled.
2528 * As a rule these aren't called more than once (except for drivers
2529 * using the open-drain emulation idiom) so these are natural places
2530 * to accumulate extra debugging checks. Note that we can't (yet)
2531 * rely on gpio_request() having been called beforehand.
2535 * gpiod_direction_input - set the GPIO direction to input
2536 * @desc: GPIO to set to input
2538 * Set the direction of the passed GPIO to input, such as gpiod_get_value() can
2539 * be called safely on it.
2541 * Return 0 in case of success, else an error code.
2543 int gpiod_direction_input(struct gpio_desc *desc)
2545 struct gpio_chip *chip;
2548 VALIDATE_DESC(desc);
2549 chip = desc->gdev->chip;
2552 * It is legal to have no .get() and .direction_input() specified if
2553 * the chip is output-only, but you can't specify .direction_input()
2554 * and not support the .get() operation, that doesn't make sense.
2556 if (!chip->get && chip->direction_input) {
2558 "%s: missing get() but have direction_input()\n",
2564 * If we have a .direction_input() callback, things are simple,
2565 * just call it. Else we are some input-only chip so try to check the
2566 * direction (if .get_direction() is supported) else we silently
2567 * assume we are in input mode after this.
2569 if (chip->direction_input) {
2570 status = chip->direction_input(chip, gpio_chip_hwgpio(desc));
2571 } else if (chip->get_direction &&
2572 (chip->get_direction(chip, gpio_chip_hwgpio(desc)) != 1)) {
2574 "%s: missing direction_input() operation and line is output\n",
2579 clear_bit(FLAG_IS_OUT, &desc->flags);
2581 trace_gpio_direction(desc_to_gpio(desc), 1, status);
2585 EXPORT_SYMBOL_GPL(gpiod_direction_input);
2587 static int gpio_set_drive_single_ended(struct gpio_chip *gc, unsigned offset,
2588 enum pin_config_param mode)
2590 unsigned long config = { PIN_CONF_PACKED(mode, 0) };
2592 return gc->set_config ? gc->set_config(gc, offset, config) : -ENOTSUPP;
2595 static int gpiod_direction_output_raw_commit(struct gpio_desc *desc, int value)
2597 struct gpio_chip *gc = desc->gdev->chip;
2602 * It's OK not to specify .direction_output() if the gpiochip is
2603 * output-only, but if there is then not even a .set() operation it
2604 * is pretty tricky to drive the output line.
2606 if (!gc->set && !gc->direction_output) {
2608 "%s: missing set() and direction_output() operations\n",
2613 if (gc->direction_output) {
2614 ret = gc->direction_output(gc, gpio_chip_hwgpio(desc), val);
2616 /* Check that we are in output mode if we can */
2617 if (gc->get_direction &&
2618 gc->get_direction(gc, gpio_chip_hwgpio(desc))) {
2620 "%s: missing direction_output() operation\n",
2625 * If we can't actively set the direction, we are some
2626 * output-only chip, so just drive the output as desired.
2628 gc->set(gc, gpio_chip_hwgpio(desc), val);
2632 set_bit(FLAG_IS_OUT, &desc->flags);
2633 trace_gpio_value(desc_to_gpio(desc), 0, val);
2634 trace_gpio_direction(desc_to_gpio(desc), 0, ret);
2639 * gpiod_direction_output_raw - set the GPIO direction to output
2640 * @desc: GPIO to set to output
2641 * @value: initial output value of the GPIO
2643 * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
2644 * be called safely on it. The initial value of the output must be specified
2645 * as raw value on the physical line without regard for the ACTIVE_LOW status.
2647 * Return 0 in case of success, else an error code.
2649 int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
2651 VALIDATE_DESC(desc);
2652 return gpiod_direction_output_raw_commit(desc, value);
2654 EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);
2657 * gpiod_direction_output - set the GPIO direction to output
2658 * @desc: GPIO to set to output
2659 * @value: initial output value of the GPIO
2661 * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
2662 * be called safely on it. The initial value of the output must be specified
2663 * as the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2666 * Return 0 in case of success, else an error code.
2668 int gpiod_direction_output(struct gpio_desc *desc, int value)
2670 struct gpio_chip *gc;
2673 VALIDATE_DESC(desc);
2674 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2679 /* GPIOs used for enabled IRQs shall not be set as output */
2680 if (test_bit(FLAG_USED_AS_IRQ, &desc->flags) &&
2681 test_bit(FLAG_IRQ_IS_ENABLED, &desc->flags)) {
2683 "%s: tried to set a GPIO tied to an IRQ as output\n",
2688 gc = desc->gdev->chip;
2689 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
2690 /* First see if we can enable open drain in hardware */
2691 ret = gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
2692 PIN_CONFIG_DRIVE_OPEN_DRAIN);
2694 goto set_output_value;
2695 /* Emulate open drain by not actively driving the line high */
2697 return gpiod_direction_input(desc);
2699 else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
2700 ret = gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
2701 PIN_CONFIG_DRIVE_OPEN_SOURCE);
2703 goto set_output_value;
2704 /* Emulate open source by not actively driving the line low */
2706 return gpiod_direction_input(desc);
2708 gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
2709 PIN_CONFIG_DRIVE_PUSH_PULL);
2713 return gpiod_direction_output_raw_commit(desc, value);
2715 EXPORT_SYMBOL_GPL(gpiod_direction_output);
2718 * gpiod_set_debounce - sets @debounce time for a GPIO
2719 * @desc: descriptor of the GPIO for which to set debounce time
2720 * @debounce: debounce time in microseconds
2723 * 0 on success, %-ENOTSUPP if the controller doesn't support setting the
2726 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
2728 struct gpio_chip *chip;
2729 unsigned long config;
2731 VALIDATE_DESC(desc);
2732 chip = desc->gdev->chip;
2733 if (!chip->set || !chip->set_config) {
2735 "%s: missing set() or set_config() operations\n",
2740 config = pinconf_to_config_packed(PIN_CONFIG_INPUT_DEBOUNCE, debounce);
2741 return chip->set_config(chip, gpio_chip_hwgpio(desc), config);
2743 EXPORT_SYMBOL_GPL(gpiod_set_debounce);
2746 * gpiod_set_transitory - Lose or retain GPIO state on suspend or reset
2747 * @desc: descriptor of the GPIO for which to configure persistence
2748 * @transitory: True to lose state on suspend or reset, false for persistence
2751 * 0 on success, otherwise a negative error code.
2753 int gpiod_set_transitory(struct gpio_desc *desc, bool transitory)
2755 struct gpio_chip *chip;
2756 unsigned long packed;
2760 VALIDATE_DESC(desc);
2762 * Handle FLAG_TRANSITORY first, enabling queries to gpiolib for
2763 * persistence state.
2766 set_bit(FLAG_TRANSITORY, &desc->flags);
2768 clear_bit(FLAG_TRANSITORY, &desc->flags);
2770 /* If the driver supports it, set the persistence state now */
2771 chip = desc->gdev->chip;
2772 if (!chip->set_config)
2775 packed = pinconf_to_config_packed(PIN_CONFIG_PERSIST_STATE,
2777 gpio = gpio_chip_hwgpio(desc);
2778 rc = chip->set_config(chip, gpio, packed);
2779 if (rc == -ENOTSUPP) {
2780 dev_dbg(&desc->gdev->dev, "Persistence not supported for GPIO %d\n",
2787 EXPORT_SYMBOL_GPL(gpiod_set_transitory);
2790 * gpiod_is_active_low - test whether a GPIO is active-low or not
2791 * @desc: the gpio descriptor to test
2793 * Returns 1 if the GPIO is active-low, 0 otherwise.
2795 int gpiod_is_active_low(const struct gpio_desc *desc)
2797 VALIDATE_DESC(desc);
2798 return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
2800 EXPORT_SYMBOL_GPL(gpiod_is_active_low);
2802 /* I/O calls are only valid after configuration completed; the relevant
2803 * "is this a valid GPIO" error checks should already have been done.
2805 * "Get" operations are often inlinable as reading a pin value register,
2806 * and masking the relevant bit in that register.
2808 * When "set" operations are inlinable, they involve writing that mask to
2809 * one register to set a low value, or a different register to set it high.
2810 * Otherwise locking is needed, so there may be little value to inlining.
2812 *------------------------------------------------------------------------
2814 * IMPORTANT!!! The hot paths -- get/set value -- assume that callers
2815 * have requested the GPIO. That can include implicit requesting by
2816 * a direction setting call. Marking a gpio as requested locks its chip
2817 * in memory, guaranteeing that these table lookups need no more locking
2818 * and that gpiochip_remove() will fail.
2820 * REVISIT when debugging, consider adding some instrumentation to ensure
2821 * that the GPIO was actually requested.
2824 static int gpiod_get_raw_value_commit(const struct gpio_desc *desc)
2826 struct gpio_chip *chip;
2830 chip = desc->gdev->chip;
2831 offset = gpio_chip_hwgpio(desc);
2832 value = chip->get ? chip->get(chip, offset) : -EIO;
2833 value = value < 0 ? value : !!value;
2834 trace_gpio_value(desc_to_gpio(desc), 1, value);
2838 static int gpio_chip_get_multiple(struct gpio_chip *chip,
2839 unsigned long *mask, unsigned long *bits)
2841 if (chip->get_multiple) {
2842 return chip->get_multiple(chip, mask, bits);
2843 } else if (chip->get) {
2846 for_each_set_bit(i, mask, chip->ngpio) {
2847 value = chip->get(chip, i);
2850 __assign_bit(i, bits, value);
2857 int gpiod_get_array_value_complex(bool raw, bool can_sleep,
2858 unsigned int array_size,
2859 struct gpio_desc **desc_array,
2860 struct gpio_array *array_info,
2861 unsigned long *value_bitmap)
2866 * Validate array_info against desc_array and its size.
2867 * It should immediately follow desc_array if both
2868 * have been obtained from the same gpiod_get_array() call.
2870 if (array_info && array_info->desc == desc_array &&
2871 array_size <= array_info->size &&
2872 (void *)array_info == desc_array + array_info->size) {
2874 WARN_ON(array_info->chip->can_sleep);
2876 err = gpio_chip_get_multiple(array_info->chip,
2877 array_info->get_mask,
2882 if (!raw && !bitmap_empty(array_info->invert_mask, array_size))
2883 bitmap_xor(value_bitmap, value_bitmap,
2884 array_info->invert_mask, array_size);
2886 if (bitmap_full(array_info->get_mask, array_size))
2889 i = find_first_zero_bit(array_info->get_mask, array_size);
2894 while (i < array_size) {
2895 struct gpio_chip *chip = desc_array[i]->gdev->chip;
2896 unsigned long fastpath[2 * BITS_TO_LONGS(FASTPATH_NGPIO)];
2897 unsigned long *mask, *bits;
2900 if (likely(chip->ngpio <= FASTPATH_NGPIO)) {
2903 mask = kmalloc_array(2 * BITS_TO_LONGS(chip->ngpio),
2905 can_sleep ? GFP_KERNEL : GFP_ATOMIC);
2910 bits = mask + BITS_TO_LONGS(chip->ngpio);
2911 bitmap_zero(mask, chip->ngpio);
2914 WARN_ON(chip->can_sleep);
2916 /* collect all inputs belonging to the same chip */
2919 const struct gpio_desc *desc = desc_array[i];
2920 int hwgpio = gpio_chip_hwgpio(desc);
2922 __set_bit(hwgpio, mask);
2925 i = find_next_zero_bit(array_info->get_mask,
2929 } while ((i < array_size) &&
2930 (desc_array[i]->gdev->chip == chip));
2932 ret = gpio_chip_get_multiple(chip, mask, bits);
2934 if (mask != fastpath)
2939 for (j = first; j < i; ) {
2940 const struct gpio_desc *desc = desc_array[j];
2941 int hwgpio = gpio_chip_hwgpio(desc);
2942 int value = test_bit(hwgpio, bits);
2944 if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2946 __assign_bit(j, value_bitmap, value);
2947 trace_gpio_value(desc_to_gpio(desc), 1, value);
2950 j = find_next_zero_bit(array_info->get_mask, i,
2956 if (mask != fastpath)
2963 * gpiod_get_raw_value() - return a gpio's raw value
2964 * @desc: gpio whose value will be returned
2966 * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2967 * its ACTIVE_LOW status, or negative errno on failure.
2969 * This function should be called from contexts where we cannot sleep, and will
2970 * complain if the GPIO chip functions potentially sleep.
2972 int gpiod_get_raw_value(const struct gpio_desc *desc)
2974 VALIDATE_DESC(desc);
2975 /* Should be using gpio_get_value_cansleep() */
2976 WARN_ON(desc->gdev->chip->can_sleep);
2977 return gpiod_get_raw_value_commit(desc);
2979 EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
2982 * gpiod_get_value() - return a gpio's value
2983 * @desc: gpio whose value will be returned
2985 * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
2986 * account, or negative errno on failure.
2988 * This function should be called from contexts where we cannot sleep, and will
2989 * complain if the GPIO chip functions potentially sleep.
2991 int gpiod_get_value(const struct gpio_desc *desc)
2995 VALIDATE_DESC(desc);
2996 /* Should be using gpio_get_value_cansleep() */
2997 WARN_ON(desc->gdev->chip->can_sleep);
2999 value = gpiod_get_raw_value_commit(desc);
3003 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
3008 EXPORT_SYMBOL_GPL(gpiod_get_value);
3011 * gpiod_get_raw_array_value() - read raw values from an array of GPIOs
3012 * @array_size: number of elements in the descriptor array / value bitmap
3013 * @desc_array: array of GPIO descriptors whose values will be read
3014 * @array_info: information on applicability of fast bitmap processing path
3015 * @value_bitmap: bitmap to store the read values
3017 * Read the raw values of the GPIOs, i.e. the values of the physical lines
3018 * without regard for their ACTIVE_LOW status. Return 0 in case of success,
3019 * else an error code.
3021 * This function should be called from contexts where we cannot sleep,
3022 * and it will complain if the GPIO chip functions potentially sleep.
3024 int gpiod_get_raw_array_value(unsigned int array_size,
3025 struct gpio_desc **desc_array,
3026 struct gpio_array *array_info,
3027 unsigned long *value_bitmap)
3031 return gpiod_get_array_value_complex(true, false, array_size,
3032 desc_array, array_info,
3035 EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value);
3038 * gpiod_get_array_value() - read values from an array of GPIOs
3039 * @array_size: number of elements in the descriptor array / value bitmap
3040 * @desc_array: array of GPIO descriptors whose values will be read
3041 * @array_info: information on applicability of fast bitmap processing path
3042 * @value_bitmap: bitmap to store the read values
3044 * Read the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
3045 * into account. Return 0 in case of success, else an error code.
3047 * This function should be called from contexts where we cannot sleep,
3048 * and it will complain if the GPIO chip functions potentially sleep.
3050 int gpiod_get_array_value(unsigned int array_size,
3051 struct gpio_desc **desc_array,
3052 struct gpio_array *array_info,
3053 unsigned long *value_bitmap)
3057 return gpiod_get_array_value_complex(false, false, array_size,
3058 desc_array, array_info,
3061 EXPORT_SYMBOL_GPL(gpiod_get_array_value);
3064 * gpio_set_open_drain_value_commit() - Set the open drain gpio's value.
3065 * @desc: gpio descriptor whose state need to be set.
3066 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
3068 static void gpio_set_open_drain_value_commit(struct gpio_desc *desc, bool value)
3071 struct gpio_chip *chip = desc->gdev->chip;
3072 int offset = gpio_chip_hwgpio(desc);
3075 err = chip->direction_input(chip, offset);
3077 clear_bit(FLAG_IS_OUT, &desc->flags);
3079 err = chip->direction_output(chip, offset, 0);
3081 set_bit(FLAG_IS_OUT, &desc->flags);
3083 trace_gpio_direction(desc_to_gpio(desc), value, err);
3086 "%s: Error in set_value for open drain err %d\n",
3091 * _gpio_set_open_source_value() - Set the open source gpio's value.
3092 * @desc: gpio descriptor whose state need to be set.
3093 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
3095 static void gpio_set_open_source_value_commit(struct gpio_desc *desc, bool value)
3098 struct gpio_chip *chip = desc->gdev->chip;
3099 int offset = gpio_chip_hwgpio(desc);
3102 err = chip->direction_output(chip, offset, 1);
3104 set_bit(FLAG_IS_OUT, &desc->flags);
3106 err = chip->direction_input(chip, offset);
3108 clear_bit(FLAG_IS_OUT, &desc->flags);
3110 trace_gpio_direction(desc_to_gpio(desc), !value, err);
3113 "%s: Error in set_value for open source err %d\n",
3117 static void gpiod_set_raw_value_commit(struct gpio_desc *desc, bool value)
3119 struct gpio_chip *chip;
3121 chip = desc->gdev->chip;
3122 trace_gpio_value(desc_to_gpio(desc), 0, value);
3123 chip->set(chip, gpio_chip_hwgpio(desc), value);
3127 * set multiple outputs on the same chip;
3128 * use the chip's set_multiple function if available;
3129 * otherwise set the outputs sequentially;
3130 * @mask: bit mask array; one bit per output; BITS_PER_LONG bits per word
3131 * defines which outputs are to be changed
3132 * @bits: bit value array; one bit per output; BITS_PER_LONG bits per word
3133 * defines the values the outputs specified by mask are to be set to
3135 static void gpio_chip_set_multiple(struct gpio_chip *chip,
3136 unsigned long *mask, unsigned long *bits)
3138 if (chip->set_multiple) {
3139 chip->set_multiple(chip, mask, bits);
3143 /* set outputs if the corresponding mask bit is set */
3144 for_each_set_bit(i, mask, chip->ngpio)
3145 chip->set(chip, i, test_bit(i, bits));
3149 int gpiod_set_array_value_complex(bool raw, bool can_sleep,
3150 unsigned int array_size,
3151 struct gpio_desc **desc_array,
3152 struct gpio_array *array_info,
3153 unsigned long *value_bitmap)
3158 * Validate array_info against desc_array and its size.
3159 * It should immediately follow desc_array if both
3160 * have been obtained from the same gpiod_get_array() call.
3162 if (array_info && array_info->desc == desc_array &&
3163 array_size <= array_info->size &&
3164 (void *)array_info == desc_array + array_info->size) {
3166 WARN_ON(array_info->chip->can_sleep);
3168 if (!raw && !bitmap_empty(array_info->invert_mask, array_size))
3169 bitmap_xor(value_bitmap, value_bitmap,
3170 array_info->invert_mask, array_size);
3172 gpio_chip_set_multiple(array_info->chip, array_info->set_mask,
3175 if (bitmap_full(array_info->set_mask, array_size))
3178 i = find_first_zero_bit(array_info->set_mask, array_size);
3183 while (i < array_size) {
3184 struct gpio_chip *chip = desc_array[i]->gdev->chip;
3185 unsigned long fastpath[2 * BITS_TO_LONGS(FASTPATH_NGPIO)];
3186 unsigned long *mask, *bits;
3189 if (likely(chip->ngpio <= FASTPATH_NGPIO)) {
3192 mask = kmalloc_array(2 * BITS_TO_LONGS(chip->ngpio),
3194 can_sleep ? GFP_KERNEL : GFP_ATOMIC);
3199 bits = mask + BITS_TO_LONGS(chip->ngpio);
3200 bitmap_zero(mask, chip->ngpio);
3203 WARN_ON(chip->can_sleep);
3206 struct gpio_desc *desc = desc_array[i];
3207 int hwgpio = gpio_chip_hwgpio(desc);
3208 int value = test_bit(i, value_bitmap);
3211 * Pins applicable for fast input but not for
3212 * fast output processing may have been already
3213 * inverted inside the fast path, skip them.
3215 if (!raw && !(array_info &&
3216 test_bit(i, array_info->invert_mask)) &&
3217 test_bit(FLAG_ACTIVE_LOW, &desc->flags))
3219 trace_gpio_value(desc_to_gpio(desc), 0, value);
3221 * collect all normal outputs belonging to the same chip
3222 * open drain and open source outputs are set individually
3224 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) && !raw) {
3225 gpio_set_open_drain_value_commit(desc, value);
3226 } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags) && !raw) {
3227 gpio_set_open_source_value_commit(desc, value);
3229 __set_bit(hwgpio, mask);
3231 __set_bit(hwgpio, bits);
3233 __clear_bit(hwgpio, bits);
3238 i = find_next_zero_bit(array_info->set_mask,
3242 } while ((i < array_size) &&
3243 (desc_array[i]->gdev->chip == chip));
3244 /* push collected bits to outputs */
3246 gpio_chip_set_multiple(chip, mask, bits);
3248 if (mask != fastpath)
3255 * gpiod_set_raw_value() - assign a gpio's raw value
3256 * @desc: gpio whose value will be assigned
3257 * @value: value to assign
3259 * Set the raw value of the GPIO, i.e. the value of its physical line without
3260 * regard for its ACTIVE_LOW status.
3262 * This function should be called from contexts where we cannot sleep, and will
3263 * complain if the GPIO chip functions potentially sleep.
3265 void gpiod_set_raw_value(struct gpio_desc *desc, int value)
3267 VALIDATE_DESC_VOID(desc);
3268 /* Should be using gpiod_set_value_cansleep() */
3269 WARN_ON(desc->gdev->chip->can_sleep);
3270 gpiod_set_raw_value_commit(desc, value);
3272 EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
3275 * gpiod_set_value_nocheck() - set a GPIO line value without checking
3276 * @desc: the descriptor to set the value on
3277 * @value: value to set
3279 * This sets the value of a GPIO line backing a descriptor, applying
3280 * different semantic quirks like active low and open drain/source
3283 static void gpiod_set_value_nocheck(struct gpio_desc *desc, int value)
3285 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
3287 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
3288 gpio_set_open_drain_value_commit(desc, value);
3289 else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
3290 gpio_set_open_source_value_commit(desc, value);
3292 gpiod_set_raw_value_commit(desc, value);
3296 * gpiod_set_value() - assign a gpio's value
3297 * @desc: gpio whose value will be assigned
3298 * @value: value to assign
3300 * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW,
3301 * OPEN_DRAIN and OPEN_SOURCE flags into account.
3303 * This function should be called from contexts where we cannot sleep, and will
3304 * complain if the GPIO chip functions potentially sleep.
3306 void gpiod_set_value(struct gpio_desc *desc, int value)
3308 VALIDATE_DESC_VOID(desc);
3309 WARN_ON(desc->gdev->chip->can_sleep);
3310 gpiod_set_value_nocheck(desc, value);
3312 EXPORT_SYMBOL_GPL(gpiod_set_value);
3315 * gpiod_set_raw_array_value() - assign values to an array of GPIOs
3316 * @array_size: number of elements in the descriptor array / value bitmap
3317 * @desc_array: array of GPIO descriptors whose values will be assigned
3318 * @array_info: information on applicability of fast bitmap processing path
3319 * @value_bitmap: bitmap of values to assign
3321 * Set the raw values of the GPIOs, i.e. the values of the physical lines
3322 * without regard for their ACTIVE_LOW status.
3324 * This function should be called from contexts where we cannot sleep, and will
3325 * complain if the GPIO chip functions potentially sleep.
3327 int gpiod_set_raw_array_value(unsigned int array_size,
3328 struct gpio_desc **desc_array,
3329 struct gpio_array *array_info,
3330 unsigned long *value_bitmap)
3334 return gpiod_set_array_value_complex(true, false, array_size,
3335 desc_array, array_info, value_bitmap);
3337 EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value);
3340 * gpiod_set_array_value() - assign values to an array of GPIOs
3341 * @array_size: number of elements in the descriptor array / value bitmap
3342 * @desc_array: array of GPIO descriptors whose values will be assigned
3343 * @array_info: information on applicability of fast bitmap processing path
3344 * @value_bitmap: bitmap of values to assign
3346 * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
3349 * This function should be called from contexts where we cannot sleep, and will
3350 * complain if the GPIO chip functions potentially sleep.
3352 void gpiod_set_array_value(unsigned int array_size,
3353 struct gpio_desc **desc_array,
3354 struct gpio_array *array_info,
3355 unsigned long *value_bitmap)
3359 gpiod_set_array_value_complex(false, false, array_size, desc_array,
3360 array_info, value_bitmap);
3362 EXPORT_SYMBOL_GPL(gpiod_set_array_value);
3365 * gpiod_cansleep() - report whether gpio value access may sleep
3366 * @desc: gpio to check
3369 int gpiod_cansleep(const struct gpio_desc *desc)
3371 VALIDATE_DESC(desc);
3372 return desc->gdev->chip->can_sleep;
3374 EXPORT_SYMBOL_GPL(gpiod_cansleep);
3377 * gpiod_set_consumer_name() - set the consumer name for the descriptor
3378 * @desc: gpio to set the consumer name on
3379 * @name: the new consumer name
3381 void gpiod_set_consumer_name(struct gpio_desc *desc, const char *name)
3383 VALIDATE_DESC_VOID(desc);
3384 /* Just overwrite whatever the previous name was */
3387 EXPORT_SYMBOL_GPL(gpiod_set_consumer_name);
3390 * gpiod_to_irq() - return the IRQ corresponding to a GPIO
3391 * @desc: gpio whose IRQ will be returned (already requested)
3393 * Return the IRQ corresponding to the passed GPIO, or an error code in case of
3396 int gpiod_to_irq(const struct gpio_desc *desc)
3398 struct gpio_chip *chip;
3402 * Cannot VALIDATE_DESC() here as gpiod_to_irq() consumer semantics
3403 * requires this function to not return zero on an invalid descriptor
3404 * but rather a negative error number.
3406 if (!desc || IS_ERR(desc) || !desc->gdev || !desc->gdev->chip)
3409 chip = desc->gdev->chip;
3410 offset = gpio_chip_hwgpio(desc);
3412 int retirq = chip->to_irq(chip, offset);
3414 /* Zero means NO_IRQ */
3422 EXPORT_SYMBOL_GPL(gpiod_to_irq);
3425 * gpiochip_lock_as_irq() - lock a GPIO to be used as IRQ
3426 * @chip: the chip the GPIO to lock belongs to
3427 * @offset: the offset of the GPIO to lock as IRQ
3429 * This is used directly by GPIO drivers that want to lock down
3430 * a certain GPIO line to be used for IRQs.
3432 int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
3434 struct gpio_desc *desc;
3436 desc = gpiochip_get_desc(chip, offset);
3438 return PTR_ERR(desc);
3441 * If it's fast: flush the direction setting if something changed
3444 if (!chip->can_sleep && chip->get_direction) {
3445 int dir = gpiod_get_direction(desc);
3448 chip_err(chip, "%s: cannot get GPIO direction\n",
3454 if (test_bit(FLAG_IS_OUT, &desc->flags)) {
3456 "%s: tried to flag a GPIO set as output for IRQ\n",
3461 set_bit(FLAG_USED_AS_IRQ, &desc->flags);
3462 set_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
3465 * If the consumer has not set up a label (such as when the
3466 * IRQ is referenced from .to_irq()) we set up a label here
3467 * so it is clear this is used as an interrupt.
3470 desc_set_label(desc, "interrupt");
3474 EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq);
3477 * gpiochip_unlock_as_irq() - unlock a GPIO used as IRQ
3478 * @chip: the chip the GPIO to lock belongs to
3479 * @offset: the offset of the GPIO to lock as IRQ
3481 * This is used directly by GPIO drivers that want to indicate
3482 * that a certain GPIO is no longer used exclusively for IRQ.
3484 void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
3486 struct gpio_desc *desc;
3488 desc = gpiochip_get_desc(chip, offset);
3492 clear_bit(FLAG_USED_AS_IRQ, &desc->flags);
3493 clear_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
3495 /* If we only had this marking, erase it */
3496 if (desc->label && !strcmp(desc->label, "interrupt"))
3497 desc_set_label(desc, NULL);
3499 EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq);
3501 void gpiochip_disable_irq(struct gpio_chip *chip, unsigned int offset)
3503 struct gpio_desc *desc = gpiochip_get_desc(chip, offset);
3505 if (!IS_ERR(desc) &&
3506 !WARN_ON(!test_bit(FLAG_USED_AS_IRQ, &desc->flags)))
3507 clear_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
3509 EXPORT_SYMBOL_GPL(gpiochip_disable_irq);
3511 void gpiochip_enable_irq(struct gpio_chip *chip, unsigned int offset)
3513 struct gpio_desc *desc = gpiochip_get_desc(chip, offset);
3515 if (!IS_ERR(desc) &&
3516 !WARN_ON(!test_bit(FLAG_USED_AS_IRQ, &desc->flags))) {
3517 WARN_ON(test_bit(FLAG_IS_OUT, &desc->flags));
3518 set_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
3521 EXPORT_SYMBOL_GPL(gpiochip_enable_irq);
3523 bool gpiochip_line_is_irq(struct gpio_chip *chip, unsigned int offset)
3525 if (offset >= chip->ngpio)
3528 return test_bit(FLAG_USED_AS_IRQ, &chip->gpiodev->descs[offset].flags);
3530 EXPORT_SYMBOL_GPL(gpiochip_line_is_irq);
3532 int gpiochip_reqres_irq(struct gpio_chip *chip, unsigned int offset)
3536 if (!try_module_get(chip->gpiodev->owner))
3539 ret = gpiochip_lock_as_irq(chip, offset);
3541 chip_err(chip, "unable to lock HW IRQ %u for IRQ\n", offset);
3542 module_put(chip->gpiodev->owner);
3547 EXPORT_SYMBOL_GPL(gpiochip_reqres_irq);
3549 void gpiochip_relres_irq(struct gpio_chip *chip, unsigned int offset)
3551 gpiochip_unlock_as_irq(chip, offset);
3552 module_put(chip->gpiodev->owner);
3554 EXPORT_SYMBOL_GPL(gpiochip_relres_irq);
3556 bool gpiochip_line_is_open_drain(struct gpio_chip *chip, unsigned int offset)
3558 if (offset >= chip->ngpio)
3561 return test_bit(FLAG_OPEN_DRAIN, &chip->gpiodev->descs[offset].flags);
3563 EXPORT_SYMBOL_GPL(gpiochip_line_is_open_drain);
3565 bool gpiochip_line_is_open_source(struct gpio_chip *chip, unsigned int offset)
3567 if (offset >= chip->ngpio)
3570 return test_bit(FLAG_OPEN_SOURCE, &chip->gpiodev->descs[offset].flags);
3572 EXPORT_SYMBOL_GPL(gpiochip_line_is_open_source);
3574 bool gpiochip_line_is_persistent(struct gpio_chip *chip, unsigned int offset)
3576 if (offset >= chip->ngpio)
3579 return !test_bit(FLAG_TRANSITORY, &chip->gpiodev->descs[offset].flags);
3581 EXPORT_SYMBOL_GPL(gpiochip_line_is_persistent);
3584 * gpiod_get_raw_value_cansleep() - return a gpio's raw value
3585 * @desc: gpio whose value will be returned
3587 * Return the GPIO's raw value, i.e. the value of the physical line disregarding
3588 * its ACTIVE_LOW status, or negative errno on failure.
3590 * This function is to be called from contexts that can sleep.
3592 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
3594 might_sleep_if(extra_checks);
3595 VALIDATE_DESC(desc);
3596 return gpiod_get_raw_value_commit(desc);
3598 EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
3601 * gpiod_get_value_cansleep() - return a gpio's value
3602 * @desc: gpio whose value will be returned
3604 * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
3605 * account, or negative errno on failure.
3607 * This function is to be called from contexts that can sleep.
3609 int gpiod_get_value_cansleep(const struct gpio_desc *desc)
3613 might_sleep_if(extra_checks);
3614 VALIDATE_DESC(desc);
3615 value = gpiod_get_raw_value_commit(desc);
3619 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
3624 EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
3627 * gpiod_get_raw_array_value_cansleep() - read raw values from an array of GPIOs
3628 * @array_size: number of elements in the descriptor array / value bitmap
3629 * @desc_array: array of GPIO descriptors whose values will be read
3630 * @array_info: information on applicability of fast bitmap processing path
3631 * @value_bitmap: bitmap to store the read values
3633 * Read the raw values of the GPIOs, i.e. the values of the physical lines
3634 * without regard for their ACTIVE_LOW status. Return 0 in case of success,
3635 * else an error code.
3637 * This function is to be called from contexts that can sleep.
3639 int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
3640 struct gpio_desc **desc_array,
3641 struct gpio_array *array_info,
3642 unsigned long *value_bitmap)
3644 might_sleep_if(extra_checks);
3647 return gpiod_get_array_value_complex(true, true, array_size,
3648 desc_array, array_info,
3651 EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value_cansleep);
3654 * gpiod_get_array_value_cansleep() - read values from an array of GPIOs
3655 * @array_size: number of elements in the descriptor array / value bitmap
3656 * @desc_array: array of GPIO descriptors whose values will be read
3657 * @array_info: information on applicability of fast bitmap processing path
3658 * @value_bitmap: bitmap to store the read values
3660 * Read the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
3661 * into account. Return 0 in case of success, else an error code.
3663 * This function is to be called from contexts that can sleep.
3665 int gpiod_get_array_value_cansleep(unsigned int array_size,
3666 struct gpio_desc **desc_array,
3667 struct gpio_array *array_info,
3668 unsigned long *value_bitmap)
3670 might_sleep_if(extra_checks);
3673 return gpiod_get_array_value_complex(false, true, array_size,
3674 desc_array, array_info,
3677 EXPORT_SYMBOL_GPL(gpiod_get_array_value_cansleep);
3680 * gpiod_set_raw_value_cansleep() - assign a gpio's raw value
3681 * @desc: gpio whose value will be assigned
3682 * @value: value to assign
3684 * Set the raw value of the GPIO, i.e. the value of its physical line without
3685 * regard for its ACTIVE_LOW status.
3687 * This function is to be called from contexts that can sleep.
3689 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value)
3691 might_sleep_if(extra_checks);
3692 VALIDATE_DESC_VOID(desc);
3693 gpiod_set_raw_value_commit(desc, value);
3695 EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
3698 * gpiod_set_value_cansleep() - assign a gpio's value
3699 * @desc: gpio whose value will be assigned
3700 * @value: value to assign
3702 * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
3705 * This function is to be called from contexts that can sleep.
3707 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
3709 might_sleep_if(extra_checks);
3710 VALIDATE_DESC_VOID(desc);
3711 gpiod_set_value_nocheck(desc, value);
3713 EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
3716 * gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs
3717 * @array_size: number of elements in the descriptor array / value bitmap
3718 * @desc_array: array of GPIO descriptors whose values will be assigned
3719 * @array_info: information on applicability of fast bitmap processing path
3720 * @value_bitmap: bitmap of values to assign
3722 * Set the raw values of the GPIOs, i.e. the values of the physical lines
3723 * without regard for their ACTIVE_LOW status.
3725 * This function is to be called from contexts that can sleep.
3727 int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
3728 struct gpio_desc **desc_array,
3729 struct gpio_array *array_info,
3730 unsigned long *value_bitmap)
3732 might_sleep_if(extra_checks);
3735 return gpiod_set_array_value_complex(true, true, array_size, desc_array,
3736 array_info, value_bitmap);
3738 EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep);
3741 * gpiod_add_lookup_tables() - register GPIO device consumers
3742 * @tables: list of tables of consumers to register
3743 * @n: number of tables in the list
3745 void gpiod_add_lookup_tables(struct gpiod_lookup_table **tables, size_t n)
3749 mutex_lock(&gpio_lookup_lock);
3751 for (i = 0; i < n; i++)
3752 list_add_tail(&tables[i]->list, &gpio_lookup_list);
3754 mutex_unlock(&gpio_lookup_lock);
3758 * gpiod_set_array_value_cansleep() - assign values to an array of GPIOs
3759 * @array_size: number of elements in the descriptor array / value bitmap
3760 * @desc_array: array of GPIO descriptors whose values will be assigned
3761 * @array_info: information on applicability of fast bitmap processing path
3762 * @value_bitmap: bitmap of values to assign
3764 * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
3767 * This function is to be called from contexts that can sleep.
3769 void gpiod_set_array_value_cansleep(unsigned int array_size,
3770 struct gpio_desc **desc_array,
3771 struct gpio_array *array_info,
3772 unsigned long *value_bitmap)
3774 might_sleep_if(extra_checks);
3777 gpiod_set_array_value_complex(false, true, array_size, desc_array,
3778 array_info, value_bitmap);
3780 EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep);
3783 * gpiod_add_lookup_table() - register GPIO device consumers
3784 * @table: table of consumers to register
3786 void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
3788 mutex_lock(&gpio_lookup_lock);
3790 list_add_tail(&table->list, &gpio_lookup_list);
3792 mutex_unlock(&gpio_lookup_lock);
3794 EXPORT_SYMBOL_GPL(gpiod_add_lookup_table);
3797 * gpiod_remove_lookup_table() - unregister GPIO device consumers
3798 * @table: table of consumers to unregister
3800 void gpiod_remove_lookup_table(struct gpiod_lookup_table *table)
3802 mutex_lock(&gpio_lookup_lock);
3804 list_del(&table->list);
3806 mutex_unlock(&gpio_lookup_lock);
3808 EXPORT_SYMBOL_GPL(gpiod_remove_lookup_table);
3811 * gpiod_add_hogs() - register a set of GPIO hogs from machine code
3812 * @hogs: table of gpio hog entries with a zeroed sentinel at the end
3814 void gpiod_add_hogs(struct gpiod_hog *hogs)
3816 struct gpio_chip *chip;
3817 struct gpiod_hog *hog;
3819 mutex_lock(&gpio_machine_hogs_mutex);
3821 for (hog = &hogs[0]; hog->chip_label; hog++) {
3822 list_add_tail(&hog->list, &gpio_machine_hogs);
3825 * The chip may have been registered earlier, so check if it
3826 * exists and, if so, try to hog the line now.
3828 chip = find_chip_by_name(hog->chip_label);
3830 gpiochip_machine_hog(chip, hog);
3833 mutex_unlock(&gpio_machine_hogs_mutex);
3835 EXPORT_SYMBOL_GPL(gpiod_add_hogs);
3837 static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
3839 const char *dev_id = dev ? dev_name(dev) : NULL;
3840 struct gpiod_lookup_table *table;
3842 mutex_lock(&gpio_lookup_lock);
3844 list_for_each_entry(table, &gpio_lookup_list, list) {
3845 if (table->dev_id && dev_id) {
3847 * Valid strings on both ends, must be identical to have
3850 if (!strcmp(table->dev_id, dev_id))
3854 * One of the pointers is NULL, so both must be to have
3857 if (dev_id == table->dev_id)
3864 mutex_unlock(&gpio_lookup_lock);
3868 static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
3870 enum gpio_lookup_flags *flags)
3872 struct gpio_desc *desc = ERR_PTR(-ENOENT);
3873 struct gpiod_lookup_table *table;
3874 struct gpiod_lookup *p;
3876 table = gpiod_find_lookup_table(dev);
3880 for (p = &table->table[0]; p->chip_label; p++) {
3881 struct gpio_chip *chip;
3883 /* idx must always match exactly */
3887 /* If the lookup entry has a con_id, require exact match */
3888 if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
3891 chip = find_chip_by_name(p->chip_label);
3895 * As the lookup table indicates a chip with
3896 * p->chip_label should exist, assume it may
3897 * still appear later and let the interested
3898 * consumer be probed again or let the Deferred
3899 * Probe infrastructure handle the error.
3901 dev_warn(dev, "cannot find GPIO chip %s, deferring\n",
3903 return ERR_PTR(-EPROBE_DEFER);
3906 if (chip->ngpio <= p->chip_hwnum) {
3908 "requested GPIO %d is out of range [0..%d] for chip %s\n",
3909 idx, chip->ngpio, chip->label);
3910 return ERR_PTR(-EINVAL);
3913 desc = gpiochip_get_desc(chip, p->chip_hwnum);
3922 static int dt_gpio_count(struct device *dev, const char *con_id)
3928 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
3930 snprintf(propname, sizeof(propname), "%s-%s",
3931 con_id, gpio_suffixes[i]);
3933 snprintf(propname, sizeof(propname), "%s",
3936 ret = of_gpio_named_count(dev->of_node, propname);
3940 return ret ? ret : -ENOENT;
3943 static int platform_gpio_count(struct device *dev, const char *con_id)
3945 struct gpiod_lookup_table *table;
3946 struct gpiod_lookup *p;
3947 unsigned int count = 0;
3949 table = gpiod_find_lookup_table(dev);
3953 for (p = &table->table[0]; p->chip_label; p++) {
3954 if ((con_id && p->con_id && !strcmp(con_id, p->con_id)) ||
3955 (!con_id && !p->con_id))
3965 * gpiod_count - return the number of GPIOs associated with a device / function
3966 * or -ENOENT if no GPIO has been assigned to the requested function
3967 * @dev: GPIO consumer, can be NULL for system-global GPIOs
3968 * @con_id: function within the GPIO consumer
3970 int gpiod_count(struct device *dev, const char *con_id)
3972 int count = -ENOENT;
3974 if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node)
3975 count = dt_gpio_count(dev, con_id);
3976 else if (IS_ENABLED(CONFIG_ACPI) && dev && ACPI_HANDLE(dev))
3977 count = acpi_gpio_count(dev, con_id);
3980 count = platform_gpio_count(dev, con_id);
3984 EXPORT_SYMBOL_GPL(gpiod_count);
3987 * gpiod_get - obtain a GPIO for a given GPIO function
3988 * @dev: GPIO consumer, can be NULL for system-global GPIOs
3989 * @con_id: function within the GPIO consumer
3990 * @flags: optional GPIO initialization flags
3992 * Return the GPIO descriptor corresponding to the function con_id of device
3993 * dev, -ENOENT if no GPIO has been assigned to the requested function, or
3994 * another IS_ERR() code if an error occurred while trying to acquire the GPIO.
3996 struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id,
3997 enum gpiod_flags flags)
3999 return gpiod_get_index(dev, con_id, 0, flags);
4001 EXPORT_SYMBOL_GPL(gpiod_get);
4004 * gpiod_get_optional - obtain an optional GPIO for a given GPIO function
4005 * @dev: GPIO consumer, can be NULL for system-global GPIOs
4006 * @con_id: function within the GPIO consumer
4007 * @flags: optional GPIO initialization flags
4009 * This is equivalent to gpiod_get(), except that when no GPIO was assigned to
4010 * the requested function it will return NULL. This is convenient for drivers
4011 * that need to handle optional GPIOs.
4013 struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
4015 enum gpiod_flags flags)
4017 return gpiod_get_index_optional(dev, con_id, 0, flags);
4019 EXPORT_SYMBOL_GPL(gpiod_get_optional);
4023 * gpiod_configure_flags - helper function to configure a given GPIO
4024 * @desc: gpio whose value will be assigned
4025 * @con_id: function within the GPIO consumer
4026 * @lflags: gpio_lookup_flags - returned from of_find_gpio() or
4028 * @dflags: gpiod_flags - optional GPIO initialization flags
4030 * Return 0 on success, -ENOENT if no GPIO has been assigned to the
4031 * requested function and/or index, or another IS_ERR() code if an error
4032 * occurred while trying to acquire the GPIO.
4034 int gpiod_configure_flags(struct gpio_desc *desc, const char *con_id,
4035 unsigned long lflags, enum gpiod_flags dflags)
4039 if (lflags & GPIO_ACTIVE_LOW)
4040 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
4042 if (lflags & GPIO_OPEN_DRAIN)
4043 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
4044 else if (dflags & GPIOD_FLAGS_BIT_OPEN_DRAIN) {
4046 * This enforces open drain mode from the consumer side.
4047 * This is necessary for some busses like I2C, but the lookup
4048 * should *REALLY* have specified them as open drain in the
4049 * first place, so print a little warning here.
4051 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
4053 "enforced open drain please flag it properly in DT/ACPI DSDT/board file\n");
4056 if (lflags & GPIO_OPEN_SOURCE)
4057 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
4059 status = gpiod_set_transitory(desc, (lflags & GPIO_TRANSITORY));
4063 /* No particular flag request, return here... */
4064 if (!(dflags & GPIOD_FLAGS_BIT_DIR_SET)) {
4065 pr_debug("no flags found for %s\n", con_id);
4070 if (dflags & GPIOD_FLAGS_BIT_DIR_OUT)
4071 status = gpiod_direction_output(desc,
4072 !!(dflags & GPIOD_FLAGS_BIT_DIR_VAL));
4074 status = gpiod_direction_input(desc);
4080 * gpiod_get_index - obtain a GPIO from a multi-index GPIO function
4081 * @dev: GPIO consumer, can be NULL for system-global GPIOs
4082 * @con_id: function within the GPIO consumer
4083 * @idx: index of the GPIO to obtain in the consumer
4084 * @flags: optional GPIO initialization flags
4086 * This variant of gpiod_get() allows to access GPIOs other than the first
4087 * defined one for functions that define several GPIOs.
4089 * Return a valid GPIO descriptor, -ENOENT if no GPIO has been assigned to the
4090 * requested function and/or index, or another IS_ERR() code if an error
4091 * occurred while trying to acquire the GPIO.
4093 struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
4096 enum gpiod_flags flags)
4098 struct gpio_desc *desc = NULL;
4100 enum gpio_lookup_flags lookupflags = 0;
4101 /* Maybe we have a device name, maybe not */
4102 const char *devname = dev ? dev_name(dev) : "?";
4104 dev_dbg(dev, "GPIO lookup for consumer %s\n", con_id);
4107 /* Using device tree? */
4108 if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
4109 dev_dbg(dev, "using device tree for GPIO lookup\n");
4110 desc = of_find_gpio(dev, con_id, idx, &lookupflags);
4111 } else if (ACPI_COMPANION(dev)) {
4112 dev_dbg(dev, "using ACPI for GPIO lookup\n");
4113 desc = acpi_find_gpio(dev, con_id, idx, &flags, &lookupflags);
4118 * Either we are not using DT or ACPI, or their lookup did not return
4119 * a result. In that case, use platform lookup as a fallback.
4121 if (!desc || desc == ERR_PTR(-ENOENT)) {
4122 dev_dbg(dev, "using lookup tables for GPIO lookup\n");
4123 desc = gpiod_find(dev, con_id, idx, &lookupflags);
4127 dev_dbg(dev, "No GPIO consumer %s found\n", con_id);
4132 * If a connection label was passed use that, else attempt to use
4133 * the device name as label
4135 status = gpiod_request(desc, con_id ? con_id : devname);
4137 return ERR_PTR(status);
4139 status = gpiod_configure_flags(desc, con_id, lookupflags, flags);
4141 dev_dbg(dev, "setup of GPIO %s failed\n", con_id);
4143 return ERR_PTR(status);
4148 EXPORT_SYMBOL_GPL(gpiod_get_index);
4151 * gpiod_get_from_of_node() - obtain a GPIO from an OF node
4152 * @node: handle of the OF node
4153 * @propname: name of the DT property representing the GPIO
4154 * @index: index of the GPIO to obtain for the consumer
4155 * @dflags: GPIO initialization flags
4156 * @label: label to attach to the requested GPIO
4159 * On successful request the GPIO pin is configured in accordance with
4160 * provided @dflags. If the node does not have the requested GPIO
4161 * property, NULL is returned.
4163 * In case of error an ERR_PTR() is returned.
4165 struct gpio_desc *gpiod_get_from_of_node(struct device_node *node,
4166 const char *propname, int index,
4167 enum gpiod_flags dflags,
4170 struct gpio_desc *desc;
4171 unsigned long lflags = 0;
4172 enum of_gpio_flags flags;
4173 bool active_low = false;
4174 bool single_ended = false;
4175 bool open_drain = false;
4176 bool transitory = false;
4179 desc = of_get_named_gpiod_flags(node, propname,
4182 if (!desc || IS_ERR(desc)) {
4183 /* If it is not there, just return NULL */
4184 if (PTR_ERR(desc) == -ENOENT)
4189 active_low = flags & OF_GPIO_ACTIVE_LOW;
4190 single_ended = flags & OF_GPIO_SINGLE_ENDED;
4191 open_drain = flags & OF_GPIO_OPEN_DRAIN;
4192 transitory = flags & OF_GPIO_TRANSITORY;
4194 ret = gpiod_request(desc, label);
4196 return ERR_PTR(ret);
4199 lflags |= GPIO_ACTIVE_LOW;
4203 lflags |= GPIO_OPEN_DRAIN;
4205 lflags |= GPIO_OPEN_SOURCE;
4209 lflags |= GPIO_TRANSITORY;
4211 ret = gpiod_configure_flags(desc, propname, lflags, dflags);
4214 return ERR_PTR(ret);
4219 EXPORT_SYMBOL(gpiod_get_from_of_node);
4222 * fwnode_get_named_gpiod - obtain a GPIO from firmware node
4223 * @fwnode: handle of the firmware node
4224 * @propname: name of the firmware property representing the GPIO
4225 * @index: index of the GPIO to obtain for the consumer
4226 * @dflags: GPIO initialization flags
4227 * @label: label to attach to the requested GPIO
4229 * This function can be used for drivers that get their configuration
4230 * from opaque firmware.
4232 * The function properly finds the corresponding GPIO using whatever is the
4233 * underlying firmware interface and then makes sure that the GPIO
4234 * descriptor is requested before it is returned to the caller.
4237 * On successful request the GPIO pin is configured in accordance with
4240 * In case of error an ERR_PTR() is returned.
4242 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
4243 const char *propname, int index,
4244 enum gpiod_flags dflags,
4247 struct gpio_desc *desc = ERR_PTR(-ENODEV);
4248 unsigned long lflags = 0;
4252 return ERR_PTR(-EINVAL);
4254 if (is_of_node(fwnode)) {
4255 desc = gpiod_get_from_of_node(to_of_node(fwnode),
4260 } else if (is_acpi_node(fwnode)) {
4261 struct acpi_gpio_info info;
4263 desc = acpi_node_get_gpiod(fwnode, propname, index, &info);
4267 acpi_gpio_update_gpiod_flags(&dflags, &info);
4269 if (info.polarity == GPIO_ACTIVE_LOW)
4270 lflags |= GPIO_ACTIVE_LOW;
4273 /* Currently only ACPI takes this path */
4274 ret = gpiod_request(desc, label);
4276 return ERR_PTR(ret);
4278 ret = gpiod_configure_flags(desc, propname, lflags, dflags);
4281 return ERR_PTR(ret);
4286 EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod);
4289 * gpiod_get_index_optional - obtain an optional GPIO from a multi-index GPIO
4291 * @dev: GPIO consumer, can be NULL for system-global GPIOs
4292 * @con_id: function within the GPIO consumer
4293 * @index: index of the GPIO to obtain in the consumer
4294 * @flags: optional GPIO initialization flags
4296 * This is equivalent to gpiod_get_index(), except that when no GPIO with the
4297 * specified index was assigned to the requested function it will return NULL.
4298 * This is convenient for drivers that need to handle optional GPIOs.
4300 struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
4303 enum gpiod_flags flags)
4305 struct gpio_desc *desc;
4307 desc = gpiod_get_index(dev, con_id, index, flags);
4309 if (PTR_ERR(desc) == -ENOENT)
4315 EXPORT_SYMBOL_GPL(gpiod_get_index_optional);
4318 * gpiod_hog - Hog the specified GPIO desc given the provided flags
4319 * @desc: gpio whose value will be assigned
4320 * @name: gpio line name
4321 * @lflags: gpio_lookup_flags - returned from of_find_gpio() or
4323 * @dflags: gpiod_flags - optional GPIO initialization flags
4325 int gpiod_hog(struct gpio_desc *desc, const char *name,
4326 unsigned long lflags, enum gpiod_flags dflags)
4328 struct gpio_chip *chip;
4329 struct gpio_desc *local_desc;
4333 chip = gpiod_to_chip(desc);
4334 hwnum = gpio_chip_hwgpio(desc);
4336 local_desc = gpiochip_request_own_desc(chip, hwnum, name);
4337 if (IS_ERR(local_desc)) {
4338 status = PTR_ERR(local_desc);
4339 pr_err("requesting hog GPIO %s (chip %s, offset %d) failed, %d\n",
4340 name, chip->label, hwnum, status);
4344 status = gpiod_configure_flags(desc, name, lflags, dflags);
4346 pr_err("setup of hog GPIO %s (chip %s, offset %d) failed, %d\n",
4347 name, chip->label, hwnum, status);
4348 gpiochip_free_own_desc(desc);
4352 /* Mark GPIO as hogged so it can be identified and removed later */
4353 set_bit(FLAG_IS_HOGGED, &desc->flags);
4355 pr_info("GPIO line %d (%s) hogged as %s%s\n",
4356 desc_to_gpio(desc), name,
4357 (dflags&GPIOD_FLAGS_BIT_DIR_OUT) ? "output" : "input",
4358 (dflags&GPIOD_FLAGS_BIT_DIR_OUT) ?
4359 (dflags&GPIOD_FLAGS_BIT_DIR_VAL) ? "/high" : "/low":"");
4365 * gpiochip_free_hogs - Scan gpio-controller chip and release GPIO hog
4366 * @chip: gpio chip to act on
4368 * This is only used by of_gpiochip_remove to free hogged gpios
4370 static void gpiochip_free_hogs(struct gpio_chip *chip)
4374 for (id = 0; id < chip->ngpio; id++) {
4375 if (test_bit(FLAG_IS_HOGGED, &chip->gpiodev->descs[id].flags))
4376 gpiochip_free_own_desc(&chip->gpiodev->descs[id]);
4381 * gpiod_get_array - obtain multiple GPIOs from a multi-index GPIO function
4382 * @dev: GPIO consumer, can be NULL for system-global GPIOs
4383 * @con_id: function within the GPIO consumer
4384 * @flags: optional GPIO initialization flags
4386 * This function acquires all the GPIOs defined under a given function.
4388 * Return a struct gpio_descs containing an array of descriptors, -ENOENT if
4389 * no GPIO has been assigned to the requested function, or another IS_ERR()
4390 * code if an error occurred while trying to acquire the GPIOs.
4392 struct gpio_descs *__must_check gpiod_get_array(struct device *dev,
4394 enum gpiod_flags flags)
4396 struct gpio_desc *desc;
4397 struct gpio_descs *descs;
4398 struct gpio_array *array_info = NULL;
4399 struct gpio_chip *chip;
4400 int count, bitmap_size;
4402 count = gpiod_count(dev, con_id);
4404 return ERR_PTR(count);
4406 descs = kzalloc(struct_size(descs, desc, count), GFP_KERNEL);
4408 return ERR_PTR(-ENOMEM);
4410 for (descs->ndescs = 0; descs->ndescs < count; ) {
4411 desc = gpiod_get_index(dev, con_id, descs->ndescs, flags);
4413 gpiod_put_array(descs);
4414 return ERR_CAST(desc);
4417 descs->desc[descs->ndescs] = desc;
4419 chip = gpiod_to_chip(desc);
4421 * If pin hardware number of array member 0 is also 0, select
4422 * its chip as a candidate for fast bitmap processing path.
4424 if (descs->ndescs == 0 && gpio_chip_hwgpio(desc) == 0) {
4425 struct gpio_descs *array;
4427 bitmap_size = BITS_TO_LONGS(chip->ngpio > count ?
4428 chip->ngpio : count);
4430 array = kzalloc(struct_size(descs, desc, count) +
4431 struct_size(array_info, invert_mask,
4432 3 * bitmap_size), GFP_KERNEL);
4434 gpiod_put_array(descs);
4435 return ERR_PTR(-ENOMEM);
4438 memcpy(array, descs,
4439 struct_size(descs, desc, descs->ndescs + 1));
4443 array_info = (void *)(descs->desc + count);
4444 array_info->get_mask = array_info->invert_mask +
4446 array_info->set_mask = array_info->get_mask +
4449 array_info->desc = descs->desc;
4450 array_info->size = count;
4451 array_info->chip = chip;
4452 bitmap_set(array_info->get_mask, descs->ndescs,
4453 count - descs->ndescs);
4454 bitmap_set(array_info->set_mask, descs->ndescs,
4455 count - descs->ndescs);
4456 descs->info = array_info;
4458 /* Unmark array members which don't belong to the 'fast' chip */
4459 if (array_info && array_info->chip != chip) {
4460 __clear_bit(descs->ndescs, array_info->get_mask);
4461 __clear_bit(descs->ndescs, array_info->set_mask);
4464 * Detect array members which belong to the 'fast' chip
4465 * but their pins are not in hardware order.
4467 else if (array_info &&
4468 gpio_chip_hwgpio(desc) != descs->ndescs) {
4470 * Don't use fast path if all array members processed so
4471 * far belong to the same chip as this one but its pin
4472 * hardware number is different from its array index.
4474 if (bitmap_full(array_info->get_mask, descs->ndescs)) {
4477 __clear_bit(descs->ndescs,
4478 array_info->get_mask);
4479 __clear_bit(descs->ndescs,
4480 array_info->set_mask);
4482 } else if (array_info) {
4483 /* Exclude open drain or open source from fast output */
4484 if (gpiochip_line_is_open_drain(chip, descs->ndescs) ||
4485 gpiochip_line_is_open_source(chip, descs->ndescs))
4486 __clear_bit(descs->ndescs,
4487 array_info->set_mask);
4488 /* Identify 'fast' pins which require invertion */
4489 if (gpiod_is_active_low(desc))
4490 __set_bit(descs->ndescs,
4491 array_info->invert_mask);
4498 "GPIO array info: chip=%s, size=%d, get_mask=%lx, set_mask=%lx, invert_mask=%lx\n",
4499 array_info->chip->label, array_info->size,
4500 *array_info->get_mask, *array_info->set_mask,
4501 *array_info->invert_mask);
4504 EXPORT_SYMBOL_GPL(gpiod_get_array);
4507 * gpiod_get_array_optional - obtain multiple GPIOs from a multi-index GPIO
4509 * @dev: GPIO consumer, can be NULL for system-global GPIOs
4510 * @con_id: function within the GPIO consumer
4511 * @flags: optional GPIO initialization flags
4513 * This is equivalent to gpiod_get_array(), except that when no GPIO was
4514 * assigned to the requested function it will return NULL.
4516 struct gpio_descs *__must_check gpiod_get_array_optional(struct device *dev,
4518 enum gpiod_flags flags)
4520 struct gpio_descs *descs;
4522 descs = gpiod_get_array(dev, con_id, flags);
4523 if (IS_ERR(descs) && (PTR_ERR(descs) == -ENOENT))
4528 EXPORT_SYMBOL_GPL(gpiod_get_array_optional);
4531 * gpiod_put - dispose of a GPIO descriptor
4532 * @desc: GPIO descriptor to dispose of
4534 * No descriptor can be used after gpiod_put() has been called on it.
4536 void gpiod_put(struct gpio_desc *desc)
4540 EXPORT_SYMBOL_GPL(gpiod_put);
4543 * gpiod_put_array - dispose of multiple GPIO descriptors
4544 * @descs: struct gpio_descs containing an array of descriptors
4546 void gpiod_put_array(struct gpio_descs *descs)
4550 for (i = 0; i < descs->ndescs; i++)
4551 gpiod_put(descs->desc[i]);
4555 EXPORT_SYMBOL_GPL(gpiod_put_array);
4557 static int __init gpiolib_dev_init(void)
4561 /* Register GPIO sysfs bus */
4562 ret = bus_register(&gpio_bus_type);
4564 pr_err("gpiolib: could not register GPIO bus type\n");
4568 ret = alloc_chrdev_region(&gpio_devt, 0, GPIO_DEV_MAX, "gpiochip");
4570 pr_err("gpiolib: failed to allocate char dev region\n");
4571 bus_unregister(&gpio_bus_type);
4573 gpiolib_initialized = true;
4574 gpiochip_setup_devs();
4578 core_initcall(gpiolib_dev_init);
4580 #ifdef CONFIG_DEBUG_FS
4582 static void gpiolib_dbg_show(struct seq_file *s, struct gpio_device *gdev)
4585 struct gpio_chip *chip = gdev->chip;
4586 unsigned gpio = gdev->base;
4587 struct gpio_desc *gdesc = &gdev->descs[0];
4591 for (i = 0; i < gdev->ngpio; i++, gpio++, gdesc++) {
4592 if (!test_bit(FLAG_REQUESTED, &gdesc->flags)) {
4594 seq_printf(s, " gpio-%-3d (%-20.20s)\n",
4600 gpiod_get_direction(gdesc);
4601 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
4602 is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
4603 seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s",
4604 gpio, gdesc->name ? gdesc->name : "", gdesc->label,
4605 is_out ? "out" : "in ",
4606 chip->get ? (chip->get(chip, i) ? "hi" : "lo") : "? ",
4607 is_irq ? "IRQ" : " ");
4608 seq_printf(s, "\n");
4612 static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
4614 unsigned long flags;
4615 struct gpio_device *gdev = NULL;
4616 loff_t index = *pos;
4620 spin_lock_irqsave(&gpio_lock, flags);
4621 list_for_each_entry(gdev, &gpio_devices, list)
4623 spin_unlock_irqrestore(&gpio_lock, flags);
4626 spin_unlock_irqrestore(&gpio_lock, flags);
4631 static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
4633 unsigned long flags;
4634 struct gpio_device *gdev = v;
4637 spin_lock_irqsave(&gpio_lock, flags);
4638 if (list_is_last(&gdev->list, &gpio_devices))
4641 ret = list_entry(gdev->list.next, struct gpio_device, list);
4642 spin_unlock_irqrestore(&gpio_lock, flags);
4650 static void gpiolib_seq_stop(struct seq_file *s, void *v)
4654 static int gpiolib_seq_show(struct seq_file *s, void *v)
4656 struct gpio_device *gdev = v;
4657 struct gpio_chip *chip = gdev->chip;
4658 struct device *parent;
4661 seq_printf(s, "%s%s: (dangling chip)", (char *)s->private,
4662 dev_name(&gdev->dev));
4666 seq_printf(s, "%s%s: GPIOs %d-%d", (char *)s->private,
4667 dev_name(&gdev->dev),
4668 gdev->base, gdev->base + gdev->ngpio - 1);
4669 parent = chip->parent;
4671 seq_printf(s, ", parent: %s/%s",
4672 parent->bus ? parent->bus->name : "no-bus",
4675 seq_printf(s, ", %s", chip->label);
4676 if (chip->can_sleep)
4677 seq_printf(s, ", can sleep");
4678 seq_printf(s, ":\n");
4681 chip->dbg_show(s, chip);
4683 gpiolib_dbg_show(s, gdev);
4688 static const struct seq_operations gpiolib_seq_ops = {
4689 .start = gpiolib_seq_start,
4690 .next = gpiolib_seq_next,
4691 .stop = gpiolib_seq_stop,
4692 .show = gpiolib_seq_show,
4695 static int gpiolib_open(struct inode *inode, struct file *file)
4697 return seq_open(file, &gpiolib_seq_ops);
4700 static const struct file_operations gpiolib_operations = {
4701 .owner = THIS_MODULE,
4702 .open = gpiolib_open,
4704 .llseek = seq_lseek,
4705 .release = seq_release,
4708 static int __init gpiolib_debugfs_init(void)
4710 /* /sys/kernel/debug/gpio */
4711 (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
4712 NULL, NULL, &gpiolib_operations);
4715 subsys_initcall(gpiolib_debugfs_init);
4717 #endif /* DEBUG_FS */