Merge linux-3.10.67 into dev-kernel-3.10
[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 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 DEVICE_ATTR(active_low, 0644,
610                 gpio_active_low_show, gpio_active_low_store);
611
612 static 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 = 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 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 = 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_remove_attr_group;
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_remove_attr_direction;
843         }
844
845         set_bit(FLAG_EXPORT, &desc->flags);
846         mutex_unlock(&sysfs_lock);
847         return 0;
848
849 fail_remove_attr_direction:
850         device_remove_file(dev, &dev_attr_direction);
851 fail_remove_attr_group:
852         sysfs_remove_group(&dev->kobj, &gpio_attr_group);
853 fail_unregister_device:
854         device_unregister(dev);
855 fail_unlock:
856         mutex_unlock(&sysfs_lock);
857         pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
858                  status);
859         return status;
860 }
861
862 int gpio_export(unsigned gpio, bool direction_may_change)
863 {
864         return gpiod_export(gpio_to_desc(gpio), direction_may_change);
865 }
866 EXPORT_SYMBOL_GPL(gpio_export);
867
868 static int match_export(struct device *dev, const void *data)
869 {
870         return dev_get_drvdata(dev) == data;
871 }
872
873 /**
874  * gpio_export_link - create a sysfs link to an exported GPIO node
875  * @dev: device under which to create symlink
876  * @name: name of the symlink
877  * @gpio: gpio to create symlink to, already exported
878  *
879  * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
880  * node. Caller is responsible for unlinking.
881  *
882  * Returns zero on success, else an error.
883  */
884 static int gpiod_export_link(struct device *dev, const char *name,
885                              struct gpio_desc *desc)
886 {
887         int                     status = -EINVAL;
888
889         if (!desc) {
890                 pr_warn("%s: invalid GPIO\n", __func__);
891                 return -EINVAL;
892         }
893
894         mutex_lock(&sysfs_lock);
895
896         if (test_bit(FLAG_EXPORT, &desc->flags)) {
897                 struct device *tdev;
898
899                 tdev = class_find_device(&gpio_class, NULL, desc, match_export);
900                 if (tdev != NULL) {
901                         status = sysfs_create_link(&dev->kobj, &tdev->kobj,
902                                                 name);
903                 } else {
904                         status = -ENODEV;
905                 }
906         }
907
908         mutex_unlock(&sysfs_lock);
909
910         if (status)
911                 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
912                          status);
913
914         return status;
915 }
916
917 int gpio_export_link(struct device *dev, const char *name, unsigned gpio)
918 {
919         return gpiod_export_link(dev, name, gpio_to_desc(gpio));
920 }
921 EXPORT_SYMBOL_GPL(gpio_export_link);
922
923 /**
924  * gpio_sysfs_set_active_low - set the polarity of gpio sysfs value
925  * @gpio: gpio to change
926  * @value: non-zero to use active low, i.e. inverted values
927  *
928  * Set the polarity of /sys/class/gpio/gpioN/value sysfs attribute.
929  * The GPIO does not have to be exported yet.  If poll(2) support has
930  * been enabled for either rising or falling edge, it will be
931  * reconfigured to follow the new polarity.
932  *
933  * Returns zero on success, else an error.
934  */
935 static int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
936 {
937         struct device           *dev = NULL;
938         int                     status = -EINVAL;
939
940         if (!desc) {
941                 pr_warn("%s: invalid GPIO\n", __func__);
942                 return -EINVAL;
943         }
944
945         mutex_lock(&sysfs_lock);
946
947         if (test_bit(FLAG_EXPORT, &desc->flags)) {
948                 dev = class_find_device(&gpio_class, NULL, desc, match_export);
949                 if (dev == NULL) {
950                         status = -ENODEV;
951                         goto unlock;
952                 }
953         }
954
955         status = sysfs_set_active_low(desc, dev, value);
956
957 unlock:
958         mutex_unlock(&sysfs_lock);
959
960         if (status)
961                 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
962                          status);
963
964         return status;
965 }
966
967 int gpio_sysfs_set_active_low(unsigned gpio, int value)
968 {
969         return gpiod_sysfs_set_active_low(gpio_to_desc(gpio), value);
970 }
971 EXPORT_SYMBOL_GPL(gpio_sysfs_set_active_low);
972
973 /**
974  * gpio_unexport - reverse effect of gpio_export()
975  * @gpio: gpio to make unavailable
976  *
977  * This is implicit on gpio_free().
978  */
979 static void gpiod_unexport(struct gpio_desc *desc)
980 {
981         int                     status = 0;
982         struct device           *dev = NULL;
983
984         if (!desc) {
985                 pr_warn("%s: invalid GPIO\n", __func__);
986                 return;
987         }
988
989         mutex_lock(&sysfs_lock);
990
991         if (test_bit(FLAG_EXPORT, &desc->flags)) {
992
993                 dev = class_find_device(&gpio_class, NULL, desc, match_export);
994                 if (dev) {
995                         gpio_setup_irq(desc, dev, 0);
996                         clear_bit(FLAG_EXPORT, &desc->flags);
997                 } else
998                         status = -ENODEV;
999         }
1000
1001         mutex_unlock(&sysfs_lock);
1002
1003         if (dev) {
1004                 device_remove_file(dev, &dev_attr_edge);
1005                 device_remove_file(dev, &dev_attr_direction);
1006                 sysfs_remove_group(&dev->kobj, &gpio_attr_group);
1007                 device_unregister(dev);
1008                 put_device(dev);
1009         }
1010
1011         if (status)
1012                 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
1013                          status);
1014 }
1015
1016 void gpio_unexport(unsigned gpio)
1017 {
1018         gpiod_unexport(gpio_to_desc(gpio));
1019 }
1020 EXPORT_SYMBOL_GPL(gpio_unexport);
1021
1022 static int gpiochip_export(struct gpio_chip *chip)
1023 {
1024         int             status;
1025         struct device   *dev;
1026
1027         /* Many systems register gpio chips for SOC support very early,
1028          * before driver model support is available.  In those cases we
1029          * export this later, in gpiolib_sysfs_init() ... here we just
1030          * verify that _some_ field of gpio_class got initialized.
1031          */
1032         if (!gpio_class.p)
1033                 return 0;
1034
1035         /* use chip->base for the ID; it's already known to be unique */
1036         mutex_lock(&sysfs_lock);
1037         dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
1038                                 "gpiochip%d", chip->base);
1039         if (!IS_ERR(dev)) {
1040                 status = sysfs_create_group(&dev->kobj,
1041                                 &gpiochip_attr_group);
1042         } else
1043                 status = PTR_ERR(dev);
1044         chip->exported = (status == 0);
1045         mutex_unlock(&sysfs_lock);
1046
1047         if (status) {
1048                 unsigned long   flags;
1049                 unsigned        gpio;
1050
1051                 spin_lock_irqsave(&gpio_lock, flags);
1052                 gpio = 0;
1053                 while (gpio < chip->ngpio)
1054                         chip->desc[gpio++].chip = NULL;
1055                 spin_unlock_irqrestore(&gpio_lock, flags);
1056
1057                 pr_debug("%s: chip %s status %d\n", __func__,
1058                                 chip->label, status);
1059         }
1060
1061         return status;
1062 }
1063
1064 static void gpiochip_unexport(struct gpio_chip *chip)
1065 {
1066         int                     status;
1067         struct device           *dev;
1068
1069         mutex_lock(&sysfs_lock);
1070         dev = class_find_device(&gpio_class, NULL, chip, match_export);
1071         if (dev) {
1072                 sysfs_remove_group(&dev->kobj, &gpiochip_attr_group);
1073                 put_device(dev);
1074                 device_unregister(dev);
1075                 chip->exported = 0;
1076                 status = 0;
1077         } else
1078                 status = -ENODEV;
1079         mutex_unlock(&sysfs_lock);
1080
1081         if (status)
1082                 pr_debug("%s: chip %s status %d\n", __func__,
1083                                 chip->label, status);
1084 }
1085
1086 static int __init gpiolib_sysfs_init(void)
1087 {
1088         int             status;
1089         unsigned long   flags;
1090         struct gpio_chip *chip;
1091
1092         status = class_register(&gpio_class);
1093         if (status < 0)
1094                 return status;
1095
1096         /* Scan and register the gpio_chips which registered very
1097          * early (e.g. before the class_register above was called).
1098          *
1099          * We run before arch_initcall() so chip->dev nodes can have
1100          * registered, and so arch_initcall() can always gpio_export().
1101          */
1102         spin_lock_irqsave(&gpio_lock, flags);
1103         list_for_each_entry(chip, &gpio_chips, list) {
1104                 if (!chip || chip->exported)
1105                         continue;
1106
1107                 spin_unlock_irqrestore(&gpio_lock, flags);
1108                 status = gpiochip_export(chip);
1109                 spin_lock_irqsave(&gpio_lock, flags);
1110         }
1111         spin_unlock_irqrestore(&gpio_lock, flags);
1112
1113
1114         return status;
1115 }
1116 postcore_initcall(gpiolib_sysfs_init);
1117
1118 #else
1119 static inline int gpiochip_export(struct gpio_chip *chip)
1120 {
1121         return 0;
1122 }
1123
1124 static inline void gpiochip_unexport(struct gpio_chip *chip)
1125 {
1126 }
1127
1128 static inline int gpiod_export(struct gpio_desc *desc,
1129                                bool direction_may_change)
1130 {
1131         return -ENOSYS;
1132 }
1133
1134 static inline int gpiod_export_link(struct device *dev, const char *name,
1135                                     struct gpio_desc *desc)
1136 {
1137         return -ENOSYS;
1138 }
1139
1140 static inline int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
1141 {
1142         return -ENOSYS;
1143 }
1144
1145 static inline void gpiod_unexport(struct gpio_desc *desc)
1146 {
1147 }
1148
1149 #endif /* CONFIG_GPIO_SYSFS */
1150
1151 /*
1152  * Add a new chip to the global chips list, keeping the list of chips sorted
1153  * by base order.
1154  *
1155  * Return -EBUSY if the new chip overlaps with some other chip's integer
1156  * space.
1157  */
1158 static int gpiochip_add_to_list(struct gpio_chip *chip)
1159 {
1160         struct list_head *pos = &gpio_chips;
1161         struct gpio_chip *_chip;
1162         int err = 0;
1163
1164         /* find where to insert our chip */
1165         list_for_each(pos, &gpio_chips) {
1166                 _chip = list_entry(pos, struct gpio_chip, list);
1167                 /* shall we insert before _chip? */
1168                 if (_chip->base >= chip->base + chip->ngpio)
1169                         break;
1170         }
1171
1172         /* are we stepping on the chip right before? */
1173         if (pos != &gpio_chips && pos->prev != &gpio_chips) {
1174                 _chip = list_entry(pos->prev, struct gpio_chip, list);
1175                 if (_chip->base + _chip->ngpio > chip->base) {
1176                         dev_err(chip->dev,
1177                                "GPIO integer space overlap, cannot add chip\n");
1178                         err = -EBUSY;
1179                 }
1180         }
1181
1182         if (!err)
1183                 list_add_tail(&chip->list, pos);
1184
1185         return err;
1186 }
1187
1188 /**
1189  * gpiochip_add() - register a gpio_chip
1190  * @chip: the chip to register, with chip->base initialized
1191  * Context: potentially before irqs or kmalloc will work
1192  *
1193  * Returns a negative errno if the chip can't be registered, such as
1194  * because the chip->base is invalid or already associated with a
1195  * different chip.  Otherwise it returns zero as a success code.
1196  *
1197  * When gpiochip_add() is called very early during boot, so that GPIOs
1198  * can be freely used, the chip->dev device must be registered before
1199  * the gpio framework's arch_initcall().  Otherwise sysfs initialization
1200  * for GPIOs will fail rudely.
1201  *
1202  * If chip->base is negative, this requests dynamic assignment of
1203  * a range of valid GPIOs.
1204  */
1205 int gpiochip_add(struct gpio_chip *chip)
1206 {
1207         unsigned long   flags;
1208         int             status = 0;
1209         unsigned        id;
1210         int             base = chip->base;
1211         int             aliased_base = -1;
1212
1213         if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))
1214                         && base >= 0) {
1215                 status = -EINVAL;
1216                 goto fail;
1217         }
1218
1219 #ifdef CONFIG_OF
1220         if (chip->of_node)
1221                 aliased_base = of_alias_get_id(chip->of_node, "gpio");
1222 #endif
1223
1224         spin_lock_irqsave(&gpio_lock, flags);
1225
1226         if (base < 0) {
1227                 base = gpiochip_find_base(chip, aliased_base);
1228                 if (base < 0) {
1229                         status = base;
1230                         goto unlock;
1231                 }
1232                 chip->base = base;
1233         }
1234
1235         status = gpiochip_add_to_list(chip);
1236
1237         if (status == 0) {
1238                 chip->desc = &gpio_desc[chip->base];
1239
1240                 for (id = 0; id < chip->ngpio; id++) {
1241                         struct gpio_desc *desc = &chip->desc[id];
1242                         desc->chip = chip;
1243
1244                         /* REVISIT:  most hardware initializes GPIOs as
1245                          * inputs (often with pullups enabled) so power
1246                          * usage is minimized.  Linux code should set the
1247                          * gpio direction first thing; but until it does,
1248                          * and in case chip->get_direction is not set,
1249                          * we may expose the wrong direction in sysfs.
1250                          */
1251                         desc->flags = !chip->direction_input
1252                                 ? (1 << FLAG_IS_OUT)
1253                                 : 0;
1254                 }
1255         }
1256
1257         spin_unlock_irqrestore(&gpio_lock, flags);
1258
1259 #ifdef CONFIG_PINCTRL
1260         INIT_LIST_HEAD(&chip->pin_ranges);
1261 #endif
1262
1263         of_gpiochip_add(chip);
1264
1265         if (status)
1266                 goto fail;
1267
1268         of_gpiochip_init(chip);
1269
1270         status = gpiochip_export(chip);
1271         if (status)
1272                 goto fail;
1273
1274         pr_info("gpiochip_add: registered GPIOs %d to %d on device: %s\n",
1275                 chip->base, chip->base + chip->ngpio - 1,
1276                 chip->label ? : "generic");
1277
1278         return 0;
1279
1280 unlock:
1281         spin_unlock_irqrestore(&gpio_lock, flags);
1282 fail:
1283         /* failures here can mean systems won't boot... */
1284         pr_err("gpiochip_add: gpios %d..%d (%s) failed to register\n",
1285                 chip->base, chip->base + chip->ngpio - 1,
1286                 chip->label ? : "generic");
1287         return status;
1288 }
1289 EXPORT_SYMBOL_GPL(gpiochip_add);
1290
1291 /**
1292  * gpiochip_remove() - unregister a gpio_chip
1293  * @chip: the chip to unregister
1294  *
1295  * A gpio_chip with any GPIOs still requested may not be removed.
1296  */
1297 int gpiochip_remove(struct gpio_chip *chip)
1298 {
1299         unsigned long   flags;
1300         int             status = 0;
1301         unsigned        id;
1302
1303         spin_lock_irqsave(&gpio_lock, flags);
1304
1305         gpiochip_remove_pin_ranges(chip);
1306         of_gpiochip_remove(chip);
1307
1308         for (id = 0; id < chip->ngpio; id++) {
1309                 if (test_bit(FLAG_REQUESTED, &chip->desc[id].flags)) {
1310                         status = -EBUSY;
1311                         break;
1312                 }
1313         }
1314         if (status == 0) {
1315                 for (id = 0; id < chip->ngpio; id++)
1316                         chip->desc[id].chip = NULL;
1317
1318                 list_del(&chip->list);
1319         }
1320
1321         spin_unlock_irqrestore(&gpio_lock, flags);
1322
1323         if (status == 0)
1324                 gpiochip_unexport(chip);
1325
1326         return status;
1327 }
1328 EXPORT_SYMBOL_GPL(gpiochip_remove);
1329
1330 /**
1331  * gpiochip_find() - iterator for locating a specific gpio_chip
1332  * @data: data to pass to match function
1333  * @callback: Callback function to check gpio_chip
1334  *
1335  * Similar to bus_find_device.  It returns a reference to a gpio_chip as
1336  * determined by a user supplied @match callback.  The callback should return
1337  * 0 if the device doesn't match and non-zero if it does.  If the callback is
1338  * non-zero, this function will return to the caller and not iterate over any
1339  * more gpio_chips.
1340  */
1341 struct gpio_chip *gpiochip_find(void *data,
1342                                 int (*match)(struct gpio_chip *chip,
1343                                              void *data))
1344 {
1345         struct gpio_chip *chip;
1346         unsigned long flags;
1347
1348         spin_lock_irqsave(&gpio_lock, flags);
1349         list_for_each_entry(chip, &gpio_chips, list)
1350                 if (match(chip, data))
1351                         break;
1352
1353         /* No match? */
1354         if (&chip->list == &gpio_chips)
1355                 chip = NULL;
1356         spin_unlock_irqrestore(&gpio_lock, flags);
1357
1358         return chip;
1359 }
1360 EXPORT_SYMBOL_GPL(gpiochip_find);
1361
1362 #ifdef CONFIG_PINCTRL
1363
1364 /**
1365  * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
1366  * @chip: the gpiochip to add the range for
1367  * @pinctrl_name: the dev_name() of the pin controller to map to
1368  * @gpio_offset: the start offset in the current gpio_chip number space
1369  * @pin_offset: the start offset in the pin controller number space
1370  * @npins: the number of pins from the offset of each pin space (GPIO and
1371  *      pin controller) to accumulate in this range
1372  */
1373 int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
1374                            unsigned int gpio_offset, unsigned int pin_offset,
1375                            unsigned int npins)
1376 {
1377         struct gpio_pin_range *pin_range;
1378         int ret;
1379
1380         pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1381         if (!pin_range) {
1382                 pr_err("%s: GPIO chip: failed to allocate pin ranges\n",
1383                                 chip->label);
1384                 return -ENOMEM;
1385         }
1386
1387         /* Use local offset as range ID */
1388         pin_range->range.id = gpio_offset;
1389         pin_range->range.gc = chip;
1390         pin_range->range.name = chip->label;
1391         pin_range->range.base = chip->base + gpio_offset;
1392         pin_range->range.pin_base = pin_offset;
1393         pin_range->range.npins = npins;
1394         pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
1395                         &pin_range->range);
1396         if (IS_ERR(pin_range->pctldev)) {
1397                 ret = PTR_ERR(pin_range->pctldev);
1398                 pr_err("%s: GPIO chip: could not create pin range\n",
1399                        chip->label);
1400                 kfree(pin_range);
1401                 return ret;
1402         }
1403         pr_info("GPIO chip %s: created GPIO range %d->%d ==> %s PIN %d->%d\n",
1404                  chip->label, gpio_offset, gpio_offset + npins - 1,
1405                  pinctl_name,
1406                  pin_offset, pin_offset + npins - 1);
1407
1408         list_add_tail(&pin_range->node, &chip->pin_ranges);
1409
1410         return 0;
1411 }
1412 EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
1413
1414 /**
1415  * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
1416  * @chip: the chip to remove all the mappings for
1417  */
1418 void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
1419 {
1420         struct gpio_pin_range *pin_range, *tmp;
1421
1422         list_for_each_entry_safe(pin_range, tmp, &chip->pin_ranges, node) {
1423                 list_del(&pin_range->node);
1424                 pinctrl_remove_gpio_range(pin_range->pctldev,
1425                                 &pin_range->range);
1426                 kfree(pin_range);
1427         }
1428 }
1429 EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
1430
1431 #endif /* CONFIG_PINCTRL */
1432
1433 /* These "optional" allocation calls help prevent drivers from stomping
1434  * on each other, and help provide better diagnostics in debugfs.
1435  * They're called even less than the "set direction" calls.
1436  */
1437 static int gpiod_request(struct gpio_desc *desc, const char *label)
1438 {
1439         struct gpio_chip        *chip;
1440         int                     status = -EPROBE_DEFER;
1441         unsigned long           flags;
1442
1443         if (!desc) {
1444                 pr_warn("%s: invalid GPIO\n", __func__);
1445                 return -EINVAL;
1446         }
1447
1448         spin_lock_irqsave(&gpio_lock, flags);
1449
1450         chip = desc->chip;
1451         if (chip == NULL)
1452                 goto done;
1453
1454         if (!try_module_get(chip->owner))
1455                 goto done;
1456
1457         /* NOTE:  gpio_request() can be called in early boot,
1458          * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
1459          */
1460
1461         if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
1462                 desc_set_label(desc, label ? : "?");
1463                 status = 0;
1464         } else {
1465                 status = -EBUSY;
1466                 module_put(chip->owner);
1467                 goto done;
1468         }
1469
1470         if (chip->request) {
1471                 /* chip->request may sleep */
1472                 spin_unlock_irqrestore(&gpio_lock, flags);
1473                 status = chip->request(chip, gpio_chip_hwgpio(desc));
1474                 spin_lock_irqsave(&gpio_lock, flags);
1475
1476                 if (status < 0) {
1477                         desc_set_label(desc, NULL);
1478                         module_put(chip->owner);
1479                         clear_bit(FLAG_REQUESTED, &desc->flags);
1480                         goto done;
1481                 }
1482         }
1483         if (chip->get_direction) {
1484                 /* chip->get_direction may sleep */
1485                 spin_unlock_irqrestore(&gpio_lock, flags);
1486                 gpiod_get_direction(desc);
1487                 spin_lock_irqsave(&gpio_lock, flags);
1488         }
1489 done:
1490         if (status)
1491                 pr_debug("_gpio_request: gpio-%d (%s) status %d\n",
1492                          desc_to_gpio(desc), label ? : "?", status);
1493         spin_unlock_irqrestore(&gpio_lock, flags);
1494         return status;
1495 }
1496
1497 int gpio_request(unsigned gpio, const char *label)
1498 {
1499         return gpiod_request(gpio_to_desc(gpio), label);
1500 }
1501 EXPORT_SYMBOL_GPL(gpio_request);
1502
1503 static void gpiod_free(struct gpio_desc *desc)
1504 {
1505         unsigned long           flags;
1506         struct gpio_chip        *chip;
1507
1508         might_sleep();
1509
1510         if (!desc) {
1511                 WARN_ON(extra_checks);
1512                 return;
1513         }
1514
1515         gpiod_unexport(desc);
1516
1517         spin_lock_irqsave(&gpio_lock, flags);
1518
1519         chip = desc->chip;
1520         if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
1521                 if (chip->free) {
1522                         spin_unlock_irqrestore(&gpio_lock, flags);
1523                         might_sleep_if(chip->can_sleep);
1524                         chip->free(chip, gpio_chip_hwgpio(desc));
1525                         spin_lock_irqsave(&gpio_lock, flags);
1526                 }
1527                 desc_set_label(desc, NULL);
1528                 module_put(desc->chip->owner);
1529                 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
1530                 clear_bit(FLAG_REQUESTED, &desc->flags);
1531                 clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
1532                 clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
1533         } else
1534                 WARN_ON(extra_checks);
1535
1536         spin_unlock_irqrestore(&gpio_lock, flags);
1537 }
1538
1539 void gpio_free(unsigned gpio)
1540 {
1541         gpiod_free(gpio_to_desc(gpio));
1542 }
1543 EXPORT_SYMBOL_GPL(gpio_free);
1544
1545 /**
1546  * gpio_request_one - request a single GPIO with initial configuration
1547  * @gpio:       the GPIO number
1548  * @flags:      GPIO configuration as specified by GPIOF_*
1549  * @label:      a literal description string of this GPIO
1550  */
1551 int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
1552 {
1553         struct gpio_desc *desc;
1554         int err;
1555
1556         desc = gpio_to_desc(gpio);
1557
1558         err = gpiod_request(desc, label);
1559         if (err)
1560                 return err;
1561
1562         if (flags & GPIOF_OPEN_DRAIN)
1563                 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
1564
1565         if (flags & GPIOF_OPEN_SOURCE)
1566                 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
1567
1568         if (flags & GPIOF_DIR_IN)
1569                 err = gpiod_direction_input(desc);
1570         else
1571                 err = gpiod_direction_output(desc,
1572                                 (flags & GPIOF_INIT_HIGH) ? 1 : 0);
1573
1574         if (err)
1575                 goto free_gpio;
1576
1577         if (flags & GPIOF_EXPORT) {
1578                 err = gpiod_export(desc, flags & GPIOF_EXPORT_CHANGEABLE);
1579                 if (err)
1580                         goto free_gpio;
1581         }
1582
1583         return 0;
1584
1585  free_gpio:
1586         gpiod_free(desc);
1587         return err;
1588 }
1589 EXPORT_SYMBOL_GPL(gpio_request_one);
1590
1591 /**
1592  * gpio_request_array - request multiple GPIOs in a single call
1593  * @array:      array of the 'struct gpio'
1594  * @num:        how many GPIOs in the array
1595  */
1596 int gpio_request_array(const struct gpio *array, size_t num)
1597 {
1598         int i, err;
1599
1600         for (i = 0; i < num; i++, array++) {
1601                 err = gpio_request_one(array->gpio, array->flags, array->label);
1602                 if (err)
1603                         goto err_free;
1604         }
1605         return 0;
1606
1607 err_free:
1608         while (i--)
1609                 gpio_free((--array)->gpio);
1610         return err;
1611 }
1612 EXPORT_SYMBOL_GPL(gpio_request_array);
1613
1614 /**
1615  * gpio_free_array - release multiple GPIOs in a single call
1616  * @array:      array of the 'struct gpio'
1617  * @num:        how many GPIOs in the array
1618  */
1619 void gpio_free_array(const struct gpio *array, size_t num)
1620 {
1621         while (num--)
1622                 gpio_free((array++)->gpio);
1623 }
1624 EXPORT_SYMBOL_GPL(gpio_free_array);
1625
1626 /**
1627  * gpiochip_is_requested - return string iff signal was requested
1628  * @chip: controller managing the signal
1629  * @offset: of signal within controller's 0..(ngpio - 1) range
1630  *
1631  * Returns NULL if the GPIO is not currently requested, else a string.
1632  * If debugfs support is enabled, the string returned is the label passed
1633  * to gpio_request(); otherwise it is a meaningless constant.
1634  *
1635  * This function is for use by GPIO controller drivers.  The label can
1636  * help with diagnostics, and knowing that the signal is used as a GPIO
1637  * can help avoid accidentally multiplexing it to another controller.
1638  */
1639 const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
1640 {
1641         struct gpio_desc *desc;
1642
1643         if (!GPIO_OFFSET_VALID(chip, offset))
1644                 return NULL;
1645
1646         desc = &chip->desc[offset];
1647
1648         if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
1649                 return NULL;
1650 #ifdef CONFIG_DEBUG_FS
1651         return desc->label;
1652 #else
1653         return "?";
1654 #endif
1655 }
1656 EXPORT_SYMBOL_GPL(gpiochip_is_requested);
1657
1658
1659 /* Drivers MUST set GPIO direction before making get/set calls.  In
1660  * some cases this is done in early boot, before IRQs are enabled.
1661  *
1662  * As a rule these aren't called more than once (except for drivers
1663  * using the open-drain emulation idiom) so these are natural places
1664  * to accumulate extra debugging checks.  Note that we can't (yet)
1665  * rely on gpio_request() having been called beforehand.
1666  */
1667
1668 static int gpiod_direction_input(struct gpio_desc *desc)
1669 {
1670         unsigned long           flags;
1671         struct gpio_chip        *chip;
1672         int                     status = -EINVAL;
1673         int                     offset;
1674
1675         if (!desc) {
1676                 pr_warn("%s: invalid GPIO\n", __func__);
1677                 return -EINVAL;
1678         }
1679
1680         spin_lock_irqsave(&gpio_lock, flags);
1681
1682         chip = desc->chip;
1683         if (!chip || !chip->get || !chip->direction_input)
1684                 goto fail;
1685         status = gpio_ensure_requested(desc);
1686         if (status < 0)
1687                 goto fail;
1688
1689         /* now we know the gpio is valid and chip won't vanish */
1690
1691         spin_unlock_irqrestore(&gpio_lock, flags);
1692
1693         might_sleep_if(chip->can_sleep);
1694
1695         offset = gpio_chip_hwgpio(desc);
1696         if (status) {
1697                 status = chip->request(chip, offset);
1698                 if (status < 0) {
1699                         pr_debug("GPIO-%d: chip request fail, %d\n",
1700                                 desc_to_gpio(desc), status);
1701                         /* and it's not available to anyone else ...
1702                          * gpio_request() is the fully clean solution.
1703                          */
1704                         goto lose;
1705                 }
1706         }
1707
1708         status = chip->direction_input(chip, offset);
1709         if (status == 0)
1710                 clear_bit(FLAG_IS_OUT, &desc->flags);
1711
1712         trace_gpio_direction(desc_to_gpio(desc), 1, status);
1713 lose:
1714         return status;
1715 fail:
1716         spin_unlock_irqrestore(&gpio_lock, flags);
1717         if (status)
1718                 pr_debug("%s: gpio-%d status %d\n", __func__,
1719                          desc_to_gpio(desc), status);
1720         return status;
1721 }
1722
1723 int gpio_direction_input(unsigned gpio)
1724 {
1725         return gpiod_direction_input(gpio_to_desc(gpio));
1726 }
1727 EXPORT_SYMBOL_GPL(gpio_direction_input);
1728
1729 static int gpiod_direction_output(struct gpio_desc *desc, int value)
1730 {
1731         unsigned long           flags;
1732         struct gpio_chip        *chip;
1733         int                     status = -EINVAL;
1734         int offset;
1735
1736         if (!desc) {
1737                 pr_warn("%s: invalid GPIO\n", __func__);
1738                 return -EINVAL;
1739         }
1740
1741         /* Open drain pin should not be driven to 1 */
1742         if (value && test_bit(FLAG_OPEN_DRAIN,  &desc->flags))
1743                 return gpiod_direction_input(desc);
1744
1745         /* Open source pin should not be driven to 0 */
1746         if (!value && test_bit(FLAG_OPEN_SOURCE,  &desc->flags))
1747                 return gpiod_direction_input(desc);
1748
1749         spin_lock_irqsave(&gpio_lock, flags);
1750
1751         chip = desc->chip;
1752         if (!chip || !chip->set || !chip->direction_output)
1753                 goto fail;
1754         status = gpio_ensure_requested(desc);
1755         if (status < 0)
1756                 goto fail;
1757
1758         /* now we know the gpio is valid and chip won't vanish */
1759
1760         spin_unlock_irqrestore(&gpio_lock, flags);
1761
1762         might_sleep_if(chip->can_sleep);
1763
1764         offset = gpio_chip_hwgpio(desc);
1765         if (status) {
1766                 status = chip->request(chip, offset);
1767                 if (status < 0) {
1768                         pr_debug("GPIO-%d: chip request fail, %d\n",
1769                                 desc_to_gpio(desc), status);
1770                         /* and it's not available to anyone else ...
1771                          * gpio_request() is the fully clean solution.
1772                          */
1773                         goto lose;
1774                 }
1775         }
1776
1777         status = chip->direction_output(chip, offset, value);
1778         if (status == 0)
1779                 set_bit(FLAG_IS_OUT, &desc->flags);
1780         trace_gpio_value(desc_to_gpio(desc), 0, value);
1781         trace_gpio_direction(desc_to_gpio(desc), 0, status);
1782 lose:
1783         return status;
1784 fail:
1785         spin_unlock_irqrestore(&gpio_lock, flags);
1786         if (status)
1787                 pr_debug("%s: gpio-%d status %d\n", __func__,
1788                          desc_to_gpio(desc), status);
1789         return status;
1790 }
1791
1792 int gpio_direction_output(unsigned gpio, int value)
1793 {
1794         return gpiod_direction_output(gpio_to_desc(gpio), value);
1795 }
1796 EXPORT_SYMBOL_GPL(gpio_direction_output);
1797
1798 /**
1799  * gpio_set_debounce - sets @debounce time for a @gpio
1800  * @gpio: the gpio to set debounce time
1801  * @debounce: debounce time is microseconds
1802  */
1803 static int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
1804 {
1805         unsigned long           flags;
1806         struct gpio_chip        *chip;
1807         int                     status = -EINVAL;
1808         int                     offset;
1809
1810         if (!desc) {
1811                 pr_warn("%s: invalid GPIO\n", __func__);
1812                 return -EINVAL;
1813         }
1814
1815         spin_lock_irqsave(&gpio_lock, flags);
1816
1817         chip = desc->chip;
1818         if (!chip || !chip->set || !chip->set_debounce)
1819                 goto fail;
1820
1821         status = gpio_ensure_requested(desc);
1822         if (status < 0)
1823                 goto fail;
1824
1825         /* now we know the gpio is valid and chip won't vanish */
1826
1827         spin_unlock_irqrestore(&gpio_lock, flags);
1828
1829         might_sleep_if(chip->can_sleep);
1830
1831         offset = gpio_chip_hwgpio(desc);
1832         return chip->set_debounce(chip, offset, debounce);
1833
1834 fail:
1835         spin_unlock_irqrestore(&gpio_lock, flags);
1836         if (status)
1837                 pr_debug("%s: gpio-%d status %d\n", __func__,
1838                          desc_to_gpio(desc), status);
1839
1840         return status;
1841 }
1842
1843 int gpio_set_debounce(unsigned gpio, unsigned debounce)
1844 {
1845         return gpiod_set_debounce(gpio_to_desc(gpio), debounce);
1846 }
1847 EXPORT_SYMBOL_GPL(gpio_set_debounce);
1848
1849 /* I/O calls are only valid after configuration completed; the relevant
1850  * "is this a valid GPIO" error checks should already have been done.
1851  *
1852  * "Get" operations are often inlinable as reading a pin value register,
1853  * and masking the relevant bit in that register.
1854  *
1855  * When "set" operations are inlinable, they involve writing that mask to
1856  * one register to set a low value, or a different register to set it high.
1857  * Otherwise locking is needed, so there may be little value to inlining.
1858  *
1859  *------------------------------------------------------------------------
1860  *
1861  * IMPORTANT!!!  The hot paths -- get/set value -- assume that callers
1862  * have requested the GPIO.  That can include implicit requesting by
1863  * a direction setting call.  Marking a gpio as requested locks its chip
1864  * in memory, guaranteeing that these table lookups need no more locking
1865  * and that gpiochip_remove() will fail.
1866  *
1867  * REVISIT when debugging, consider adding some instrumentation to ensure
1868  * that the GPIO was actually requested.
1869  */
1870
1871 /**
1872  * __gpio_get_value() - return a gpio's value
1873  * @gpio: gpio whose value will be returned
1874  * Context: any
1875  *
1876  * This is used directly or indirectly to implement gpio_get_value().
1877  * It returns the zero or nonzero value provided by the associated
1878  * gpio_chip.get() method; or zero if no such method is provided.
1879  */
1880 static int gpiod_get_value(const struct gpio_desc *desc)
1881 {
1882         struct gpio_chip        *chip;
1883         int value;
1884         int offset;
1885
1886         if (!desc)
1887                 return 0;
1888         chip = desc->chip;
1889         offset = gpio_chip_hwgpio(desc);
1890         /* Should be using gpio_get_value_cansleep() */
1891         WARN_ON(chip->can_sleep);
1892         value = chip->get ? chip->get(chip, offset) : 0;
1893         trace_gpio_value(desc_to_gpio(desc), 1, value);
1894         return value;
1895 }
1896
1897 int __gpio_get_value(unsigned gpio)
1898 {
1899         return gpiod_get_value(gpio_to_desc(gpio));
1900 }
1901 EXPORT_SYMBOL_GPL(__gpio_get_value);
1902
1903 /*
1904  *  _gpio_set_open_drain_value() - Set the open drain gpio's value.
1905  * @gpio: Gpio whose state need to be set.
1906  * @chip: Gpio chip.
1907  * @value: Non-zero for setting it HIGH otherise it will set to LOW.
1908  */
1909 static void _gpio_set_open_drain_value(struct gpio_desc *desc, int value)
1910 {
1911         int err = 0;
1912         struct gpio_chip *chip = desc->chip;
1913         int offset = gpio_chip_hwgpio(desc);
1914
1915         if (value) {
1916                 err = chip->direction_input(chip, offset);
1917                 if (!err)
1918                         clear_bit(FLAG_IS_OUT, &desc->flags);
1919         } else {
1920                 err = chip->direction_output(chip, offset, 0);
1921                 if (!err)
1922                         set_bit(FLAG_IS_OUT, &desc->flags);
1923         }
1924         trace_gpio_direction(desc_to_gpio(desc), value, err);
1925         if (err < 0)
1926                 pr_err("%s: Error in set_value for open drain gpio%d err %d\n",
1927                                         __func__, desc_to_gpio(desc), err);
1928 }
1929
1930 /*
1931  *  _gpio_set_open_source() - Set the open source gpio's value.
1932  * @gpio: Gpio whose state need to be set.
1933  * @chip: Gpio chip.
1934  * @value: Non-zero for setting it HIGH otherise it will set to LOW.
1935  */
1936 static void _gpio_set_open_source_value(struct gpio_desc *desc, int value)
1937 {
1938         int err = 0;
1939         struct gpio_chip *chip = desc->chip;
1940         int offset = gpio_chip_hwgpio(desc);
1941
1942         if (value) {
1943                 err = chip->direction_output(chip, offset, 1);
1944                 if (!err)
1945                         set_bit(FLAG_IS_OUT, &desc->flags);
1946         } else {
1947                 err = chip->direction_input(chip, offset);
1948                 if (!err)
1949                         clear_bit(FLAG_IS_OUT, &desc->flags);
1950         }
1951         trace_gpio_direction(desc_to_gpio(desc), !value, err);
1952         if (err < 0)
1953                 pr_err("%s: Error in set_value for open source gpio%d err %d\n",
1954                                         __func__, desc_to_gpio(desc), err);
1955 }
1956
1957 /**
1958  * __gpio_set_value() - assign a gpio's value
1959  * @gpio: gpio whose value will be assigned
1960  * @value: value to assign
1961  * Context: any
1962  *
1963  * This is used directly or indirectly to implement gpio_set_value().
1964  * It invokes the associated gpio_chip.set() method.
1965  */
1966 static void gpiod_set_value(struct gpio_desc *desc, int value)
1967 {
1968         struct gpio_chip        *chip;
1969
1970         if (!desc)
1971                 return;
1972         chip = desc->chip;
1973         /* Should be using gpio_set_value_cansleep() */
1974         WARN_ON(chip->can_sleep);
1975         trace_gpio_value(desc_to_gpio(desc), 0, value);
1976         if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
1977                 _gpio_set_open_drain_value(desc, value);
1978         else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
1979                 _gpio_set_open_source_value(desc, value);
1980         else
1981                 chip->set(chip, gpio_chip_hwgpio(desc), value);
1982 }
1983
1984 void __gpio_set_value(unsigned gpio, int value)
1985 {
1986         return gpiod_set_value(gpio_to_desc(gpio), value);
1987 }
1988 EXPORT_SYMBOL_GPL(__gpio_set_value);
1989
1990 /**
1991  * __gpio_cansleep() - report whether gpio value access will sleep
1992  * @gpio: gpio in question
1993  * Context: any
1994  *
1995  * This is used directly or indirectly to implement gpio_cansleep().  It
1996  * returns nonzero if access reading or writing the GPIO value can sleep.
1997  */
1998 static int gpiod_cansleep(const struct gpio_desc *desc)
1999 {
2000         if (!desc)
2001                 return 0;
2002         /* only call this on GPIOs that are valid! */
2003         return desc->chip->can_sleep;
2004 }
2005
2006 int __gpio_cansleep(unsigned gpio)
2007 {
2008         return gpiod_cansleep(gpio_to_desc(gpio));
2009 }
2010 EXPORT_SYMBOL_GPL(__gpio_cansleep);
2011
2012 /**
2013  * __gpio_to_irq() - return the IRQ corresponding to a GPIO
2014  * @gpio: gpio whose IRQ will be returned (already requested)
2015  * Context: any
2016  *
2017  * This is used directly or indirectly to implement gpio_to_irq().
2018  * It returns the number of the IRQ signaled by this (input) GPIO,
2019  * or a negative errno.
2020  */
2021 static int gpiod_to_irq(const struct gpio_desc *desc)
2022 {
2023         struct gpio_chip        *chip;
2024         int                     offset;
2025
2026         if (!desc)
2027                 return -EINVAL;
2028         chip = desc->chip;
2029         offset = gpio_chip_hwgpio(desc);
2030         return chip->to_irq ? chip->to_irq(chip, offset) : -ENXIO;
2031 }
2032
2033 int __gpio_to_irq(unsigned gpio)
2034 {
2035         return gpiod_to_irq(gpio_to_desc(gpio));
2036 }
2037 EXPORT_SYMBOL_GPL(__gpio_to_irq);
2038
2039
2040 /* There's no value in making it easy to inline GPIO calls that may sleep.
2041  * Common examples include ones connected to I2C or SPI chips.
2042  */
2043
2044 static int gpiod_get_value_cansleep(const struct gpio_desc *desc)
2045 {
2046         struct gpio_chip        *chip;
2047         int value;
2048         int offset;
2049
2050         might_sleep_if(extra_checks);
2051         if (!desc)
2052                 return 0;
2053         chip = desc->chip;
2054         offset = gpio_chip_hwgpio(desc);
2055         value = chip->get ? chip->get(chip, offset) : 0;
2056         trace_gpio_value(desc_to_gpio(desc), 1, value);
2057         return value;
2058 }
2059
2060 int gpio_get_value_cansleep(unsigned gpio)
2061 {
2062         return gpiod_get_value_cansleep(gpio_to_desc(gpio));
2063 }
2064 EXPORT_SYMBOL_GPL(gpio_get_value_cansleep);
2065
2066 static void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
2067 {
2068         struct gpio_chip        *chip;
2069
2070         might_sleep_if(extra_checks);
2071         if (!desc)
2072                 return;
2073         chip = desc->chip;
2074         trace_gpio_value(desc_to_gpio(desc), 0, value);
2075         if (test_bit(FLAG_OPEN_DRAIN,  &desc->flags))
2076                 _gpio_set_open_drain_value(desc, value);
2077         else if (test_bit(FLAG_OPEN_SOURCE,  &desc->flags))
2078                 _gpio_set_open_source_value(desc, value);
2079         else
2080                 chip->set(chip, gpio_chip_hwgpio(desc), value);
2081 }
2082
2083 void gpio_set_value_cansleep(unsigned gpio, int value)
2084 {
2085         return gpiod_set_value_cansleep(gpio_to_desc(gpio), value);
2086 }
2087 EXPORT_SYMBOL_GPL(gpio_set_value_cansleep);
2088
2089 #ifdef CONFIG_DEBUG_FS
2090
2091 static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
2092 {
2093         unsigned                i;
2094         unsigned                gpio = chip->base;
2095         struct gpio_desc        *gdesc = &chip->desc[0];
2096         int                     is_out;
2097
2098         for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) {
2099                 if (!test_bit(FLAG_REQUESTED, &gdesc->flags))
2100                         continue;
2101
2102                 gpiod_get_direction(gdesc);
2103                 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
2104                 seq_printf(s, " gpio-%-3d (%-20.20s) %s %s",
2105                         gpio, gdesc->label,
2106                         is_out ? "out" : "in ",
2107                         chip->get
2108                                 ? (chip->get(chip, i) ? "hi" : "lo")
2109                                 : "?  ");
2110                 seq_printf(s, "\n");
2111         }
2112 }
2113
2114 static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
2115 {
2116         unsigned long flags;
2117         struct gpio_chip *chip = NULL;
2118         loff_t index = *pos;
2119
2120         s->private = "";
2121
2122         spin_lock_irqsave(&gpio_lock, flags);
2123         list_for_each_entry(chip, &gpio_chips, list)
2124                 if (index-- == 0) {
2125                         spin_unlock_irqrestore(&gpio_lock, flags);
2126                         return chip;
2127                 }
2128         spin_unlock_irqrestore(&gpio_lock, flags);
2129
2130         return NULL;
2131 }
2132
2133 static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
2134 {
2135         unsigned long flags;
2136         struct gpio_chip *chip = v;
2137         void *ret = NULL;
2138
2139         spin_lock_irqsave(&gpio_lock, flags);
2140         if (list_is_last(&chip->list, &gpio_chips))
2141                 ret = NULL;
2142         else
2143                 ret = list_entry(chip->list.next, struct gpio_chip, list);
2144         spin_unlock_irqrestore(&gpio_lock, flags);
2145
2146         s->private = "\n";
2147         ++*pos;
2148
2149         return ret;
2150 }
2151
2152 static void gpiolib_seq_stop(struct seq_file *s, void *v)
2153 {
2154 }
2155
2156 static int gpiolib_seq_show(struct seq_file *s, void *v)
2157 {
2158         struct gpio_chip *chip = v;
2159         struct device *dev;
2160
2161         seq_printf(s, "%sGPIOs %d-%d", (char *)s->private,
2162                         chip->base, chip->base + chip->ngpio - 1);
2163         dev = chip->dev;
2164         if (dev)
2165                 seq_printf(s, ", %s/%s", dev->bus ? dev->bus->name : "no-bus",
2166                         dev_name(dev));
2167         if (chip->label)
2168                 seq_printf(s, ", %s", chip->label);
2169         if (chip->can_sleep)
2170                 seq_printf(s, ", can sleep");
2171         seq_printf(s, ":\n");
2172
2173         if (chip->dbg_show)
2174                 chip->dbg_show(s, chip);
2175         else
2176                 gpiolib_dbg_show(s, chip);
2177
2178         return 0;
2179 }
2180
2181 static const struct seq_operations gpiolib_seq_ops = {
2182         .start = gpiolib_seq_start,
2183         .next = gpiolib_seq_next,
2184         .stop = gpiolib_seq_stop,
2185         .show = gpiolib_seq_show,
2186 };
2187
2188 static int gpiolib_open(struct inode *inode, struct file *file)
2189 {
2190         return seq_open(file, &gpiolib_seq_ops);
2191 }
2192
2193 static const struct file_operations gpiolib_operations = {
2194         .owner          = THIS_MODULE,
2195         .open           = gpiolib_open,
2196         .read           = seq_read,
2197         .llseek         = seq_lseek,
2198         .release        = seq_release,
2199 };
2200
2201 static int __init gpiolib_debugfs_init(void)
2202 {
2203         /* /sys/kernel/debug/gpio */
2204         (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
2205                                 NULL, NULL, &gpiolib_operations);
2206         return 0;
2207 }
2208 subsys_initcall(gpiolib_debugfs_init);
2209
2210 #endif  /* DEBUG_FS */