1 #include <linux/kernel.h>
2 #include <linux/module.h>
3 #include <linux/interrupt.h>
5 #include <linux/spinlock.h>
6 #include <linux/device.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>
15 #define CREATE_TRACE_POINTS
16 #include <trace/events/gpio.h>
18 /* Optional implementation infrastructure for GPIO interfaces.
20 * Platforms may want to use this if they tend to use very many GPIOs
21 * that aren't part of a System-On-Chip core; or across I2C/SPI/etc.
23 * When kernel footprint or instruction count is an issue, simpler
24 * implementations may be preferred. The GPIO programming interface
25 * allows for inlining speed-critical get/set operations for common
26 * cases, so that access to SOC-integrated GPIOs can sometimes cost
27 * only an instruction or two per bit.
31 /* When debugging, extend minimal trust to callers and platform code.
32 * Also emit diagnostic messages that may help initial bringup, when
33 * board setup or driver bugs are most common.
35 * Otherwise, minimize overhead in what may be bitbanging codepaths.
38 #define extra_checks 1
40 #define extra_checks 0
43 /* gpio_lock prevents conflicts during gpio_desc[] table updates.
44 * While any GPIO is requested, its gpio_chip is not removable;
45 * each GPIO's "requested" flag serves as a lock and refcount.
47 static DEFINE_SPINLOCK(gpio_lock
);
50 struct gpio_chip
*chip
;
52 /* flag symbols are bit numbers */
53 #define FLAG_REQUESTED 0
55 #define FLAG_RESERVED 2
56 #define FLAG_EXPORT 3 /* protected by sysfs_lock */
57 #define FLAG_SYSFS 4 /* exported via /sys/class/gpio/control */
58 #define FLAG_TRIG_FALL 5 /* trigger on falling edge */
59 #define FLAG_TRIG_RISE 6 /* trigger on rising edge */
60 #define FLAG_ACTIVE_LOW 7 /* sysfs value has active low */
61 #define FLAG_OPEN_DRAIN 8 /* Gpio is open drain type */
63 #define ID_SHIFT 16 /* add new flags before this one */
65 #define GPIO_FLAGS_MASK ((1 << ID_SHIFT) - 1)
66 #define GPIO_TRIGGER_MASK (BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE))
68 #ifdef CONFIG_DEBUG_FS
72 static struct gpio_desc gpio_desc
[ARCH_NR_GPIOS
];
74 #ifdef CONFIG_GPIO_SYSFS
75 static DEFINE_IDR(dirent_idr
);
78 static inline void desc_set_label(struct gpio_desc
*d
, const char *label
)
80 #ifdef CONFIG_DEBUG_FS
85 /* Warn when drivers omit gpio_request() calls -- legal but ill-advised
86 * when setting direction, and otherwise illegal. Until board setup code
87 * and drivers use explicit requests everywhere (which won't happen when
88 * those calls have no teeth) we can't avoid autorequesting. This nag
89 * message should motivate switching to explicit requests... so should
90 * the weaker cleanup after faults, compared to gpio_request().
92 * NOTE: the autorequest mechanism is going away; at this point it's
93 * only "legal" in the sense that (old) code using it won't break yet,
94 * but instead only triggers a WARN() stack dump.
96 static int gpio_ensure_requested(struct gpio_desc
*desc
, unsigned offset
)
98 const struct gpio_chip
*chip
= desc
->chip
;
99 const int gpio
= chip
->base
+ offset
;
101 if (WARN(test_and_set_bit(FLAG_REQUESTED
, &desc
->flags
) == 0,
102 "autorequest GPIO-%d\n", gpio
)) {
103 if (!try_module_get(chip
->owner
)) {
104 pr_err("GPIO-%d: module can't be gotten \n", gpio
);
105 clear_bit(FLAG_REQUESTED
, &desc
->flags
);
109 desc_set_label(desc
, "[auto]");
110 /* caller must chip->request() w/o spinlock */
117 /* caller holds gpio_lock *OR* gpio is marked as requested */
118 struct gpio_chip
*gpio_to_chip(unsigned gpio
)
120 return gpio_desc
[gpio
].chip
;
123 /* dynamic allocation of GPIOs, e.g. on a hotplugged device */
124 static int gpiochip_find_base(int ngpio
)
130 for (i
= ARCH_NR_GPIOS
- 1; i
>= 0 ; i
--) {
131 struct gpio_desc
*desc
= &gpio_desc
[i
];
132 struct gpio_chip
*chip
= desc
->chip
;
134 if (!chip
&& !test_bit(FLAG_RESERVED
, &desc
->flags
)) {
136 if (spare
== ngpio
) {
143 i
-= chip
->ngpio
- 1;
147 if (gpio_is_valid(base
))
148 pr_debug("%s: found new base at %d\n", __func__
, base
);
153 * gpiochip_reserve() - reserve range of gpios to use with platform code only
154 * @start: starting gpio number
155 * @ngpio: number of gpios to reserve
156 * Context: platform init, potentially before irqs or kmalloc will work
158 * Returns a negative errno if any gpio within the range is already reserved
159 * or registered, else returns zero as a success code. Use this function
160 * to mark a range of gpios as unavailable for dynamic gpio number allocation,
161 * for example because its driver support is not yet loaded.
163 int __init
gpiochip_reserve(int start
, int ngpio
)
169 if (!gpio_is_valid(start
) || !gpio_is_valid(start
+ ngpio
- 1))
172 spin_lock_irqsave(&gpio_lock
, flags
);
174 for (i
= start
; i
< start
+ ngpio
; i
++) {
175 struct gpio_desc
*desc
= &gpio_desc
[i
];
177 if (desc
->chip
|| test_bit(FLAG_RESERVED
, &desc
->flags
)) {
182 set_bit(FLAG_RESERVED
, &desc
->flags
);
185 pr_debug("%s: reserved gpios from %d to %d\n",
186 __func__
, start
, start
+ ngpio
- 1);
188 spin_unlock_irqrestore(&gpio_lock
, flags
);
193 #ifdef CONFIG_GPIO_SYSFS
195 /* lock protects against unexport_gpio() being called while
196 * sysfs files are active.
198 static DEFINE_MUTEX(sysfs_lock
);
201 * /sys/class/gpio/gpioN... only for GPIOs that are exported
203 * * MAY BE OMITTED if kernel won't allow direction changes
204 * * is read/write as "in" or "out"
205 * * may also be written as "high" or "low", initializing
206 * output value as specified ("out" implies "low")
208 * * always readable, subject to hardware behavior
209 * * may be writable, as zero/nonzero
211 * * configures behavior of poll(2) on /value
212 * * available only if pin can generate IRQs on input
213 * * is read/write as "none", "falling", "rising", or "both"
215 * * configures polarity of /value
216 * * is read/write as zero/nonzero
217 * * also affects existing and subsequent "falling" and "rising"
218 * /edge configuration
221 static ssize_t
gpio_direction_show(struct device
*dev
,
222 struct device_attribute
*attr
, char *buf
)
224 const struct gpio_desc
*desc
= dev_get_drvdata(dev
);
227 mutex_lock(&sysfs_lock
);
229 if (!test_bit(FLAG_EXPORT
, &desc
->flags
))
232 status
= sprintf(buf
, "%s\n",
233 test_bit(FLAG_IS_OUT
, &desc
->flags
)
236 mutex_unlock(&sysfs_lock
);
240 static ssize_t
gpio_direction_store(struct device
*dev
,
241 struct device_attribute
*attr
, const char *buf
, size_t size
)
243 const struct gpio_desc
*desc
= dev_get_drvdata(dev
);
244 unsigned gpio
= desc
- gpio_desc
;
247 mutex_lock(&sysfs_lock
);
249 if (!test_bit(FLAG_EXPORT
, &desc
->flags
))
251 else if (sysfs_streq(buf
, "high"))
252 status
= gpio_direction_output(gpio
, 1);
253 else if (sysfs_streq(buf
, "out") || sysfs_streq(buf
, "low"))
254 status
= gpio_direction_output(gpio
, 0);
255 else if (sysfs_streq(buf
, "in"))
256 status
= gpio_direction_input(gpio
);
260 mutex_unlock(&sysfs_lock
);
261 return status
? : size
;
264 static /* const */ DEVICE_ATTR(direction
, 0644,
265 gpio_direction_show
, gpio_direction_store
);
267 static ssize_t
gpio_value_show(struct device
*dev
,
268 struct device_attribute
*attr
, char *buf
)
270 const struct gpio_desc
*desc
= dev_get_drvdata(dev
);
271 unsigned gpio
= desc
- gpio_desc
;
274 mutex_lock(&sysfs_lock
);
276 if (!test_bit(FLAG_EXPORT
, &desc
->flags
)) {
281 value
= !!gpio_get_value_cansleep(gpio
);
282 if (test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
))
285 status
= sprintf(buf
, "%d\n", value
);
288 mutex_unlock(&sysfs_lock
);
292 static ssize_t
gpio_value_store(struct device
*dev
,
293 struct device_attribute
*attr
, const char *buf
, size_t size
)
295 const struct gpio_desc
*desc
= dev_get_drvdata(dev
);
296 unsigned gpio
= desc
- gpio_desc
;
299 mutex_lock(&sysfs_lock
);
301 if (!test_bit(FLAG_EXPORT
, &desc
->flags
))
303 else if (!test_bit(FLAG_IS_OUT
, &desc
->flags
))
308 status
= strict_strtol(buf
, 0, &value
);
310 if (test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
))
312 gpio_set_value_cansleep(gpio
, value
!= 0);
317 mutex_unlock(&sysfs_lock
);
321 static const DEVICE_ATTR(value
, 0644,
322 gpio_value_show
, gpio_value_store
);
324 static irqreturn_t
gpio_sysfs_irq(int irq
, void *priv
)
326 struct sysfs_dirent
*value_sd
= priv
;
328 sysfs_notify_dirent(value_sd
);
332 static int gpio_setup_irq(struct gpio_desc
*desc
, struct device
*dev
,
333 unsigned long gpio_flags
)
335 struct sysfs_dirent
*value_sd
;
336 unsigned long irq_flags
;
339 if ((desc
->flags
& GPIO_TRIGGER_MASK
) == gpio_flags
)
342 irq
= gpio_to_irq(desc
- gpio_desc
);
346 id
= desc
->flags
>> ID_SHIFT
;
347 value_sd
= idr_find(&dirent_idr
, id
);
349 free_irq(irq
, value_sd
);
351 desc
->flags
&= ~GPIO_TRIGGER_MASK
;
358 irq_flags
= IRQF_SHARED
;
359 if (test_bit(FLAG_TRIG_FALL
, &gpio_flags
))
360 irq_flags
|= test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
) ?
361 IRQF_TRIGGER_RISING
: IRQF_TRIGGER_FALLING
;
362 if (test_bit(FLAG_TRIG_RISE
, &gpio_flags
))
363 irq_flags
|= test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
) ?
364 IRQF_TRIGGER_FALLING
: IRQF_TRIGGER_RISING
;
367 value_sd
= sysfs_get_dirent(dev
->kobj
.sd
, NULL
, "value");
375 if (idr_pre_get(&dirent_idr
, GFP_KERNEL
))
376 ret
= idr_get_new_above(&dirent_idr
, value_sd
,
378 } while (ret
== -EAGAIN
);
383 desc
->flags
&= GPIO_FLAGS_MASK
;
384 desc
->flags
|= (unsigned long)id
<< ID_SHIFT
;
386 if (desc
->flags
>> ID_SHIFT
!= id
) {
392 ret
= request_any_context_irq(irq
, gpio_sysfs_irq
, irq_flags
,
393 "gpiolib", value_sd
);
397 desc
->flags
|= gpio_flags
;
401 idr_remove(&dirent_idr
, id
);
402 desc
->flags
&= GPIO_FLAGS_MASK
;
410 static const struct {
413 } trigger_types
[] = {
415 { "falling", BIT(FLAG_TRIG_FALL
) },
416 { "rising", BIT(FLAG_TRIG_RISE
) },
417 { "both", BIT(FLAG_TRIG_FALL
) | BIT(FLAG_TRIG_RISE
) },
420 static ssize_t
gpio_edge_show(struct device
*dev
,
421 struct device_attribute
*attr
, char *buf
)
423 const struct gpio_desc
*desc
= dev_get_drvdata(dev
);
426 mutex_lock(&sysfs_lock
);
428 if (!test_bit(FLAG_EXPORT
, &desc
->flags
))
434 for (i
= 0; i
< ARRAY_SIZE(trigger_types
); i
++)
435 if ((desc
->flags
& GPIO_TRIGGER_MASK
)
436 == trigger_types
[i
].flags
) {
437 status
= sprintf(buf
, "%s\n",
438 trigger_types
[i
].name
);
443 mutex_unlock(&sysfs_lock
);
447 static ssize_t
gpio_edge_store(struct device
*dev
,
448 struct device_attribute
*attr
, const char *buf
, size_t size
)
450 struct gpio_desc
*desc
= dev_get_drvdata(dev
);
454 for (i
= 0; i
< ARRAY_SIZE(trigger_types
); i
++)
455 if (sysfs_streq(trigger_types
[i
].name
, buf
))
460 mutex_lock(&sysfs_lock
);
462 if (!test_bit(FLAG_EXPORT
, &desc
->flags
))
465 status
= gpio_setup_irq(desc
, dev
, trigger_types
[i
].flags
);
470 mutex_unlock(&sysfs_lock
);
475 static DEVICE_ATTR(edge
, 0644, gpio_edge_show
, gpio_edge_store
);
477 static int sysfs_set_active_low(struct gpio_desc
*desc
, struct device
*dev
,
482 if (!!test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
) == !!value
)
486 set_bit(FLAG_ACTIVE_LOW
, &desc
->flags
);
488 clear_bit(FLAG_ACTIVE_LOW
, &desc
->flags
);
490 /* reconfigure poll(2) support if enabled on one edge only */
491 if (dev
!= NULL
&& (!!test_bit(FLAG_TRIG_RISE
, &desc
->flags
) ^
492 !!test_bit(FLAG_TRIG_FALL
, &desc
->flags
))) {
493 unsigned long trigger_flags
= desc
->flags
& GPIO_TRIGGER_MASK
;
495 gpio_setup_irq(desc
, dev
, 0);
496 status
= gpio_setup_irq(desc
, dev
, trigger_flags
);
502 static ssize_t
gpio_active_low_show(struct device
*dev
,
503 struct device_attribute
*attr
, char *buf
)
505 const struct gpio_desc
*desc
= dev_get_drvdata(dev
);
508 mutex_lock(&sysfs_lock
);
510 if (!test_bit(FLAG_EXPORT
, &desc
->flags
))
513 status
= sprintf(buf
, "%d\n",
514 !!test_bit(FLAG_ACTIVE_LOW
, &desc
->flags
));
516 mutex_unlock(&sysfs_lock
);
521 static ssize_t
gpio_active_low_store(struct device
*dev
,
522 struct device_attribute
*attr
, const char *buf
, size_t size
)
524 struct gpio_desc
*desc
= dev_get_drvdata(dev
);
527 mutex_lock(&sysfs_lock
);
529 if (!test_bit(FLAG_EXPORT
, &desc
->flags
)) {
534 status
= strict_strtol(buf
, 0, &value
);
536 status
= sysfs_set_active_low(desc
, dev
, value
!= 0);
539 mutex_unlock(&sysfs_lock
);
541 return status
? : size
;
544 static const DEVICE_ATTR(active_low
, 0644,
545 gpio_active_low_show
, gpio_active_low_store
);
547 static const struct attribute
*gpio_attrs
[] = {
548 &dev_attr_value
.attr
,
549 &dev_attr_active_low
.attr
,
553 static const struct attribute_group gpio_attr_group
= {
554 .attrs
= (struct attribute
**) gpio_attrs
,
558 * /sys/class/gpio/gpiochipN/
559 * /base ... matching gpio_chip.base (N)
560 * /label ... matching gpio_chip.label
561 * /ngpio ... matching gpio_chip.ngpio
564 static ssize_t
chip_base_show(struct device
*dev
,
565 struct device_attribute
*attr
, char *buf
)
567 const struct gpio_chip
*chip
= dev_get_drvdata(dev
);
569 return sprintf(buf
, "%d\n", chip
->base
);
571 static DEVICE_ATTR(base
, 0444, chip_base_show
, NULL
);
573 static ssize_t
chip_label_show(struct device
*dev
,
574 struct device_attribute
*attr
, char *buf
)
576 const struct gpio_chip
*chip
= dev_get_drvdata(dev
);
578 return sprintf(buf
, "%s\n", chip
->label
? : "");
580 static DEVICE_ATTR(label
, 0444, chip_label_show
, NULL
);
582 static ssize_t
chip_ngpio_show(struct device
*dev
,
583 struct device_attribute
*attr
, char *buf
)
585 const struct gpio_chip
*chip
= dev_get_drvdata(dev
);
587 return sprintf(buf
, "%u\n", chip
->ngpio
);
589 static DEVICE_ATTR(ngpio
, 0444, chip_ngpio_show
, NULL
);
591 static const struct attribute
*gpiochip_attrs
[] = {
593 &dev_attr_label
.attr
,
594 &dev_attr_ngpio
.attr
,
598 static const struct attribute_group gpiochip_attr_group
= {
599 .attrs
= (struct attribute
**) gpiochip_attrs
,
603 * /sys/class/gpio/export ... write-only
604 * integer N ... number of GPIO to export (full access)
605 * /sys/class/gpio/unexport ... write-only
606 * integer N ... number of GPIO to unexport
608 static ssize_t
export_store(struct class *class,
609 struct class_attribute
*attr
,
610 const char *buf
, size_t len
)
615 status
= strict_strtol(buf
, 0, &gpio
);
619 /* No extra locking here; FLAG_SYSFS just signifies that the
620 * request and export were done by on behalf of userspace, so
621 * they may be undone on its behalf too.
624 status
= gpio_request(gpio
, "sysfs");
628 status
= gpio_export(gpio
, true);
632 set_bit(FLAG_SYSFS
, &gpio_desc
[gpio
].flags
);
636 pr_debug("%s: status %d\n", __func__
, status
);
637 return status
? : len
;
640 static ssize_t
unexport_store(struct class *class,
641 struct class_attribute
*attr
,
642 const char *buf
, size_t len
)
647 status
= strict_strtol(buf
, 0, &gpio
);
653 /* reject bogus commands (gpio_unexport ignores them) */
654 if (!gpio_is_valid(gpio
))
657 /* No extra locking here; FLAG_SYSFS just signifies that the
658 * request and export were done by on behalf of userspace, so
659 * they may be undone on its behalf too.
661 if (test_and_clear_bit(FLAG_SYSFS
, &gpio_desc
[gpio
].flags
)) {
667 pr_debug("%s: status %d\n", __func__
, status
);
668 return status
? : len
;
671 static struct class_attribute gpio_class_attrs
[] = {
672 __ATTR(export
, 0200, NULL
, export_store
),
673 __ATTR(unexport
, 0200, NULL
, unexport_store
),
677 static struct class gpio_class
= {
679 .owner
= THIS_MODULE
,
681 .class_attrs
= gpio_class_attrs
,
686 * gpio_export - export a GPIO through sysfs
687 * @gpio: gpio to make available, already requested
688 * @direction_may_change: true if userspace may change gpio direction
689 * Context: arch_initcall or later
691 * When drivers want to make a GPIO accessible to userspace after they
692 * have requested it -- perhaps while debugging, or as part of their
693 * public interface -- they may use this routine. If the GPIO can
694 * change direction (some can't) and the caller allows it, userspace
695 * will see "direction" sysfs attribute which may be used to change
696 * the gpio's direction. A "value" attribute will always be provided.
698 * Returns zero on success, else an error.
700 int gpio_export(unsigned gpio
, bool direction_may_change
)
703 struct gpio_desc
*desc
;
704 int status
= -EINVAL
;
705 const char *ioname
= NULL
;
707 /* can't export until sysfs is available ... */
709 pr_debug("%s: called too early!\n", __func__
);
713 if (!gpio_is_valid(gpio
))
716 mutex_lock(&sysfs_lock
);
718 spin_lock_irqsave(&gpio_lock
, flags
);
719 desc
= &gpio_desc
[gpio
];
720 if (test_bit(FLAG_REQUESTED
, &desc
->flags
)
721 && !test_bit(FLAG_EXPORT
, &desc
->flags
)) {
723 if (!desc
->chip
->direction_input
724 || !desc
->chip
->direction_output
)
725 direction_may_change
= false;
727 spin_unlock_irqrestore(&gpio_lock
, flags
);
729 if (desc
->chip
->names
&& desc
->chip
->names
[gpio
- desc
->chip
->base
])
730 ioname
= desc
->chip
->names
[gpio
- desc
->chip
->base
];
735 dev
= device_create(&gpio_class
, desc
->chip
->dev
, MKDEV(0, 0),
736 desc
, ioname
? ioname
: "gpio%u", gpio
);
738 status
= sysfs_create_group(&dev
->kobj
,
741 if (!status
&& direction_may_change
)
742 status
= device_create_file(dev
,
743 &dev_attr_direction
);
745 if (!status
&& gpio_to_irq(gpio
) >= 0
746 && (direction_may_change
747 || !test_bit(FLAG_IS_OUT
,
749 status
= device_create_file(dev
,
753 device_unregister(dev
);
755 status
= PTR_ERR(dev
);
757 set_bit(FLAG_EXPORT
, &desc
->flags
);
760 mutex_unlock(&sysfs_lock
);
764 pr_debug("%s: gpio%d status %d\n", __func__
, gpio
, status
);
768 EXPORT_SYMBOL_GPL(gpio_export
);
770 static int match_export(struct device
*dev
, void *data
)
772 return dev_get_drvdata(dev
) == data
;
776 * gpio_export_link - create a sysfs link to an exported GPIO node
777 * @dev: device under which to create symlink
778 * @name: name of the symlink
779 * @gpio: gpio to create symlink to, already exported
781 * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
782 * node. Caller is responsible for unlinking.
784 * Returns zero on success, else an error.
786 int gpio_export_link(struct device
*dev
, const char *name
, unsigned gpio
)
788 struct gpio_desc
*desc
;
789 int status
= -EINVAL
;
791 if (!gpio_is_valid(gpio
))
794 mutex_lock(&sysfs_lock
);
796 desc
= &gpio_desc
[gpio
];
798 if (test_bit(FLAG_EXPORT
, &desc
->flags
)) {
801 tdev
= class_find_device(&gpio_class
, NULL
, desc
, match_export
);
803 status
= sysfs_create_link(&dev
->kobj
, &tdev
->kobj
,
810 mutex_unlock(&sysfs_lock
);
814 pr_debug("%s: gpio%d status %d\n", __func__
, gpio
, status
);
818 EXPORT_SYMBOL_GPL(gpio_export_link
);
822 * gpio_sysfs_set_active_low - set the polarity of gpio sysfs value
823 * @gpio: gpio to change
824 * @value: non-zero to use active low, i.e. inverted values
826 * Set the polarity of /sys/class/gpio/gpioN/value sysfs attribute.
827 * The GPIO does not have to be exported yet. If poll(2) support has
828 * been enabled for either rising or falling edge, it will be
829 * reconfigured to follow the new polarity.
831 * Returns zero on success, else an error.
833 int gpio_sysfs_set_active_low(unsigned gpio
, int value
)
835 struct gpio_desc
*desc
;
836 struct device
*dev
= NULL
;
837 int status
= -EINVAL
;
839 if (!gpio_is_valid(gpio
))
842 mutex_lock(&sysfs_lock
);
844 desc
= &gpio_desc
[gpio
];
846 if (test_bit(FLAG_EXPORT
, &desc
->flags
)) {
847 dev
= class_find_device(&gpio_class
, NULL
, desc
, match_export
);
854 status
= sysfs_set_active_low(desc
, dev
, value
);
857 mutex_unlock(&sysfs_lock
);
861 pr_debug("%s: gpio%d status %d\n", __func__
, gpio
, status
);
865 EXPORT_SYMBOL_GPL(gpio_sysfs_set_active_low
);
868 * gpio_unexport - reverse effect of gpio_export()
869 * @gpio: gpio to make unavailable
871 * This is implicit on gpio_free().
873 void gpio_unexport(unsigned gpio
)
875 struct gpio_desc
*desc
;
877 struct device
*dev
= NULL
;
879 if (!gpio_is_valid(gpio
)) {
884 mutex_lock(&sysfs_lock
);
886 desc
= &gpio_desc
[gpio
];
888 if (test_bit(FLAG_EXPORT
, &desc
->flags
)) {
890 dev
= class_find_device(&gpio_class
, NULL
, desc
, match_export
);
892 gpio_setup_irq(desc
, dev
, 0);
893 clear_bit(FLAG_EXPORT
, &desc
->flags
);
898 mutex_unlock(&sysfs_lock
);
900 device_unregister(dev
);
905 pr_debug("%s: gpio%d status %d\n", __func__
, gpio
, status
);
907 EXPORT_SYMBOL_GPL(gpio_unexport
);
909 static int gpiochip_export(struct gpio_chip
*chip
)
914 /* Many systems register gpio chips for SOC support very early,
915 * before driver model support is available. In those cases we
916 * export this later, in gpiolib_sysfs_init() ... here we just
917 * verify that _some_ field of gpio_class got initialized.
922 /* use chip->base for the ID; it's already known to be unique */
923 mutex_lock(&sysfs_lock
);
924 dev
= device_create(&gpio_class
, chip
->dev
, MKDEV(0, 0), chip
,
925 "gpiochip%d", chip
->base
);
927 status
= sysfs_create_group(&dev
->kobj
,
928 &gpiochip_attr_group
);
930 status
= PTR_ERR(dev
);
931 chip
->exported
= (status
== 0);
932 mutex_unlock(&sysfs_lock
);
938 spin_lock_irqsave(&gpio_lock
, flags
);
940 while (gpio_desc
[gpio
].chip
== chip
)
941 gpio_desc
[gpio
++].chip
= NULL
;
942 spin_unlock_irqrestore(&gpio_lock
, flags
);
944 pr_debug("%s: chip %s status %d\n", __func__
,
945 chip
->label
, status
);
951 static void gpiochip_unexport(struct gpio_chip
*chip
)
956 mutex_lock(&sysfs_lock
);
957 dev
= class_find_device(&gpio_class
, NULL
, chip
, match_export
);
960 device_unregister(dev
);
965 mutex_unlock(&sysfs_lock
);
968 pr_debug("%s: chip %s status %d\n", __func__
,
969 chip
->label
, status
);
972 static int __init
gpiolib_sysfs_init(void)
978 status
= class_register(&gpio_class
);
982 /* Scan and register the gpio_chips which registered very
983 * early (e.g. before the class_register above was called).
985 * We run before arch_initcall() so chip->dev nodes can have
986 * registered, and so arch_initcall() can always gpio_export().
988 spin_lock_irqsave(&gpio_lock
, flags
);
989 for (gpio
= 0; gpio
< ARCH_NR_GPIOS
; gpio
++) {
990 struct gpio_chip
*chip
;
992 chip
= gpio_desc
[gpio
].chip
;
993 if (!chip
|| chip
->exported
)
996 spin_unlock_irqrestore(&gpio_lock
, flags
);
997 status
= gpiochip_export(chip
);
998 spin_lock_irqsave(&gpio_lock
, flags
);
1000 spin_unlock_irqrestore(&gpio_lock
, flags
);
1005 postcore_initcall(gpiolib_sysfs_init
);
1008 static inline int gpiochip_export(struct gpio_chip
*chip
)
1013 static inline void gpiochip_unexport(struct gpio_chip
*chip
)
1017 #endif /* CONFIG_GPIO_SYSFS */
1020 * gpiochip_add() - register a gpio_chip
1021 * @chip: the chip to register, with chip->base initialized
1022 * Context: potentially before irqs or kmalloc will work
1024 * Returns a negative errno if the chip can't be registered, such as
1025 * because the chip->base is invalid or already associated with a
1026 * different chip. Otherwise it returns zero as a success code.
1028 * When gpiochip_add() is called very early during boot, so that GPIOs
1029 * can be freely used, the chip->dev device must be registered before
1030 * the gpio framework's arch_initcall(). Otherwise sysfs initialization
1031 * for GPIOs will fail rudely.
1033 * If chip->base is negative, this requests dynamic assignment of
1034 * a range of valid GPIOs.
1036 int gpiochip_add(struct gpio_chip
*chip
)
1038 unsigned long flags
;
1041 int base
= chip
->base
;
1043 if ((!gpio_is_valid(base
) || !gpio_is_valid(base
+ chip
->ngpio
- 1))
1049 spin_lock_irqsave(&gpio_lock
, flags
);
1052 base
= gpiochip_find_base(chip
->ngpio
);
1060 /* these GPIO numbers must not be managed by another gpio_chip */
1061 for (id
= base
; id
< base
+ chip
->ngpio
; id
++) {
1062 if (gpio_desc
[id
].chip
!= NULL
) {
1068 for (id
= base
; id
< base
+ chip
->ngpio
; id
++) {
1069 gpio_desc
[id
].chip
= chip
;
1071 /* REVISIT: most hardware initializes GPIOs as
1072 * inputs (often with pullups enabled) so power
1073 * usage is minimized. Linux code should set the
1074 * gpio direction first thing; but until it does,
1075 * we may expose the wrong direction in sysfs.
1077 gpio_desc
[id
].flags
= !chip
->direction_input
1078 ? (1 << FLAG_IS_OUT
)
1083 of_gpiochip_add(chip
);
1086 spin_unlock_irqrestore(&gpio_lock
, flags
);
1091 status
= gpiochip_export(chip
);
1095 pr_info("gpiochip_add: registered GPIOs %d to %d on device: %s\n",
1096 chip
->base
, chip
->base
+ chip
->ngpio
- 1,
1097 chip
->label
? : "generic");
1101 /* failures here can mean systems won't boot... */
1102 pr_err("gpiochip_add: gpios %d..%d (%s) failed to register\n",
1103 chip
->base
, chip
->base
+ chip
->ngpio
- 1,
1104 chip
->label
? : "generic");
1107 EXPORT_SYMBOL_GPL(gpiochip_add
);
1110 * gpiochip_remove() - unregister a gpio_chip
1111 * @chip: the chip to unregister
1113 * A gpio_chip with any GPIOs still requested may not be removed.
1115 int gpiochip_remove(struct gpio_chip
*chip
)
1117 unsigned long flags
;
1121 spin_lock_irqsave(&gpio_lock
, flags
);
1123 of_gpiochip_remove(chip
);
1125 for (id
= chip
->base
; id
< chip
->base
+ chip
->ngpio
; id
++) {
1126 if (test_bit(FLAG_REQUESTED
, &gpio_desc
[id
].flags
)) {
1132 for (id
= chip
->base
; id
< chip
->base
+ chip
->ngpio
; id
++)
1133 gpio_desc
[id
].chip
= NULL
;
1136 spin_unlock_irqrestore(&gpio_lock
, flags
);
1139 gpiochip_unexport(chip
);
1143 EXPORT_SYMBOL_GPL(gpiochip_remove
);
1146 * gpiochip_find() - iterator for locating a specific gpio_chip
1147 * @data: data to pass to match function
1148 * @callback: Callback function to check gpio_chip
1150 * Similar to bus_find_device. It returns a reference to a gpio_chip as
1151 * determined by a user supplied @match callback. The callback should return
1152 * 0 if the device doesn't match and non-zero if it does. If the callback is
1153 * non-zero, this function will return to the caller and not iterate over any
1156 struct gpio_chip
*gpiochip_find(const void *data
,
1157 int (*match
)(struct gpio_chip
*chip
,
1160 struct gpio_chip
*chip
= NULL
;
1161 unsigned long flags
;
1164 spin_lock_irqsave(&gpio_lock
, flags
);
1165 for (i
= 0; i
< ARCH_NR_GPIOS
; i
++) {
1166 if (!gpio_desc
[i
].chip
)
1169 if (match(gpio_desc
[i
].chip
, data
)) {
1170 chip
= gpio_desc
[i
].chip
;
1174 spin_unlock_irqrestore(&gpio_lock
, flags
);
1178 EXPORT_SYMBOL_GPL(gpiochip_find
);
1180 /* These "optional" allocation calls help prevent drivers from stomping
1181 * on each other, and help provide better diagnostics in debugfs.
1182 * They're called even less than the "set direction" calls.
1184 int gpio_request(unsigned gpio
, const char *label
)
1186 struct gpio_desc
*desc
;
1187 struct gpio_chip
*chip
;
1188 int status
= -EINVAL
;
1189 unsigned long flags
;
1191 spin_lock_irqsave(&gpio_lock
, flags
);
1193 if (!gpio_is_valid(gpio
))
1195 desc
= &gpio_desc
[gpio
];
1200 if (!try_module_get(chip
->owner
))
1203 /* NOTE: gpio_request() can be called in early boot,
1204 * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
1207 if (test_and_set_bit(FLAG_REQUESTED
, &desc
->flags
) == 0) {
1208 desc_set_label(desc
, label
? : "?");
1212 module_put(chip
->owner
);
1216 if (chip
->request
) {
1217 /* chip->request may sleep */
1218 spin_unlock_irqrestore(&gpio_lock
, flags
);
1219 status
= chip
->request(chip
, gpio
- chip
->base
);
1220 spin_lock_irqsave(&gpio_lock
, flags
);
1223 desc_set_label(desc
, NULL
);
1224 module_put(chip
->owner
);
1225 clear_bit(FLAG_REQUESTED
, &desc
->flags
);
1231 pr_debug("gpio_request: gpio-%d (%s) status %d\n",
1232 gpio
, label
? : "?", status
);
1233 spin_unlock_irqrestore(&gpio_lock
, flags
);
1236 EXPORT_SYMBOL_GPL(gpio_request
);
1238 void gpio_free(unsigned gpio
)
1240 unsigned long flags
;
1241 struct gpio_desc
*desc
;
1242 struct gpio_chip
*chip
;
1246 if (!gpio_is_valid(gpio
)) {
1247 WARN_ON(extra_checks
);
1251 gpio_unexport(gpio
);
1253 spin_lock_irqsave(&gpio_lock
, flags
);
1255 desc
= &gpio_desc
[gpio
];
1257 if (chip
&& test_bit(FLAG_REQUESTED
, &desc
->flags
)) {
1259 spin_unlock_irqrestore(&gpio_lock
, flags
);
1260 might_sleep_if(chip
->can_sleep
);
1261 chip
->free(chip
, gpio
- chip
->base
);
1262 spin_lock_irqsave(&gpio_lock
, flags
);
1264 desc_set_label(desc
, NULL
);
1265 module_put(desc
->chip
->owner
);
1266 clear_bit(FLAG_ACTIVE_LOW
, &desc
->flags
);
1267 clear_bit(FLAG_REQUESTED
, &desc
->flags
);
1268 clear_bit(FLAG_OPEN_DRAIN
, &desc
->flags
);
1270 WARN_ON(extra_checks
);
1272 spin_unlock_irqrestore(&gpio_lock
, flags
);
1274 EXPORT_SYMBOL_GPL(gpio_free
);
1277 * gpio_request_one - request a single GPIO with initial configuration
1278 * @gpio: the GPIO number
1279 * @flags: GPIO configuration as specified by GPIOF_*
1280 * @label: a literal description string of this GPIO
1282 int gpio_request_one(unsigned gpio
, unsigned long flags
, const char *label
)
1286 err
= gpio_request(gpio
, label
);
1290 if (flags
& GPIOF_OPEN_DRAIN
)
1291 set_bit(FLAG_OPEN_DRAIN
, &gpio_desc
[gpio
].flags
);
1293 if (flags
& GPIOF_DIR_IN
)
1294 err
= gpio_direction_input(gpio
);
1296 err
= gpio_direction_output(gpio
,
1297 (flags
& GPIOF_INIT_HIGH
) ? 1 : 0);
1304 EXPORT_SYMBOL_GPL(gpio_request_one
);
1307 * gpio_request_array - request multiple GPIOs in a single call
1308 * @array: array of the 'struct gpio'
1309 * @num: how many GPIOs in the array
1311 int gpio_request_array(const struct gpio
*array
, size_t num
)
1315 for (i
= 0; i
< num
; i
++, array
++) {
1316 err
= gpio_request_one(array
->gpio
, array
->flags
, array
->label
);
1324 gpio_free((--array
)->gpio
);
1327 EXPORT_SYMBOL_GPL(gpio_request_array
);
1330 * gpio_free_array - release multiple GPIOs in a single call
1331 * @array: array of the 'struct gpio'
1332 * @num: how many GPIOs in the array
1334 void gpio_free_array(const struct gpio
*array
, size_t num
)
1337 gpio_free((array
++)->gpio
);
1339 EXPORT_SYMBOL_GPL(gpio_free_array
);
1342 * gpiochip_is_requested - return string iff signal was requested
1343 * @chip: controller managing the signal
1344 * @offset: of signal within controller's 0..(ngpio - 1) range
1346 * Returns NULL if the GPIO is not currently requested, else a string.
1347 * If debugfs support is enabled, the string returned is the label passed
1348 * to gpio_request(); otherwise it is a meaningless constant.
1350 * This function is for use by GPIO controller drivers. The label can
1351 * help with diagnostics, and knowing that the signal is used as a GPIO
1352 * can help avoid accidentally multiplexing it to another controller.
1354 const char *gpiochip_is_requested(struct gpio_chip
*chip
, unsigned offset
)
1356 unsigned gpio
= chip
->base
+ offset
;
1358 if (!gpio_is_valid(gpio
) || gpio_desc
[gpio
].chip
!= chip
)
1360 if (test_bit(FLAG_REQUESTED
, &gpio_desc
[gpio
].flags
) == 0)
1362 #ifdef CONFIG_DEBUG_FS
1363 return gpio_desc
[gpio
].label
;
1368 EXPORT_SYMBOL_GPL(gpiochip_is_requested
);
1371 /* Drivers MUST set GPIO direction before making get/set calls. In
1372 * some cases this is done in early boot, before IRQs are enabled.
1374 * As a rule these aren't called more than once (except for drivers
1375 * using the open-drain emulation idiom) so these are natural places
1376 * to accumulate extra debugging checks. Note that we can't (yet)
1377 * rely on gpio_request() having been called beforehand.
1380 int gpio_direction_input(unsigned gpio
)
1382 unsigned long flags
;
1383 struct gpio_chip
*chip
;
1384 struct gpio_desc
*desc
= &gpio_desc
[gpio
];
1385 int status
= -EINVAL
;
1387 spin_lock_irqsave(&gpio_lock
, flags
);
1389 if (!gpio_is_valid(gpio
))
1392 if (!chip
|| !chip
->get
|| !chip
->direction_input
)
1395 if (gpio
>= chip
->ngpio
)
1397 status
= gpio_ensure_requested(desc
, gpio
);
1401 /* now we know the gpio is valid and chip won't vanish */
1403 spin_unlock_irqrestore(&gpio_lock
, flags
);
1405 might_sleep_if(chip
->can_sleep
);
1408 status
= chip
->request(chip
, gpio
);
1410 pr_debug("GPIO-%d: chip request fail, %d\n",
1411 chip
->base
+ gpio
, status
);
1412 /* and it's not available to anyone else ...
1413 * gpio_request() is the fully clean solution.
1419 status
= chip
->direction_input(chip
, gpio
);
1421 clear_bit(FLAG_IS_OUT
, &desc
->flags
);
1423 trace_gpio_direction(chip
->base
+ gpio
, 1, status
);
1427 spin_unlock_irqrestore(&gpio_lock
, flags
);
1429 pr_debug("%s: gpio-%d status %d\n",
1430 __func__
, gpio
, status
);
1433 EXPORT_SYMBOL_GPL(gpio_direction_input
);
1435 int gpio_direction_output(unsigned gpio
, int value
)
1437 unsigned long flags
;
1438 struct gpio_chip
*chip
;
1439 struct gpio_desc
*desc
= &gpio_desc
[gpio
];
1440 int status
= -EINVAL
;
1442 /* Open drain pin should not be driven to 1 */
1443 if (value
&& test_bit(FLAG_OPEN_DRAIN
, &desc
->flags
))
1444 return gpio_direction_input(gpio
);
1446 spin_lock_irqsave(&gpio_lock
, flags
);
1448 if (!gpio_is_valid(gpio
))
1451 if (!chip
|| !chip
->set
|| !chip
->direction_output
)
1454 if (gpio
>= chip
->ngpio
)
1456 status
= gpio_ensure_requested(desc
, gpio
);
1460 /* now we know the gpio is valid and chip won't vanish */
1462 spin_unlock_irqrestore(&gpio_lock
, flags
);
1464 might_sleep_if(chip
->can_sleep
);
1467 status
= chip
->request(chip
, gpio
);
1469 pr_debug("GPIO-%d: chip request fail, %d\n",
1470 chip
->base
+ gpio
, status
);
1471 /* and it's not available to anyone else ...
1472 * gpio_request() is the fully clean solution.
1478 status
= chip
->direction_output(chip
, gpio
, value
);
1480 set_bit(FLAG_IS_OUT
, &desc
->flags
);
1481 trace_gpio_value(chip
->base
+ gpio
, 0, value
);
1482 trace_gpio_direction(chip
->base
+ gpio
, 0, status
);
1486 spin_unlock_irqrestore(&gpio_lock
, flags
);
1488 pr_debug("%s: gpio-%d status %d\n",
1489 __func__
, gpio
, status
);
1492 EXPORT_SYMBOL_GPL(gpio_direction_output
);
1495 * gpio_set_debounce - sets @debounce time for a @gpio
1496 * @gpio: the gpio to set debounce time
1497 * @debounce: debounce time is microseconds
1499 int gpio_set_debounce(unsigned gpio
, unsigned debounce
)
1501 unsigned long flags
;
1502 struct gpio_chip
*chip
;
1503 struct gpio_desc
*desc
= &gpio_desc
[gpio
];
1504 int status
= -EINVAL
;
1506 spin_lock_irqsave(&gpio_lock
, flags
);
1508 if (!gpio_is_valid(gpio
))
1511 if (!chip
|| !chip
->set
|| !chip
->set_debounce
)
1514 if (gpio
>= chip
->ngpio
)
1516 status
= gpio_ensure_requested(desc
, gpio
);
1520 /* now we know the gpio is valid and chip won't vanish */
1522 spin_unlock_irqrestore(&gpio_lock
, flags
);
1524 might_sleep_if(chip
->can_sleep
);
1526 return chip
->set_debounce(chip
, gpio
, debounce
);
1529 spin_unlock_irqrestore(&gpio_lock
, flags
);
1531 pr_debug("%s: gpio-%d status %d\n",
1532 __func__
, gpio
, status
);
1536 EXPORT_SYMBOL_GPL(gpio_set_debounce
);
1538 /* I/O calls are only valid after configuration completed; the relevant
1539 * "is this a valid GPIO" error checks should already have been done.
1541 * "Get" operations are often inlinable as reading a pin value register,
1542 * and masking the relevant bit in that register.
1544 * When "set" operations are inlinable, they involve writing that mask to
1545 * one register to set a low value, or a different register to set it high.
1546 * Otherwise locking is needed, so there may be little value to inlining.
1548 *------------------------------------------------------------------------
1550 * IMPORTANT!!! The hot paths -- get/set value -- assume that callers
1551 * have requested the GPIO. That can include implicit requesting by
1552 * a direction setting call. Marking a gpio as requested locks its chip
1553 * in memory, guaranteeing that these table lookups need no more locking
1554 * and that gpiochip_remove() will fail.
1556 * REVISIT when debugging, consider adding some instrumentation to ensure
1557 * that the GPIO was actually requested.
1561 * __gpio_get_value() - return a gpio's value
1562 * @gpio: gpio whose value will be returned
1565 * This is used directly or indirectly to implement gpio_get_value().
1566 * It returns the zero or nonzero value provided by the associated
1567 * gpio_chip.get() method; or zero if no such method is provided.
1569 int __gpio_get_value(unsigned gpio
)
1571 struct gpio_chip
*chip
;
1574 chip
= gpio_to_chip(gpio
);
1575 WARN_ON(chip
->can_sleep
);
1576 value
= chip
->get
? chip
->get(chip
, gpio
- chip
->base
) : 0;
1577 trace_gpio_value(gpio
, 1, value
);
1580 EXPORT_SYMBOL_GPL(__gpio_get_value
);
1583 * _gpio_set_open_drain_value() - Set the open drain gpio's value.
1584 * @gpio: Gpio whose state need to be set.
1586 * @value: Non-zero for setting it HIGH otherise it will set to LOW.
1588 static void _gpio_set_open_drain_value(unsigned gpio
,
1589 struct gpio_chip
*chip
, int value
)
1593 err
= chip
->direction_input(chip
, gpio
- chip
->base
);
1595 clear_bit(FLAG_IS_OUT
, &gpio_desc
[gpio
].flags
);
1597 err
= chip
->direction_output(chip
, gpio
- chip
->base
, 0);
1599 set_bit(FLAG_IS_OUT
, &gpio_desc
[gpio
].flags
);
1601 trace_gpio_direction(gpio
, value
, err
);
1603 pr_err("%s: Error in set_value for open drain gpio%d err %d\n",
1604 __func__
, gpio
, err
);
1608 * __gpio_set_value() - assign a gpio's value
1609 * @gpio: gpio whose value will be assigned
1610 * @value: value to assign
1613 * This is used directly or indirectly to implement gpio_set_value().
1614 * It invokes the associated gpio_chip.set() method.
1616 void __gpio_set_value(unsigned gpio
, int value
)
1618 struct gpio_chip
*chip
;
1620 chip
= gpio_to_chip(gpio
);
1621 WARN_ON(chip
->can_sleep
);
1622 trace_gpio_value(gpio
, 0, value
);
1623 if (test_bit(FLAG_OPEN_DRAIN
, &gpio_desc
[gpio
].flags
))
1624 _gpio_set_open_drain_value(gpio
, chip
, value
);
1626 chip
->set(chip
, gpio
- chip
->base
, value
);
1628 EXPORT_SYMBOL_GPL(__gpio_set_value
);
1631 * __gpio_cansleep() - report whether gpio value access will sleep
1632 * @gpio: gpio in question
1635 * This is used directly or indirectly to implement gpio_cansleep(). It
1636 * returns nonzero if access reading or writing the GPIO value can sleep.
1638 int __gpio_cansleep(unsigned gpio
)
1640 struct gpio_chip
*chip
;
1642 /* only call this on GPIOs that are valid! */
1643 chip
= gpio_to_chip(gpio
);
1645 return chip
->can_sleep
;
1647 EXPORT_SYMBOL_GPL(__gpio_cansleep
);
1650 * __gpio_to_irq() - return the IRQ corresponding to a GPIO
1651 * @gpio: gpio whose IRQ will be returned (already requested)
1654 * This is used directly or indirectly to implement gpio_to_irq().
1655 * It returns the number of the IRQ signaled by this (input) GPIO,
1656 * or a negative errno.
1658 int __gpio_to_irq(unsigned gpio
)
1660 struct gpio_chip
*chip
;
1662 chip
= gpio_to_chip(gpio
);
1663 return chip
->to_irq
? chip
->to_irq(chip
, gpio
- chip
->base
) : -ENXIO
;
1665 EXPORT_SYMBOL_GPL(__gpio_to_irq
);
1669 /* There's no value in making it easy to inline GPIO calls that may sleep.
1670 * Common examples include ones connected to I2C or SPI chips.
1673 int gpio_get_value_cansleep(unsigned gpio
)
1675 struct gpio_chip
*chip
;
1678 might_sleep_if(extra_checks
);
1679 chip
= gpio_to_chip(gpio
);
1680 value
= chip
->get
? chip
->get(chip
, gpio
- chip
->base
) : 0;
1681 trace_gpio_value(gpio
, 1, value
);
1684 EXPORT_SYMBOL_GPL(gpio_get_value_cansleep
);
1686 void gpio_set_value_cansleep(unsigned gpio
, int value
)
1688 struct gpio_chip
*chip
;
1690 might_sleep_if(extra_checks
);
1691 chip
= gpio_to_chip(gpio
);
1692 trace_gpio_value(gpio
, 0, value
);
1693 if (test_bit(FLAG_OPEN_DRAIN
, &gpio_desc
[gpio
].flags
))
1694 _gpio_set_open_drain_value(gpio
, chip
, value
);
1696 chip
->set(chip
, gpio
- chip
->base
, value
);
1698 EXPORT_SYMBOL_GPL(gpio_set_value_cansleep
);
1701 #ifdef CONFIG_DEBUG_FS
1703 static void gpiolib_dbg_show(struct seq_file
*s
, struct gpio_chip
*chip
)
1706 unsigned gpio
= chip
->base
;
1707 struct gpio_desc
*gdesc
= &gpio_desc
[gpio
];
1710 for (i
= 0; i
< chip
->ngpio
; i
++, gpio
++, gdesc
++) {
1711 if (!test_bit(FLAG_REQUESTED
, &gdesc
->flags
))
1714 is_out
= test_bit(FLAG_IS_OUT
, &gdesc
->flags
);
1715 seq_printf(s
, " gpio-%-3d (%-20.20s) %s %s",
1717 is_out
? "out" : "in ",
1719 ? (chip
->get(chip
, i
) ? "hi" : "lo")
1721 seq_printf(s
, "\n");
1725 static int gpiolib_show(struct seq_file
*s
, void *unused
)
1727 struct gpio_chip
*chip
= NULL
;
1731 /* REVISIT this isn't locked against gpio_chip removal ... */
1733 for (gpio
= 0; gpio_is_valid(gpio
); gpio
++) {
1736 if (chip
== gpio_desc
[gpio
].chip
)
1738 chip
= gpio_desc
[gpio
].chip
;
1742 seq_printf(s
, "%sGPIOs %d-%d",
1743 started
? "\n" : "",
1744 chip
->base
, chip
->base
+ chip
->ngpio
- 1);
1747 seq_printf(s
, ", %s/%s",
1748 dev
->bus
? dev
->bus
->name
: "no-bus",
1751 seq_printf(s
, ", %s", chip
->label
);
1752 if (chip
->can_sleep
)
1753 seq_printf(s
, ", can sleep");
1754 seq_printf(s
, ":\n");
1758 chip
->dbg_show(s
, chip
);
1760 gpiolib_dbg_show(s
, chip
);
1765 static int gpiolib_open(struct inode
*inode
, struct file
*file
)
1767 return single_open(file
, gpiolib_show
, NULL
);
1770 static const struct file_operations gpiolib_operations
= {
1771 .open
= gpiolib_open
,
1773 .llseek
= seq_lseek
,
1774 .release
= single_release
,
1777 static int __init
gpiolib_debugfs_init(void)
1779 /* /sys/kernel/debug/gpio */
1780 (void) debugfs_create_file("gpio", S_IFREG
| S_IRUGO
,
1781 NULL
, NULL
, &gpiolib_operations
);
1784 subsys_initcall(gpiolib_debugfs_init
);
1786 #endif /* DEBUG_FS */