Fix circular locking dependency (3.3-rc2)

[pandora-kernel.git] / drivers / gpio / gpiolib.c

diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index a971e3d..64e1950 100644 (file)
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -587,16 +587,13 @@ static ssize_t chip_ngpio_show(struct device *dev,
 }
 static DEVICE_ATTR(ngpio, 0444, chip_ngpio_show, NULL);
 
-static const struct attribute *gpiochip_attrs[] = {
+static struct attribute *gpiochip_attrs[] = {
        &dev_attr_base.attr,
        &dev_attr_label.attr,
        &dev_attr_ngpio.attr,
        NULL,
 };
-
-static const struct attribute_group gpiochip_attr_group = {
-       .attrs = (struct attribute **) gpiochip_attrs,
-};
+ATTRIBUTE_GROUPS(gpiochip);
 
 /*
  * /sys/class/gpio/export ... write-only
@@ -700,8 +697,9 @@ int gpio_export(unsigned gpio, bool direction_may_change)
 {
        unsigned long           flags;
        struct gpio_desc        *desc;
-       int                     status = -EINVAL;
+       int                     status;
        const char              *ioname = NULL;
+       struct device           *dev;
 
        /* can't export until sysfs is available ... */
        if (!gpio_class.p) {
@@ -709,59 +707,65 @@ int gpio_export(unsigned gpio, bool direction_may_change)
                return -ENOENT;
        }
 
-       if (!gpio_is_valid(gpio))
-               goto done;
+       if (!gpio_is_valid(gpio)) {
+               pr_debug("%s: gpio %d is not valid\n", __func__, gpio);
+               return -EINVAL;
+       }
 
        mutex_lock(&sysfs_lock);
 
        spin_lock_irqsave(&gpio_lock, flags);
        desc = &gpio_desc[gpio];
-       if (test_bit(FLAG_REQUESTED, &desc->flags)
-                       && !test_bit(FLAG_EXPORT, &desc->flags)) {
-               status = 0;
-               if (!desc->chip->direction_input
-                               || !desc->chip->direction_output)
-                       direction_may_change = false;
+       if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
+            test_bit(FLAG_EXPORT, &desc->flags)) {
+               spin_unlock_irqrestore(&gpio_lock, flags);
+               pr_debug("%s: gpio %d unavailable (requested=%d, exported=%d)\n",
+                               __func__, gpio,
+                               test_bit(FLAG_REQUESTED, &desc->flags),
+                               test_bit(FLAG_EXPORT, &desc->flags));
+               return -EPERM;
        }
+
+       if (!desc->chip->direction_input || !desc->chip->direction_output)
+               direction_may_change = false;
        spin_unlock_irqrestore(&gpio_lock, flags);
 
        if (desc->chip->names && desc->chip->names[gpio - desc->chip->base])
                ioname = desc->chip->names[gpio - desc->chip->base];
 
-       if (status == 0) {
-               struct device   *dev;
-
-               dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
-                               desc, ioname ? ioname : "gpio%u", gpio);
-               if (!IS_ERR(dev)) {
-                       status = sysfs_create_group(&dev->kobj,
-                                               &gpio_attr_group);
-
-                       if (!status && direction_may_change)
-                               status = device_create_file(dev,
-                                               &dev_attr_direction);
-
-                       if (!status && gpio_to_irq(gpio) >= 0
-                                       && (direction_may_change
-                                               || !test_bit(FLAG_IS_OUT,
-                                                       &desc->flags)))
-                               status = device_create_file(dev,
-                                               &dev_attr_edge);
-
-                       if (status != 0)
-                               device_unregister(dev);
-               } else
-                       status = PTR_ERR(dev);
-               if (status == 0)
-                       set_bit(FLAG_EXPORT, &desc->flags);
+       dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
+                           desc, ioname ? ioname : "gpio%u", gpio);
+       if (IS_ERR(dev)) {
+               status = PTR_ERR(dev);
+               goto fail_unlock;
        }
 
-       mutex_unlock(&sysfs_lock);
-
-done:
+       status = sysfs_create_group(&dev->kobj, &gpio_attr_group);
        if (status)
-               pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
+               goto fail_unregister_device;
 
+       if (direction_may_change) {
+               status = device_create_file(dev, &dev_attr_direction);
+               if (status)
+                       goto fail_unregister_device;
+       }
+
+       if (gpio_to_irq(gpio) >= 0 && (direction_may_change ||
+                                      !test_bit(FLAG_IS_OUT, &desc->flags))) {
+               status = device_create_file(dev, &dev_attr_edge);
+               if (status)
+                       goto fail_unregister_device;
+       }
+
+       set_bit(FLAG_EXPORT, &desc->flags);
+       mutex_unlock(&sysfs_lock);
+       return 0;
+
+fail_unregister_device:
+       device_unregister(dev);
+fail_unlock:
+       mutex_unlock(&sysfs_lock);
+       pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
        return status;
 }
 EXPORT_SYMBOL_GPL(gpio_export);
@@ -873,6 +877,7 @@ void gpio_unexport(unsigned gpio)
 {
        struct gpio_desc        *desc;
        int                     status = 0;
+       struct device           *dev = NULL;
 
        if (!gpio_is_valid(gpio)) {
                status = -EINVAL;
@@ -884,19 +889,20 @@ void gpio_unexport(unsigned gpio)
        desc = &gpio_desc[gpio];
 
        if (test_bit(FLAG_EXPORT, &desc->flags)) {
-               struct device   *dev = NULL;
 
                dev = class_find_device(&gpio_class, NULL, desc, match_export);
                if (dev) {
                        gpio_setup_irq(desc, dev, 0);
                        clear_bit(FLAG_EXPORT, &desc->flags);
-                       put_device(dev);
-                       device_unregister(dev);
                } else
                        status = -ENODEV;
        }
 
        mutex_unlock(&sysfs_lock);
+       if (dev) {
+               device_unregister(dev);
+               put_device(dev);
+       }
 done:
        if (status)
                pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
@@ -918,13 +924,13 @@ static int gpiochip_export(struct gpio_chip *chip)
 
        /* use chip->base for the ID; it's already known to be unique */
        mutex_lock(&sysfs_lock);
-       dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
-                               "gpiochip%d", chip->base);
-       if (!IS_ERR(dev)) {
-               status = sysfs_create_group(&dev->kobj,
-                               &gpiochip_attr_group);
-       } else
+       dev = device_create_with_groups(&gpio_class, chip->dev, MKDEV(0, 0),
+                                       chip, gpiochip_groups,
+                                       "gpiochip%d", chip->base);
+       if (IS_ERR(dev))
                status = PTR_ERR(dev);
+       else
+               status = 0;
        chip->exported = (status == 0);
        mutex_unlock(&sysfs_lock);
 
@@ -1075,9 +1081,9 @@ int gpiochip_add(struct gpio_chip *chip)
                                ? (1 << FLAG_IS_OUT)
                                : 0;
                }
-       }
 
-       of_gpiochip_add(chip);
+               of_gpiochip_add(chip);
+       }
 
 unlock:
        spin_unlock_irqrestore(&gpio_lock, flags);
@@ -1086,8 +1092,10 @@ unlock:
                goto fail;
 
        status = gpiochip_export(chip);
-       if (status)
+       if (status) {
+               of_gpiochip_remove(chip);
                goto fail;
+       }
 
        return 0;
 fail: