Merge tag 'regulator-v3.16' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regulator into next

Pull regulator updates from Mark Brown:
 "The bulk of the changes for this release are a few new drivers however
  there are a couple of noticable core changes and the usual stream of
  cleanups and fixes:

   - move disable of unused regulators later in init so it comes after
     deferred probe has iterated making startup smoother.
   - fixes to reference counting of the DT nodes for constraints from
     Charles Keepax.  This has little practical impact since all real
     users of the regulator bindings use FDT which doesn't need the
     reference counting.
   - lots of cleanups, especially to the Samsung drivers.
   - support for Linear Technologies LTC3589, Texas Instruments
     TPS658640 and X-Powers AXP20x"

* tag 'regulator-v3.16' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regulator: (64 commits)
  regulator: pbias: remove unnecessary OOM messages
  regulator: max8649: remove unnecessary OOM messages
  regulator: core: Fix the init of DT defined fixed regulators
  regulator: core: Disable unused regulators after deferred probing is done
  regulator: Don't disable unused regulators we don't have permission for
  regulator: axp20x: Use regulator_map_voltage_ascend for LDO4
  regulator: use of_property_read_{bool|u32}()
  regulator: Fix regulator_get_{optional,exclusive}() documentation
  regulators: Add definition of regulator_set_voltage_time() for !CONFIG_REGULATOR
  regulator: arizona-ldo1: add missing #include
  regulator: pfuze100: Support enable/disable for fixed regulator
  regulator: ltc3589: Remove ltc3589_list_voltage_fixed function
  regulator: ltc3589: Fix module dependency
  regulator: tps6586x: Remove unused to_tps6586x_dev() function
  regulator: tps65218: Convert to use regulator_set_voltage_time_sel
  regulator: tps6586x: Add support for the TPS658640
  regulator: tps6586x: Prepare supporting fixed regulators
  regulator: pfuze100: Don't allocate an invalid gpio
  regulator: pfuze100: Support SWB enable/disable
  regulator: fixed: use of_property_read_{bool|u32}()
  ...

1 files changed, 96 insertions, 17 deletions

diff --git a/drivers/regulator/s2mps11.c b/drivers/regulator/s2mps11.c
index e713c162fbd4..02e2fb2fca66 100644
--- a/drivers/regulator/s2mps11.c
+++ b/drivers/regulator/s2mps11.c
@@ -27,6 +27,7 @@
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
 #include <linux/regulator/of_regulator.h>
+#include <linux/of_gpio.h>
 #include <linux/mfd/samsung/core.h>
 #include <linux/mfd/samsung/s2mps11.h>
 #include <linux/mfd/samsung/s2mps14.h>
@@ -44,6 +45,8 @@ struct s2mps11_info {
          * was enabled.
          */
         unsigned int s2mps14_suspend_state:30;
+        /* Array of size rdev_num with GPIO-s for external sleep control */
+        int *ext_control_gpio;
 };
 
 static int get_ramp_delay(int ramp_delay)
@@ -202,11 +205,16 @@ static int s2mps11_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
         if (!ramp_enable)
                 goto ramp_disable;
 
