aef6b3d8e2cf32f637cbdaeb2d4557f73e976361
[linux-2.6.git] / drivers / gpio / gpiolib.c
1 #include <linux/kernel.h>
2 #include <linux/module.h>
3 #include <linux/irq.h>
4 #include <linux/spinlock.h>
5 #include <linux/device.h>
6 #include <linux/err.h>
7 #include <linux/debugfs.h>
8 #include <linux/seq_file.h>
9 #include <linux/gpio.h>
10
11
12 /* Optional implementation infrastructure for GPIO interfaces.
13  *
14  * Platforms may want to use this if they tend to use very many GPIOs
15  * that aren't part of a System-On-Chip core; or across I2C/SPI/etc.
16  *
17  * When kernel footprint or instruction count is an issue, simpler
18  * implementations may be preferred.  The GPIO programming interface
19  * allows for inlining speed-critical get/set operations for common
20  * cases, so that access to SOC-integrated GPIOs can sometimes cost
21  * only an instruction or two per bit.
22  */
23
24
25 /* When debugging, extend minimal trust to callers and platform code.
26  * Also emit diagnostic messages that may help initial bringup, when
27  * board setup or driver bugs are most common.
28  *
29  * Otherwise, minimize overhead in what may be bitbanging codepaths.
30  */
31 #ifdef  DEBUG
32 #define extra_checks    1
33 #else
34 #define extra_checks    0
35 #endif
36
37 /* gpio_lock prevents conflicts during gpio_desc[] table updates.
38  * While any GPIO is requested, its gpio_chip is not removable;
39  * each GPIO's "requested" flag serves as a lock and refcount.
40  */
41 static DEFINE_SPINLOCK(gpio_lock);
42
43 struct gpio_desc {
44         struct gpio_chip        *chip;
45         unsigned long           flags;
46 /* flag symbols are bit numbers */
47 #define FLAG_REQUESTED  0
48 #define FLAG_IS_OUT     1
49 #define FLAG_RESERVED   2
50 #define FLAG_EXPORT     3       /* protected by sysfs_lock */
51 #define FLAG_SYSFS      4       /* exported via /sys/class/gpio/control */
52
53 #ifdef CONFIG_DEBUG_FS
54         const char              *label;
55 #endif
56 };
57 static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];
58
59 static inline void desc_set_label(struct gpio_desc *d, const char *label)
60 {
61 #ifdef CONFIG_DEBUG_FS
62         d->label = label;
63 #endif
64 }
65
66 /* Warn when drivers omit gpio_request() calls -- legal but ill-advised
67  * when setting direction, and otherwise illegal.  Until board setup code
68  * and drivers use explicit requests everywhere (which won't happen when
69  * those calls have no teeth) we can't avoid autorequesting.  This nag
70  * message should motivate switching to explicit requests... so should
71  * the weaker cleanup after faults, compared to gpio_request().
72  *
73  * NOTE: the autorequest mechanism is going away; at this point it's
74  * only "legal" in the sense that (old) code using it won't break yet,
75  * but instead only triggers a WARN() stack dump.
76  */
77 static int gpio_ensure_requested(struct gpio_desc *desc, unsigned offset)
78 {
79         const struct gpio_chip *chip = desc->chip;
80         const int gpio = chip->base + offset;
81
82         if (WARN(test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0,
83                         "autorequest GPIO-%d\n", gpio)) {
84                 if (!try_module_get(chip->owner)) {
85                         pr_err("GPIO-%d: module can't be gotten \n", gpio);
86                         clear_bit(FLAG_REQUESTED, &desc->flags);
87                         /* lose */
88                         return -EIO;
89                 }
90                 desc_set_label(desc, "[auto]");
91                 /* caller must chip->request() w/o spinlock */
92                 if (chip->request)
93                         return 1;
94         }
95         return 0;
96 }
97
98 /* caller holds gpio_lock *OR* gpio is marked as requested */
99 static inline struct gpio_chip *gpio_to_chip(unsigned gpio)
100 {
101         return gpio_desc[gpio].chip;
102 }
103
104 /* dynamic allocation of GPIOs, e.g. on a hotplugged device */
105 static int gpiochip_find_base(int ngpio)
106 {
107         int i;
108         int spare = 0;
109         int base = -ENOSPC;
110
111         for (i = ARCH_NR_GPIOS - 1; i >= 0 ; i--) {
112                 struct gpio_desc *desc = &gpio_desc[i];
113                 struct gpio_chip *chip = desc->chip;
114
115                 if (!chip && !test_bit(FLAG_RESERVED, &desc->flags)) {
116                         spare++;
117                         if (spare == ngpio) {
118                                 base = i;
119                                 break;
120                         }
121                 } else {
122                         spare = 0;
123                         if (chip)
124                                 i -= chip->ngpio - 1;
125                 }
126         }
127
128         if (gpio_is_valid(base))
129                 pr_debug("%s: found new base at %d\n", __func__, base);
130         return base;
131 }
132
133 /**
134  * gpiochip_reserve() - reserve range of gpios to use with platform code only
135  * @start: starting gpio number
136  * @ngpio: number of gpios to reserve
137  * Context: platform init, potentially before irqs or kmalloc will work
138  *
139  * Returns a negative errno if any gpio within the range is already reserved
140  * or registered, else returns zero as a success code.  Use this function
141  * to mark a range of gpios as unavailable for dynamic gpio number allocation,
142  * for example because its driver support is not yet loaded.
143  */
144 int __init gpiochip_reserve(int start, int ngpio)
145 {
146         int ret = 0;
147         unsigned long flags;
148         int i;
149
150         if (!gpio_is_valid(start) || !gpio_is_valid(start + ngpio - 1))
151                 return -EINVAL;
152
153         spin_lock_irqsave(&gpio_lock, flags);
154
155         for (i = start; i < start + ngpio; i++) {
156                 struct gpio_desc *desc = &gpio_desc[i];
157
158                 if (desc->chip || test_bit(FLAG_RESERVED, &desc->flags)) {
159                         ret = -EBUSY;
160                         goto err;
161                 }
162
163                 set_bit(FLAG_RESERVED, &desc->flags);
164         }
165
166         pr_debug("%s: reserved gpios from %d to %d\n",
167                  __func__, start, start + ngpio - 1);
168 err:
169         spin_unlock_irqrestore(&gpio_lock, flags);
170
171         return ret;
172 }
173
174 #ifdef CONFIG_GPIO_SYSFS
175
176 /* lock protects against unexport_gpio() being called while
177  * sysfs files are active.
178  */
179 static DEFINE_MUTEX(sysfs_lock);
180
181 /*
182  * /sys/class/gpio/gpioN... only for GPIOs that are exported
183  *   /direction
184  *      * MAY BE OMITTED if kernel won't allow direction changes
185  *      * is read/write as "in" or "out"
186  *      * may also be written as "high" or "low", initializing
187  *        output value as specified ("out" implies "low")
188  *   /value
189  *      * always readable, subject to hardware behavior
190  *      * may be writable, as zero/nonzero
191  *
192  * REVISIT there will likely be an attribute for configuring async
193  * notifications, e.g. to specify polling interval or IRQ trigger type
194  * that would for example trigger a poll() on the "value".
195  */
196
197 static ssize_t gpio_direction_show(struct device *dev,
198                 struct device_attribute *attr, char *buf)
199 {
200         const struct gpio_desc  *desc = dev_get_drvdata(dev);
201         ssize_t                 status;
202
203         mutex_lock(&sysfs_lock);
204
205         if (!test_bit(FLAG_EXPORT, &desc->flags))
206                 status = -EIO;
207         else
208                 status = sprintf(buf, "%s\n",
209                         test_bit(FLAG_IS_OUT, &desc->flags)
210                                 ? "out" : "in");
211
212         mutex_unlock(&sysfs_lock);
213         return status;
214 }
215
216 static ssize_t gpio_direction_store(struct device *dev,
217                 struct device_attribute *attr, const char *buf, size_t size)
218 {
219         const struct gpio_desc  *desc = dev_get_drvdata(dev);
220         unsigned                gpio = desc - gpio_desc;
221         ssize_t                 status;
222
223         mutex_lock(&sysfs_lock);
224
225         if (!test_bit(FLAG_EXPORT, &desc->flags))
226                 status = -EIO;
227         else if (sysfs_streq(buf, "high"))
228                 status = gpio_direction_output(gpio, 1);
229         else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
230                 status = gpio_direction_output(gpio, 0);
231         else if (sysfs_streq(buf, "in"))
232                 status = gpio_direction_input(gpio);
233         else
234                 status = -EINVAL;
235
236         mutex_unlock(&sysfs_lock);
237         return status ? : size;
238 }
239
240 static const DEVICE_ATTR(direction, 0644,
241                 gpio_direction_show, gpio_direction_store);
242
243 static ssize_t gpio_value_show(struct device *dev,
244                 struct device_attribute *attr, char *buf)
245 {
246         const struct gpio_desc  *desc = dev_get_drvdata(dev);
247         unsigned                gpio = desc - gpio_desc;
248         ssize_t                 status;
249
250         mutex_lock(&sysfs_lock);
251
252         if (!test_bit(FLAG_EXPORT, &desc->flags))
253                 status = -EIO;
254         else
255                 status = sprintf(buf, "%d\n", !!gpio_get_value_cansleep(gpio));
256
257         mutex_unlock(&sysfs_lock);
258         return status;
259 }
260
261 static ssize_t gpio_value_store(struct device *dev,
262                 struct device_attribute *attr, const char *buf, size_t size)
263 {
264         const struct gpio_desc  *desc = dev_get_drvdata(dev);
265         unsigned                gpio = desc - gpio_desc;
266         ssize_t                 status;
267
268         mutex_lock(&sysfs_lock);
269
270         if (!test_bit(FLAG_EXPORT, &desc->flags))
271                 status = -EIO;
272         else if (!test_bit(FLAG_IS_OUT, &desc->flags))
273                 status = -EPERM;
274         else {
275                 long            value;
276
277                 status = strict_strtol(buf, 0, &value);
278                 if (status == 0) {
279                         gpio_set_value_cansleep(gpio, value != 0);
280                         status = size;
281                 }
282         }
283
284         mutex_unlock(&sysfs_lock);
285         return status;
286 }
287
288 static /*const*/ DEVICE_ATTR(value, 0644,
289                 gpio_value_show, gpio_value_store);
290
291 static const struct attribute *gpio_attrs[] = {
292         &dev_attr_direction.attr,
293         &dev_attr_value.attr,
294         NULL,
295 };
296
297 static const struct attribute_group gpio_attr_group = {
298         .attrs = (struct attribute **) gpio_attrs,
299 };
300
301 /*
302  * /sys/class/gpio/gpiochipN/
303  *   /base ... matching gpio_chip.base (N)
304  *   /label ... matching gpio_chip.label
305  *   /ngpio ... matching gpio_chip.ngpio
306  */
307
308 static ssize_t chip_base_show(struct device *dev,
309                                struct device_attribute *attr, char *buf)
310 {
311         const struct gpio_chip  *chip = dev_get_drvdata(dev);
312
313         return sprintf(buf, "%d\n", chip->base);
314 }
315 static DEVICE_ATTR(base, 0444, chip_base_show, NULL);
316
317 static ssize_t chip_label_show(struct device *dev,
318                                struct device_attribute *attr, char *buf)
319 {
320         const struct gpio_chip  *chip = dev_get_drvdata(dev);
321
322         return sprintf(buf, "%s\n", chip->label ? : "");
323 }
324 static DEVICE_ATTR(label, 0444, chip_label_show, NULL);
325
326 static ssize_t chip_ngpio_show(struct device *dev,
327                                struct device_attribute *attr, char *buf)
328 {
329         const struct gpio_chip  *chip = dev_get_drvdata(dev);
330
331         return sprintf(buf, "%u\n", chip->ngpio);
332 }
333 static DEVICE_ATTR(ngpio, 0444, chip_ngpio_show, NULL);
334
335 static const struct attribute *gpiochip_attrs[] = {
336         &dev_attr_base.attr,
337         &dev_attr_label.attr,
338         &dev_attr_ngpio.attr,
339         NULL,
340 };
341
342 static const struct attribute_group gpiochip_attr_group = {
343         .attrs = (struct attribute **) gpiochip_attrs,
344 };
345
346 /*
347  * /sys/class/gpio/export ... write-only
348  *      integer N ... number of GPIO to export (full access)
349  * /sys/class/gpio/unexport ... write-only
350  *      integer N ... number of GPIO to unexport
351  */
352 static ssize_t export_store(struct class *class, const char *buf, size_t len)
353 {
354         long    gpio;
355         int     status;
356
357         status = strict_strtol(buf, 0, &gpio);
358         if (status < 0)
359                 goto done;
360
361         /* No extra locking here; FLAG_SYSFS just signifies that the
362          * request and export were done by on behalf of userspace, so
363          * they may be undone on its behalf too.
364          */
365
366         status = gpio_request(gpio, "sysfs");
367         if (status < 0)
368                 goto done;
369
370         status = gpio_export(gpio, true);
371         if (status < 0)
372                 gpio_free(gpio);
373         else
374                 set_bit(FLAG_SYSFS, &gpio_desc[gpio].flags);
375
376 done:
377         if (status)
378                 pr_debug("%s: status %d\n", __func__, status);
379         return status ? : len;
380 }
381
382 static ssize_t unexport_store(struct class *class, const char *buf, size_t len)
383 {
384         long    gpio;
385         int     status;
386
387         status = strict_strtol(buf, 0, &gpio);
388         if (status < 0)
389                 goto done;
390
391         status = -EINVAL;
392
393         /* reject bogus commands (gpio_unexport ignores them) */
394         if (!gpio_is_valid(gpio))
395                 goto done;
396
397         /* No extra locking here; FLAG_SYSFS just signifies that the
398          * request and export were done by on behalf of userspace, so
399          * they may be undone on its behalf too.
400          */
401         if (test_and_clear_bit(FLAG_SYSFS, &gpio_desc[gpio].flags)) {
402                 status = 0;
403                 gpio_free(gpio);
404         }
405 done:
406         if (status)
407                 pr_debug("%s: status %d\n", __func__, status);
408         return status ? : len;
409 }
410
411 static struct class_attribute gpio_class_attrs[] = {
412         __ATTR(export, 0200, NULL, export_store),
413         __ATTR(unexport, 0200, NULL, unexport_store),
414         __ATTR_NULL,
415 };
416
417 static struct class gpio_class = {
418         .name =         "gpio",
419         .owner =        THIS_MODULE,
420
421         .class_attrs =  gpio_class_attrs,
422 };
423
424
425 /**
426  * gpio_export - export a GPIO through sysfs
427  * @gpio: gpio to make available, already requested
428  * @direction_may_change: true if userspace may change gpio direction
429  * Context: arch_initcall or later
430  *
431  * When drivers want to make a GPIO accessible to userspace after they
432  * have requested it -- perhaps while debugging, or as part of their
433  * public interface -- they may use this routine.  If the GPIO can
434  * change direction (some can't) and the caller allows it, userspace
435  * will see "direction" sysfs attribute which may be used to change
436  * the gpio's direction.  A "value" attribute will always be provided.
437  *
438  * Returns zero on success, else an error.
439  */
440 int gpio_export(unsigned gpio, bool direction_may_change)
441 {
442         unsigned long           flags;
443         struct gpio_desc        *desc;
444         int                     status = -EINVAL;
445         char                    *ioname = NULL;
446
447         /* can't export until sysfs is available ... */
448         if (!gpio_class.p) {
449                 pr_debug("%s: called too early!\n", __func__);
450                 return -ENOENT;
451         }
452
453         if (!gpio_is_valid(gpio))
454                 goto done;
455
456         mutex_lock(&sysfs_lock);
457
458         spin_lock_irqsave(&gpio_lock, flags);
459         desc = &gpio_desc[gpio];
460         if (test_bit(FLAG_REQUESTED, &desc->flags)
461                         && !test_bit(FLAG_EXPORT, &desc->flags)) {
462                 status = 0;
463                 if (!desc->chip->direction_input
464                                 || !desc->chip->direction_output)
465                         direction_may_change = false;
466         }
467         spin_unlock_irqrestore(&gpio_lock, flags);
468
469         if (desc->chip->names && desc->chip->names[gpio - desc->chip->base])
470                 ioname = desc->chip->names[gpio - desc->chip->base];
471
472         if (status == 0) {
473                 struct device   *dev;
474
475                 dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
476                                     desc, ioname ? ioname : "gpio%d", gpio);
477                 if (dev) {
478                         if (direction_may_change)
479                                 status = sysfs_create_group(&dev->kobj,
480                                                 &gpio_attr_group);
481                         else
482                                 status = device_create_file(dev,
483                                                 &dev_attr_value);
484                         if (status != 0)
485                                 device_unregister(dev);
486                 } else
487                         status = -ENODEV;
488                 if (status == 0)
489                         set_bit(FLAG_EXPORT, &desc->flags);
490         }
491
492         mutex_unlock(&sysfs_lock);
493
494 done:
495         if (status)
496                 pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
497
498         return status;
499 }
500 EXPORT_SYMBOL_GPL(gpio_export);
501
502 static int match_export(struct device *dev, void *data)
503 {
504         return dev_get_drvdata(dev) == data;
505 }
506
507 /**
508  * gpio_export_link - create a sysfs link to an exported GPIO node
509  * @dev: device under which to create symlink
510  * @name: name of the symlink
511  * @gpio: gpio to create symlink to, already exported
512  *
513  * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
514  * node. Caller is responsible for unlinking.
515  *
516  * Returns zero on success, else an error.
517  */
518 int gpio_export_link(struct device *dev, const char *name, unsigned gpio)
519 {
520         struct gpio_desc        *desc;
521         int                     status = -EINVAL;
522
523         if (!gpio_is_valid(gpio))
524                 goto done;
525
526         mutex_lock(&sysfs_lock);
527
528         desc = &gpio_desc[gpio];
529
530         if (test_bit(FLAG_EXPORT, &desc->flags)) {
531                 struct device *tdev;
532
533                 tdev = class_find_device(&gpio_class, NULL, desc, match_export);
534                 if (tdev != NULL) {
535                         status = sysfs_create_link(&dev->kobj, &tdev->kobj,
536                                                 name);
537                 } else {
538                         status = -ENODEV;
539                 }
540         }
541
542         mutex_unlock(&sysfs_lock);
543
544 done:
545         if (status)
546                 pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
547
548         return status;
549 }
550 EXPORT_SYMBOL_GPL(gpio_export_link);
551
552 /**
553  * gpio_unexport - reverse effect of gpio_export()
554  * @gpio: gpio to make unavailable
555  *
556  * This is implicit on gpio_free().
557  */
558 void gpio_unexport(unsigned gpio)
559 {
560         struct gpio_desc        *desc;
561         int                     status = -EINVAL;
562
563         if (!gpio_is_valid(gpio))
564                 goto done;
565
566         mutex_lock(&sysfs_lock);
567
568         desc = &gpio_desc[gpio];
569
570         if (test_bit(FLAG_EXPORT, &desc->flags)) {
571                 struct device   *dev = NULL;
572
573                 dev = class_find_device(&gpio_class, NULL, desc, match_export);
574                 if (dev) {
575                         clear_bit(FLAG_EXPORT, &desc->flags);
576                         put_device(dev);
577                         device_unregister(dev);
578                         status = 0;
579                 } else
580                         status = -ENODEV;
581         }
582
583         mutex_unlock(&sysfs_lock);
584 done:
585         if (status)
586                 pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
587 }
588 EXPORT_SYMBOL_GPL(gpio_unexport);
589
590 static int gpiochip_export(struct gpio_chip *chip)
591 {
592         int             status;
593         struct device   *dev;
594
595         /* Many systems register gpio chips for SOC support very early,
596          * before driver model support is available.  In those cases we
597          * export this later, in gpiolib_sysfs_init() ... here we just
598          * verify that _some_ field of gpio_class got initialized.
599          */
600         if (!gpio_class.p)
601                 return 0;
602
603         /* use chip->base for the ID; it's already known to be unique */
604         mutex_lock(&sysfs_lock);
605         dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
606                                 "gpiochip%d", chip->base);
607         if (dev) {
608                 status = sysfs_create_group(&dev->kobj,
609                                 &gpiochip_attr_group);
610         } else
611                 status = -ENODEV;
612         chip->exported = (status == 0);
613         mutex_unlock(&sysfs_lock);
614
615         if (status) {
616                 unsigned long   flags;
617                 unsigned        gpio;
618
619                 spin_lock_irqsave(&gpio_lock, flags);
620                 gpio = chip->base;
621                 while (gpio_desc[gpio].chip == chip)
622                         gpio_desc[gpio++].chip = NULL;
623                 spin_unlock_irqrestore(&gpio_lock, flags);
624
625                 pr_debug("%s: chip %s status %d\n", __func__,
626                                 chip->label, status);
627         }
628
629         return status;
630 }
631
632 static void gpiochip_unexport(struct gpio_chip *chip)
633 {
634         int                     status;
635         struct device           *dev;
636
637         mutex_lock(&sysfs_lock);
638         dev = class_find_device(&gpio_class, NULL, chip, match_export);
639         if (dev) {
640                 put_device(dev);
641                 device_unregister(dev);
642                 chip->exported = 0;
643                 status = 0;
644         } else
645                 status = -ENODEV;
646         mutex_unlock(&sysfs_lock);
647
648         if (status)
649                 pr_debug("%s: chip %s status %d\n", __func__,
650                                 chip->label, status);
651 }
652
653 static int __init gpiolib_sysfs_init(void)
654 {
655         int             status;
656         unsigned long   flags;
657         unsigned        gpio;
658
659         status = class_register(&gpio_class);
660         if (status < 0)
661                 return status;
662
663         /* Scan and register the gpio_chips which registered very
664          * early (e.g. before the class_register above was called).
665          *
666          * We run before arch_initcall() so chip->dev nodes can have
667          * registered, and so arch_initcall() can always gpio_export().
668          */
669         spin_lock_irqsave(&gpio_lock, flags);
670         for (gpio = 0; gpio < ARCH_NR_GPIOS; gpio++) {
671                 struct gpio_chip        *chip;
672
673                 chip = gpio_desc[gpio].chip;
674                 if (!chip || chip->exported)
675                         continue;
676
677                 spin_unlock_irqrestore(&gpio_lock, flags);
678                 status = gpiochip_export(chip);
679                 spin_lock_irqsave(&gpio_lock, flags);
680         }
681         spin_unlock_irqrestore(&gpio_lock, flags);
682
683
684         return status;
685 }
686 postcore_initcall(gpiolib_sysfs_init);
687
688 #else
689 static inline int gpiochip_export(struct gpio_chip *chip)
690 {
691         return 0;
692 }
693
694 static inline void gpiochip_unexport(struct gpio_chip *chip)
695 {
696 }
697
698 #endif /* CONFIG_GPIO_SYSFS */
699
700 /**
701  * gpiochip_add() - register a gpio_chip
702  * @chip: the chip to register, with chip->base initialized
703  * Context: potentially before irqs or kmalloc will work
704  *
705  * Returns a negative errno if the chip can't be registered, such as
706  * because the chip->base is invalid or already associated with a
707  * different chip.  Otherwise it returns zero as a success code.
708  *
709  * When gpiochip_add() is called very early during boot, so that GPIOs
710  * can be freely used, the chip->dev device must be registered before
711  * the gpio framework's arch_initcall().  Otherwise sysfs initialization
712  * for GPIOs will fail rudely.
713  *
714  * If chip->base is negative, this requests dynamic assignment of
715  * a range of valid GPIOs.
716  */
717 int gpiochip_add(struct gpio_chip *chip)
718 {
719         unsigned long   flags;
720         int             status = 0;
721         unsigned        id;
722         int             base = chip->base;
723
724         if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))
725                         && base >= 0) {
726                 status = -EINVAL;
727                 goto fail;
728         }
729
730         spin_lock_irqsave(&gpio_lock, flags);
731
732         if (base < 0) {
733                 base = gpiochip_find_base(chip->ngpio);
734                 if (base < 0) {
735                         status = base;
736                         goto unlock;
737                 }
738                 chip->base = base;
739         }
740
741         /* these GPIO numbers must not be managed by another gpio_chip */
742         for (id = base; id < base + chip->ngpio; id++) {
743                 if (gpio_desc[id].chip != NULL) {
744                         status = -EBUSY;
745                         break;
746                 }
747         }
748         if (status == 0) {
749                 for (id = base; id < base + chip->ngpio; id++) {
750                         gpio_desc[id].chip = chip;
751
752                         /* REVISIT:  most hardware initializes GPIOs as
753                          * inputs (often with pullups enabled) so power
754                          * usage is minimized.  Linux code should set the
755                          * gpio direction first thing; but until it does,
756                          * we may expose the wrong direction in sysfs.
757                          */
758                         gpio_desc[id].flags = !chip->direction_input
759                                 ? (1 << FLAG_IS_OUT)
760                                 : 0;
761                 }
762         }
763
764 unlock:
765         spin_unlock_irqrestore(&gpio_lock, flags);
766         if (status == 0)
767                 status = gpiochip_export(chip);
768 fail:
769         /* failures here can mean systems won't boot... */
770         if (status)
771                 pr_err("gpiochip_add: gpios %d..%d (%s) not registered\n",
772                         chip->base, chip->base + chip->ngpio - 1,
773                         chip->label ? : "generic");
774         return status;
775 }
776 EXPORT_SYMBOL_GPL(gpiochip_add);
777
778 /**
779  * gpiochip_remove() - unregister a gpio_chip
780  * @chip: the chip to unregister
781  *
782  * A gpio_chip with any GPIOs still requested may not be removed.
783  */
784 int gpiochip_remove(struct gpio_chip *chip)
785 {
786         unsigned long   flags;
787         int             status = 0;
788         unsigned        id;
789
790         spin_lock_irqsave(&gpio_lock, flags);
791
792         for (id = chip->base; id < chip->base + chip->ngpio; id++) {
793                 if (test_bit(FLAG_REQUESTED, &gpio_desc[id].flags)) {
794                         status = -EBUSY;
795                         break;
796                 }
797         }
798         if (status == 0) {
799                 for (id = chip->base; id < chip->base + chip->ngpio; id++)
800                         gpio_desc[id].chip = NULL;
801         }
802
803         spin_unlock_irqrestore(&gpio_lock, flags);
804
805         if (status == 0)
806                 gpiochip_unexport(chip);
807
808         return status;
809 }
810 EXPORT_SYMBOL_GPL(gpiochip_remove);
811
812
813 /* These "optional" allocation calls help prevent drivers from stomping
814  * on each other, and help provide better diagnostics in debugfs.
815  * They're called even less than the "set direction" calls.
816  */
817 int gpio_request(unsigned gpio, const char *label)
818 {
819         struct gpio_desc        *desc;
820         struct gpio_chip        *chip;
821         int                     status = -EINVAL;
822         unsigned long           flags;
823
824         spin_lock_irqsave(&gpio_lock, flags);
825
826         if (!gpio_is_valid(gpio))
827                 goto done;
828         desc = &gpio_desc[gpio];
829         chip = desc->chip;
830         if (chip == NULL)
831                 goto done;
832
833         if (!try_module_get(chip->owner))
834                 goto done;
835
836         /* NOTE:  gpio_request() can be called in early boot,
837          * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
838          */
839
840         if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
841                 desc_set_label(desc, label ? : "?");
842                 status = 0;
843         } else {
844                 status = -EBUSY;
845                 module_put(chip->owner);
846                 goto done;
847         }
848
849         if (chip->request) {
850                 /* chip->request may sleep */
851                 spin_unlock_irqrestore(&gpio_lock, flags);
852                 status = chip->request(chip, gpio - chip->base);
853                 spin_lock_irqsave(&gpio_lock, flags);
854
855                 if (status < 0) {
856                         desc_set_label(desc, NULL);
857                         module_put(chip->owner);
858                         clear_bit(FLAG_REQUESTED, &desc->flags);
859                 }
860         }
861
862 done:
863         if (status)
864                 pr_debug("gpio_request: gpio-%d (%s) status %d\n",
865                         gpio, label ? : "?", status);
866         spin_unlock_irqrestore(&gpio_lock, flags);
867         return status;
868 }
869 EXPORT_SYMBOL_GPL(gpio_request);
870
871 void gpio_free(unsigned gpio)
872 {
873         unsigned long           flags;
874         struct gpio_desc        *desc;
875         struct gpio_chip        *chip;
876
877         might_sleep();
878
879         if (!gpio_is_valid(gpio)) {
880                 WARN_ON(extra_checks);
881                 return;
882         }
883
884         gpio_unexport(gpio);
885
886         spin_lock_irqsave(&gpio_lock, flags);
887
888         desc = &gpio_desc[gpio];
889         chip = desc->chip;
890         if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
891                 if (chip->free) {
892                         spin_unlock_irqrestore(&gpio_lock, flags);
893                         might_sleep_if(extra_checks && chip->can_sleep);
894                         chip->free(chip, gpio - chip->base);
895                         spin_lock_irqsave(&gpio_lock, flags);
896                 }
897                 desc_set_label(desc, NULL);
898                 module_put(desc->chip->owner);
899                 clear_bit(FLAG_REQUESTED, &desc->flags);
900         } else
901                 WARN_ON(extra_checks);
902
903         spin_unlock_irqrestore(&gpio_lock, flags);
904 }
905 EXPORT_SYMBOL_GPL(gpio_free);
906
907
908 /**
909  * gpiochip_is_requested - return string iff signal was requested
910  * @chip: controller managing the signal
911  * @offset: of signal within controller's 0..(ngpio - 1) range
912  *
913  * Returns NULL if the GPIO is not currently requested, else a string.
914  * If debugfs support is enabled, the string returned is the label passed
915  * to gpio_request(); otherwise it is a meaningless constant.
916  *
917  * This function is for use by GPIO controller drivers.  The label can
918  * help with diagnostics, and knowing that the signal is used as a GPIO
919  * can help avoid accidentally multiplexing it to another controller.
920  */
921 const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
922 {
923         unsigned gpio = chip->base + offset;
924
925         if (!gpio_is_valid(gpio) || gpio_desc[gpio].chip != chip)
926                 return NULL;
927         if (test_bit(FLAG_REQUESTED, &gpio_desc[gpio].flags) == 0)
928                 return NULL;
929 #ifdef CONFIG_DEBUG_FS
930         return gpio_desc[gpio].label;
931 #else
932         return "?";
933 #endif
934 }
935 EXPORT_SYMBOL_GPL(gpiochip_is_requested);
936
937
938 /* Drivers MUST set GPIO direction before making get/set calls.  In
939  * some cases this is done in early boot, before IRQs are enabled.
940  *
941  * As a rule these aren't called more than once (except for drivers
942  * using the open-drain emulation idiom) so these are natural places
943  * to accumulate extra debugging checks.  Note that we can't (yet)
944  * rely on gpio_request() having been called beforehand.
945  */
946
947 int gpio_direction_input(unsigned gpio)
948 {
949         unsigned long           flags;
950         struct gpio_chip        *chip;
951         struct gpio_desc        *desc = &gpio_desc[gpio];
952         int                     status = -EINVAL;
953
954         spin_lock_irqsave(&gpio_lock, flags);
955
956         if (!gpio_is_valid(gpio))
957                 goto fail;
958         chip = desc->chip;
959         if (!chip || !chip->get || !chip->direction_input)
960                 goto fail;
961         gpio -= chip->base;
962         if (gpio >= chip->ngpio)
963                 goto fail;
964         status = gpio_ensure_requested(desc, gpio);
965         if (status < 0)
966                 goto fail;
967
968         /* now we know the gpio is valid and chip won't vanish */
969
970         spin_unlock_irqrestore(&gpio_lock, flags);
971
972         might_sleep_if(extra_checks && chip->can_sleep);
973
974         if (status) {
975                 status = chip->request(chip, gpio);
976                 if (status < 0) {
977                         pr_debug("GPIO-%d: chip request fail, %d\n",
978                                 chip->base + gpio, status);
979                         /* and it's not available to anyone else ...
980                          * gpio_request() is the fully clean solution.
981                          */
982                         goto lose;
983                 }
984         }
985
986         status = chip->direction_input(chip, gpio);
987         if (status == 0)
988                 clear_bit(FLAG_IS_OUT, &desc->flags);
989 lose:
990         return status;
991 fail:
992         spin_unlock_irqrestore(&gpio_lock, flags);
993         if (status)
994                 pr_debug("%s: gpio-%d status %d\n",
995                         __func__, gpio, status);
996         return status;
997 }
998 EXPORT_SYMBOL_GPL(gpio_direction_input);
999
1000 int gpio_direction_output(unsigned gpio, int value)
1001 {
1002         unsigned long           flags;
1003         struct gpio_chip        *chip;
1004         struct gpio_desc        *desc = &gpio_desc[gpio];
1005         int                     status = -EINVAL;
1006
1007         spin_lock_irqsave(&gpio_lock, flags);
1008
1009         if (!gpio_is_valid(gpio))
1010                 goto fail;
1011         chip = desc->chip;
1012         if (!chip || !chip->set || !chip->direction_output)
1013                 goto fail;
1014         gpio -= chip->base;
1015         if (gpio >= chip->ngpio)
1016                 goto fail;
1017         status = gpio_ensure_requested(desc, gpio);
1018         if (status < 0)
1019                 goto fail;
1020
1021         /* now we know the gpio is valid and chip won't vanish */
1022
1023         spin_unlock_irqrestore(&gpio_lock, flags);
1024
1025         might_sleep_if(extra_checks && chip->can_sleep);
1026
1027         if (status) {
1028                 status = chip->request(chip, gpio);
1029                 if (status < 0) {
1030                         pr_debug("GPIO-%d: chip request fail, %d\n",
1031                                 chip->base + gpio, status);
1032                         /* and it's not available to anyone else ...
1033                          * gpio_request() is the fully clean solution.
1034                          */
1035                         goto lose;
1036                 }
1037         }
1038
1039         status = chip->direction_output(chip, gpio, value);
1040         if (status == 0)
1041                 set_bit(FLAG_IS_OUT, &desc->flags);
1042 lose:
1043         return status;
1044 fail:
1045         spin_unlock_irqrestore(&gpio_lock, flags);
1046         if (status)
1047                 pr_debug("%s: gpio-%d status %d\n",
1048                         __func__, gpio, status);
1049         return status;
1050 }
1051 EXPORT_SYMBOL_GPL(gpio_direction_output);
1052
1053
1054 /* I/O calls are only valid after configuration completed; the relevant
1055  * "is this a valid GPIO" error checks should already have been done.
1056  *
1057  * "Get" operations are often inlinable as reading a pin value register,
1058  * and masking the relevant bit in that register.
1059  *
1060  * When "set" operations are inlinable, they involve writing that mask to
1061  * one register to set a low value, or a different register to set it high.
1062  * Otherwise locking is needed, so there may be little value to inlining.
1063  *
1064  *------------------------------------------------------------------------
1065  *
1066  * IMPORTANT!!!  The hot paths -- get/set value -- assume that callers
1067  * have requested the GPIO.  That can include implicit requesting by
1068  * a direction setting call.  Marking a gpio as requested locks its chip
1069  * in memory, guaranteeing that these table lookups need no more locking
1070  * and that gpiochip_remove() will fail.
1071  *
1072  * REVISIT when debugging, consider adding some instrumentation to ensure
1073  * that the GPIO was actually requested.
1074  */
1075
1076 /**
1077  * __gpio_get_value() - return a gpio's value
1078  * @gpio: gpio whose value will be returned
1079  * Context: any
1080  *
1081  * This is used directly or indirectly to implement gpio_get_value().
1082  * It returns the zero or nonzero value provided by the associated
1083  * gpio_chip.get() method; or zero if no such method is provided.
1084  */
1085 int __gpio_get_value(unsigned gpio)
1086 {
1087         struct gpio_chip        *chip;
1088
1089         chip = gpio_to_chip(gpio);
1090         WARN_ON(extra_checks && chip->can_sleep);
1091         return chip->get ? chip->get(chip, gpio - chip->base) : 0;
1092 }
1093 EXPORT_SYMBOL_GPL(__gpio_get_value);
1094
1095 /**
1096  * __gpio_set_value() - assign a gpio's value
1097  * @gpio: gpio whose value will be assigned
1098  * @value: value to assign
1099  * Context: any
1100  *
1101  * This is used directly or indirectly to implement gpio_set_value().
1102  * It invokes the associated gpio_chip.set() method.
1103  */
1104 void __gpio_set_value(unsigned gpio, int value)
1105 {
1106         struct gpio_chip        *chip;
1107
1108         chip = gpio_to_chip(gpio);
1109         WARN_ON(extra_checks && chip->can_sleep);
1110         chip->set(chip, gpio - chip->base, value);
1111 }
1112 EXPORT_SYMBOL_GPL(__gpio_set_value);
1113
1114 /**
1115  * __gpio_cansleep() - report whether gpio value access will sleep
1116  * @gpio: gpio in question
1117  * Context: any
1118  *
1119  * This is used directly or indirectly to implement gpio_cansleep().  It
1120  * returns nonzero if access reading or writing the GPIO value can sleep.
1121  */
1122 int __gpio_cansleep(unsigned gpio)
1123 {
1124         struct gpio_chip        *chip;
1125
1126         /* only call this on GPIOs that are valid! */
1127         chip = gpio_to_chip(gpio);
1128
1129         return chip->can_sleep;
1130 }
1131 EXPORT_SYMBOL_GPL(__gpio_cansleep);
1132
1133 /**
1134  * __gpio_to_irq() - return the IRQ corresponding to a GPIO
1135  * @gpio: gpio whose IRQ will be returned (already requested)
1136  * Context: any
1137  *
1138  * This is used directly or indirectly to implement gpio_to_irq().
1139  * It returns the number of the IRQ signaled by this (input) GPIO,
1140  * or a negative errno.
1141  */
1142 int __gpio_to_irq(unsigned gpio)
1143 {
1144         struct gpio_chip        *chip;
1145
1146         chip = gpio_to_chip(gpio);
1147         return chip->to_irq ? chip->to_irq(chip, gpio - chip->base) : -ENXIO;
1148 }
1149 EXPORT_SYMBOL_GPL(__gpio_to_irq);
1150
1151
1152
1153 /* There's no value in making it easy to inline GPIO calls that may sleep.
1154  * Common examples include ones connected to I2C or SPI chips.
1155  */
1156
1157 int gpio_get_value_cansleep(unsigned gpio)
1158 {
1159         struct gpio_chip        *chip;
1160
1161         might_sleep_if(extra_checks);
1162         chip = gpio_to_chip(gpio);
1163         return chip->get ? chip->get(chip, gpio - chip->base) : 0;
1164 }
1165 EXPORT_SYMBOL_GPL(gpio_get_value_cansleep);
1166
1167 void gpio_set_value_cansleep(unsigned gpio, int value)
1168 {
1169         struct gpio_chip        *chip;
1170
1171         might_sleep_if(extra_checks);
1172         chip = gpio_to_chip(gpio);
1173         chip->set(chip, gpio - chip->base, value);
1174 }
1175 EXPORT_SYMBOL_GPL(gpio_set_value_cansleep);
1176
1177
1178 #ifdef CONFIG_DEBUG_FS
1179
1180 static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
1181 {
1182         unsigned                i;
1183         unsigned                gpio = chip->base;
1184         struct gpio_desc        *gdesc = &gpio_desc[gpio];
1185         int                     is_out;
1186
1187         for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) {
1188                 if (!test_bit(FLAG_REQUESTED, &gdesc->flags))
1189                         continue;
1190
1191                 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
1192                 seq_printf(s, " gpio-%-3d (%-20.20s) %s %s",
1193                         gpio, gdesc->label,
1194                         is_out ? "out" : "in ",
1195                         chip->get
1196                                 ? (chip->get(chip, i) ? "hi" : "lo")
1197                                 : "?  ");
1198
1199                 if (!is_out) {
1200                         int             irq = gpio_to_irq(gpio);
1201                         struct irq_desc *desc = irq_to_desc(irq);
1202
1203                         /* This races with request_irq(), set_irq_type(),
1204                          * and set_irq_wake() ... but those are "rare".
1205                          *
1206                          * More significantly, trigger type flags aren't
1207                          * currently maintained by genirq.
1208                          */
1209                         if (irq >= 0 && desc->action) {
1210                                 char *trigger;
1211
1212                                 switch (desc->status & IRQ_TYPE_SENSE_MASK) {
1213                                 case IRQ_TYPE_NONE:
1214                                         trigger = "(default)";
1215                                         break;
1216                                 case IRQ_TYPE_EDGE_FALLING:
1217                                         trigger = "edge-falling";
1218                                         break;
1219                                 case IRQ_TYPE_EDGE_RISING:
1220                                         trigger = "edge-rising";
1221                                         break;
1222                                 case IRQ_TYPE_EDGE_BOTH:
1223                                         trigger = "edge-both";
1224                                         break;
1225                                 case IRQ_TYPE_LEVEL_HIGH:
1226                                         trigger = "level-high";
1227                                         break;
1228                                 case IRQ_TYPE_LEVEL_LOW:
1229                                         trigger = "level-low";
1230                                         break;
1231                                 default:
1232                                         trigger = "?trigger?";
1233                                         break;
1234                                 }
1235
1236                                 seq_printf(s, " irq-%d %s%s",
1237                                         irq, trigger,
1238                                         (desc->status & IRQ_WAKEUP)
1239                                                 ? " wakeup" : "");
1240                         }
1241                 }
1242
1243                 seq_printf(s, "\n");
1244         }
1245 }
1246
1247 static int gpiolib_show(struct seq_file *s, void *unused)
1248 {
1249         struct gpio_chip        *chip = NULL;
1250         unsigned                gpio;
1251         int                     started = 0;
1252
1253         /* REVISIT this isn't locked against gpio_chip removal ... */
1254
1255         for (gpio = 0; gpio_is_valid(gpio); gpio++) {
1256                 struct device *dev;
1257
1258                 if (chip == gpio_desc[gpio].chip)
1259                         continue;
1260                 chip = gpio_desc[gpio].chip;
1261                 if (!chip)
1262                         continue;
1263
1264                 seq_printf(s, "%sGPIOs %d-%d",
1265                                 started ? "\n" : "",
1266                                 chip->base, chip->base + chip->ngpio - 1);
1267                 dev = chip->dev;
1268                 if (dev)
1269                         seq_printf(s, ", %s/%s",
1270                                 dev->bus ? dev->bus->name : "no-bus",
1271                                 dev_name(dev));
1272                 if (chip->label)
1273                         seq_printf(s, ", %s", chip->label);
1274                 if (chip->can_sleep)
1275                         seq_printf(s, ", can sleep");
1276                 seq_printf(s, ":\n");
1277
1278                 started = 1;
1279                 if (chip->dbg_show)
1280                         chip->dbg_show(s, chip);
1281                 else
1282                         gpiolib_dbg_show(s, chip);
1283         }
1284         return 0;
1285 }
1286
1287 static int gpiolib_open(struct inode *inode, struct file *file)
1288 {
1289         return single_open(file, gpiolib_show, NULL);
1290 }
1291
1292 static struct file_operations gpiolib_operations = {
1293         .open           = gpiolib_open,
1294         .read           = seq_read,
1295         .llseek         = seq_lseek,
1296         .release        = single_release,
1297 };
1298
1299 static int __init gpiolib_debugfs_init(void)
1300 {
1301         /* /sys/kernel/debug/gpio */
1302         (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
1303                                 NULL, NULL, &gpiolib_operations);
1304         return 0;
1305 }
1306 subsys_initcall(gpiolib_debugfs_init);
1307
1308 #endif  /* DEBUG_FS */