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