Merge tag 'gpio-for-linus' of git://git.secretlab.ca/git/linux
[~shefty/rdma-dev.git] / drivers / gpio / gpiolib.c
index 5359ca7..4828fe7 100644 (file)
@@ -3,6 +3,7 @@
 #include <linux/interrupt.h>
 #include <linux/irq.h>
 #include <linux/spinlock.h>
+#include <linux/list.h>
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/debugfs.h>
@@ -52,14 +53,13 @@ struct gpio_desc {
 /* flag symbols are bit numbers */
 #define FLAG_REQUESTED 0
 #define FLAG_IS_OUT    1
-#define FLAG_RESERVED  2
-#define FLAG_EXPORT    3       /* protected by sysfs_lock */
-#define FLAG_SYSFS     4       /* exported via /sys/class/gpio/control */
-#define FLAG_TRIG_FALL 5       /* trigger on falling edge */
-#define FLAG_TRIG_RISE 6       /* trigger on rising edge */
-#define FLAG_ACTIVE_LOW        7       /* sysfs value has active low */
-#define FLAG_OPEN_DRAIN        8       /* Gpio is open drain type */
-#define FLAG_OPEN_SOURCE 9     /* Gpio is open source type */
+#define FLAG_EXPORT    2       /* protected by sysfs_lock */
+#define FLAG_SYSFS     3       /* exported via /sys/class/gpio/control */
+#define FLAG_TRIG_FALL 4       /* trigger on falling edge */
+#define FLAG_TRIG_RISE 5       /* trigger on rising edge */
+#define FLAG_ACTIVE_LOW        6       /* sysfs value has active low */
+#define FLAG_OPEN_DRAIN        7       /* Gpio is open drain type */
+#define FLAG_OPEN_SOURCE 8     /* Gpio is open source type */
 
 #define ID_SHIFT       16      /* add new flags before this one */
 
@@ -72,10 +72,36 @@ struct gpio_desc {
 };
 static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];
 
+#define GPIO_OFFSET_VALID(chip, offset) (offset >= 0 && offset < chip->ngpio)
+
+static LIST_HEAD(gpio_chips);
+
 #ifdef CONFIG_GPIO_SYSFS
 static DEFINE_IDR(dirent_idr);
 #endif
 
+/*
+ * Internal gpiod_* API using descriptors instead of the integer namespace.
+ * Most of this should eventually go public.
+ */
+static int gpiod_request(struct gpio_desc *desc, const char *label);
+static void gpiod_free(struct gpio_desc *desc);
+static int gpiod_direction_input(struct gpio_desc *desc);
+static int gpiod_direction_output(struct gpio_desc *desc, int value);
+static int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
+static int gpiod_get_value_cansleep(struct gpio_desc *desc);
+static void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
+static int gpiod_get_value(struct gpio_desc *desc);
+static void gpiod_set_value(struct gpio_desc *desc, int value);
+static int gpiod_cansleep(struct gpio_desc *desc);
+static int gpiod_to_irq(struct gpio_desc *desc);
+static int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
+static int gpiod_export_link(struct device *dev, const char *name,
+                            struct gpio_desc *desc);
+static int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value);
+static void gpiod_unexport(struct gpio_desc *desc);
+
+
 static inline void desc_set_label(struct gpio_desc *d, const char *label)
 {
 #ifdef CONFIG_DEBUG_FS
@@ -83,6 +109,36 @@ static inline void desc_set_label(struct gpio_desc *d, const char *label)
 #endif
 }
 
+/*
+ * Return the GPIO number of the passed descriptor relative to its chip
+ */
+static int gpio_chip_hwgpio(const struct gpio_desc *desc)
+{
+       return desc - &desc->chip->desc[0];
+}
+
+/**
+ * Convert a GPIO number to its descriptor
+ */
+static struct gpio_desc *gpio_to_desc(unsigned gpio)
+{
+       if (WARN(!gpio_is_valid(gpio), "invalid GPIO %d\n", gpio))
+               return NULL;
+       else
+               return &gpio_desc[gpio];
+}
+
+/**
+ * Convert a GPIO descriptor to the integer namespace.
+ * This should disappear in the future but is needed since we still
+ * use GPIO numbers for error messages and sysfs nodes
+ */
+static int desc_to_gpio(const struct gpio_desc *desc)
+{
+       return desc->chip->base + gpio_chip_hwgpio(desc);
+}
+
+
 /* Warn when drivers omit gpio_request() calls -- legal but ill-advised
  * when setting direction, and otherwise illegal.  Until board setup code
  * and drivers use explicit requests everywhere (which won't happen when
@@ -94,10 +150,10 @@ static inline void desc_set_label(struct gpio_desc *d, const char *label)
  * only "legal" in the sense that (old) code using it won't break yet,
  * but instead only triggers a WARN() stack dump.
  */
