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