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