Merge tag 'pinctrl-v4.15-1' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw...
[sfrench/cifs-2.6.git] / drivers / gpio / gpiolib.c
1 #include <linux/bitmap.h>
2 #include <linux/kernel.h>
3 #include <linux/module.h>
4 #include <linux/interrupt.h>
5 #include <linux/irq.h>
6 #include <linux/spinlock.h>
7 #include <linux/list.h>
8 #include <linux/device.h>
9 #include <linux/err.h>
10 #include <linux/debugfs.h>
11 #include <linux/seq_file.h>
12 #include <linux/gpio.h>
13 #include <linux/of_gpio.h>
14 #include <linux/idr.h>
15 #include <linux/slab.h>
16 #include <linux/acpi.h>
17 #include <linux/gpio/driver.h>
18 #include <linux/gpio/machine.h>
19 #include <linux/pinctrl/consumer.h>
20 #include <linux/cdev.h>
21 #include <linux/fs.h>
22 #include <linux/uaccess.h>
23 #include <linux/compat.h>
24 #include <linux/anon_inodes.h>
25 #include <linux/file.h>
26 #include <linux/kfifo.h>
27 #include <linux/poll.h>
28 #include <linux/timekeeping.h>
29 #include <uapi/linux/gpio.h>
30
31 #include "gpiolib.h"
32
33 #define CREATE_TRACE_POINTS
34 #include <trace/events/gpio.h>
35
36 /* Implementation infrastructure for GPIO interfaces.
37  *
38  * The GPIO programming interface allows for inlining speed-critical
39  * get/set operations for common cases, so that access to SOC-integrated
40  * GPIOs can sometimes cost only an instruction or two per bit.
41  */
42
43
44 /* When debugging, extend minimal trust to callers and platform code.
45  * Also emit diagnostic messages that may help initial bringup, when
46  * board setup or driver bugs are most common.
47  *
48  * Otherwise, minimize overhead in what may be bitbanging codepaths.
49  */
50 #ifdef  DEBUG
51 #define extra_checks    1
52 #else
53 #define extra_checks    0
54 #endif
55
56 /* Device and char device-related information */
57 static DEFINE_IDA(gpio_ida);
58 static dev_t gpio_devt;
59 #define GPIO_DEV_MAX 256 /* 256 GPIO chip devices supported */
60 static struct bus_type gpio_bus_type = {
61         .name = "gpio",
62 };
63
64 /* gpio_lock prevents conflicts during gpio_desc[] table updates.
65  * While any GPIO is requested, its gpio_chip is not removable;
66  * each GPIO's "requested" flag serves as a lock and refcount.
67  */
68 DEFINE_SPINLOCK(gpio_lock);
69
70 static DEFINE_MUTEX(gpio_lookup_lock);
71 static LIST_HEAD(gpio_lookup_list);
72 LIST_HEAD(gpio_devices);
73
74 static void gpiochip_free_hogs(struct gpio_chip *chip);
75 static int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
76                                 struct lock_class_key *key);
77 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip);
78 static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip);
79 static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip);
80
81 static bool gpiolib_initialized;
82
83 static inline void desc_set_label(struct gpio_desc *d, const char *label)
84 {
85         d->label = label;
86 }
87
88 /**
89  * gpio_to_desc - Convert a GPIO number to its descriptor
90  * @gpio: global GPIO number
91  *
92  * Returns:
93  * The GPIO descriptor associated with the given GPIO, or %NULL if no GPIO
94  * with the given number exists in the system.
95  */
96 struct gpio_desc *gpio_to_desc(unsigned gpio)
97 {
98         struct gpio_device *gdev;
99         unsigned long flags;
100
101         spin_lock_irqsave(&gpio_lock, flags);
102
103         list_for_each_entry(gdev, &gpio_devices, list) {
104                 if (gdev->base <= gpio &&
105                     gdev->base + gdev->ngpio > gpio) {
106                         spin_unlock_irqrestore(&gpio_lock, flags);
107                         return &gdev->descs[gpio - gdev->base];
108                 }
109         }
110
111         spin_unlock_irqrestore(&gpio_lock, flags);
112
113         if (!gpio_is_valid(gpio))
114                 WARN(1, "invalid GPIO %d\n", gpio);
115
116         return NULL;
117 }
118 EXPORT_SYMBOL_GPL(gpio_to_desc);
119
120 /**
121  * gpiochip_get_desc - get the GPIO descriptor corresponding to the given
122  *                     hardware number for this chip
123  * @chip: GPIO chip
124  * @hwnum: hardware number of the GPIO for this chip
125  *
126  * Returns:
127  * A pointer to the GPIO descriptor or %ERR_PTR(-EINVAL) if no GPIO exists
128  * in the given chip for the specified hardware number.
129  */
130 struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip,
131                                     u16 hwnum)
132 {
133         struct gpio_device *gdev = chip->gpiodev;
134
135         if (hwnum >= gdev->ngpio)
136                 return ERR_PTR(-EINVAL);
137
138         return &gdev->descs[hwnum];
139 }
140
141 /**
142  * desc_to_gpio - convert a GPIO descriptor to the integer namespace
143  * @desc: GPIO descriptor
144  *
145  * This should disappear in the future but is needed since we still
146  * use GPIO numbers for error messages and sysfs nodes.
147  *
148  * Returns:
149  * The global GPIO number for the GPIO specified by its descriptor.
150  */
151 int desc_to_gpio(const struct gpio_desc *desc)
152 {
153         return desc->gdev->base + (desc - &desc->gdev->descs[0]);
154 }
155 EXPORT_SYMBOL_GPL(desc_to_gpio);
156
157
158 /**
159  * gpiod_to_chip - Return the GPIO chip to which a GPIO descriptor belongs
160  * @desc:       descriptor to return the chip of
161  */
162 struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc)
163 {
164         if (!desc || !desc->gdev || !desc->gdev->chip)
165                 return NULL;
166         return desc->gdev->chip;
167 }
168 EXPORT_SYMBOL_GPL(gpiod_to_chip);
169
170 /* dynamic allocation of GPIOs, e.g. on a hotplugged device */
171 static int gpiochip_find_base(int ngpio)
172 {
173         struct gpio_device *gdev;
174         int base = ARCH_NR_GPIOS - ngpio;
175
176         list_for_each_entry_reverse(gdev, &gpio_devices, list) {
177                 /* found a free space? */
178                 if (gdev->base + gdev->ngpio <= base)
179                         break;
180                 else
181                         /* nope, check the space right before the chip */
182                         base = gdev->base - ngpio;
183         }
184
185         if (gpio_is_valid(base)) {
186                 pr_debug("%s: found new base at %d\n", __func__, base);
187                 return base;
188         } else {
189                 pr_err("%s: cannot find free range\n", __func__);
190                 return -ENOSPC;
191         }
192 }
193
194 /**
195  * gpiod_get_direction - return the current direction of a GPIO
196  * @desc:       GPIO to get the direction of
197  *
198  * Return GPIOF_DIR_IN or GPIOF_DIR_OUT, or an error code in case of error.
199  *
200  * This function may sleep if gpiod_cansleep() is true.
201  */
202 int gpiod_get_direction(struct gpio_desc *desc)
203 {
204         struct gpio_chip        *chip;
205         unsigned                offset;
206         int                     status = -EINVAL;
207
208         chip = gpiod_to_chip(desc);
209         offset = gpio_chip_hwgpio(desc);
210
211         if (!chip->get_direction)
212                 return status;
213
214         status = chip->get_direction(chip, offset);
215         if (status > 0) {
216                 /* GPIOF_DIR_IN, or other positive */
217                 status = 1;
218                 clear_bit(FLAG_IS_OUT, &desc->flags);
219         }
220         if (status == 0) {
221                 /* GPIOF_DIR_OUT */
222                 set_bit(FLAG_IS_OUT, &desc->flags);
223         }
224         return status;
225 }
226 EXPORT_SYMBOL_GPL(gpiod_get_direction);
227
228 /*
229  * Add a new chip to the global chips list, keeping the list of chips sorted
230  * by range(means [base, base + ngpio - 1]) order.
231  *
232  * Return -EBUSY if the new chip overlaps with some other chip's integer
233  * space.
234  */
235 static int gpiodev_add_to_list(struct gpio_device *gdev)
236 {
237         struct gpio_device *prev, *next;
238
239         if (list_empty(&gpio_devices)) {
240                 /* initial entry in list */
241                 list_add_tail(&gdev->list, &gpio_devices);
242                 return 0;
243         }
244
245         next = list_entry(gpio_devices.next, struct gpio_device, list);
246         if (gdev->base + gdev->ngpio <= next->base) {
247                 /* add before first entry */
248                 list_add(&gdev->list, &gpio_devices);
249                 return 0;
250         }
251
252         prev = list_entry(gpio_devices.prev, struct gpio_device, list);
253         if (prev->base + prev->ngpio <= gdev->base) {
254                 /* add behind last entry */
255                 list_add_tail(&gdev->list, &gpio_devices);
256                 return 0;
257         }
258
259         list_for_each_entry_safe(prev, next, &gpio_devices, list) {
260                 /* at the end of the list */
261                 if (&next->list == &gpio_devices)
262                         break;
263
264                 /* add between prev and next */
265                 if (prev->base + prev->ngpio <= gdev->base
266                                 && gdev->base + gdev->ngpio <= next->base) {
267                         list_add(&gdev->list, &prev->list);
268                         return 0;
269                 }
270         }
271
272         dev_err(&gdev->dev, "GPIO integer space overlap, cannot add chip\n");
273         return -EBUSY;
274 }
275
276 /*
277  * Convert a GPIO name to its descriptor
278  */
279 static struct gpio_desc *gpio_name_to_desc(const char * const name)
280 {
281         struct gpio_device *gdev;
282         unsigned long flags;
283
284         spin_lock_irqsave(&gpio_lock, flags);
285
286         list_for_each_entry(gdev, &gpio_devices, list) {
287                 int i;
288
289                 for (i = 0; i != gdev->ngpio; ++i) {
290                         struct gpio_desc *desc = &gdev->descs[i];
291
292                         if (!desc->name || !name)
293                                 continue;
294
295                         if (!strcmp(desc->name, name)) {
296                                 spin_unlock_irqrestore(&gpio_lock, flags);
297                                 return desc;
298                         }
299                 }
300         }
301
302         spin_unlock_irqrestore(&gpio_lock, flags);
303
304         return NULL;
305 }
306
307 /*
308  * Takes the names from gc->names and checks if they are all unique. If they
309  * are, they are assigned to their gpio descriptors.
310  *
311  * Warning if one of the names is already used for a different GPIO.
312  */
313 static int gpiochip_set_desc_names(struct gpio_chip *gc)
314 {
315         struct gpio_device *gdev = gc->gpiodev;
316         int i;
317
318         if (!gc->names)
319                 return 0;
320
321         /* First check all names if they are unique */
322         for (i = 0; i != gc->ngpio; ++i) {
323                 struct gpio_desc *gpio;
324
325                 gpio = gpio_name_to_desc(gc->names[i]);
326                 if (gpio)
327                         dev_warn(&gdev->dev,
328                                  "Detected name collision for GPIO name '%s'\n",
329                                  gc->names[i]);
330         }
331
332         /* Then add all names to the GPIO descriptors */
333         for (i = 0; i != gc->ngpio; ++i)
334                 gdev->descs[i].name = gc->names[i];
335
336         return 0;
337 }
338
339 /*
340  * GPIO line handle management
341  */
342
343 /**
344  * struct linehandle_state - contains the state of a userspace handle
345  * @gdev: the GPIO device the handle pertains to
346  * @label: consumer label used to tag descriptors
347  * @descs: the GPIO descriptors held by this handle
348  * @numdescs: the number of descriptors held in the descs array
349  */
350 struct linehandle_state {
351         struct gpio_device *gdev;
352         const char *label;
353         struct gpio_desc *descs[GPIOHANDLES_MAX];
354         u32 numdescs;
355 };
356
357 #define GPIOHANDLE_REQUEST_VALID_FLAGS \
358         (GPIOHANDLE_REQUEST_INPUT | \
359         GPIOHANDLE_REQUEST_OUTPUT | \
360         GPIOHANDLE_REQUEST_ACTIVE_LOW | \
361         GPIOHANDLE_REQUEST_OPEN_DRAIN | \
362         GPIOHANDLE_REQUEST_OPEN_SOURCE)
363
364 static long linehandle_ioctl(struct file *filep, unsigned int cmd,
365                              unsigned long arg)
366 {
367         struct linehandle_state *lh = filep->private_data;
368         void __user *ip = (void __user *)arg;
369         struct gpiohandle_data ghd;
370         int vals[GPIOHANDLES_MAX];
371         int i;
372
373         if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
374                 /* TODO: check if descriptors are really input */
375                 int ret = gpiod_get_array_value_complex(false,
376                                                         true,
377                                                         lh->numdescs,
378                                                         lh->descs,
379                                                         vals);
380                 if (ret)
381                         return ret;
382
383                 memset(&ghd, 0, sizeof(ghd));
384                 for (i = 0; i < lh->numdescs; i++)
385                         ghd.values[i] = vals[i];
386
387                 if (copy_to_user(ip, &ghd, sizeof(ghd)))
388                         return -EFAULT;
389
390                 return 0;
391         } else if (cmd == GPIOHANDLE_SET_LINE_VALUES_IOCTL) {
392                 /* TODO: check if descriptors are really output */
393                 if (copy_from_user(&ghd, ip, sizeof(ghd)))
394                         return -EFAULT;
395
396                 /* Clamp all values to [0,1] */
397                 for (i = 0; i < lh->numdescs; i++)
398                         vals[i] = !!ghd.values[i];
399
400                 /* Reuse the array setting function */
401                 gpiod_set_array_value_complex(false,
402                                               true,
403                                               lh->numdescs,
404                                               lh->descs,
405                                               vals);
406                 return 0;
407         }
408         return -EINVAL;
409 }
410
411 #ifdef CONFIG_COMPAT
412 static long linehandle_ioctl_compat(struct file *filep, unsigned int cmd,
413                              unsigned long arg)
414 {
415         return linehandle_ioctl(filep, cmd, (unsigned long)compat_ptr(arg));
416 }
417 #endif
418
419 static int linehandle_release(struct inode *inode, struct file *filep)
420 {
421         struct linehandle_state *lh = filep->private_data;
422         struct gpio_device *gdev = lh->gdev;
423         int i;
424
425         for (i = 0; i < lh->numdescs; i++)
426                 gpiod_free(lh->descs[i]);
427         kfree(lh->label);
428         kfree(lh);
429         put_device(&gdev->dev);
430         return 0;
431 }
432
433 static const struct file_operations linehandle_fileops = {
434         .release = linehandle_release,
435         .owner = THIS_MODULE,
436         .llseek = noop_llseek,
437         .unlocked_ioctl = linehandle_ioctl,
438 #ifdef CONFIG_COMPAT
439         .compat_ioctl = linehandle_ioctl_compat,
440 #endif
441 };
442
443 static int linehandle_create(struct gpio_device *gdev, void __user *ip)
444 {
445         struct gpiohandle_request handlereq;
446         struct linehandle_state *lh;
447         struct file *file;
448         int fd, i, ret;
449         u32 lflags;
450
451         if (copy_from_user(&handlereq, ip, sizeof(handlereq)))
452                 return -EFAULT;
453         if ((handlereq.lines == 0) || (handlereq.lines > GPIOHANDLES_MAX))
454                 return -EINVAL;
455
456         lflags = handlereq.flags;
457
458         /* Return an error if an unknown flag is set */
459         if (lflags & ~GPIOHANDLE_REQUEST_VALID_FLAGS)
460                 return -EINVAL;
461
462         /* OPEN_DRAIN and OPEN_SOURCE flags only make sense for output mode. */
463         if (!(lflags & GPIOHANDLE_REQUEST_OUTPUT) &&
464             ((lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN) ||
465              (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)))
466                 return -EINVAL;
467
468         lh = kzalloc(sizeof(*lh), GFP_KERNEL);
469         if (!lh)
470                 return -ENOMEM;
471         lh->gdev = gdev;
472         get_device(&gdev->dev);
473
474         /* Make sure this is terminated */
475         handlereq.consumer_label[sizeof(handlereq.consumer_label)-1] = '\0';
476         if (strlen(handlereq.consumer_label)) {
477                 lh->label = kstrdup(handlereq.consumer_label,
478                                     GFP_KERNEL);
479                 if (!lh->label) {
480                         ret = -ENOMEM;
481                         goto out_free_lh;
482                 }
483         }
484
485         /* Request each GPIO */
486         for (i = 0; i < handlereq.lines; i++) {
487                 u32 offset = handlereq.lineoffsets[i];
488                 struct gpio_desc *desc;
489
490                 if (offset >= gdev->ngpio) {
491                         ret = -EINVAL;
492                         goto out_free_descs;
493                 }
494
495                 desc = &gdev->descs[offset];
496                 ret = gpiod_request(desc, lh->label);
497                 if (ret)
498                         goto out_free_descs;
499                 lh->descs[i] = desc;
500
501                 if (lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW)
502                         set_bit(FLAG_ACTIVE_LOW, &desc->flags);
503                 if (lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN)
504                         set_bit(FLAG_OPEN_DRAIN, &desc->flags);
505                 if (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)
506                         set_bit(FLAG_OPEN_SOURCE, &desc->flags);
507
508                 /*
509                  * Lines have to be requested explicitly for input
510                  * or output, else the line will be treated "as is".
511                  */
512                 if (lflags & GPIOHANDLE_REQUEST_OUTPUT) {
513                         int val = !!handlereq.default_values[i];
514
515                         ret = gpiod_direction_output(desc, val);
516                         if (ret)
517                                 goto out_free_descs;
518                 } else if (lflags & GPIOHANDLE_REQUEST_INPUT) {
519                         ret = gpiod_direction_input(desc);
520                         if (ret)
521                                 goto out_free_descs;
522                 }
523                 dev_dbg(&gdev->dev, "registered chardev handle for line %d\n",
524                         offset);
525         }
526         /* Let i point at the last handle */
527         i--;
528         lh->numdescs = handlereq.lines;
529
530         fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
531         if (fd < 0) {
532                 ret = fd;
533                 goto out_free_descs;
534         }
535
536         file = anon_inode_getfile("gpio-linehandle",
537                                   &linehandle_fileops,
538                                   lh,
539                                   O_RDONLY | O_CLOEXEC);
540         if (IS_ERR(file)) {
541                 ret = PTR_ERR(file);
542                 goto out_put_unused_fd;
543         }
544
545         handlereq.fd = fd;
546         if (copy_to_user(ip, &handlereq, sizeof(handlereq))) {
547                 /*
548                  * fput() will trigger the release() callback, so do not go onto
549                  * the regular error cleanup path here.
550                  */
551                 fput(file);
552                 put_unused_fd(fd);
553                 return -EFAULT;
554         }
555
556         fd_install(fd, file);
557
558         dev_dbg(&gdev->dev, "registered chardev handle for %d lines\n",
559                 lh->numdescs);
560
561         return 0;
562
563 out_put_unused_fd:
564         put_unused_fd(fd);
565 out_free_descs:
566         for (; i >= 0; i--)
567                 gpiod_free(lh->descs[i]);
568         kfree(lh->label);
569 out_free_lh:
570         kfree(lh);
571         put_device(&gdev->dev);
572         return ret;
573 }
574
575 /*
576  * GPIO line event management
577  */
578
579 /**
580  * struct lineevent_state - contains the state of a userspace event
581  * @gdev: the GPIO device the event pertains to
582  * @label: consumer label used to tag descriptors
583  * @desc: the GPIO descriptor held by this event
584  * @eflags: the event flags this line was requested with
585  * @irq: the interrupt that trigger in response to events on this GPIO
586  * @wait: wait queue that handles blocking reads of events
587  * @events: KFIFO for the GPIO events
588  * @read_lock: mutex lock to protect reads from colliding with adding
589  * new events to the FIFO
590  */
591 struct lineevent_state {
592         struct gpio_device *gdev;
593         const char *label;
594         struct gpio_desc *desc;
595         u32 eflags;
596         int irq;
597         wait_queue_head_t wait;
598         DECLARE_KFIFO(events, struct gpioevent_data, 16);
599         struct mutex read_lock;
600 };
601
602 #define GPIOEVENT_REQUEST_VALID_FLAGS \
603         (GPIOEVENT_REQUEST_RISING_EDGE | \
604         GPIOEVENT_REQUEST_FALLING_EDGE)
605
606 static unsigned int lineevent_poll(struct file *filep,
607                                    struct poll_table_struct *wait)
608 {
609         struct lineevent_state *le = filep->private_data;
610         unsigned int events = 0;
611
612         poll_wait(filep, &le->wait, wait);
613
614         if (!kfifo_is_empty(&le->events))
615                 events = POLLIN | POLLRDNORM;
616
617         return events;
618 }
619
620
621 static ssize_t lineevent_read(struct file *filep,
622                               char __user *buf,
623                               size_t count,
624                               loff_t *f_ps)
625 {
626         struct lineevent_state *le = filep->private_data;
627         unsigned int copied;
628         int ret;
629
630         if (count < sizeof(struct gpioevent_data))
631                 return -EINVAL;
632
633         do {
634                 if (kfifo_is_empty(&le->events)) {
635                         if (filep->f_flags & O_NONBLOCK)
636                                 return -EAGAIN;
637
638                         ret = wait_event_interruptible(le->wait,
639                                         !kfifo_is_empty(&le->events));
640                         if (ret)
641                                 return ret;
642                 }
643
644                 if (mutex_lock_interruptible(&le->read_lock))
645                         return -ERESTARTSYS;
646                 ret = kfifo_to_user(&le->events, buf, count, &copied);
647                 mutex_unlock(&le->read_lock);
648
649                 if (ret)
650                         return ret;
651
652                 /*
653                  * If we couldn't read anything from the fifo (a different
654                  * thread might have been faster) we either return -EAGAIN if
655                  * the file descriptor is non-blocking, otherwise we go back to
656                  * sleep and wait for more data to arrive.
657                  */
658                 if (copied == 0 && (filep->f_flags & O_NONBLOCK))
659                         return -EAGAIN;
660
661         } while (copied == 0);
662
663         return copied;
664 }
665
666 static int lineevent_release(struct inode *inode, struct file *filep)
667 {
668         struct lineevent_state *le = filep->private_data;
669         struct gpio_device *gdev = le->gdev;
670
671         free_irq(le->irq, le);
672         gpiod_free(le->desc);
673         kfree(le->label);
674         kfree(le);
675         put_device(&gdev->dev);
676         return 0;
677 }
678
679 static long lineevent_ioctl(struct file *filep, unsigned int cmd,
680                             unsigned long arg)
681 {
682         struct lineevent_state *le = filep->private_data;
683         void __user *ip = (void __user *)arg;
684         struct gpiohandle_data ghd;
685
686         /*
687          * We can get the value for an event line but not set it,
688          * because it is input by definition.
689          */
690         if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
691                 int val;
692
693                 memset(&ghd, 0, sizeof(ghd));
694
695                 val = gpiod_get_value_cansleep(le->desc);
696                 if (val < 0)
697                         return val;
698                 ghd.values[0] = val;
699
700                 if (copy_to_user(ip, &ghd, sizeof(ghd)))
701                         return -EFAULT;
702
703                 return 0;
704         }
705         return -EINVAL;
706 }
707
708 #ifdef CONFIG_COMPAT
709 static long lineevent_ioctl_compat(struct file *filep, unsigned int cmd,
710                                    unsigned long arg)
711 {
712         return lineevent_ioctl(filep, cmd, (unsigned long)compat_ptr(arg));
713 }
714 #endif
715
716 static const struct file_operations lineevent_fileops = {
717         .release = lineevent_release,
718         .read = lineevent_read,
719         .poll = lineevent_poll,
720         .owner = THIS_MODULE,
721         .llseek = noop_llseek,
722         .unlocked_ioctl = lineevent_ioctl,
723 #ifdef CONFIG_COMPAT
724         .compat_ioctl = lineevent_ioctl_compat,
725 #endif
726 };
727
728 static irqreturn_t lineevent_irq_thread(int irq, void *p)
729 {
730         struct lineevent_state *le = p;
731         struct gpioevent_data ge;
732         int ret, level;
733
734         ge.timestamp = ktime_get_real_ns();
735         level = gpiod_get_value_cansleep(le->desc);
736
737         if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE
738             && le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) {
739                 if (level)
740                         /* Emit low-to-high event */
741                         ge.id = GPIOEVENT_EVENT_RISING_EDGE;
742                 else
743                         /* Emit high-to-low event */
744                         ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
745         } else if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE && level) {
746                 /* Emit low-to-high event */
747                 ge.id = GPIOEVENT_EVENT_RISING_EDGE;
748         } else if (le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE && !level) {
749                 /* Emit high-to-low event */
750                 ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
751         } else {
752                 return IRQ_NONE;
753         }
754
755         ret = kfifo_put(&le->events, ge);
756         if (ret != 0)
757                 wake_up_poll(&le->wait, POLLIN);
758
759         return IRQ_HANDLED;
760 }
761
762 static int lineevent_create(struct gpio_device *gdev, void __user *ip)
763 {
764         struct gpioevent_request eventreq;
765         struct lineevent_state *le;
766         struct gpio_desc *desc;
767         struct file *file;
768         u32 offset;
769         u32 lflags;
770         u32 eflags;
771         int fd;
772         int ret;
773         int irqflags = 0;
774
775         if (copy_from_user(&eventreq, ip, sizeof(eventreq)))
776                 return -EFAULT;
777
778         le = kzalloc(sizeof(*le), GFP_KERNEL);
779         if (!le)
780                 return -ENOMEM;
781         le->gdev = gdev;
782         get_device(&gdev->dev);
783
784         /* Make sure this is terminated */
785         eventreq.consumer_label[sizeof(eventreq.consumer_label)-1] = '\0';
786         if (strlen(eventreq.consumer_label)) {
787                 le->label = kstrdup(eventreq.consumer_label,
788                                     GFP_KERNEL);
789                 if (!le->label) {
790                         ret = -ENOMEM;
791                         goto out_free_le;
792                 }
793         }
794
795         offset = eventreq.lineoffset;
796         lflags = eventreq.handleflags;
797         eflags = eventreq.eventflags;
798
799         if (offset >= gdev->ngpio) {
800                 ret = -EINVAL;
801                 goto out_free_label;
802         }
803
804         /* Return an error if a unknown flag is set */
805         if ((lflags & ~GPIOHANDLE_REQUEST_VALID_FLAGS) ||
806             (eflags & ~GPIOEVENT_REQUEST_VALID_FLAGS)) {
807                 ret = -EINVAL;
808                 goto out_free_label;
809         }
810
811         /* This is just wrong: we don't look for events on output lines */
812         if (lflags & GPIOHANDLE_REQUEST_OUTPUT) {
813                 ret = -EINVAL;
814                 goto out_free_label;
815         }
816
817         desc = &gdev->descs[offset];
818         ret = gpiod_request(desc, le->label);
819         if (ret)
820                 goto out_free_desc;
821         le->desc = desc;
822         le->eflags = eflags;
823
824         if (lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW)
825                 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
826         if (lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN)
827                 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
828         if (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)
829                 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
830
831         ret = gpiod_direction_input(desc);
832         if (ret)
833                 goto out_free_desc;
834
835         le->irq = gpiod_to_irq(desc);
836         if (le->irq <= 0) {
837                 ret = -ENODEV;
838                 goto out_free_desc;
839         }
840
841         if (eflags & GPIOEVENT_REQUEST_RISING_EDGE)
842                 irqflags |= IRQF_TRIGGER_RISING;
843         if (eflags & GPIOEVENT_REQUEST_FALLING_EDGE)
844                 irqflags |= IRQF_TRIGGER_FALLING;
845         irqflags |= IRQF_ONESHOT;
846         irqflags |= IRQF_SHARED;
847
848         INIT_KFIFO(le->events);
849         init_waitqueue_head(&le->wait);
850         mutex_init(&le->read_lock);
851
852         /* Request a thread to read the events */
853         ret = request_threaded_irq(le->irq,
854                         NULL,
855                         lineevent_irq_thread,
856                         irqflags,
857                         le->label,
858                         le);
859         if (ret)
860                 goto out_free_desc;
861
862         fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
863         if (fd < 0) {
864                 ret = fd;
865                 goto out_free_irq;
866         }
867
868         file = anon_inode_getfile("gpio-event",
869                                   &lineevent_fileops,
870                                   le,
871                                   O_RDONLY | O_CLOEXEC);
872         if (IS_ERR(file)) {
873                 ret = PTR_ERR(file);
874                 goto out_put_unused_fd;
875         }
876
877         eventreq.fd = fd;
878         if (copy_to_user(ip, &eventreq, sizeof(eventreq))) {
879                 /*
880                  * fput() will trigger the release() callback, so do not go onto
881                  * the regular error cleanup path here.
882                  */
883                 fput(file);
884                 put_unused_fd(fd);
885                 return -EFAULT;
886         }
887
888         fd_install(fd, file);
889
890         return 0;
891
892 out_put_unused_fd:
893         put_unused_fd(fd);
894 out_free_irq:
895         free_irq(le->irq, le);
896 out_free_desc:
897         gpiod_free(le->desc);
898 out_free_label:
899         kfree(le->label);
900 out_free_le:
901         kfree(le);
902         put_device(&gdev->dev);
903         return ret;
904 }
905
906 /*
907  * gpio_ioctl() - ioctl handler for the GPIO chardev
908  */
909 static long gpio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
910 {
911         struct gpio_device *gdev = filp->private_data;
912         struct gpio_chip *chip = gdev->chip;
913         void __user *ip = (void __user *)arg;
914
915         /* We fail any subsequent ioctl():s when the chip is gone */
916         if (!chip)
917                 return -ENODEV;
918
919         /* Fill in the struct and pass to userspace */
920         if (cmd == GPIO_GET_CHIPINFO_IOCTL) {
921                 struct gpiochip_info chipinfo;
922
923                 memset(&chipinfo, 0, sizeof(chipinfo));
924
925                 strncpy(chipinfo.name, dev_name(&gdev->dev),
926                         sizeof(chipinfo.name));
927                 chipinfo.name[sizeof(chipinfo.name)-1] = '\0';
928                 strncpy(chipinfo.label, gdev->label,
929                         sizeof(chipinfo.label));
930                 chipinfo.label[sizeof(chipinfo.label)-1] = '\0';
931                 chipinfo.lines = gdev->ngpio;
932                 if (copy_to_user(ip, &chipinfo, sizeof(chipinfo)))
933                         return -EFAULT;
934                 return 0;
935         } else if (cmd == GPIO_GET_LINEINFO_IOCTL) {
936                 struct gpioline_info lineinfo;
937                 struct gpio_desc *desc;
938
939                 if (copy_from_user(&lineinfo, ip, sizeof(lineinfo)))
940                         return -EFAULT;
941                 if (lineinfo.line_offset >= gdev->ngpio)
942                         return -EINVAL;
943
944                 desc = &gdev->descs[lineinfo.line_offset];
945                 if (desc->name) {
946                         strncpy(lineinfo.name, desc->name,
947                                 sizeof(lineinfo.name));
948                         lineinfo.name[sizeof(lineinfo.name)-1] = '\0';
949                 } else {
950                         lineinfo.name[0] = '\0';
951                 }
952                 if (desc->label) {
953                         strncpy(lineinfo.consumer, desc->label,
954                                 sizeof(lineinfo.consumer));
955                         lineinfo.consumer[sizeof(lineinfo.consumer)-1] = '\0';
956                 } else {
957                         lineinfo.consumer[0] = '\0';
958                 }
959
960                 /*
961                  * Userspace only need to know that the kernel is using
962                  * this GPIO so it can't use it.
963                  */
964                 lineinfo.flags = 0;
965                 if (test_bit(FLAG_REQUESTED, &desc->flags) ||
966                     test_bit(FLAG_IS_HOGGED, &desc->flags) ||
967                     test_bit(FLAG_USED_AS_IRQ, &desc->flags) ||
968                     test_bit(FLAG_EXPORT, &desc->flags) ||
969                     test_bit(FLAG_SYSFS, &desc->flags))
970                         lineinfo.flags |= GPIOLINE_FLAG_KERNEL;
971                 if (test_bit(FLAG_IS_OUT, &desc->flags))
972                         lineinfo.flags |= GPIOLINE_FLAG_IS_OUT;
973                 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
974                         lineinfo.flags |= GPIOLINE_FLAG_ACTIVE_LOW;
975                 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
976                         lineinfo.flags |= GPIOLINE_FLAG_OPEN_DRAIN;
977                 if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
978                         lineinfo.flags |= GPIOLINE_FLAG_OPEN_SOURCE;
979
980                 if (copy_to_user(ip, &lineinfo, sizeof(lineinfo)))
981                         return -EFAULT;
982                 return 0;
983         } else if (cmd == GPIO_GET_LINEHANDLE_IOCTL) {
984                 return linehandle_create(gdev, ip);
985         } else if (cmd == GPIO_GET_LINEEVENT_IOCTL) {
986                 return lineevent_create(gdev, ip);
987         }
988         return -EINVAL;
989 }
990
991 #ifdef CONFIG_COMPAT
992 static long gpio_ioctl_compat(struct file *filp, unsigned int cmd,
993                               unsigned long arg)
994 {
995         return gpio_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
996 }
997 #endif
998
999 /**
1000  * gpio_chrdev_open() - open the chardev for ioctl operations
1001  * @inode: inode for this chardev
1002  * @filp: file struct for storing private data
1003  * Returns 0 on success
1004  */
1005 static int gpio_chrdev_open(struct inode *inode, struct file *filp)
1006 {
1007         struct gpio_device *gdev = container_of(inode->i_cdev,
1008                                               struct gpio_device, chrdev);
1009
1010         /* Fail on open if the backing gpiochip is gone */
1011         if (!gdev->chip)
1012                 return -ENODEV;
1013         get_device(&gdev->dev);
1014         filp->private_data = gdev;
1015
1016         return nonseekable_open(inode, filp);
1017 }
1018
1019 /**
1020  * gpio_chrdev_release() - close chardev after ioctl operations
1021  * @inode: inode for this chardev
1022  * @filp: file struct for storing private data
1023  * Returns 0 on success
1024  */
1025 static int gpio_chrdev_release(struct inode *inode, struct file *filp)
1026 {
1027         struct gpio_device *gdev = container_of(inode->i_cdev,
1028                                               struct gpio_device, chrdev);
1029
1030         put_device(&gdev->dev);
1031         return 0;
1032 }
1033
1034
1035 static const struct file_operations gpio_fileops = {
1036         .release = gpio_chrdev_release,
1037         .open = gpio_chrdev_open,
1038         .owner = THIS_MODULE,
1039         .llseek = no_llseek,
1040         .unlocked_ioctl = gpio_ioctl,
1041 #ifdef CONFIG_COMPAT
1042         .compat_ioctl = gpio_ioctl_compat,
1043 #endif
1044 };
1045
1046 static void gpiodevice_release(struct device *dev)
1047 {
1048         struct gpio_device *gdev = dev_get_drvdata(dev);
1049
1050         list_del(&gdev->list);
1051         ida_simple_remove(&gpio_ida, gdev->id);
1052         kfree(gdev->label);
1053         kfree(gdev->descs);
1054         kfree(gdev);
1055 }
1056
1057 static int gpiochip_setup_dev(struct gpio_device *gdev)
1058 {
1059         int status;
1060
1061         cdev_init(&gdev->chrdev, &gpio_fileops);
1062         gdev->chrdev.owner = THIS_MODULE;
1063         gdev->dev.devt = MKDEV(MAJOR(gpio_devt), gdev->id);
1064
1065         status = cdev_device_add(&gdev->chrdev, &gdev->dev);
1066         if (status)
1067                 return status;
1068
1069         chip_dbg(gdev->chip, "added GPIO chardev (%d:%d)\n",
1070                  MAJOR(gpio_devt), gdev->id);
1071
1072         status = gpiochip_sysfs_register(gdev);
1073         if (status)
1074                 goto err_remove_device;
1075
1076         /* From this point, the .release() function cleans up gpio_device */
1077         gdev->dev.release = gpiodevice_release;
1078         pr_debug("%s: registered GPIOs %d to %d on device: %s (%s)\n",
1079                  __func__, gdev->base, gdev->base + gdev->ngpio - 1,
1080                  dev_name(&gdev->dev), gdev->chip->label ? : "generic");
1081
1082         return 0;
1083
1084 err_remove_device:
1085         cdev_device_del(&gdev->chrdev, &gdev->dev);
1086         return status;
1087 }
1088
1089 static void gpiochip_setup_devs(void)
1090 {
1091         struct gpio_device *gdev;
1092         int err;
1093
1094         list_for_each_entry(gdev, &gpio_devices, list) {
1095                 err = gpiochip_setup_dev(gdev);
1096                 if (err)
1097                         pr_err("%s: Failed to initialize gpio device (%d)\n",
1098                                dev_name(&gdev->dev), err);
1099         }
1100 }
1101
1102 int gpiochip_add_data_with_key(struct gpio_chip *chip, void *data,
1103                                struct lock_class_key *key)
1104 {
1105         unsigned long   flags;
1106         int             status = 0;
1107         unsigned        i;
1108         int             base = chip->base;
1109         struct gpio_device *gdev;
1110
1111         /*
1112          * First: allocate and populate the internal stat container, and
1113          * set up the struct device.
1114          */
1115         gdev = kzalloc(sizeof(*gdev), GFP_KERNEL);
1116         if (!gdev)
1117                 return -ENOMEM;
1118         gdev->dev.bus = &gpio_bus_type;
1119         gdev->chip = chip;
1120         chip->gpiodev = gdev;
1121         if (chip->parent) {
1122                 gdev->dev.parent = chip->parent;
1123                 gdev->dev.of_node = chip->parent->of_node;
1124         }
1125
1126 #ifdef CONFIG_OF_GPIO
1127         /* If the gpiochip has an assigned OF node this takes precedence */
1128         if (chip->of_node)
1129                 gdev->dev.of_node = chip->of_node;
1130 #endif
1131
1132         gdev->id = ida_simple_get(&gpio_ida, 0, 0, GFP_KERNEL);
1133         if (gdev->id < 0) {
1134                 status = gdev->id;
1135                 goto err_free_gdev;
1136         }
1137         dev_set_name(&gdev->dev, "gpiochip%d", gdev->id);
1138         device_initialize(&gdev->dev);
1139         dev_set_drvdata(&gdev->dev, gdev);
1140         if (chip->parent && chip->parent->driver)
1141                 gdev->owner = chip->parent->driver->owner;
1142         else if (chip->owner)
1143                 /* TODO: remove chip->owner */
1144                 gdev->owner = chip->owner;
1145         else
1146                 gdev->owner = THIS_MODULE;
1147
1148         gdev->descs = kcalloc(chip->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
1149         if (!gdev->descs) {
1150                 status = -ENOMEM;
1151                 goto err_free_gdev;
1152         }
1153
1154         if (chip->ngpio == 0) {
1155                 chip_err(chip, "tried to insert a GPIO chip with zero lines\n");
1156                 status = -EINVAL;
1157                 goto err_free_descs;
1158         }
1159
1160         if (chip->label)
1161                 gdev->label = kstrdup(chip->label, GFP_KERNEL);
1162         else
1163                 gdev->label = kstrdup("unknown", GFP_KERNEL);
1164         if (!gdev->label) {
1165                 status = -ENOMEM;
1166                 goto err_free_descs;
1167         }
1168
1169         gdev->ngpio = chip->ngpio;
1170         gdev->data = data;
1171
1172         spin_lock_irqsave(&gpio_lock, flags);
1173
1174         /*
1175          * TODO: this allocates a Linux GPIO number base in the global
1176          * GPIO numberspace for this chip. In the long run we want to
1177          * get *rid* of this numberspace and use only descriptors, but
1178          * it may be a pipe dream. It will not happen before we get rid
1179          * of the sysfs interface anyways.
1180          */
1181         if (base < 0) {
1182                 base = gpiochip_find_base(chip->ngpio);
1183                 if (base < 0) {
1184                         status = base;
1185                         spin_unlock_irqrestore(&gpio_lock, flags);
1186                         goto err_free_label;
1187                 }
1188                 /*
1189                  * TODO: it should not be necessary to reflect the assigned
1190                  * base outside of the GPIO subsystem. Go over drivers and
1191                  * see if anyone makes use of this, else drop this and assign
1192                  * a poison instead.
1193                  */
1194                 chip->base = base;
1195         }
1196         gdev->base = base;
1197
1198         status = gpiodev_add_to_list(gdev);
1199         if (status) {
1200                 spin_unlock_irqrestore(&gpio_lock, flags);
1201                 goto err_free_label;
1202         }
1203
1204         spin_unlock_irqrestore(&gpio_lock, flags);
1205
1206         for (i = 0; i < chip->ngpio; i++) {
1207                 struct gpio_desc *desc = &gdev->descs[i];
1208
1209                 desc->gdev = gdev;
1210                 /*
1211                  * REVISIT: most hardware initializes GPIOs as inputs
1212                  * (often with pullups enabled) so power usage is
1213                  * minimized. Linux code should set the gpio direction
1214                  * first thing; but until it does, and in case
1215                  * chip->get_direction is not set, we may expose the
1216                  * wrong direction in sysfs.
1217                  */
1218
1219                 if (chip->get_direction) {
1220                         /*
1221                          * If we have .get_direction, set up the initial
1222                          * direction flag from the hardware.
1223                          */
1224                         int dir = chip->get_direction(chip, i);
1225
1226                         if (!dir)
1227                                 set_bit(FLAG_IS_OUT, &desc->flags);
1228                 } else if (!chip->direction_input) {
1229                         /*
1230                          * If the chip lacks the .direction_input callback
1231                          * we logically assume all lines are outputs.
1232                          */
1233                         set_bit(FLAG_IS_OUT, &desc->flags);
1234                 }
1235         }
1236
1237 #ifdef CONFIG_PINCTRL
1238         INIT_LIST_HEAD(&gdev->pin_ranges);
1239 #endif
1240
1241         status = gpiochip_set_desc_names(chip);
1242         if (status)
1243                 goto err_remove_from_list;
1244
1245         status = gpiochip_irqchip_init_valid_mask(chip);
1246         if (status)
1247                 goto err_remove_from_list;
1248
1249         status = gpiochip_add_irqchip(chip, key);
1250         if (status)
1251                 goto err_remove_chip;
1252
1253         status = of_gpiochip_add(chip);
1254         if (status)
1255                 goto err_remove_chip;
1256
1257         acpi_gpiochip_add(chip);
1258
1259         /*
1260          * By first adding the chardev, and then adding the device,
1261          * we get a device node entry in sysfs under
1262          * /sys/bus/gpio/devices/gpiochipN/dev that can be used for
1263          * coldplug of device nodes and other udev business.
1264          * We can do this only if gpiolib has been initialized.
1265          * Otherwise, defer until later.
1266          */
1267         if (gpiolib_initialized) {
1268                 status = gpiochip_setup_dev(gdev);
1269                 if (status)
1270                         goto err_remove_chip;
1271         }
1272         return 0;
1273
1274 err_remove_chip:
1275         acpi_gpiochip_remove(chip);
1276         gpiochip_free_hogs(chip);
1277         of_gpiochip_remove(chip);
1278         gpiochip_irqchip_free_valid_mask(chip);
1279 err_remove_from_list:
1280         spin_lock_irqsave(&gpio_lock, flags);
1281         list_del(&gdev->list);
1282         spin_unlock_irqrestore(&gpio_lock, flags);
1283 err_free_label:
1284         kfree(gdev->label);
1285 err_free_descs:
1286         kfree(gdev->descs);
1287 err_free_gdev:
1288         ida_simple_remove(&gpio_ida, gdev->id);
1289         /* failures here can mean systems won't boot... */
1290         pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__,
1291                gdev->base, gdev->base + gdev->ngpio - 1,
1292                chip->label ? : "generic");
1293         kfree(gdev);
1294         return status;
1295 }
1296 EXPORT_SYMBOL_GPL(gpiochip_add_data_with_key);
1297
1298 /**
1299  * gpiochip_get_data() - get per-subdriver data for the chip
1300  * @chip: GPIO chip
1301  *
1302  * Returns:
1303  * The per-subdriver data for the chip.
1304  */
1305 void *gpiochip_get_data(struct gpio_chip *chip)
1306 {
1307         return chip->gpiodev->data;
1308 }
1309 EXPORT_SYMBOL_GPL(gpiochip_get_data);
1310
1311 /**
1312  * gpiochip_remove() - unregister a gpio_chip
1313  * @chip: the chip to unregister
1314  *
1315  * A gpio_chip with any GPIOs still requested may not be removed.
1316  */
1317 void gpiochip_remove(struct gpio_chip *chip)
1318 {
1319         struct gpio_device *gdev = chip->gpiodev;
1320         struct gpio_desc *desc;
1321         unsigned long   flags;
1322         unsigned        i;
1323         bool            requested = false;
1324
1325         /* FIXME: should the legacy sysfs handling be moved to gpio_device? */
1326         gpiochip_sysfs_unregister(gdev);
1327         gpiochip_free_hogs(chip);
1328         /* Numb the device, cancelling all outstanding operations */
1329         gdev->chip = NULL;
1330         gpiochip_irqchip_remove(chip);
1331         acpi_gpiochip_remove(chip);
1332         gpiochip_remove_pin_ranges(chip);
1333         of_gpiochip_remove(chip);
1334         /*
1335          * We accept no more calls into the driver from this point, so
1336          * NULL the driver data pointer
1337          */
1338         gdev->data = NULL;
1339
1340         spin_lock_irqsave(&gpio_lock, flags);
1341         for (i = 0; i < gdev->ngpio; i++) {
1342                 desc = &gdev->descs[i];
1343                 if (test_bit(FLAG_REQUESTED, &desc->flags))
1344                         requested = true;
1345         }
1346         spin_unlock_irqrestore(&gpio_lock, flags);
1347
1348         if (requested)
1349                 dev_crit(&gdev->dev,
1350                          "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
1351
1352         /*
1353          * The gpiochip side puts its use of the device to rest here:
1354          * if there are no userspace clients, the chardev and device will
1355          * be removed, else it will be dangling until the last user is
1356          * gone.
1357          */
1358         cdev_device_del(&gdev->chrdev, &gdev->dev);
1359         put_device(&gdev->dev);
1360 }
1361 EXPORT_SYMBOL_GPL(gpiochip_remove);
1362
1363 static void devm_gpio_chip_release(struct device *dev, void *res)
1364 {
1365         struct gpio_chip *chip = *(struct gpio_chip **)res;
1366
1367         gpiochip_remove(chip);
1368 }
1369
1370 static int devm_gpio_chip_match(struct device *dev, void *res, void *data)
1371
1372 {
1373         struct gpio_chip **r = res;
1374
1375         if (!r || !*r) {
1376                 WARN_ON(!r || !*r);
1377                 return 0;
1378         }
1379
1380         return *r == data;
1381 }
1382
1383 /**
1384  * devm_gpiochip_add_data() - Resource manager piochip_add_data()
1385  * @dev: the device pointer on which irq_chip belongs to.
1386  * @chip: the chip to register, with chip->base initialized
1387  * @data: driver-private data associated with this chip
1388  *
1389  * Context: potentially before irqs will work
1390  *
1391  * The gpio chip automatically be released when the device is unbound.
1392  *
1393  * Returns:
1394  * A negative errno if the chip can't be registered, such as because the
1395  * chip->base is invalid or already associated with a different chip.
1396  * Otherwise it returns zero as a success code.
1397  */
1398 int devm_gpiochip_add_data(struct device *dev, struct gpio_chip *chip,
1399                            void *data)
1400 {
1401         struct gpio_chip **ptr;
1402         int ret;
1403
1404         ptr = devres_alloc(devm_gpio_chip_release, sizeof(*ptr),
1405                              GFP_KERNEL);
1406         if (!ptr)
1407                 return -ENOMEM;
1408
1409         ret = gpiochip_add_data(chip, data);
1410         if (ret < 0) {
1411                 devres_free(ptr);
1412                 return ret;
1413         }
1414
1415         *ptr = chip;
1416         devres_add(dev, ptr);
1417
1418         return 0;
1419 }
1420 EXPORT_SYMBOL_GPL(devm_gpiochip_add_data);
1421
1422 /**
1423  * devm_gpiochip_remove() - Resource manager of gpiochip_remove()
1424  * @dev: device for which which resource was allocated
1425  * @chip: the chip to remove
1426  *
1427  * A gpio_chip with any GPIOs still requested may not be removed.
1428  */
1429 void devm_gpiochip_remove(struct device *dev, struct gpio_chip *chip)
1430 {
1431         int ret;
1432
1433         ret = devres_release(dev, devm_gpio_chip_release,
1434                              devm_gpio_chip_match, chip);
1435         WARN_ON(ret);
1436 }
1437 EXPORT_SYMBOL_GPL(devm_gpiochip_remove);
1438
1439 /**
1440  * gpiochip_find() - iterator for locating a specific gpio_chip
1441  * @data: data to pass to match function
1442  * @match: Callback function to check gpio_chip
1443  *
1444  * Similar to bus_find_device.  It returns a reference to a gpio_chip as
1445  * determined by a user supplied @match callback.  The callback should return
1446  * 0 if the device doesn't match and non-zero if it does.  If the callback is
1447  * non-zero, this function will return to the caller and not iterate over any
1448  * more gpio_chips.
1449  */
1450 struct gpio_chip *gpiochip_find(void *data,
1451                                 int (*match)(struct gpio_chip *chip,
1452                                              void *data))
1453 {
1454         struct gpio_device *gdev;
1455         struct gpio_chip *chip = NULL;
1456         unsigned long flags;
1457
1458         spin_lock_irqsave(&gpio_lock, flags);
1459         list_for_each_entry(gdev, &gpio_devices, list)
1460                 if (gdev->chip && match(gdev->chip, data)) {
1461                         chip = gdev->chip;
1462                         break;
1463                 }
1464
1465         spin_unlock_irqrestore(&gpio_lock, flags);
1466
1467         return chip;
1468 }
1469 EXPORT_SYMBOL_GPL(gpiochip_find);
1470
1471 static int gpiochip_match_name(struct gpio_chip *chip, void *data)
1472 {
1473         const char *name = data;
1474
1475         return !strcmp(chip->label, name);
1476 }
1477
1478 static struct gpio_chip *find_chip_by_name(const char *name)
1479 {
1480         return gpiochip_find((void *)name, gpiochip_match_name);
1481 }
1482
1483 #ifdef CONFIG_GPIOLIB_IRQCHIP
1484
1485 /*
1486  * The following is irqchip helper code for gpiochips.
1487  */
1488
1489 static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
1490 {
1491         if (!gpiochip->irq.need_valid_mask)
1492                 return 0;
1493
1494         gpiochip->irq.valid_mask = kcalloc(BITS_TO_LONGS(gpiochip->ngpio),
1495                                            sizeof(long), GFP_KERNEL);
1496         if (!gpiochip->irq.valid_mask)
1497                 return -ENOMEM;
1498
1499         /* Assume by default all GPIOs are valid */
1500         bitmap_fill(gpiochip->irq.valid_mask, gpiochip->ngpio);
1501
1502         return 0;
1503 }
1504
1505 static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip)
1506 {
1507         kfree(gpiochip->irq.valid_mask);
1508         gpiochip->irq.valid_mask = NULL;
1509 }
1510
1511 static bool gpiochip_irqchip_irq_valid(const struct gpio_chip *gpiochip,
1512                                        unsigned int offset)
1513 {
1514         /* No mask means all valid */
1515         if (likely(!gpiochip->irq.valid_mask))
1516                 return true;
1517         return test_bit(offset, gpiochip->irq.valid_mask);
1518 }
1519
1520 /**
1521  * gpiochip_set_cascaded_irqchip() - connects a cascaded irqchip to a gpiochip
1522  * @gpiochip: the gpiochip to set the irqchip chain to
1523  * @irqchip: the irqchip to chain to the gpiochip
1524  * @parent_irq: the irq number corresponding to the parent IRQ for this
1525  * chained irqchip
1526  * @parent_handler: the parent interrupt handler for the accumulated IRQ
1527  * coming out of the gpiochip. If the interrupt is nested rather than
1528  * cascaded, pass NULL in this handler argument
1529  */
1530 static void gpiochip_set_cascaded_irqchip(struct gpio_chip *gpiochip,
1531                                           struct irq_chip *irqchip,
1532                                           unsigned int parent_irq,
1533                                           irq_flow_handler_t parent_handler)
1534 {
1535         unsigned int offset;
1536
1537         if (!gpiochip->irq.domain) {
1538                 chip_err(gpiochip, "called %s before setting up irqchip\n",
1539                          __func__);
1540                 return;
1541         }
1542
1543         if (parent_handler) {
1544                 if (gpiochip->can_sleep) {
1545                         chip_err(gpiochip,
1546                                  "you cannot have chained interrupts on a "
1547                                  "chip that may sleep\n");
1548                         return;
1549                 }
1550                 /*
1551                  * The parent irqchip is already using the chip_data for this
1552                  * irqchip, so our callbacks simply use the handler_data.
1553                  */
1554                 irq_set_chained_handler_and_data(parent_irq, parent_handler,
1555                                                  gpiochip);
1556
1557                 gpiochip->irq.parents = &parent_irq;
1558                 gpiochip->irq.num_parents = 1;
1559         }
1560
1561         /* Set the parent IRQ for all affected IRQs */
1562         for (offset = 0; offset < gpiochip->ngpio; offset++) {
1563                 if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
1564                         continue;
1565                 irq_set_parent(irq_find_mapping(gpiochip->irq.domain, offset),
1566                                parent_irq);
1567         }
1568 }
1569
1570 /**
1571  * gpiochip_set_chained_irqchip() - connects a chained irqchip to a gpiochip
1572  * @gpiochip: the gpiochip to set the irqchip chain to
1573  * @irqchip: the irqchip to chain to the gpiochip
1574  * @parent_irq: the irq number corresponding to the parent IRQ for this
1575  * chained irqchip
1576  * @parent_handler: the parent interrupt handler for the accumulated IRQ
1577  * coming out of the gpiochip. If the interrupt is nested rather than
1578  * cascaded, pass NULL in this handler argument
1579  */
1580 void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
1581                                   struct irq_chip *irqchip,
1582                                   unsigned int parent_irq,
1583                                   irq_flow_handler_t parent_handler)
1584 {
1585         if (gpiochip->irq.threaded) {
1586                 chip_err(gpiochip, "tried to chain a threaded gpiochip\n");
1587                 return;
1588         }
1589
1590         gpiochip_set_cascaded_irqchip(gpiochip, irqchip, parent_irq,
1591                                       parent_handler);
1592 }
1593 EXPORT_SYMBOL_GPL(gpiochip_set_chained_irqchip);
1594
1595 /**
1596  * gpiochip_set_nested_irqchip() - connects a nested irqchip to a gpiochip
1597  * @gpiochip: the gpiochip to set the irqchip nested handler to
1598  * @irqchip: the irqchip to nest to the gpiochip
1599  * @parent_irq: the irq number corresponding to the parent IRQ for this
1600  * nested irqchip
1601  */
1602 void gpiochip_set_nested_irqchip(struct gpio_chip *gpiochip,
1603                                  struct irq_chip *irqchip,
1604                                  unsigned int parent_irq)
1605 {
1606         gpiochip_set_cascaded_irqchip(gpiochip, irqchip, parent_irq,
1607                                       NULL);
1608 }
1609 EXPORT_SYMBOL_GPL(gpiochip_set_nested_irqchip);
1610
1611 /**
1612  * gpiochip_irq_map() - maps an IRQ into a GPIO irqchip
1613  * @d: the irqdomain used by this irqchip
1614  * @irq: the global irq number used by this GPIO irqchip irq
1615  * @hwirq: the local IRQ/GPIO line offset on this gpiochip
1616  *
1617  * This function will set up the mapping for a certain IRQ line on a
1618  * gpiochip by assigning the gpiochip as chip data, and using the irqchip
1619  * stored inside the gpiochip.
1620  */
1621 int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
1622                      irq_hw_number_t hwirq)
1623 {
1624         struct gpio_chip *chip = d->host_data;
1625         int err = 0;
1626
1627         if (!gpiochip_irqchip_irq_valid(chip, hwirq))
1628                 return -ENXIO;
1629
1630         irq_set_chip_data(irq, chip);
1631         /*
1632          * This lock class tells lockdep that GPIO irqs are in a different
1633          * category than their parents, so it won't report false recursion.
1634          */
1635         irq_set_lockdep_class(irq, chip->irq.lock_key);
1636         irq_set_chip_and_handler(irq, chip->irq.chip, chip->irq.handler);
1637         /* Chips that use nested thread handlers have them marked */
1638         if (chip->irq.threaded)
1639                 irq_set_nested_thread(irq, 1);
1640         irq_set_noprobe(irq);
1641
1642         if (chip->irq.num_parents == 1)
1643                 err = irq_set_parent(irq, chip->irq.parents[0]);
1644         else if (chip->irq.map)
1645                 err = irq_set_parent(irq, chip->irq.map[hwirq]);
1646
1647         if (err < 0)
1648                 return err;
1649
1650         /*
1651          * No set-up of the hardware will happen if IRQ_TYPE_NONE
1652          * is passed as default type.
1653          */
1654         if (chip->irq.default_type != IRQ_TYPE_NONE)
1655                 irq_set_irq_type(irq, chip->irq.default_type);
1656
1657         return 0;
1658 }
1659 EXPORT_SYMBOL_GPL(gpiochip_irq_map);
1660
1661 void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
1662 {
1663         struct gpio_chip *chip = d->host_data;
1664
1665         if (chip->irq.threaded)
1666                 irq_set_nested_thread(irq, 0);
1667         irq_set_chip_and_handler(irq, NULL, NULL);
1668         irq_set_chip_data(irq, NULL);
1669 }
1670 EXPORT_SYMBOL_GPL(gpiochip_irq_unmap);
1671
1672 static const struct irq_domain_ops gpiochip_domain_ops = {
1673         .map    = gpiochip_irq_map,
1674         .unmap  = gpiochip_irq_unmap,
1675         /* Virtually all GPIO irqchips are twocell:ed */
1676         .xlate  = irq_domain_xlate_twocell,
1677 };
1678
1679 static int gpiochip_irq_reqres(struct irq_data *d)
1680 {
1681         struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
1682
1683         if (!try_module_get(chip->gpiodev->owner))
1684                 return -ENODEV;
1685
1686         if (gpiochip_lock_as_irq(chip, d->hwirq)) {
1687                 chip_err(chip,
1688                         "unable to lock HW IRQ %lu for IRQ\n",
1689                         d->hwirq);
1690                 module_put(chip->gpiodev->owner);
1691                 return -EINVAL;
1692         }
1693         return 0;
1694 }
1695
1696 static void gpiochip_irq_relres(struct irq_data *d)
1697 {
1698         struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
1699
1700         gpiochip_unlock_as_irq(chip, d->hwirq);
1701         module_put(chip->gpiodev->owner);
1702 }
1703
1704 static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset)
1705 {
1706         if (!gpiochip_irqchip_irq_valid(chip, offset))
1707                 return -ENXIO;
1708
1709         return irq_create_mapping(chip->irq.domain, offset);
1710 }
1711
1712 /**
1713  * gpiochip_add_irqchip() - adds an IRQ chip to a GPIO chip
1714  * @gpiochip: the GPIO chip to add the IRQ chip to
1715  * @lock_key: lockdep class
1716  */
1717 static int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
1718                                 struct lock_class_key *lock_key)
1719 {
1720         struct irq_chip *irqchip = gpiochip->irq.chip;
1721         const struct irq_domain_ops *ops;
1722         struct device_node *np;
1723         unsigned int type;
1724         unsigned int i;
1725
1726         if (!irqchip)
1727                 return 0;
1728
1729         if (gpiochip->irq.parent_handler && gpiochip->can_sleep) {
1730                 chip_err(gpiochip, "you cannot have chained interrupts on a "
1731                          "chip that may sleep\n");
1732                 return -EINVAL;
1733         }
1734
1735         np = gpiochip->gpiodev->dev.of_node;
1736         type = gpiochip->irq.default_type;
1737
1738         /*
1739          * Specifying a default trigger is a terrible idea if DT or ACPI is
1740          * used to configure the interrupts, as you may end up with
1741          * conflicting triggers. Tell the user, and reset to NONE.
1742          */
1743         if (WARN(np && type != IRQ_TYPE_NONE,
1744                  "%s: Ignoring %u default trigger\n", np->full_name, type))
1745                 type = IRQ_TYPE_NONE;
1746
1747         if (has_acpi_companion(gpiochip->parent) && type != IRQ_TYPE_NONE) {
1748                 acpi_handle_warn(ACPI_HANDLE(gpiochip->parent),
1749                                  "Ignoring %u default trigger\n", type);
1750                 type = IRQ_TYPE_NONE;
1751         }
1752
1753         gpiochip->to_irq = gpiochip_to_irq;
1754         gpiochip->irq.default_type = type;
1755         gpiochip->irq.lock_key = lock_key;
1756
1757         if (gpiochip->irq.domain_ops)
1758                 ops = gpiochip->irq.domain_ops;
1759         else
1760                 ops = &gpiochip_domain_ops;
1761
1762         gpiochip->irq.domain = irq_domain_add_simple(np, gpiochip->ngpio,
1763                                                      gpiochip->irq.first,
1764                                                      ops, gpiochip);
1765         if (!gpiochip->irq.domain)
1766                 return -EINVAL;
1767
1768         /*
1769          * It is possible for a driver to override this, but only if the
1770          * alternative functions are both implemented.
1771          */
1772         if (!irqchip->irq_request_resources &&
1773             !irqchip->irq_release_resources) {
1774                 irqchip->irq_request_resources = gpiochip_irq_reqres;
1775                 irqchip->irq_release_resources = gpiochip_irq_relres;
1776         }
1777
1778         if (gpiochip->irq.parent_handler) {
1779                 void *data = gpiochip->irq.parent_handler_data ?: gpiochip;
1780
1781                 for (i = 0; i < gpiochip->irq.num_parents; i++) {
1782                         /*
1783                          * The parent IRQ chip is already using the chip_data
1784                          * for this IRQ chip, so our callbacks simply use the
1785                          * handler_data.
1786                          */
1787                         irq_set_chained_handler_and_data(gpiochip->irq.parents[i],
1788                                                          gpiochip->irq.parent_handler,
1789                                                          data);
1790                 }
1791         }
1792
1793         acpi_gpiochip_request_interrupts(gpiochip);
1794
1795         return 0;
1796 }
1797
1798 /**
1799  * gpiochip_irqchip_remove() - removes an irqchip added to a gpiochip
1800  * @gpiochip: the gpiochip to remove the irqchip from
1801  *
1802  * This is called only from gpiochip_remove()
1803  */
1804 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip)
1805 {
1806         unsigned int offset;
1807
1808         acpi_gpiochip_free_interrupts(gpiochip);
1809
1810         if (gpiochip->irq.chip && gpiochip->irq.parent_handler) {
1811                 struct gpio_irq_chip *irq = &gpiochip->irq;
1812                 unsigned int i;
1813
1814                 for (i = 0; i < irq->num_parents; i++)
1815                         irq_set_chained_handler_and_data(irq->parents[i],
1816                                                          NULL, NULL);
1817         }
1818
1819         /* Remove all IRQ mappings and delete the domain */
1820         if (gpiochip->irq.domain) {
1821                 unsigned int irq;
1822
1823                 for (offset = 0; offset < gpiochip->ngpio; offset++) {
1824                         if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
1825                                 continue;
1826
1827                         irq = irq_find_mapping(gpiochip->irq.domain, offset);
1828                         irq_dispose_mapping(irq);
1829                 }
1830
1831                 irq_domain_remove(gpiochip->irq.domain);
1832         }
1833
1834         if (gpiochip->irq.chip) {
1835                 gpiochip->irq.chip->irq_request_resources = NULL;
1836                 gpiochip->irq.chip->irq_release_resources = NULL;
1837                 gpiochip->irq.chip = NULL;
1838         }
1839
1840         gpiochip_irqchip_free_valid_mask(gpiochip);
1841 }
1842
1843 /**
1844  * gpiochip_irqchip_add_key() - adds an irqchip to a gpiochip
1845  * @gpiochip: the gpiochip to add the irqchip to
1846  * @irqchip: the irqchip to add to the gpiochip
1847  * @first_irq: if not dynamically assigned, the base (first) IRQ to
1848  * allocate gpiochip irqs from
1849  * @handler: the irq handler to use (often a predefined irq core function)
1850  * @type: the default type for IRQs on this irqchip, pass IRQ_TYPE_NONE
1851  * to have the core avoid setting up any default type in the hardware.
1852  * @threaded: whether this irqchip uses a nested thread handler
1853  * @lock_key: lockdep class
1854  *
1855  * This function closely associates a certain irqchip with a certain
1856  * gpiochip, providing an irq domain to translate the local IRQs to
1857  * global irqs in the gpiolib core, and making sure that the gpiochip
1858  * is passed as chip data to all related functions. Driver callbacks
1859  * need to use gpiochip_get_data() to get their local state containers back
1860  * from the gpiochip passed as chip data. An irqdomain will be stored
1861  * in the gpiochip that shall be used by the driver to handle IRQ number
1862  * translation. The gpiochip will need to be initialized and registered
1863  * before calling this function.
1864  *
1865  * This function will handle two cell:ed simple IRQs and assumes all
1866  * the pins on the gpiochip can generate a unique IRQ. Everything else
1867  * need to be open coded.
1868  */
1869 int gpiochip_irqchip_add_key(struct gpio_chip *gpiochip,
1870                              struct irq_chip *irqchip,
1871                              unsigned int first_irq,
1872                              irq_flow_handler_t handler,
1873                              unsigned int type,
1874                              bool threaded,
1875                              struct lock_class_key *lock_key)
1876 {
1877         struct device_node *of_node;
1878
1879         if (!gpiochip || !irqchip)
1880                 return -EINVAL;
1881
1882         if (!gpiochip->parent) {
1883                 pr_err("missing gpiochip .dev parent pointer\n");
1884                 return -EINVAL;
1885         }
1886         gpiochip->irq.threaded = threaded;
1887         of_node = gpiochip->parent->of_node;
1888 #ifdef CONFIG_OF_GPIO
1889         /*
1890          * If the gpiochip has an assigned OF node this takes precedence
1891          * FIXME: get rid of this and use gpiochip->parent->of_node
1892          * everywhere
1893          */
1894         if (gpiochip->of_node)
1895                 of_node = gpiochip->of_node;
1896 #endif
1897         /*
1898          * Specifying a default trigger is a terrible idea if DT or ACPI is
1899          * used to configure the interrupts, as you may end-up with
1900          * conflicting triggers. Tell the user, and reset to NONE.
1901          */
1902         if (WARN(of_node && type != IRQ_TYPE_NONE,
1903                  "%pOF: Ignoring %d default trigger\n", of_node, type))
1904                 type = IRQ_TYPE_NONE;
1905         if (has_acpi_companion(gpiochip->parent) && type != IRQ_TYPE_NONE) {
1906                 acpi_handle_warn(ACPI_HANDLE(gpiochip->parent),
1907                                  "Ignoring %d default trigger\n", type);
1908                 type = IRQ_TYPE_NONE;
1909         }
1910
1911         gpiochip->irq.chip = irqchip;
1912         gpiochip->irq.handler = handler;
1913         gpiochip->irq.default_type = type;
1914         gpiochip->to_irq = gpiochip_to_irq;
1915         gpiochip->irq.lock_key = lock_key;
1916         gpiochip->irq.domain = irq_domain_add_simple(of_node,
1917                                         gpiochip->ngpio, first_irq,
1918                                         &gpiochip_domain_ops, gpiochip);
1919         if (!gpiochip->irq.domain) {
1920                 gpiochip->irq.chip = NULL;
1921                 return -EINVAL;
1922         }
1923
1924         /*
1925          * It is possible for a driver to override this, but only if the
1926          * alternative functions are both implemented.
1927          */
1928         if (!irqchip->irq_request_resources &&
1929             !irqchip->irq_release_resources) {
1930                 irqchip->irq_request_resources = gpiochip_irq_reqres;
1931                 irqchip->irq_release_resources = gpiochip_irq_relres;
1932         }
1933
1934         acpi_gpiochip_request_interrupts(gpiochip);
1935
1936         return 0;
1937 }
1938 EXPORT_SYMBOL_GPL(gpiochip_irqchip_add_key);
1939
1940 #else /* CONFIG_GPIOLIB_IRQCHIP */
1941
1942 static inline int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
1943                                        struct lock_class_key *key)
1944 {
1945         return 0;
1946 }
1947
1948 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}
1949 static inline int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
1950 {
1951         return 0;
1952 }
1953 static inline void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip)
1954 { }
1955
1956 #endif /* CONFIG_GPIOLIB_IRQCHIP */
1957
1958 /**
1959  * gpiochip_generic_request() - request the gpio function for a pin
1960  * @chip: the gpiochip owning the GPIO
1961  * @offset: the offset of the GPIO to request for GPIO function
1962  */
1963 int gpiochip_generic_request(struct gpio_chip *chip, unsigned offset)
1964 {
1965         return pinctrl_gpio_request(chip->gpiodev->base + offset);
1966 }
1967 EXPORT_SYMBOL_GPL(gpiochip_generic_request);
1968
1969 /**
1970  * gpiochip_generic_free() - free the gpio function from a pin
1971  * @chip: the gpiochip to request the gpio function for
1972  * @offset: the offset of the GPIO to free from GPIO function
1973  */
1974 void gpiochip_generic_free(struct gpio_chip *chip, unsigned offset)
1975 {
1976         pinctrl_gpio_free(chip->gpiodev->base + offset);
1977 }
1978 EXPORT_SYMBOL_GPL(gpiochip_generic_free);
1979
1980 /**
1981  * gpiochip_generic_config() - apply configuration for a pin
1982  * @chip: the gpiochip owning the GPIO
1983  * @offset: the offset of the GPIO to apply the configuration
1984  * @config: the configuration to be applied
1985  */
1986 int gpiochip_generic_config(struct gpio_chip *chip, unsigned offset,
1987                             unsigned long config)
1988 {
1989         return pinctrl_gpio_set_config(chip->gpiodev->base + offset, config);
1990 }
1991 EXPORT_SYMBOL_GPL(gpiochip_generic_config);
1992
1993 #ifdef CONFIG_PINCTRL
1994
1995 /**
1996  * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
1997  * @chip: the gpiochip to add the range for
1998  * @pctldev: the pin controller to map to
1999  * @gpio_offset: the start offset in the current gpio_chip number space
2000  * @pin_group: name of the pin group inside the pin controller
2001  */
2002 int gpiochip_add_pingroup_range(struct gpio_chip *chip,
2003                         struct pinctrl_dev *pctldev,
2004                         unsigned int gpio_offset, const char *pin_group)
2005 {
2006         struct gpio_pin_range *pin_range;
2007         struct gpio_device *gdev = chip->gpiodev;
2008         int ret;
2009
2010         pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
2011         if (!pin_range) {
2012                 chip_err(chip, "failed to allocate pin ranges\n");
2013                 return -ENOMEM;
2014         }
2015
2016         /* Use local offset as range ID */
2017         pin_range->range.id = gpio_offset;
2018         pin_range->range.gc = chip;
2019         pin_range->range.name = chip->label;
2020         pin_range->range.base = gdev->base + gpio_offset;
2021         pin_range->pctldev = pctldev;
2022
2023         ret = pinctrl_get_group_pins(pctldev, pin_group,
2024                                         &pin_range->range.pins,
2025                                         &pin_range->range.npins);
2026         if (ret < 0) {
2027                 kfree(pin_range);
2028                 return ret;
2029         }
2030
2031         pinctrl_add_gpio_range(pctldev, &pin_range->range);
2032
2033         chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
2034                  gpio_offset, gpio_offset + pin_range->range.npins - 1,
2035                  pinctrl_dev_get_devname(pctldev), pin_group);
2036
2037         list_add_tail(&pin_range->node, &gdev->pin_ranges);
2038
2039         return 0;
2040 }
2041 EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);
2042
2043 /**
2044  * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
2045  * @chip: the gpiochip to add the range for
2046  * @pinctl_name: the dev_name() of the pin controller to map to
2047  * @gpio_offset: the start offset in the current gpio_chip number space
2048  * @pin_offset: the start offset in the pin controller number space
2049  * @npins: the number of pins from the offset of each pin space (GPIO and
2050  *      pin controller) to accumulate in this range
2051  *
2052  * Returns:
2053  * 0 on success, or a negative error-code on failure.
2054  */
2055 int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
2056                            unsigned int gpio_offset, unsigned int pin_offset,
2057                            unsigned int npins)
2058 {
2059         struct gpio_pin_range *pin_range;
2060         struct gpio_device *gdev = chip->gpiodev;
2061         int ret;
2062
2063         pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
2064         if (!pin_range) {
2065                 chip_err(chip, "failed to allocate pin ranges\n");
2066                 return -ENOMEM;
2067         }
2068
2069         /* Use local offset as range ID */
2070         pin_range->range.id = gpio_offset;
2071         pin_range->range.gc = chip;
2072         pin_range->range.name = chip->label;
2073         pin_range->range.base = gdev->base + gpio_offset;
2074         pin_range->range.pin_base = pin_offset;
2075         pin_range->range.npins = npins;
2076         pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
2077                         &pin_range->range);
2078         if (IS_ERR(pin_range->pctldev)) {
2079                 ret = PTR_ERR(pin_range->pctldev);
2080                 chip_err(chip, "could not create pin range\n");
2081                 kfree(pin_range);
2082                 return ret;
2083         }
2084         chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
2085                  gpio_offset, gpio_offset + npins - 1,
2086                  pinctl_name,
2087                  pin_offset, pin_offset + npins - 1);
2088
2089         list_add_tail(&pin_range->node, &gdev->pin_ranges);
2090
2091         return 0;
2092 }
2093 EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
2094
2095 /**
2096  * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
2097  * @chip: the chip to remove all the mappings for
2098  */
2099 void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
2100 {
2101         struct gpio_pin_range *pin_range, *tmp;
2102         struct gpio_device *gdev = chip->gpiodev;
2103
2104         list_for_each_entry_safe(pin_range, tmp, &gdev->pin_ranges, node) {
2105                 list_del(&pin_range->node);
2106                 pinctrl_remove_gpio_range(pin_range->pctldev,
2107                                 &pin_range->range);
2108                 kfree(pin_range);
2109         }
2110 }
2111 EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
2112
2113 #endif /* CONFIG_PINCTRL */
2114
2115 /* These "optional" allocation calls help prevent drivers from stomping
2116  * on each other, and help provide better diagnostics in debugfs.
2117  * They're called even less than the "set direction" calls.
2118  */
2119 static int gpiod_request_commit(struct gpio_desc *desc, const char *label)
2120 {
2121         struct gpio_chip        *chip = desc->gdev->chip;
2122         int                     status;
2123         unsigned long           flags;
2124
2125         spin_lock_irqsave(&gpio_lock, flags);
2126
2127         /* NOTE:  gpio_request() can be called in early boot,
2128          * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
2129          */
2130
2131         if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
2132                 desc_set_label(desc, label ? : "?");
2133                 status = 0;
2134         } else {
2135                 status = -EBUSY;
2136                 goto done;
2137         }
2138
2139         if (chip->request) {
2140                 /* chip->request may sleep */
2141                 spin_unlock_irqrestore(&gpio_lock, flags);
2142                 status = chip->request(chip, gpio_chip_hwgpio(desc));
2143                 spin_lock_irqsave(&gpio_lock, flags);
2144
2145                 if (status < 0) {
2146                         desc_set_label(desc, NULL);
2147                         clear_bit(FLAG_REQUESTED, &desc->flags);
2148                         goto done;
2149                 }
2150         }
2151         if (chip->get_direction) {
2152                 /* chip->get_direction may sleep */
2153                 spin_unlock_irqrestore(&gpio_lock, flags);
2154                 gpiod_get_direction(desc);
2155                 spin_lock_irqsave(&gpio_lock, flags);
2156         }
2157 done:
2158         spin_unlock_irqrestore(&gpio_lock, flags);
2159         return status;
2160 }
2161
2162 /*
2163  * This descriptor validation needs to be inserted verbatim into each
2164  * function taking a descriptor, so we need to use a preprocessor
2165  * macro to avoid endless duplication. If the desc is NULL it is an
2166  * optional GPIO and calls should just bail out.
2167  */
2168 #define VALIDATE_DESC(desc) do { \
2169         if (!desc) \
2170                 return 0; \
2171         if (IS_ERR(desc)) {                                             \
2172                 pr_warn("%s: invalid GPIO (errorpointer)\n", __func__); \
2173                 return PTR_ERR(desc); \
2174         } \
2175         if (!desc->gdev) { \
2176                 pr_warn("%s: invalid GPIO (no device)\n", __func__); \
2177                 return -EINVAL; \
2178         } \
2179         if ( !desc->gdev->chip ) { \
2180                 dev_warn(&desc->gdev->dev, \
2181                          "%s: backing chip is gone\n", __func__); \
2182                 return 0; \
2183         } } while (0)
2184
2185 #define VALIDATE_DESC_VOID(desc) do { \
2186         if (!desc) \
2187                 return; \
2188         if (IS_ERR(desc)) {                                             \
2189                 pr_warn("%s: invalid GPIO (errorpointer)\n", __func__); \
2190                 return; \
2191         } \
2192         if (!desc->gdev) { \
2193                 pr_warn("%s: invalid GPIO (no device)\n", __func__); \
2194                 return; \
2195         } \
2196         if (!desc->gdev->chip) { \
2197                 dev_warn(&desc->gdev->dev, \
2198                          "%s: backing chip is gone\n", __func__); \
2199                 return; \
2200         } } while (0)
2201
2202
2203 int gpiod_request(struct gpio_desc *desc, const char *label)
2204 {
2205         int status = -EPROBE_DEFER;
2206         struct gpio_device *gdev;
2207
2208         VALIDATE_DESC(desc);
2209         gdev = desc->gdev;
2210
2211         if (try_module_get(gdev->owner)) {
2212                 status = gpiod_request_commit(desc, label);
2213                 if (status < 0)
2214                         module_put(gdev->owner);
2215                 else
2216                         get_device(&gdev->dev);
2217         }
2218
2219         if (status)
2220                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
2221
2222         return status;
2223 }
2224
2225 static bool gpiod_free_commit(struct gpio_desc *desc)
2226 {
2227         bool                    ret = false;
2228         unsigned long           flags;
2229         struct gpio_chip        *chip;
2230
2231         might_sleep();
2232
2233         gpiod_unexport(desc);
2234
2235         spin_lock_irqsave(&gpio_lock, flags);
2236
2237         chip = desc->gdev->chip;
2238         if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
2239                 if (chip->free) {
2240                         spin_unlock_irqrestore(&gpio_lock, flags);
2241                         might_sleep_if(chip->can_sleep);
2242                         chip->free(chip, gpio_chip_hwgpio(desc));
2243                         spin_lock_irqsave(&gpio_lock, flags);
2244                 }
2245                 desc_set_label(desc, NULL);
2246                 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
2247                 clear_bit(FLAG_REQUESTED, &desc->flags);
2248                 clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
2249                 clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
2250                 clear_bit(FLAG_IS_HOGGED, &desc->flags);
2251                 ret = true;
2252         }
2253
2254         spin_unlock_irqrestore(&gpio_lock, flags);
2255         return ret;
2256 }
2257
2258 void gpiod_free(struct gpio_desc *desc)
2259 {
2260         if (desc && desc->gdev && gpiod_free_commit(desc)) {
2261                 module_put(desc->gdev->owner);
2262                 put_device(&desc->gdev->dev);
2263         } else {
2264                 WARN_ON(extra_checks);
2265         }
2266 }
2267
2268 /**
2269  * gpiochip_is_requested - return string iff signal was requested
2270  * @chip: controller managing the signal
2271  * @offset: of signal within controller's 0..(ngpio - 1) range
2272  *
2273  * Returns NULL if the GPIO is not currently requested, else a string.
2274  * The string returned is the label passed to gpio_request(); if none has been
2275  * passed it is a meaningless, non-NULL constant.
2276  *
2277  * This function is for use by GPIO controller drivers.  The label can
2278  * help with diagnostics, and knowing that the signal is used as a GPIO
2279  * can help avoid accidentally multiplexing it to another controller.
2280  */
2281 const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
2282 {
2283         struct gpio_desc *desc;
2284
2285         if (offset >= chip->ngpio)
2286                 return NULL;
2287
2288         desc = &chip->gpiodev->descs[offset];
2289
2290         if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
2291                 return NULL;
2292         return desc->label;
2293 }
2294 EXPORT_SYMBOL_GPL(gpiochip_is_requested);
2295
2296 /**
2297  * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor
2298  * @chip: GPIO chip
2299  * @hwnum: hardware number of the GPIO for which to request the descriptor
2300  * @label: label for the GPIO
2301  *
2302  * Function allows GPIO chip drivers to request and use their own GPIO
2303  * descriptors via gpiolib API. Difference to gpiod_request() is that this
2304  * function will not increase reference count of the GPIO chip module. This
2305  * allows the GPIO chip module to be unloaded as needed (we assume that the
2306  * GPIO chip driver handles freeing the GPIOs it has requested).
2307  *
2308  * Returns:
2309  * A pointer to the GPIO descriptor, or an ERR_PTR()-encoded negative error
2310  * code on failure.
2311  */
2312 struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *chip, u16 hwnum,
2313                                             const char *label)
2314 {
2315         struct gpio_desc *desc = gpiochip_get_desc(chip, hwnum);
2316         int err;
2317
2318         if (IS_ERR(desc)) {
2319                 chip_err(chip, "failed to get GPIO descriptor\n");
2320                 return desc;
2321         }
2322
2323         err = gpiod_request_commit(desc, label);
2324         if (err < 0)
2325                 return ERR_PTR(err);
2326
2327         return desc;
2328 }
2329 EXPORT_SYMBOL_GPL(gpiochip_request_own_desc);
2330
2331 /**
2332  * gpiochip_free_own_desc - Free GPIO requested by the chip driver
2333  * @desc: GPIO descriptor to free
2334  *
2335  * Function frees the given GPIO requested previously with
2336  * gpiochip_request_own_desc().
2337  */
2338 void gpiochip_free_own_desc(struct gpio_desc *desc)
2339 {
2340         if (desc)
2341                 gpiod_free_commit(desc);
2342 }
2343 EXPORT_SYMBOL_GPL(gpiochip_free_own_desc);
2344
2345 /*
2346  * Drivers MUST set GPIO direction before making get/set calls.  In
2347  * some cases this is done in early boot, before IRQs are enabled.
2348  *
2349  * As a rule these aren't called more than once (except for drivers
2350  * using the open-drain emulation idiom) so these are natural places
2351  * to accumulate extra debugging checks.  Note that we can't (yet)
2352  * rely on gpio_request() having been called beforehand.
2353  */
2354
2355 /**
2356  * gpiod_direction_input - set the GPIO direction to input
2357  * @desc:       GPIO to set to input
2358  *
2359  * Set the direction of the passed GPIO to input, such as gpiod_get_value() can
2360  * be called safely on it.
2361  *
2362  * Return 0 in case of success, else an error code.
2363  */
2364 int gpiod_direction_input(struct gpio_desc *desc)
2365 {
2366         struct gpio_chip        *chip;
2367         int                     status = -EINVAL;
2368
2369         VALIDATE_DESC(desc);
2370         chip = desc->gdev->chip;
2371
2372         if (!chip->get || !chip->direction_input) {
2373                 gpiod_warn(desc,
2374                         "%s: missing get() or direction_input() operations\n",
2375                         __func__);
2376                 return -EIO;
2377         }
2378
2379         status = chip->direction_input(chip, gpio_chip_hwgpio(desc));
2380         if (status == 0)
2381                 clear_bit(FLAG_IS_OUT, &desc->flags);
2382
2383         trace_gpio_direction(desc_to_gpio(desc), 1, status);
2384
2385         return status;
2386 }
2387 EXPORT_SYMBOL_GPL(gpiod_direction_input);
2388
2389 static int gpio_set_drive_single_ended(struct gpio_chip *gc, unsigned offset,
2390                                        enum pin_config_param mode)
2391 {
2392         unsigned long config = { PIN_CONF_PACKED(mode, 0) };
2393
2394         return gc->set_config ? gc->set_config(gc, offset, config) : -ENOTSUPP;
2395 }
2396
2397 static int gpiod_direction_output_raw_commit(struct gpio_desc *desc, int value)
2398 {
2399         struct gpio_chip *gc = desc->gdev->chip;
2400         int val = !!value;
2401         int ret;
2402
2403         if (!gc->set || !gc->direction_output) {
2404                 gpiod_warn(desc,
2405                        "%s: missing set() or direction_output() operations\n",
2406                        __func__);
2407                 return -EIO;
2408         }
2409
2410         ret = gc->direction_output(gc, gpio_chip_hwgpio(desc), val);
2411         if (!ret)
2412                 set_bit(FLAG_IS_OUT, &desc->flags);
2413         trace_gpio_value(desc_to_gpio(desc), 0, val);
2414         trace_gpio_direction(desc_to_gpio(desc), 0, ret);
2415         return ret;
2416 }
2417
2418 /**
2419  * gpiod_direction_output_raw - set the GPIO direction to output
2420  * @desc:       GPIO to set to output
2421  * @value:      initial output value of the GPIO
2422  *
2423  * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
2424  * be called safely on it. The initial value of the output must be specified
2425  * as raw value on the physical line without regard for the ACTIVE_LOW status.
2426  *
2427  * Return 0 in case of success, else an error code.
2428  */
2429 int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
2430 {
2431         VALIDATE_DESC(desc);
2432         return gpiod_direction_output_raw_commit(desc, value);
2433 }
2434 EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);
2435
2436 /**
2437  * gpiod_direction_output - set the GPIO direction to output
2438  * @desc:       GPIO to set to output
2439  * @value:      initial output value of the GPIO
2440  *
2441  * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
2442  * be called safely on it. The initial value of the output must be specified
2443  * as the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2444  * account.
2445  *
2446  * Return 0 in case of success, else an error code.
2447  */
2448 int gpiod_direction_output(struct gpio_desc *desc, int value)
2449 {
2450         struct gpio_chip *gc = desc->gdev->chip;
2451         int ret;
2452
2453         VALIDATE_DESC(desc);
2454         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2455                 value = !value;
2456         else
2457                 value = !!value;
2458
2459         /* GPIOs used for IRQs shall not be set as output */
2460         if (test_bit(FLAG_USED_AS_IRQ, &desc->flags)) {
2461                 gpiod_err(desc,
2462                           "%s: tried to set a GPIO tied to an IRQ as output\n",
2463                           __func__);
2464                 return -EIO;
2465         }
2466
2467         if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
2468                 /* First see if we can enable open drain in hardware */
2469                 ret = gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
2470                                                   PIN_CONFIG_DRIVE_OPEN_DRAIN);
2471                 if (!ret)
2472                         goto set_output_value;
2473                 /* Emulate open drain by not actively driving the line high */
2474                 if (value)
2475                         return gpiod_direction_input(desc);
2476         }
2477         else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
2478                 ret = gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
2479                                                   PIN_CONFIG_DRIVE_OPEN_SOURCE);
2480                 if (!ret)
2481                         goto set_output_value;
2482                 /* Emulate open source by not actively driving the line low */
2483                 if (!value)
2484                         return gpiod_direction_input(desc);
2485         } else {
2486                 gpio_set_drive_single_ended(gc, gpio_chip_hwgpio(desc),
2487                                             PIN_CONFIG_DRIVE_PUSH_PULL);
2488         }
2489
2490 set_output_value:
2491         return gpiod_direction_output_raw_commit(desc, value);
2492 }
2493 EXPORT_SYMBOL_GPL(gpiod_direction_output);
2494
2495 /**
2496  * gpiod_set_debounce - sets @debounce time for a GPIO
2497  * @desc: descriptor of the GPIO for which to set debounce time
2498  * @debounce: debounce time in microseconds
2499  *
2500  * Returns:
2501  * 0 on success, %-ENOTSUPP if the controller doesn't support setting the
2502  * debounce time.
2503  */
2504 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
2505 {
2506         struct gpio_chip        *chip;
2507         unsigned long           config;
2508
2509         VALIDATE_DESC(desc);
2510         chip = desc->gdev->chip;
2511         if (!chip->set || !chip->set_config) {
2512                 gpiod_dbg(desc,
2513                           "%s: missing set() or set_config() operations\n",
2514                           __func__);
2515                 return -ENOTSUPP;
2516         }
2517
2518         config = pinconf_to_config_packed(PIN_CONFIG_INPUT_DEBOUNCE, debounce);
2519         return chip->set_config(chip, gpio_chip_hwgpio(desc), config);
2520 }
2521 EXPORT_SYMBOL_GPL(gpiod_set_debounce);
2522
2523 /**
2524  * gpiod_is_active_low - test whether a GPIO is active-low or not
2525  * @desc: the gpio descriptor to test
2526  *
2527  * Returns 1 if the GPIO is active-low, 0 otherwise.
2528  */
2529 int gpiod_is_active_low(const struct gpio_desc *desc)
2530 {
2531         VALIDATE_DESC(desc);
2532         return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
2533 }
2534 EXPORT_SYMBOL_GPL(gpiod_is_active_low);
2535
2536 /* I/O calls are only valid after configuration completed; the relevant
2537  * "is this a valid GPIO" error checks should already have been done.
2538  *
2539  * "Get" operations are often inlinable as reading a pin value register,
2540  * and masking the relevant bit in that register.
2541  *
2542  * When "set" operations are inlinable, they involve writing that mask to
2543  * one register to set a low value, or a different register to set it high.
2544  * Otherwise locking is needed, so there may be little value to inlining.
2545  *
2546  *------------------------------------------------------------------------
2547  *
2548  * IMPORTANT!!!  The hot paths -- get/set value -- assume that callers
2549  * have requested the GPIO.  That can include implicit requesting by
2550  * a direction setting call.  Marking a gpio as requested locks its chip
2551  * in memory, guaranteeing that these table lookups need no more locking
2552  * and that gpiochip_remove() will fail.
2553  *
2554  * REVISIT when debugging, consider adding some instrumentation to ensure
2555  * that the GPIO was actually requested.
2556  */
2557
2558 static int gpiod_get_raw_value_commit(const struct gpio_desc *desc)
2559 {
2560         struct gpio_chip        *chip;
2561         int offset;
2562         int value;
2563
2564         chip = desc->gdev->chip;
2565         offset = gpio_chip_hwgpio(desc);
2566         value = chip->get ? chip->get(chip, offset) : -EIO;
2567         value = value < 0 ? value : !!value;
2568         trace_gpio_value(desc_to_gpio(desc), 1, value);
2569         return value;
2570 }
2571
2572 static int gpio_chip_get_multiple(struct gpio_chip *chip,
2573                                   unsigned long *mask, unsigned long *bits)
2574 {
2575         if (chip->get_multiple) {
2576                 return chip->get_multiple(chip, mask, bits);
2577         } else if (chip->get) {
2578                 int i, value;
2579
2580                 for_each_set_bit(i, mask, chip->ngpio) {
2581                         value = chip->get(chip, i);
2582                         if (value < 0)
2583                                 return value;
2584                         __assign_bit(i, bits, value);
2585                 }
2586                 return 0;
2587         }
2588         return -EIO;
2589 }
2590
2591 int gpiod_get_array_value_complex(bool raw, bool can_sleep,
2592                                   unsigned int array_size,
2593                                   struct gpio_desc **desc_array,
2594                                   int *value_array)
2595 {
2596         int i = 0;
2597
2598         while (i < array_size) {
2599                 struct gpio_chip *chip = desc_array[i]->gdev->chip;
2600                 unsigned long mask[BITS_TO_LONGS(chip->ngpio)];
2601                 unsigned long bits[BITS_TO_LONGS(chip->ngpio)];
2602                 int first, j, ret;
2603
2604                 if (!can_sleep)
2605                         WARN_ON(chip->can_sleep);
2606
2607                 /* collect all inputs belonging to the same chip */
2608                 first = i;
2609                 memset(mask, 0, sizeof(mask));
2610                 do {
2611                         const struct gpio_desc *desc = desc_array[i];
2612                         int hwgpio = gpio_chip_hwgpio(desc);
2613
2614                         __set_bit(hwgpio, mask);
2615                         i++;
2616                 } while ((i < array_size) &&
2617                          (desc_array[i]->gdev->chip == chip));
2618
2619                 ret = gpio_chip_get_multiple(chip, mask, bits);
2620                 if (ret)
2621                         return ret;
2622
2623                 for (j = first; j < i; j++) {
2624                         const struct gpio_desc *desc = desc_array[j];
2625                         int hwgpio = gpio_chip_hwgpio(desc);
2626                         int value = test_bit(hwgpio, bits);
2627
2628                         if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2629                                 value = !value;
2630                         value_array[j] = value;
2631                         trace_gpio_value(desc_to_gpio(desc), 1, value);
2632                 }
2633         }
2634         return 0;
2635 }
2636
2637 /**
2638  * gpiod_get_raw_value() - return a gpio's raw value
2639  * @desc: gpio whose value will be returned
2640  *
2641  * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2642  * its ACTIVE_LOW status, or negative errno on failure.
2643  *
2644  * This function should be called from contexts where we cannot sleep, and will
2645  * complain if the GPIO chip functions potentially sleep.
2646  */
2647 int gpiod_get_raw_value(const struct gpio_desc *desc)
2648 {
2649         VALIDATE_DESC(desc);
2650         /* Should be using gpio_get_value_cansleep() */
2651         WARN_ON(desc->gdev->chip->can_sleep);
2652         return gpiod_get_raw_value_commit(desc);
2653 }
2654 EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
2655
2656 /**
2657  * gpiod_get_value() - return a gpio's value
2658  * @desc: gpio whose value will be returned
2659  *
2660  * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
2661  * account, or negative errno on failure.
2662  *
2663  * This function should be called from contexts where we cannot sleep, and will
2664  * complain if the GPIO chip functions potentially sleep.
2665  */
2666 int gpiod_get_value(const struct gpio_desc *desc)
2667 {
2668         int value;
2669
2670         VALIDATE_DESC(desc);
2671         /* Should be using gpio_get_value_cansleep() */
2672         WARN_ON(desc->gdev->chip->can_sleep);
2673
2674         value = gpiod_get_raw_value_commit(desc);
2675         if (value < 0)
2676                 return value;
2677
2678         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2679                 value = !value;
2680
2681         return value;
2682 }
2683 EXPORT_SYMBOL_GPL(gpiod_get_value);
2684
2685 /**
2686  * gpiod_get_raw_array_value() - read raw values from an array of GPIOs
2687  * @array_size: number of elements in the descriptor / value arrays
2688  * @desc_array: array of GPIO descriptors whose values will be read
2689  * @value_array: array to store the read values
2690  *
2691  * Read the raw values of the GPIOs, i.e. the values of the physical lines
2692  * without regard for their ACTIVE_LOW status.  Return 0 in case of success,
2693  * else an error code.
2694  *
2695  * This function should be called from contexts where we cannot sleep,
2696  * and it will complain if the GPIO chip functions potentially sleep.
2697  */
2698 int gpiod_get_raw_array_value(unsigned int array_size,
2699                               struct gpio_desc **desc_array, int *value_array)
2700 {
2701         if (!desc_array)
2702                 return -EINVAL;
2703         return gpiod_get_array_value_complex(true, false, array_size,
2704                                              desc_array, value_array);
2705 }
2706 EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value);
2707
2708 /**
2709  * gpiod_get_array_value() - read values from an array of GPIOs
2710  * @array_size: number of elements in the descriptor / value arrays
2711  * @desc_array: array of GPIO descriptors whose values will be read
2712  * @value_array: array to store the read values
2713  *
2714  * Read the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
2715  * into account.  Return 0 in case of success, else an error code.
2716  *
2717  * This function should be called from contexts where we cannot sleep,
2718  * and it will complain if the GPIO chip functions potentially sleep.
2719  */
2720 int gpiod_get_array_value(unsigned int array_size,
2721                           struct gpio_desc **desc_array, int *value_array)
2722 {
2723         if (!desc_array)
2724                 return -EINVAL;
2725         return gpiod_get_array_value_complex(false, false, array_size,
2726                                              desc_array, value_array);
2727 }
2728 EXPORT_SYMBOL_GPL(gpiod_get_array_value);
2729
2730 /*
2731  *  gpio_set_open_drain_value_commit() - Set the open drain gpio's value.
2732  * @desc: gpio descriptor whose state need to be set.
2733  * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
2734  */
2735 static void gpio_set_open_drain_value_commit(struct gpio_desc *desc, bool value)
2736 {
2737         int err = 0;
2738         struct gpio_chip *chip = desc->gdev->chip;
2739         int offset = gpio_chip_hwgpio(desc);
2740
2741         if (value) {
2742                 err = chip->direction_input(chip, offset);
2743                 if (!err)
2744                         clear_bit(FLAG_IS_OUT, &desc->flags);
2745         } else {
2746                 err = chip->direction_output(chip, offset, 0);
2747                 if (!err)
2748                         set_bit(FLAG_IS_OUT, &desc->flags);
2749         }
2750         trace_gpio_direction(desc_to_gpio(desc), value, err);
2751         if (err < 0)
2752                 gpiod_err(desc,
2753                           "%s: Error in set_value for open drain err %d\n",
2754                           __func__, err);
2755 }
2756
2757 /*
2758  *  _gpio_set_open_source_value() - Set the open source gpio's value.
2759  * @desc: gpio descriptor whose state need to be set.
2760  * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
2761  */
2762 static void gpio_set_open_source_value_commit(struct gpio_desc *desc, bool value)
2763 {
2764         int err = 0;
2765         struct gpio_chip *chip = desc->gdev->chip;
2766         int offset = gpio_chip_hwgpio(desc);
2767
2768         if (value) {
2769                 err = chip->direction_output(chip, offset, 1);
2770                 if (!err)
2771                         set_bit(FLAG_IS_OUT, &desc->flags);
2772         } else {
2773                 err = chip->direction_input(chip, offset);
2774                 if (!err)
2775                         clear_bit(FLAG_IS_OUT, &desc->flags);
2776         }
2777         trace_gpio_direction(desc_to_gpio(desc), !value, err);
2778         if (err < 0)
2779                 gpiod_err(desc,
2780                           "%s: Error in set_value for open source err %d\n",
2781                           __func__, err);
2782 }
2783
2784 static void gpiod_set_raw_value_commit(struct gpio_desc *desc, bool value)
2785 {
2786         struct gpio_chip        *chip;
2787
2788         chip = desc->gdev->chip;
2789         trace_gpio_value(desc_to_gpio(desc), 0, value);
2790         chip->set(chip, gpio_chip_hwgpio(desc), value);
2791 }
2792
2793 /*
2794  * set multiple outputs on the same chip;
2795  * use the chip's set_multiple function if available;
2796  * otherwise set the outputs sequentially;
2797  * @mask: bit mask array; one bit per output; BITS_PER_LONG bits per word
2798  *        defines which outputs are to be changed
2799  * @bits: bit value array; one bit per output; BITS_PER_LONG bits per word
2800  *        defines the values the outputs specified by mask are to be set to
2801  */
2802 static void gpio_chip_set_multiple(struct gpio_chip *chip,
2803                                    unsigned long *mask, unsigned long *bits)
2804 {
2805         if (chip->set_multiple) {
2806                 chip->set_multiple(chip, mask, bits);
2807         } else {
2808                 unsigned int i;
2809
2810                 /* set outputs if the corresponding mask bit is set */
2811                 for_each_set_bit(i, mask, chip->ngpio)
2812                         chip->set(chip, i, test_bit(i, bits));
2813         }
2814 }
2815
2816 void gpiod_set_array_value_complex(bool raw, bool can_sleep,
2817                                    unsigned int array_size,
2818                                    struct gpio_desc **desc_array,
2819                                    int *value_array)
2820 {
2821         int i = 0;
2822
2823         while (i < array_size) {
2824                 struct gpio_chip *chip = desc_array[i]->gdev->chip;
2825                 unsigned long mask[BITS_TO_LONGS(chip->ngpio)];
2826                 unsigned long bits[BITS_TO_LONGS(chip->ngpio)];
2827                 int count = 0;
2828
2829                 if (!can_sleep)
2830                         WARN_ON(chip->can_sleep);
2831
2832                 memset(mask, 0, sizeof(mask));
2833                 do {
2834                         struct gpio_desc *desc = desc_array[i];
2835                         int hwgpio = gpio_chip_hwgpio(desc);
2836                         int value = value_array[i];
2837
2838                         if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2839                                 value = !value;
2840                         trace_gpio_value(desc_to_gpio(desc), 0, value);
2841                         /*
2842                          * collect all normal outputs belonging to the same chip
2843                          * open drain and open source outputs are set individually
2844                          */
2845                         if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) && !raw) {
2846                                 gpio_set_open_drain_value_commit(desc, value);
2847                         } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags) && !raw) {
2848                                 gpio_set_open_source_value_commit(desc, value);
2849                         } else {
2850                                 __set_bit(hwgpio, mask);
2851                                 if (value)
2852                                         __set_bit(hwgpio, bits);
2853                                 else
2854                                         __clear_bit(hwgpio, bits);
2855                                 count++;
2856                         }
2857                         i++;
2858                 } while ((i < array_size) &&
2859                          (desc_array[i]->gdev->chip == chip));
2860                 /* push collected bits to outputs */
2861                 if (count != 0)
2862                         gpio_chip_set_multiple(chip, mask, bits);
2863         }
2864 }
2865
2866 /**
2867  * gpiod_set_raw_value() - assign a gpio's raw value
2868  * @desc: gpio whose value will be assigned
2869  * @value: value to assign
2870  *
2871  * Set the raw value of the GPIO, i.e. the value of its physical line without
2872  * regard for its ACTIVE_LOW status.
2873  *
2874  * This function should be called from contexts where we cannot sleep, and will
2875  * complain if the GPIO chip functions potentially sleep.
2876  */
2877 void gpiod_set_raw_value(struct gpio_desc *desc, int value)
2878 {
2879         VALIDATE_DESC_VOID(desc);
2880         /* Should be using gpiod_set_value_cansleep() */
2881         WARN_ON(desc->gdev->chip->can_sleep);
2882         gpiod_set_raw_value_commit(desc, value);
2883 }
2884 EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
2885
2886 /**
2887  * gpiod_set_value() - assign a gpio's value
2888  * @desc: gpio whose value will be assigned
2889  * @value: value to assign
2890  *
2891  * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW,
2892  * OPEN_DRAIN and OPEN_SOURCE flags into account.
2893  *
2894  * This function should be called from contexts where we cannot sleep, and will
2895  * complain if the GPIO chip functions potentially sleep.
2896  */
2897 void gpiod_set_value(struct gpio_desc *desc, int value)
2898 {
2899         VALIDATE_DESC_VOID(desc);
2900         /* Should be using gpiod_set_value_cansleep() */
2901         WARN_ON(desc->gdev->chip->can_sleep);
2902         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2903                 value = !value;
2904         if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
2905                 gpio_set_open_drain_value_commit(desc, value);
2906         else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
2907                 gpio_set_open_source_value_commit(desc, value);
2908         else
2909                 gpiod_set_raw_value_commit(desc, value);
2910 }
2911 EXPORT_SYMBOL_GPL(gpiod_set_value);
2912
2913 /**
2914  * gpiod_set_raw_array_value() - assign values to an array of GPIOs
2915  * @array_size: number of elements in the descriptor / value arrays
2916  * @desc_array: array of GPIO descriptors whose values will be assigned
2917  * @value_array: array of values to assign
2918  *
2919  * Set the raw values of the GPIOs, i.e. the values of the physical lines
2920  * without regard for their ACTIVE_LOW status.
2921  *
2922  * This function should be called from contexts where we cannot sleep, and will
2923  * complain if the GPIO chip functions potentially sleep.
2924  */
2925 void gpiod_set_raw_array_value(unsigned int array_size,
2926                          struct gpio_desc **desc_array, int *value_array)
2927 {
2928         if (!desc_array)
2929                 return;
2930         gpiod_set_array_value_complex(true, false, array_size, desc_array,
2931                                       value_array);
2932 }
2933 EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value);
2934
2935 /**
2936  * gpiod_set_array_value() - assign values to an array of GPIOs
2937  * @array_size: number of elements in the descriptor / value arrays
2938  * @desc_array: array of GPIO descriptors whose values will be assigned
2939  * @value_array: array of values to assign
2940  *
2941  * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
2942  * into account.
2943  *
2944  * This function should be called from contexts where we cannot sleep, and will
2945  * complain if the GPIO chip functions potentially sleep.
2946  */
2947 void gpiod_set_array_value(unsigned int array_size,
2948                            struct gpio_desc **desc_array, int *value_array)
2949 {
2950         if (!desc_array)
2951                 return;
2952         gpiod_set_array_value_complex(false, false, array_size, desc_array,
2953                                       value_array);
2954 }
2955 EXPORT_SYMBOL_GPL(gpiod_set_array_value);
2956
2957 /**
2958  * gpiod_cansleep() - report whether gpio value access may sleep
2959  * @desc: gpio to check
2960  *
2961  */
2962 int gpiod_cansleep(const struct gpio_desc *desc)
2963 {
2964         VALIDATE_DESC(desc);
2965         return desc->gdev->chip->can_sleep;
2966 }
2967 EXPORT_SYMBOL_GPL(gpiod_cansleep);
2968
2969 /**
2970  * gpiod_to_irq() - return the IRQ corresponding to a GPIO
2971  * @desc: gpio whose IRQ will be returned (already requested)
2972  *
2973  * Return the IRQ corresponding to the passed GPIO, or an error code in case of
2974  * error.
2975  */
2976 int gpiod_to_irq(const struct gpio_desc *desc)
2977 {
2978         struct gpio_chip *chip;
2979         int offset;
2980
2981         /*
2982          * Cannot VALIDATE_DESC() here as gpiod_to_irq() consumer semantics
2983          * requires this function to not return zero on an invalid descriptor
2984          * but rather a negative error number.
2985          */
2986         if (!desc || IS_ERR(desc) || !desc->gdev || !desc->gdev->chip)
2987                 return -EINVAL;
2988
2989         chip = desc->gdev->chip;
2990         offset = gpio_chip_hwgpio(desc);
2991         if (chip->to_irq) {
2992                 int retirq = chip->to_irq(chip, offset);
2993
2994                 /* Zero means NO_IRQ */
2995                 if (!retirq)
2996                         return -ENXIO;
2997
2998                 return retirq;
2999         }
3000         return -ENXIO;
3001 }
3002 EXPORT_SYMBOL_GPL(gpiod_to_irq);
3003
3004 /**
3005  * gpiochip_lock_as_irq() - lock a GPIO to be used as IRQ
3006  * @chip: the chip the GPIO to lock belongs to
3007  * @offset: the offset of the GPIO to lock as IRQ
3008  *
3009  * This is used directly by GPIO drivers that want to lock down
3010  * a certain GPIO line to be used for IRQs.
3011  */
3012 int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
3013 {
3014         struct gpio_desc *desc;
3015
3016         desc = gpiochip_get_desc(chip, offset);
3017         if (IS_ERR(desc))
3018                 return PTR_ERR(desc);
3019
3020         /*
3021          * If it's fast: flush the direction setting if something changed
3022          * behind our back
3023          */
3024         if (!chip->can_sleep && chip->get_direction) {
3025                 int dir = chip->get_direction(chip, offset);
3026
3027                 if (dir)
3028                         clear_bit(FLAG_IS_OUT, &desc->flags);
3029                 else
3030                         set_bit(FLAG_IS_OUT, &desc->flags);
3031         }
3032
3033         if (test_bit(FLAG_IS_OUT, &desc->flags)) {
3034                 chip_err(chip,
3035                           "%s: tried to flag a GPIO set as output for IRQ\n",
3036                           __func__);
3037                 return -EIO;
3038         }
3039
3040         set_bit(FLAG_USED_AS_IRQ, &desc->flags);
3041
3042         /*
3043          * If the consumer has not set up a label (such as when the
3044          * IRQ is referenced from .to_irq()) we set up a label here
3045          * so it is clear this is used as an interrupt.
3046          */
3047         if (!desc->label)
3048                 desc_set_label(desc, "interrupt");
3049
3050         return 0;
3051 }
3052 EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq);
3053
3054 /**
3055  * gpiochip_unlock_as_irq() - unlock a GPIO used as IRQ
3056  * @chip: the chip the GPIO to lock belongs to
3057  * @offset: the offset of the GPIO to lock as IRQ
3058  *
3059  * This is used directly by GPIO drivers that want to indicate
3060  * that a certain GPIO is no longer used exclusively for IRQ.
3061  */
3062 void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
3063 {
3064         struct gpio_desc *desc;
3065
3066         desc = gpiochip_get_desc(chip, offset);
3067         if (IS_ERR(desc))
3068                 return;
3069
3070         clear_bit(FLAG_USED_AS_IRQ, &desc->flags);
3071
3072         /* If we only had this marking, erase it */
3073         if (desc->label && !strcmp(desc->label, "interrupt"))
3074                 desc_set_label(desc, NULL);
3075 }
3076 EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq);
3077
3078 bool gpiochip_line_is_irq(struct gpio_chip *chip, unsigned int offset)
3079 {
3080         if (offset >= chip->ngpio)
3081                 return false;
3082
3083         return test_bit(FLAG_USED_AS_IRQ, &chip->gpiodev->descs[offset].flags);
3084 }
3085 EXPORT_SYMBOL_GPL(gpiochip_line_is_irq);
3086
3087 bool gpiochip_line_is_open_drain(struct gpio_chip *chip, unsigned int offset)
3088 {
3089         if (offset >= chip->ngpio)
3090                 return false;
3091
3092         return test_bit(FLAG_OPEN_DRAIN, &chip->gpiodev->descs[offset].flags);
3093 }
3094 EXPORT_SYMBOL_GPL(gpiochip_line_is_open_drain);
3095
3096 bool gpiochip_line_is_open_source(struct gpio_chip *chip, unsigned int offset)
3097 {
3098         if (offset >= chip->ngpio)
3099                 return false;
3100
3101         return test_bit(FLAG_OPEN_SOURCE, &chip->gpiodev->descs[offset].flags);
3102 }
3103 EXPORT_SYMBOL_GPL(gpiochip_line_is_open_source);
3104
3105 bool gpiochip_line_is_persistent(struct gpio_chip *chip, unsigned int offset)
3106 {
3107         if (offset >= chip->ngpio)
3108                 return false;
3109
3110         return !test_bit(FLAG_SLEEP_MAY_LOSE_VALUE,
3111                          &chip->gpiodev->descs[offset].flags);
3112 }
3113 EXPORT_SYMBOL_GPL(gpiochip_line_is_persistent);
3114
3115 /**
3116  * gpiod_get_raw_value_cansleep() - return a gpio's raw value
3117  * @desc: gpio whose value will be returned
3118  *
3119  * Return the GPIO's raw value, i.e. the value of the physical line disregarding
3120  * its ACTIVE_LOW status, or negative errno on failure.
3121  *
3122  * This function is to be called from contexts that can sleep.
3123  */
3124 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
3125 {
3126         might_sleep_if(extra_checks);
3127         VALIDATE_DESC(desc);
3128         return gpiod_get_raw_value_commit(desc);
3129 }
3130 EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
3131
3132 /**
3133  * gpiod_get_value_cansleep() - return a gpio's value
3134  * @desc: gpio whose value will be returned
3135  *
3136  * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
3137  * account, or negative errno on failure.
3138  *
3139  * This function is to be called from contexts that can sleep.
3140  */
3141 int gpiod_get_value_cansleep(const struct gpio_desc *desc)
3142 {
3143         int value;
3144
3145         might_sleep_if(extra_checks);
3146         VALIDATE_DESC(desc);
3147         value = gpiod_get_raw_value_commit(desc);
3148         if (value < 0)
3149                 return value;
3150
3151         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
3152                 value = !value;
3153
3154         return value;
3155 }
3156 EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
3157
3158 /**
3159  * gpiod_get_raw_array_value_cansleep() - read raw values from an array of GPIOs
3160  * @array_size: number of elements in the descriptor / value arrays
3161  * @desc_array: array of GPIO descriptors whose values will be read
3162  * @value_array: array to store the read values
3163  *
3164  * Read the raw values of the GPIOs, i.e. the values of the physical lines
3165  * without regard for their ACTIVE_LOW status.  Return 0 in case of success,
3166  * else an error code.
3167  *
3168  * This function is to be called from contexts that can sleep.
3169  */
3170 int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
3171                                        struct gpio_desc **desc_array,
3172                                        int *value_array)
3173 {
3174         might_sleep_if(extra_checks);
3175         if (!desc_array)
3176                 return -EINVAL;
3177         return gpiod_get_array_value_complex(true, true, array_size,
3178                                              desc_array, value_array);
3179 }
3180 EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value_cansleep);
3181
3182 /**
3183  * gpiod_get_array_value_cansleep() - read values from an array of GPIOs
3184  * @array_size: number of elements in the descriptor / value arrays
3185  * @desc_array: array of GPIO descriptors whose values will be read
3186  * @value_array: array to store the read values
3187  *
3188  * Read the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
3189  * into account.  Return 0 in case of success, else an error code.
3190  *
3191  * This function is to be called from contexts that can sleep.
3192  */
3193 int gpiod_get_array_value_cansleep(unsigned int array_size,
3194                                    struct gpio_desc **desc_array,
3195                                    int *value_array)
3196 {
3197         might_sleep_if(extra_checks);
3198         if (!desc_array)
3199                 return -EINVAL;
3200         return gpiod_get_array_value_complex(false, true, array_size,
3201                                              desc_array, value_array);
3202 }
3203 EXPORT_SYMBOL_GPL(gpiod_get_array_value_cansleep);
3204
3205 /**
3206  * gpiod_set_raw_value_cansleep() - assign a gpio's raw value
3207  * @desc: gpio whose value will be assigned
3208  * @value: value to assign
3209  *
3210  * Set the raw value of the GPIO, i.e. the value of its physical line without
3211  * regard for its ACTIVE_LOW status.
3212  *
3213  * This function is to be called from contexts that can sleep.
3214  */
3215 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value)
3216 {
3217         might_sleep_if(extra_checks);
3218         VALIDATE_DESC_VOID(desc);
3219         gpiod_set_raw_value_commit(desc, value);
3220 }
3221 EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
3222
3223 /**
3224  * gpiod_set_value_cansleep() - assign a gpio's value
3225  * @desc: gpio whose value will be assigned
3226  * @value: value to assign
3227  *
3228  * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
3229  * account
3230  *
3231  * This function is to be called from contexts that can sleep.
3232  */
3233 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
3234 {
3235         might_sleep_if(extra_checks);
3236         VALIDATE_DESC_VOID(desc);
3237         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
3238                 value = !value;
3239         gpiod_set_raw_value_commit(desc, value);
3240 }
3241 EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
3242
3243 /**
3244  * gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs
3245  * @array_size: number of elements in the descriptor / value arrays
3246  * @desc_array: array of GPIO descriptors whose values will be assigned
3247  * @value_array: array of values to assign
3248  *
3249  * Set the raw values of the GPIOs, i.e. the values of the physical lines
3250  * without regard for their ACTIVE_LOW status.
3251  *
3252  * This function is to be called from contexts that can sleep.
3253  */
3254 void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
3255                                         struct gpio_desc **desc_array,
3256                                         int *value_array)
3257 {
3258         might_sleep_if(extra_checks);
3259         if (!desc_array)
3260                 return;
3261         gpiod_set_array_value_complex(true, true, array_size, desc_array,
3262                                       value_array);
3263 }
3264 EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep);
3265
3266 /**
3267  * gpiod_add_lookup_tables() - register GPIO device consumers
3268  * @tables: list of tables of consumers to register
3269  * @n: number of tables in the list
3270  */
3271 void gpiod_add_lookup_tables(struct gpiod_lookup_table **tables, size_t n)
3272 {
3273         unsigned int i;
3274
3275         mutex_lock(&gpio_lookup_lock);
3276
3277         for (i = 0; i < n; i++)
3278                 list_add_tail(&tables[i]->list, &gpio_lookup_list);
3279
3280         mutex_unlock(&gpio_lookup_lock);
3281 }
3282
3283 /**
3284  * gpiod_set_array_value_cansleep() - assign values to an array of GPIOs
3285  * @array_size: number of elements in the descriptor / value arrays
3286  * @desc_array: array of GPIO descriptors whose values will be assigned
3287  * @value_array: array of values to assign
3288  *
3289  * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
3290  * into account.
3291  *
3292  * This function is to be called from contexts that can sleep.
3293  */
3294 void gpiod_set_array_value_cansleep(unsigned int array_size,
3295                                     struct gpio_desc **desc_array,
3296                                     int *value_array)
3297 {
3298         might_sleep_if(extra_checks);
3299         if (!desc_array)
3300                 return;
3301         gpiod_set_array_value_complex(false, true, array_size, desc_array,
3302                                       value_array);
3303 }
3304 EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep);
3305
3306 /**
3307  * gpiod_add_lookup_table() - register GPIO device consumers
3308  * @table: table of consumers to register
3309  */
3310 void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
3311 {
3312         mutex_lock(&gpio_lookup_lock);
3313
3314         list_add_tail(&table->list, &gpio_lookup_list);
3315
3316         mutex_unlock(&gpio_lookup_lock);
3317 }
3318 EXPORT_SYMBOL_GPL(gpiod_add_lookup_table);
3319
3320 /**
3321  * gpiod_remove_lookup_table() - unregister GPIO device consumers
3322  * @table: table of consumers to unregister
3323  */
3324 void gpiod_remove_lookup_table(struct gpiod_lookup_table *table)