d9c9cb4665dbf8899d3fe5b7ce9269b3fdee5961
[firefly-linux-kernel-4.4.55.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
18 #include "gpiolib.h"
19
20 #define CREATE_TRACE_POINTS
21 #include <trace/events/gpio.h>
22
23 /* Implementation infrastructure for GPIO interfaces.
24  *
25  * The GPIO programming interface allows for inlining speed-critical
26  * get/set operations for common cases, so that access to SOC-integrated
27  * GPIOs can sometimes cost only an instruction or two per bit.
28  */
29
30
31 /* When debugging, extend minimal trust to callers and platform code.
32  * Also emit diagnostic messages that may help initial bringup, when
33  * board setup or driver bugs are most common.
34  *
35  * Otherwise, minimize overhead in what may be bitbanging codepaths.
36  */
37 #ifdef  DEBUG
38 #define extra_checks    1
39 #else
40 #define extra_checks    0
41 #endif
42
43 /* gpio_lock prevents conflicts during gpio_desc[] table updates.
44  * While any GPIO is requested, its gpio_chip is not removable;
45  * each GPIO's "requested" flag serves as a lock and refcount.
46  */
47 static DEFINE_SPINLOCK(gpio_lock);
48
49 struct gpio_desc {
50         struct gpio_chip        *chip;
51         unsigned long           flags;
52 /* flag symbols are bit numbers */
53 #define FLAG_REQUESTED  0
54 #define FLAG_IS_OUT     1
55 #define FLAG_EXPORT     2       /* protected by sysfs_lock */
56 #define FLAG_SYSFS      3       /* exported via /sys/class/gpio/control */
57 #define FLAG_TRIG_FALL  4       /* trigger on falling edge */
58 #define FLAG_TRIG_RISE  5       /* trigger on rising edge */
59 #define FLAG_ACTIVE_LOW 6       /* value has active low */
60 #define FLAG_OPEN_DRAIN 7       /* Gpio is open drain type */
61 #define FLAG_OPEN_SOURCE 8      /* Gpio is open source type */
62 #define FLAG_USED_AS_IRQ 9      /* GPIO is connected to an IRQ */
63
64 #define ID_SHIFT        16      /* add new flags before this one */
65
66 #define GPIO_FLAGS_MASK         ((1 << ID_SHIFT) - 1)
67 #define GPIO_TRIGGER_MASK       (BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE))
68
69 #ifdef CONFIG_DEBUG_FS
70         const char              *label;
71 #endif
72 };
73 static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];
74
75 #define GPIO_OFFSET_VALID(chip, offset) (offset >= 0 && offset < chip->ngpio)
76
77 static DEFINE_MUTEX(gpio_lookup_lock);
78 static LIST_HEAD(gpio_lookup_list);
79 static LIST_HEAD(gpio_chips);
80
81 #ifdef CONFIG_GPIO_SYSFS
82 static DEFINE_IDR(dirent_idr);
83 #endif
84
85 static int gpiod_request(struct gpio_desc *desc, const char *label);
86 static void gpiod_free(struct gpio_desc *desc);
87
88 /* With descriptor prefix */
89
90 #ifdef CONFIG_DEBUG_FS
91 #define gpiod_emerg(desc, fmt, ...)                                            \
92         pr_emerg("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",\
93                  ##__VA_ARGS__)
94 #define gpiod_crit(desc, fmt, ...)                                             \
95         pr_crit("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
96                  ##__VA_ARGS__)
97 #define gpiod_err(desc, fmt, ...)                                              \
98         pr_err("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",  \
99                  ##__VA_ARGS__)
100 #define gpiod_warn(desc, fmt, ...)                                             \
101         pr_warn("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
102                  ##__VA_ARGS__)
103 #define gpiod_info(desc, fmt, ...)                                             \
104         pr_info("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
105                 ##__VA_ARGS__)
106 #define gpiod_dbg(desc, fmt, ...)                                              \
107         pr_debug("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",\
108                  ##__VA_ARGS__)
109 #else
110 #define gpiod_emerg(desc, fmt, ...)                                     \
111         pr_emerg("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
112 #define gpiod_crit(desc, fmt, ...)                                      \
113         pr_crit("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
114 #define gpiod_err(desc, fmt, ...)                                       \
115         pr_err("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
116 #define gpiod_warn(desc, fmt, ...)                                      \
117         pr_warn("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
118 #define gpiod_info(desc, fmt, ...)                                      \
119         pr_info("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
120 #define gpiod_dbg(desc, fmt, ...)                                       \
121         pr_debug("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
122 #endif
123
124 /* With chip prefix */
125
126 #define chip_emerg(chip, fmt, ...)                                      \
127         pr_emerg("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
128 #define chip_crit(chip, fmt, ...)                                       \
129         pr_crit("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
130 #define chip_err(chip, fmt, ...)                                        \
131         pr_err("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
132 #define chip_warn(chip, fmt, ...)                                       \
133         pr_warn("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
134 #define chip_info(chip, fmt, ...)                                       \
135         pr_info("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
136 #define chip_dbg(chip, fmt, ...)                                        \
137         pr_debug("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
138
139 static inline void desc_set_label(struct gpio_desc *d, const char *label)
140 {
141 #ifdef CONFIG_DEBUG_FS
142         d->label = label;
143 #endif
144 }
145
146 /*
147  * Return the GPIO number of the passed descriptor relative to its chip
148  */
149 static int gpio_chip_hwgpio(const struct gpio_desc *desc)
150 {
151         return desc - &desc->chip->desc[0];
152 }
153
154 /**
155  * Convert a GPIO number to its descriptor
156  */
157 struct gpio_desc *gpio_to_desc(unsigned gpio)
158 {
159         if (WARN(!gpio_is_valid(gpio), "invalid GPIO %d\n", gpio))
160                 return NULL;
161         else
162                 return &gpio_desc[gpio];
163 }
164 EXPORT_SYMBOL_GPL(gpio_to_desc);
165
166 /**
167  * Get the GPIO descriptor corresponding to the given hw number for this chip.
168  */
169 struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip,
170                                     u16 hwnum)
171 {
172         if (hwnum >= chip->ngpio)
173                 return ERR_PTR(-EINVAL);
174
175         return &chip->desc[hwnum];
176 }
177 EXPORT_SYMBOL_GPL(gpiochip_get_desc);
178
179 /**
180  * Convert a GPIO descriptor to the integer namespace.
181  * This should disappear in the future but is needed since we still
182  * use GPIO numbers for error messages and sysfs nodes
183  */
184 int desc_to_gpio(const struct gpio_desc *desc)
185 {
186         return desc - &gpio_desc[0];
187 }
188 EXPORT_SYMBOL_GPL(desc_to_gpio);
189
190
191 /* Warn when drivers omit gpio_request() calls -- legal but ill-advised
192  * when setting direction, and otherwise illegal.  Until board setup code
193  * and drivers use explicit requests everywhere (which won't happen when
194  * those calls have no teeth) we can't avoid autorequesting.  This nag
195  * message should motivate switching to explicit requests... so should
196  * the weaker cleanup after faults, compared to gpio_request().
197  *
198  * NOTE: the autorequest mechanism is going away; at this point it's
199  * only "legal" in the sense that (old) code using it won't break yet,
200  * but instead only triggers a WARN() stack dump.
201  */
202 static int gpio_ensure_requested(struct gpio_desc *desc)
203 {
204         const struct gpio_chip *chip = desc->chip;
205         const int gpio = desc_to_gpio(desc);
206
207         if (WARN(test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0,
208                         "autorequest GPIO-%d\n", gpio)) {
209                 if (!try_module_get(chip->owner)) {
210                         gpiod_err(desc, "%s: module can't be gotten\n",
211                                         __func__);
212                         clear_bit(FLAG_REQUESTED, &desc->flags);
213                         /* lose */
214                         return -EIO;
215                 }
216                 desc_set_label(desc, "[auto]");
217                 /* caller must chip->request() w/o spinlock */
218                 if (chip->request)
219                         return 1;
220         }
221         return 0;
222 }
223
224 /**
225  * gpiod_to_chip - Return the GPIO chip to which a GPIO descriptor belongs
226  * @desc:       descriptor to return the chip of
227  */
228 struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc)
229 {
230         return desc ? desc->chip : NULL;
231 }
232 EXPORT_SYMBOL_GPL(gpiod_to_chip);
233
234 /* dynamic allocation of GPIOs, e.g. on a hotplugged device */
235 static int gpiochip_find_base(int ngpio)
236 {
237         struct gpio_chip *chip;
238         int base = ARCH_NR_GPIOS - ngpio;
239
240         list_for_each_entry_reverse(chip, &gpio_chips, list) {
241                 /* found a free space? */
242                 if (chip->base + chip->ngpio <= base)
243                         break;
244                 else
245                         /* nope, check the space right before the chip */
246                         base = chip->base - ngpio;
247         }
248
249         if (gpio_is_valid(base)) {
250                 pr_debug("%s: found new base at %d\n", __func__, base);
251                 return base;
252         } else {
253                 pr_err("%s: cannot find free range\n", __func__);
254                 return -ENOSPC;
255         }
256 }
257
258 /**
259  * gpiod_get_direction - return the current direction of a GPIO
260  * @desc:       GPIO to get the direction of
261  *
262  * Return GPIOF_DIR_IN or GPIOF_DIR_OUT, or an error code in case of error.
263  *
264  * This function may sleep if gpiod_cansleep() is true.
265  */
266 int gpiod_get_direction(const struct gpio_desc *desc)
267 {
268         struct gpio_chip        *chip;
269         unsigned                offset;
270         int                     status = -EINVAL;
271
272         chip = gpiod_to_chip(desc);
273         offset = gpio_chip_hwgpio(desc);
274
275         if (!chip->get_direction)
276                 return status;
277
278         status = chip->get_direction(chip, offset);
279         if (status > 0) {
280                 /* GPIOF_DIR_IN, or other positive */
281                 status = 1;
282                 /* FLAG_IS_OUT is just a cache of the result of get_direction(),
283                  * so it does not affect constness per se */
284                 clear_bit(FLAG_IS_OUT, &((struct gpio_desc *)desc)->flags);
285         }
286         if (status == 0) {
287                 /* GPIOF_DIR_OUT */
288                 set_bit(FLAG_IS_OUT, &((struct gpio_desc *)desc)->flags);
289         }
290         return status;
291 }
292 EXPORT_SYMBOL_GPL(gpiod_get_direction);
293
294 #ifdef CONFIG_GPIO_SYSFS
295
296 /* lock protects against unexport_gpio() being called while
297  * sysfs files are active.
298  */
299 static DEFINE_MUTEX(sysfs_lock);
300
301 /*
302  * /sys/class/gpio/gpioN... only for GPIOs that are exported
303  *   /direction
304  *      * MAY BE OMITTED if kernel won't allow direction changes
305  *      * is read/write as "in" or "out"
306  *      * may also be written as "high" or "low", initializing
307  *        output value as specified ("out" implies "low")
308  *   /value
309  *      * always readable, subject to hardware behavior
310  *      * may be writable, as zero/nonzero
311  *   /edge
312  *      * configures behavior of poll(2) on /value
313  *      * available only if pin can generate IRQs on input
314  *      * is read/write as "none", "falling", "rising", or "both"
315  *   /active_low
316  *      * configures polarity of /value
317  *      * is read/write as zero/nonzero
318  *      * also affects existing and subsequent "falling" and "rising"
319  *        /edge configuration
320  */
321
322 static ssize_t gpio_direction_show(struct device *dev,
323                 struct device_attribute *attr, char *buf)
324 {
325         const struct gpio_desc  *desc = dev_get_drvdata(dev);
326         ssize_t                 status;
327
328         mutex_lock(&sysfs_lock);
329
330         if (!test_bit(FLAG_EXPORT, &desc->flags)) {
331                 status = -EIO;
332         } else {
333                 gpiod_get_direction(desc);
334                 status = sprintf(buf, "%s\n",
335                         test_bit(FLAG_IS_OUT, &desc->flags)
336                                 ? "out" : "in");
337         }
338
339         mutex_unlock(&sysfs_lock);
340         return status;
341 }
342
343 static ssize_t gpio_direction_store(struct device *dev,
344                 struct device_attribute *attr, const char *buf, size_t size)
345 {
346         struct gpio_desc        *desc = dev_get_drvdata(dev);
347         ssize_t                 status;
348
349         mutex_lock(&sysfs_lock);
350
351         if (!test_bit(FLAG_EXPORT, &desc->flags))
352                 status = -EIO;
353         else if (sysfs_streq(buf, "high"))
354                 status = gpiod_direction_output_raw(desc, 1);
355         else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
356                 status = gpiod_direction_output_raw(desc, 0);
357         else if (sysfs_streq(buf, "in"))
358                 status = gpiod_direction_input(desc);
359         else
360                 status = -EINVAL;
361
362         mutex_unlock(&sysfs_lock);
363         return status ? : size;
364 }
365
366 static /* const */ DEVICE_ATTR(direction, 0644,
367                 gpio_direction_show, gpio_direction_store);
368
369 static ssize_t gpio_value_show(struct device *dev,
370                 struct device_attribute *attr, char *buf)
371 {
372         struct gpio_desc        *desc = dev_get_drvdata(dev);
373         ssize_t                 status;
374
375         mutex_lock(&sysfs_lock);
376
377         if (!test_bit(FLAG_EXPORT, &desc->flags))
378                 status = -EIO;
379         else
380                 status = sprintf(buf, "%d\n", gpiod_get_value_cansleep(desc));
381
382         mutex_unlock(&sysfs_lock);
383         return status;
384 }
385
386 static ssize_t gpio_value_store(struct device *dev,
387                 struct device_attribute *attr, const char *buf, size_t size)
388 {
389         struct gpio_desc        *desc = dev_get_drvdata(dev);
390         ssize_t                 status;
391
392         mutex_lock(&sysfs_lock);
393
394         if (!test_bit(FLAG_EXPORT, &desc->flags))
395                 status = -EIO;
396         else if (!test_bit(FLAG_IS_OUT, &desc->flags))
397                 status = -EPERM;
398         else {
399                 long            value;
400
401                 status = kstrtol(buf, 0, &value);
402                 if (status == 0) {
403                         gpiod_set_value_cansleep(desc, value);
404                         status = size;
405                 }
406         }
407
408         mutex_unlock(&sysfs_lock);
409         return status;
410 }
411
412 static const DEVICE_ATTR(value, 0644,
413                 gpio_value_show, gpio_value_store);
414
415 static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
416 {
417         struct kernfs_node      *value_sd = priv;
418
419         sysfs_notify_dirent(value_sd);
420         return IRQ_HANDLED;
421 }
422
423 static int gpio_setup_irq(struct gpio_desc *desc, struct device *dev,
424                 unsigned long gpio_flags)
425 {
426         struct kernfs_node      *value_sd;
427         unsigned long           irq_flags;
428         int                     ret, irq, id;
429
430         if ((desc->flags & GPIO_TRIGGER_MASK) == gpio_flags)
431                 return 0;
432
433         irq = gpiod_to_irq(desc);
434         if (irq < 0)
435                 return -EIO;
436
437         id = desc->flags >> ID_SHIFT;
438         value_sd = idr_find(&dirent_idr, id);
439         if (value_sd)
440                 free_irq(irq, value_sd);
441
442         desc->flags &= ~GPIO_TRIGGER_MASK;
443
444         if (!gpio_flags) {
445                 gpiod_unlock_as_irq(desc);
446                 ret = 0;
447                 goto free_id;
448         }
449
450         irq_flags = IRQF_SHARED;
451         if (test_bit(FLAG_TRIG_FALL, &gpio_flags))
452                 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
453                         IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
454         if (test_bit(FLAG_TRIG_RISE, &gpio_flags))
455                 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
456                         IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
457
458         if (!value_sd) {
459                 value_sd = sysfs_get_dirent(dev->kobj.sd, "value");
460                 if (!value_sd) {
461                         ret = -ENODEV;
462                         goto err_out;
463                 }
464
465                 ret = idr_alloc(&dirent_idr, value_sd, 1, 0, GFP_KERNEL);
466                 if (ret < 0)
467                         goto free_sd;
468                 id = ret;
469
470                 desc->flags &= GPIO_FLAGS_MASK;
471                 desc->flags |= (unsigned long)id << ID_SHIFT;
472
473                 if (desc->flags >> ID_SHIFT != id) {
474                         ret = -ERANGE;
475                         goto free_id;
476                 }
477         }
478
479         ret = request_any_context_irq(irq, gpio_sysfs_irq, irq_flags,
480                                 "gpiolib", value_sd);
481         if (ret < 0)
482                 goto free_id;
483
484         ret = gpiod_lock_as_irq(desc);
485         if (ret < 0) {
486                 gpiod_warn(desc, "failed to flag the GPIO for IRQ\n");
487                 goto free_id;
488         }
489
490         desc->flags |= gpio_flags;
491         return 0;
492
493 free_id:
494         idr_remove(&dirent_idr, id);
495         desc->flags &= GPIO_FLAGS_MASK;
496 free_sd:
497         if (value_sd)
498                 sysfs_put(value_sd);
499 err_out:
500         return ret;
501 }
502
503 static const struct {
504         const char *name;
505         unsigned long flags;
506 } trigger_types[] = {
507         { "none",    0 },
508         { "falling", BIT(FLAG_TRIG_FALL) },
509         { "rising",  BIT(FLAG_TRIG_RISE) },
510         { "both",    BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE) },
511 };
512
513 static ssize_t gpio_edge_show(struct device *dev,
514                 struct device_attribute *attr, char *buf)
515 {
516         const struct gpio_desc  *desc = dev_get_drvdata(dev);
517         ssize_t                 status;
518
519         mutex_lock(&sysfs_lock);
520
521         if (!test_bit(FLAG_EXPORT, &desc->flags))
522                 status = -EIO;
523         else {
524                 int i;
525
526                 status = 0;
527                 for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
528                         if ((desc->flags & GPIO_TRIGGER_MASK)
529                                         == trigger_types[i].flags) {
530                                 status = sprintf(buf, "%s\n",
531                                                  trigger_types[i].name);
532                                 break;
533                         }
534         }
535
536         mutex_unlock(&sysfs_lock);
537         return status;
538 }
539
540 static ssize_t gpio_edge_store(struct device *dev,
541                 struct device_attribute *attr, const char *buf, size_t size)
542 {
543         struct gpio_desc        *desc = dev_get_drvdata(dev);
544         ssize_t                 status;
545         int                     i;
546
547         for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
548                 if (sysfs_streq(trigger_types[i].name, buf))
549                         goto found;
550         return -EINVAL;
551
552 found:
553         mutex_lock(&sysfs_lock);
554
555         if (!test_bit(FLAG_EXPORT, &desc->flags))
556                 status = -EIO;
557         else {
558                 status = gpio_setup_irq(desc, dev, trigger_types[i].flags);
559                 if (!status)
560                         status = size;
561         }
562
563         mutex_unlock(&sysfs_lock);
564
565         return status;
566 }
567
568 static DEVICE_ATTR(edge, 0644, gpio_edge_show, gpio_edge_store);
569
570 static int sysfs_set_active_low(struct gpio_desc *desc, struct device *dev,
571                                 int value)
572 {
573         int                     status = 0;
574
575         if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value)
576                 return 0;
577
578         if (value)
579                 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
580         else
581                 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
582
583         /* reconfigure poll(2) support if enabled on one edge only */
584         if (dev != NULL && (!!test_bit(FLAG_TRIG_RISE, &desc->flags) ^
585                                 !!test_bit(FLAG_TRIG_FALL, &desc->flags))) {
586                 unsigned long trigger_flags = desc->flags & GPIO_TRIGGER_MASK;
587
588                 gpio_setup_irq(desc, dev, 0);
589                 status = gpio_setup_irq(desc, dev, trigger_flags);
590         }
591
592         return status;
593 }
594
595 static ssize_t gpio_active_low_show(struct device *dev,
596                 struct device_attribute *attr, char *buf)
597 {
598         const struct gpio_desc  *desc = dev_get_drvdata(dev);
599         ssize_t                 status;
600
601         mutex_lock(&sysfs_lock);
602
603         if (!test_bit(FLAG_EXPORT, &desc->flags))
604                 status = -EIO;
605         else
606                 status = sprintf(buf, "%d\n",
607                                 !!test_bit(FLAG_ACTIVE_LOW, &desc->flags));
608
609         mutex_unlock(&sysfs_lock);
610
611         return status;
612 }
613
614 static ssize_t gpio_active_low_store(struct device *dev,
615                 struct device_attribute *attr, const char *buf, size_t size)
616 {
617         struct gpio_desc        *desc = dev_get_drvdata(dev);
618         ssize_t                 status;
619
620         mutex_lock(&sysfs_lock);
621
622         if (!test_bit(FLAG_EXPORT, &desc->flags)) {
623                 status = -EIO;
624         } else {
625                 long            value;
626
627                 status = kstrtol(buf, 0, &value);
628                 if (status == 0)
629                         status = sysfs_set_active_low(desc, dev, value != 0);
630         }
631
632         mutex_unlock(&sysfs_lock);
633
634         return status ? : size;
635 }
636
637 static const DEVICE_ATTR(active_low, 0644,
638                 gpio_active_low_show, gpio_active_low_store);
639
640 static const struct attribute *gpio_attrs[] = {
641         &dev_attr_value.attr,
642         &dev_attr_active_low.attr,
643         NULL,
644 };
645
646 static const struct attribute_group gpio_attr_group = {
647         .attrs = (struct attribute **) gpio_attrs,
648 };
649
650 /*
651  * /sys/class/gpio/gpiochipN/
652  *   /base ... matching gpio_chip.base (N)
653  *   /label ... matching gpio_chip.label
654  *   /ngpio ... matching gpio_chip.ngpio
655  */
656
657 static ssize_t chip_base_show(struct device *dev,
658                                struct device_attribute *attr, char *buf)
659 {
660         const struct gpio_chip  *chip = dev_get_drvdata(dev);
661
662         return sprintf(buf, "%d\n", chip->base);
663 }
664 static DEVICE_ATTR(base, 0444, chip_base_show, NULL);
665
666 static ssize_t chip_label_show(struct device *dev,
667                                struct device_attribute *attr, char *buf)
668 {
669         const struct gpio_chip  *chip = dev_get_drvdata(dev);
670
671         return sprintf(buf, "%s\n", chip->label ? : "");
672 }
673 static DEVICE_ATTR(label, 0444, chip_label_show, NULL);
674
675 static ssize_t chip_ngpio_show(struct device *dev,
676                                struct device_attribute *attr, char *buf)
677 {
678         const struct gpio_chip  *chip = dev_get_drvdata(dev);
679
680         return sprintf(buf, "%u\n", chip->ngpio);
681 }
682 static DEVICE_ATTR(ngpio, 0444, chip_ngpio_show, NULL);
683
684 static const struct attribute *gpiochip_attrs[] = {
685         &dev_attr_base.attr,
686         &dev_attr_label.attr,
687         &dev_attr_ngpio.attr,
688         NULL,
689 };
690
691 static const struct attribute_group gpiochip_attr_group = {
692         .attrs = (struct attribute **) gpiochip_attrs,
693 };
694
695 /*
696  * /sys/class/gpio/export ... write-only
697  *      integer N ... number of GPIO to export (full access)
698  * /sys/class/gpio/unexport ... write-only
699  *      integer N ... number of GPIO to unexport
700  */
701 static ssize_t export_store(struct class *class,
702                                 struct class_attribute *attr,
703                                 const char *buf, size_t len)
704 {
705         long                    gpio;
706         struct gpio_desc        *desc;
707         int                     status;
708
709         status = kstrtol(buf, 0, &gpio);
710         if (status < 0)
711                 goto done;
712
713         desc = gpio_to_desc(gpio);
714         /* reject invalid GPIOs */
715         if (!desc) {
716                 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
717                 return -EINVAL;
718         }
719
720         /* No extra locking here; FLAG_SYSFS just signifies that the
721          * request and export were done by on behalf of userspace, so
722          * they may be undone on its behalf too.
723          */
724
725         status = gpiod_request(desc, "sysfs");
726         if (status < 0) {
727                 if (status == -EPROBE_DEFER)
728                         status = -ENODEV;
729                 goto done;
730         }
731         status = gpiod_export(desc, true);
732         if (status < 0)
733                 gpiod_free(desc);
734         else
735                 set_bit(FLAG_SYSFS, &desc->flags);
736
737 done:
738         if (status)
739                 pr_debug("%s: status %d\n", __func__, status);
740         return status ? : len;
741 }
742
743 static ssize_t unexport_store(struct class *class,
744                                 struct class_attribute *attr,
745                                 const char *buf, size_t len)
746 {
747         long                    gpio;
748         struct gpio_desc        *desc;
749         int                     status;
750
751         status = kstrtol(buf, 0, &gpio);
752         if (status < 0)
753                 goto done;
754
755         desc = gpio_to_desc(gpio);
756         /* reject bogus commands (gpio_unexport ignores them) */
757         if (!desc) {
758                 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
759                 return -EINVAL;
760         }
761
762         status = -EINVAL;
763
764         /* No extra locking here; FLAG_SYSFS just signifies that the
765          * request and export were done by on behalf of userspace, so
766          * they may be undone on its behalf too.
767          */
768         if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
769                 status = 0;
770                 gpiod_free(desc);
771         }
772 done:
773         if (status)
774                 pr_debug("%s: status %d\n", __func__, status);
775         return status ? : len;
776 }
777
778 static struct class_attribute gpio_class_attrs[] = {
779         __ATTR(export, 0200, NULL, export_store),
780         __ATTR(unexport, 0200, NULL, unexport_store),
781         __ATTR_NULL,
782 };
783
784 static struct class gpio_class = {
785         .name =         "gpio",
786         .owner =        THIS_MODULE,
787
788         .class_attrs =  gpio_class_attrs,
789 };
790
791
792 /**
793  * gpiod_export - export a GPIO through sysfs
794  * @gpio: gpio to make available, already requested
795  * @direction_may_change: true if userspace may change gpio direction
796  * Context: arch_initcall or later
797  *
798  * When drivers want to make a GPIO accessible to userspace after they
799  * have requested it -- perhaps while debugging, or as part of their
800  * public interface -- they may use this routine.  If the GPIO can
801  * change direction (some can't) and the caller allows it, userspace
802  * will see "direction" sysfs attribute which may be used to change
803  * the gpio's direction.  A "value" attribute will always be provided.
804  *
805  * Returns zero on success, else an error.
806  */
807 int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
808 {
809         unsigned long           flags;
810         int                     status;
811         const char              *ioname = NULL;
812         struct device           *dev;
813         int                     offset;
814
815         /* can't export until sysfs is available ... */
816         if (!gpio_class.p) {
817                 pr_debug("%s: called too early!\n", __func__);
818                 return -ENOENT;
819         }
820
821         if (!desc) {
822                 pr_debug("%s: invalid gpio descriptor\n", __func__);
823                 return -EINVAL;
824         }
825
826         mutex_lock(&sysfs_lock);
827
828         spin_lock_irqsave(&gpio_lock, flags);
829         if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
830              test_bit(FLAG_EXPORT, &desc->flags)) {
831                 spin_unlock_irqrestore(&gpio_lock, flags);
832                 gpiod_dbg(desc, "%s: unavailable (requested=%d, exported=%d)\n",
833                                 __func__,
834                                 test_bit(FLAG_REQUESTED, &desc->flags),
835                                 test_bit(FLAG_EXPORT, &desc->flags));
836                 status = -EPERM;
837                 goto fail_unlock;
838         }
839
840         if (!desc->chip->direction_input || !desc->chip->direction_output)
841                 direction_may_change = false;
842         spin_unlock_irqrestore(&gpio_lock, flags);
843
844         offset = gpio_chip_hwgpio(desc);
845         if (desc->chip->names && desc->chip->names[offset])
846                 ioname = desc->chip->names[offset];
847
848         dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
849                             desc, ioname ? ioname : "gpio%u",
850                             desc_to_gpio(desc));
851         if (IS_ERR(dev)) {
852                 status = PTR_ERR(dev);
853                 goto fail_unlock;
854         }
855
856         status = sysfs_create_group(&dev->kobj, &gpio_attr_group);
857         if (status)
858                 goto fail_unregister_device;
859
860         if (direction_may_change) {
861                 status = device_create_file(dev, &dev_attr_direction);
862                 if (status)
863                         goto fail_unregister_device;
864         }
865
866         if (gpiod_to_irq(desc) >= 0 && (direction_may_change ||
867                                        !test_bit(FLAG_IS_OUT, &desc->flags))) {
868                 status = device_create_file(dev, &dev_attr_edge);
869                 if (status)
870                         goto fail_unregister_device;
871         }
872
873         set_bit(FLAG_EXPORT, &desc->flags);
874         mutex_unlock(&sysfs_lock);
875         return 0;
876
877 fail_unregister_device:
878         device_unregister(dev);
879 fail_unlock:
880         mutex_unlock(&sysfs_lock);
881         gpiod_dbg(desc, "%s: status %d\n", __func__, status);
882         return status;
883 }
884 EXPORT_SYMBOL_GPL(gpiod_export);
885
886 static int match_export(struct device *dev, const void *data)
887 {
888         return dev_get_drvdata(dev) == data;
889 }
890
891 /**
892  * gpiod_export_link - create a sysfs link to an exported GPIO node
893  * @dev: device under which to create symlink
894  * @name: name of the symlink
895  * @gpio: gpio to create symlink to, already exported
896  *
897  * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
898  * node. Caller is responsible for unlinking.
899  *
900  * Returns zero on success, else an error.
901  */
902 int gpiod_export_link(struct device *dev, const char *name,
903                       struct gpio_desc *desc)
904 {
905         int                     status = -EINVAL;
906
907         if (!desc) {
908                 pr_warn("%s: invalid GPIO\n", __func__);
909                 return -EINVAL;
910         }
911
912         mutex_lock(&sysfs_lock);
913
914         if (test_bit(FLAG_EXPORT, &desc->flags)) {
915                 struct device *tdev;
916
917                 tdev = class_find_device(&gpio_class, NULL, desc, match_export);
918                 if (tdev != NULL) {
919                         status = sysfs_create_link(&dev->kobj, &tdev->kobj,
920                                                 name);
921                 } else {
922                         status = -ENODEV;
923                 }
924         }
925
926         mutex_unlock(&sysfs_lock);
927
928         if (status)
929                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
930
931         return status;
932 }
933 EXPORT_SYMBOL_GPL(gpiod_export_link);
934
935 /**
936  * gpiod_sysfs_set_active_low - set the polarity of gpio sysfs value
937  * @gpio: gpio to change
938  * @value: non-zero to use active low, i.e. inverted values
939  *
940  * Set the polarity of /sys/class/gpio/gpioN/value sysfs attribute.
941  * The GPIO does not have to be exported yet.  If poll(2) support has
942  * been enabled for either rising or falling edge, it will be
943  * reconfigured to follow the new polarity.
944  *
945  * Returns zero on success, else an error.
946  */
947 int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
948 {
949         struct device           *dev = NULL;
950         int                     status = -EINVAL;
951
952         if (!desc) {
953                 pr_warn("%s: invalid GPIO\n", __func__);
954                 return -EINVAL;
955         }
956
957         mutex_lock(&sysfs_lock);
958
959         if (test_bit(FLAG_EXPORT, &desc->flags)) {
960                 dev = class_find_device(&gpio_class, NULL, desc, match_export);
961                 if (dev == NULL) {
962                         status = -ENODEV;
963                         goto unlock;
964                 }
965         }
966
967         status = sysfs_set_active_low(desc, dev, value);
968
969 unlock:
970         mutex_unlock(&sysfs_lock);
971
972         if (status)
973                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
974
975         return status;
976 }
977 EXPORT_SYMBOL_GPL(gpiod_sysfs_set_active_low);
978
979 /**
980  * gpiod_unexport - reverse effect of gpio_export()
981  * @gpio: gpio to make unavailable
982  *
983  * This is implicit on gpio_free().
984  */
985 void gpiod_unexport(struct gpio_desc *desc)
986 {
987         int                     status = 0;
988         struct device           *dev = NULL;
989
990         if (!desc) {
991                 pr_warn("%s: invalid GPIO\n", __func__);
992                 return;
993         }
994
995         mutex_lock(&sysfs_lock);
996
997         if (test_bit(FLAG_EXPORT, &desc->flags)) {
998
999                 dev = class_find_device(&gpio_class, NULL, desc, match_export);
1000                 if (dev) {
1001                         gpio_setup_irq(desc, dev, 0);
1002                         clear_bit(FLAG_EXPORT, &desc->flags);
1003                 } else
1004                         status = -ENODEV;
1005         }
1006
1007         mutex_unlock(&sysfs_lock);
1008
1009         if (dev) {
1010                 device_unregister(dev);
1011                 put_device(dev);
1012         }
1013
1014         if (status)
1015                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1016 }
1017 EXPORT_SYMBOL_GPL(gpiod_unexport);
1018
1019 static int gpiochip_export(struct gpio_chip *chip)
1020 {
1021         int             status;
1022         struct device   *dev;
1023
1024         /* Many systems register gpio chips for SOC support very early,
1025          * before driver model support is available.  In those cases we
1026          * export this later, in gpiolib_sysfs_init() ... here we just
1027          * verify that _some_ field of gpio_class got initialized.
1028          */
1029         if (!gpio_class.p)
1030                 return 0;
1031
1032         /* use chip->base for the ID; it's already known to be unique */
1033         mutex_lock(&sysfs_lock);
1034         dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
1035                                 "gpiochip%d", chip->base);
1036         if (!IS_ERR(dev)) {
1037                 status = sysfs_create_group(&dev->kobj,
1038                                 &gpiochip_attr_group);
1039         } else
1040                 status = PTR_ERR(dev);
1041         chip->exported = (status == 0);
1042         mutex_unlock(&sysfs_lock);
1043
1044         if (status) {
1045                 unsigned long   flags;
1046                 unsigned        gpio;
1047
1048                 spin_lock_irqsave(&gpio_lock, flags);
1049                 gpio = 0;
1050                 while (gpio < chip->ngpio)
1051                         chip->desc[gpio++].chip = NULL;
1052                 spin_unlock_irqrestore(&gpio_lock, flags);
1053
1054                 chip_dbg(chip, "%s: status %d\n", __func__, status);
1055         }
1056
1057         return status;
1058 }
1059
1060 static void gpiochip_unexport(struct gpio_chip *chip)
1061 {
1062         int                     status;
1063         struct device           *dev;
1064
1065         mutex_lock(&sysfs_lock);
1066         dev = class_find_device(&gpio_class, NULL, chip, match_export);
1067         if (dev) {
1068                 put_device(dev);
1069                 device_unregister(dev);
1070                 chip->exported = false;
1071                 status = 0;
1072         } else
1073                 status = -ENODEV;
1074         mutex_unlock(&sysfs_lock);
1075
1076         if (status)
1077                 chip_dbg(chip, "%s: status %d\n", __func__, status);
1078 }
1079
1080 static int __init gpiolib_sysfs_init(void)
1081 {
1082         int             status;
1083         unsigned long   flags;
1084         struct gpio_chip *chip;
1085
1086         status = class_register(&gpio_class);
1087         if (status < 0)
1088                 return status;
1089
1090         /* Scan and register the gpio_chips which registered very
1091          * early (e.g. before the class_register above was called).
1092          *
1093          * We run before arch_initcall() so chip->dev nodes can have
1094          * registered, and so arch_initcall() can always gpio_export().
1095          */
1096         spin_lock_irqsave(&gpio_lock, flags);
1097         list_for_each_entry(chip, &gpio_chips, list) {
1098                 if (!chip || chip->exported)
1099                         continue;
1100
1101                 spin_unlock_irqrestore(&gpio_lock, flags);
1102                 status = gpiochip_export(chip);
1103                 spin_lock_irqsave(&gpio_lock, flags);
1104         }
1105         spin_unlock_irqrestore(&gpio_lock, flags);
1106
1107
1108         return status;
1109 }
1110 postcore_initcall(gpiolib_sysfs_init);
1111
1112 #else
1113 static inline int gpiochip_export(struct gpio_chip *chip)
1114 {
1115         return 0;
1116 }
1117
1118 static inline void gpiochip_unexport(struct gpio_chip *chip)
1119 {
1120 }
1121
1122 #endif /* CONFIG_GPIO_SYSFS */
1123
1124 /*
1125  * Add a new chip to the global chips list, keeping the list of chips sorted
1126  * by base order.
1127  *
1128  * Return -EBUSY if the new chip overlaps with some other chip's integer
1129  * space.
1130  */
1131 static int gpiochip_add_to_list(struct gpio_chip *chip)
1132 {
1133         struct list_head *pos = &gpio_chips;
1134         struct gpio_chip *_chip;
1135         int err = 0;
1136
1137         /* find where to insert our chip */
1138         list_for_each(pos, &gpio_chips) {
1139                 _chip = list_entry(pos, struct gpio_chip, list);
1140                 /* shall we insert before _chip? */
1141                 if (_chip->base >= chip->base + chip->ngpio)
1142                         break;
1143         }
1144
1145         /* are we stepping on the chip right before? */
1146         if (pos != &gpio_chips && pos->prev != &gpio_chips) {
1147                 _chip = list_entry(pos->prev, struct gpio_chip, list);
1148                 if (_chip->base + _chip->ngpio > chip->base) {
1149                         dev_err(chip->dev,
1150                                "GPIO integer space overlap, cannot add chip\n");
1151                         err = -EBUSY;
1152                 }
1153         }
1154
1155         if (!err)
1156                 list_add_tail(&chip->list, pos);
1157
1158         return err;
1159 }
1160
1161 /**
1162  * gpiochip_add() - register a gpio_chip
1163  * @chip: the chip to register, with chip->base initialized
1164  * Context: potentially before irqs or kmalloc will work
1165  *
1166  * Returns a negative errno if the chip can't be registered, such as
1167  * because the chip->base is invalid or already associated with a
1168  * different chip.  Otherwise it returns zero as a success code.
1169  *
1170  * When gpiochip_add() is called very early during boot, so that GPIOs
1171  * can be freely used, the chip->dev device must be registered before
1172  * the gpio framework's arch_initcall().  Otherwise sysfs initialization
1173  * for GPIOs will fail rudely.
1174  *
1175  * If chip->base is negative, this requests dynamic assignment of
1176  * a range of valid GPIOs.
1177  */
1178 int gpiochip_add(struct gpio_chip *chip)
1179 {
1180         unsigned long   flags;
1181         int             status = 0;
1182         unsigned        id;
1183         int             base = chip->base;
1184
1185         if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))
1186                         && base >= 0) {
1187                 status = -EINVAL;
1188                 goto fail;
1189         }
1190
1191         spin_lock_irqsave(&gpio_lock, flags);
1192
1193         if (base < 0) {
1194                 base = gpiochip_find_base(chip->ngpio);
1195                 if (base < 0) {
1196                         status = base;
1197                         goto unlock;
1198                 }
1199                 chip->base = base;
1200         }
1201
1202         status = gpiochip_add_to_list(chip);
1203
1204         if (status == 0) {
1205                 chip->desc = &gpio_desc[chip->base];
1206
1207                 for (id = 0; id < chip->ngpio; id++) {
1208                         struct gpio_desc *desc = &chip->desc[id];
1209                         desc->chip = chip;
1210
1211                         /* REVISIT:  most hardware initializes GPIOs as
1212                          * inputs (often with pullups enabled) so power
1213                          * usage is minimized.  Linux code should set the
1214                          * gpio direction first thing; but until it does,
1215                          * and in case chip->get_direction is not set,
1216                          * we may expose the wrong direction in sysfs.
1217                          */
1218                         desc->flags = !chip->direction_input
1219                                 ? (1 << FLAG_IS_OUT)
1220                                 : 0;
1221                 }
1222         }
1223
1224         spin_unlock_irqrestore(&gpio_lock, flags);
1225
1226 #ifdef CONFIG_PINCTRL
1227         INIT_LIST_HEAD(&chip->pin_ranges);
1228 #endif
1229
1230         of_gpiochip_add(chip);
1231         acpi_gpiochip_add(chip);
1232
1233         if (status)
1234                 goto fail;
1235
1236         status = gpiochip_export(chip);
1237         if (status)
1238                 goto fail;
1239
1240         pr_debug("%s: registered GPIOs %d to %d on device: %s\n", __func__,
1241                 chip->base, chip->base + chip->ngpio - 1,
1242                 chip->label ? : "generic");
1243
1244         return 0;
1245
1246 unlock:
1247         spin_unlock_irqrestore(&gpio_lock, flags);
1248 fail:
1249         /* failures here can mean systems won't boot... */
1250         pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__,
1251                 chip->base, chip->base + chip->ngpio - 1,
1252                 chip->label ? : "generic");
1253         return status;
1254 }
1255 EXPORT_SYMBOL_GPL(gpiochip_add);
1256
1257 /* Forward-declaration */
1258 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip);
1259
1260 /**
1261  * gpiochip_remove() - unregister a gpio_chip
1262  * @chip: the chip to unregister
1263  *
1264  * A gpio_chip with any GPIOs still requested may not be removed.
1265  */
1266 int gpiochip_remove(struct gpio_chip *chip)
1267 {
1268         unsigned long   flags;
1269         int             status = 0;
1270         unsigned        id;
1271
1272         acpi_gpiochip_remove(chip);
1273
1274         spin_lock_irqsave(&gpio_lock, flags);
1275
1276         gpiochip_irqchip_remove(chip);
1277         gpiochip_remove_pin_ranges(chip);
1278         of_gpiochip_remove(chip);
1279
1280         for (id = 0; id < chip->ngpio; id++) {
1281                 if (test_bit(FLAG_REQUESTED, &chip->desc[id].flags)) {
1282                         status = -EBUSY;
1283                         break;
1284                 }
1285         }
1286         if (status == 0) {
1287                 for (id = 0; id < chip->ngpio; id++)
1288                         chip->desc[id].chip = NULL;
1289
1290                 list_del(&chip->list);
1291         }
1292
1293         spin_unlock_irqrestore(&gpio_lock, flags);
1294
1295         if (status == 0)
1296                 gpiochip_unexport(chip);
1297
1298         return status;
1299 }
1300 EXPORT_SYMBOL_GPL(gpiochip_remove);
1301
1302 /**
1303  * gpiochip_find() - iterator for locating a specific gpio_chip
1304  * @data: data to pass to match function
1305  * @callback: Callback function to check gpio_chip
1306  *
1307  * Similar to bus_find_device.  It returns a reference to a gpio_chip as
1308  * determined by a user supplied @match callback.  The callback should return
1309  * 0 if the device doesn't match and non-zero if it does.  If the callback is
1310  * non-zero, this function will return to the caller and not iterate over any
1311  * more gpio_chips.
1312  */
1313 struct gpio_chip *gpiochip_find(void *data,
1314                                 int (*match)(struct gpio_chip *chip,
1315                                              void *data))
1316 {
1317         struct gpio_chip *chip;
1318         unsigned long flags;
1319
1320         spin_lock_irqsave(&gpio_lock, flags);
1321         list_for_each_entry(chip, &gpio_chips, list)
1322                 if (match(chip, data))
1323                         break;
1324
1325         /* No match? */
1326         if (&chip->list == &gpio_chips)
1327                 chip = NULL;
1328         spin_unlock_irqrestore(&gpio_lock, flags);
1329
1330         return chip;
1331 }
1332 EXPORT_SYMBOL_GPL(gpiochip_find);
1333
1334 static int gpiochip_match_name(struct gpio_chip *chip, void *data)
1335 {
1336         const char *name = data;
1337
1338         return !strcmp(chip->label, name);
1339 }
1340
1341 static struct gpio_chip *find_chip_by_name(const char *name)
1342 {
1343         return gpiochip_find((void *)name, gpiochip_match_name);
1344 }
1345
1346 #ifdef CONFIG_GPIOLIB_IRQCHIP
1347
1348 /*
1349  * The following is irqchip helper code for gpiochips.
1350  */
1351
1352 /**
1353  * gpiochip_add_chained_irqchip() - adds a chained irqchip to a gpiochip
1354  * @gpiochip: the gpiochip to add the irqchip to
1355  * @irqchip: the irqchip to add to the gpiochip
1356  * @parent_irq: the irq number corresponding to the parent IRQ for this
1357  * chained irqchip
1358  * @parent_handler: the parent interrupt handler for the accumulated IRQ
1359  * coming out of the gpiochip
1360  */
1361 void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
1362                                   struct irq_chip *irqchip,
1363                                   int parent_irq,
1364                                   irq_flow_handler_t parent_handler)
1365 {
1366         if (gpiochip->can_sleep) {
1367                 chip_err(gpiochip, "you cannot have chained interrupts on a chip that may sleep\n");
1368                 return;
1369         }
1370
1371         irq_set_chained_handler(parent_irq, parent_handler);
1372         /*
1373          * The parent irqchip is already using the chip_data for this
1374          * irqchip, so our callbacks simply use the handler_data.
1375          */
1376         irq_set_handler_data(parent_irq, gpiochip);
1377 }
1378 EXPORT_SYMBOL_GPL(gpiochip_set_chained_irqchip);
1379
1380 /*
1381  * This lock class tells lockdep that GPIO irqs are in a different
1382  * category than their parents, so it won't report false recursion.
1383  */
1384 static struct lock_class_key gpiochip_irq_lock_class;
1385
1386 /**
1387  * gpiochip_irq_map() - maps an IRQ into a GPIO irqchip
1388  * @d: the irqdomain used by this irqchip
1389  * @irq: the global irq number used by this GPIO irqchip irq
1390  * @hwirq: the local IRQ/GPIO line offset on this gpiochip
1391  *
1392  * This function will set up the mapping for a certain IRQ line on a
1393  * gpiochip by assigning the gpiochip as chip data, and using the irqchip
1394  * stored inside the gpiochip.
1395  */
1396 static int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
1397                             irq_hw_number_t hwirq)
1398 {
1399         struct gpio_chip *chip = d->host_data;
1400
1401         irq_set_chip_data(irq, chip);
1402         irq_set_lockdep_class(irq, &gpiochip_irq_lock_class);
1403         irq_set_chip_and_handler(irq, chip->irqchip, chip->irq_handler);
1404         /* Chips that can sleep need nested thread handlers */
1405         if (chip->can_sleep)
1406                 irq_set_nested_thread(irq, 1);
1407 #ifdef CONFIG_ARM
1408         set_irq_flags(irq, IRQF_VALID);
1409 #else
1410         irq_set_noprobe(irq);
1411 #endif
1412         /*
1413          * No set-up of the hardware will happen if IRQ_TYPE_NONE
1414          * is passed as default type.
1415          */
1416         if (chip->irq_default_type != IRQ_TYPE_NONE)
1417                 irq_set_irq_type(irq, chip->irq_default_type);
1418
1419         return 0;
1420 }
1421
1422 static void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
1423 {
1424         struct gpio_chip *chip = d->host_data;
1425
1426 #ifdef CONFIG_ARM
1427         set_irq_flags(irq, 0);
1428 #endif
1429         if (chip->can_sleep)
1430                 irq_set_nested_thread(irq, 0);
1431         irq_set_chip_and_handler(irq, NULL, NULL);
1432         irq_set_chip_data(irq, NULL);
1433 }
1434
1435 static const struct irq_domain_ops gpiochip_domain_ops = {
1436         .map    = gpiochip_irq_map,
1437         .unmap  = gpiochip_irq_unmap,
1438         /* Virtually all GPIO irqchips are twocell:ed */
1439         .xlate  = irq_domain_xlate_twocell,
1440 };
1441
1442 static int gpiochip_irq_reqres(struct irq_data *d)
1443 {
1444         struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
1445
1446         if (gpio_lock_as_irq(chip, d->hwirq)) {
1447                 chip_err(chip,
1448                         "unable to lock HW IRQ %lu for IRQ\n",
1449                         d->hwirq);
1450                 return -EINVAL;
1451         }
1452         return 0;
1453 }
1454
1455 static void gpiochip_irq_relres(struct irq_data *d)
1456 {
1457         struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
1458
1459         gpio_unlock_as_irq(chip, d->hwirq);
1460 }
1461
1462 static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset)
1463 {
1464         return irq_find_mapping(chip->irqdomain, offset);
1465 }
1466
1467 /**
1468  * gpiochip_irqchip_remove() - removes an irqchip added to a gpiochip
1469  * @gpiochip: the gpiochip to remove the irqchip from
1470  *
1471  * This is called only from gpiochip_remove()
1472  */
1473 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip)
1474 {
1475         unsigned int offset;
1476
1477         /* Remove all IRQ mappings and delete the domain */
1478         if (gpiochip->irqdomain) {
1479                 for (offset = 0; offset < gpiochip->ngpio; offset++)
1480                         irq_dispose_mapping(gpiochip->irq_base + offset);
1481                 irq_domain_remove(gpiochip->irqdomain);
1482         }
1483
1484         if (gpiochip->irqchip) {
1485                 gpiochip->irqchip->irq_request_resources = NULL;
1486                 gpiochip->irqchip->irq_release_resources = NULL;
1487                 gpiochip->irqchip = NULL;
1488         }
1489 }
1490
1491 /**
1492  * gpiochip_irqchip_add() - adds an irqchip to a gpiochip
1493  * @gpiochip: the gpiochip to add the irqchip to
1494  * @irqchip: the irqchip to add to the gpiochip
1495  * @first_irq: if not dynamically assigned, the base (first) IRQ to
1496  * allocate gpiochip irqs from
1497  * @handler: the irq handler to use (often a predefined irq core function)
1498  * @type: the default type for IRQs on this irqchip, pass IRQ_TYPE_NONE
1499  * to have the core avoid setting up any default type in the hardware.
1500  *
1501  * This function closely associates a certain irqchip with a certain
1502  * gpiochip, providing an irq domain to translate the local IRQs to
1503  * global irqs in the gpiolib core, and making sure that the gpiochip
1504  * is passed as chip data to all related functions. Driver callbacks
1505  * need to use container_of() to get their local state containers back
1506  * from the gpiochip passed as chip data. An irqdomain will be stored
1507  * in the gpiochip that shall be used by the driver to handle IRQ number
1508  * translation. The gpiochip will need to be initialized and registered
1509  * before calling this function.
1510  *
1511  * This function will handle two cell:ed simple IRQs and assumes all
1512  * the pins on the gpiochip can generate a unique IRQ. Everything else
1513  * need to be open coded.
1514  */
1515 int gpiochip_irqchip_add(struct gpio_chip *gpiochip,
1516                          struct irq_chip *irqchip,
1517                          unsigned int first_irq,
1518                          irq_flow_handler_t handler,
1519                          unsigned int type)
1520 {
1521         struct device_node *of_node;
1522         unsigned int offset;
1523         unsigned irq_base = 0;
1524
1525         if (!gpiochip || !irqchip)
1526                 return -EINVAL;
1527
1528         if (!gpiochip->dev) {
1529                 pr_err("missing gpiochip .dev parent pointer\n");
1530                 return -EINVAL;
1531         }
1532         of_node = gpiochip->dev->of_node;
1533 #ifdef CONFIG_OF_GPIO
1534         /*
1535          * If the gpiochip has an assigned OF node this takes precendence
1536          * FIXME: get rid of this and use gpiochip->dev->of_node everywhere
1537          */
1538         if (gpiochip->of_node)
1539                 of_node = gpiochip->of_node;
1540 #endif
1541         gpiochip->irqchip = irqchip;
1542         gpiochip->irq_handler = handler;
1543         gpiochip->irq_default_type = type;
1544         gpiochip->to_irq = gpiochip_to_irq;
1545         gpiochip->irqdomain = irq_domain_add_simple(of_node,
1546                                         gpiochip->ngpio, first_irq,
1547                                         &gpiochip_domain_ops, gpiochip);
1548         if (!gpiochip->irqdomain) {
1549                 gpiochip->irqchip = NULL;
1550                 return -EINVAL;
1551         }
1552         irqchip->irq_request_resources = gpiochip_irq_reqres;
1553         irqchip->irq_release_resources = gpiochip_irq_relres;
1554
1555         /*
1556          * Prepare the mapping since the irqchip shall be orthogonal to
1557          * any gpiochip calls. If the first_irq was zero, this is
1558          * necessary to allocate descriptors for all IRQs.
1559          */
1560         for (offset = 0; offset < gpiochip->ngpio; offset++) {
1561                 irq_base = irq_create_mapping(gpiochip->irqdomain, offset);
1562                 if (offset == 0)
1563                         /*
1564                          * Store the base into the gpiochip to be used when
1565                          * unmapping the irqs.
1566                          */
1567                         gpiochip->irq_base = irq_base;
1568         }
1569
1570         return 0;
1571 }
1572 EXPORT_SYMBOL_GPL(gpiochip_irqchip_add);
1573
1574 #else /* CONFIG_GPIOLIB_IRQCHIP */
1575
1576 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}
1577
1578 #endif /* CONFIG_GPIOLIB_IRQCHIP */
1579
1580 #ifdef CONFIG_PINCTRL
1581
1582 /**
1583  * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
1584  * @chip: the gpiochip to add the range for
1585  * @pinctrl: the dev_name() of the pin controller to map to
1586  * @gpio_offset: the start offset in the current gpio_chip number space
1587  * @pin_group: name of the pin group inside the pin controller
1588  */
1589 int gpiochip_add_pingroup_range(struct gpio_chip *chip,
1590                         struct pinctrl_dev *pctldev,
1591                         unsigned int gpio_offset, const char *pin_group)
1592 {
1593         struct gpio_pin_range *pin_range;
1594         int ret;
1595
1596         pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1597         if (!pin_range) {
1598                 chip_err(chip, "failed to allocate pin ranges\n");
1599                 return -ENOMEM;
1600         }
1601
1602         /* Use local offset as range ID */
1603         pin_range->range.id = gpio_offset;
1604         pin_range->range.gc = chip;
1605         pin_range->range.name = chip->label;
1606         pin_range->range.base = chip->base + gpio_offset;
1607         pin_range->pctldev = pctldev;
1608
1609         ret = pinctrl_get_group_pins(pctldev, pin_group,
1610                                         &pin_range->range.pins,
1611                                         &pin_range->range.npins);
1612         if (ret < 0) {
1613                 kfree(pin_range);
1614                 return ret;
1615         }
1616
1617         pinctrl_add_gpio_range(pctldev, &pin_range->range);
1618
1619         chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
1620                  gpio_offset, gpio_offset + pin_range->range.npins - 1,
1621                  pinctrl_dev_get_devname(pctldev), pin_group);
1622
1623         list_add_tail(&pin_range->node, &chip->pin_ranges);
1624
1625         return 0;
1626 }
1627 EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);
1628
1629 /**
1630  * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
1631  * @chip: the gpiochip to add the range for
1632  * @pinctrl_name: the dev_name() of the pin controller to map to
1633  * @gpio_offset: the start offset in the current gpio_chip number space
1634  * @pin_offset: the start offset in the pin controller number space
1635  * @npins: the number of pins from the offset of each pin space (GPIO and
1636  *      pin controller) to accumulate in this range
1637  */
1638 int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
1639                            unsigned int gpio_offset, unsigned int pin_offset,
1640                            unsigned int npins)
1641 {
1642         struct gpio_pin_range *pin_range;
1643         int ret;
1644
1645         pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1646         if (!pin_range) {
1647                 chip_err(chip, "failed to allocate pin ranges\n");
1648                 return -ENOMEM;
1649         }
1650
1651         /* Use local offset as range ID */
1652         pin_range->range.id = gpio_offset;
1653         pin_range->range.gc = chip;
1654         pin_range->range.name = chip->label;
1655         pin_range->range.base = chip->base + gpio_offset;
1656         pin_range->range.pin_base = pin_offset;
1657         pin_range->range.npins = npins;
1658         pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
1659                         &pin_range->range);
1660         if (IS_ERR(pin_range->pctldev)) {
1661                 ret = PTR_ERR(pin_range->pctldev);
1662                 chip_err(chip, "could not create pin range\n");
1663                 kfree(pin_range);
1664                 return ret;
1665         }
1666         chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
1667                  gpio_offset, gpio_offset + npins - 1,
1668                  pinctl_name,
1669                  pin_offset, pin_offset + npins - 1);
1670
1671         list_add_tail(&pin_range->node, &chip->pin_ranges);
1672
1673         return 0;
1674 }
1675 EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
1676
1677 /**
1678  * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
1679  * @chip: the chip to remove all the mappings for
1680  */
1681 void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
1682 {
1683         struct gpio_pin_range *pin_range, *tmp;
1684
1685         list_for_each_entry_safe(pin_range, tmp, &chip->pin_ranges, node) {
1686                 list_del(&pin_range->node);
1687                 pinctrl_remove_gpio_range(pin_range->pctldev,
1688                                 &pin_range->range);
1689                 kfree(pin_range);
1690         }
1691 }
1692 EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
1693
1694 #endif /* CONFIG_PINCTRL */
1695
1696 /* These "optional" allocation calls help prevent drivers from stomping
1697  * on each other, and help provide better diagnostics in debugfs.
1698  * They're called even less than the "set direction" calls.
1699  */
1700 static int __gpiod_request(struct gpio_desc *desc, const char *label)
1701 {
1702         struct gpio_chip        *chip = desc->chip;
1703         int                     status;
1704         unsigned long           flags;
1705
1706         spin_lock_irqsave(&gpio_lock, flags);
1707
1708         /* NOTE:  gpio_request() can be called in early boot,
1709          * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
1710          */
1711
1712         if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
1713                 desc_set_label(desc, label ? : "?");
1714                 status = 0;
1715         } else {
1716                 status = -EBUSY;
1717                 goto done;
1718         }
1719
1720         if (chip->request) {
1721                 /* chip->request may sleep */
1722                 spin_unlock_irqrestore(&gpio_lock, flags);
1723                 status = chip->request(chip, gpio_chip_hwgpio(desc));
1724                 spin_lock_irqsave(&gpio_lock, flags);
1725
1726                 if (status < 0) {
1727                         desc_set_label(desc, NULL);
1728                         clear_bit(FLAG_REQUESTED, &desc->flags);
1729                         goto done;
1730                 }
1731         }
1732         if (chip->get_direction) {
1733                 /* chip->get_direction may sleep */
1734                 spin_unlock_irqrestore(&gpio_lock, flags);
1735                 gpiod_get_direction(desc);
1736                 spin_lock_irqsave(&gpio_lock, flags);
1737         }
1738 done:
1739         spin_unlock_irqrestore(&gpio_lock, flags);
1740         return status;
1741 }
1742
1743 static int gpiod_request(struct gpio_desc *desc, const char *label)
1744 {
1745         int status = -EPROBE_DEFER;
1746         struct gpio_chip *chip;
1747
1748         if (!desc) {
1749                 pr_warn("%s: invalid GPIO\n", __func__);
1750                 return -EINVAL;
1751         }
1752
1753         chip = desc->chip;
1754         if (!chip)
1755                 goto done;
1756
1757         if (try_module_get(chip->owner)) {
1758                 status = __gpiod_request(desc, label);
1759                 if (status < 0)
1760                         module_put(chip->owner);
1761         }
1762
1763 done:
1764         if (status)
1765                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1766
1767         return status;
1768 }
1769
1770 int gpio_request(unsigned gpio, const char *label)
1771 {
1772         return gpiod_request(gpio_to_desc(gpio), label);
1773 }
1774 EXPORT_SYMBOL_GPL(gpio_request);
1775
1776 static bool __gpiod_free(struct gpio_desc *desc)
1777 {
1778         bool                    ret = false;
1779         unsigned long           flags;
1780         struct gpio_chip        *chip;
1781
1782         might_sleep();
1783
1784         gpiod_unexport(desc);
1785
1786         spin_lock_irqsave(&gpio_lock, flags);
1787
1788         chip = desc->chip;
1789         if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
1790                 if (chip->free) {
1791                         spin_unlock_irqrestore(&gpio_lock, flags);
1792                         might_sleep_if(chip->can_sleep);
1793                         chip->free(chip, gpio_chip_hwgpio(desc));
1794                         spin_lock_irqsave(&gpio_lock, flags);
1795                 }
1796                 desc_set_label(desc, NULL);
1797                 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
1798                 clear_bit(FLAG_REQUESTED, &desc->flags);
1799                 clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
1800                 clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
1801                 ret = true;
1802         }
1803
1804         spin_unlock_irqrestore(&gpio_lock, flags);
1805         return ret;
1806 }
1807
1808 static void gpiod_free(struct gpio_desc *desc)
1809 {
1810         if (desc && __gpiod_free(desc))
1811                 module_put(desc->chip->owner);
1812         else
1813                 WARN_ON(extra_checks);
1814 }
1815
1816 void gpio_free(unsigned gpio)
1817 {
1818         gpiod_free(gpio_to_desc(gpio));
1819 }
1820 EXPORT_SYMBOL_GPL(gpio_free);
1821
1822 /**
1823  * gpio_request_one - request a single GPIO with initial configuration
1824  * @gpio:       the GPIO number
1825  * @flags:      GPIO configuration as specified by GPIOF_*
1826  * @label:      a literal description string of this GPIO
1827  */
1828 int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
1829 {
1830         struct gpio_desc *desc;
1831         int err;
1832
1833         desc = gpio_to_desc(gpio);
1834
1835         err = gpiod_request(desc, label);
1836         if (err)
1837                 return err;
1838
1839         if (flags & GPIOF_OPEN_DRAIN)
1840                 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
1841
1842         if (flags & GPIOF_OPEN_SOURCE)
1843                 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
1844
1845         if (flags & GPIOF_DIR_IN)
1846                 err = gpiod_direction_input(desc);
1847         else
1848                 err = gpiod_direction_output_raw(desc,
1849                                 (flags & GPIOF_INIT_HIGH) ? 1 : 0);
1850
1851         if (err)
1852                 goto free_gpio;
1853
1854         if (flags & GPIOF_EXPORT) {
1855                 err = gpiod_export(desc, flags & GPIOF_EXPORT_CHANGEABLE);
1856                 if (err)
1857                         goto free_gpio;
1858         }
1859
1860         return 0;
1861
1862  free_gpio:
1863         gpiod_free(desc);
1864         return err;
1865 }
1866 EXPORT_SYMBOL_GPL(gpio_request_one);
1867
1868 /**
1869  * gpio_request_array - request multiple GPIOs in a single call
1870  * @array:      array of the 'struct gpio'
1871  * @num:        how many GPIOs in the array
1872  */
1873 int gpio_request_array(const struct gpio *array, size_t num)
1874 {
1875         int i, err;
1876
1877         for (i = 0; i < num; i++, array++) {
1878                 err = gpio_request_one(array->gpio, array->flags, array->label);
1879                 if (err)
1880                         goto err_free;
1881         }
1882         return 0;
1883
1884 err_free:
1885         while (i--)
1886                 gpio_free((--array)->gpio);
1887         return err;
1888 }
1889 EXPORT_SYMBOL_GPL(gpio_request_array);
1890
1891 /**
1892  * gpio_free_array - release multiple GPIOs in a single call
1893  * @array:      array of the 'struct gpio'
1894  * @num:        how many GPIOs in the array
1895  */
1896 void gpio_free_array(const struct gpio *array, size_t num)
1897 {
1898         while (num--)
1899                 gpio_free((array++)->gpio);
1900 }
1901 EXPORT_SYMBOL_GPL(gpio_free_array);
1902
1903 /**
1904  * gpiochip_is_requested - return string iff signal was requested
1905  * @chip: controller managing the signal
1906  * @offset: of signal within controller's 0..(ngpio - 1) range
1907  *
1908  * Returns NULL if the GPIO is not currently requested, else a string.
1909  * If debugfs support is enabled, the string returned is the label passed
1910  * to gpio_request(); otherwise it is a meaningless constant.
1911  *
1912  * This function is for use by GPIO controller drivers.  The label can
1913  * help with diagnostics, and knowing that the signal is used as a GPIO
1914  * can help avoid accidentally multiplexing it to another controller.
1915  */
1916 const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
1917 {
1918         struct gpio_desc *desc;
1919
1920         if (!GPIO_OFFSET_VALID(chip, offset))
1921                 return NULL;
1922
1923         desc = &chip->desc[offset];
1924
1925         if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
1926                 return NULL;
1927 #ifdef CONFIG_DEBUG_FS
1928         return desc->label;
1929 #else
1930         return "?";
1931 #endif
1932 }
1933 EXPORT_SYMBOL_GPL(gpiochip_is_requested);
1934
1935 /**
1936  * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor
1937  * @desc: GPIO descriptor to request
1938  * @label: label for the GPIO
1939  *
1940  * Function allows GPIO chip drivers to request and use their own GPIO
1941  * descriptors via gpiolib API. Difference to gpiod_request() is that this
1942  * function will not increase reference count of the GPIO chip module. This
1943  * allows the GPIO chip module to be unloaded as needed (we assume that the
1944  * GPIO chip driver handles freeing the GPIOs it has requested).
1945  */
1946 int gpiochip_request_own_desc(struct gpio_desc *desc, const char *label)
1947 {
1948         if (!desc || !desc->chip)
1949                 return -EINVAL;
1950
1951         return __gpiod_request(desc, label);
1952 }
1953
1954 /**
1955  * gpiochip_free_own_desc - Free GPIO requested by the chip driver
1956  * @desc: GPIO descriptor to free
1957  *
1958  * Function frees the given GPIO requested previously with
1959  * gpiochip_request_own_desc().
1960  */
1961 void gpiochip_free_own_desc(struct gpio_desc *desc)
1962 {
1963         if (desc)
1964                 __gpiod_free(desc);
1965 }
1966
1967 /* Drivers MUST set GPIO direction before making get/set calls.  In
1968  * some cases this is done in early boot, before IRQs are enabled.
1969  *
1970  * As a rule these aren't called more than once (except for drivers
1971  * using the open-drain emulation idiom) so these are natural places
1972  * to accumulate extra debugging checks.  Note that we can't (yet)
1973  * rely on gpio_request() having been called beforehand.
1974  */
1975
1976 /**
1977  * gpiod_direction_input - set the GPIO direction to input
1978  * @desc:       GPIO to set to input
1979  *
1980  * Set the direction of the passed GPIO to input, such as gpiod_get_value() can
1981  * be called safely on it.
1982  *
1983  * Return 0 in case of success, else an error code.
1984  */
1985 int gpiod_direction_input(struct gpio_desc *desc)
1986 {
1987         unsigned long           flags;
1988         struct gpio_chip        *chip;
1989         int                     status = -EINVAL;
1990         int                     offset;
1991
1992         if (!desc || !desc->chip) {
1993                 pr_warn("%s: invalid GPIO\n", __func__);
1994                 return -EINVAL;
1995         }
1996
1997         chip = desc->chip;
1998         if (!chip->get || !chip->direction_input) {
1999                 gpiod_warn(desc,
2000                         "%s: missing get() or direction_input() operations\n",
2001                         __func__);
2002                 return -EIO;
2003         }
2004
2005         spin_lock_irqsave(&gpio_lock, flags);
2006
2007         status = gpio_ensure_requested(desc);
2008         if (status < 0)
2009                 goto fail;
2010
2011         /* now we know the gpio is valid and chip won't vanish */
2012
2013         spin_unlock_irqrestore(&gpio_lock, flags);
2014
2015         might_sleep_if(chip->can_sleep);
2016
2017         offset = gpio_chip_hwgpio(desc);
2018         if (status) {
2019                 status = chip->request(chip, offset);
2020                 if (status < 0) {
2021                         gpiod_dbg(desc, "%s: chip request fail, %d\n",
2022                                         __func__, status);
2023                         /* and it's not available to anyone else ...
2024                          * gpio_request() is the fully clean solution.
2025                          */
2026                         goto lose;
2027                 }
2028         }
2029
2030         status = chip->direction_input(chip, offset);
2031         if (status == 0)
2032                 clear_bit(FLAG_IS_OUT, &desc->flags);
2033
2034         trace_gpio_direction(desc_to_gpio(desc), 1, status);
2035 lose:
2036         return status;
2037 fail:
2038         spin_unlock_irqrestore(&gpio_lock, flags);
2039         if (status)
2040                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
2041         return status;
2042 }
2043 EXPORT_SYMBOL_GPL(gpiod_direction_input);
2044
2045 static int _gpiod_direction_output_raw(struct gpio_desc *desc, int value)
2046 {
2047         unsigned long           flags;
2048         struct gpio_chip        *chip;
2049         int                     status = -EINVAL;
2050         int offset;
2051
2052         /* GPIOs used for IRQs shall not be set as output */
2053         if (test_bit(FLAG_USED_AS_IRQ, &desc->flags)) {
2054                 gpiod_err(desc,
2055                           "%s: tried to set a GPIO tied to an IRQ as output\n",
2056                           __func__);
2057                 return -EIO;
2058         }
2059
2060         /* Open drain pin should not be driven to 1 */
2061         if (value && test_bit(FLAG_OPEN_DRAIN,  &desc->flags))
2062                 return gpiod_direction_input(desc);
2063
2064         /* Open source pin should not be driven to 0 */
2065         if (!value && test_bit(FLAG_OPEN_SOURCE,  &desc->flags))
2066                 return gpiod_direction_input(desc);
2067
2068         chip = desc->chip;
2069         if (!chip->set || !chip->direction_output) {
2070                 gpiod_warn(desc,
2071                        "%s: missing set() or direction_output() operations\n",
2072                        __func__);
2073                 return -EIO;
2074         }
2075
2076         spin_lock_irqsave(&gpio_lock, flags);
2077
2078         status = gpio_ensure_requested(desc);
2079         if (status < 0)
2080                 goto fail;
2081
2082         /* now we know the gpio is valid and chip won't vanish */
2083
2084         spin_unlock_irqrestore(&gpio_lock, flags);
2085
2086         might_sleep_if(chip->can_sleep);
2087
2088         offset = gpio_chip_hwgpio(desc);
2089         if (status) {
2090                 status = chip->request(chip, offset);
2091                 if (status < 0) {
2092                         gpiod_dbg(desc, "%s: chip request fail, %d\n",
2093                                         __func__, status);
2094                         /* and it's not available to anyone else ...
2095                          * gpio_request() is the fully clean solution.
2096                          */
2097                         goto lose;
2098                 }
2099         }
2100
2101         status = chip->direction_output(chip, offset, value);
2102         if (status == 0)
2103                 set_bit(FLAG_IS_OUT, &desc->flags);
2104         trace_gpio_value(desc_to_gpio(desc), 0, value);
2105         trace_gpio_direction(desc_to_gpio(desc), 0, status);
2106 lose:
2107         return status;
2108 fail:
2109         spin_unlock_irqrestore(&gpio_lock, flags);
2110         if (status)
2111                 gpiod_dbg(desc, "%s: gpio status %d\n", __func__, status);
2112         return status;
2113 }
2114
2115 /**
2116  * gpiod_direction_output_raw - set the GPIO direction to output
2117  * @desc:       GPIO to set to output
2118  * @value:      initial output value of the GPIO
2119  *
2120  * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
2121  * be called safely on it. The initial value of the output must be specified
2122  * as raw value on the physical line without regard for the ACTIVE_LOW status.
2123  *
2124  * Return 0 in case of success, else an error code.
2125  */
2126 int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
2127 {
2128         if (!desc || !desc->chip) {
2129                 pr_warn("%s: invalid GPIO\n", __func__);
2130                 return -EINVAL;
2131         }
2132         return _gpiod_direction_output_raw(desc, value);
2133 }
2134 EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);
2135
2136 /**
2137  * gpiod_direction_output - set the GPIO direction to output
2138  * @desc:       GPIO to set to output
2139  * @value:      initial output value of the GPIO
2140  *
2141  * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
2142  * be called safely on it. The initial value of the output must be specified
2143  * as the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2144  * account.
2145  *
2146  * Return 0 in case of success, else an error code.
2147  */
2148 int gpiod_direction_output(struct gpio_desc *desc, int value)
2149 {
2150         if (!desc || !desc->chip) {
2151                 pr_warn("%s: invalid GPIO\n", __func__);
2152                 return -EINVAL;
2153         }
2154         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2155                 value = !value;
2156         return _gpiod_direction_output_raw(desc, value);
2157 }
2158 EXPORT_SYMBOL_GPL(gpiod_direction_output);
2159
2160 /**
2161  * gpiod_set_debounce - sets @debounce time for a @gpio
2162  * @gpio: the gpio to set debounce time
2163  * @debounce: debounce time is microseconds
2164  *
2165  * returns -ENOTSUPP if the controller does not support setting
2166  * debounce.
2167  */
2168 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
2169 {
2170         unsigned long           flags;
2171         struct gpio_chip        *chip;
2172         int                     status = -EINVAL;
2173         int                     offset;
2174
2175         if (!desc || !desc->chip) {
2176                 pr_warn("%s: invalid GPIO\n", __func__);
2177                 return -EINVAL;
2178         }
2179
2180         chip = desc->chip;
2181         if (!chip->set || !chip->set_debounce) {
2182                 gpiod_dbg(desc,
2183                           "%s: missing set() or set_debounce() operations\n",
2184                           __func__);
2185                 return -ENOTSUPP;
2186         }
2187
2188         spin_lock_irqsave(&gpio_lock, flags);
2189
2190         status = gpio_ensure_requested(desc);
2191         if (status < 0)
2192                 goto fail;
2193
2194         /* now we know the gpio is valid and chip won't vanish */
2195
2196         spin_unlock_irqrestore(&gpio_lock, flags);
2197
2198         might_sleep_if(chip->can_sleep);
2199
2200         offset = gpio_chip_hwgpio(desc);
2201         return chip->set_debounce(chip, offset, debounce);
2202
2203 fail:
2204         spin_unlock_irqrestore(&gpio_lock, flags);
2205         if (status)
2206                 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
2207
2208         return status;
2209 }
2210 EXPORT_SYMBOL_GPL(gpiod_set_debounce);
2211
2212 /**
2213  * gpiod_is_active_low - test whether a GPIO is active-low or not
2214  * @desc: the gpio descriptor to test
2215  *
2216  * Returns 1 if the GPIO is active-low, 0 otherwise.
2217  */
2218 int gpiod_is_active_low(const struct gpio_desc *desc)
2219 {
2220         return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
2221 }
2222 EXPORT_SYMBOL_GPL(gpiod_is_active_low);
2223
2224 /* I/O calls are only valid after configuration completed; the relevant
2225  * "is this a valid GPIO" error checks should already have been done.
2226  *
2227  * "Get" operations are often inlinable as reading a pin value register,
2228  * and masking the relevant bit in that register.
2229  *
2230  * When "set" operations are inlinable, they involve writing that mask to
2231  * one register to set a low value, or a different register to set it high.
2232  * Otherwise locking is needed, so there may be little value to inlining.
2233  *
2234  *------------------------------------------------------------------------
2235  *
2236  * IMPORTANT!!!  The hot paths -- get/set value -- assume that callers
2237  * have requested the GPIO.  That can include implicit requesting by
2238  * a direction setting call.  Marking a gpio as requested locks its chip
2239  * in memory, guaranteeing that these table lookups need no more locking
2240  * and that gpiochip_remove() will fail.
2241  *
2242  * REVISIT when debugging, consider adding some instrumentation to ensure
2243  * that the GPIO was actually requested.
2244  */
2245
2246 static bool _gpiod_get_raw_value(const struct gpio_desc *desc)
2247 {
2248         struct gpio_chip        *chip;
2249         bool value;
2250         int offset;
2251
2252         chip = desc->chip;
2253         offset = gpio_chip_hwgpio(desc);
2254         value = chip->get ? chip->get(chip, offset) : false;
2255         trace_gpio_value(desc_to_gpio(desc), 1, value);
2256         return value;
2257 }
2258
2259 /**
2260  * gpiod_get_raw_value() - return a gpio's raw value
2261  * @desc: gpio whose value will be returned
2262  *
2263  * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2264  * its ACTIVE_LOW status.
2265  *
2266  * This function should be called from contexts where we cannot sleep, and will
2267  * complain if the GPIO chip functions potentially sleep.
2268  */
2269 int gpiod_get_raw_value(const struct gpio_desc *desc)
2270 {
2271         if (!desc)
2272                 return 0;
2273         /* Should be using gpio_get_value_cansleep() */
2274         WARN_ON(desc->chip->can_sleep);
2275         return _gpiod_get_raw_value(desc);
2276 }
2277 EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
2278
2279 /**
2280  * gpiod_get_value() - return a gpio's value
2281  * @desc: gpio whose value will be returned
2282  *
2283  * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
2284  * account.
2285  *
2286  * This function should be called from contexts where we cannot sleep, and will
2287  * complain if the GPIO chip functions potentially sleep.
2288  */
2289 int gpiod_get_value(const struct gpio_desc *desc)
2290 {
2291         int value;
2292         if (!desc)
2293                 return 0;
2294         /* Should be using gpio_get_value_cansleep() */
2295         WARN_ON(desc->chip->can_sleep);
2296
2297         value = _gpiod_get_raw_value(desc);
2298         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2299                 value = !value;
2300
2301         return value;
2302 }
2303 EXPORT_SYMBOL_GPL(gpiod_get_value);
2304
2305 /*
2306  *  _gpio_set_open_drain_value() - Set the open drain gpio's value.
2307  * @desc: gpio descriptor whose state need to be set.
2308  * @value: Non-zero for setting it HIGH otherise it will set to LOW.
2309  */
2310 static void _gpio_set_open_drain_value(struct gpio_desc *desc, bool value)
2311 {
2312         int err = 0;
2313         struct gpio_chip *chip = desc->chip;
2314         int offset = gpio_chip_hwgpio(desc);
2315
2316         if (value) {
2317                 err = chip->direction_input(chip, offset);
2318                 if (!err)
2319                         clear_bit(FLAG_IS_OUT, &desc->flags);
2320         } else {
2321                 err = chip->direction_output(chip, offset, 0);
2322                 if (!err)
2323                         set_bit(FLAG_IS_OUT, &desc->flags);
2324         }
2325         trace_gpio_direction(desc_to_gpio(desc), value, err);
2326         if (err < 0)
2327                 gpiod_err(desc,
2328                           "%s: Error in set_value for open drain err %d\n",
2329                           __func__, err);
2330 }
2331
2332 /*
2333  *  _gpio_set_open_source_value() - Set the open source gpio's value.
2334  * @desc: gpio descriptor whose state need to be set.
2335  * @value: Non-zero for setting it HIGH otherise it will set to LOW.
2336  */
2337 static void _gpio_set_open_source_value(struct gpio_desc *desc, bool value)
2338 {
2339         int err = 0;
2340         struct gpio_chip *chip = desc->chip;
2341         int offset = gpio_chip_hwgpio(desc);
2342
2343         if (value) {
2344                 err = chip->direction_output(chip, offset, 1);
2345                 if (!err)
2346                         set_bit(FLAG_IS_OUT, &desc->flags);
2347         } else {
2348                 err = chip->direction_input(chip, offset);
2349                 if (!err)
2350                         clear_bit(FLAG_IS_OUT, &desc->flags);
2351         }
2352         trace_gpio_direction(desc_to_gpio(desc), !value, err);
2353         if (err < 0)
2354                 gpiod_err(desc,
2355                           "%s: Error in set_value for open source err %d\n",
2356                           __func__, err);
2357 }
2358
2359 static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value)
2360 {
2361         struct gpio_chip        *chip;
2362
2363         chip = desc->chip;
2364         trace_gpio_value(desc_to_gpio(desc), 0, value);
2365         if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
2366                 _gpio_set_open_drain_value(desc, value);
2367         else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
2368                 _gpio_set_open_source_value(desc, value);
2369         else
2370                 chip->set(chip, gpio_chip_hwgpio(desc), value);
2371 }
2372
2373 /**
2374  * gpiod_set_raw_value() - assign a gpio's raw value
2375  * @desc: gpio whose value will be assigned
2376  * @value: value to assign
2377  *
2378  * Set the raw value of the GPIO, i.e. the value of its physical line without
2379  * regard for its ACTIVE_LOW status.
2380  *
2381  * This function should be called from contexts where we cannot sleep, and will
2382  * complain if the GPIO chip functions potentially sleep.
2383  */
2384 void gpiod_set_raw_value(struct gpio_desc *desc, int value)
2385 {
2386         if (!desc)
2387                 return;
2388         /* Should be using gpio_set_value_cansleep() */
2389         WARN_ON(desc->chip->can_sleep);
2390         _gpiod_set_raw_value(desc, value);
2391 }
2392 EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
2393
2394 /**
2395  * gpiod_set_value() - assign a gpio's value
2396  * @desc: gpio whose value will be assigned
2397  * @value: value to assign
2398  *
2399  * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2400  * account
2401  *
2402  * This function should be called from contexts where we cannot sleep, and will
2403  * complain if the GPIO chip functions potentially sleep.
2404  */
2405 void gpiod_set_value(struct gpio_desc *desc, int value)
2406 {
2407         if (!desc)
2408                 return;
2409         /* Should be using gpio_set_value_cansleep() */
2410         WARN_ON(desc->chip->can_sleep);
2411         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2412                 value = !value;
2413         _gpiod_set_raw_value(desc, value);
2414 }
2415 EXPORT_SYMBOL_GPL(gpiod_set_value);
2416
2417 /**
2418  * gpiod_cansleep() - report whether gpio value access may sleep
2419  * @desc: gpio to check
2420  *
2421  */
2422 int gpiod_cansleep(const struct gpio_desc *desc)
2423 {
2424         if (!desc)
2425                 return 0;
2426         return desc->chip->can_sleep;
2427 }
2428 EXPORT_SYMBOL_GPL(gpiod_cansleep);
2429
2430 /**
2431  * gpiod_to_irq() - return the IRQ corresponding to a GPIO
2432  * @desc: gpio whose IRQ will be returned (already requested)
2433  *
2434  * Return the IRQ corresponding to the passed GPIO, or an error code in case of
2435  * error.
2436  */
2437 int gpiod_to_irq(const struct gpio_desc *desc)
2438 {
2439         struct gpio_chip        *chip;
2440         int                     offset;
2441
2442         if (!desc)
2443                 return -EINVAL;
2444         chip = desc->chip;
2445         offset = gpio_chip_hwgpio(desc);
2446         return chip->to_irq ? chip->to_irq(chip, offset) : -ENXIO;
2447 }
2448 EXPORT_SYMBOL_GPL(gpiod_to_irq);
2449
2450 /**
2451  * gpiod_lock_as_irq() - lock a GPIO to be used as IRQ
2452  * @gpio: the GPIO line to lock as used for IRQ
2453  *
2454  * This is used directly by GPIO drivers that want to lock down
2455  * a certain GPIO line to be used for IRQs.
2456  */
2457 int gpiod_lock_as_irq(struct gpio_desc *desc)
2458 {
2459         if (!desc)
2460                 return -EINVAL;
2461
2462         if (test_bit(FLAG_IS_OUT, &desc->flags)) {
2463                 gpiod_err(desc,
2464                           "%s: tried to flag a GPIO set as output for IRQ\n",
2465                           __func__);
2466                 return -EIO;
2467         }
2468
2469         set_bit(FLAG_USED_AS_IRQ, &desc->flags);
2470         return 0;
2471 }
2472 EXPORT_SYMBOL_GPL(gpiod_lock_as_irq);
2473
2474 int gpio_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
2475 {
2476         return gpiod_lock_as_irq(gpiochip_get_desc(chip, offset));
2477 }
2478 EXPORT_SYMBOL_GPL(gpio_lock_as_irq);
2479
2480 /**
2481  * gpiod_unlock_as_irq() - unlock a GPIO used as IRQ
2482  * @gpio: the GPIO line to unlock from IRQ usage
2483  *
2484  * This is used directly by GPIO drivers that want to indicate
2485  * that a certain GPIO is no longer used exclusively for IRQ.
2486  */
2487 void gpiod_unlock_as_irq(struct gpio_desc *desc)
2488 {
2489         if (!desc)
2490                 return;
2491
2492         clear_bit(FLAG_USED_AS_IRQ, &desc->flags);
2493 }
2494 EXPORT_SYMBOL_GPL(gpiod_unlock_as_irq);
2495
2496 void gpio_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
2497 {
2498         return gpiod_unlock_as_irq(gpiochip_get_desc(chip, offset));
2499 }
2500 EXPORT_SYMBOL_GPL(gpio_unlock_as_irq);
2501
2502 /**
2503  * gpiod_get_raw_value_cansleep() - return a gpio's raw value
2504  * @desc: gpio whose value will be returned
2505  *
2506  * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2507  * its ACTIVE_LOW status.
2508  *
2509  * This function is to be called from contexts that can sleep.
2510  */
2511 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
2512 {
2513         might_sleep_if(extra_checks);
2514         if (!desc)
2515                 return 0;
2516         return _gpiod_get_raw_value(desc);
2517 }
2518 EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
2519
2520 /**
2521  * gpiod_get_value_cansleep() - return a gpio's value
2522  * @desc: gpio whose value will be returned
2523  *
2524  * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
2525  * account.
2526  *
2527  * This function is to be called from contexts that can sleep.
2528  */
2529 int gpiod_get_value_cansleep(const struct gpio_desc *desc)
2530 {
2531         int value;
2532
2533         might_sleep_if(extra_checks);
2534         if (!desc)
2535                 return 0;
2536
2537         value = _gpiod_get_raw_value(desc);
2538         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2539                 value = !value;
2540
2541         return value;
2542 }
2543 EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
2544
2545 /**
2546  * gpiod_set_raw_value_cansleep() - assign a gpio's raw value
2547  * @desc: gpio whose value will be assigned
2548  * @value: value to assign
2549  *
2550  * Set the raw value of the GPIO, i.e. the value of its physical line without
2551  * regard for its ACTIVE_LOW status.
2552  *
2553  * This function is to be called from contexts that can sleep.
2554  */
2555 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value)
2556 {
2557         might_sleep_if(extra_checks);
2558         if (!desc)
2559                 return;
2560         _gpiod_set_raw_value(desc, value);
2561 }
2562 EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
2563
2564 /**
2565  * gpiod_set_value_cansleep() - assign a gpio's value
2566  * @desc: gpio whose value will be assigned
2567  * @value: value to assign
2568  *
2569  * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2570  * account
2571  *
2572  * This function is to be called from contexts that can sleep.
2573  */
2574 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
2575 {
2576         might_sleep_if(extra_checks);
2577         if (!desc)
2578                 return;
2579
2580         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2581                 value = !value;
2582         _gpiod_set_raw_value(desc, value);
2583 }
2584 EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
2585
2586 /**
2587  * gpiod_add_lookup_table() - register GPIO device consumers
2588  * @table: table of consumers to register
2589  */
2590 void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
2591 {
2592         mutex_lock(&gpio_lookup_lock);
2593
2594         list_add_tail(&table->list, &gpio_lookup_list);
2595
2596         mutex_unlock(&gpio_lookup_lock);
2597 }
2598
2599 static struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
2600                                       unsigned int idx,
2601                                       enum gpio_lookup_flags *flags)
2602 {
2603         static const char *suffixes[] = { "gpios", "gpio" };
2604         char prop_name[32]; /* 32 is max size of property name */
2605         enum of_gpio_flags of_flags;
2606         struct gpio_desc *desc;
2607         unsigned int i;
2608
2609         for (i = 0; i < ARRAY_SIZE(suffixes); i++) {
2610                 if (con_id)
2611                         snprintf(prop_name, 32, "%s-%s", con_id, suffixes[i]);
2612                 else
2613                         snprintf(prop_name, 32, "%s", suffixes[i]);
2614
2615                 desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx,
2616                                                 &of_flags);
2617                 if (!IS_ERR(desc))
2618                         break;
2619         }
2620
2621         if (IS_ERR(desc))
2622                 return desc;
2623
2624         if (of_flags & OF_GPIO_ACTIVE_LOW)
2625                 *flags |= GPIO_ACTIVE_LOW;
2626
2627         return desc;
2628 }
2629
2630 static struct gpio_desc *acpi_find_gpio(struct device *dev, const char *con_id,
2631                                         unsigned int idx,
2632                                         enum gpio_lookup_flags *flags)
2633 {
2634         struct acpi_gpio_info info;
2635         struct gpio_desc *desc;
2636
2637         desc = acpi_get_gpiod_by_index(dev, idx, &info);
2638         if (IS_ERR(desc))
2639                 return desc;
2640
2641         if (info.gpioint && info.active_low)
2642                 *flags |= GPIO_ACTIVE_LOW;
2643
2644         return desc;
2645 }
2646
2647 static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
2648 {
2649         const char *dev_id = dev ? dev_name(dev) : NULL;
2650         struct gpiod_lookup_table *table;
2651
2652         mutex_lock(&gpio_lookup_lock);
2653
2654         list_for_each_entry(table, &gpio_lookup_list, list) {
2655                 if (table->dev_id && dev_id) {
2656                         /*
2657                          * Valid strings on both ends, must be identical to have
2658                          * a match
2659                          */
2660                         if (!strcmp(table->dev_id, dev_id))
2661                                 goto found;
2662                 } else {
2663                         /*
2664                          * One of the pointers is NULL, so both must be to have
2665                          * a match
2666                          */
2667                         if (dev_id == table->dev_id)
2668                                 goto found;
2669                 }
2670         }
2671         table = NULL;
2672
2673 found:
2674         mutex_unlock(&gpio_lookup_lock);
2675         return table;
2676 }
2677
2678 static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
2679                                     unsigned int idx,
2680                                     enum gpio_lookup_flags *flags)
2681 {
2682         struct gpio_desc *desc = ERR_PTR(-ENOENT);
2683         struct gpiod_lookup_table *table;
2684         struct gpiod_lookup *p;
2685
2686         table = gpiod_find_lookup_table(dev);
2687         if (!table)
2688                 return desc;
2689
2690         for (p = &table->table[0]; p->chip_label; p++) {
2691                 struct gpio_chip *chip;
2692
2693                 /* idx must always match exactly */
2694                 if (p->idx != idx)
2695                         continue;
2696
2697                 /* If the lookup entry has a con_id, require exact match */
2698                 if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
2699                         continue;
2700
2701                 chip = find_chip_by_name(p->chip_label);
2702
2703                 if (!chip) {
2704                         dev_err(dev, "cannot find GPIO chip %s\n",
2705                                 p->chip_label);
2706                         return ERR_PTR(-ENODEV);
2707                 }
2708
2709                 if (chip->ngpio <= p->chip_hwnum) {
2710                         dev_err(dev,
2711                                 "requested GPIO %d is out of range [0..%d] for chip %s\n",
2712                                 idx, chip->ngpio, chip->label);
2713                         return ERR_PTR(-EINVAL);
2714                 }
2715
2716                 desc = gpiochip_get_desc(chip, p->chip_hwnum);
2717                 *flags = p->flags;
2718
2719                 return desc;
2720         }
2721
2722         return desc;
2723 }
2724
2725 /**
2726  * gpiod_get - obtain a GPIO for a given GPIO function
2727  * @dev:        GPIO consumer, can be NULL for system-global GPIOs
2728  * @con_id:     function within the GPIO consumer
2729  *
2730  * Return the GPIO descriptor corresponding to the function con_id of device
2731  * dev, -ENOENT if no GPIO has been assigned to the requested function, or
2732  * another IS_ERR() code if an error occured while trying to acquire the GPIO.
2733  */
2734 struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id)
2735 {
2736         return gpiod_get_index(dev, con_id, 0);
2737 }
2738 EXPORT_SYMBOL_GPL(gpiod_get);
2739
2740 /**
2741  * gpiod_get_optional - obtain an optional GPIO for a given GPIO function
2742  * @dev: GPIO consumer, can be NULL for system-global GPIOs
2743  * @con_id: function within the GPIO consumer
2744  *
2745  * This is equivalent to gpiod_get(), except that when no GPIO was assigned to
2746  * the requested function it will return NULL. This is convenient for drivers
2747  * that need to handle optional GPIOs.
2748  */
2749 struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
2750                                                   const char *con_id)
2751 {
2752         return gpiod_get_index_optional(dev, con_id, 0);
2753 }
2754 EXPORT_SYMBOL_GPL(gpiod_get_optional);
2755
2756 /**
2757  * gpiod_get_index - obtain a GPIO from a multi-index GPIO function
2758  * @dev:        GPIO consumer, can be NULL for system-global GPIOs
2759  * @con_id:     function within the GPIO consumer
2760  * @idx:        index of the GPIO to obtain in the consumer
2761  *
2762  * This variant of gpiod_get() allows to access GPIOs other than the first
2763  * defined one for functions that define several GPIOs.
2764  *
2765  * Return a valid GPIO descriptor, -ENOENT if no GPIO has been assigned to the
2766  * requested function and/or index, or another IS_ERR() code if an error
2767  * occured while trying to acquire the GPIO.
2768  */
2769 struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
2770                                                const char *con_id,
2771                                                unsigned int idx)
2772 {
2773         struct gpio_desc *desc = NULL;
2774         int status;
2775         enum gpio_lookup_flags flags = 0;
2776
2777         dev_dbg(dev, "GPIO lookup for consumer %s\n", con_id);
2778
2779         /* Using device tree? */
2780         if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node) {
2781                 dev_dbg(dev, "using device tree for GPIO lookup\n");
2782                 desc = of_find_gpio(dev, con_id, idx, &flags);
2783         } else if (IS_ENABLED(CONFIG_ACPI) && dev && ACPI_HANDLE(dev)) {
2784                 dev_dbg(dev, "using ACPI for GPIO lookup\n");
2785                 desc = acpi_find_gpio(dev, con_id, idx, &flags);
2786         }
2787
2788         /*
2789          * Either we are not using DT or ACPI, or their lookup did not return
2790          * a result. In that case, use platform lookup as a fallback.
2791          */
2792         if (!desc || desc == ERR_PTR(-ENOENT)) {
2793                 dev_dbg(dev, "using lookup tables for GPIO lookup");
2794                 desc = gpiod_find(dev, con_id, idx, &flags);
2795         }
2796
2797         if (IS_ERR(desc)) {
2798                 dev_dbg(dev, "lookup for GPIO %s failed\n", con_id);
2799                 return desc;
2800         }
2801
2802         status = gpiod_request(desc, con_id);
2803
2804         if (status < 0)
2805                 return ERR_PTR(status);
2806
2807         if (flags & GPIO_ACTIVE_LOW)
2808                 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
2809         if (flags & GPIO_OPEN_DRAIN)
2810                 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
2811         if (flags & GPIO_OPEN_SOURCE)
2812                 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
2813
2814         return desc;
2815 }
2816 EXPORT_SYMBOL_GPL(gpiod_get_index);
2817
2818 /**
2819  * gpiod_get_index_optional - obtain an optional GPIO from a multi-index GPIO
2820  *                            function
2821  * @dev: GPIO consumer, can be NULL for system-global GPIOs
2822  * @con_id: function within the GPIO consumer
2823  * @index: index of the GPIO to obtain in the consumer
2824  *
2825  * This is equivalent to gpiod_get_index(), except that when no GPIO with the
2826  * specified index was assigned to the requested function it will return NULL.
2827  * This is convenient for drivers that need to handle optional GPIOs.
2828  */
2829 struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
2830                                                         const char *con_id,
2831                                                         unsigned int index)
2832 {
2833         struct gpio_desc *desc;
2834
2835         desc = gpiod_get_index(dev, con_id, index);
2836         if (IS_ERR(desc)) {
2837                 if (PTR_ERR(desc) == -ENOENT)
2838                         return NULL;
2839         }
2840
2841         return desc;
2842 }
2843 EXPORT_SYMBOL_GPL(gpiod_get_index_optional);
2844
2845 /**
2846  * gpiod_put - dispose of a GPIO descriptor
2847  * @desc:       GPIO descriptor to dispose of
2848  *
2849  * No descriptor can be used after gpiod_put() has been called on it.
2850  */
2851 void gpiod_put(struct gpio_desc *desc)
2852 {
2853         gpiod_free(desc);
2854 }
2855 EXPORT_SYMBOL_GPL(gpiod_put);
2856
2857 #ifdef CONFIG_DEBUG_FS
2858
2859 static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
2860 {
2861         unsigned                i;
2862         unsigned                gpio = chip->base;
2863         struct gpio_desc        *gdesc = &chip->desc[0];
2864         int                     is_out;
2865         int                     is_irq;
2866
2867         for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) {
2868                 if (!test_bit(FLAG_REQUESTED, &gdesc->flags))
2869                         continue;
2870
2871                 gpiod_get_direction(gdesc);
2872                 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
2873                 is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
2874                 seq_printf(s, " gpio-%-3d (%-20.20s) %s %s %s",
2875                         gpio, gdesc->label,
2876                         is_out ? "out" : "in ",
2877                         chip->get
2878                                 ? (chip->get(chip, i) ? "hi" : "lo")
2879                                 : "?  ",
2880                         is_irq ? "IRQ" : "   ");
2881                 seq_printf(s, "\n");
2882         }
2883 }
2884
2885 static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
2886 {
2887         unsigned long flags;
2888         struct gpio_chip *chip = NULL;
2889         loff_t index = *pos;
2890
2891         s->private = "";
2892
2893         spin_lock_irqsave(&gpio_lock, flags);
2894         list_for_each_entry(chip, &gpio_chips, list)
2895                 if (index-- == 0) {
2896                         spin_unlock_irqrestore(&gpio_lock, flags);
2897                         return chip;
2898                 }
2899         spin_unlock_irqrestore(&gpio_lock, flags);
2900
2901         return NULL;
2902 }
2903
2904 static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
2905 {
2906         unsigned long flags;
2907         struct gpio_chip *chip = v;
2908         void *ret = NULL;
2909
2910         spin_lock_irqsave(&gpio_lock, flags);
2911         if (list_is_last(&chip->list, &gpio_chips))
2912                 ret = NULL;
2913         else
2914                 ret = list_entry(chip->list.next, struct gpio_chip, list);
2915         spin_unlock_irqrestore(&gpio_lock, flags);
2916
2917         s->private = "\n";
2918         ++*pos;
2919
2920         return ret;
2921 }
2922
2923 static void gpiolib_seq_stop(struct seq_file *s, void *v)
2924 {
2925 }
2926
2927 static int gpiolib_seq_show(struct seq_file *s, void *v)
2928 {
2929         struct gpio_chip *chip = v;
2930         struct device *dev;
2931
2932         seq_printf(s, "%sGPIOs %d-%d", (char *)s->private,
2933                         chip->base, chip->base + chip->ngpio - 1);
2934         dev = chip->dev;
2935         if (dev)
2936                 seq_printf(s, ", %s/%s", dev->bus ? dev->bus->name : "no-bus",
2937                         dev_name(dev));
2938         if (chip->label)
2939                 seq_printf(s, ", %s", chip->label);
2940         if (chip->can_sleep)
2941                 seq_printf(s, ", can sleep");
2942         seq_printf(s, ":\n");
2943
2944         if (chip->dbg_show)
2945                 chip->dbg_show(s, chip);
2946         else
2947                 gpiolib_dbg_show(s, chip);
2948
2949         return 0;
2950 }
2951
2952 static const struct seq_operations gpiolib_seq_ops = {
2953         .start = gpiolib_seq_start,
2954         .next = gpiolib_seq_next,
2955         .stop = gpiolib_seq_stop,
2956         .show = gpiolib_seq_show,
2957 };
2958
2959 static int gpiolib_open(struct inode *inode, struct file *file)
2960 {
2961         return seq_open(file, &gpiolib_seq_ops);
2962 }
2963
2964 static const struct file_operations gpiolib_operations = {
2965         .owner          = THIS_MODULE,
2966         .open           = gpiolib_open,
2967         .read           = seq_read,
2968         .llseek         = seq_lseek,
2969         .release        = seq_release,
2970 };
2971
2972 static int __init gpiolib_debugfs_init(void)
2973 {
2974         /* /sys/kernel/debug/gpio */
2975         (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
2976                                 NULL, NULL, &gpiolib_operations);
2977         return 0;
2978 }
2979 subsys_initcall(gpiolib_debugfs_init);
2980
2981 #endif  /* DEBUG_FS */