13 files changed, 224 insertions, 78 deletions

diff --git a/Documentation/devicetree/bindings/regulator/gpio-regulator.txt b/Documentation/devicetree/bindings/regulator/gpio-regulator.txt
index 63c659800c03..e5cac1e0ca8a 100644
--- a/Documentation/devicetree/bindings/regulator/gpio-regulator.txt
+++ b/Documentation/devicetree/bindings/regulator/gpio-regulator.txt
@@ -8,8 +8,12 @@ Required properties:
 Optional properties:
 - enable-gpio           : GPIO to use to enable/disable the regulator.
 - gpios                 : GPIO group used to control voltage.
+- gpios-states          : gpios pin's initial states array. 0: LOW, 1: HIGH.
+                          defualt is LOW if nothing is specified.
 - startup-delay-us      : Startup time in microseconds.
 - enable-active-high    : Polarity of GPIO is active high (default is low).
+- regulator-type        : Specifies what is being regulated, must be either
+                          "voltage" or "current", defaults to current.
 
 Any property defined as part of the core regulator binding defined in
 regulator.txt can also be used.
diff --git a/drivers/base/devres.c b/drivers/base/devres.c
index 545c4de412c3..db4e264eecb6 100644
--- a/drivers/base/devres.c
+++ b/drivers/base/devres.c
@@ -791,6 +791,32 @@ void * devm_kmalloc(struct device *dev, size_t size, gfp_t gfp)
 EXPORT_SYMBOL_GPL(devm_kmalloc);
 
 /**
+ * devm_kstrdup - Allocate resource managed space and
+ *                copy an existing string into that.
+ * @dev: Device to allocate memory for
+ * @s: the string to duplicate
+ * @gfp: the GFP mask used in the devm_kmalloc() call when
+ *       allocating memory
+ * RETURNS:
+ * Pointer to allocated string on success, NULL on failure.
+ */
+char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp)
+{
+        size_t size;
+        char *buf;
+
+        if (!s)
+                return NULL;
+
+        size = strlen(s) + 1;
+        buf = devm_kmalloc(dev, size, gfp);
+        if (buf)
+                memcpy(buf, s, size);
+        return buf;
+}
+EXPORT_SYMBOL_GPL(devm_kstrdup);
+
+/**
  * devm_kfree - Resource-managed kfree
  * @dev: Device this memory belongs to
  * @p: Memory to free
diff --git a/drivers/of/base.c b/drivers/of/base.c
index 89e888a78899..1b95a405628f 100644
--- a/drivers/of/base.c
+++ b/drivers/of/base.c
@@ -904,6 +904,38 @@ struct device_node *of_find_node_by_phandle(phandle handle)
 EXPORT_SYMBOL(of_find_node_by_phandle);
 
 /**
+ * of_property_count_elems_of_size - Count the number of elements in a property
+ *
+ * @np:         device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ * @elem_size:  size of the individual element
+ *
+ * Search for a property in a device node and count the number of elements of
+ * size elem_size in it. Returns number of elements on sucess, -EINVAL if the
+ * property does not exist or its length does not match a multiple of elem_size
+ * and -ENODATA if the property does not have a value.
+ */
+int of_property_count_elems_of_size(const struct device_node *np,
+                                const char *propname, int elem_size)
+{
+        struct property *prop = of_find_property(np, propname, NULL);
+
+        if (!prop)
+                return -EINVAL;
+        if (!prop->value)
+                return -ENODATA;
+
+        if (prop->length % elem_size != 0) {
+                pr_err("size of %s in node %s is not a multiple of %d\n",
+                       propname, np->full_name, elem_size);
+                return -EINVAL;
+        }
+
+        return prop->length / elem_size;
+}
+EXPORT_SYMBOL_GPL(of_property_count_elems_of_size);
+
+/**
  * of_find_property_value_of_size
  *
  * @np:         device node from which the property value is to be read.
diff --git a/drivers/regulator/fan53555.c b/drivers/regulator/fan53555.c
index 7ca3d9e3b0fe..714fd9a89aa1 100644
--- a/drivers/regulator/fan53555.c
+++ b/drivers/regulator/fan53555.c
@@ -90,11 +90,11 @@ static int fan53555_set_suspend_voltage(struct regulator_dev *rdev, int uV)
                 return 0;
         ret = regulator_map_voltage_linear(rdev, uV, uV);
         if (ret < 0)
-                return -EINVAL;
+                return ret;
         ret = regmap_update_bits(di->regmap, di->sleep_reg,
                                         VSEL_NSEL_MASK, ret);
         if (ret < 0)
-                return -EINVAL;
+                return ret;
         /* Cache the sleep voltage setting.
          * Might not be the real voltage which is rounded */
         di->sleep_vol_cache = uV;
