Merge branch 'sched-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6-microblaze.git] / drivers / gpio / gpiolib-sysfs.c
1 #include <linux/idr.h>
2 #include <linux/mutex.h>
3 #include <linux/device.h>
4 #include <linux/sysfs.h>
5 #include <linux/gpio.h>
6 #include <linux/gpio/consumer.h>
7 #include <linux/gpio/driver.h>
8 #include <linux/interrupt.h>
9 #include <linux/kdev_t.h>
10 #include <linux/slab.h>
11 #include <linux/ctype.h>
12
13 #include "gpiolib.h"
14
15 #define GPIO_IRQF_TRIGGER_FALLING       BIT(0)
16 #define GPIO_IRQF_TRIGGER_RISING        BIT(1)
17 #define GPIO_IRQF_TRIGGER_BOTH          (GPIO_IRQF_TRIGGER_FALLING | \
18                                          GPIO_IRQF_TRIGGER_RISING)
19
20 struct gpiod_data {
21         struct gpio_desc *desc;
22
23         struct mutex mutex;
24         struct kernfs_node *value_kn;
25         int irq;
26         unsigned char irq_flags;
27
28         bool direction_can_change;
29 };
30
31 /*
32  * Lock to serialise gpiod export and unexport, and prevent re-export of
33  * gpiod whose chip is being unregistered.
34  */
35 static DEFINE_MUTEX(sysfs_lock);
36
37 /*
38  * /sys/class/gpio/gpioN... only for GPIOs that are exported
39  *   /direction
40  *      * MAY BE OMITTED if kernel won't allow direction changes
41  *      * is read/write as "in" or "out"
42  *      * may also be written as "high" or "low", initializing
43  *        output value as specified ("out" implies "low")
44  *   /value
45  *      * always readable, subject to hardware behavior
46  *      * may be writable, as zero/nonzero
47  *   /edge
48  *      * configures behavior of poll(2) on /value
49  *      * available only if pin can generate IRQs on input
50  *      * is read/write as "none", "falling", "rising", or "both"
51  *   /active_low
52  *      * configures polarity of /value
53  *      * is read/write as zero/nonzero
54  *      * also affects existing and subsequent "falling" and "rising"
55  *        /edge configuration
56  */
57
58 static ssize_t direction_show(struct device *dev,
59                 struct device_attribute *attr, char *buf)
60 {
61         struct gpiod_data *data = dev_get_drvdata(dev);
62         struct gpio_desc *desc = data->desc;
63         ssize_t                 status;
64
65         mutex_lock(&data->mutex);
66
67         gpiod_get_direction(desc);
68         status = sprintf(buf, "%s\n",
69                         test_bit(FLAG_IS_OUT, &desc->flags)
70                                 ? "out" : "in");
71
72         mutex_unlock(&data->mutex);
73
74         return status;
75 }
76
77 static ssize_t direction_store(struct device *dev,
78                 struct device_attribute *attr, const char *buf, size_t size)
79 {
80         struct gpiod_data *data = dev_get_drvdata(dev);
81         struct gpio_desc *desc = data->desc;
82         ssize_t                 status;
83
84         mutex_lock(&data->mutex);
85
86         if (sysfs_streq(buf, "high"))
87                 status = gpiod_direction_output_raw(desc, 1);
88         else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
89                 status = gpiod_direction_output_raw(desc, 0);
90         else if (sysfs_streq(buf, "in"))
91                 status = gpiod_direction_input(desc);
92         else
93                 status = -EINVAL;
94
95         mutex_unlock(&data->mutex);
96
97         return status ? : size;
98 }
99 static DEVICE_ATTR_RW(direction);
100
101 static ssize_t value_show(struct device *dev,
102                 struct device_attribute *attr, char *buf)
103 {
104         struct gpiod_data *data = dev_get_drvdata(dev);
105         struct gpio_desc *desc = data->desc;
106         ssize_t                 status;
107
108         mutex_lock(&data->mutex);
109
110         status = gpiod_get_value_cansleep(desc);
111         if (status < 0)
112                 goto err;
113
114         buf[0] = '0' + status;
115         buf[1] = '\n';
116         status = 2;
117 err:
118         mutex_unlock(&data->mutex);
119
120         return status;
121 }
122
123 static ssize_t value_store(struct device *dev,
124                 struct device_attribute *attr, const char *buf, size_t size)
125 {
126         struct gpiod_data *data = dev_get_drvdata(dev);
127         struct gpio_desc *desc = data->desc;
128         ssize_t status = 0;
129
130         mutex_lock(&data->mutex);
131
132         if (!test_bit(FLAG_IS_OUT, &desc->flags)) {
133                 status = -EPERM;
134         } else {
135                 long            value;
136
137                 if (size <= 2 && isdigit(buf[0]) &&
138                     (size == 1 || buf[1] == '\n'))
139                         value = buf[0] - '0';
140                 else
141                         status = kstrtol(buf, 0, &value);
142                 if (status == 0) {
143                         gpiod_set_value_cansleep(desc, value);
144                         status = size;
145                 }
146         }
147
148         mutex_unlock(&data->mutex);
149
150         return status;
151 }
152 static DEVICE_ATTR_PREALLOC(value, S_IWUSR | S_IRUGO, value_show, value_store);
153
154 static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
155 {
156         struct gpiod_data *data = priv;
157
158         sysfs_notify_dirent(data->value_kn);
159
160         return IRQ_HANDLED;
161 }
162
163 /* Caller holds gpiod-data mutex. */
164 static int gpio_sysfs_request_irq(struct device *dev, unsigned char flags)
165 {
166         struct gpiod_data       *data = dev_get_drvdata(dev);
167         struct gpio_desc        *desc = data->desc;
168         unsigned long           irq_flags;
169         int                     ret;
170
171         data->irq = gpiod_to_irq(desc);
172         if (data->irq < 0)
173                 return -EIO;
174
175         data->value_kn = sysfs_get_dirent(dev->kobj.sd, "value");
176         if (!data->value_kn)
177                 return -ENODEV;
178
179         irq_flags = IRQF_SHARED;
180         if (flags & GPIO_IRQF_TRIGGER_FALLING)
181                 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
182                         IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
183         if (flags & GPIO_IRQF_TRIGGER_RISING)
184                 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
185                         IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
186
187         /*
188          * FIXME: This should be done in the irq_request_resources callback
189          *        when the irq is requested, but a few drivers currently fail
190          *        to do so.
191          *
192          *        Remove this redundant call (along with the corresponding
193          *        unlock) when those drivers have been fixed.
194          */
195         ret = gpiochip_lock_as_irq(desc->gdev->chip, gpio_chip_hwgpio(desc));
196         if (ret < 0)
197                 goto err_put_kn;
198
199         ret = request_any_context_irq(data->irq, gpio_sysfs_irq, irq_flags,
200                                 "gpiolib", data);
201         if (ret < 0)
202                 goto err_unlock;
203
204         data->irq_flags = flags;
205
206         return 0;
207
208 err_unlock:
209         gpiochip_unlock_as_irq(desc->gdev->chip, gpio_chip_hwgpio(desc));
210 err_put_kn:
211         sysfs_put(data->value_kn);
212
213         return ret;
214 }
215
216 /*
217  * Caller holds gpiod-data mutex (unless called after class-device
218  * deregistration).
219  */
220 static void gpio_sysfs_free_irq(struct device *dev)
221 {
222         struct gpiod_data *data = dev_get_drvdata(dev);
223         struct gpio_desc *desc = data->desc;
224
225         data->irq_flags = 0;
226         free_irq(data->irq, data);
227         gpiochip_unlock_as_irq(desc->gdev->chip, gpio_chip_hwgpio(desc));
228         sysfs_put(data->value_kn);
229 }
230
231 static const struct {
232         const char *name;
233         unsigned char flags;
234 } trigger_types[] = {
235         { "none",    0 },
236         { "falling", GPIO_IRQF_TRIGGER_FALLING },
237         { "rising",  GPIO_IRQF_TRIGGER_RISING },
238         { "both",    GPIO_IRQF_TRIGGER_BOTH },
239 };
240
241 static ssize_t edge_show(struct device *dev,
242                 struct device_attribute *attr, char *buf)
243 {
244         struct gpiod_data *data = dev_get_drvdata(dev);
245         ssize_t status = 0;
246         int i;
247
248         mutex_lock(&data->mutex);
249
250         for (i = 0; i < ARRAY_SIZE(trigger_types); i++) {
251                 if (data->irq_flags == trigger_types[i].flags) {
252                         status = sprintf(buf, "%s\n", trigger_types[i].name);
253                         break;
254                 }
255         }
256
257         mutex_unlock(&data->mutex);
258
259         return status;
260 }
261
262 static ssize_t edge_store(struct device *dev,
263                 struct device_attribute *attr, const char *buf, size_t size)
264 {
265         struct gpiod_data *data = dev_get_drvdata(dev);
266         unsigned char flags;
267         ssize_t status = size;
268         int i;
269
270         for (i = 0; i < ARRAY_SIZE(trigger_types); i++) {
271                 if (sysfs_streq(trigger_types[i].name, buf))
272                         break;
273         }
274
275         if (i == ARRAY_SIZE(trigger_types))
276                 return -EINVAL;
277
278         flags = trigger_types[i].flags;
279
280         mutex_lock(&data->mutex);
281
282         if (flags == data->irq_flags) {
283                 status = size;
284                 goto out_unlock;
285         }
286
287         if (data->irq_flags)
288                 gpio_sysfs_free_irq(dev);
289
290         if (flags) {
291                 status = gpio_sysfs_request_irq(dev, flags);
292                 if (!status)
293                         status = size;
294         }
295
296 out_unlock:
297         mutex_unlock(&data->mutex);
298
299         return status;
300 }
301 static DEVICE_ATTR_RW(edge);
302
303 /* Caller holds gpiod-data mutex. */
304 static int gpio_sysfs_set_active_low(struct device *dev, int value)
305 {
306         struct gpiod_data       *data = dev_get_drvdata(dev);
307         struct gpio_desc        *desc = data->desc;
308         int                     status = 0;
309         unsigned int            flags = data->irq_flags;
310
311         if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value)
312                 return 0;
313
314         if (value)
315                 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
316         else
317                 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
318
319         /* reconfigure poll(2) support if enabled on one edge only */
320         if (flags == GPIO_IRQF_TRIGGER_FALLING ||
321                                         flags == GPIO_IRQF_TRIGGER_RISING) {
322                 gpio_sysfs_free_irq(dev);
323                 status = gpio_sysfs_request_irq(dev, flags);
324         }
325
326         return status;
327 }
328
329 static ssize_t active_low_show(struct device *dev,
330                 struct device_attribute *attr, char *buf)
331 {
332         struct gpiod_data *data = dev_get_drvdata(dev);
333         struct gpio_desc *desc = data->desc;
334         ssize_t                 status;
335
336         mutex_lock(&data->mutex);
337
338         status = sprintf(buf, "%d\n",
339                                 !!test_bit(FLAG_ACTIVE_LOW, &desc->flags));
340
341         mutex_unlock(&data->mutex);
342
343         return status;
344 }
345
346 static ssize_t active_low_store(struct device *dev,
347                 struct device_attribute *attr, const char *buf, size_t size)
348 {
349         struct gpiod_data       *data = dev_get_drvdata(dev);
350         ssize_t                 status;
351         long                    value;
352
353         mutex_lock(&data->mutex);
354
355         status = kstrtol(buf, 0, &value);
356         if (status == 0)
357                 status = gpio_sysfs_set_active_low(dev, value);
358
359         mutex_unlock(&data->mutex);
360
361         return status ? : size;
362 }
363 static DEVICE_ATTR_RW(active_low);
364
365 static umode_t gpio_is_visible(struct kobject *kobj, struct attribute *attr,
366                                int n)
367 {
368         struct device *dev = container_of(kobj, struct device, kobj);
369         struct gpiod_data *data = dev_get_drvdata(dev);
370         struct gpio_desc *desc = data->desc;
371         umode_t mode = attr->mode;
372         bool show_direction = data->direction_can_change;
373
374         if (attr == &dev_attr_direction.attr) {
375                 if (!show_direction)
376                         mode = 0;
377         } else if (attr == &dev_attr_edge.attr) {
378                 if (gpiod_to_irq(desc) < 0)
379                         mode = 0;
380                 if (!show_direction && test_bit(FLAG_IS_OUT, &desc->flags))
381                         mode = 0;
382         }
383
384         return mode;
385 }
386
387 static struct attribute *gpio_attrs[] = {
388         &dev_attr_direction.attr,
389         &dev_attr_edge.attr,
390         &dev_attr_value.attr,
391         &dev_attr_active_low.attr,
392         NULL,
393 };
394
395 static const struct attribute_group gpio_group = {
396         .attrs = gpio_attrs,
397         .is_visible = gpio_is_visible,
398 };
399
400 static const struct attribute_group *gpio_groups[] = {
401         &gpio_group,
402         NULL
403 };
404
405 /*
406  * /sys/class/gpio/gpiochipN/
407  *   /base ... matching gpio_chip.base (N)
408  *   /label ... matching gpio_chip.label
409  *   /ngpio ... matching gpio_chip.ngpio
410  */
411
412 static ssize_t base_show(struct device *dev,
413                                struct device_attribute *attr, char *buf)
414 {
415         const struct gpio_chip  *chip = dev_get_drvdata(dev);
416
417         return sprintf(buf, "%d\n", chip->base);
418 }
419 static DEVICE_ATTR_RO(base);
420
421 static ssize_t label_show(struct device *dev,
422                                struct device_attribute *attr, char *buf)
423 {
424         const struct gpio_chip  *chip = dev_get_drvdata(dev);
425
426         return sprintf(buf, "%s\n", chip->label ? : "");
427 }
428 static DEVICE_ATTR_RO(label);
429
430 static ssize_t ngpio_show(struct device *dev,
431                                struct device_attribute *attr, char *buf)
432 {
433         const struct gpio_chip  *chip = dev_get_drvdata(dev);
434
435         return sprintf(buf, "%u\n", chip->ngpio);
436 }
437 static DEVICE_ATTR_RO(ngpio);
438
439 static struct attribute *gpiochip_attrs[] = {
440         &dev_attr_base.attr,
441         &dev_attr_label.attr,
442         &dev_attr_ngpio.attr,
443         NULL,
444 };
445 ATTRIBUTE_GROUPS(gpiochip);
446
447 static struct gpio_desc *gpio_to_valid_desc(int gpio)
448 {
449         return gpio_is_valid(gpio) ? gpio_to_desc(gpio) : NULL;
450 }
451
452 /*
453  * /sys/class/gpio/export ... write-only
454  *      integer N ... number of GPIO to export (full access)
455  * /sys/class/gpio/unexport ... write-only
456  *      integer N ... number of GPIO to unexport
457  */
458 static ssize_t export_store(struct class *class,
459                                 struct class_attribute *attr,
460                                 const char *buf, size_t len)
461 {
462         long                    gpio;
463         struct gpio_desc        *desc;
464         int                     status;
465
466         status = kstrtol(buf, 0, &gpio);
467         if (status < 0)
468                 goto done;
469
470         desc = gpio_to_valid_desc(gpio);
471         /* reject invalid GPIOs */
472         if (!desc) {
473                 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
474                 return -EINVAL;
475         }
476
477         /* No extra locking here; FLAG_SYSFS just signifies that the
478          * request and export were done by on behalf of userspace, so
479          * they may be undone on its behalf too.
480          */
481
482         status = gpiod_request(desc, "sysfs");
483         if (status < 0) {
484                 if (status == -EPROBE_DEFER)
485                         status = -ENODEV;
486                 goto done;
487         }
488
489         status = gpiod_set_transitory(desc, false);
490         if (!status) {
491                 status = gpiod_export(desc, true);
492                 if (status < 0)
493                         gpiod_free(desc);
494                 else
495                         set_bit(FLAG_SYSFS, &desc->flags);
496         }
497
498 done:
499         if (status)
500                 pr_debug("%s: status %d\n", __func__, status);
501         return status ? : len;
502 }
503 static CLASS_ATTR_WO(export);
504
505 static ssize_t unexport_store(struct class *class,
506                                 struct class_attribute *attr,
507                                 const char *buf, size_t len)
508 {
509         long                    gpio;
510         struct gpio_desc        *desc;
511         int                     status;
512
513         status = kstrtol(buf, 0, &gpio);
514         if (status < 0)
515                 goto done;
516
517         desc = gpio_to_valid_desc(gpio);
518         /* reject bogus commands (gpio_unexport ignores them) */
519         if (!desc) {
520                 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
521                 return -EINVAL;
522         }
523
524         status = -EINVAL;
525
526         /* No extra locking here; FLAG_SYSFS just signifies that the
527          * request and export were done by on behalf of userspace, so
528          * they may be undone on its behalf too.
529          */
530         if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
531                 status = 0;
532                 gpiod_free(desc);
533         }
534 done:
535         if (status)
536                 pr_debug("%s: status %d\n", __func__, status);
537         return status ? : len;
538 }
539 static CLASS_ATTR_WO(unexport);
540
541 static struct attribute *gpio_class_attrs[] = {
542         &class_attr_export.attr,
543         &class_attr_unexport.attr,
544         NULL,
545 };
546 ATTRIBUTE_GROUPS(gpio_class);
547
548 static struct class gpio_class = {
549         .name =         "gpio",
550         .owner =        THIS_MODULE,
551
552         .class_groups = gpio_class_groups,
553 };
554
555
556 /**
557  * gpiod_export - export a GPIO through sysfs
558  * @desc: GPIO to make available, already requested
559  * @direction_may_change: true if userspace may change GPIO direction
560  * Context: arch_initcall or later
561  *
562  * When drivers want to make a GPIO accessible to userspace after they
563  * have requested it -- perhaps while debugging, or as part of their
564  * public interface -- they may use this routine.  If the GPIO can
565  * change direction (some can't) and the caller allows it, userspace
566  * will see "direction" sysfs attribute which may be used to change
567  * the gpio's direction.  A "value" attribute will always be provided.
568  *
569  * Returns zero on success, else an error.
570  */
571 int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
572 {
573         struct gpio_chip        *chip;
574         struct gpio_device      *gdev;
575         struct gpiod_data       *data;
576         unsigned long           flags;
577         int                     status;
578         const char              *ioname = NULL;
579         struct device           *dev;
580         int                     offset;
581
582         /* can't export until sysfs is available ... */
583         if (!gpio_class.p) {
584                 pr_debug("%s: called too early!\n", __func__);
585                 return -ENOENT;
586         }
587
588         if (!desc) {
589                 pr_debug("%s: invalid gpio descriptor\n", __func__);
590                 return -EINVAL;
591         }
592
593         gdev = desc->gdev;
594         chip = gdev->chip;
595
596         mutex_lock(&sysfs_lock);
597
598         /* check if chip is being removed */
599         if (!chip || !gdev->mockdev) {
600                 status = -ENODEV;
601                 goto err_unlock;
602         }
603
604         spin_lock_irqsave(&gpio_lock, flags);
605         if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
606              test_bit(FLAG_EXPORT, &desc->flags)) {
607                 spin_unlock_irqrestore(&gpio_lock, flags);
608                 gpiod_dbg(desc, "%s: unavailable (requested=%d, exported=%d)\n",
609                                 __func__,
610                                 test_bit(FLAG_REQUESTED, &desc->flags),
611                                 test_bit(FLAG_EXPORT, &desc->flags));
612                 status = -EPERM;
613                 goto err_unlock;
614         }
615         spin_unlock_irqrestore(&gpio_lock, flags);
616
617         data = kzalloc(sizeof(*data), GFP_KERNEL);
618         if (!data) {
619                 status = -ENOMEM;
620                 goto err_unlock;
621         }
622
623         data->desc = desc;
624         mutex_init(&data->mutex);
625         if (chip->direction_input && chip->direction_output)
626                 data->direction_can_change = direction_may_change;
627         else
628                 data->direction_can_change = false;
629
630         offset = gpio_chip_hwgpio(desc);
631         if (chip->names && chip->names[offset])
632                 ioname = chip->names[offset];
633
634         dev = device_create_with_groups(&gpio_class, &gdev->dev,
635                                         MKDEV(0, 0), data, gpio_groups,
636                                         ioname ? ioname : "gpio%u",
637                                         desc_to_gpio(desc));
638         if (IS_ERR(dev)) {
639                 status = PTR_ERR(dev);
640                 goto err_free_data;
641         }
642
643         set_bit(FLAG_EXPORT, &desc->flags);
644         mutex_unlock(&sysfs_lock);
645         return 0;
646
647 err_free_data:
648         kfree(data);
649 err_unlock:
650         mutex_unlock(&sysfs_lock);
651         gpiod_dbg(desc, "%s: status %d\n", __func__, status);
652         return status;
653 }
654 EXPORT_SYMBOL_GPL(gpiod_export);
655
656 static int match_export(struct device *dev, const void *desc)
657 {
658         struct gpiod_data *data = dev_get_drvdata(dev);
659
660         return data->desc == desc;
661 }
662
663 /**
664  * gpiod_export_link - create a sysfs link to an exported GPIO node
665  * @dev: device under which to create symlink
666  * @name: name of the symlink
667  * @desc: GPIO to create symlink to, already exported
668  *
669  * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
670  * node. Caller is responsible for unlinking.
671  *
672  * Returns zero on success, else an error.
673  */
674 int gpiod_export_link(struct device *dev, const char *name,
675                       struct gpio_desc *desc)
676 {
677         struct device *cdev;
678         int ret;
679
680         if (!desc) {
681                 pr_warn("%s: invalid GPIO\n", __func__);
682                 return -EINVAL;
683         }
684
685         cdev = class_find_device(&gpio_class, NULL, desc, match_export);
686         if (!cdev)
687                 return -ENODEV;
688
689         ret = sysfs_create_link(&dev->kobj, &cdev->kobj, name);
690         put_device(cdev);
691
692         return ret;
693 }
694 EXPORT_SYMBOL_GPL(gpiod_export_link);
695
696 /**
697  * gpiod_unexport - reverse effect of gpiod_export()
698  * @desc: GPIO to make unavailable
699  *
700  * This is implicit on gpiod_free().
701  */
702 void gpiod_unexport(struct gpio_desc *desc)
703 {
704         struct gpiod_data *data;
705         struct device *dev;
706
707         if (!desc) {
708                 pr_warn("%s: invalid GPIO\n", __func__);
709                 return;
710         }
711
712         mutex_lock(&sysfs_lock);
713
714         if (!test_bit(FLAG_EXPORT, &desc->flags))
715                 goto err_unlock;
716
717         dev = class_find_device(&gpio_class, NULL, desc, match_export);
718         if (!dev)
719                 goto err_unlock;
720
721         data = dev_get_drvdata(dev);
722
723         clear_bit(FLAG_EXPORT, &desc->flags);
724
725         device_unregister(dev);
726
727         /*
728          * Release irq after deregistration to prevent race with edge_store.
729          */
730         if (data->irq_flags)
731                 gpio_sysfs_free_irq(dev);
732
733         mutex_unlock(&sysfs_lock);
734
735         put_device(dev);
736         kfree(data);
737
738         return;
739
740 err_unlock:
741         mutex_unlock(&sysfs_lock);
742 }
743 EXPORT_SYMBOL_GPL(gpiod_unexport);
744
745 int gpiochip_sysfs_register(struct gpio_device *gdev)
746 {
747         struct device   *dev;
748         struct device   *parent;
749         struct gpio_chip *chip = gdev->chip;
750
751         /*
752          * Many systems add gpio chips for SOC support very early,
753          * before driver model support is available.  In those cases we
754          * register later, in gpiolib_sysfs_init() ... here we just
755          * verify that _some_ field of gpio_class got initialized.
756          */
757         if (!gpio_class.p)
758                 return 0;
759
760         /*
761          * For sysfs backward compatibility we need to preserve this
762          * preferred parenting to the gpio_chip parent field, if set.
763          */
764         if (chip->parent)
765                 parent = chip->parent;
766         else
767                 parent = &gdev->dev;
768
769         /* use chip->base for the ID; it's already known to be unique */
770         dev = device_create_with_groups(&gpio_class, parent,
771                                         MKDEV(0, 0),
772                                         chip, gpiochip_groups,
773                                         "gpiochip%d", chip->base);
774         if (IS_ERR(dev))
775                 return PTR_ERR(dev);
776
777         mutex_lock(&sysfs_lock);
778         gdev->mockdev = dev;
779         mutex_unlock(&sysfs_lock);
780
781         return 0;
782 }
783
784 void gpiochip_sysfs_unregister(struct gpio_device *gdev)
785 {
786         struct gpio_desc *desc;
787         struct gpio_chip *chip = gdev->chip;
788         unsigned int i;
789
790         if (!gdev->mockdev)
791                 return;
792
793         device_unregister(gdev->mockdev);
794
795         /* prevent further gpiod exports */
796         mutex_lock(&sysfs_lock);
797         gdev->mockdev = NULL;
798         mutex_unlock(&sysfs_lock);
799
800         /* unregister gpiod class devices owned by sysfs */
801         for (i = 0; i < chip->ngpio; i++) {
802                 desc = &gdev->descs[i];
803                 if (test_and_clear_bit(FLAG_SYSFS, &desc->flags))
804                         gpiod_free(desc);
805         }
806 }
807
808 static int __init gpiolib_sysfs_init(void)
809 {
810         int             status;
811         unsigned long   flags;
812         struct gpio_device *gdev;
813
814         status = class_register(&gpio_class);
815         if (status < 0)
816                 return status;
817
818         /* Scan and register the gpio_chips which registered very
819          * early (e.g. before the class_register above was called).
820          *
821          * We run before arch_initcall() so chip->dev nodes can have
822          * registered, and so arch_initcall() can always gpio_export().
823          */
824         spin_lock_irqsave(&gpio_lock, flags);
825         list_for_each_entry(gdev, &gpio_devices, list) {
826                 if (gdev->mockdev)
827                         continue;
828
829                 /*
830                  * TODO we yield gpio_lock here because
831                  * gpiochip_sysfs_register() acquires a mutex. This is unsafe
832                  * and needs to be fixed.
833                  *
834                  * Also it would be nice to use gpiochip_find() here so we
835                  * can keep gpio_chips local to gpiolib.c, but the yield of
836                  * gpio_lock prevents us from doing this.
837                  */
838                 spin_unlock_irqrestore(&gpio_lock, flags);
839                 status = gpiochip_sysfs_register(gdev);
840                 spin_lock_irqsave(&gpio_lock, flags);
841         }
842         spin_unlock_irqrestore(&gpio_lock, flags);
843
844         return status;
845 }
846 postcore_initcall(gpiolib_sysfs_init);