karo: fdt: fix panel-dpi support

[karo-tx-uboot.git] / drivers / gpio / gpio-uclass.c

diff --git a/drivers/gpio/gpio-uclass.c b/drivers/gpio/gpio-uclass.c
index a69bbd2002e9f62c06f75cb1f1b4b755140eecc2..4cce11fe215f05b2cfbc1d55b5c4e020940b1ee6 100644 (file)
--- a/drivers/gpio/gpio-uclass.c
+++ b/drivers/gpio/gpio-uclass.c
@@ -34,7 +34,7 @@ static int gpio_to_device(unsigned int gpio, struct gpio_desc *desc)
        for (ret = uclass_first_device(UCLASS_GPIO, &dev);
             dev;
             ret = uclass_next_device(&dev)) {
-               uc_priv = dev->uclass_priv;
+               uc_priv = dev_get_uclass_priv(dev);
                if (gpio >= uc_priv->gpio_base &&
                    gpio < uc_priv->gpio_base + uc_priv->gpio_count) {
                        desc->dev = dev;
@@ -48,8 +48,7 @@ static int gpio_to_device(unsigned int gpio, struct gpio_desc *desc)
        return ret ? ret : -ENOENT;
 }
 
-int gpio_lookup_name(const char *name, struct udevice **devp,
-                    unsigned int *offsetp, unsigned int *gpiop)
+int dm_gpio_lookup_name(const char *name, struct gpio_desc *desc)
 {
        struct gpio_dev_priv *uc_priv = NULL;
        struct udevice *dev;
@@ -57,15 +56,13 @@ int gpio_lookup_name(const char *name, struct udevice **devp,
        int numeric;
        int ret;
 
-       if (devp)
-               *devp = NULL;
        numeric = isdigit(*name) ? simple_strtoul(name, NULL, 10) : -1;
        for (ret = uclass_first_device(UCLASS_GPIO, &dev);
             dev;
             ret = uclass_next_device(&dev)) {
                int len;
 
-               uc_priv = dev->uclass_priv;
+               uc_priv = dev_get_uclass_priv(dev);
                if (numeric != -1) {
                        offset = numeric - uc_priv->gpio_base;
                        /* Allow GPIOs to be numbered from 0 */
@@ -84,12 +81,33 @@ int gpio_lookup_name(const char *name, struct udevice **devp,
        if (!dev)
                return ret ? ret : -EINVAL;
 
+       desc->dev = dev;
+       desc->offset = offset;
+
+       return 0;
+}
+
+int gpio_lookup_name(const char *name, struct udevice **devp,
+                    unsigned int *offsetp, unsigned int *gpiop)
+{
+       struct gpio_desc desc;
+       int ret;
+
        if (devp)
-               *devp = dev;
+               *devp = NULL;
+       ret = dm_gpio_lookup_name(name, &desc);
+       if (ret)
+               return ret;
+
+       if (devp)
+               *devp = desc.dev;
        if (offsetp)
-               *offsetp = offset;
-       if (gpiop)
-               *gpiop = uc_priv->gpio_base + offset;
+               *offsetp = desc.offset;
+       if (gpiop) {
+               struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(desc.dev);
+
+               *gpiop = uc_priv->gpio_base + desc.offset;
+       }
 
        return 0;
 }
@@ -109,14 +127,14 @@ static int gpio_find_and_xlate(struct gpio_desc *desc,
        return ops->xlate ? ops->xlate(desc->dev, desc, args) : 0;
 }
 
-static int dm_gpio_request(struct gpio_desc *desc, const char *label)
+int dm_gpio_request(struct gpio_desc *desc, const char *label)
 {
        struct udevice *dev = desc->dev;
        struct gpio_dev_priv *uc_priv;
        char *str;
        int ret;
 
-       uc_priv = dev->uclass_priv;
+       uc_priv = dev_get_uclass_priv(dev);
        if (uc_priv->name[desc->offset])
                return -EBUSY;
        str = strdup(label);
@@ -195,7 +213,7 @@ int _dm_gpio_free(struct udevice *dev, uint offset)
        struct gpio_dev_priv *uc_priv;
        int ret;
 
-       uc_priv = dev->uclass_priv;
+       uc_priv = dev_get_uclass_priv(dev);
        if (!uc_priv->name[offset])
                return -ENXIO;
        if (gpio_get_ops(dev)->free) {
@@ -232,8 +250,12 @@ int gpio_free(unsigned gpio)
 
 static int check_reserved(struct gpio_desc *desc, const char *func)
 {
-       struct gpio_dev_priv *uc_priv = desc->dev->uclass_priv;
+       struct gpio_dev_priv *uc_priv;
 
+       if (!dm_gpio_is_valid(desc))
+               return -ENOENT;
+
+       uc_priv = dev_get_uclass_priv(desc->dev);
        if (!uc_priv->name[desc->offset]) {
                printf("%s: %s: error: gpio %s%d not reserved\n",
                       desc->dev->name, func,
@@ -402,7 +424,7 @@ const char *gpio_get_bank_info(struct udevice *dev, int *bit_count)
        struct gpio_dev_priv *priv;
 
        /* Must be called on an active device */
-       priv = dev->uclass_priv;
+       priv = dev_get_uclass_priv(dev);
        assert(priv);
 
        *bit_count = priv->gpio_count;
@@ -420,7 +442,7 @@ static const char * const gpio_function[GPIOF_COUNT] = {
 int get_function(struct udevice *dev, int offset, bool skip_unused,
                 const char **namep)
 {
-       struct gpio_dev_priv *uc_priv = dev->uclass_priv;
+       struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
        struct dm_gpio_ops *ops = gpio_get_ops(dev);
 
        BUILD_BUG_ON(GPIOF_COUNT != ARRAY_SIZE(gpio_function));
@@ -468,7 +490,7 @@ int gpio_get_status(struct udevice *dev, int offset, char *buf, int buffsize)
        BUILD_BUG_ON(GPIOF_COUNT != ARRAY_SIZE(gpio_function));
 
        *buf = 0;
-       priv = dev->uclass_priv;
+       priv = dev_get_uclass_priv(dev);
        ret = gpio_get_raw_function(dev, offset, NULL);
        if (ret < 0)
                return ret;
@@ -495,22 +517,54 @@ int gpio_get_status(struct udevice *dev, int offset, char *buf, int buffsize)
        return 0;
 }
 
+int gpio_claim_vector(const int *gpio_num_array, const char *fmt)
+{
+       int i, ret;
+       int gpio;
+
+       for (i = 0; i < 32; i++) {
+               gpio = gpio_num_array[i];
+               if (gpio == -1)
+                       break;
+               ret = gpio_requestf(gpio, fmt, i);
+               if (ret)
+                       goto err;
+               ret = gpio_direction_input(gpio);
+               if (ret) {
+                       gpio_free(gpio);
+                       goto err;
+               }
+       }
+
+       return 0;
+err:
+       for (i--; i >= 0; i--)
+               gpio_free(gpio_num_array[i]);
+
+       return ret;
+}
+
 /*
  * get a number comprised of multiple GPIO values. gpio_num_array points to
  * the array of gpio pin numbers to scan, terminated by -1.
  */
-unsigned gpio_get_values_as_int(const int *gpio_num_array)
+int gpio_get_values_as_int(const int *gpio_list)
 {
        int gpio;
        unsigned bitmask = 1;
        unsigned vector = 0;
+       int ret;
 
        while (bitmask &&
-              ((gpio = *gpio_num_array++) != -1)) {
-               if (gpio_get_value(gpio))
+              ((gpio = *gpio_list++) != -1)) {
+               ret = gpio_get_value(gpio);
+               if (ret < 0)
+                       return ret;
+               else if (ret)
                        vector |= bitmask;
                bitmask <<= 1;
        }
+
        return vector;
 }
 
@@ -590,11 +644,7 @@ int gpio_request_list_by_name_nodev(const void *blob, int node,
        int count;
        int ret;
 
-       for (count = 0; ; count++) {
-               if (count >= max_count) {
-                       ret = -ENOSPC;
-                       goto err;
-               }
+       for (count = 0; count < max_count; count++) {
                ret = _gpio_request_by_name_nodev(blob, node, list_name, count,
                                                  &desc[count], flags, true);
                if (ret == -ENOENT)
@@ -680,7 +730,7 @@ static int gpio_renumber(struct udevice *removed_dev)
        base = 0;
        uclass_foreach_dev(dev, uc) {
                if (device_active(dev) && dev != removed_dev) {
-                       uc_priv = dev->uclass_priv;
+                       uc_priv = dev_get_uclass_priv(dev);
                        uc_priv->gpio_base = base;
                        base += uc_priv->gpio_count;
                }
@@ -689,9 +739,21 @@ static int gpio_renumber(struct udevice *removed_dev)
        return 0;
 }
 
+int gpio_get_number(struct gpio_desc *desc)
+{
+       struct udevice *dev = desc->dev;
+       struct gpio_dev_priv *uc_priv;
+
+       if (!dev)
+               return -1;
+       uc_priv = dev->uclass_priv;
+
+       return uc_priv->gpio_base + desc->offset;
+}
+
 static int gpio_post_probe(struct udevice *dev)
 {
-       struct gpio_dev_priv *uc_priv = dev->uclass_priv;
+       struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
 
        uc_priv->name = calloc(uc_priv->gpio_count, sizeof(char *));
        if (!uc_priv->name)
@@ -702,7 +764,7 @@ static int gpio_post_probe(struct udevice *dev)
 
 static int gpio_pre_remove(struct udevice *dev)
 {
-       struct gpio_dev_priv *uc_priv = dev->uclass_priv;
+       struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
        int i;
 
        for (i = 0; i < uc_priv->gpio_count; i++) {
@@ -717,6 +779,7 @@ static int gpio_pre_remove(struct udevice *dev)
 UCLASS_DRIVER(gpio) = {
        .id             = UCLASS_GPIO,
        .name           = "gpio",
+       .flags          = DM_UC_FLAG_SEQ_ALIAS,
        .post_probe     = gpio_post_probe,
        .pre_remove     = gpio_pre_remove,
        .per_device_auto_alloc_size = sizeof(struct gpio_dev_priv),