gpio: tegra: configure debouncing of key only for T210
[linux-3.10.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
16 #define CREATE_TRACE_POINTS
17 #include <trace/events/gpio.h>
18
19 /* Optional implementation infrastructure for GPIO interfaces.
20  *
21  * Platforms may want to use this if they tend to use very many GPIOs
22  * that aren't part of a System-On-Chip core; or across I2C/SPI/etc.
23  *
24  * When kernel footprint or instruction count is an issue, simpler
25  * implementations may be preferred.  The GPIO programming interface
26  * allows for inlining speed-critical get/set operations for common
27  * cases, so that access to SOC-integrated GPIOs can sometimes cost
28  * only an instruction or two per bit.
29  */
30
31
32 /* When debugging, extend minimal trust to callers and platform code.
33  * Also emit diagnostic messages that may help initial bringup, when
34  * board setup or driver bugs are most common.
35  *
36  * Otherwise, minimize overhead in what may be bitbanging codepaths.
37  */
38 #ifdef  DEBUG
39 #define extra_checks    1
40 #else
41 #define extra_checks    0
42 #endif
43
44 /* gpio_lock prevents conflicts during gpio_desc[] table updates.
45  * While any GPIO is requested, its gpio_chip is not removable;
46  * each GPIO's "requested" flag serves as a lock and refcount.
47  */
48 static DEFINE_SPINLOCK(gpio_lock);
49
50 struct gpio_desc {
51         struct gpio_chip        *chip;
52         unsigned long           flags;
53 /* flag symbols are bit numbers */
54 #define FLAG_REQUESTED  0
55 #define FLAG_IS_OUT     1
56 #define FLAG_EXPORT     2       /* protected by sysfs_lock */
57 #define FLAG_SYSFS      3       /* exported via /sys/class/gpio/control */
58 #define FLAG_TRIG_FALL  4       /* trigger on falling edge */
59 #define FLAG_TRIG_RISE  5       /* trigger on rising edge */
60 #define FLAG_ACTIVE_LOW 6       /* sysfs value has active low */
61 #define FLAG_OPEN_DRAIN 7       /* Gpio is open drain type */
62 #define FLAG_OPEN_SOURCE 8      /* Gpio is open source type */
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 LIST_HEAD(gpio_chips);
78
79 #ifdef CONFIG_GPIO_SYSFS
80 static DEFINE_IDR(dirent_idr);
81 #endif
82
83 /*
84  * Internal gpiod_* API using descriptors instead of the integer namespace.
85  * Most of this should eventually go public.
86  */
87 static int gpiod_request(struct gpio_desc *desc, const char *label);
88 static void gpiod_free(struct gpio_desc *desc);
89 static int gpiod_direction_input(struct gpio_desc *desc);
90 static int gpiod_direction_output(struct gpio_desc *desc, int value);
91 static int gpiod_get_direction(const struct gpio_desc *desc);
92 static int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
93 static int gpiod_get_value_cansleep(const struct gpio_desc *desc);
94 static void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
95 static int gpiod_get_value(const struct gpio_desc *desc);
96 static void gpiod_set_value(struct gpio_desc *desc, int value);
97 static int gpiod_cansleep(const struct gpio_desc *desc);
98 static int gpiod_to_irq(const struct gpio_desc *desc);
99 static int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
100 static int gpiod_export_link(struct device *dev, const char *name,
101                              struct gpio_desc *desc);
102 static int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value);
103 static void gpiod_unexport(struct gpio_desc *desc);
104
105
106 static inline void desc_set_label(struct gpio_desc *d, const char *label)
107 {
108 #ifdef CONFIG_DEBUG_FS
109         d->label = label;
110 #endif
111 }
112
113 /*
114  * Return the GPIO number of the passed descriptor relative to its chip
115  */
116 static int gpio_chip_hwgpio(const struct gpio_desc *desc)
117 {
118         return desc - &desc->chip->desc[0];
119 }
120
121 /**
122  * Convert a GPIO number to its descriptor
123  */
124 static struct gpio_desc *gpio_to_desc(unsigned gpio)
125 {
126         if (WARN(!gpio_is_valid(gpio), "invalid GPIO %d\n", gpio))
127                 return NULL;
128         else
129                 return &gpio_desc[gpio];
130 }
131
132 /**
133  * Convert a GPIO descriptor to the integer namespace.
134  * This should disappear in the future but is needed since we still
135  * use GPIO numbers for error messages and sysfs nodes
136  */
137 static int desc_to_gpio(const struct gpio_desc *desc)
138 {
139         return desc - &gpio_desc[0];
140 }
141
142
143 /* Warn when drivers omit gpio_request() calls -- legal but ill-advised
144  * when setting direction, and otherwise illegal.  Until board setup code
145  * and drivers use explicit requests everywhere (which won't happen when
146  * those calls have no teeth) we can't avoid autorequesting.  This nag
147  * message should motivate switching to explicit requests... so should
148  * the weaker cleanup after faults, compared to gpio_request().
149  *
150  * NOTE: the autorequest mechanism is going away; at this point it's
151  * only "legal" in the sense that (old) code using it won't break yet,
152  * but instead only triggers a WARN() stack dump.
153  */
154 static int gpio_ensure_requested(struct gpio_desc *desc)
155 {
156         const struct gpio_chip *chip = desc->chip;
157         const int gpio = desc_to_gpio(desc);
158
159         if (WARN(test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0,
160                         "autorequest GPIO-%d\n", gpio)) {
161                 if (!try_module_get(chip->owner)) {
162                         pr_err("GPIO-%d: module can't be gotten \n", gpio);
163                         clear_bit(FLAG_REQUESTED, &desc->flags);
164                         /* lose */
165                         return -EIO;
166                 }
167                 desc_set_label(desc, "[auto]");
168                 /* caller must chip->request() w/o spinlock */
169                 if (chip->request)
170                         return 1;
171         }
172         return 0;
173 }
174
175 static struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc)
176 {
177         return desc ? desc->chip : NULL;
178 }
179
180 /* caller holds gpio_lock *OR* gpio is marked as requested */
181 struct gpio_chip *gpio_to_chip(unsigned gpio)
182 {
183         return gpiod_to_chip(gpio_to_desc(gpio));
184 }
185
186 /* dynamic allocation of GPIOs, e.g. on a hotplugged device */
187 static int gpiochip_find_base(struct gpio_chip *req_chip, int aliased_base)
188 {
189         struct gpio_chip *chip;
190         int ngpio = req_chip->ngpio;
191         int base = -1;
192
193         if (aliased_base >= 0) {
194                 int start_gpio = aliased_base;
195                 int end_gpio = aliased_base + req_chip->ngpio;
196
197                 /* Check if aliased base is not already allocated */
198                 list_for_each_entry(chip, &gpio_chips, list) {
199                         if (chip->base > end_gpio)
200                                 continue;
201
202                         if ((chip->base < start_gpio) &&
203                                 ((chip->base + chip->ngpio) < start_gpio))
204                                         continue;
205                         pr_err("GPIO %d to %d is already allocated\n",
206                                         start_gpio, end_gpio);
207                         aliased_base = -1;
208                         break;
209                 }
210                 base = aliased_base;
211         }
212
213         if (base >= 0)
214                 goto found;
215
216         base = ARCH_NR_GPIOS - ngpio;
217         list_for_each_entry_reverse(chip, &gpio_chips, list) {
218                 /* found a free space? */
219                 if (chip->base + chip->ngpio <= base)
220                         break;
221                 else
222                         /* nope, check the space right before the chip */
223                         base = chip->base - ngpio;
224         }
225
226 found:
227         if (gpio_is_valid(base)) {
228                 pr_debug("%s: found new base at %d\n", __func__, base);
229                 return base;
230         } else {
231                 pr_err("%s: cannot find free range\n", __func__);
232                 return -ENOSPC;
233         }
234 }
235
236 /* caller ensures gpio is valid and requested, chip->get_direction may sleep  */
237 static int gpiod_get_direction(const struct gpio_desc *desc)
238 {
239         struct gpio_chip        *chip;
240         unsigned                offset;
241         int                     status = -EINVAL;
242
243         chip = gpiod_to_chip(desc);
244         offset = gpio_chip_hwgpio(desc);
245
246         if (!chip->get_direction)
247                 return status;
248
249         status = chip->get_direction(chip, offset);
250         if (status > 0) {
251                 /* GPIOF_DIR_IN, or other positive */
252                 status = 1;
253                 /* FLAG_IS_OUT is just a cache of the result of get_direction(),
254                  * so it does not affect constness per se */
255                 clear_bit(FLAG_IS_OUT, &((struct gpio_desc *)desc)->flags);
256         }
257         if (status == 0) {
258                 /* GPIOF_DIR_OUT */
259                 set_bit(FLAG_IS_OUT, &((struct gpio_desc *)desc)->flags);
260         }
261         return status;
262 }
263
264 #ifdef CONFIG_GPIO_SYSFS
265
266 /* lock protects against unexport_gpio() being called while
267  * sysfs files are active.
268  */
269 static DEFINE_MUTEX(sysfs_lock);
270
271 /*
272  * /sys/class/gpio/gpioN... only for GPIOs that are exported
273  *   /direction
274  *      * MAY BE OMITTED if kernel won't allow direction changes
275  *      * is read/write as "in" or "out"
276  *      * may also be written as "high" or "low", initializing
277  *        output value as specified ("out" implies "low")
278  *   /value
279  *      * always readable, subject to hardware behavior
280  *      * may be writable, as zero/nonzero
281  *   /edge
282  *      * configures behavior of poll(2) on /value
283  *      * available only if pin can generate IRQs on input
284  *      * is read/write as "none", "falling", "rising", or "both"
285  *   /active_low
286  *      * configures polarity of /value
287  *      * is read/write as zero/nonzero
288  *      * also affects existing and subsequent "falling" and "rising"
289  *        /edge configuration
290  */
291
292 static ssize_t gpio_direction_show(struct device *dev,
293                 struct device_attribute *attr, char *buf)
294 {
295         const struct gpio_desc  *desc = dev_get_drvdata(dev);
296         ssize_t                 status;
297
298         mutex_lock(&sysfs_lock);
299
300         if (!test_bit(FLAG_EXPORT, &desc->flags)) {
301                 status = -EIO;
302         } else {
303                 gpiod_get_direction(desc);
304                 status = sprintf(buf, "%s\n",
305                         test_bit(FLAG_IS_OUT, &desc->flags)
306                                 ? "out" : "in");
307         }
308
309         mutex_unlock(&sysfs_lock);
310         return status;
311 }
312
313 static ssize_t gpio_direction_store(struct device *dev,
314                 struct device_attribute *attr, const char *buf, size_t size)
315 {
316         struct gpio_desc        *desc = dev_get_drvdata(dev);
317         ssize_t                 status;
318
319         mutex_lock(&sysfs_lock);
320
321         if (!test_bit(FLAG_EXPORT, &desc->flags))
322                 status = -EIO;
323         else if (sysfs_streq(buf, "high"))
324                 status = gpiod_direction_output(desc, 1);
325         else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
326                 status = gpiod_direction_output(desc, 0);
327         else if (sysfs_streq(buf, "in"))
328                 status = gpiod_direction_input(desc);
329         else
330                 status = -EINVAL;
331
332         mutex_unlock(&sysfs_lock);
333         return status ? : size;
334 }
335
336 static /* const */ DEVICE_ATTR(direction, 0644,
337                 gpio_direction_show, gpio_direction_store);
338
339 static ssize_t gpio_value_show(struct device *dev,
340                 struct device_attribute *attr, char *buf)
341 {
342         struct gpio_desc        *desc = dev_get_drvdata(dev);
343         ssize_t                 status;
344
345         mutex_lock(&sysfs_lock);
346
347         if (!test_bit(FLAG_EXPORT, &desc->flags)) {
348                 status = -EIO;
349         } else {
350                 int value;
351
352                 value = !!gpiod_get_value_cansleep(desc);
353                 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
354                         value = !value;
355
356                 status = sprintf(buf, "%d\n", value);
357         }
358
359         mutex_unlock(&sysfs_lock);
360         return status;
361 }
362
363 static ssize_t gpio_value_store(struct device *dev,
364                 struct device_attribute *attr, const char *buf, size_t size)
365 {
366         struct gpio_desc        *desc = dev_get_drvdata(dev);
367         ssize_t                 status;
368
369         mutex_lock(&sysfs_lock);
370
371         if (!test_bit(FLAG_EXPORT, &desc->flags))
372                 status = -EIO;
373         else if (!test_bit(FLAG_IS_OUT, &desc->flags))
374                 status = -EPERM;
375         else {
376                 long            value;
377
378                 status = strict_strtol(buf, 0, &value);
379                 if (status == 0) {
380                         if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
381                                 value = !value;
382                         gpiod_set_value_cansleep(desc, value != 0);
383                         status = size;
384                 }
385         }
386
387         mutex_unlock(&sysfs_lock);
388         return status;
389 }
390
391 static const DEVICE_ATTR(value, 0644,
392                 gpio_value_show, gpio_value_store);
393
394 static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
395 {
396         struct sysfs_dirent     *value_sd = priv;
397
398         sysfs_notify_dirent(value_sd);
399         return IRQ_HANDLED;
400 }
401
402 static int gpio_setup_irq(struct gpio_desc *desc, struct device *dev,
403                 unsigned long gpio_flags)
404 {
405         struct sysfs_dirent     *value_sd;
406         unsigned long           irq_flags;
407         int                     ret, irq, id;
408
409         if ((desc->flags & GPIO_TRIGGER_MASK) == gpio_flags)
410                 return 0;
411
412         irq = gpiod_to_irq(desc);
413         if (irq < 0)
414                 return -EIO;
415
416         id = desc->flags >> ID_SHIFT;
417         value_sd = idr_find(&dirent_idr, id);
418         if (value_sd)
419                 free_irq(irq, value_sd);
420
421         desc->flags &= ~GPIO_TRIGGER_MASK;
422
423         if (!gpio_flags) {
424                 ret = 0;
425                 goto free_id;
426         }
427
428         irq_flags = IRQF_SHARED;
429         if (test_bit(FLAG_TRIG_FALL, &gpio_flags))
430                 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
431                         IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
432         if (test_bit(FLAG_TRIG_RISE, &gpio_flags))
433                 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
434                         IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
435
436         if (!value_sd) {
437                 value_sd = sysfs_get_dirent(dev->kobj.sd, NULL, "value");
438                 if (!value_sd) {
439                         ret = -ENODEV;
440                         goto err_out;
441                 }
442
443                 ret = idr_alloc(&dirent_idr, value_sd, 1, 0, GFP_KERNEL);
444                 if (ret < 0)
445                         goto free_sd;
446                 id = ret;
447
448                 desc->flags &= GPIO_FLAGS_MASK;
449                 desc->flags |= (unsigned long)id << ID_SHIFT;
450
451                 if (desc->flags >> ID_SHIFT != id) {
452                         ret = -ERANGE;
453                         goto free_id;
454                 }
455         }
456
457         ret = request_any_context_irq(irq, gpio_sysfs_irq, irq_flags,
458                                 "gpiolib", value_sd);
459         if (ret < 0)
460                 goto free_id;
461
462         desc->flags |= gpio_flags;
463         return 0;
464
465 free_id:
466         idr_remove(&dirent_idr, id);
467         desc->flags &= GPIO_FLAGS_MASK;
468 free_sd:
469         if (value_sd)
470                 sysfs_put(value_sd);
471 err_out:
472         return ret;
473 }
474
475 static const struct {
476         const char *name;
477         unsigned long flags;
478 } trigger_types[] = {
479         { "none",    0 },
480         { "falling", BIT(FLAG_TRIG_FALL) },
481         { "rising",  BIT(FLAG_TRIG_RISE) },
482         { "both",    BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE) },
483 };
484
485 static ssize_t gpio_edge_show(struct device *dev,
486                 struct device_attribute *attr, char *buf)
487 {
488         const struct gpio_desc  *desc = dev_get_drvdata(dev);
489         ssize_t                 status;
490
491         mutex_lock(&sysfs_lock);
492
493         if (!test_bit(FLAG_EXPORT, &desc->flags))
494                 status = -EIO;
495         else {
496                 int i;
497
498                 status = 0;
499                 for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
500                         if ((desc->flags & GPIO_TRIGGER_MASK)
501                                         == trigger_types[i].flags) {
502                                 status = sprintf(buf, "%s\n",
503                                                  trigger_types[i].name);
504                                 break;
505                         }
506         }
507
508         mutex_unlock(&sysfs_lock);
509         return status;
510 }
511
512 static ssize_t gpio_edge_store(struct device *dev,
513                 struct device_attribute *attr, const char *buf, size_t size)
514 {
515         struct gpio_desc        *desc = dev_get_drvdata(dev);
516         ssize_t                 status;
517         int                     i;
518
519         for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
520                 if (sysfs_streq(trigger_types[i].name, buf))
521                         goto found;
522         return -EINVAL;
523
524 found:
525         mutex_lock(&sysfs_lock);
526
527         if (!test_bit(FLAG_EXPORT, &desc->flags))
528                 status = -EIO;
529         else {
530                 status = gpio_setup_irq(desc, dev, trigger_types[i].flags);
531                 if (!status)
532                         status = size;
533         }
534
535         mutex_unlock(&sysfs_lock);
536
537         return status;
538 }
539
540 static DEVICE_ATTR(edge, 0644, gpio_edge_show, gpio_edge_store);
541
542 static int sysfs_set_active_low(struct gpio_desc *desc, struct device *dev,
543                                 int value)
544 {
545         int                     status = 0;
546
547         if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value)
548                 return 0;
549
550         if (value)
551                 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
552         else
553                 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
554
555         /* reconfigure poll(2) support if enabled on one edge only */
556         if (dev != NULL && (!!test_bit(FLAG_TRIG_RISE, &desc->flags) ^
557                                 !!test_bit(FLAG_TRIG_FALL, &desc->flags))) {
558                 unsigned long trigger_flags = desc->flags & GPIO_TRIGGER_MASK;
559
560                 gpio_setup_irq(desc, dev, 0);
561                 status = gpio_setup_irq(desc, dev, trigger_flags);
562         }
563
564         return status;
565 }
566
567 static ssize_t gpio_active_low_show(struct device *dev,
568                 struct device_attribute *attr, char *buf)
569 {
570         const struct gpio_desc  *desc = dev_get_drvdata(dev);
571         ssize_t                 status;
572
573         mutex_lock(&sysfs_lock);
574
575         if (!test_bit(FLAG_EXPORT, &desc->flags))
576                 status = -EIO;
577         else
578                 status = sprintf(buf, "%d\n",
579                                 !!test_bit(FLAG_ACTIVE_LOW, &desc->flags));
580
581         mutex_unlock(&sysfs_lock);
582
583         return status;
584 }
585
586 static ssize_t gpio_active_low_store(struct device *dev,
587                 struct device_attribute *attr, const char *buf, size_t size)
588 {
589         struct gpio_desc        *desc = dev_get_drvdata(dev);
590         ssize_t                 status;
591
592         mutex_lock(&sysfs_lock);
593
594         if (!test_bit(FLAG_EXPORT, &desc->flags)) {
595                 status = -EIO;
596         } else {
597                 long            value;
598
599                 status = strict_strtol(buf, 0, &value);
600                 if (status == 0)
601                         status = sysfs_set_active_low(desc, dev, value != 0);
602         }
603
604         mutex_unlock(&sysfs_lock);
605
606         return status ? : size;
607 }
608
609 static const DEVICE_ATTR(active_low, 0644,
610                 gpio_active_low_show, gpio_active_low_store);
611
612 static const struct attribute *gpio_attrs[] = {
613         &dev_attr_value.attr,
614         &dev_attr_active_low.attr,
615         NULL,
616 };
617
618 static const struct attribute_group gpio_attr_group = {
619         .attrs = (struct attribute **) gpio_attrs,
620 };
621
622 /*
623  * /sys/class/gpio/gpiochipN/
624  *   /base ... matching gpio_chip.base (N)
625  *   /label ... matching gpio_chip.label
626  *   /ngpio ... matching gpio_chip.ngpio
627  */
628
629 static ssize_t chip_base_show(struct device *dev,
630                                struct device_attribute *attr, char *buf)
631 {
632         const struct gpio_chip  *chip = dev_get_drvdata(dev);
633
634         return sprintf(buf, "%d\n", chip->base);
635 }
636 static DEVICE_ATTR(base, 0444, chip_base_show, NULL);
637
638 static ssize_t chip_label_show(struct device *dev,
639                                struct device_attribute *attr, char *buf)
640 {
641         const struct gpio_chip  *chip = dev_get_drvdata(dev);
642
643         return sprintf(buf, "%s\n", chip->label ? : "");
644 }
645 static DEVICE_ATTR(label, 0444, chip_label_show, NULL);
646
647 static ssize_t chip_ngpio_show(struct device *dev,
648                                struct device_attribute *attr, char *buf)
649 {
650         const struct gpio_chip  *chip = dev_get_drvdata(dev);
651
652         return sprintf(buf, "%u\n", chip->ngpio);
653 }
654 static DEVICE_ATTR(ngpio, 0444, chip_ngpio_show, NULL);
655
656 static const struct attribute *gpiochip_attrs[] = {
657         &dev_attr_base.attr,
658         &dev_attr_label.attr,
659         &dev_attr_ngpio.attr,
660         NULL,
661 };
662
663 static const struct attribute_group gpiochip_attr_group = {
664         .attrs = (struct attribute **) gpiochip_attrs,
665 };
666
667 /*
668  * /sys/class/gpio/export ... write-only
669  *      integer N ... number of GPIO to export (full access)
670  * /sys/class/gpio/unexport ... write-only
671  *      integer N ... number of GPIO to unexport
672  */
673 static ssize_t export_store(struct class *class,
674                                 struct class_attribute *attr,
675                                 const char *buf, size_t len)
676 {
677         long                    gpio;
678         struct gpio_desc        *desc;
679         int                     status;
680
681         status = strict_strtol(buf, 0, &gpio);
682         if (status < 0)
683                 goto done;
684
685         desc = gpio_to_desc(gpio);
686         /* reject invalid GPIOs */
687         if (!desc) {
688                 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
689                 return -EINVAL;
690         }
691
692         /* No extra locking here; FLAG_SYSFS just signifies that the
693          * request and export were done by on behalf of userspace, so
694          * they may be undone on its behalf too.
695          */
696
697         status = gpiod_request(desc, "sysfs");
698         if (status < 0) {
699                 if (status == -EPROBE_DEFER)
700                         status = -ENODEV;
701                 goto done;
702         }
703         status = gpiod_export(desc, true);
704         if (status < 0)
705                 gpiod_free(desc);
706         else
707                 set_bit(FLAG_SYSFS, &desc->flags);
708
709 done:
710         if (status)
711                 pr_debug("%s: status %d\n", __func__, status);
712         return status ? : len;
713 }
714
715 static ssize_t unexport_store(struct class *class,
716                                 struct class_attribute *attr,
717                                 const char *buf, size_t len)
718 {
719         long                    gpio;
720         struct gpio_desc        *desc;
721         int                     status;
722
723         status = strict_strtol(buf, 0, &gpio);
724         if (status < 0)
725                 goto done;
726
727         desc = gpio_to_desc(gpio);
728         /* reject bogus commands (gpio_unexport ignores them) */
729         if (!desc) {
730                 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
731                 return -EINVAL;
732         }
733
734         status = -EINVAL;
735
736         /* No extra locking here; FLAG_SYSFS just signifies that the
737          * request and export were done by on behalf of userspace, so
738          * they may be undone on its behalf too.
739          */
740         if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
741                 status = 0;
742                 gpiod_free(desc);
743         }
744 done:
745         if (status)
746                 pr_debug("%s: status %d\n", __func__, status);
747         return status ? : len;
748 }
749
750 static struct class_attribute gpio_class_attrs[] = {
751         __ATTR(export, 0200, NULL, export_store),
752         __ATTR(unexport, 0200, NULL, unexport_store),
753         __ATTR_NULL,
754 };
755
756 static struct class gpio_class = {
757         .name =         "gpio",
758         .owner =        THIS_MODULE,
759
760         .class_attrs =  gpio_class_attrs,
761 };
762
763
764 /**
765  * gpio_export - export a GPIO through sysfs
766  * @gpio: gpio to make available, already requested
767  * @direction_may_change: true if userspace may change gpio direction
768  * Context: arch_initcall or later
769  *
770  * When drivers want to make a GPIO accessible to userspace after they
771  * have requested it -- perhaps while debugging, or as part of their
772  * public interface -- they may use this routine.  If the GPIO can
773  * change direction (some can't) and the caller allows it, userspace
774  * will see "direction" sysfs attribute which may be used to change
775  * the gpio's direction.  A "value" attribute will always be provided.
776  *
777  * Returns zero on success, else an error.
778  */
779 static int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
780 {
781         unsigned long           flags;
782         int                     status;
783         const char              *ioname = NULL;
784         struct device           *dev;
785         int                     offset;
786
787         /* can't export until sysfs is available ... */
788         if (!gpio_class.p) {
789                 pr_debug("%s: called too early!\n", __func__);
790                 return -ENOENT;
791         }
792
793         if (!desc) {
794                 pr_debug("%s: invalid gpio descriptor\n", __func__);
795                 return -EINVAL;
796         }
797
798         mutex_lock(&sysfs_lock);
799
800         spin_lock_irqsave(&gpio_lock, flags);
801         if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
802              test_bit(FLAG_EXPORT, &desc->flags)) {
803                 spin_unlock_irqrestore(&gpio_lock, flags);
804                 pr_debug("%s: gpio %d unavailable (requested=%d, exported=%d)\n",
805                                 __func__, desc_to_gpio(desc),
806                                 test_bit(FLAG_REQUESTED, &desc->flags),
807                                 test_bit(FLAG_EXPORT, &desc->flags));
808                 status = -EPERM;
809                 goto fail_unlock;
810         }
811
812         if (!desc->chip->direction_input || !desc->chip->direction_output)
813                 direction_may_change = false;
814         spin_unlock_irqrestore(&gpio_lock, flags);
815
816         offset = gpio_chip_hwgpio(desc);
817         if (desc->chip->names && desc->chip->names[offset])
818                 ioname = desc->chip->names[offset];
819
820         dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
821                             desc, ioname ? ioname : "gpio%u",
822                             desc_to_gpio(desc));
823         if (IS_ERR(dev)) {
824                 status = PTR_ERR(dev);
825                 goto fail_unlock;
826         }
827
828         status = sysfs_create_group(&dev->kobj, &gpio_attr_group);
829         if (status)
830                 goto fail_unregister_device;
831
832         if (direction_may_change) {
833                 status = device_create_file(dev, &dev_attr_direction);
834                 if (status)
835                         goto fail_unregister_device;
836         }
837
838         if (gpiod_to_irq(desc) >= 0 && (direction_may_change ||
839                                        !test_bit(FLAG_IS_OUT, &desc->flags))) {
840                 status = device_create_file(dev, &dev_attr_edge);
841                 if (status)
842                         goto fail_unregister_device;
843         }
844
845         set_bit(FLAG_EXPORT, &desc->flags);
846         mutex_unlock(&sysfs_lock);
847         return 0;
848
849 fail_unregister_device:
850         device_unregister(dev);
851 fail_unlock:
852         mutex_unlock(&sysfs_lock);
853         pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
854                  status);
855         return status;
856 }
857
858 int gpio_export(unsigned gpio, bool direction_may_change)
859 {
860         return gpiod_export(gpio_to_desc(gpio), direction_may_change);
861 }
862 EXPORT_SYMBOL_GPL(gpio_export);
863
864 static int match_export(struct device *dev, const void *data)
865 {
866         return dev_get_drvdata(dev) == data;
867 }
868
869 /**
870  * gpio_export_link - create a sysfs link to an exported GPIO node
871  * @dev: device under which to create symlink
872  * @name: name of the symlink
873  * @gpio: gpio to create symlink to, already exported
874  *
875  * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
876  * node. Caller is responsible for unlinking.
877  *
878  * Returns zero on success, else an error.
879  */
880 static int gpiod_export_link(struct device *dev, const char *name,
881                              struct gpio_desc *desc)
882 {
883         int                     status = -EINVAL;
884
885         if (!desc) {
886                 pr_warn("%s: invalid GPIO\n", __func__);
887                 return -EINVAL;
888         }
889
890         mutex_lock(&sysfs_lock);
891
892         if (test_bit(FLAG_EXPORT, &desc->flags)) {
893                 struct device *tdev;
894
895                 tdev = class_find_device(&gpio_class, NULL, desc, match_export);
896                 if (tdev != NULL) {
897                         status = sysfs_create_link(&dev->kobj, &tdev->kobj,
898                                                 name);
899                 } else {
900                         status = -ENODEV;
901                 }
902         }
903
904         mutex_unlock(&sysfs_lock);
905
906         if (status)
907                 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
908                          status);
909
910         return status;
911 }
912
913 int gpio_export_link(struct device *dev, const char *name, unsigned gpio)
914 {
915         return gpiod_export_link(dev, name, gpio_to_desc(gpio));
916 }
917 EXPORT_SYMBOL_GPL(gpio_export_link);
918
919 /**
920  * gpio_sysfs_set_active_low - set the polarity of gpio sysfs value
921  * @gpio: gpio to change
922  * @value: non-zero to use active low, i.e. inverted values
923  *
924  * Set the polarity of /sys/class/gpio/gpioN/value sysfs attribute.
925  * The GPIO does not have to be exported yet.  If poll(2) support has
926  * been enabled for either rising or falling edge, it will be
927  * reconfigured to follow the new polarity.
928  *
929  * Returns zero on success, else an error.
930  */
931 static int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
932 {
933         struct device           *dev = NULL;
934         int                     status = -EINVAL;
935
936         if (!desc) {
937                 pr_warn("%s: invalid GPIO\n", __func__);
938                 return -EINVAL;
939         }
940
941         mutex_lock(&sysfs_lock);
942
943         if (test_bit(FLAG_EXPORT, &desc->flags)) {
944                 dev = class_find_device(&gpio_class, NULL, desc, match_export);
945                 if (dev == NULL) {
946                         status = -ENODEV;
947                         goto unlock;
948                 }
949         }
950
951         status = sysfs_set_active_low(desc, dev, value);
952
953 unlock:
954         mutex_unlock(&sysfs_lock);
955
956         if (status)
957                 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
958                          status);
959
960         return status;
961 }
962
963 int gpio_sysfs_set_active_low(unsigned gpio, int value)
964 {
965         return gpiod_sysfs_set_active_low(gpio_to_desc(gpio), value);
966 }
967 EXPORT_SYMBOL_GPL(gpio_sysfs_set_active_low);
968
969 /**
970  * gpio_unexport - reverse effect of gpio_export()
971  * @gpio: gpio to make unavailable
972  *
973  * This is implicit on gpio_free().
974  */
975 static void gpiod_unexport(struct gpio_desc *desc)
976 {
977         int                     status = 0;
978         struct device           *dev = NULL;
979
980         if (!desc) {
981                 pr_warn("%s: invalid GPIO\n", __func__);
982                 return;
983         }
984
985         mutex_lock(&sysfs_lock);
986
987         if (test_bit(FLAG_EXPORT, &desc->flags)) {
988
989                 dev = class_find_device(&gpio_class, NULL, desc, match_export);
990                 if (dev) {
991                         gpio_setup_irq(desc, dev, 0);
992                         clear_bit(FLAG_EXPORT, &desc->flags);
993                 } else
994                         status = -ENODEV;
995         }
996
997         mutex_unlock(&sysfs_lock);
998
999         if (dev) {
1000                 device_unregister(dev);
1001                 put_device(dev);
1002         }
1003
1004         if (status)
1005                 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
1006                          status);
1007 }
1008
1009 void gpio_unexport(unsigned gpio)
1010 {
1011         gpiod_unexport(gpio_to_desc(gpio));
1012 }
1013 EXPORT_SYMBOL_GPL(gpio_unexport);
1014
1015 static int gpiochip_export(struct gpio_chip *chip)
1016 {
1017         int             status;
1018         struct device   *dev;
1019
1020         /* Many systems register gpio chips for SOC support very early,
1021          * before driver model support is available.  In those cases we
1022          * export this later, in gpiolib_sysfs_init() ... here we just
1023          * verify that _some_ field of gpio_class got initialized.
1024          */
1025         if (!gpio_class.p)
1026                 return 0;
1027
1028         /* use chip->base for the ID; it's already known to be unique */
1029         mutex_lock(&sysfs_lock);
1030         dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
1031                                 "gpiochip%d", chip->base);
1032         if (!IS_ERR(dev)) {
1033                 status = sysfs_create_group(&dev->kobj,
1034                                 &gpiochip_attr_group);
1035         } else
1036                 status = PTR_ERR(dev);
1037         chip->exported = (status == 0);
1038         mutex_unlock(&sysfs_lock);
1039
1040         if (status) {
1041                 unsigned long   flags;
1042                 unsigned        gpio;
1043
1044                 spin_lock_irqsave(&gpio_lock, flags);
1045                 gpio = 0;
1046                 while (gpio < chip->ngpio)
1047                         chip->desc[gpio++].chip = NULL;
1048                 spin_unlock_irqrestore(&gpio_lock, flags);
1049
1050                 pr_debug("%s: chip %s status %d\n", __func__,
1051                                 chip->label, status);
1052         }
1053
1054         return status;
1055 }
1056
1057 static void gpiochip_unexport(struct gpio_chip *chip)
1058 {
1059         int                     status;
1060         struct device           *dev;
1061
1062         mutex_lock(&sysfs_lock);
1063         dev = class_find_device(&gpio_class, NULL, chip, match_export);
1064         if (dev) {
1065                 put_device(dev);
1066                 device_unregister(dev);
1067                 chip->exported = 0;
1068                 status = 0;
1069         } else
1070                 status = -ENODEV;
1071         mutex_unlock(&sysfs_lock);
1072
1073         if (status)
1074                 pr_debug("%s: chip %s status %d\n", __func__,
1075                                 chip->label, status);
1076 }
1077
1078 static int __init gpiolib_sysfs_init(void)
1079 {
1080         int             status;
1081         unsigned long   flags;
1082         struct gpio_chip *chip;
1083
1084         status = class_register(&gpio_class);
1085         if (status < 0)
1086                 return status;
1087
1088         /* Scan and register the gpio_chips which registered very
1089          * early (e.g. before the class_register above was called).
1090          *
1091          * We run before arch_initcall() so chip->dev nodes can have
1092          * registered, and so arch_initcall() can always gpio_export().
1093          */
1094         spin_lock_irqsave(&gpio_lock, flags);
1095         list_for_each_entry(chip, &gpio_chips, list) {
1096                 if (!chip || chip->exported)
1097                         continue;
1098
1099                 spin_unlock_irqrestore(&gpio_lock, flags);
1100                 status = gpiochip_export(chip);
1101                 spin_lock_irqsave(&gpio_lock, flags);
1102         }
1103         spin_unlock_irqrestore(&gpio_lock, flags);
1104
1105
1106         return status;
1107 }
1108 postcore_initcall(gpiolib_sysfs_init);
1109
1110 #else
1111 static inline int gpiochip_export(struct gpio_chip *chip)
1112 {
1113         return 0;
1114 }
1115
1116 static inline void gpiochip_unexport(struct gpio_chip *chip)
1117 {
1118 }
1119
1120 static inline int gpiod_export(struct gpio_desc *desc,
1121                                bool direction_may_change)
1122 {
1123         return -ENOSYS;
1124 }
1125
1126 static inline int gpiod_export_link(struct device *dev, const char *name,
1127                                     struct gpio_desc *desc)
1128 {
1129         return -ENOSYS;
1130 }
1131
1132 static inline int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
1133 {
1134         return -ENOSYS;
1135 }
1136
1137 static inline void gpiod_unexport(struct gpio_desc *desc)
1138 {
1139 }
1140
1141 #endif /* CONFIG_GPIO_SYSFS */
1142
1143 /*
1144  * Add a new chip to the global chips list, keeping the list of chips sorted
1145  * by base order.
1146  *
1147  * Return -EBUSY if the new chip overlaps with some other chip's integer
1148  * space.
1149  */
1150 static int gpiochip_add_to_list(struct gpio_chip *chip)
1151 {
1152         struct list_head *pos = &gpio_chips;
1153         struct gpio_chip *_chip;
1154         int err = 0;
1155
1156         /* find where to insert our chip */
1157         list_for_each(pos, &gpio_chips) {
1158                 _chip = list_entry(pos, struct gpio_chip, list);
1159                 /* shall we insert before _chip? */
1160                 if (_chip->base >= chip->base + chip->ngpio)
1161                         break;
1162         }
1163
1164         /* are we stepping on the chip right before? */
1165         if (pos != &gpio_chips && pos->prev != &gpio_chips) {
1166                 _chip = list_entry(pos->prev, struct gpio_chip, list);
1167                 if (_chip->base + _chip->ngpio > chip->base) {
1168                         dev_err(chip->dev,
1169                                "GPIO integer space overlap, cannot add chip\n");
1170                         err = -EBUSY;
1171                 }
1172         }
1173
1174         if (!err)
1175                 list_add_tail(&chip->list, pos);
1176
1177         return err;
1178 }
1179
1180 /**
1181  * gpiochip_add() - register a gpio_chip
1182  * @chip: the chip to register, with chip->base initialized
1183  * Context: potentially before irqs or kmalloc will work
1184  *
1185  * Returns a negative errno if the chip can't be registered, such as
1186  * because the chip->base is invalid or already associated with a
1187  * different chip.  Otherwise it returns zero as a success code.
1188  *
1189  * When gpiochip_add() is called very early during boot, so that GPIOs
1190  * can be freely used, the chip->dev device must be registered before
1191  * the gpio framework's arch_initcall().  Otherwise sysfs initialization
1192  * for GPIOs will fail rudely.
1193  *
1194  * If chip->base is negative, this requests dynamic assignment of
1195  * a range of valid GPIOs.
1196  */
1197 int gpiochip_add(struct gpio_chip *chip)
1198 {
1199         unsigned long   flags;
1200         int             status = 0;
1201         unsigned        id;
1202         int             base = chip->base;
1203         int             aliased_base = -1;
1204
1205         if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))
1206                         && base >= 0) {
1207                 status = -EINVAL;
1208                 goto fail;
1209         }
1210
1211 #ifdef CONFIG_OF
1212         if (chip->of_node)
1213                 aliased_base = of_alias_get_id(chip->of_node, "gpio");
1214 #endif
1215
1216         spin_lock_irqsave(&gpio_lock, flags);
1217
1218         if (base < 0) {
1219                 base = gpiochip_find_base(chip, aliased_base);
1220                 if (base < 0) {
1221                         status = base;
1222                         goto unlock;
1223                 }
1224                 chip->base = base;
1225         }
1226
1227         status = gpiochip_add_to_list(chip);
1228
1229         if (status == 0) {
1230                 chip->desc = &gpio_desc[chip->base];
1231
1232                 for (id = 0; id < chip->ngpio; id++) {
1233                         struct gpio_desc *desc = &chip->desc[id];
1234                         desc->chip = chip;
1235
1236                         /* REVISIT:  most hardware initializes GPIOs as
1237                          * inputs (often with pullups enabled) so power
1238                          * usage is minimized.  Linux code should set the
1239                          * gpio direction first thing; but until it does,
1240                          * and in case chip->get_direction is not set,
1241                          * we may expose the wrong direction in sysfs.
1242                          */
1243                         desc->flags = !chip->direction_input
1244                                 ? (1 << FLAG_IS_OUT)
1245                                 : 0;
1246                 }
1247         }
1248
1249         spin_unlock_irqrestore(&gpio_lock, flags);
1250
1251 #ifdef CONFIG_PINCTRL
1252         INIT_LIST_HEAD(&chip->pin_ranges);
1253 #endif
1254
1255         of_gpiochip_add(chip);
1256
1257         if (status)
1258                 goto fail;
1259
1260         of_gpiochip_init(chip);
1261
1262         status = gpiochip_export(chip);
1263         if (status)
1264                 goto fail;
1265
1266         pr_info("gpiochip_add: registered GPIOs %d to %d on device: %s\n",
1267                 chip->base, chip->base + chip->ngpio - 1,
1268                 chip->label ? : "generic");
1269
1270         return 0;
1271
1272 unlock:
1273         spin_unlock_irqrestore(&gpio_lock, flags);
1274 fail:
1275         /* failures here can mean systems won't boot... */
1276         pr_err("gpiochip_add: gpios %d..%d (%s) failed to register\n",
1277                 chip->base, chip->base + chip->ngpio - 1,
1278                 chip->label ? : "generic");
1279         return status;
1280 }
1281 EXPORT_SYMBOL_GPL(gpiochip_add);
1282
1283 /**
1284  * gpiochip_remove() - unregister a gpio_chip
1285  * @chip: the chip to unregister
1286  *
1287  * A gpio_chip with any GPIOs still requested may not be removed.
1288  */
1289 int gpiochip_remove(struct gpio_chip *chip)
1290 {
1291         unsigned long   flags;
1292         int             status = 0;
1293         unsigned        id;
1294
1295         spin_lock_irqsave(&gpio_lock, flags);
1296
1297         gpiochip_remove_pin_ranges(chip);
1298         of_gpiochip_remove(chip);
1299
1300         for (id = 0; id < chip->ngpio; id++) {
1301                 if (test_bit(FLAG_REQUESTED, &chip->desc[id].flags)) {
1302                         status = -EBUSY;
1303                         break;
1304                 }
1305         }
1306         if (status == 0) {
1307                 for (id = 0; id < chip->ngpio; id++)
1308                         chip->desc[id].chip = NULL;
1309
1310                 list_del(&chip->list);
1311         }
1312
1313         spin_unlock_irqrestore(&gpio_lock, flags);
1314
1315         if (status == 0)
1316                 gpiochip_unexport(chip);
1317
1318         return status;
1319 }
1320 EXPORT_SYMBOL_GPL(gpiochip_remove);
1321
1322 /**
1323  * gpiochip_find() - iterator for locating a specific gpio_chip
1324  * @data: data to pass to match function
1325  * @callback: Callback function to check gpio_chip
1326  *
1327  * Similar to bus_find_device.  It returns a reference to a gpio_chip as
1328  * determined by a user supplied @match callback.  The callback should return
1329  * 0 if the device doesn't match and non-zero if it does.  If the callback is
1330  * non-zero, this function will return to the caller and not iterate over any
1331  * more gpio_chips.
1332  */
1333 struct gpio_chip *gpiochip_find(void *data,
1334                                 int (*match)(struct gpio_chip *chip,
1335                                              void *data))
1336 {
1337         struct gpio_chip *chip;
1338         unsigned long flags;
1339
1340         spin_lock_irqsave(&gpio_lock, flags);
1341         list_for_each_entry(chip, &gpio_chips, list)
1342                 if (match(chip, data))
1343                         break;
1344
1345         /* No match? */
1346         if (&chip->list == &gpio_chips)
1347                 chip = NULL;
1348         spin_unlock_irqrestore(&gpio_lock, flags);
1349
1350         return chip;
1351 }
1352 EXPORT_SYMBOL_GPL(gpiochip_find);
1353
1354 #ifdef CONFIG_PINCTRL
1355
1356 /**
1357  * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
1358  * @chip: the gpiochip to add the range for
1359  * @pinctrl_name: the dev_name() of the pin controller to map to
1360  * @gpio_offset: the start offset in the current gpio_chip number space
1361  * @pin_offset: the start offset in the pin controller number space
1362  * @npins: the number of pins from the offset of each pin space (GPIO and
1363  *      pin controller) to accumulate in this range
1364  */
1365 int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
1366                            unsigned int gpio_offset, unsigned int pin_offset,
1367                            unsigned int npins)
1368 {
1369         struct gpio_pin_range *pin_range;
1370         int ret;
1371
1372         pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1373         if (!pin_range) {
1374                 pr_err("%s: GPIO chip: failed to allocate pin ranges\n",
1375                                 chip->label);
1376                 return -ENOMEM;
1377         }
1378
1379         /* Use local offset as range ID */
1380         pin_range->range.id = gpio_offset;
1381         pin_range->range.gc = chip;
1382         pin_range->range.name = chip->label;
1383         pin_range->range.base = chip->base + gpio_offset;
1384         pin_range->range.pin_base = pin_offset;
1385         pin_range->range.npins = npins;
1386         pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
1387                         &pin_range->range);
1388         if (IS_ERR(pin_range->pctldev)) {
1389                 ret = PTR_ERR(pin_range->pctldev);
1390                 pr_err("%s: GPIO chip: could not create pin range\n",
1391                        chip->label);
1392                 kfree(pin_range);
1393                 return ret;
1394         }
1395         pr_debug("GPIO chip %s: created GPIO range %d->%d ==> %s PIN %d->%d\n",
1396                  chip->label, gpio_offset, gpio_offset + npins - 1,
1397                  pinctl_name,
1398                  pin_offset, pin_offset + npins - 1);
1399
1400         list_add_tail(&pin_range->node, &chip->pin_ranges);
1401
1402         return 0;
1403 }
1404 EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
1405
1406 /**
1407  * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
1408  * @chip: the chip to remove all the mappings for
1409  */
1410 void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
1411 {
1412         struct gpio_pin_range *pin_range, *tmp;
1413
1414         list_for_each_entry_safe(pin_range, tmp, &chip->pin_ranges, node) {
1415                 list_del(&pin_range->node);
1416                 pinctrl_remove_gpio_range(pin_range->pctldev,
1417                                 &pin_range->range);
1418                 kfree(pin_range);
1419         }
1420 }
1421 EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
1422
1423 #endif /* CONFIG_PINCTRL */
1424
1425 /* These "optional" allocation calls help prevent drivers from stomping
1426  * on each other, and help provide better diagnostics in debugfs.
1427  * They're called even less than the "set direction" calls.
1428  */
1429 static int gpiod_request(struct gpio_desc *desc, const char *label)
1430 {
1431         struct gpio_chip        *chip;
1432         int                     status = -EPROBE_DEFER;
1433         unsigned long           flags;
1434
1435         if (!desc) {
1436                 pr_warn("%s: invalid GPIO\n", __func__);
1437                 return -EINVAL;
1438         }
1439
1440         spin_lock_irqsave(&gpio_lock, flags);
1441
1442         chip = desc->chip;
1443         if (chip == NULL)
1444                 goto done;
1445
1446         if (!try_module_get(chip->owner))
1447                 goto done;
1448
1449         /* NOTE:  gpio_request() can be called in early boot,
1450          * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
1451          */
1452
1453         if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
1454                 desc_set_label(desc, label ? : "?");
1455                 status = 0;
1456         } else {
1457                 status = -EBUSY;
1458                 module_put(chip->owner);
1459                 goto done;
1460         }
1461
1462         if (chip->request) {
1463                 /* chip->request may sleep */
1464                 spin_unlock_irqrestore(&gpio_lock, flags);
1465                 status = chip->request(chip, gpio_chip_hwgpio(desc));
1466                 spin_lock_irqsave(&gpio_lock, flags);
1467
1468                 if (status < 0) {
1469                         desc_set_label(desc, NULL);
1470                         module_put(chip->owner);
1471                         clear_bit(FLAG_REQUESTED, &desc->flags);
1472                         goto done;
1473                 }
1474         }
1475         if (chip->get_direction) {
1476                 /* chip->get_direction may sleep */
1477                 spin_unlock_irqrestore(&gpio_lock, flags);
1478                 gpiod_get_direction(desc);
1479                 spin_lock_irqsave(&gpio_lock, flags);
1480         }
1481 done:
1482         if (status)
1483                 pr_debug("_gpio_request: gpio-%d (%s) status %d\n",
1484                          desc_to_gpio(desc), label ? : "?", status);
1485         spin_unlock_irqrestore(&gpio_lock, flags);
1486         return status;
1487 }
1488
1489 int gpio_request(unsigned gpio, const char *label)
1490 {
1491         return gpiod_request(gpio_to_desc(gpio), label);
1492 }
1493 EXPORT_SYMBOL_GPL(gpio_request);
1494
1495 static void gpiod_free(struct gpio_desc *desc)
1496 {
1497         unsigned long           flags;
1498         struct gpio_chip        *chip;
1499
1500         might_sleep();
1501
1502         if (!desc) {
1503                 WARN_ON(extra_checks);
1504                 return;
1505         }
1506
1507         gpiod_unexport(desc);
1508
1509         spin_lock_irqsave(&gpio_lock, flags);
1510
1511         chip = desc->chip;
1512         if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
1513                 if (chip->free) {
1514                         spin_unlock_irqrestore(&gpio_lock, flags);
1515                         might_sleep_if(chip->can_sleep);
1516                         chip->free(chip, gpio_chip_hwgpio(desc));
1517                         spin_lock_irqsave(&gpio_lock, flags);
1518                 }
1519                 desc_set_label(desc, NULL);
1520                 module_put(desc->chip->owner);
1521                 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
1522                 clear_bit(FLAG_REQUESTED, &desc->flags);
1523                 clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
1524                 clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
1525         } else
1526                 WARN_ON(extra_checks);
1527
1528         spin_unlock_irqrestore(&gpio_lock, flags);
1529 }
1530
1531 void gpio_free(unsigned gpio)
1532 {
1533         gpiod_free(gpio_to_desc(gpio));
1534 }
1535 EXPORT_SYMBOL_GPL(gpio_free);
1536
1537 /**
1538  * gpio_request_one - request a single GPIO with initial configuration
1539  * @gpio:       the GPIO number
1540  * @flags:      GPIO configuration as specified by GPIOF_*
1541  * @label:      a literal description string of this GPIO
1542  */
1543 int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
1544 {
1545         struct gpio_desc *desc;
1546         int err;
1547
1548         desc = gpio_to_desc(gpio);
1549
1550         err = gpiod_request(desc, label);
1551         if (err)
1552                 return err;
1553
1554         if (flags & GPIOF_OPEN_DRAIN)
1555                 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
1556
1557         if (flags & GPIOF_OPEN_SOURCE)
1558                 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
1559
1560         if (flags & GPIOF_DIR_IN)
1561                 err = gpiod_direction_input(desc);
1562         else
1563                 err = gpiod_direction_output(desc,
1564                                 (flags & GPIOF_INIT_HIGH) ? 1 : 0);
1565
1566         if (err)
1567                 goto free_gpio;
1568
1569         if (flags & GPIOF_EXPORT) {
1570                 err = gpiod_export(desc, flags & GPIOF_EXPORT_CHANGEABLE);
1571                 if (err)
1572                         goto free_gpio;
1573         }
1574
1575         return 0;
1576
1577  free_gpio:
1578         gpiod_free(desc);
1579         return err;
1580 }
1581 EXPORT_SYMBOL_GPL(gpio_request_one);
1582
1583 /**
1584  * gpio_request_array - request multiple GPIOs in a single call
1585  * @array:      array of the 'struct gpio'
1586  * @num:        how many GPIOs in the array
1587  */
1588 int gpio_request_array(const struct gpio *array, size_t num)
1589 {
1590         int i, err;
1591
1592         for (i = 0; i < num; i++, array++) {
1593                 err = gpio_request_one(array->gpio, array->flags, array->label);
1594                 if (err)
1595                         goto err_free;
1596         }
1597         return 0;
1598
1599 err_free:
1600         while (i--)
1601                 gpio_free((--array)->gpio);
1602         return err;
1603 }
1604 EXPORT_SYMBOL_GPL(gpio_request_array);
1605
1606 /**
1607  * gpio_free_array - release multiple GPIOs in a single call
1608  * @array:      array of the 'struct gpio'
1609  * @num:        how many GPIOs in the array
1610  */
1611 void gpio_free_array(const struct gpio *array, size_t num)
1612 {
1613         while (num--)
1614                 gpio_free((array++)->gpio);
1615 }
1616 EXPORT_SYMBOL_GPL(gpio_free_array);
1617
1618 /**
1619  * gpiochip_is_requested - return string iff signal was requested
1620  * @chip: controller managing the signal
1621  * @offset: of signal within controller's 0..(ngpio - 1) range
1622  *
1623  * Returns NULL if the GPIO is not currently requested, else a string.
1624  * If debugfs support is enabled, the string returned is the label passed
1625  * to gpio_request(); otherwise it is a meaningless constant.
1626  *
1627  * This function is for use by GPIO controller drivers.  The label can
1628  * help with diagnostics, and knowing that the signal is used as a GPIO
1629  * can help avoid accidentally multiplexing it to another controller.
1630  */
1631 const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
1632 {
1633         struct gpio_desc *desc;
1634
1635         if (!GPIO_OFFSET_VALID(chip, offset))
1636                 return NULL;
1637
1638         desc = &chip->desc[offset];
1639
1640         if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
1641                 return NULL;
1642 #ifdef CONFIG_DEBUG_FS
1643         return desc->label;
1644 #else
1645         return "?";
1646 #endif
1647 }
1648 EXPORT_SYMBOL_GPL(gpiochip_is_requested);
1649
1650
1651 /* Drivers MUST set GPIO direction before making get/set calls.  In
1652  * some cases this is done in early boot, before IRQs are enabled.
1653  *
1654  * As a rule these aren't called more than once (except for drivers
1655  * using the open-drain emulation idiom) so these are natural places
1656  * to accumulate extra debugging checks.  Note that we can't (yet)
1657  * rely on gpio_request() having been called beforehand.
1658  */
1659
1660 static int gpiod_direction_input(struct gpio_desc *desc)
1661 {
1662         unsigned long           flags;
1663         struct gpio_chip        *chip;
1664         int                     status = -EINVAL;
1665         int                     offset;
1666
1667         if (!desc) {
1668                 pr_warn("%s: invalid GPIO\n", __func__);
1669                 return -EINVAL;
1670         }
1671
1672         spin_lock_irqsave(&gpio_lock, flags);
1673
1674         chip = desc->chip;
1675         if (!chip || !chip->get || !chip->direction_input)
1676                 goto fail;
1677         status = gpio_ensure_requested(desc);
1678         if (status < 0)
1679                 goto fail;
1680
1681         /* now we know the gpio is valid and chip won't vanish */
1682
1683         spin_unlock_irqrestore(&gpio_lock, flags);
1684
1685         might_sleep_if(chip->can_sleep);
1686
1687         offset = gpio_chip_hwgpio(desc);
1688         if (status) {
1689                 status = chip->request(chip, offset);
1690                 if (status < 0) {
1691                         pr_debug("GPIO-%d: chip request fail, %d\n",
1692                                 desc_to_gpio(desc), status);
1693                         /* and it's not available to anyone else ...
1694                          * gpio_request() is the fully clean solution.
1695                          */
1696                         goto lose;
1697                 }
1698         }
1699
1700         status = chip->direction_input(chip, offset);
1701         if (status == 0)
1702                 clear_bit(FLAG_IS_OUT, &desc->flags);
1703
1704         trace_gpio_direction(desc_to_gpio(desc), 1, status);
1705 lose:
1706         return status;
1707 fail:
1708         spin_unlock_irqrestore(&gpio_lock, flags);
1709         if (status)
1710                 pr_debug("%s: gpio-%d status %d\n", __func__,
1711                          desc_to_gpio(desc), status);
1712         return status;
1713 }
1714
1715 int gpio_direction_input(unsigned gpio)
1716 {
1717         return gpiod_direction_input(gpio_to_desc(gpio));
1718 }
1719 EXPORT_SYMBOL_GPL(gpio_direction_input);
1720
1721 static int gpiod_direction_output(struct gpio_desc *desc, int value)
1722 {
1723         unsigned long           flags;
1724         struct gpio_chip        *chip;
1725         int                     status = -EINVAL;
1726         int offset;
1727
1728         if (!desc) {
1729                 pr_warn("%s: invalid GPIO\n", __func__);
1730                 return -EINVAL;
1731         }
1732
1733         /* Open drain pin should not be driven to 1 */
1734         if (value && test_bit(FLAG_OPEN_DRAIN,  &desc->flags))
1735                 return gpiod_direction_input(desc);
1736
1737         /* Open source pin should not be driven to 0 */
1738         if (!value && test_bit(FLAG_OPEN_SOURCE,  &desc->flags))
1739                 return gpiod_direction_input(desc);
1740
1741         spin_lock_irqsave(&gpio_lock, flags);
1742
1743         chip = desc->chip;
1744         if (!chip || !chip->set || !chip->direction_output)
1745                 goto fail;
1746         status = gpio_ensure_requested(desc);
1747         if (status < 0)
1748                 goto fail;
1749
1750         /* now we know the gpio is valid and chip won't vanish */
1751
1752         spin_unlock_irqrestore(&gpio_lock, flags);
1753
1754         might_sleep_if(chip->can_sleep);
1755
1756         offset = gpio_chip_hwgpio(desc);
1757         if (status) {
1758                 status = chip->request(chip, offset);
1759                 if (status < 0) {
1760                         pr_debug("GPIO-%d: chip request fail, %d\n",
1761                                 desc_to_gpio(desc), status);
1762                         /* and it's not available to anyone else ...
1763                          * gpio_request() is the fully clean solution.
1764                          */
1765                         goto lose;
1766                 }
1767         }
1768
1769         status = chip->direction_output(chip, offset, value);
1770         if (status == 0)
1771                 set_bit(FLAG_IS_OUT, &desc->flags);
1772         trace_gpio_value(desc_to_gpio(desc), 0, value);
1773         trace_gpio_direction(desc_to_gpio(desc), 0, status);
1774 lose:
1775         return status;
1776 fail:
1777         spin_unlock_irqrestore(&gpio_lock, flags);
1778         if (status)
1779                 pr_debug("%s: gpio-%d status %d\n", __func__,
1780                          desc_to_gpio(desc), status);
1781         return status;
1782 }
1783
1784 int gpio_direction_output(unsigned gpio, int value)
1785 {
1786         return gpiod_direction_output(gpio_to_desc(gpio), value);
1787 }
1788 EXPORT_SYMBOL_GPL(gpio_direction_output);
1789
1790 /**
1791  * gpio_set_debounce - sets @debounce time for a @gpio
1792  * @gpio: the gpio to set debounce time
1793  * @debounce: debounce time is microseconds
1794  */
1795 static int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
1796 {
1797         unsigned long           flags;
1798         struct gpio_chip        *chip;
1799         int                     status = -EINVAL;
1800         int                     offset;
1801
1802         if (!desc) {
1803                 pr_warn("%s: invalid GPIO\n", __func__);
1804                 return -EINVAL;
1805         }
1806
1807         spin_lock_irqsave(&gpio_lock, flags);
1808
1809         chip = desc->chip;
1810         if (!chip || !chip->set || !chip->set_debounce)
1811                 goto fail;
1812
1813         status = gpio_ensure_requested(desc);
1814         if (status < 0)
1815                 goto fail;
1816
1817         /* now we know the gpio is valid and chip won't vanish */
1818
1819         spin_unlock_irqrestore(&gpio_lock, flags);
1820
1821         might_sleep_if(chip->can_sleep);
1822
1823         offset = gpio_chip_hwgpio(desc);
1824         return chip->set_debounce(chip, offset, debounce);
1825
1826 fail:
1827         spin_unlock_irqrestore(&gpio_lock, flags);
1828         if (status)
1829                 pr_debug("%s: gpio-%d status %d\n", __func__,
1830                          desc_to_gpio(desc), status);
1831
1832         return status;
1833 }
1834
1835 int gpio_set_debounce(unsigned gpio, unsigned debounce)
1836 {
1837         return gpiod_set_debounce(gpio_to_desc(gpio), debounce);
1838 }
1839 EXPORT_SYMBOL_GPL(gpio_set_debounce);
1840
1841 /* I/O calls are only valid after configuration completed; the relevant
1842  * "is this a valid GPIO" error checks should already have been done.
1843  *
1844  * "Get" operations are often inlinable as reading a pin value register,
1845  * and masking the relevant bit in that register.
1846  *
1847  * When "set" operations are inlinable, they involve writing that mask to
1848  * one register to set a low value, or a different register to set it high.
1849  * Otherwise locking is needed, so there may be little value to inlining.
1850  *
1851  *------------------------------------------------------------------------
1852  *
1853  * IMPORTANT!!!  The hot paths -- get/set value -- assume that callers
1854  * have requested the GPIO.  That can include implicit requesting by
1855  * a direction setting call.  Marking a gpio as requested locks its chip
1856  * in memory, guaranteeing that these table lookups need no more locking
1857  * and that gpiochip_remove() will fail.
1858  *
1859  * REVISIT when debugging, consider adding some instrumentation to ensure
1860  * that the GPIO was actually requested.
1861  */
1862
1863 /**
1864  * __gpio_get_value() - return a gpio's value
1865  * @gpio: gpio whose value will be returned
1866  * Context: any
1867  *
1868  * This is used directly or indirectly to implement gpio_get_value().
1869  * It returns the zero or nonzero value provided by the associated
1870  * gpio_chip.get() method; or zero if no such method is provided.
1871  */
1872 static int gpiod_get_value(const struct gpio_desc *desc)
1873 {
1874         struct gpio_chip        *chip;
1875         int value;
1876         int offset;
1877
1878         if (!desc)
1879                 return 0;
1880         chip = desc->chip;
1881         offset = gpio_chip_hwgpio(desc);
1882         /* Should be using gpio_get_value_cansleep() */
1883         WARN_ON(chip->can_sleep);
1884         value = chip->get ? chip->get(chip, offset) : 0;
1885         trace_gpio_value(desc_to_gpio(desc), 1, value);
1886         return value;
1887 }
1888
1889 int __gpio_get_value(unsigned gpio)
1890 {
1891         return gpiod_get_value(gpio_to_desc(gpio));
1892 }
1893 EXPORT_SYMBOL_GPL(__gpio_get_value);
1894
1895 /*
1896  *  _gpio_set_open_drain_value() - Set the open drain gpio's value.
1897  * @gpio: Gpio whose state need to be set.
1898  * @chip: Gpio chip.
1899  * @value: Non-zero for setting it HIGH otherise it will set to LOW.
1900  */
1901 static void _gpio_set_open_drain_value(struct gpio_desc *desc, int value)
1902 {
1903         int err = 0;
1904         struct gpio_chip *chip = desc->chip;
1905         int offset = gpio_chip_hwgpio(desc);
1906
1907         if (value) {
1908                 err = chip->direction_input(chip, offset);
1909                 if (!err)
1910                         clear_bit(FLAG_IS_OUT, &desc->flags);
1911         } else {
1912                 err = chip->direction_output(chip, offset, 0);
1913                 if (!err)
1914                         set_bit(FLAG_IS_OUT, &desc->flags);
1915         }
1916         trace_gpio_direction(desc_to_gpio(desc), value, err);
1917         if (err < 0)
1918                 pr_err("%s: Error in set_value for open drain gpio%d err %d\n",
1919                                         __func__, desc_to_gpio(desc), err);
1920 }
1921
1922 /*
1923  *  _gpio_set_open_source() - Set the open source gpio's value.
1924  * @gpio: Gpio whose state need to be set.
1925  * @chip: Gpio chip.
1926  * @value: Non-zero for setting it HIGH otherise it will set to LOW.
1927  */
1928 static void _gpio_set_open_source_value(struct gpio_desc *desc, int value)
1929 {
1930         int err = 0;
1931         struct gpio_chip *chip = desc->chip;
1932         int offset = gpio_chip_hwgpio(desc);
1933
1934         if (value) {
1935                 err = chip->direction_output(chip, offset, 1);
1936                 if (!err)
1937                         set_bit(FLAG_IS_OUT, &desc->flags);
1938         } else {
1939                 err = chip->direction_input(chip, offset);
1940                 if (!err)
1941                         clear_bit(FLAG_IS_OUT, &desc->flags);
1942         }
1943         trace_gpio_direction(desc_to_gpio(desc), !value, err);
1944         if (err < 0)
1945                 pr_err("%s: Error in set_value for open source gpio%d err %d\n",
1946                                         __func__, desc_to_gpio(desc), err);
1947 }
1948
1949 /**
1950  * __gpio_set_value() - assign a gpio's value
1951  * @gpio: gpio whose value will be assigned
1952  * @value: value to assign
1953  * Context: any
1954  *
1955  * This is used directly or indirectly to implement gpio_set_value().
1956  * It invokes the associated gpio_chip.set() method.
1957  */
1958 static void gpiod_set_value(struct gpio_desc *desc, int value)
1959 {
1960         struct gpio_chip        *chip;
1961
1962         if (!desc)
1963                 return;
1964         chip = desc->chip;
1965         /* Should be using gpio_set_value_cansleep() */
1966         WARN_ON(chip->can_sleep);
1967         trace_gpio_value(desc_to_gpio(desc), 0, value);
1968         if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
1969                 _gpio_set_open_drain_value(desc, value);
1970         else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
1971                 _gpio_set_open_source_value(desc, value);
1972         else
1973                 chip->set(chip, gpio_chip_hwgpio(desc), value);
1974 }
1975
1976 void __gpio_set_value(unsigned gpio, int value)
1977 {
1978         return gpiod_set_value(gpio_to_desc(gpio), value);
1979 }
1980 EXPORT_SYMBOL_GPL(__gpio_set_value);
1981
1982 /**
1983  * __gpio_cansleep() - report whether gpio value access will sleep
1984  * @gpio: gpio in question
1985  * Context: any
1986  *
1987  * This is used directly or indirectly to implement gpio_cansleep().  It
1988  * returns nonzero if access reading or writing the GPIO value can sleep.
1989  */
1990 static int gpiod_cansleep(const struct gpio_desc *desc)
1991 {
1992         if (!desc)
1993                 return 0;
1994         /* only call this on GPIOs that are valid! */
1995         return desc->chip->can_sleep;
1996 }
1997
1998 int __gpio_cansleep(unsigned gpio)
1999 {
2000         return gpiod_cansleep(gpio_to_desc(gpio));
2001 }
2002 EXPORT_SYMBOL_GPL(__gpio_cansleep);
2003
2004 /**
2005  * __gpio_to_irq() - return the IRQ corresponding to a GPIO
2006  * @gpio: gpio whose IRQ will be returned (already requested)
2007  * Context: any
2008  *
2009  * This is used directly or indirectly to implement gpio_to_irq().
2010  * It returns the number of the IRQ signaled by this (input) GPIO,
2011  * or a negative errno.
2012  */
2013 static int gpiod_to_irq(const struct gpio_desc *desc)
2014 {
2015         struct gpio_chip        *chip;
2016         int                     offset;
2017
2018         if (!desc)
2019                 return -EINVAL;
2020         chip = desc->chip;
2021         offset = gpio_chip_hwgpio(desc);
2022         return chip->to_irq ? chip->to_irq(chip, offset) : -ENXIO;
2023 }
2024
2025 int __gpio_to_irq(unsigned gpio)
2026 {
2027         return gpiod_to_irq(gpio_to_desc(gpio));
2028 }
2029 EXPORT_SYMBOL_GPL(__gpio_to_irq);
2030
2031
2032 /* There's no value in making it easy to inline GPIO calls that may sleep.
2033  * Common examples include ones connected to I2C or SPI chips.
2034  */
2035
2036 static int gpiod_get_value_cansleep(const struct gpio_desc *desc)
2037 {
2038         struct gpio_chip        *chip;
2039         int value;
2040         int offset;
2041
2042         might_sleep_if(extra_checks);
2043         if (!desc)
2044                 return 0;
2045         chip = desc->chip;
2046         offset = gpio_chip_hwgpio(desc);
2047         value = chip->get ? chip->get(chip, offset) : 0;
2048         trace_gpio_value(desc_to_gpio(desc), 1, value);
2049         return value;
2050 }
2051
2052 int gpio_get_value_cansleep(unsigned gpio)
2053 {
2054         return gpiod_get_value_cansleep(gpio_to_desc(gpio));
2055 }
2056 EXPORT_SYMBOL_GPL(gpio_get_value_cansleep);
2057
2058 static void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
2059 {
2060         struct gpio_chip        *chip;
2061
2062         might_sleep_if(extra_checks);
2063         if (!desc)
2064                 return;
2065         chip = desc->chip;
2066         trace_gpio_value(desc_to_gpio(desc), 0, value);
2067         if (test_bit(FLAG_OPEN_DRAIN,  &desc->flags))
2068                 _gpio_set_open_drain_value(desc, value);
2069         else if (test_bit(FLAG_OPEN_SOURCE,  &desc->flags))
2070                 _gpio_set_open_source_value(desc, value);
2071         else
2072                 chip->set(chip, gpio_chip_hwgpio(desc), value);
2073 }
2074
2075 void gpio_set_value_cansleep(unsigned gpio, int value)
2076 {
2077         return gpiod_set_value_cansleep(gpio_to_desc(gpio), value);
2078 }
2079 EXPORT_SYMBOL_GPL(gpio_set_value_cansleep);
2080
2081 #ifdef CONFIG_DEBUG_FS
2082
2083 static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
2084 {
2085         unsigned                i;
2086         unsigned                gpio = chip->base;
2087         struct gpio_desc        *gdesc = &chip->desc[0];
2088         int                     is_out;
2089
2090         for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) {
2091                 if (!test_bit(FLAG_REQUESTED, &gdesc->flags))
2092                         continue;
2093
2094                 gpiod_get_direction(gdesc);
2095                 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
2096                 seq_printf(s, " gpio-%-3d (%-20.20s) %s %s",
2097                         gpio, gdesc->label,
2098                         is_out ? "out" : "in ",
2099                         chip->get
2100                                 ? (chip->get(chip, i) ? "hi" : "lo")
2101                                 : "?  ");
2102                 seq_printf(s, "\n");
2103         }
2104 }
2105
2106 static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
2107 {
2108         unsigned long flags;
2109         struct gpio_chip *chip = NULL;
2110         loff_t index = *pos;
2111
2112         s->private = "";
2113
2114         spin_lock_irqsave(&gpio_lock, flags);
2115         list_for_each_entry(chip, &gpio_chips, list)
2116                 if (index-- == 0) {
2117                         spin_unlock_irqrestore(&gpio_lock, flags);
2118                         return chip;
2119                 }
2120         spin_unlock_irqrestore(&gpio_lock, flags);
2121
2122         return NULL;
2123 }
2124
2125 static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
2126 {
2127         unsigned long flags;
2128         struct gpio_chip *chip = v;
2129         void *ret = NULL;
2130
2131         spin_lock_irqsave(&gpio_lock, flags);
2132         if (list_is_last(&chip->list, &gpio_chips))
2133                 ret = NULL;
2134         else
2135                 ret = list_entry(chip->list.next, struct gpio_chip, list);
2136         spin_unlock_irqrestore(&gpio_lock, flags);
2137
2138         s->private = "\n";
2139         ++*pos;
2140
2141         return ret;
2142 }
2143
2144 static void gpiolib_seq_stop(struct seq_file *s, void *v)
2145 {
2146 }
2147
2148 static int gpiolib_seq_show(struct seq_file *s, void *v)
2149 {
2150         struct gpio_chip *chip = v;
2151         struct device *dev;
2152
2153         seq_printf(s, "%sGPIOs %d-%d", (char *)s->private,
2154                         chip->base, chip->base + chip->ngpio - 1);
2155         dev = chip->dev;
2156         if (dev)
2157                 seq_printf(s, ", %s/%s", dev->bus ? dev->bus->name : "no-bus",
2158                         dev_name(dev));
2159         if (chip->label)
2160                 seq_printf(s, ", %s", chip->label);
2161         if (chip->can_sleep)
2162                 seq_printf(s, ", can sleep");
2163         seq_printf(s, ":\n");
2164
2165         if (chip->dbg_show)
2166                 chip->dbg_show(s, chip);
2167         else
2168                 gpiolib_dbg_show(s, chip);
2169
2170         return 0;
2171 }
2172
2173 static const struct seq_operations gpiolib_seq_ops = {
2174         .start = gpiolib_seq_start,
2175         .next = gpiolib_seq_next,
2176         .stop = gpiolib_seq_stop,
2177         .show = gpiolib_seq_show,
2178 };
2179
2180 static int gpiolib_open(struct inode *inode, struct file *file)
2181 {
2182         return seq_open(file, &gpiolib_seq_ops);
2183 }
2184
2185 static const struct file_operations gpiolib_operations = {
2186         .owner          = THIS_MODULE,
2187         .open           = gpiolib_open,
2188         .read           = seq_read,
2189         .llseek         = seq_lseek,
2190         .release        = seq_release,
2191 };
2192
2193 static int __init gpiolib_debugfs_init(void)
2194 {
2195         /* /sys/kernel/debug/gpio */
2196         (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
2197                                 NULL, NULL, &gpiolib_operations);
2198         return 0;
2199 }
2200 subsys_initcall(gpiolib_debugfs_init);
2201
2202 #endif  /* DEBUG_FS */