@@ -244,10 +244,9 @@ static int fan53555_regulator_probe(struct i2c_client *client,
 
         di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info),
                                         GFP_KERNEL);
-        if (!di) {
-                dev_err(&client->dev, "Failed to allocate device info data!\n");
+        if (!di)
                 return -ENOMEM;
-        }
+
         di->regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config);
         if (IS_ERR(di->regmap)) {
                 dev_err(&client->dev, "Failed to allocate regmap!\n");
@@ -260,14 +259,14 @@ static int fan53555_regulator_probe(struct i2c_client *client,
         ret = regmap_read(di->regmap, FAN53555_ID1, &val);
         if (ret < 0) {
                 dev_err(&client->dev, "Failed to get chip ID!\n");
-                return -ENODEV;
+                return ret;
         }
         di->chip_id = val & DIE_ID;
         /* Get chip revision */
         ret = regmap_read(di->regmap, FAN53555_ID2, &val);
         if (ret < 0) {
                 dev_err(&client->dev, "Failed to get chip Rev!\n");
-                return -ENODEV;
+                return ret;
         }
         di->chip_rev = val & DIE_REV;
         dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n",
diff --git a/drivers/regulator/fixed.c b/drivers/regulator/fixed.c
index 5ea64b94341c..c61f7e97e4f8 100644
--- a/drivers/regulator/fixed.c
+++ b/drivers/regulator/fixed.c
@@ -130,17 +130,15 @@ static int reg_fixed_voltage_probe(struct platform_device *pdev)
 
         drvdata = devm_kzalloc(&pdev->dev, sizeof(struct fixed_voltage_data),
                                GFP_KERNEL);
-        if (drvdata == NULL) {
-                dev_err(&pdev->dev, "Failed to allocate device data\n");
-                ret = -ENOMEM;
-                goto err;
-        }
+        if (!drvdata)
+                return -ENOMEM;
 
-        drvdata->desc.name = kstrdup(config->supply_name, GFP_KERNEL);
+        drvdata->desc.name = devm_kstrdup(&pdev->dev,
+                                          config->supply_name,
+                                          GFP_KERNEL);
         if (drvdata->desc.name == NULL) {
                 dev_err(&pdev->dev, "Failed to allocate supply name\n");
-                ret = -ENOMEM;
-                goto err;
+                return -ENOMEM;
         }
         drvdata->desc.type = REGULATOR_VOLTAGE;
         drvdata->desc.owner = THIS_MODULE;
@@ -149,13 +147,13 @@ static int reg_fixed_voltage_probe(struct platform_device *pdev)
         drvdata->desc.enable_time = config->startup_delay;
 
         if (config->input_supply) {
-                drvdata->desc.supply_name = kstrdup(config->input_supply,
-                                                        GFP_KERNEL);
+                drvdata->desc.supply_name = devm_kstrdup(&pdev->dev,
+                                            config->input_supply,
+                                            GFP_KERNEL);
                 if (!drvdata->desc.supply_name) {
                         dev_err(&pdev->dev,
                                 "Failed to allocate input supply\n");
-                        ret = -ENOMEM;
-                        goto err_name;
+                        return -ENOMEM;
                 }
         }
 
@@ -186,11 +184,12 @@ static int reg_fixed_voltage_probe(struct platform_device *pdev)
         cfg.driver_data = drvdata;
         cfg.of_node = pdev->dev.of_node;
 
-        drvdata->dev = regulator_register(&drvdata->desc, &cfg);
+        drvdata->dev = devm_regulator_register(&pdev->dev, &drvdata->desc,
+                                               &cfg);
         if (IS_ERR(drvdata->dev)) {
                 ret = PTR_ERR(drvdata->dev);
                 dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret);
-                goto err_input;
+                return ret;
         }
 
         platform_set_drvdata(pdev, drvdata);
@@ -199,24 +198,6 @@ static int reg_fixed_voltage_probe(struct platform_device *pdev)
                 drvdata->desc.fixed_uV);
 
         return 0;