-static int gpio_ensure_requested(struct gpio_desc *desc, unsigned offset)
+static int gpio_ensure_requested(struct gpio_desc *desc)
 {
        const struct gpio_chip *chip = desc->chip;
-       const int gpio = chip->base + offset;
+       const int gpio = desc_to_gpio(desc);
 
        if (WARN(test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0,
                        "autorequest GPIO-%d\n", gpio)) {
@@ -116,95 +172,54 @@ static int gpio_ensure_requested(struct gpio_desc *desc, unsigned offset)
 }
 
 /* caller holds gpio_lock *OR* gpio is marked as requested */
+static struct gpio_chip *gpiod_to_chip(struct gpio_desc *desc)
+{
+       return desc->chip;
+}
+
 struct gpio_chip *gpio_to_chip(unsigned gpio)
 {
-       return gpio_desc[gpio].chip;
+       return gpiod_to_chip(gpio_to_desc(gpio));
 }
 
 /* dynamic allocation of GPIOs, e.g. on a hotplugged device */
 static int gpiochip_find_base(int ngpio)
 {
-       int i;
-       int spare = 0;
-       int base = -ENOSPC;
-
-       for (i = ARCH_NR_GPIOS - 1; i >= 0 ; i--) {
-               struct gpio_desc *desc = &gpio_desc[i];
-               struct gpio_chip *chip = desc->chip;
+       struct gpio_chip *chip;
+       int base = ARCH_NR_GPIOS - ngpio;
 
-               if (!chip && !test_bit(FLAG_RESERVED, &desc->flags)) {
-                       spare++;
-                       if (spare == ngpio) {
-                               base = i;
-                               break;
-                       }
-               } else {
-                       spare = 0;
-                       if (chip)
-                               i -= chip->ngpio - 1;
-               }
+       list_for_each_entry_reverse(chip, &gpio_chips, list) {
+               /* found a free space? */
+               if (chip->base + chip->ngpio <= base)
+                       break;
+               else
+                       /* nope, check the space right before the chip */
+                       base = chip->base - ngpio;
        }
 
-       if (gpio_is_valid(base))
+       if (gpio_is_valid(base)) {
                pr_debug("%s: found new base at %d\n", __func__, base);
-       return base;
-}
-
-/**
- * gpiochip_reserve() - reserve range of gpios to use with platform code only
- * @start: starting gpio number
- * @ngpio: number of gpios to reserve
- * Context: platform init, potentially before irqs or kmalloc will work
- *
- * Returns a negative errno if any gpio within the range is already reserved
- * or registered, else returns zero as a success code.  Use this function
- * to mark a range of gpios as unavailable for dynamic gpio number allocation,
- * for example because its driver support is not yet loaded.
- */
-int __init gpiochip_reserve(int start, int ngpio)
-{
-       int ret = 0;
-       unsigned long flags;
-       int i;
-
-       if (!gpio_is_valid(start) || !gpio_is_valid(start + ngpio - 1))
-               return -EINVAL;
-
-       spin_lock_irqsave(&gpio_lock, flags);
-
-       for (i = start; i < start + ngpio; i++) {
-               struct gpio_desc *desc = &gpio_desc[i];
-
-               if (desc->chip || test_bit(FLAG_RESERVED, &desc->flags)) {
-                       ret = -EBUSY;
-                       goto err;
-               }
-
-               set_bit(FLAG_RESERVED, &desc->flags);
+               return base;
+       } else {
+               pr_err("%s: cannot find free range\n", __func__);
+               return -ENOSPC;
        }
-
-       pr_debug("%s: reserved gpios from %d to %d\n",
-                __func__, start, start + ngpio - 1);
-err:
-       spin_unlock_irqrestore(&gpio_lock, flags);
-
-       return ret;
 }
 
 /* caller ensures gpio is valid and requested, chip->get_direction may sleep  */
-static int gpio_get_direction(unsigned gpio)
+static int gpiod_get_direction(struct gpio_desc *desc)
 {
        struct gpio_chip        *chip;
-       struct gpio_desc        *desc = &gpio_desc[gpio];
+       unsigned                offset;
        int                     status = -EINVAL;
 
-       chip = gpio_to_chip(gpio);
-       gpio -= chip->base;
+       chip = gpiod_to_chip(desc);
+       offset = gpio_chip_hwgpio(desc);
 
        if (!chip->get_direction)
                return status;
 
-       status = chip->get_direction(chip, gpio);
+       status = chip->get_direction(chip, offset);
        if (status > 0) {
                /* GPIOF_DIR_IN, or other positive */
                status = 1;
@@ -248,19 +263,19 @@ static DEFINE_MUTEX(sysfs_lock);
 static ssize_t gpio_direction_show(struct device *dev,
                struct device_attribute *attr, char *buf)
 {
-       const struct gpio_desc  *desc = dev_get_drvdata(dev);
-       unsigned                gpio = desc - gpio_desc;
+       struct gpio_desc        *desc = dev_get_drvdata(dev);
        ssize_t                 status;
 
        mutex_lock(&sysfs_lock);
 
-       if (!test_bit(FLAG_EXPORT, &desc->flags))
+       if (!test_bit(FLAG_EXPORT, &desc->flags)) {
                status = -EIO;
-       else
-               gpio_get_direction(gpio);
+       } else {
+               gpiod_get_direction(desc);
                status = sprintf(buf, "%s\n",
                        test_bit(FLAG_IS_OUT, &desc->flags)
                                ? "out" : "in");
+       }
 
        mutex_unlock(&sysfs_lock);
        return status;
@@ -269,8 +284,7 @@ static ssize_t gpio_direction_show(struct device *dev,
 static ssize_t gpio_direction_store(struct device *dev,
                struct device_attribute *attr, const char *buf, size_t size)
 {
-       const struct gpio_desc  *desc = dev_get_drvdata(dev);
-       unsigned                gpio = desc - gpio_desc;
+       struct gpio_desc        *desc = dev_get_drvdata(dev);
        ssize_t                 status;
 
        mutex_lock(&sysfs_lock);
@@ -278,11 +292,11 @@ static ssize_t gpio_direction_store(struct device *dev,
        if (!test_bit(FLAG_EXPORT, &desc->flags))
                status = -EIO;
        else if (sysfs_streq(buf, "high"))
-               status = gpio_direction_output(gpio, 1);
+               status = gpiod_direction_output(desc, 1);
        else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
-               status = gpio_direction_output(gpio, 0);
+               status = gpiod_direction_output(desc, 0);
        else if (sysfs_streq(buf, "in"))
-               status = gpio_direction_input(gpio);
+               status = gpiod_direction_input(desc);
        else
                status = -EINVAL;
 
@@ -296,8 +310,7 @@ static /* const */ DEVICE_ATTR(direction, 0644,
 static ssize_t gpio_value_show(struct device *dev,
                struct device_attribute *attr, char *buf)
 {
-       const struct gpio_desc  *desc = dev_get_drvdata(dev);
-       unsigned                gpio = desc - gpio_desc;
+       struct gpio_desc        *desc = dev_get_drvdata(dev);
        ssize_t                 status;
 
        mutex_lock(&sysfs_lock);
@@ -307,7 +320,7 @@ static ssize_t gpio_value_show(struct device *dev,
        } else {
                int value;
 
-               value = !!gpio_get_value_cansleep(gpio);
+               value = !!gpiod_get_value_cansleep(desc);
                if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
                        value = !value;
 
@@ -321,8 +334,7 @@ static ssize_t gpio_value_show(struct device *dev,
 static ssize_t gpio_value_store(struct device *dev,
                struct device_attribute *attr, const char *buf, size_t size)
 {
-       const struct gpio_desc  *desc = dev_get_drvdata(dev);
-       unsigned                gpio = desc - gpio_desc;
+       struct gpio_desc        *desc = dev_get_drvdata(dev);
        ssize_t                 status;
 
        mutex_lock(&sysfs_lock);
@@ -338,7 +350,7 @@ static ssize_t gpio_value_store(struct device *dev,
                if (status == 0) {
                        if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
                                value = !value;
-                       gpio_set_value_cansleep(gpio, value != 0);
+                       gpiod_set_value_cansleep(desc, value != 0);
                        status = size;
                }
        }
@@ -368,7 +380,7 @@ static int gpio_setup_irq(struct gpio_desc *desc, struct device *dev,
        if ((desc->flags & GPIO_TRIGGER_MASK) == gpio_flags)
                return 0;
 
-       irq = gpio_to_irq(desc - gpio_desc);
+       irq = gpiod_to_irq(desc);
        if (irq < 0)
                return -EIO;
 
@@ -638,29 +650,32 @@ static ssize_t export_store(struct class *class,
                                struct class_attribute *attr,
                                const char *buf, size_t len)
 {
-       long    gpio;
-       int     status;
+       long                    gpio;
+       struct gpio_desc        *desc;
+       int                     status;
 
        status = strict_strtol(buf, 0, &gpio);
        if (status < 0)
                goto done;
 
+       desc = gpio_to_desc(gpio);
+
        /* No extra locking here; FLAG_SYSFS just signifies that the
         * request and export were done by on behalf of userspace, so
         * they may be undone on its behalf too.
         */
 
-       status = gpio_request(gpio, "sysfs");
+       status = gpiod_request(desc, "sysfs");
        if (status < 0) {
                if (status == -EPROBE_DEFER)
                        status = -ENODEV;
                goto done;
        }
-       status = gpio_export(gpio, true);
+       status = gpiod_export(desc, true);
        if (status < 0)
-               gpio_free(gpio);
+               gpiod_free(desc);
        else
-               set_bit(FLAG_SYSFS, &gpio_desc[gpio].flags);
+               set_bit(FLAG_SYSFS, &desc->flags);
 
 done:
        if (status)
@@ -672,8 +687,9 @@ static ssize_t unexport_store(struct class *class,
                                struct class_attribute *attr,
                                const char *buf, size_t len)
 {
-       long    gpio;
-       int     status;
+       long                    gpio;
+       struct gpio_desc        *desc;
+       int                     status;
 
        status = strict_strtol(buf, 0, &gpio);
        if (status < 0)
@@ -681,17 +697,18 @@ static ssize_t unexport_store(struct class *class,
 
        status = -EINVAL;
 
+       desc = gpio_to_desc(gpio);
        /* reject bogus commands (gpio_unexport ignores them) */
-       if (!gpio_is_valid(gpio))
+       if (!desc)
                goto done;
 
        /* No extra locking here; FLAG_SYSFS just signifies that the
         * request and export were done by on behalf of userspace, so
         * they may be undone on its behalf too.
         */
-       if (test_and_clear_bit(FLAG_SYSFS, &gpio_desc[gpio].flags)) {
+       if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
                status = 0;
-               gpio_free(gpio);
+               gpiod_free(desc);
        }
 done:
        if (status)
@@ -728,13 +745,13 @@ static struct class gpio_class = {
  *
  * Returns zero on success, else an error.
  */
-int gpio_export(unsigned gpio, bool direction_may_change)
+static int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
 {
        unsigned long           flags;
-       struct gpio_desc        *desc;
        int                     status;
        const char              *ioname = NULL;
        struct device           *dev;
+       int                     offset;
 
        /* can't export until sysfs is available ... */
        if (!gpio_class.p) {
@@ -742,20 +759,19 @@ int gpio_export(unsigned gpio, bool direction_may_change)
                return -ENOENT;
        }
 
-       if (!gpio_is_valid(gpio)) {
-               pr_debug("%s: gpio %d is not valid\n", __func__, gpio);
+       if (!desc) {
+               pr_debug("%s: invalid gpio descriptor\n", __func__);
                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)) {
                spin_unlock_irqrestore(&gpio_lock, flags);
                pr_debug("%s: gpio %d unavailable (requested=%d, exported=%d)\n",
-                               __func__, gpio,
+                               __func__, desc_to_gpio(desc),
                                test_bit(FLAG_REQUESTED, &desc->flags),
                                test_bit(FLAG_EXPORT, &desc->flags));
                status = -EPERM;
@@ -766,11 +782,13 @@ int gpio_export(unsigned gpio, bool direction_may_change)
                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];
+       offset = gpio_chip_hwgpio(desc);
+       if (desc->chip->names && desc->chip->names[offset])
+               ioname = desc->chip->names[offset];
 
        dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
-                           desc, ioname ? ioname : "gpio%u", gpio);
+                           desc, ioname ? ioname : "gpio%u",
+                           desc_to_gpio(desc));
        if (IS_ERR(dev)) {
                status = PTR_ERR(dev);
                goto fail_unlock;
@@ -786,7 +804,7 @@ int gpio_export(unsigned gpio, bool direction_may_change)
                        goto fail_unregister_device;
        }
 
-       if (gpio_to_irq(gpio) >= 0 && (direction_may_change ||
+       if (gpiod_to_irq(desc) >= 0 && (direction_may_change ||
                                       !test_bit(FLAG_IS_OUT, &desc->flags))) {
                status = device_create_file(dev, &dev_attr_edge);
                if (status)
@@ -801,9 +819,15 @@ fail_unregister_device:
        device_unregister(dev);
 fail_unlock:
        mutex_unlock(&sysfs_lock);
-       pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
+       pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
+                status);
        return status;
 }
+
+int gpio_export(unsigned gpio, bool direction_may_change)
+{
+       return gpiod_export(gpio_to_desc(gpio), direction_may_change);
+}
 EXPORT_SYMBOL_GPL(gpio_export);
 
 static int match_export(struct device *dev, const void *data)
@@ -822,18 +846,16 @@ static int match_export(struct device *dev, const void *data)
  *
  * Returns zero on success, else an error.
  */
-int gpio_export_link(struct device *dev, const char *name, unsigned gpio)
+static int gpiod_export_link(struct device *dev, const char *name,
+                            struct gpio_desc *desc)
 {
-       struct gpio_desc        *desc;
        int                     status = -EINVAL;
 
-       if (!gpio_is_valid(gpio))
+       if (!desc)
                goto done;
 
        mutex_lock(&sysfs_lock);
 
-       desc = &gpio_desc[gpio];
-
        if (test_bit(FLAG_EXPORT, &desc->flags)) {
                struct device *tdev;
 
@@ -850,12 +872,17 @@ int gpio_export_link(struct device *dev, const char *name, unsigned gpio)
 
 done:
        if (status)
-               pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
+               pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
+                        status);
 
        return status;
 }
-EXPORT_SYMBOL_GPL(gpio_export_link);
 
+int gpio_export_link(struct device *dev, const char *name, unsigned gpio)
+{
+       return gpiod_export_link(dev, name, gpio_to_desc(gpio));
+}
+EXPORT_SYMBOL_GPL(gpio_export_link);
 
 /**
  * gpio_sysfs_set_active_low - set the polarity of gpio sysfs value
@@ -869,19 +896,16 @@ EXPORT_SYMBOL_GPL(gpio_export_link);
  *
  * Returns zero on success, else an error.
  */
-int gpio_sysfs_set_active_low(unsigned gpio, int value)
+static int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
 {
-       struct gpio_desc        *desc;
        struct device           *dev = NULL;
        int                     status = -EINVAL;
 
-       if (!gpio_is_valid(gpio))
+       if (!desc)
                goto done;
 
        mutex_lock(&sysfs_lock);
 
-       desc = &gpio_desc[gpio];
-
        if (test_bit(FLAG_EXPORT, &desc->flags)) {
                dev = class_find_device(&gpio_class, NULL, desc, match_export);
                if (dev == NULL) {
@@ -897,10 +921,16 @@ unlock:
 
 done:
        if (status)
-               pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);
+               pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
+                        status);
 
        return status;
 }
+
+int gpio_sysfs_set_active_low(unsigned gpio, int value)
+{
+       return gpiod_sysfs_set_active_low(gpio_to_desc(gpio), value);
+}
 EXPORT_SYMBOL_GPL(gpio_sysfs_set_active_low);
 
 /**
@@ -909,21 +939,18 @@ EXPORT_SYMBOL_GPL(gpio_sysfs_set_active_low);
  *
  * This is implicit on gpio_free().
  */
-void gpio_unexport(unsigned gpio)
+static void gpiod_unexport(struct gpio_desc *desc)
 {
-       struct gpio_desc        *desc;
        int                     status = 0;
        struct device           *dev = NULL;
 
-       if (!gpio_is_valid(gpio)) {
+       if (!desc) {
                status = -EINVAL;
                goto done;
        }
 
        mutex_lock(&sysfs_lock);
 
-       desc = &gpio_desc[gpio];
-
        if (test_bit(FLAG_EXPORT, &desc->flags)) {
 
                dev = class_find_device(&gpio_class, NULL, desc, match_export);
@@ -935,13 +962,20 @@ void gpio_unexport(unsigned gpio)
        }
 
        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);
+               pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
+                        status);
+}
+
+void gpio_unexport(unsigned gpio)
+{
+       gpiod_unexport(gpio_to_desc(gpio));
 }
 EXPORT_SYMBOL_GPL(gpio_unexport);
 
@@ -975,9 +1009,9 @@ static int gpiochip_export(struct gpio_chip *chip)
                unsigned        gpio;
 
                spin_lock_irqsave(&gpio_lock, flags);
-               gpio = chip->base;
-               while (gpio_desc[gpio].chip == chip)
-                       gpio_desc[gpio++].chip = NULL;
+               gpio = 0;
+               while (gpio < chip->ngpio)
+                       chip->desc[gpio++].chip = NULL;
                spin_unlock_irqrestore(&gpio_lock, flags);
 
                pr_debug("%s: chip %s status %d\n", __func__,
@@ -1012,7 +1046,7 @@ static int __init gpiolib_sysfs_init(void)
 {
        int             status;
        unsigned long   flags;
-       unsigned        gpio;
+       struct gpio_chip *chip;
 
        status = class_register(&gpio_class);
        if (status < 0)
@@ -1025,10 +1059,7 @@ static int __init gpiolib_sysfs_init(void)
         * registered, and so arch_initcall() can always gpio_export().
         */
        spin_lock_irqsave(&gpio_lock, flags);
-       for (gpio = 0; gpio < ARCH_NR_GPIOS; gpio++) {
-               struct gpio_chip        *chip;
-
-               chip = gpio_desc[gpio].chip;
+       list_for_each_entry(chip, &gpio_chips, list) {
                if (!chip || chip->exported)
                        continue;
 
@@ -1053,8 +1084,66 @@ static inline void gpiochip_unexport(struct gpio_chip *chip)
 {
 }
 
+static inline int gpiod_export(struct gpio_desc *desc,
+                              bool direction_may_change)
+{
+       return -ENOSYS;
+}
+
+static inline int gpiod_export_link(struct device *dev, const char *name,
+                                   struct gpio_desc *desc)
+{
+       return -ENOSYS;
+}
+
+static inline int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
+{
+       return -ENOSYS;
+}
+
+static inline void gpiod_unexport(struct gpio_desc *desc)
+{
+}
+
 #endif /* CONFIG_GPIO_SYSFS */
 
+/*
+ * Add a new chip to the global chips list, keeping the list of chips sorted
+ * by base order.
+ *
+ * Return -EBUSY if the new chip overlaps with some other chip's integer
+ * space.
+ */
+static int gpiochip_add_to_list(struct gpio_chip *chip)
+{
+       struct list_head *pos = &gpio_chips;
+       struct gpio_chip *_chip;
+       int err = 0;
+
+       /* find where to insert our chip */
+       list_for_each(pos, &gpio_chips) {
+               _chip = list_entry(pos, struct gpio_chip, list);
+               /* shall we insert before _chip? */
+               if (_chip->base >= chip->base + chip->ngpio)
+                       break;
+       }
+
+       /* are we stepping on the chip right before? */
+       if (pos != &gpio_chips && pos->prev != &gpio_chips) {
+               _chip = list_entry(pos->prev, struct gpio_chip, list);
+               if (_chip->base + _chip->ngpio > chip->base) {
+                       dev_err(chip->dev,
+                              "GPIO integer space overlap, cannot add chip\n");
+                       err = -EBUSY;
+               }
+       }
+
+       if (!err)
+               list_add_tail(&chip->list, pos);
+
+       return err;
+}
+
 /**
  * gpiochip_add() - register a gpio_chip
  * @chip: the chip to register, with chip->base initialized
@@ -1096,16 +1185,14 @@ int gpiochip_add(struct gpio_chip *chip)
                chip->base = base;
        }
 
-       /* these GPIO numbers must not be managed by another gpio_chip */
-       for (id = base; id < base + chip->ngpio; id++) {
-               if (gpio_desc[id].chip != NULL) {
-                       status = -EBUSY;
-                       break;
-               }
-       }
+       status = gpiochip_add_to_list(chip);
+
        if (status == 0) {
-               for (id = base; id < base + chip->ngpio; id++) {
-                       gpio_desc[id].chip = chip;
+               chip->desc = &gpio_desc[chip->base];
+
+               for (id = 0; id < chip->ngpio; id++) {
+                       struct gpio_desc *desc = &chip->desc[id];
+                       desc->chip = chip;
 
                        /* REVISIT:  most hardware initializes GPIOs as
                         * inputs (often with pullups enabled) so power
@@ -1114,7 +1201,7 @@ int gpiochip_add(struct gpio_chip *chip)
                         * and in case chip->get_direction is not set,
                         * we may expose the wrong direction in sysfs.
                         */
-                       gpio_desc[id].flags = !chip->direction_input
+                       desc->flags = !chip->direction_input
                                ? (1 << FLAG_IS_OUT)
                                : 0;
                }
@@ -1167,15 +1254,17 @@ int gpiochip_remove(struct gpio_chip *chip)
        gpiochip_remove_pin_ranges(chip);
        of_gpiochip_remove(chip);
 
-       for (id = chip->base; id < chip->base + chip->ngpio; id++) {
-               if (test_bit(FLAG_REQUESTED, &gpio_desc[id].flags)) {
+       for (id = 0; id < chip->ngpio; id++) {
+               if (test_bit(FLAG_REQUESTED, &chip->desc[id].flags)) {
                        status = -EBUSY;
                        break;
                }
        }
        if (status == 0) {
-               for (id = chip->base; id < chip->base + chip->ngpio; id++)
-                       gpio_desc[id].chip = NULL;
+               for (id = 0; id < chip->ngpio; id++)
+                       chip->desc[id].chip = NULL;
+
+               list_del(&chip->list);
        }
 
        spin_unlock_irqrestore(&gpio_lock, flags);
@@ -1202,20 +1291,17 @@ struct gpio_chip *gpiochip_find(void *data,
                                int (*match)(struct gpio_chip *chip,
                                             void *data))
 {
-       struct gpio_chip *chip = NULL;
+       struct gpio_chip *chip;
        unsigned long flags;
-       int i;
 
        spin_lock_irqsave(&gpio_lock, flags);
-       for (i = 0; i < ARCH_NR_GPIOS; i++) {
-               if (!gpio_desc[i].chip)
-                       continue;
-
-               if (match(gpio_desc[i].chip, data)) {
-                       chip = gpio_desc[i].chip;
+       list_for_each_entry(chip, &gpio_chips, list)
+               if (match(chip, data))
                        break;
-               }
-       }
+
+       /* No match? */
+       if (&chip->list == &gpio_chips)
+               chip = NULL;
        spin_unlock_irqrestore(&gpio_lock, flags);
 
        return chip;
@@ -1297,20 +1383,18 @@ EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
  * on each other, and help provide better diagnostics in debugfs.
  * They're called even less than the "set direction" calls.
  */
-int gpio_request(unsigned gpio, const char *label)
+static int gpiod_request(struct gpio_desc *desc, const char *label)
 {
-       struct gpio_desc        *desc;
        struct gpio_chip        *chip;
        int                     status = -EPROBE_DEFER;
        unsigned long           flags;
 
        spin_lock_irqsave(&gpio_lock, flags);
 
-       if (!gpio_is_valid(gpio)) {
+       if (!desc) {
                status = -EINVAL;
                goto done;
        }
-       desc = &gpio_desc[gpio];
        chip = desc->chip;
        if (chip == NULL)
                goto done;
@@ -1334,7 +1418,7 @@ int gpio_request(unsigned gpio, const char *label)
        if (chip->request) {
                /* chip->request may sleep */
                spin_unlock_irqrestore(&gpio_lock, flags);
-               status = chip->request(chip, gpio - chip->base);
+               status = chip->request(chip, gpio_chip_hwgpio(desc));
                spin_lock_irqsave(&gpio_lock, flags);
 
                if (status < 0) {
@@ -1347,42 +1431,46 @@ int gpio_request(unsigned gpio, const char *label)
        if (chip->get_direction) {
                /* chip->get_direction may sleep */
                spin_unlock_irqrestore(&gpio_lock, flags);
-               gpio_get_direction(gpio);
+               gpiod_get_direction(desc);
                spin_lock_irqsave(&gpio_lock, flags);
        }
 done:
        if (status)
-               pr_debug("gpio_request: gpio-%d (%s) status %d\n",
-                       gpio, label ? : "?", status);
+               pr_debug("_gpio_request: gpio-%d (%s) status %d\n",
+                        desc ? desc_to_gpio(desc) : -1,
+                        label ? : "?", status);
        spin_unlock_irqrestore(&gpio_lock, flags);
        return status;
 }
+
+int gpio_request(unsigned gpio, const char *label)
+{
+       return gpiod_request(gpio_to_desc(gpio), label);
+}
 EXPORT_SYMBOL_GPL(gpio_request);
 
-void gpio_free(unsigned gpio)
+static void gpiod_free(struct gpio_desc *desc)
 {
        unsigned long           flags;
-       struct gpio_desc        *desc;
        struct gpio_chip        *chip;
 
        might_sleep();
 
-       if (!gpio_is_valid(gpio)) {
+       if (!desc) {
                WARN_ON(extra_checks);
                return;
        }
 
-       gpio_unexport(gpio);
+       gpiod_unexport(desc);
 
        spin_lock_irqsave(&gpio_lock, flags);
 
-       desc = &gpio_desc[gpio];
        chip = desc->chip;
        if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
                if (chip->free) {
                        spin_unlock_irqrestore(&gpio_lock, flags);
                        might_sleep_if(chip->can_sleep);
-                       chip->free(chip, gpio - chip->base);
+                       chip->free(chip, gpio_chip_hwgpio(desc));
                        spin_lock_irqsave(&gpio_lock, flags);
                }
                desc_set_label(desc, NULL);
@@ -1396,6 +1484,11 @@ void gpio_free(unsigned gpio)
 
        spin_unlock_irqrestore(&gpio_lock, flags);
 }
+
+void gpio_free(unsigned gpio)
+{
+       gpiod_free(gpio_to_desc(gpio));
+}
 EXPORT_SYMBOL_GPL(gpio_free);
 
 /**
@@ -1406,29 +1499,32 @@ EXPORT_SYMBOL_GPL(gpio_free);
  */
 int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
 {
+       struct gpio_desc *desc;
        int err;
 
-       err = gpio_request(gpio, label);
+       desc = gpio_to_desc(gpio);
+
+       err = gpiod_request(desc, label);
        if (err)
                return err;
 
        if (flags & GPIOF_OPEN_DRAIN)
-               set_bit(FLAG_OPEN_DRAIN, &gpio_desc[gpio].flags);
+               set_bit(FLAG_OPEN_DRAIN, &desc->flags);
 
        if (flags & GPIOF_OPEN_SOURCE)
-               set_bit(FLAG_OPEN_SOURCE, &gpio_desc[gpio].flags);
+               set_bit(FLAG_OPEN_SOURCE, &desc->flags);
 
        if (flags & GPIOF_DIR_IN)
-               err = gpio_direction_input(gpio);
+               err = gpiod_direction_input(desc);
        else
-               err = gpio_direction_output(gpio,
+               err = gpiod_direction_output(desc,
                                (flags & GPIOF_INIT_HIGH) ? 1 : 0);
 
        if (err)
                goto free_gpio;
 
        if (flags & GPIOF_EXPORT) {
-               err = gpio_export(gpio, flags & GPIOF_EXPORT_CHANGEABLE);
+               err = gpiod_export(desc, flags & GPIOF_EXPORT_CHANGEABLE);
                if (err)
                        goto free_gpio;
        }
@@ -1436,7 +1532,7 @@ int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
        return 0;
 
  free_gpio:
-       gpio_free(gpio);
+       gpiod_free(desc);
        return err;
 }
 EXPORT_SYMBOL_GPL(gpio_request_one);
@@ -1491,14 +1587,17 @@ EXPORT_SYMBOL_GPL(gpio_free_array);
  */
 const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
 {
-       unsigned gpio = chip->base + offset;
+       struct gpio_desc *desc;
 
-       if (!gpio_is_valid(gpio) || gpio_desc[gpio].chip != chip)
+       if (!GPIO_OFFSET_VALID(chip, offset))
                return NULL;
-       if (test_bit(FLAG_REQUESTED, &gpio_desc[gpio].flags) == 0)
+
+       desc = &chip->desc[offset];
+
+       if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
                return NULL;
 #ifdef CONFIG_DEBUG_FS
-       return gpio_desc[gpio].label;
+       return desc->label;
 #else
        return "?";
 #endif
@@ -1515,24 +1614,21 @@ EXPORT_SYMBOL_GPL(gpiochip_is_requested);
  * rely on gpio_request() having been called beforehand.
  */
 
-int gpio_direction_input(unsigned gpio)
+static int gpiod_direction_input(struct gpio_desc *desc)
 {
        unsigned long           flags;
        struct gpio_chip        *chip;
-       struct gpio_desc        *desc = &gpio_desc[gpio];
        int                     status = -EINVAL;
+       int                     offset;
 
        spin_lock_irqsave(&gpio_lock, flags);
 
-       if (!gpio_is_valid(gpio))
+       if (!desc)
                goto fail;
        chip = desc->chip;
        if (!chip || !chip->get || !chip->direction_input)
                goto fail;
-       gpio -= chip->base;
-       if (gpio >= chip->ngpio)
-               goto fail;
-       status = gpio_ensure_requested(desc, gpio);
+       status = gpio_ensure_requested(desc);
        if (status < 0)
                goto fail;
 
@@ -1542,11 +1638,12 @@ int gpio_direction_input(unsigned gpio)
 
        might_sleep_if(chip->can_sleep);
 
+       offset = gpio_chip_hwgpio(desc);
        if (status) {
-               status = chip->request(chip, gpio);
+               status = chip->request(chip, offset);
                if (status < 0) {
                        pr_debug("GPIO-%d: chip request fail, %d\n",
-                               chip->base + gpio, status);
+                               desc_to_gpio(desc), status);
                        /* and it's not available to anyone else ...
                         * gpio_request() is the fully clean solution.
                         */
@@ -1554,48 +1651,54 @@ int gpio_direction_input(unsigned gpio)
                }
        }
 
-       status = chip->direction_input(chip, gpio);
+       status = chip->direction_input(chip, offset);
        if (status == 0)
                clear_bit(FLAG_IS_OUT, &desc->flags);
 
-       trace_gpio_direction(chip->base + gpio, 1, status);
+       trace_gpio_direction(desc_to_gpio(desc), 1, status);
 lose:
        return status;
 fail:
        spin_unlock_irqrestore(&gpio_lock, flags);
-       if (status)
+       if (status) {
+               int gpio = -1;
+               if (desc)
+                       gpio = desc_to_gpio(desc);
                pr_debug("%s: gpio-%d status %d\n",
                        __func__, gpio, status);
+       }
        return status;
 }
+
+int gpio_direction_input(unsigned gpio)
+{
+       return gpiod_direction_input(gpio_to_desc(gpio));
+}
 EXPORT_SYMBOL_GPL(gpio_direction_input);
 
-int gpio_direction_output(unsigned gpio, int value)
+static int gpiod_direction_output(struct gpio_desc *desc, int value)
 {
        unsigned long           flags;
        struct gpio_chip        *chip;
-       struct gpio_desc        *desc = &gpio_desc[gpio];
        int                     status = -EINVAL;
+       int offset;
 
        /* Open drain pin should not be driven to 1 */
        if (value && test_bit(FLAG_OPEN_DRAIN,  &desc->flags))
-               return gpio_direction_input(gpio);
+               return gpiod_direction_input(desc);
 
        /* Open source pin should not be driven to 0 */
        if (!value && test_bit(FLAG_OPEN_SOURCE,  &desc->flags))
-               return gpio_direction_input(gpio);
+               return gpiod_direction_input(desc);
 
        spin_lock_irqsave(&gpio_lock, flags);
 
-       if (!gpio_is_valid(gpio))
+       if (!desc)
                goto fail;
        chip = desc->chip;
        if (!chip || !chip->set || !chip->direction_output)
                goto fail;
-       gpio -= chip->base;
-       if (gpio >= chip->ngpio)
-               goto fail;
-       status = gpio_ensure_requested(desc, gpio);
+       status = gpio_ensure_requested(desc);
        if (status < 0)
                goto fail;
 
@@ -1605,11 +1708,12 @@ int gpio_direction_output(unsigned gpio, int value)
 
        might_sleep_if(chip->can_sleep);
 
+       offset = gpio_chip_hwgpio(desc);
        if (status) {
-               status = chip->request(chip, gpio);
+               status = chip->request(chip, offset);
                if (status < 0) {
                        pr_debug("GPIO-%d: chip request fail, %d\n",
-                               chip->base + gpio, status);
+                               desc_to_gpio(desc), status);
                        /* and it's not available to anyone else ...
                         * gpio_request() is the fully clean solution.
                         */
@@ -1617,20 +1721,29 @@ int gpio_direction_output(unsigned gpio, int value)
                }
        }
 
-       status = chip->direction_output(chip, gpio, value);
+       status = chip->direction_output(chip, offset, value);
        if (status == 0)
                set_bit(FLAG_IS_OUT, &desc->flags);
-       trace_gpio_value(chip->base + gpio, 0, value);
-       trace_gpio_direction(chip->base + gpio, 0, status);
+       trace_gpio_value(desc_to_gpio(desc), 0, value);
+       trace_gpio_direction(desc_to_gpio(desc), 0, status);
 lose:
        return status;
 fail:
        spin_unlock_irqrestore(&gpio_lock, flags);
-       if (status)
+       if (status) {
+               int gpio = -1;
+               if (desc)
+                       gpio = desc_to_gpio(desc);
                pr_debug("%s: gpio-%d status %d\n",
                        __func__, gpio, status);
+       }
        return status;
 }
+
+int gpio_direction_output(unsigned gpio, int value)
+{
+       return gpiod_direction_output(gpio_to_desc(gpio), value);
+}
 EXPORT_SYMBOL_GPL(gpio_direction_output);
 
 /**
@@ -1638,24 +1751,22 @@ EXPORT_SYMBOL_GPL(gpio_direction_output);
  * @gpio: the gpio to set debounce time
  * @debounce: debounce time is microseconds
  */
-int gpio_set_debounce(unsigned gpio, unsigned debounce)
+static int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
 {
        unsigned long           flags;
        struct gpio_chip        *chip;
-       struct gpio_desc        *desc = &gpio_desc[gpio];
        int                     status = -EINVAL;
+       int                     offset;
 
        spin_lock_irqsave(&gpio_lock, flags);
 
-       if (!gpio_is_valid(gpio))
+       if (!desc)
                goto fail;
        chip = desc->chip;
        if (!chip || !chip->set || !chip->set_debounce)
                goto fail;
-       gpio -= chip->base;
-       if (gpio >= chip->ngpio)
-               goto fail;
-       status = gpio_ensure_requested(desc, gpio);
+
+       status = gpio_ensure_requested(desc);
        if (status < 0)
                goto fail;
 
@@ -1665,16 +1776,26 @@ int gpio_set_debounce(unsigned gpio, unsigned debounce)
 
        might_sleep_if(chip->can_sleep);
 
-       return chip->set_debounce(chip, gpio, debounce);
+       offset = gpio_chip_hwgpio(desc);
+       return chip->set_debounce(chip, offset, debounce);
 
 fail:
        spin_unlock_irqrestore(&gpio_lock, flags);
-       if (status)
+       if (status) {
+               int gpio = -1;
+               if (desc)
+                       gpio = desc_to_gpio(desc);
                pr_debug("%s: gpio-%d status %d\n",
                        __func__, gpio, status);
+       }
 
        return status;
 }
+
+int gpio_set_debounce(unsigned gpio, unsigned debounce)
+{
+       return gpiod_set_debounce(gpio_to_desc(gpio), debounce);
+}
 EXPORT_SYMBOL_GPL(gpio_set_debounce);
 
 /* I/O calls are only valid after configuration completed; the relevant
@@ -1708,18 +1829,25 @@ EXPORT_SYMBOL_GPL(gpio_set_debounce);
  * It returns the zero or nonzero value provided by the associated
  * gpio_chip.get() method; or zero if no such method is provided.
  */
-int __gpio_get_value(unsigned gpio)
+static int gpiod_get_value(struct gpio_desc *desc)
 {
        struct gpio_chip        *chip;
        int value;
+       int offset;
 
-       chip = gpio_to_chip(gpio);
+       chip = desc->chip;
+       offset = gpio_chip_hwgpio(desc);
        /* Should be using gpio_get_value_cansleep() */
        WARN_ON(chip->can_sleep);
-       value = chip->get ? chip->get(chip, gpio - chip->base) : 0;
-       trace_gpio_value(gpio, 1, value);
+       value = chip->get ? chip->get(chip, offset) : 0;
+       trace_gpio_value(desc_to_gpio(desc), 1, value);
        return value;
 }
+
+int __gpio_get_value(unsigned gpio)
+{
+       return gpiod_get_value(gpio_to_desc(gpio));
+}
 EXPORT_SYMBOL_GPL(__gpio_get_value);
 
 /*
@@ -1728,23 +1856,25 @@ EXPORT_SYMBOL_GPL(__gpio_get_value);
  * @chip: Gpio chip.
  * @value: Non-zero for setting it HIGH otherise it will set to LOW.
  */
-static void _gpio_set_open_drain_value(unsigned gpio,
-                       struct gpio_chip *chip, int value)
+static void _gpio_set_open_drain_value(struct gpio_desc *desc, int value)
 {
        int err = 0;
+       struct gpio_chip *chip = desc->chip;
+       int offset = gpio_chip_hwgpio(desc);
+
        if (value) {
-               err = chip->direction_input(chip, gpio - chip->base);
+               err = chip->direction_input(chip, offset);
                if (!err)
-                       clear_bit(FLAG_IS_OUT, &gpio_desc[gpio].flags);
+                       clear_bit(FLAG_IS_OUT, &desc->flags);
        } else {
-               err = chip->direction_output(chip, gpio - chip->base, 0);
+               err = chip->direction_output(chip, offset, 0);
                if (!err)
-                       set_bit(FLAG_IS_OUT, &gpio_desc[gpio].flags);
+                       set_bit(FLAG_IS_OUT, &desc->flags);
        }
-       trace_gpio_direction(gpio, value, err);
+       trace_gpio_direction(desc_to_gpio(desc), value, err);
        if (err < 0)
                pr_err("%s: Error in set_value for open drain gpio%d err %d\n",
-                                       __func__, gpio, err);
+                                       __func__, desc_to_gpio(desc), err);
 }
 
 /*
@@ -1753,26 +1883,27 @@ static void _gpio_set_open_drain_value(unsigned gpio,
  * @chip: Gpio chip.
  * @value: Non-zero for setting it HIGH otherise it will set to LOW.
  */
-static void _gpio_set_open_source_value(unsigned gpio,
-                       struct gpio_chip *chip, int value)
+static void _gpio_set_open_source_value(struct gpio_desc *desc, int value)
 {
        int err = 0;
+       struct gpio_chip *chip = desc->chip;
+       int offset = gpio_chip_hwgpio(desc);
+
        if (value) {
-               err = chip->direction_output(chip, gpio - chip->base, 1);
+               err = chip->direction_output(chip, offset, 1);
                if (!err)
-                       set_bit(FLAG_IS_OUT, &gpio_desc[gpio].flags);
+                       set_bit(FLAG_IS_OUT, &desc->flags);
        } else {
-               err = chip->direction_input(chip, gpio - chip->base);
+               err = chip->direction_input(chip, offset);
                if (!err)
-                       clear_bit(FLAG_IS_OUT, &gpio_desc[gpio].flags);
+                       clear_bit(FLAG_IS_OUT, &desc->flags);
        }
-       trace_gpio_direction(gpio, !value, err);
+       trace_gpio_direction(desc_to_gpio(desc), !value, err);
        if (err < 0)
                pr_err("%s: Error in set_value for open source gpio%d err %d\n",
-                                       __func__, gpio, err);
+                                       __func__, desc_to_gpio(desc), err);
 }
 
-
 /**
  * __gpio_set_value() - assign a gpio's value
  * @gpio: gpio whose value will be assigned
@@ -1782,20 +1913,25 @@ static void _gpio_set_open_source_value(unsigned gpio,
  * This is used directly or indirectly to implement gpio_set_value().
  * It invokes the associated gpio_chip.set() method.
  */
-void __gpio_set_value(unsigned gpio, int value)
+static void gpiod_set_value(struct gpio_desc *desc, int value)
 {
        struct gpio_chip        *chip;
 
-       chip = gpio_to_chip(gpio);
+       chip = desc->chip;
        /* Should be using gpio_set_value_cansleep() */
        WARN_ON(chip->can_sleep);
-       trace_gpio_value(gpio, 0, value);
-       if (test_bit(FLAG_OPEN_DRAIN,  &gpio_desc[gpio].flags))
-               _gpio_set_open_drain_value(gpio, chip, value);
-       else if (test_bit(FLAG_OPEN_SOURCE,  &gpio_desc[gpio].flags))
-               _gpio_set_open_source_value(gpio, chip, value);
+       trace_gpio_value(desc_to_gpio(desc), 0, value);
+       if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
+               _gpio_set_open_drain_value(desc, value);
+       else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
+               _gpio_set_open_source_value(desc, value);
        else
-               chip->set(chip, gpio - chip->base, value);
+               chip->set(chip, gpio_chip_hwgpio(desc), value);
+}
+
+void __gpio_set_value(unsigned gpio, int value)
+{
+       return gpiod_set_value(gpio_to_desc(gpio), value);
 }
 EXPORT_SYMBOL_GPL(__gpio_set_value);
 
@@ -1807,14 +1943,15 @@ EXPORT_SYMBOL_GPL(__gpio_set_value);
  * This is used directly or indirectly to implement gpio_cansleep().  It
  * returns nonzero if access reading or writing the GPIO value can sleep.
  */
-int __gpio_cansleep(unsigned gpio)
+static int gpiod_cansleep(struct gpio_desc *desc)
 {
-       struct gpio_chip        *chip;
-
        /* only call this on GPIOs that are valid! */
-       chip = gpio_to_chip(gpio);
+       return desc->chip->can_sleep;
+}
 
-       return chip->can_sleep;
+int __gpio_cansleep(unsigned gpio)
+{
+       return gpiod_cansleep(gpio_to_desc(gpio));
 }
 EXPORT_SYMBOL_GPL(__gpio_cansleep);
 
@@ -1827,50 +1964,67 @@ EXPORT_SYMBOL_GPL(__gpio_cansleep);
  * It returns the number of the IRQ signaled by this (input) GPIO,
  * or a negative errno.
  */
-int __gpio_to_irq(unsigned gpio)
+static int gpiod_to_irq(struct gpio_desc *desc)
 {
        struct gpio_chip        *chip;
+       int                     offset;
 
-       chip = gpio_to_chip(gpio);
-       return chip->to_irq ? chip->to_irq(chip, gpio - chip->base) : -ENXIO;
+       chip = desc->chip;
+       offset = gpio_chip_hwgpio(desc);
+       return chip->to_irq ? chip->to_irq(chip, offset) : -ENXIO;
 }
-EXPORT_SYMBOL_GPL(__gpio_to_irq);
 
+int __gpio_to_irq(unsigned gpio)
+{
+       return gpiod_to_irq(gpio_to_desc(gpio));
+}
+EXPORT_SYMBOL_GPL(__gpio_to_irq);
 
 
 /* There's no value in making it easy to inline GPIO calls that may sleep.
  * Common examples include ones connected to I2C or SPI chips.
  */
 
-int gpio_get_value_cansleep(unsigned gpio)
+static int gpiod_get_value_cansleep(struct gpio_desc *desc)
 {
        struct gpio_chip        *chip;
        int value;
+       int offset;
 
        might_sleep_if(extra_checks);
-       chip = gpio_to_chip(gpio);
-       value = chip->get ? chip->get(chip, gpio - chip->base) : 0;
-       trace_gpio_value(gpio, 1, value);
+       chip = desc->chip;
+       offset = gpio_chip_hwgpio(desc);
+       value = chip->get ? chip->get(chip, offset) : 0;
+       trace_gpio_value(desc_to_gpio(desc), 1, value);
        return value;
 }
+
+int gpio_get_value_cansleep(unsigned gpio)
+{
+       return gpiod_get_value_cansleep(gpio_to_desc(gpio));
+}
 EXPORT_SYMBOL_GPL(gpio_get_value_cansleep);
 
-void gpio_set_value_cansleep(unsigned gpio, int value)
+static void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
 {
        struct gpio_chip        *chip;
 
        might_sleep_if(extra_checks);
-       chip = gpio_to_chip(gpio);
-       trace_gpio_value(gpio, 0, value);
-       if (test_bit(FLAG_OPEN_DRAIN,  &gpio_desc[gpio].flags))
-               _gpio_set_open_drain_value(gpio, chip, value);
-       else if (test_bit(FLAG_OPEN_SOURCE,  &gpio_desc[gpio].flags))
-               _gpio_set_open_source_value(gpio, chip, value);
+       chip = desc->chip;
+       trace_gpio_value(desc_to_gpio(desc), 0, value);
+       if (test_bit(FLAG_OPEN_DRAIN,  &desc->flags))
+               _gpio_set_open_drain_value(desc, value);
+       else if (test_bit(FLAG_OPEN_SOURCE,  &desc->flags))
+               _gpio_set_open_source_value(desc, value);
        else
-               chip->set(chip, gpio - chip->base, value);
+               chip->set(chip, gpio_chip_hwgpio(desc), value);
 }
-EXPORT_SYMBOL_GPL(gpio_set_value_cansleep);
 
+void gpio_set_value_cansleep(unsigned gpio, int value)
+{
+       return gpiod_set_value_cansleep(gpio_to_desc(gpio), value);
+}
+EXPORT_SYMBOL_GPL(gpio_set_value_cansleep);
 
 #ifdef CONFIG_DEBUG_FS
 
@@ -1878,14 +2032,14 @@ static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
 {
        unsigned                i;
        unsigned                gpio = chip->base;
-       struct gpio_desc        *gdesc = &gpio_desc[gpio];
+       struct gpio_desc        *gdesc = &chip->desc[0];
        int                     is_out;
 
        for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) {
                if (!test_bit(FLAG_REQUESTED, &gdesc->flags))
                        continue;
 
-               gpio_get_direction(gpio);
+               gpiod_get_direction(gdesc);
                is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
                seq_printf(s, " gpio-%-3d (%-20.20s) %s %s",
                        gpio, gdesc->label,
@@ -1899,46 +2053,35 @@ static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
 
 static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
 {
+       unsigned long flags;
        struct gpio_chip *chip = NULL;
-       unsigned int gpio;
-       void *ret = NULL;
-       loff_t index = 0;
-
-       /* REVISIT this isn't locked against gpio_chip removal ... */
+       loff_t index = *pos;
 
-       for (gpio = 0; gpio_is_valid(gpio); gpio++) {
-               if (gpio_desc[gpio].chip == chip)
-                       continue;
-
-               chip = gpio_desc[gpio].chip;
-               if (!chip)
-                       continue;
+       s->private = "";
 
-               if (index++ >= *pos) {
-                       ret = chip;
-                       break;
+       spin_lock_irqsave(&gpio_lock, flags);
+       list_for_each_entry(chip, &gpio_chips, list)
+               if (index-- == 0) {
+                       spin_unlock_irqrestore(&gpio_lock, flags);
+                       return chip;
                }
-       }
-
-       s->private = "";
+       spin_unlock_irqrestore(&gpio_lock, flags);
 
-       return ret;
+       return NULL;
 }
 
 static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
 {
+       unsigned long flags;
        struct gpio_chip *chip = v;
-       unsigned int gpio;
        void *ret = NULL;
 
-       /* skip GPIOs provided by the current chip */
-       for (gpio = chip->base + chip->ngpio; gpio_is_valid(gpio); gpio++) {
-               chip = gpio_desc[gpio].chip;
-               if (chip) {
-                       ret = chip;
-                       break;
-               }
-       }
+       spin_lock_irqsave(&gpio_lock, flags);
+       if (list_is_last(&chip->list, &gpio_chips))
+               ret = NULL;
+       else
+               ret = list_entry(chip->list.next, struct gpio_chip, list);
+       spin_unlock_irqrestore(&gpio_lock, flags);
 
        s->private = "\n";
        ++*pos;