aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
Diffstat (limited to 'drivers')
-rw-r--r--drivers/gpio/Makefile1
-rw-r--r--drivers/gpio/gpiolib-sysfs.c829
-rw-r--r--drivers/gpio/gpiolib.c911
-rw-r--r--drivers/gpio/gpiolib.h91
4 files changed, 925 insertions, 907 deletions
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index d10f6a9d875a..9d3df07290f3 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -5,6 +5,7 @@ ccflags-$(CONFIG_DEBUG_GPIO) += -DDEBUG
5obj-$(CONFIG_GPIO_DEVRES) += devres.o 5obj-$(CONFIG_GPIO_DEVRES) += devres.o
6obj-$(CONFIG_GPIOLIB) += gpiolib.o 6obj-$(CONFIG_GPIOLIB) += gpiolib.o
7obj-$(CONFIG_OF_GPIO) += gpiolib-of.o 7obj-$(CONFIG_OF_GPIO) += gpiolib-of.o
8obj-$(CONFIG_GPIO_SYSFS) += gpiolib-sysfs.o
8obj-$(CONFIG_GPIO_ACPI) += gpiolib-acpi.o 9obj-$(CONFIG_GPIO_ACPI) += gpiolib-acpi.o
9 10
10# Device drivers. Generally keep list sorted alphabetically 11# Device drivers. Generally keep list sorted alphabetically
diff --git a/drivers/gpio/gpiolib-sysfs.c b/drivers/gpio/gpiolib-sysfs.c
new file mode 100644
index 000000000000..3516502059f2
--- /dev/null
+++ b/drivers/gpio/gpiolib-sysfs.c
@@ -0,0 +1,829 @@
1#include <linux/idr.h>
2#include <linux/mutex.h>
3#include <linux/device.h>
4#include <linux/sysfs.h>
5#include <linux/gpio/consumer.h>
6#include <linux/gpio/driver.h>
7#include <linux/interrupt.h>
8#include <linux/kdev_t.h>
9
10#include "gpiolib.h"
11
12static DEFINE_IDR(dirent_idr);
13
14
15/* lock protects against unexport_gpio() being called while
16 * sysfs files are active.
17 */
18static DEFINE_MUTEX(sysfs_lock);
19
20/*
21 * /sys/class/gpio/gpioN... only for GPIOs that are exported
22 * /direction
23 * * MAY BE OMITTED if kernel won't allow direction changes
24 * * is read/write as "in" or "out"
25 * * may also be written as "high" or "low", initializing
26 * output value as specified ("out" implies "low")
27 * /value
28 * * always readable, subject to hardware behavior
29 * * may be writable, as zero/nonzero
30 * /edge
31 * * configures behavior of poll(2) on /value
32 * * available only if pin can generate IRQs on input
33 * * is read/write as "none", "falling", "rising", or "both"
34 * /active_low
35 * * configures polarity of /value
36 * * is read/write as zero/nonzero
37 * * also affects existing and subsequent "falling" and "rising"
38 * /edge configuration
39 */
40
41static ssize_t gpio_direction_show(struct device *dev,
42 struct device_attribute *attr, char *buf)
43{
44 const struct gpio_desc *desc = dev_get_drvdata(dev);
45 ssize_t status;
46
47 mutex_lock(&sysfs_lock);
48
49 if (!test_bit(FLAG_EXPORT, &desc->flags)) {
50 status = -EIO;
51 } else {
52 gpiod_get_direction(desc);
53 status = sprintf(buf, "%s\n",
54 test_bit(FLAG_IS_OUT, &desc->flags)
55 ? "out" : "in");
56 }
57
58 mutex_unlock(&sysfs_lock);
59 return status;
60}
61
62static ssize_t gpio_direction_store(struct device *dev,
63 struct device_attribute *attr, const char *buf, size_t size)
64{
65 struct gpio_desc *desc = dev_get_drvdata(dev);
66 ssize_t status;
67
68 mutex_lock(&sysfs_lock);
69
70 if (!test_bit(FLAG_EXPORT, &desc->flags))
71 status = -EIO;
72 else if (sysfs_streq(buf, "high"))
73 status = gpiod_direction_output_raw(desc, 1);
74 else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
75 status = gpiod_direction_output_raw(desc, 0);
76 else if (sysfs_streq(buf, "in"))
77 status = gpiod_direction_input(desc);
78 else
79 status = -EINVAL;
80
81 mutex_unlock(&sysfs_lock);
82 return status ? : size;
83}
84
85static /* const */ DEVICE_ATTR(direction, 0644,
86 gpio_direction_show, gpio_direction_store);
87
88static ssize_t gpio_value_show(struct device *dev,
89 struct device_attribute *attr, char *buf)
90{
91 struct gpio_desc *desc = dev_get_drvdata(dev);
92 ssize_t status;
93
94 mutex_lock(&sysfs_lock);
95
96 if (!test_bit(FLAG_EXPORT, &desc->flags))
97 status = -EIO;
98 else
99 status = sprintf(buf, "%d\n", gpiod_get_value_cansleep(desc));
100
101 mutex_unlock(&sysfs_lock);
102 return status;
103}
104
105static ssize_t gpio_value_store(struct device *dev,
106 struct device_attribute *attr, const char *buf, size_t size)
107{
108 struct gpio_desc *desc = dev_get_drvdata(dev);
109 ssize_t status;
110
111 mutex_lock(&sysfs_lock);
112
113 if (!test_bit(FLAG_EXPORT, &desc->flags))
114 status = -EIO;
115 else if (!test_bit(FLAG_IS_OUT, &desc->flags))
116 status = -EPERM;
117 else {
118 long value;
119
120 status = kstrtol(buf, 0, &value);
121 if (status == 0) {
122 gpiod_set_value_cansleep(desc, value);
123 status = size;
124 }
125 }
126
127 mutex_unlock(&sysfs_lock);
128 return status;
129}
130
131static const DEVICE_ATTR(value, 0644,
132 gpio_value_show, gpio_value_store);
133
134static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
135{
136 struct kernfs_node *value_sd = priv;
137
138 sysfs_notify_dirent(value_sd);
139 return IRQ_HANDLED;
140}
141
142static int gpio_setup_irq(struct gpio_desc *desc, struct device *dev,
143 unsigned long gpio_flags)
144{
145 struct kernfs_node *value_sd;
146 unsigned long irq_flags;
147 int ret, irq, id;
148
149 if ((desc->flags & GPIO_TRIGGER_MASK) == gpio_flags)
150 return 0;
151
152 irq = gpiod_to_irq(desc);
153 if (irq < 0)
154 return -EIO;
155
156 id = desc->flags >> ID_SHIFT;
157 value_sd = idr_find(&dirent_idr, id);
158 if (value_sd)
159 free_irq(irq, value_sd);
160
161 desc->flags &= ~GPIO_TRIGGER_MASK;
162
163 if (!gpio_flags) {
164 gpiod_unlock_as_irq(desc);
165 ret = 0;
166 goto free_id;
167 }
168
169 irq_flags = IRQF_SHARED;
170 if (test_bit(FLAG_TRIG_FALL, &gpio_flags))
171 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
172 IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
173 if (test_bit(FLAG_TRIG_RISE, &gpio_flags))
174 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
175 IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
176
177 if (!value_sd) {
178 value_sd = sysfs_get_dirent(dev->kobj.sd, "value");
179 if (!value_sd) {
180 ret = -ENODEV;
181 goto err_out;
182 }
183
184 ret = idr_alloc(&dirent_idr, value_sd, 1, 0, GFP_KERNEL);
185 if (ret < 0)
186 goto free_sd;
187 id = ret;
188
189 desc->flags &= GPIO_FLAGS_MASK;
190 desc->flags |= (unsigned long)id << ID_SHIFT;
191
192 if (desc->flags >> ID_SHIFT != id) {
193 ret = -ERANGE;
194 goto free_id;
195 }
196 }
197
198 ret = request_any_context_irq(irq, gpio_sysfs_irq, irq_flags,
199 "gpiolib", value_sd);
200 if (ret < 0)
201 goto free_id;
202
203 ret = gpiod_lock_as_irq(desc);
204 if (ret < 0) {
205 gpiod_warn(desc, "failed to flag the GPIO for IRQ\n");
206 goto free_id;
207 }
208
209 desc->flags |= gpio_flags;
210 return 0;
211
212free_id:
213 idr_remove(&dirent_idr, id);
214 desc->flags &= GPIO_FLAGS_MASK;
215free_sd:
216 if (value_sd)
217 sysfs_put(value_sd);
218err_out:
219 return ret;
220}
221
222static const struct {
223 const char *name;
224 unsigned long flags;
225} trigger_types[] = {
226 { "none", 0 },
227 { "falling", BIT(FLAG_TRIG_FALL) },
228 { "rising", BIT(FLAG_TRIG_RISE) },
229 { "both", BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE) },
230};
231
232static ssize_t gpio_edge_show(struct device *dev,
233 struct device_attribute *attr, char *buf)
234{
235 const struct gpio_desc *desc = dev_get_drvdata(dev);
236 ssize_t status;
237
238 mutex_lock(&sysfs_lock);
239
240 if (!test_bit(FLAG_EXPORT, &desc->flags))
241 status = -EIO;
242 else {
243 int i;
244
245 status = 0;
246 for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
247 if ((desc->flags & GPIO_TRIGGER_MASK)
248 == trigger_types[i].flags) {
249 status = sprintf(buf, "%s\n",
250 trigger_types[i].name);
251 break;
252 }
253 }
254
255 mutex_unlock(&sysfs_lock);
256 return status;
257}
258
259static ssize_t gpio_edge_store(struct device *dev,
260 struct device_attribute *attr, const char *buf, size_t size)
261{
262 struct gpio_desc *desc = dev_get_drvdata(dev);
263 ssize_t status;
264 int i;
265
266 for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
267 if (sysfs_streq(trigger_types[i].name, buf))
268 goto found;
269 return -EINVAL;
270
271found:
272 mutex_lock(&sysfs_lock);
273
274 if (!test_bit(FLAG_EXPORT, &desc->flags))
275 status = -EIO;
276 else {
277 status = gpio_setup_irq(desc, dev, trigger_types[i].flags);
278 if (!status)
279 status = size;
280 }
281
282 mutex_unlock(&sysfs_lock);
283
284 return status;
285}
286
287static DEVICE_ATTR(edge, 0644, gpio_edge_show, gpio_edge_store);
288
289static int sysfs_set_active_low(struct gpio_desc *desc, struct device *dev,
290 int value)
291{
292 int status = 0;
293
294 if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value)
295 return 0;
296
297 if (value)
298 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
299 else
300 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
301
302 /* reconfigure poll(2) support if enabled on one edge only */
303 if (dev != NULL && (!!test_bit(FLAG_TRIG_RISE, &desc->flags) ^
304 !!test_bit(FLAG_TRIG_FALL, &desc->flags))) {
305 unsigned long trigger_flags = desc->flags & GPIO_TRIGGER_MASK;
306
307 gpio_setup_irq(desc, dev, 0);
308 status = gpio_setup_irq(desc, dev, trigger_flags);
309 }
310
311 return status;
312}
313
314static ssize_t gpio_active_low_show(struct device *dev,
315 struct device_attribute *attr, char *buf)
316{
317 const struct gpio_desc *desc = dev_get_drvdata(dev);
318 ssize_t status;
319
320 mutex_lock(&sysfs_lock);
321
322 if (!test_bit(FLAG_EXPORT, &desc->flags))
323 status = -EIO;
324 else
325 status = sprintf(buf, "%d\n",
326 !!test_bit(FLAG_ACTIVE_LOW, &desc->flags));
327
328 mutex_unlock(&sysfs_lock);
329
330 return status;
331}
332
333static ssize_t gpio_active_low_store(struct device *dev,
334 struct device_attribute *attr, const char *buf, size_t size)
335{
336 struct gpio_desc *desc = dev_get_drvdata(dev);
337 ssize_t status;
338
339 mutex_lock(&sysfs_lock);
340
341 if (!test_bit(FLAG_EXPORT, &desc->flags)) {
342 status = -EIO;
343 } else {
344 long value;
345
346 status = kstrtol(buf, 0, &value);
347 if (status == 0)
348 status = sysfs_set_active_low(desc, dev, value != 0);
349 }
350
351 mutex_unlock(&sysfs_lock);
352
353 return status ? : size;
354}
355
356static const DEVICE_ATTR(active_low, 0644,
357 gpio_active_low_show, gpio_active_low_store);
358
359static const struct attribute *gpio_attrs[] = {
360 &dev_attr_value.attr,
361 &dev_attr_active_low.attr,
362 NULL,
363};
364
365static const struct attribute_group gpio_attr_group = {
366 .attrs = (struct attribute **) gpio_attrs,
367};
368
369/*
370 * /sys/class/gpio/gpiochipN/
371 * /base ... matching gpio_chip.base (N)
372 * /label ... matching gpio_chip.label
373 * /ngpio ... matching gpio_chip.ngpio
374 */
375
376static ssize_t chip_base_show(struct device *dev,
377 struct device_attribute *attr, char *buf)
378{
379 const struct gpio_chip *chip = dev_get_drvdata(dev);
380
381 return sprintf(buf, "%d\n", chip->base);
382}
383static DEVICE_ATTR(base, 0444, chip_base_show, NULL);
384
385static ssize_t chip_label_show(struct device *dev,
386 struct device_attribute *attr, char *buf)
387{
388 const struct gpio_chip *chip = dev_get_drvdata(dev);
389
390 return sprintf(buf, "%s\n", chip->label ? : "");
391}
392static DEVICE_ATTR(label, 0444, chip_label_show, NULL);
393
394static ssize_t chip_ngpio_show(struct device *dev,
395 struct device_attribute *attr, char *buf)
396{
397 const struct gpio_chip *chip = dev_get_drvdata(dev);
398
399 return sprintf(buf, "%u\n", chip->ngpio);
400}
401static DEVICE_ATTR(ngpio, 0444, chip_ngpio_show, NULL);
402
403static const struct attribute *gpiochip_attrs[] = {
404 &dev_attr_base.attr,
405 &dev_attr_label.attr,
406 &dev_attr_ngpio.attr,
407 NULL,
408};
409
410static const struct attribute_group gpiochip_attr_group = {
411 .attrs = (struct attribute **) gpiochip_attrs,
412};
413
414/*
415 * /sys/class/gpio/export ... write-only
416 * integer N ... number of GPIO to export (full access)
417 * /sys/class/gpio/unexport ... write-only
418 * integer N ... number of GPIO to unexport
419 */
420static ssize_t export_store(struct class *class,
421 struct class_attribute *attr,
422 const char *buf, size_t len)
423{
424 long gpio;
425 struct gpio_desc *desc;
426 int status;
427
428 status = kstrtol(buf, 0, &gpio);
429 if (status < 0)
430 goto done;
431
432 desc = gpio_to_desc(gpio);
433 /* reject invalid GPIOs */
434 if (!desc) {
435 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
436 return -EINVAL;
437 }
438
439 /* No extra locking here; FLAG_SYSFS just signifies that the
440 * request and export were done by on behalf of userspace, so
441 * they may be undone on its behalf too.
442 */
443
444 status = gpiod_request(desc, "sysfs");
445 if (status < 0) {
446 if (status == -EPROBE_DEFER)
447 status = -ENODEV;
448 goto done;
449 }
450 status = gpiod_export(desc, true);
451 if (status < 0)
452 gpiod_free(desc);
453 else
454 set_bit(FLAG_SYSFS, &desc->flags);
455
456done:
457 if (status)
458 pr_debug("%s: status %d\n", __func__, status);
459 return status ? : len;
460}
461
462static ssize_t unexport_store(struct class *class,
463 struct class_attribute *attr,
464 const char *buf, size_t len)
465{
466 long gpio;
467 struct gpio_desc *desc;
468 int status;
469
470 status = kstrtol(buf, 0, &gpio);
471 if (status < 0)
472 goto done;
473
474 desc = gpio_to_desc(gpio);
475 /* reject bogus commands (gpio_unexport ignores them) */
476 if (!desc) {
477 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
478 return -EINVAL;
479 }
480
481 status = -EINVAL;
482
483 /* No extra locking here; FLAG_SYSFS just signifies that the
484 * request and export were done by on behalf of userspace, so
485 * they may be undone on its behalf too.
486 */
487 if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
488 status = 0;
489 gpiod_free(desc);
490 }
491done:
492 if (status)
493 pr_debug("%s: status %d\n", __func__, status);
494 return status ? : len;
495}
496
497static struct class_attribute gpio_class_attrs[] = {
498 __ATTR(export, 0200, NULL, export_store),
499 __ATTR(unexport, 0200, NULL, unexport_store),
500 __ATTR_NULL,
501};
502
503static struct class gpio_class = {
504 .name = "gpio",
505 .owner = THIS_MODULE,
506
507 .class_attrs = gpio_class_attrs,
508};
509
510
511/**
512 * gpiod_export - export a GPIO through sysfs
513 * @gpio: gpio to make available, already requested
514 * @direction_may_change: true if userspace may change gpio direction
515 * Context: arch_initcall or later
516 *
517 * When drivers want to make a GPIO accessible to userspace after they
518 * have requested it -- perhaps while debugging, or as part of their
519 * public interface -- they may use this routine. If the GPIO can
520 * change direction (some can't) and the caller allows it, userspace
521 * will see "direction" sysfs attribute which may be used to change
522 * the gpio's direction. A "value" attribute will always be provided.
523 *
524 * Returns zero on success, else an error.
525 */
526int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
527{
528 unsigned long flags;
529 int status;
530 const char *ioname = NULL;
531 struct device *dev;
532 int offset;
533
534 /* can't export until sysfs is available ... */
535 if (!gpio_class.p) {
536 pr_debug("%s: called too early!\n", __func__);
537 return -ENOENT;
538 }
539
540 if (!desc) {
541 pr_debug("%s: invalid gpio descriptor\n", __func__);
542 return -EINVAL;
543 }
544
545 mutex_lock(&sysfs_lock);
546
547 spin_lock_irqsave(&gpio_lock, flags);
548 if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
549 test_bit(FLAG_EXPORT, &desc->flags)) {
550 spin_unlock_irqrestore(&gpio_lock, flags);
551 gpiod_dbg(desc, "%s: unavailable (requested=%d, exported=%d)\n",
552 __func__,
553 test_bit(FLAG_REQUESTED, &desc->flags),
554 test_bit(FLAG_EXPORT, &desc->flags));
555 status = -EPERM;
556 goto fail_unlock;
557 }
558
559 if (!desc->chip->direction_input || !desc->chip->direction_output)
560 direction_may_change = false;
561 spin_unlock_irqrestore(&gpio_lock, flags);
562
563 offset = gpio_chip_hwgpio(desc);
564 if (desc->chip->names && desc->chip->names[offset])
565 ioname = desc->chip->names[offset];
566
567 dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
568 desc, ioname ? ioname : "gpio%u",
569 desc_to_gpio(desc));
570 if (IS_ERR(dev)) {
571 status = PTR_ERR(dev);
572 goto fail_unlock;
573 }
574
575 status = sysfs_create_group(&dev->kobj, &gpio_attr_group);
576 if (status)
577 goto fail_unregister_device;
578
579 if (direction_may_change) {
580 status = device_create_file(dev, &dev_attr_direction);
581 if (status)
582 goto fail_unregister_device;
583 }
584
585 if (gpiod_to_irq(desc) >= 0 && (direction_may_change ||
586 !test_bit(FLAG_IS_OUT, &desc->flags))) {
587 status = device_create_file(dev, &dev_attr_edge);
588 if (status)
589 goto fail_unregister_device;
590 }
591
592 set_bit(FLAG_EXPORT, &desc->flags);
593 mutex_unlock(&sysfs_lock);
594 return 0;
595
596fail_unregister_device:
597 device_unregister(dev);
598fail_unlock:
599 mutex_unlock(&sysfs_lock);
600 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
601 return status;
602}
603EXPORT_SYMBOL_GPL(gpiod_export);
604
605static int match_export(struct device *dev, const void *data)
606{
607 return dev_get_drvdata(dev) == data;
608}
609
610/**
611 * gpiod_export_link - create a sysfs link to an exported GPIO node
612 * @dev: device under which to create symlink
613 * @name: name of the symlink
614 * @gpio: gpio to create symlink to, already exported
615 *
616 * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
617 * node. Caller is responsible for unlinking.
618 *
619 * Returns zero on success, else an error.
620 */
621int gpiod_export_link(struct device *dev, const char *name,
622 struct gpio_desc *desc)
623{
624 int status = -EINVAL;
625
626 if (!desc) {
627 pr_warn("%s: invalid GPIO\n", __func__);
628 return -EINVAL;
629 }
630
631 mutex_lock(&sysfs_lock);
632
633 if (test_bit(FLAG_EXPORT, &desc->flags)) {
634 struct device *tdev;
635
636 tdev = class_find_device(&gpio_class, NULL, desc, match_export);
637 if (tdev != NULL) {
638 status = sysfs_create_link(&dev->kobj, &tdev->kobj,
639 name);
640 } else {
641 status = -ENODEV;
642 }
643 }
644
645 mutex_unlock(&sysfs_lock);
646
647 if (status)
648 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
649
650 return status;
651}
652EXPORT_SYMBOL_GPL(gpiod_export_link);
653
654/**
655 * gpiod_sysfs_set_active_low - set the polarity of gpio sysfs value
656 * @gpio: gpio to change
657 * @value: non-zero to use active low, i.e. inverted values
658 *
659 * Set the polarity of /sys/class/gpio/gpioN/value sysfs attribute.
660 * The GPIO does not have to be exported yet. If poll(2) support has
661 * been enabled for either rising or falling edge, it will be
662 * reconfigured to follow the new polarity.
663 *
664 * Returns zero on success, else an error.
665 */
666int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
667{
668 struct device *dev = NULL;
669 int status = -EINVAL;
670
671 if (!desc) {
672 pr_warn("%s: invalid GPIO\n", __func__);
673 return -EINVAL;
674 }
675
676 mutex_lock(&sysfs_lock);
677
678 if (test_bit(FLAG_EXPORT, &desc->flags)) {
679 dev = class_find_device(&gpio_class, NULL, desc, match_export);
680 if (dev == NULL) {
681 status = -ENODEV;
682 goto unlock;
683 }
684 }
685
686 status = sysfs_set_active_low(desc, dev, value);
687
688unlock:
689 mutex_unlock(&sysfs_lock);
690
691 if (status)
692 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
693
694 return status;
695}
696EXPORT_SYMBOL_GPL(gpiod_sysfs_set_active_low);
697
698/**
699 * gpiod_unexport - reverse effect of gpio_export()
700 * @gpio: gpio to make unavailable
701 *
702 * This is implicit on gpio_free().
703 */
704void gpiod_unexport(struct gpio_desc *desc)
705{
706 int status = 0;
707 struct device *dev = NULL;
708
709 if (!desc) {
710 pr_warn("%s: invalid GPIO\n", __func__);
711 return;
712 }
713
714 mutex_lock(&sysfs_lock);
715
716 if (test_bit(FLAG_EXPORT, &desc->flags)) {
717
718 dev = class_find_device(&gpio_class, NULL, desc, match_export);
719 if (dev) {
720 gpio_setup_irq(desc, dev, 0);
721 clear_bit(FLAG_EXPORT, &desc->flags);
722 } else
723 status = -ENODEV;
724 }
725
726 mutex_unlock(&sysfs_lock);
727
728 if (dev) {
729 device_unregister(dev);
730 put_device(dev);
731 }
732
733 if (status)
734 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
735}
736EXPORT_SYMBOL_GPL(gpiod_unexport);
737
738int gpiochip_export(struct gpio_chip *chip)
739{
740 int status;
741 struct device *dev;
742
743 /* Many systems register gpio chips for SOC support very early,
744 * before driver model support is available. In those cases we
745 * export this later, in gpiolib_sysfs_init() ... here we just
746 * verify that _some_ field of gpio_class got initialized.
747 */
748 if (!gpio_class.p)
749 return 0;
750
751 /* use chip->base for the ID; it's already known to be unique */
752 mutex_lock(&sysfs_lock);
753 dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
754 "gpiochip%d", chip->base);
755 if (!IS_ERR(dev)) {
756 status = sysfs_create_group(&dev->kobj,
757 &gpiochip_attr_group);
758 } else
759 status = PTR_ERR(dev);
760 chip->exported = (status == 0);
761 mutex_unlock(&sysfs_lock);
762
763 if (status) {
764 unsigned long flags;
765 unsigned gpio;
766
767 spin_lock_irqsave(&gpio_lock, flags);
768 gpio = 0;
769 while (gpio < chip->ngpio)
770 chip->desc[gpio++].chip = NULL;
771 spin_unlock_irqrestore(&gpio_lock, flags);
772
773 chip_dbg(chip, "%s: status %d\n", __func__, status);
774 }
775
776 return status;
777}
778
779void gpiochip_unexport(struct gpio_chip *chip)
780{
781 int status;
782 struct device *dev;
783
784 mutex_lock(&sysfs_lock);
785 dev = class_find_device(&gpio_class, NULL, chip, match_export);
786 if (dev) {
787 put_device(dev);
788 device_unregister(dev);
789 chip->exported = false;
790 status = 0;
791 } else
792 status = -ENODEV;
793 mutex_unlock(&sysfs_lock);
794
795 if (status)
796 chip_dbg(chip, "%s: status %d\n", __func__, status);
797}
798
799static int __init gpiolib_sysfs_init(void)
800{
801 int status;
802 unsigned long flags;
803 struct gpio_chip *chip;
804
805 status = class_register(&gpio_class);
806 if (status < 0)
807 return status;
808
809 /* Scan and register the gpio_chips which registered very
810 * early (e.g. before the class_register above was called).
811 *
812 * We run before arch_initcall() so chip->dev nodes can have
813 * registered, and so arch_initcall() can always gpio_export().
814 */
815 spin_lock_irqsave(&gpio_lock, flags);
816 list_for_each_entry(chip, &gpio_chips, list) {
817 if (!chip || chip->exported)
818 continue;
819
820 spin_unlock_irqrestore(&gpio_lock, flags);
821 status = gpiochip_export(chip);
822 spin_lock_irqsave(&gpio_lock, flags);
823 }
824 spin_unlock_irqrestore(&gpio_lock, flags);
825
826
827 return status;
828}
829postcore_initcall(gpiolib_sysfs_init);
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index 8ba9dbedcfdf..7b35e5093ef5 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -44,94 +44,21 @@
44 * While any GPIO is requested, its gpio_chip is not removable; 44 * While any GPIO is requested, its gpio_chip is not removable;
45 * each GPIO's "requested" flag serves as a lock and refcount. 45 * each GPIO's "requested" flag serves as a lock and refcount.
46 */ 46 */
47static DEFINE_SPINLOCK(gpio_lock); 47DEFINE_SPINLOCK(gpio_lock);
48 48
49struct gpio_desc {
50 struct gpio_chip *chip;
51 unsigned long flags;
52/* flag symbols are bit numbers */
53#define FLAG_REQUESTED 0
54#define FLAG_IS_OUT 1
55#define FLAG_EXPORT 2 /* protected by sysfs_lock */
56#define FLAG_SYSFS 3 /* exported via /sys/class/gpio/control */
57#define FLAG_TRIG_FALL 4 /* trigger on falling edge */
58#define FLAG_TRIG_RISE 5 /* trigger on rising edge */
59#define FLAG_ACTIVE_LOW 6 /* value has active low */
60#define FLAG_OPEN_DRAIN 7 /* Gpio is open drain type */
61#define FLAG_OPEN_SOURCE 8 /* Gpio is open source type */
62#define FLAG_USED_AS_IRQ 9 /* GPIO is connected to an IRQ */
63
64#define ID_SHIFT 16 /* add new flags before this one */
65
66#define GPIO_FLAGS_MASK ((1 << ID_SHIFT) - 1)
67#define GPIO_TRIGGER_MASK (BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE))
68
69 const char *label;
70};
71static struct gpio_desc gpio_desc[ARCH_NR_GPIOS]; 49static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];
72 50
73#define GPIO_OFFSET_VALID(chip, offset) (offset >= 0 && offset < chip->ngpio) 51#define GPIO_OFFSET_VALID(chip, offset) (offset >= 0 && offset < chip->ngpio)
74 52
75static DEFINE_MUTEX(gpio_lookup_lock); 53static DEFINE_MUTEX(gpio_lookup_lock);
76static LIST_HEAD(gpio_lookup_list); 54static LIST_HEAD(gpio_lookup_list);
77static LIST_HEAD(gpio_chips); 55LIST_HEAD(gpio_chips);
78
79#ifdef CONFIG_GPIO_SYSFS
80static DEFINE_IDR(dirent_idr);
81#endif
82
83static int gpiod_request(struct gpio_desc *desc, const char *label);
84static void gpiod_free(struct gpio_desc *desc);
85
86/* With descriptor prefix */
87
88#define gpiod_emerg(desc, fmt, ...) \
89 pr_emerg("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",\
90 ##__VA_ARGS__)
91#define gpiod_crit(desc, fmt, ...) \
92 pr_crit("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
93 ##__VA_ARGS__)
94#define gpiod_err(desc, fmt, ...) \
95 pr_err("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
96 ##__VA_ARGS__)
97#define gpiod_warn(desc, fmt, ...) \
98 pr_warn("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
99 ##__VA_ARGS__)
100#define gpiod_info(desc, fmt, ...) \
101 pr_info("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
102 ##__VA_ARGS__)
103#define gpiod_dbg(desc, fmt, ...) \
104 pr_debug("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",\
105 ##__VA_ARGS__)
106
107/* With chip prefix */
108
109#define chip_emerg(chip, fmt, ...) \
110 pr_emerg("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
111#define chip_crit(chip, fmt, ...) \
112 pr_crit("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
113#define chip_err(chip, fmt, ...) \
114 pr_err("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
115#define chip_warn(chip, fmt, ...) \
116 pr_warn("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
117#define chip_info(chip, fmt, ...) \
118 pr_info("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
119#define chip_dbg(chip, fmt, ...) \
120 pr_debug("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
121 56
122static inline void desc_set_label(struct gpio_desc *d, const char *label) 57static inline void desc_set_label(struct gpio_desc *d, const char *label)
123{ 58{
124 d->label = label; 59 d->label = label;
125} 60}
126 61
127/*
128 * Return the GPIO number of the passed descriptor relative to its chip
129 */
130static int gpio_chip_hwgpio(const struct gpio_desc *desc)
131{
132 return desc - &desc->chip->desc[0];
133}
134
135/** 62/**
136 * Convert a GPIO number to its descriptor 63 * Convert a GPIO number to its descriptor
137 */ 64 */
@@ -272,836 +199,6 @@ int gpiod_get_direction(const struct gpio_desc *desc)
272} 199}
273EXPORT_SYMBOL_GPL(gpiod_get_direction); 200EXPORT_SYMBOL_GPL(gpiod_get_direction);
274 201
275#ifdef CONFIG_GPIO_SYSFS
276
277/* lock protects against unexport_gpio() being called while
278 * sysfs files are active.
279 */
280static DEFINE_MUTEX(sysfs_lock);
281
282/*
283 * /sys/class/gpio/gpioN... only for GPIOs that are exported
284 * /direction
285 * * MAY BE OMITTED if kernel won't allow direction changes
286 * * is read/write as "in" or "out"
287 * * may also be written as "high" or "low", initializing
288 * output value as specified ("out" implies "low")
289 * /value
290 * * always readable, subject to hardware behavior
291 * * may be writable, as zero/nonzero
292 * /edge
293 * * configures behavior of poll(2) on /value
294 * * available only if pin can generate IRQs on input
295 * * is read/write as "none", "falling", "rising", or "both"
296 * /active_low
297 * * configures polarity of /value
298 * * is read/write as zero/nonzero
299 * * also affects existing and subsequent "falling" and "rising"
300 * /edge configuration
301 */
302
303static ssize_t gpio_direction_show(struct device *dev,
304 struct device_attribute *attr, char *buf)
305{
306 const struct gpio_desc *desc = dev_get_drvdata(dev);
307 ssize_t status;
308
309 mutex_lock(&sysfs_lock);
310
311 if (!test_bit(FLAG_EXPORT, &desc->flags)) {
312 status = -EIO;
313 } else {
314 gpiod_get_direction(desc);
315 status = sprintf(buf, "%s\n",
316 test_bit(FLAG_IS_OUT, &desc->flags)
317 ? "out" : "in");
318 }
319
320 mutex_unlock(&sysfs_lock);
321 return status;
322}
323
324static ssize_t gpio_direction_store(struct device *dev,
325 struct device_attribute *attr, const char *buf, size_t size)
326{
327 struct gpio_desc *desc = dev_get_drvdata(dev);
328 ssize_t status;
329
330 mutex_lock(&sysfs_lock);
331
332 if (!test_bit(FLAG_EXPORT, &desc->flags))
333 status = -EIO;
334 else if (sysfs_streq(buf, "high"))
335 status = gpiod_direction_output_raw(desc, 1);
336 else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
337 status = gpiod_direction_output_raw(desc, 0);
338 else if (sysfs_streq(buf, "in"))
339 status = gpiod_direction_input(desc);
340 else
341 status = -EINVAL;
342
343 mutex_unlock(&sysfs_lock);
344 return status ? : size;
345}
346
347static /* const */ DEVICE_ATTR(direction, 0644,
348 gpio_direction_show, gpio_direction_store);
349
350static ssize_t gpio_value_show(struct device *dev,
351 struct device_attribute *attr, char *buf)
352{
353 struct gpio_desc *desc = dev_get_drvdata(dev);
354 ssize_t status;
355
356 mutex_lock(&sysfs_lock);
357
358 if (!test_bit(FLAG_EXPORT, &desc->flags))
359 status = -EIO;
360 else
361 status = sprintf(buf, "%d\n", gpiod_get_value_cansleep(desc));
362
363 mutex_unlock(&sysfs_lock);
364 return status;
365}
366
367static ssize_t gpio_value_store(struct device *dev,
368 struct device_attribute *attr, const char *buf, size_t size)
369{
370 struct gpio_desc *desc = dev_get_drvdata(dev);
371 ssize_t status;
372
373 mutex_lock(&sysfs_lock);
374
375 if (!test_bit(FLAG_EXPORT, &desc->flags))
376 status = -EIO;
377 else if (!test_bit(FLAG_IS_OUT, &desc->flags))
378 status = -EPERM;
379 else {
380 long value;
381
382 status = kstrtol(buf, 0, &value);
383 if (status == 0) {
384 gpiod_set_value_cansleep(desc, value);
385 status = size;
386 }
387 }
388
389 mutex_unlock(&sysfs_lock);
390 return status;
391}
392
393static const DEVICE_ATTR(value, 0644,
394 gpio_value_show, gpio_value_store);
395
396static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
397{
398 struct kernfs_node *value_sd = priv;
399
400 sysfs_notify_dirent(value_sd);
401 return IRQ_HANDLED;
402}
403
404static int gpio_setup_irq(struct gpio_desc *desc, struct device *dev,
405 unsigned long gpio_flags)
406{
407 struct kernfs_node *value_sd;
408 unsigned long irq_flags;
409 int ret, irq, id;
410
411 if ((desc->flags & GPIO_TRIGGER_MASK) == gpio_flags)
412 return 0;
413
414 irq = gpiod_to_irq(desc);
415 if (irq < 0)
416 return -EIO;
417
418 id = desc->flags >> ID_SHIFT;
419 value_sd = idr_find(&dirent_idr, id);
420 if (value_sd)
421 free_irq(irq, value_sd);
422
423 desc->flags &= ~GPIO_TRIGGER_MASK;
424
425 if (!gpio_flags) {
426 gpiod_unlock_as_irq(desc);
427 ret = 0;
428 goto free_id;
429 }
430
431 irq_flags = IRQF_SHARED;
432 if (test_bit(FLAG_TRIG_FALL, &gpio_flags))
433 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
434 IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
435 if (test_bit(FLAG_TRIG_RISE, &gpio_flags))
436 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
437 IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
438
439 if (!value_sd) {
440 value_sd = sysfs_get_dirent(dev->kobj.sd, "value");
441 if (!value_sd) {
442 ret = -ENODEV;
443 goto err_out;
444 }
445
446 ret = idr_alloc(&dirent_idr, value_sd, 1, 0, GFP_KERNEL);
447 if (ret < 0)
448 goto free_sd;
449 id = ret;
450
451 desc->flags &= GPIO_FLAGS_MASK;
452 desc->flags |= (unsigned long)id << ID_SHIFT;
453
454 if (desc->flags >> ID_SHIFT != id) {
455 ret = -ERANGE;
456 goto free_id;
457 }
458 }
459
460 ret = request_any_context_irq(irq, gpio_sysfs_irq, irq_flags,
461 "gpiolib", value_sd);
462 if (ret < 0)
463 goto free_id;
464
465 ret = gpiod_lock_as_irq(desc);
466 if (ret < 0) {
467 gpiod_warn(desc, "failed to flag the GPIO for IRQ\n");
468 goto free_id;
469 }
470
471 desc->flags |= gpio_flags;
472 return 0;
473
474free_id:
475 idr_remove(&dirent_idr, id);
476 desc->flags &= GPIO_FLAGS_MASK;
477free_sd:
478 if (value_sd)
479 sysfs_put(value_sd);
480err_out:
481 return ret;
482}
483
484static const struct {
485 const char *name;
486 unsigned long flags;
487} trigger_types[] = {
488 { "none", 0 },
489 { "falling", BIT(FLAG_TRIG_FALL) },
490 { "rising", BIT(FLAG_TRIG_RISE) },
491 { "both", BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE) },
492};
493
494static ssize_t gpio_edge_show(struct device *dev,
495 struct device_attribute *attr, char *buf)
496{
497 const struct gpio_desc *desc = dev_get_drvdata(dev);
498 ssize_t status;
499
500 mutex_lock(&sysfs_lock);
501
502 if (!test_bit(FLAG_EXPORT, &desc->flags))
503 status = -EIO;
504 else {
505 int i;
506
507 status = 0;
508 for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
509 if ((desc->flags & GPIO_TRIGGER_MASK)
510 == trigger_types[i].flags) {
511 status = sprintf(buf, "%s\n",
512 trigger_types[i].name);
513 break;
514 }
515 }
516
517 mutex_unlock(&sysfs_lock);
518 return status;
519}
520
521static ssize_t gpio_edge_store(struct device *dev,
522 struct device_attribute *attr, const char *buf, size_t size)
523{
524 struct gpio_desc *desc = dev_get_drvdata(dev);
525 ssize_t status;
526 int i;
527
528 for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
529 if (sysfs_streq(trigger_types[i].name, buf))
530 goto found;
531 return -EINVAL;
532
533found:
534 mutex_lock(&sysfs_lock);
535
536 if (!test_bit(FLAG_EXPORT, &desc->flags))
537 status = -EIO;
538 else {
539 status = gpio_setup_irq(desc, dev, trigger_types[i].flags);
540 if (!status)
541 status = size;
542 }
543
544 mutex_unlock(&sysfs_lock);
545
546 return status;
547}
548
549static DEVICE_ATTR(edge, 0644, gpio_edge_show, gpio_edge_store);
550
551static int sysfs_set_active_low(struct gpio_desc *desc, struct device *dev,
552 int value)
553{
554 int status = 0;
555
556 if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value)
557 return 0;
558
559 if (value)
560 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
561 else
562 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
563
564 /* reconfigure poll(2) support if enabled on one edge only */
565 if (dev != NULL && (!!test_bit(FLAG_TRIG_RISE, &desc->flags) ^
566 !!test_bit(FLAG_TRIG_FALL, &desc->flags))) {
567 unsigned long trigger_flags = desc->flags & GPIO_TRIGGER_MASK;
568
569 gpio_setup_irq(desc, dev, 0);
570 status = gpio_setup_irq(desc, dev, trigger_flags);
571 }
572
573 return status;
574}
575
576static ssize_t gpio_active_low_show(struct device *dev,
577 struct device_attribute *attr, char *buf)
578{
579 const struct gpio_desc *desc = dev_get_drvdata(dev);
580 ssize_t status;
581
582 mutex_lock(&sysfs_lock);
583
584 if (!test_bit(FLAG_EXPORT, &desc->flags))
585 status = -EIO;
586 else
587 status = sprintf(buf, "%d\n",
588 !!test_bit(FLAG_ACTIVE_LOW, &desc->flags));
589
590 mutex_unlock(&sysfs_lock);
591
592 return status;
593}
594
595static ssize_t gpio_active_low_store(struct device *dev,
596 struct device_attribute *attr, const char *buf, size_t size)
597{
598 struct gpio_desc *desc = dev_get_drvdata(dev);
599 ssize_t status;
600
601 mutex_lock(&sysfs_lock);
602
603 if (!test_bit(FLAG_EXPORT, &desc->flags)) {
604 status = -EIO;
605 } else {
606 long value;
607
608 status = kstrtol(buf, 0, &value);
609 if (status == 0)
610 status = sysfs_set_active_low(desc, dev, value != 0);
611 }
612
613 mutex_unlock(&sysfs_lock);
614
615 return status ? : size;
616}
617
618static const DEVICE_ATTR(active_low, 0644,
619 gpio_active_low_show, gpio_active_low_store);
620
621static const struct attribute *gpio_attrs[] = {
622 &dev_attr_value.attr,
623 &dev_attr_active_low.attr,
624 NULL,
625};
626
627static const struct attribute_group gpio_attr_group = {
628 .attrs = (struct attribute **) gpio_attrs,
629};
630
631/*
632 * /sys/class/gpio/gpiochipN/
633 * /base ... matching gpio_chip.base (N)
634 * /label ... matching gpio_chip.label
635 * /ngpio ... matching gpio_chip.ngpio
636 */
637
638static ssize_t chip_base_show(struct device *dev,
639 struct device_attribute *attr, char *buf)
640{
641 const struct gpio_chip *chip = dev_get_drvdata(dev);
642
643 return sprintf(buf, "%d\n", chip->base);
644}
645static DEVICE_ATTR(base, 0444, chip_base_show, NULL);
646
647static ssize_t chip_label_show(struct device *dev,
648 struct device_attribute *attr, char *buf)
649{
650 const struct gpio_chip *chip = dev_get_drvdata(dev);
651
652 return sprintf(buf, "%s\n", chip->label ? : "");
653}
654static DEVICE_ATTR(label, 0444, chip_label_show, NULL);
655
656static ssize_t chip_ngpio_show(struct device *dev,
657 struct device_attribute *attr, char *buf)
658{
659 const struct gpio_chip *chip = dev_get_drvdata(dev);
660
661 return sprintf(buf, "%u\n", chip->ngpio);
662}
663static DEVICE_ATTR(ngpio, 0444, chip_ngpio_show, NULL);
664
665static const struct attribute *gpiochip_attrs[] = {
666 &dev_attr_base.attr,
667 &dev_attr_label.attr,
668 &dev_attr_ngpio.attr,
669 NULL,
670};
671
672static const struct attribute_group gpiochip_attr_group = {
673 .attrs = (struct attribute **) gpiochip_attrs,
674};
675
676/*
677 * /sys/class/gpio/export ... write-only
678 * integer N ... number of GPIO to export (full access)
679 * /sys/class/gpio/unexport ... write-only
680 * integer N ... number of GPIO to unexport
681 */
682static ssize_t export_store(struct class *class,
683 struct class_attribute *attr,
684 const char *buf, size_t len)
685{
686 long gpio;
687 struct gpio_desc *desc;
688 int status;
689
690 status = kstrtol(buf, 0, &gpio);
691 if (status < 0)
692 goto done;
693
694 desc = gpio_to_desc(gpio);
695 /* reject invalid GPIOs */
696 if (!desc) {
697 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
698 return -EINVAL;
699 }
700
701 /* No extra locking here; FLAG_SYSFS just signifies that the
702 * request and export were done by on behalf of userspace, so
703 * they may be undone on its behalf too.
704 */
705
706 status = gpiod_request(desc, "sysfs");
707 if (status < 0) {
708 if (status == -EPROBE_DEFER)
709 status = -ENODEV;
710 goto done;
711 }
712 status = gpiod_export(desc, true);
713 if (status < 0)
714 gpiod_free(desc);
715 else
716 set_bit(FLAG_SYSFS, &desc->flags);
717
718done:
719 if (status)
720 pr_debug("%s: status %d\n", __func__, status);
721 return status ? : len;
722}
723
724static ssize_t unexport_store(struct class *class,
725 struct class_attribute *attr,
726 const char *buf, size_t len)
727{
728 long gpio;
729 struct gpio_desc *desc;
730 int status;
731
732 status = kstrtol(buf, 0, &gpio);
733 if (status < 0)
734 goto done;
735
736 desc = gpio_to_desc(gpio);
737 /* reject bogus commands (gpio_unexport ignores them) */
738 if (!desc) {
739 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
740 return -EINVAL;
741 }
742
743 status = -EINVAL;
744
745 /* No extra locking here; FLAG_SYSFS just signifies that the
746 * request and export were done by on behalf of userspace, so
747 * they may be undone on its behalf too.
748 */
749 if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
750 status = 0;
751 gpiod_free(desc);
752 }
753done:
754 if (status)
755 pr_debug("%s: status %d\n", __func__, status);
756 return status ? : len;
757}
758
759static struct class_attribute gpio_class_attrs[] = {
760 __ATTR(export, 0200, NULL, export_store),
761 __ATTR(unexport, 0200, NULL, unexport_store),
762 __ATTR_NULL,
763};
764
765static struct class gpio_class = {
766 .name = "gpio",
767 .owner = THIS_MODULE,
768
769 .class_attrs = gpio_class_attrs,
770};
771
772
773/**
774 * gpiod_export - export a GPIO through sysfs
775 * @gpio: gpio to make available, already requested
776 * @direction_may_change: true if userspace may change gpio direction
777 * Context: arch_initcall or later
778 *
779 * When drivers want to make a GPIO accessible to userspace after they
780 * have requested it -- perhaps while debugging, or as part of their
781 * public interface -- they may use this routine. If the GPIO can
782 * change direction (some can't) and the caller allows it, userspace
783 * will see "direction" sysfs attribute which may be used to change
784 * the gpio's direction. A "value" attribute will always be provided.
785 *
786 * Returns zero on success, else an error.
787 */
788int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
789{
790 unsigned long flags;
791 int status;
792 const char *ioname = NULL;
793 struct device *dev;
794 int offset;
795
796 /* can't export until sysfs is available ... */
797 if (!gpio_class.p) {
798 pr_debug("%s: called too early!\n", __func__);
799 return -ENOENT;
800 }
801
802 if (!desc) {
803 pr_debug("%s: invalid gpio descriptor\n", __func__);
804 return -EINVAL;
805 }
806
807 mutex_lock(&sysfs_lock);
808
809 spin_lock_irqsave(&gpio_lock, flags);
810 if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
811 test_bit(FLAG_EXPORT, &desc->flags)) {
812 spin_unlock_irqrestore(&gpio_lock, flags);
813 gpiod_dbg(desc, "%s: unavailable (requested=%d, exported=%d)\n",
814 __func__,
815 test_bit(FLAG_REQUESTED, &desc->flags),
816 test_bit(FLAG_EXPORT, &desc->flags));
817 status = -EPERM;
818 goto fail_unlock;
819 }
820
821 if (!desc->chip->direction_input || !desc->chip->direction_output)
822 direction_may_change = false;
823 spin_unlock_irqrestore(&gpio_lock, flags);
824
825 offset = gpio_chip_hwgpio(desc);
826 if (desc->chip->names && desc->chip->names[offset])
827 ioname = desc->chip->names[offset];
828
829 dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
830 desc, ioname ? ioname : "gpio%u",
831 desc_to_gpio(desc));
832 if (IS_ERR(dev)) {
833 status = PTR_ERR(dev);
834 goto fail_unlock;
835 }
836
837 status = sysfs_create_group(&dev->kobj, &gpio_attr_group);
838 if (status)
839 goto fail_unregister_device;
840
841 if (direction_may_change) {
842 status = device_create_file(dev, &dev_attr_direction);
843 if (status)
844 goto fail_unregister_device;
845 }
846
847 if (gpiod_to_irq(desc) >= 0 && (direction_may_change ||
848 !test_bit(FLAG_IS_OUT, &desc->flags))) {
849 status = device_create_file(dev, &dev_attr_edge);
850 if (status)
851 goto fail_unregister_device;
852 }
853
854 set_bit(FLAG_EXPORT, &desc->flags);
855 mutex_unlock(&sysfs_lock);
856 return 0;
857
858fail_unregister_device:
859 device_unregister(dev);
860fail_unlock:
861 mutex_unlock(&sysfs_lock);
862 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
863 return status;
864}
865EXPORT_SYMBOL_GPL(gpiod_export);
866
867static int match_export(struct device *dev, const void *data)
868{
869 return dev_get_drvdata(dev) == data;
870}
871
872/**
873 * gpiod_export_link - create a sysfs link to an exported GPIO node
874 * @dev: device under which to create symlink
875 * @name: name of the symlink
876 * @gpio: gpio to create symlink to, already exported
877 *
878 * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
879 * node. Caller is responsible for unlinking.
880 *
881 * Returns zero on success, else an error.
882 */
883int gpiod_export_link(struct device *dev, const char *name,
884 struct gpio_desc *desc)
885{
886 int status = -EINVAL;
887
888 if (!desc) {
889 pr_warn("%s: invalid GPIO\n", __func__);
890 return -EINVAL;
891 }
892
893 mutex_lock(&sysfs_lock);
894
895 if (test_bit(FLAG_EXPORT, &desc->flags)) {
896 struct device *tdev;
897
898 tdev = class_find_device(&gpio_class, NULL, desc, match_export);
899 if (tdev != NULL) {
900 status = sysfs_create_link(&dev->kobj, &tdev->kobj,
901 name);
902 } else {
903 status = -ENODEV;
904 }
905 }
906
907 mutex_unlock(&sysfs_lock);
908
909 if (status)
910 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
911
912 return status;
913}
914EXPORT_SYMBOL_GPL(gpiod_export_link);
915
916/**
917 * gpiod_sysfs_set_active_low - set the polarity of gpio sysfs value
918 * @gpio: gpio to change
919 * @value: non-zero to use active low, i.e. inverted values
920 *
921 * Set the polarity of /sys/class/gpio/gpioN/value sysfs attribute.
922 * The GPIO does not have to be exported yet. If poll(2) support has
923 * been enabled for either rising or falling edge, it will be
924 * reconfigured to follow the new polarity.
925 *
926 * Returns zero on success, else an error.
927 */
928int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
929{
930 struct device *dev = NULL;
931 int status = -EINVAL;
932
933 if (!desc) {
934 pr_warn("%s: invalid GPIO\n", __func__);
935 return -EINVAL;
936 }
937
938 mutex_lock(&sysfs_lock);
939
940 if (test_bit(FLAG_EXPORT, &desc->flags)) {
941 dev = class_find_device(&gpio_class, NULL, desc, match_export);
942 if (dev == NULL) {
943 status = -ENODEV;
944 goto unlock;
945 }
946 }
947
948 status = sysfs_set_active_low(desc, dev, value);
949
950unlock:
951 mutex_unlock(&sysfs_lock);
952
953 if (status)
954 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
955
956 return status;
957}
958EXPORT_SYMBOL_GPL(gpiod_sysfs_set_active_low);
959
960/**
961 * gpiod_unexport - reverse effect of gpio_export()
962 * @gpio: gpio to make unavailable
963 *
964 * This is implicit on gpio_free().
965 */
966void gpiod_unexport(struct gpio_desc *desc)
967{
968 int status = 0;
969 struct device *dev = NULL;
970
971 if (!desc) {
972 pr_warn("%s: invalid GPIO\n", __func__);
973 return;
974 }
975
976 mutex_lock(&sysfs_lock);
977
978 if (test_bit(FLAG_EXPORT, &desc->flags)) {
979
980 dev = class_find_device(&gpio_class, NULL, desc, match_export);
981 if (dev) {
982 gpio_setup_irq(desc, dev, 0);
983 clear_bit(FLAG_EXPORT, &desc->flags);
984 } else
985 status = -ENODEV;
986 }
987
988 mutex_unlock(&sysfs_lock);
989
990 if (dev) {
991 device_unregister(dev);
992 put_device(dev);
993 }
994
995 if (status)
996 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
997}
998EXPORT_SYMBOL_GPL(gpiod_unexport);
999
1000static int gpiochip_export(struct gpio_chip *chip)
1001{
1002 int status;
1003 struct device *dev;
1004
1005 /* Many systems register gpio chips for SOC support very early,
1006 * before driver model support is available. In those cases we
1007 * export this later, in gpiolib_sysfs_init() ... here we just
1008 * verify that _some_ field of gpio_class got initialized.
1009 */
1010 if (!gpio_class.p)
1011 return 0;
1012
1013 /* use chip->base for the ID; it's already known to be unique */
1014 mutex_lock(&sysfs_lock);
1015 dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
1016 "gpiochip%d", chip->base);
1017 if (!IS_ERR(dev)) {
1018 status = sysfs_create_group(&dev->kobj,
1019 &gpiochip_attr_group);
1020 } else
1021 status = PTR_ERR(dev);
1022 chip->exported = (status == 0);
1023 mutex_unlock(&sysfs_lock);
1024
1025 if (status) {
1026 unsigned long flags;
1027 unsigned gpio;
1028
1029 spin_lock_irqsave(&gpio_lock, flags);
1030 gpio = 0;
1031 while (gpio < chip->ngpio)
1032 chip->desc[gpio++].chip = NULL;
1033 spin_unlock_irqrestore(&gpio_lock, flags);
1034
1035 chip_dbg(chip, "%s: status %d\n", __func__, status);
1036 }
1037
1038 return status;
1039}
1040
1041static void gpiochip_unexport(struct gpio_chip *chip)
1042{
1043 int status;
1044 struct device *dev;
1045
1046 mutex_lock(&sysfs_lock);
1047 dev = class_find_device(&gpio_class, NULL, chip, match_export);
1048 if (dev) {
1049 put_device(dev);
1050 device_unregister(dev);
1051 chip->exported = false;
1052 status = 0;
1053 } else
1054 status = -ENODEV;
1055 mutex_unlock(&sysfs_lock);
1056
1057 if (status)
1058 chip_dbg(chip, "%s: status %d\n", __func__, status);
1059}
1060
1061static int __init gpiolib_sysfs_init(void)
1062{
1063 int status;
1064 unsigned long flags;
1065 struct gpio_chip *chip;
1066
1067 status = class_register(&gpio_class);
1068 if (status < 0)
1069 return status;
1070
1071 /* Scan and register the gpio_chips which registered very
1072 * early (e.g. before the class_register above was called).
1073 *
1074 * We run before arch_initcall() so chip->dev nodes can have
1075 * registered, and so arch_initcall() can always gpio_export().
1076 */
1077 spin_lock_irqsave(&gpio_lock, flags);
1078 list_for_each_entry(chip, &gpio_chips, list) {
1079 if (!chip || chip->exported)
1080 continue;
1081
1082 spin_unlock_irqrestore(&gpio_lock, flags);
1083 status = gpiochip_export(chip);
1084 spin_lock_irqsave(&gpio_lock, flags);
1085 }
1086 spin_unlock_irqrestore(&gpio_lock, flags);
1087
1088
1089 return status;
1090}
1091postcore_initcall(gpiolib_sysfs_init);
1092
1093#else
1094static inline int gpiochip_export(struct gpio_chip *chip)
1095{
1096 return 0;
1097}
1098
1099static inline void gpiochip_unexport(struct gpio_chip *chip)
1100{
1101}
1102
1103#endif /* CONFIG_GPIO_SYSFS */
1104
1105/* 202/*
1106 * Add a new chip to the global chips list, keeping the list of chips sorted 203 * Add a new chip to the global chips list, keeping the list of chips sorted
1107 * by base order. 204 * by base order.
@@ -1721,7 +818,7 @@ done:
1721 return status; 818 return status;
1722} 819}
1723 820
1724static int gpiod_request(struct gpio_desc *desc, const char *label) 821int gpiod_request(struct gpio_desc *desc, const char *label)
1725{ 822{
1726 int status = -EPROBE_DEFER; 823 int status = -EPROBE_DEFER;
1727 struct gpio_chip *chip; 824 struct gpio_chip *chip;
@@ -1786,7 +883,7 @@ static bool __gpiod_free(struct gpio_desc *desc)
1786 return ret; 883 return ret;
1787} 884}
1788 885
1789static void gpiod_free(struct gpio_desc *desc) 886void gpiod_free(struct gpio_desc *desc)
1790{ 887{
1791 if (desc && __gpiod_free(desc)) 888 if (desc && __gpiod_free(desc))
1792 module_put(desc->chip->owner); 889 module_put(desc->chip->owner);
diff --git a/drivers/gpio/gpiolib.h b/drivers/gpio/gpiolib.h
index 1a4103dd38df..98020c393eb3 100644
--- a/drivers/gpio/gpiolib.h
+++ b/drivers/gpio/gpiolib.h
@@ -51,4 +51,95 @@ void gpiochip_free_own_desc(struct gpio_desc *desc);
51struct gpio_desc *of_get_named_gpiod_flags(struct device_node *np, 51struct gpio_desc *of_get_named_gpiod_flags(struct device_node *np,
52 const char *list_name, int index, enum of_gpio_flags *flags); 52 const char *list_name, int index, enum of_gpio_flags *flags);
53 53
54extern struct spinlock gpio_lock;
55extern struct list_head gpio_chips;
56
57struct gpio_desc {
58 struct gpio_chip *chip;
59 unsigned long flags;
60/* flag symbols are bit numbers */
61#define FLAG_REQUESTED 0
62#define FLAG_IS_OUT 1
63#define FLAG_EXPORT 2 /* protected by sysfs_lock */
64#define FLAG_SYSFS 3 /* exported via /sys/class/gpio/control */
65#define FLAG_TRIG_FALL 4 /* trigger on falling edge */
66#define FLAG_TRIG_RISE 5 /* trigger on rising edge */
67#define FLAG_ACTIVE_LOW 6 /* value has active low */
68#define FLAG_OPEN_DRAIN 7 /* Gpio is open drain type */
69#define FLAG_OPEN_SOURCE 8 /* Gpio is open source type */
70#define FLAG_USED_AS_IRQ 9 /* GPIO is connected to an IRQ */
71
72#define ID_SHIFT 16 /* add new flags before this one */
73
74#define GPIO_FLAGS_MASK ((1 << ID_SHIFT) - 1)
75#define GPIO_TRIGGER_MASK (BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE))
76
77 const char *label;
78};
79
80int gpiod_request(struct gpio_desc *desc, const char *label);
81void gpiod_free(struct gpio_desc *desc);
82
83/*
84 * Return the GPIO number of the passed descriptor relative to its chip
85 */
86static int __maybe_unused gpio_chip_hwgpio(const struct gpio_desc *desc)
87{
88 return desc - &desc->chip->desc[0];
89}
90
91/* With descriptor prefix */
92
93#define gpiod_emerg(desc, fmt, ...) \
94 pr_emerg("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",\
95 ##__VA_ARGS__)
96#define gpiod_crit(desc, fmt, ...) \
97 pr_crit("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
98 ##__VA_ARGS__)
99#define gpiod_err(desc, fmt, ...) \
100 pr_err("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
101 ##__VA_ARGS__)
102#define gpiod_warn(desc, fmt, ...) \
103 pr_warn("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
104 ##__VA_ARGS__)
105#define gpiod_info(desc, fmt, ...) \
106 pr_info("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
107 ##__VA_ARGS__)
108#define gpiod_dbg(desc, fmt, ...) \
109 pr_debug("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",\
110 ##__VA_ARGS__)
111
112/* With chip prefix */
113
114#define chip_emerg(chip, fmt, ...) \
115 pr_emerg("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
116#define chip_crit(chip, fmt, ...) \
117 pr_crit("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
118#define chip_err(chip, fmt, ...) \
119 pr_err("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
120#define chip_warn(chip, fmt, ...) \
121 pr_warn("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
122#define chip_info(chip, fmt, ...) \
123 pr_info("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
124#define chip_dbg(chip, fmt, ...) \
125 pr_debug("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
126
127#ifdef CONFIG_GPIO_SYSFS
128
129int gpiochip_export(struct gpio_chip *chip);
130void gpiochip_unexport(struct gpio_chip *chip);
131
132#else
133
134static inline int gpiochip_export(struct gpio_chip *chip)
135{
136 return 0;
137}
138
139static inline void gpiochip_unexport(struct gpio_chip *chip)
140{
141}
142
143#endif /* CONFIG_GPIO_SYSFS */
144
54#endif /* GPIOLIB_H */ 145#endif /* GPIOLIB_H */
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-18 11:57:30 -0500