-
-err_input:
-        kfree(drvdata->desc.supply_name);
-err_name:
-        kfree(drvdata->desc.name);
-err:
-        return ret;
-}
-
-static int reg_fixed_voltage_remove(struct platform_device *pdev)
-{
-        struct fixed_voltage_data *drvdata = platform_get_drvdata(pdev);
-
-        regulator_unregister(drvdata->dev);
-        kfree(drvdata->desc.supply_name);
-        kfree(drvdata->desc.name);
-
-        return 0;
 }
 
 #if defined(CONFIG_OF)
@@ -229,7 +210,6 @@ MODULE_DEVICE_TABLE(of, fixed_of_match);
 
 static struct platform_driver regulator_fixed_voltage_driver = {
         .probe          = reg_fixed_voltage_probe,
-        .remove         = reg_fixed_voltage_remove,
         .driver         = {
                 .name           = "reg-fixed-voltage",
                 .owner          = THIS_MODULE,
diff --git a/drivers/regulator/gpio-regulator.c b/drivers/regulator/gpio-regulator.c
index c0a1d00b78c9..989b23b377c0 100644
--- a/drivers/regulator/gpio-regulator.c
+++ b/drivers/regulator/gpio-regulator.c
@@ -136,7 +136,6 @@ static struct gpio_regulator_config *
 of_get_gpio_regulator_config(struct device *dev, struct device_node *np)
 {
         struct gpio_regulator_config *config;
-        struct property *prop;
         const char *regtype;
         int proplen, gpio, i;
         int ret;
@@ -172,22 +171,35 @@ of_get_gpio_regulator_config(struct device *dev, struct device_node *np)
         if (!config->gpios)
                 return ERR_PTR(-ENOMEM);
 
+        proplen = of_property_count_u32_elems(np, "gpios-states");
+        /* optional property */
+        if (proplen < 0)
+                proplen = 0;
+
+        if (proplen > 0 && proplen != config->nr_gpios) {
+                dev_warn(dev, "gpios <-> gpios-states mismatch\n");
+                proplen = 0;
+        }
+
         for (i = 0; i < config->nr_gpios; i++) {
                 gpio = of_get_named_gpio(np, "gpios", i);
                 if (gpio < 0)
                         break;
                 config->gpios[i].gpio = gpio;
+                if (proplen > 0) {
+                        of_property_read_u32_index(np, "gpios-states", i, &ret);
+                        if (ret)
+                                config->gpios[i].flags = GPIOF_OUT_INIT_HIGH;
+                }
         }
 
         /* Fetch states. */
-        prop = of_find_property(np, "states", NULL);
-        if (!prop) {
+        proplen = of_property_count_u32_elems(np, "states");
+        if (proplen < 0) {
                 dev_err(dev, "No 'states' property found\n");
                 return ERR_PTR(-EINVAL);
         }
 
-        proplen = prop->length / sizeof(int);
-
         config->states = devm_kzalloc(dev,
                                 sizeof(struct gpio_regulator_state)
                                 * (proplen / 2),
@@ -196,10 +208,10 @@ of_get_gpio_regulator_config(struct device *dev, struct device_node *np)
                 return ERR_PTR(-ENOMEM);
 
         for (i = 0; i < proplen / 2; i++) {
-                config->states[i].value =
-                        be32_to_cpup((int *)prop->value + (i * 2));
-                config->states[i].gpios =
-                        be32_to_cpup((int *)prop->value + (i * 2 + 1));
+                of_property_read_u32_index(np, "states", i * 2,
+                                           &config->states[i].value);
+                of_property_read_u32_index(np, "states", i * 2 + 1,
+                                           &config->states[i].gpios);
         }
         config->nr_states = i;
 
@@ -239,10 +251,8 @@ static int gpio_regulator_probe(struct platform_device *pdev)
 
         drvdata = devm_kzalloc(&pdev->dev, sizeof(struct gpio_regulator_data),
                                GFP_KERNEL);
-        if (drvdata == NULL) {
-                dev_err(&pdev->dev, "Failed to allocate device data\n");
+        if (drvdata == NULL)
                 return -ENOMEM;
-        }
 
         drvdata->desc.name = kstrdup(config->supply_name, GFP_KERNEL);
         if (drvdata->desc.name == NULL) {
diff --git a/drivers/regulator/helpers.c b/drivers/regulator/helpers.c
index e221a271ba56..cbc39096c78d 100644
--- a/drivers/regulator/helpers.c
+++ b/drivers/regulator/helpers.c
@@ -37,10 +37,17 @@ int regulator_is_enabled_regmap(struct regulator_dev *rdev)
         if (ret != 0)
                 return ret;
 
-        if (rdev->desc->enable_is_inverted)
-                return (val & rdev->desc->enable_mask) == 0;
-        else
-                return (val & rdev->desc->enable_mask) != 0;
+        val &= rdev->desc->enable_mask;
+
+        if (rdev->desc->enable_is_inverted) {
+                if (rdev->desc->enable_val)
+                        return val != rdev->desc->enable_val;
+                return val == 0;
+        } else {
+                if (rdev->desc->enable_val)
+                        return val == rdev->desc->enable_val;
+                return val != 0;
+        }
 }
 EXPORT_SYMBOL_GPL(regulator_is_enabled_regmap);
 
@@ -57,10 +64,13 @@ int regulator_enable_regmap(struct regulator_dev *rdev)
 {
         unsigned int val;
 
-        if (rdev->desc->enable_is_inverted)
-                val = 0;
-        else
-                val = rdev->desc->enable_mask;
+        if (rdev->desc->enable_is_inverted) {
+                val = rdev->desc->disable_val;
+        } else {
+                val = rdev->desc->enable_val;
+                if (!val)
+                        val = rdev->desc->enable_mask;
+        }
 
         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
                                   rdev->desc->enable_mask, val);
@@ -80,10 +90,13 @@ int regulator_disable_regmap(struct regulator_dev *rdev)
 {
         unsigned int val;
 
-        if (rdev->desc->enable_is_inverted)
-                val = rdev->desc->enable_mask;
-        else
-                val = 0;
+        if (rdev->desc->enable_is_inverted) {
+                val = rdev->desc->enable_val;
+                if (!val)
+                        val = rdev->desc->enable_mask;
+        } else {
+                val = rdev->desc->disable_val;
+        }
 
         return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
                                   rdev->desc->enable_mask, val);
@@ -419,10 +432,13 @@ int regulator_set_bypass_regmap(struct regulator_dev *rdev, bool enable)
 {
         unsigned int val;
 
-        if (enable)
-                val = rdev->desc->bypass_mask;
-        else
-                val = 0;
+        if (enable) {
+                val = rdev->desc->bypass_val_on;
+                if (!val)
+                        val = rdev->desc->bypass_mask;
+        } else {
+                val = rdev->desc->bypass_val_off;
+        }
 
         return regmap_update_bits(rdev->regmap, rdev->desc->bypass_reg,
                                   rdev->desc->bypass_mask, val);
diff --git a/drivers/regulator/lp3971.c b/drivers/regulator/lp3971.c
index 3b1102b75071..66fd2330dca0 100644
--- a/drivers/regulator/lp3971.c
+++ b/drivers/regulator/lp3971.c
@@ -327,7 +327,7 @@ static int lp3971_i2c_read(struct i2c_client *i2c, char reg, int count,
                 return -EIO;
         ret = i2c_smbus_read_byte_data(i2c, reg);
         if (ret < 0)
-                return -EIO;
+                return ret;
 
         *dest = ret;
         return 0;
diff --git a/drivers/regulator/lp872x.c b/drivers/regulator/lp872x.c
index 2e4734ff79fc..2e022aabd951 100644
--- a/drivers/regulator/lp872x.c
+++ b/drivers/regulator/lp872x.c
@@ -211,7 +211,7 @@ static int lp872x_get_timestep_usec(struct lp872x *lp)
 
         ret = lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val);
         if (ret)
-                return -EINVAL;
+                return ret;
 
         val = (val & mask) >> shift;
         if (val >= size)
@@ -229,7 +229,7 @@ static int lp872x_regulator_enable_time(struct regulator_dev *rdev)
         u8 addr, val;
 
         if (time_step_us < 0)
-                return -EINVAL;
+                return time_step_us;
 
         switch (rid) {
         case LP8720_ID_LDO1 ... LP8720_ID_BUCK:
diff --git a/drivers/regulator/max14577.c b/drivers/regulator/max14577.c
index e0619526708c..ed60baaeceec 100644
--- a/drivers/regulator/max14577.c
+++ b/drivers/regulator/max14577.c
@@ -1,7 +1,7 @@
 /*
  * max14577.c - Regulator driver for the Maxim 14577
  *
- * Copyright (C) 2013 Samsung Electronics
+ * Copyright (C) 2013,2014 Samsung Electronics
  * Krzysztof Kozlowski <k.kozlowski@samsung.com>
  *
  * This program is free software; you can redistribute it and/or modify
@@ -22,12 +22,6 @@
 #include <linux/mfd/max14577-private.h>
 #include <linux/regulator/of_regulator.h>
 
-struct max14577_regulator {
-        struct device *dev;
-        struct max14577 *max14577;
-        struct regulator_dev **regulators;
-};
-
 static int max14577_reg_is_enabled(struct regulator_dev *rdev)
 {
         int rid = rdev_get_id(rdev);
diff --git a/include/linux/device.h b/include/linux/device.h
index 952b01033c32..ec1b6e21f0ef 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -626,6 +626,7 @@ static inline void *devm_kcalloc(struct device *dev,
         return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO);
 }
 extern void devm_kfree(struct device *dev, void *p);
+extern char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp);
 
 void __iomem *devm_ioremap_resource(struct device *dev, struct resource *res);
 void __iomem *devm_request_and_ioremap(struct device *dev,
diff --git a/include/linux/of.h b/include/linux/of.h
index 435cb995904d..83d1ac80c91e 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -198,6 +198,8 @@ extern struct device_node *of_find_node_with_property(
 extern struct property *of_find_property(const struct device_node *np,
                                          const char *name,
                                          int *lenp);
+extern int of_property_count_elems_of_size(const struct device_node *np,
+                                const char *propname, int elem_size);
 extern int of_property_read_u32_index(const struct device_node *np,
                                        const char *propname,
                                        u32 index, u32 *out_value);
@@ -390,6 +392,12 @@ static inline struct device_node *of_find_compatible_node(
         return NULL;
 }
 
+static inline int of_property_count_elems_of_size(const struct device_node *np,
+                        const char *propname, int elem_size)
+{
+        return -ENOSYS;
+}
+
 static inline int of_property_read_u32_index(const struct device_node *np,
                         const char *propname, u32 index, u32 *out_value)
 {
@@ -536,6 +544,74 @@ static inline struct device_node *of_find_matching_node(
 }
 
 /**
+ * of_property_count_u8_elems - Count the number of u8 elements in a property
+ *
+ * @np:         device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u8 elements
+ * in it. Returns number of elements on sucess, -EINVAL if the property does
+ * not exist or its length does not match a multiple of u8 and -ENODATA if the
+ * property does not have a value.
+ */
+static inline int of_property_count_u8_elems(const struct device_node *np,
+                                const char *propname)
+{
+        return of_property_count_elems_of_size(np, propname, sizeof(u8));
+}
+
+/**
+ * of_property_count_u16_elems - Count the number of u16 elements in a property
+ *
+ * @np:         device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u16 elements
+ * in it. Returns number of elements on sucess, -EINVAL if the property does
+ * not exist or its length does not match a multiple of u16 and -ENODATA if the
+ * property does not have a value.
+ */
+static inline int of_property_count_u16_elems(const struct device_node *np,
+                                const char *propname)
+{
+        return of_property_count_elems_of_size(np, propname, sizeof(u16));
+}
+
+/**
+ * of_property_count_u32_elems - Count the number of u32 elements in a property
+ *
+ * @np:         device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u32 elements
+ * in it. Returns number of elements on sucess, -EINVAL if the property does
+ * not exist or its length does not match a multiple of u32 and -ENODATA if the
+ * property does not have a value.
+ */
+static inline int of_property_count_u32_elems(const struct device_node *np,
+                                const char *propname)
+{
+        return of_property_count_elems_of_size(np, propname, sizeof(u32));
+}
+
+/**
+ * of_property_count_u64_elems - Count the number of u64 elements in a property
+ *
+ * @np:         device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u64 elements
+ * in it. Returns number of elements on sucess, -EINVAL if the property does
+ * not exist or its length does not match a multiple of u64 and -ENODATA if the
+ * property does not have a value.
+ */
+static inline int of_property_count_u64_elems(const struct device_node *np,
+                                const char *propname)
+{
+        return of_property_count_elems_of_size(np, propname, sizeof(u64));
+}
+
+/**
  * of_property_read_bool - Findfrom a property
  * @np:         device node from which the property value is to be read.
  * @propname:   name of the property to be searched.
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index 9370e65348a4..bbe03a1924c0 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -228,10 +228,14 @@ enum regulator_type {
  *                output when using regulator_set_voltage_sel_regmap
  * @enable_reg: Register for control when using regmap enable/disable ops
  * @enable_mask: Mask for control when using regmap enable/disable ops
+ * @enable_val: Enabling value for control when using regmap enable/disable ops
+ * @disable_val: Disabling value for control when using regmap enable/disable ops
  * @enable_is_inverted: A flag to indicate set enable_mask bits to disable
  *                      when using regulator_enable_regmap and friends APIs.
  * @bypass_reg: Register for control when using regmap set_bypass
  * @bypass_mask: Mask for control when using regmap set_bypass
+ * @bypass_val_on: Enabling value for control when using regmap set_bypass
+ * @bypass_val_off: Disabling value for control when using regmap set_bypass
  *
  * @enable_time: Time taken for initial enable of regulator (in uS).
  */
@@ -263,9 +267,13 @@ struct regulator_desc {
         unsigned int apply_bit;
         unsigned int enable_reg;
         unsigned int enable_mask;
+        unsigned int enable_val;
+        unsigned int disable_val;
         bool enable_is_inverted;
         unsigned int bypass_reg;
         unsigned int bypass_mask;
+        unsigned int bypass_val_on;
+        unsigned int bypass_val_off;
 
         unsigned int enable_time;
 };