aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
authorAlexandre Courbot <acourbot@nvidia.com>2014-07-01 01:45:15 -0400
committerLinus Walleij <linus.walleij@linaro.org>2014-07-09 06:22:57 -0400
commit0eb4c6c2671ca05e447811041c838e2a6bc2a1f4 (patch)
tree8edc2ff6a011aaaa304bcd769ef889f1e1a04fe8 /drivers
parent9c8318ff7041c8024e3afa22ce77e208138f1da5 (diff)
gpio: move sysfs support to its own file
sysfs support is currently entangled within the core GPIO support, while it should relly just be a (privileged) user of the integer GPIO API. This patch is a first step towards making the gpiolib code more readable by splitting it into logical parts. Move all sysfs support to their own source file, and share static members of gpiolib that need to be in the private gpiolib.h file. In the future we will want to put some of them back into gpiolib.c, but this first patch let us at least identify them. Signed-off-by: Alexandre Courbot <acourbot@nvidia.com> Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
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 2024-11-26 17:01:39 -0500