-        ret = regmap_update_bits(rdev->regmap, S2MPS11_REG_RAMP,
-                                 1 << enable_shift, 1 << enable_shift);
-        if (ret) {
-                dev_err(&rdev->dev, "failed to enable ramp rate\n");
-                return ret;
+        /* Ramp delay can be enabled/disabled only for buck[2346] */
+        if ((rdev_get_id(rdev) >= S2MPS11_BUCK2 &&
+                        rdev_get_id(rdev) <= S2MPS11_BUCK4) ||
+                        rdev_get_id(rdev) == S2MPS11_BUCK6)  {
+                ret = regmap_update_bits(rdev->regmap, S2MPS11_REG_RAMP,
+                                         1 << enable_shift, 1 << enable_shift);
+                if (ret) {
+                        dev_err(&rdev->dev, "failed to enable ramp rate\n");
+                        return ret;
+                }
         }
 
         ramp_val = get_ramp_delay(ramp_delay);
@@ -409,6 +417,8 @@ static int s2mps14_regulator_enable(struct regulator_dev *rdev)
 
         if (s2mps11->s2mps14_suspend_state & (1 << rdev_get_id(rdev)))
                 val = S2MPS14_ENABLE_SUSPEND;
+        else if (gpio_is_valid(s2mps11->ext_control_gpio[rdev_get_id(rdev)]))
+                val = S2MPS14_ENABLE_EXT_CONTROL;
         else
                 val = rdev->desc->enable_mask;
 
@@ -565,12 +575,61 @@ static const struct regulator_desc s2mps14_regulators[] = {
         regulator_desc_s2mps14_buck1235(5),
 };
 
+static int s2mps14_pmic_enable_ext_control(struct s2mps11_info *s2mps11,
+                struct regulator_dev *rdev)
+{
+        return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
+                        rdev->desc->enable_mask, S2MPS14_ENABLE_EXT_CONTROL);
+}
+
+static void s2mps14_pmic_dt_parse_ext_control_gpio(struct platform_device *pdev,
+                struct of_regulator_match *rdata, struct s2mps11_info *s2mps11)
+{
+        int *gpio = s2mps11->ext_control_gpio;
+        unsigned int i;
+        unsigned int valid_regulators[3] = { S2MPS14_LDO10, S2MPS14_LDO11,
+                S2MPS14_LDO12 };
+
+        for (i = 0; i < ARRAY_SIZE(valid_regulators); i++) {
+                unsigned int reg = valid_regulators[i];
+
+                if (!rdata[reg].init_data || !rdata[reg].of_node)
+                        continue;
+
+                gpio[reg] = of_get_named_gpio(rdata[reg].of_node,
+                                "samsung,ext-control-gpios", 0);
+                if (gpio_is_valid(gpio[reg]))
+                        dev_dbg(&pdev->dev, "Using GPIO %d for ext-control over %d/%s\n",
+                                        gpio[reg], reg, rdata[reg].name);
+        }
+}
+
+static int s2mps11_pmic_dt_parse(struct platform_device *pdev,
+                struct of_regulator_match *rdata, struct s2mps11_info *s2mps11,
+                enum sec_device_type dev_type)
+{
+        struct device_node *reg_np;
+
+        reg_np = of_get_child_by_name(pdev->dev.parent->of_node, "regulators");
+        if (!reg_np) {
+                dev_err(&pdev->dev, "could not find regulators sub-node\n");
+                return -EINVAL;
+        }
+
+        of_regulator_match(&pdev->dev, reg_np, rdata, s2mps11->rdev_num);
+        if (dev_type == S2MPS14X)
+                s2mps14_pmic_dt_parse_ext_control_gpio(pdev, rdata, s2mps11);
+
+        of_node_put(reg_np);
+
+        return 0;
+}
+
 static int s2mps11_pmic_probe(struct platform_device *pdev)
 {
         struct sec_pmic_dev *iodev = dev_get_drvdata(pdev->dev.parent);
-        struct sec_platform_data *pdata = iodev->pdata;
+        struct sec_platform_data *pdata = NULL;
         struct of_regulator_match *rdata = NULL;
-        struct device_node *reg_np = NULL;
         struct regulator_config config = { };
         struct s2mps11_info *s2mps11;
         int i, ret = 0;
@@ -597,8 +656,21 @@ static int s2mps11_pmic_probe(struct platform_device *pdev)
                 return -EINVAL;
         };
 
+        s2mps11->ext_control_gpio = devm_kzalloc(&pdev->dev,
+                        sizeof(*s2mps11->ext_control_gpio) * s2mps11->rdev_num,
+                        GFP_KERNEL);
+        if (!s2mps11->ext_control_gpio)
+                return -ENOMEM;
+        /*
+         * 0 is a valid GPIO so initialize all GPIO-s to negative value
+         * to indicate that external control won't be used for this regulator.
+         */
+        for (i = 0; i < s2mps11->rdev_num; i++)
+                s2mps11->ext_control_gpio[i] = -EINVAL;
+
         if (!iodev->dev->of_node) {
-                if (pdata) {
+                if (iodev->pdata) {
+                        pdata = iodev->pdata;
                         goto common_reg;
                 } else {
                         dev_err(pdev->dev.parent,
@@ -614,15 +686,9 @@ static int s2mps11_pmic_probe(struct platform_device *pdev)
         for (i = 0; i < s2mps11->rdev_num; i++)
                 rdata[i].name = regulators[i].name;
 
-        reg_np = of_get_child_by_name(iodev->dev->of_node, "regulators");
-        if (!reg_np) {
-                dev_err(&pdev->dev, "could not find regulators sub-node\n");
-                ret = -EINVAL;
+        ret = s2mps11_pmic_dt_parse(pdev, rdata, s2mps11, dev_type);
+        if (ret)
                 goto out;
-        }
-
-        of_regulator_match(&pdev->dev, reg_np, rdata, s2mps11->rdev_num);
-        of_node_put(reg_np);
 
 common_reg:
         platform_set_drvdata(pdev, s2mps11);
@@ -630,16 +696,18 @@ common_reg:
         config.dev = &pdev->dev;
         config.regmap = iodev->regmap_pmic;
         config.driver_data = s2mps11;
+        config.ena_gpio_flags = GPIOF_OUT_INIT_HIGH;
         for (i = 0; i < s2mps11->rdev_num; i++) {
                 struct regulator_dev *regulator;
 
-                if (!reg_np) {
+                if (pdata) {
                         config.init_data = pdata->regulators[i].initdata;
                         config.of_node = pdata->regulators[i].reg_node;
                 } else {
                         config.init_data = rdata[i].init_data;
                         config.of_node = rdata[i].of_node;
                 }
+                config.ena_gpio = s2mps11->ext_control_gpio[i];
 
                 regulator = devm_regulator_register(&pdev->dev,
                                                 &regulators[i], &config);
@@ -649,6 +717,17 @@ common_reg:
                                 i);
                         goto out;
                 }
+
+                if (gpio_is_valid(s2mps11->ext_control_gpio[i])) {
+                        ret = s2mps14_pmic_enable_ext_control(s2mps11,
+                                        regulator);
+                        if (ret < 0) {
+                                dev_err(&pdev->dev,
+                                                "failed to enable GPIO control over %s: %d\n",
+                                                regulator->desc->name, ret);
+                                goto out;
+                        }
+                }
         }
 
 out: