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: