6 files changed, 418 insertions, 99 deletions

diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index 903eb37f047a..f0cc9e6dac3a 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -266,11 +266,12 @@ config REGULATOR_LP8788
           This driver supports LP8788 voltage regulator chip.
 
 config REGULATOR_MAX14577
-        tristate "Maxim 14577 regulator"
+        tristate "Maxim 14577/77836 regulator"
         depends on MFD_MAX14577
         help
-          This driver controls a Maxim 14577 regulator via I2C bus.
-          The regulators include safeout LDO and current regulator 'CHARGER'.
+          This driver controls a Maxim MAX14577/77836 regulator via I2C bus.
+          The MAX14577 regulators include safeout LDO and charger current
+          regulator. The MAX77836 has two additional LDOs.
 
 config REGULATOR_MAX1586
         tristate "Maxim 1586/1587 voltage regulator"
diff --git a/drivers/regulator/arizona-ldo1.c b/drivers/regulator/arizona-ldo1.c
index b1033d30b504..d3787e11f535 100644
--- a/drivers/regulator/arizona-ldo1.c
+++ b/drivers/regulator/arizona-ldo1.c
@@ -19,6 +19,7 @@
 #include <linux/platform_device.h>
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
+#include <linux/regulator/of_regulator.h>
 #include <linux/gpio.h>
 #include <linux/slab.h>
 
@@ -178,6 +179,42 @@ static const struct regulator_init_data arizona_ldo1_default = {
         .num_consumer_supplies = 1,
 };
 
+static int arizona_ldo1_of_get_pdata(struct arizona *arizona,
+                                     struct regulator_config *config)
+{
+        struct arizona_pdata *pdata = &arizona->pdata;
+        struct arizona_ldo1 *ldo1 = config->driver_data;
+        struct device_node *init_node, *dcvdd_node;
+        struct regulator_init_data *init_data;
+
+        pdata->ldoena = arizona_of_get_named_gpio(arizona, "wlf,ldoena", true);
+
+        init_node = of_get_child_by_name(arizona->dev->of_node, "ldo1");
+        dcvdd_node = of_parse_phandle(arizona->dev->of_node, "DCVDD-supply", 0);
+
+        if (init_node) {
+                config->of_node = init_node;
+
+                init_data = of_get_regulator_init_data(arizona->dev, init_node);
+
+                if (init_data) {
+                        init_data->consumer_supplies = &ldo1->supply;
+                        init_data->num_consumer_supplies = 1;
+
+                        if (dcvdd_node && dcvdd_node != init_node)
+                                arizona->external_dcvdd = true;
+
+                        pdata->ldo1 = init_data;
+                }
+        } else if (dcvdd_node) {
+                arizona->external_dcvdd = true;
+        }
+
+        of_node_put(dcvdd_node);
+
+        return 0;
+}
+
 static int arizona_ldo1_probe(struct platform_device *pdev)
 {
         struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
@@ -186,6 +223,8 @@ static int arizona_ldo1_probe(struct platform_device *pdev)
         struct arizona_ldo1 *ldo1;
         int ret;
 
+        arizona->external_dcvdd = false;
+
         ldo1 = devm_kzalloc(&pdev->dev, sizeof(*ldo1), GFP_KERNEL);
         if (!ldo1)
                 return -ENOMEM;
@@ -216,6 +255,15 @@ static int arizona_ldo1_probe(struct platform_device *pdev)
         config.dev = arizona->dev;
         config.driver_data = ldo1;
         config.regmap = arizona->regmap;
+
+        if (IS_ENABLED(CONFIG_OF)) {
+                if (!dev_get_platdata(arizona->dev)) {
+                        ret = arizona_ldo1_of_get_pdata(arizona, &config);
+                        if (ret < 0)
+                                return ret;
+                }
+        }
+
         config.ena_gpio = arizona->pdata.ldoena;
 
         if (arizona->pdata.ldo1)
@@ -223,6 +271,13 @@ static int arizona_ldo1_probe(struct platform_device *pdev)
         else
                 config.init_data = &ldo1->init_data;
 
+        /*
+         * LDO1 can only be used to supply DCVDD so if it has no
+         * consumers then DCVDD is supplied externally.
+         */
+        if (config.init_data->num_consumer_supplies == 0)
+                arizona->external_dcvdd = true;
+
         ldo1->regulator = devm_regulator_register(&pdev->dev, desc, &config);
         if (IS_ERR(ldo1->regulator)) {
                 ret = PTR_ERR(ldo1->regulator);
@@ -231,6 +286,8 @@ static int arizona_ldo1_probe(struct platform_device *pdev)
                 return ret;
         }
 
+        of_node_put(config.of_node);
+
         platform_set_drvdata(pdev, ldo1);
 
         return 0;
diff --git a/drivers/regulator/arizona-micsupp.c b/drivers/regulator/arizona-micsupp.c
index 6fdd9bf6927f..b80ebbe88bac 100644
--- a/drivers/regulator/arizona-micsupp.c
+++ b/drivers/regulator/arizona-micsupp.c
@@ -19,6 +19,7 @@
 #include <linux/platform_device.h>
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
+#include <linux/regulator/of_regulator.h>
 #include <linux/gpio.h>
 #include <linux/slab.h>
 #include <linux/workqueue.h>
@@ -195,6 +196,32 @@ static const struct regulator_init_data arizona_micsupp_ext_default = {
         .num_consumer_supplies = 1,
 };
 
+static int arizona_micsupp_of_get_pdata(struct arizona *arizona,
+                                        struct regulator_config *config)
+{
+        struct arizona_pdata *pdata = &arizona->pdata;
+        struct arizona_micsupp *micsupp = config->driver_data;
+        struct device_node *np;
+        struct regulator_init_data *init_data;
+
+        np = of_get_child_by_name(arizona->dev->of_node, "micvdd");
+
+        if (np) {
+                config->of_node = np;
+
+                init_data = of_get_regulator_init_data(arizona->dev, np);
+
+                if (init_data) {
+                        init_data->consumer_supplies = &micsupp->supply;
+                        init_data->num_consumer_supplies = 1;
+
+                        pdata->micvdd = init_data;
+                }
+        }
+
+        return 0;
+}
+
 static int arizona_micsupp_probe(struct platform_device *pdev)
 {
         struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
@@ -234,6 +261,14 @@ static int arizona_micsupp_probe(struct platform_device *pdev)
         config.driver_data = micsupp;
         config.regmap = arizona->regmap;
 
+        if (IS_ENABLED(CONFIG_OF)) {
+                if (!dev_get_platdata(arizona->dev)) {
+                        ret = arizona_micsupp_of_get_pdata(arizona, &config);
+                        if (ret < 0)
+                                return ret;
+                }
+        }
+
         if (arizona->pdata.micvdd)
                 config.init_data = arizona->pdata.micvdd;
         else
@@ -253,6 +288,8 @@ static int arizona_micsupp_probe(struct platform_device *pdev)
                 return ret;
         }
 
+        of_node_put(config.of_node);
+
         platform_set_drvdata(pdev, micsupp);
 
         return 0;
diff --git a/drivers/regulator/max14577.c b/drivers/regulator/max14577.c
index ed60baaeceec..5d9c605cf534 100644
--- a/drivers/regulator/max14577.c
+++ b/drivers/regulator/max14577.c
@@ -1,5 +1,5 @@
 /*
- * max14577.c - Regulator driver for the Maxim 14577
+ * max14577.c - Regulator driver for the Maxim 14577/77836
  *
  * Copyright (C) 2013,2014 Samsung Electronics
  * Krzysztof Kozlowski <k.kozlowski@samsung.com>
@@ -22,6 +22,42 @@
 #include <linux/mfd/max14577-private.h>
 #include <linux/regulator/of_regulator.h>
 
+/*
+ * Valid limits of current for max14577 and max77836 chargers.
+ * They must correspond to MBCICHWRCL and MBCICHWRCH fields in CHGCTRL4
+ * register for given chipset.
+ */
+struct maxim_charger_current {
+        /* Minimal current, set in CHGCTRL4/MBCICHWRCL, uA */
+        unsigned int min;
+        /*
+         * Minimal current when high setting is active,
+         * set in CHGCTRL4/MBCICHWRCH, uA
+         */
+        unsigned int high_start;
+        /* Value of one step in high setting, uA */
+        unsigned int high_step;
+        /* Maximum current of high setting, uA */
+        unsigned int max;
+};
+
+/* Table of valid charger currents for different Maxim chipsets */
+static const struct maxim_charger_current maxim_charger_currents[] = {
+        [MAXIM_DEVICE_TYPE_UNKNOWN] = { 0, 0, 0, 0 },
+        [MAXIM_DEVICE_TYPE_MAX14577] = {
+                .min            = MAX14577_REGULATOR_CURRENT_LIMIT_MIN,
+                .high_start     = MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START,
+                .high_step      = MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP,
+                .max            = MAX14577_REGULATOR_CURRENT_LIMIT_MAX,
+        },
+        [MAXIM_DEVICE_TYPE_MAX77836] = {
+                .min            = MAX77836_REGULATOR_CURRENT_LIMIT_MIN,
+                .high_start     = MAX77836_REGULATOR_CURRENT_LIMIT_HIGH_START,
+                .high_step      = MAX77836_REGULATOR_CURRENT_LIMIT_HIGH_STEP,
+                .max            = MAX77836_REGULATOR_CURRENT_LIMIT_MAX,
+        },
+};
+
 static int max14577_reg_is_enabled(struct regulator_dev *rdev)
 {
         int rid = rdev_get_id(rdev);
@@ -47,6 +83,9 @@ static int max14577_reg_get_current_limit(struct regulator_dev *rdev)
 {
         u8 reg_data;
         struct regmap *rmap = rdev->regmap;
+        struct max14577 *max14577 = rdev_get_drvdata(rdev);
+        const struct maxim_charger_current *limits =
+                &maxim_charger_currents[max14577->dev_type];
 
         if (rdev_get_id(rdev) != MAX14577_CHARGER)
                 return -EINVAL;
@@ -54,12 +93,11 @@ static int max14577_reg_get_current_limit(struct regulator_dev *rdev)
         max14577_read_reg(rmap, MAX14577_CHG_REG_CHG_CTRL4, &reg_data);
 
         if ((reg_data & CHGCTRL4_MBCICHWRCL_MASK) == 0)
-                return MAX14577_REGULATOR_CURRENT_LIMIT_MIN;
+                return limits->min;
 
         reg_data = ((reg_data & CHGCTRL4_MBCICHWRCH_MASK) >>
                         CHGCTRL4_MBCICHWRCH_SHIFT);
-        return MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START +
-                reg_data * MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP;
+        return limits->high_start + reg_data * limits->high_step;
 }
 
 static int max14577_reg_set_current_limit(struct regulator_dev *rdev,
@@ -67,33 +105,39 @@ static int max14577_reg_set_current_limit(struct regulator_dev *rdev,
 {
         int i, current_bits = 0xf;
         u8 reg_data;
+        struct max14577 *max14577 = rdev_get_drvdata(rdev);
+        const struct maxim_charger_current *limits =
+                &maxim_charger_currents[max14577->dev_type];
 
         if (rdev_get_id(rdev) != MAX14577_CHARGER)
                 return -EINVAL;
 
-        if (min_uA > MAX14577_REGULATOR_CURRENT_LIMIT_MAX ||
-                        max_uA < MAX14577_REGULATOR_CURRENT_LIMIT_MIN)
+        if (min_uA > limits->max || max_uA < limits->min)
                 return -EINVAL;
 
-        if (max_uA < MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START) {
-                /* Less than 200 mA, so set 90mA (turn only Low Bit off) */
+        if (max_uA < limits->high_start) {
+                /*
+                 * Less than high_start,
+                 * so set the minimal current (turn only Low Bit off)
+                 */
                 u8 reg_data = 0x0 << CHGCTRL4_MBCICHWRCL_SHIFT;
                 return max14577_update_reg(rdev->regmap,
                                 MAX14577_CHG_REG_CHG_CTRL4,
                                 CHGCTRL4_MBCICHWRCL_MASK, reg_data);
         }
 
-        /* max_uA is in range: <LIMIT_HIGH_START, inifinite>, so search for
-         * valid current starting from LIMIT_MAX. */
-        for (i = MAX14577_REGULATOR_CURRENT_LIMIT_MAX;
-                        i >= MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START;
-                        i -= MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP) {
+        /*
+         * max_uA is in range: <high_start, inifinite>, so search for
+         * valid current starting from maximum current.
+         */
+        for (i = limits->max; i >= limits->high_start; i -= limits->high_step) {
                 if (i <= max_uA)
                         break;
                 current_bits--;
         }
         BUG_ON(current_bits < 0); /* Cannot happen */
-        /* Turn Low Bit on (use range 200mA-950 mA) */
+
+        /* Turn Low Bit on (use range high_start-max)... */
         reg_data = 0x1 << CHGCTRL4_MBCICHWRCL_SHIFT;
         /* and set proper High Bits */
         reg_data |= current_bits << CHGCTRL4_MBCICHWRCH_SHIFT;
@@ -118,7 +162,7 @@ static struct regulator_ops max14577_charger_ops = {
         .set_current_limit      = max14577_reg_set_current_limit,
 };
 
-static const struct regulator_desc supported_regulators[] = {
+static const struct regulator_desc max14577_supported_regulators[] = {
         [MAX14577_SAFEOUT] = {
                 .name           = "SAFEOUT",
                 .id             = MAX14577_SAFEOUT,
@@ -141,16 +185,88 @@ static const struct regulator_desc supported_regulators[] = {
         },
 };
 
+static struct regulator_ops max77836_ldo_ops = {
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
+        /* TODO: add .set_suspend_mode */
+};
+
+static const struct regulator_desc max77836_supported_regulators[] = {
+        [MAX14577_SAFEOUT] = {
+                .name           = "SAFEOUT",
+                .id             = MAX14577_SAFEOUT,
+                .ops            = &max14577_safeout_ops,
+                .type           = REGULATOR_VOLTAGE,
+                .owner          = THIS_MODULE,
+                .n_voltages     = 1,
+                .min_uV         = MAX14577_REGULATOR_SAFEOUT_VOLTAGE,
+                .enable_reg     = MAX14577_REG_CONTROL2,
+                .enable_mask    = CTRL2_SFOUTORD_MASK,
+        },
+        [MAX14577_CHARGER] = {
+                .name           = "CHARGER",
+                .id             = MAX14577_CHARGER,
+                .ops            = &max14577_charger_ops,
+                .type           = REGULATOR_CURRENT,
+                .owner          = THIS_MODULE,
+                .enable_reg     = MAX14577_CHG_REG_CHG_CTRL2,
+                .enable_mask    = CHGCTRL2_MBCHOSTEN_MASK,
+        },
+        [MAX77836_LDO1] = {
+                .name           = "LDO1",
+                .id             = MAX77836_LDO1,
+                .ops            = &max77836_ldo_ops,
+                .type           = REGULATOR_VOLTAGE,
+                .owner          = THIS_MODULE,
+                .n_voltages     = MAX77836_REGULATOR_LDO_VOLTAGE_STEPS_NUM,
+                .min_uV         = MAX77836_REGULATOR_LDO_VOLTAGE_MIN,
+                .uV_step        = MAX77836_REGULATOR_LDO_VOLTAGE_STEP,
+                .enable_reg     = MAX77836_LDO_REG_CNFG1_LDO1,
+                .enable_mask    = MAX77836_CNFG1_LDO_PWRMD_MASK,
+                .vsel_reg       = MAX77836_LDO_REG_CNFG1_LDO1,
+                .vsel_mask      = MAX77836_CNFG1_LDO_TV_MASK,
+        },
+        [MAX77836_LDO2] = {
+                .name           = "LDO2",
+                .id             = MAX77836_LDO2,
+                .ops            = &max77836_ldo_ops,
+                .type           = REGULATOR_VOLTAGE,
+                .owner          = THIS_MODULE,
+                .n_voltages     = MAX77836_REGULATOR_LDO_VOLTAGE_STEPS_NUM,
+                .min_uV         = MAX77836_REGULATOR_LDO_VOLTAGE_MIN,
+                .uV_step        = MAX77836_REGULATOR_LDO_VOLTAGE_STEP,
+                .enable_reg     = MAX77836_LDO_REG_CNFG1_LDO2,
+                .enable_mask    = MAX77836_CNFG1_LDO_PWRMD_MASK,
+                .vsel_reg       = MAX77836_LDO_REG_CNFG1_LDO2,
+                .vsel_mask      = MAX77836_CNFG1_LDO_TV_MASK,
+        },
+};
+
 #ifdef CONFIG_OF
 static struct of_regulator_match max14577_regulator_matches[] = {
         { .name = "SAFEOUT", },
         { .name = "CHARGER", },
 };
 
-static int max14577_regulator_dt_parse_pdata(struct platform_device *pdev)
+static struct of_regulator_match max77836_regulator_matches[] = {
+        { .name = "SAFEOUT", },
+        { .name = "CHARGER", },
+        { .name = "LDO1", },
+        { .name = "LDO2", },
+};
+
+static int max14577_regulator_dt_parse_pdata(struct platform_device *pdev,
+                enum maxim_device_type dev_type)
 {
         int ret;
         struct device_node *np;
+        struct of_regulator_match *regulator_matches;
+        unsigned int regulator_matches_size;
 
         np = of_get_child_by_name(pdev->dev.parent->of_node, "regulators");
         if (!np) {
@@ -158,8 +274,19 @@ static int max14577_regulator_dt_parse_pdata(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        ret = of_regulator_match(&pdev->dev, np, max14577_regulator_matches,
-                        MAX14577_REG_MAX);
+        switch (dev_type) {
+        case MAXIM_DEVICE_TYPE_MAX77836:
+                regulator_matches = max77836_regulator_matches;
+                regulator_matches_size = ARRAY_SIZE(max77836_regulator_matches);
+                break;
+        case MAXIM_DEVICE_TYPE_MAX14577:
+        default:
+                regulator_matches = max14577_regulator_matches;
+                regulator_matches_size = ARRAY_SIZE(max14577_regulator_matches);
+        }
+
+        ret = of_regulator_match(&pdev->dev, np, regulator_matches,
+                        regulator_matches_size);
         if (ret < 0)
                 dev_err(&pdev->dev, "Error parsing regulator init data: %d\n", ret);
         else
@@ -170,31 +297,74 @@ static int max14577_regulator_dt_parse_pdata(struct platform_device *pdev)
         return ret;
 }
 
-static inline struct regulator_init_data *match_init_data(int index)
+static inline struct regulator_init_data *match_init_data(int index,
+                enum maxim_device_type dev_type)
 {
-        return max14577_regulator_matches[index].init_data;
+        switch (dev_type) {
+        case MAXIM_DEVICE_TYPE_MAX77836:
+                return max77836_regulator_matches[index].init_data;
+
+        case MAXIM_DEVICE_TYPE_MAX14577:
+        default:
+                return max14577_regulator_matches[index].init_data;
+        }
 }
 
-static inline struct device_node *match_of_node(int index)
+static inline struct device_node *match_of_node(int index,
+                enum maxim_device_type dev_type)
 {
-        return max14577_regulator_matches[index].of_node;
+        switch (dev_type) {
+        case MAXIM_DEVICE_TYPE_MAX77836:
+                return max77836_regulator_matches[index].of_node;
+
+        case MAXIM_DEVICE_TYPE_MAX14577:
+        default:
+                return max14577_regulator_matches[index].of_node;
+        }
 }
 #else /* CONFIG_OF */
-static int max14577_regulator_dt_parse_pdata(struct platform_device *pdev)
+static int max14577_regulator_dt_parse_pdata(struct platform_device *pdev,
+                enum maxim_device_type dev_type)
 {
         return 0;
 }
-static inline struct regulator_init_data *match_init_data(int index)
+static inline struct regulator_init_data *match_init_data(int index,
+                enum maxim_device_type dev_type)
 {
         return NULL;
 }
 
-static inline struct device_node *match_of_node(int index)
+static inline struct device_node *match_of_node(int index,
+                enum maxim_device_type dev_type)
 {
         return NULL;
 }
 #endif /* CONFIG_OF */
 
+/**
+ * Registers for regulators of max77836 use different I2C slave addresses so
+ * different regmaps must be used for them.
+ *
+ * Returns proper regmap for accessing regulator passed by id.
+ */
+static struct regmap *max14577_get_regmap(struct max14577 *max14577,
+                int reg_id)
+{
+        switch (max14577->dev_type) {
+        case MAXIM_DEVICE_TYPE_MAX77836:
+                switch (reg_id) {
+                case MAX77836_SAFEOUT ... MAX77836_CHARGER:
+                        return max14577->regmap;
+                default:
+                        /* MAX77836_LDO1 ... MAX77836_LDO2 */
+                        return max14577->regmap_pmic;
+                }
+
+        case MAXIM_DEVICE_TYPE_MAX14577:
+        default:
+                return max14577->regmap;
+        }
+}
 
 static int max14577_regulator_probe(struct platform_device *pdev)
 {
@@ -202,15 +372,29 @@ static int max14577_regulator_probe(struct platform_device *pdev)
         struct max14577_platform_data *pdata = dev_get_platdata(max14577->dev);
         int i, ret;
         struct regulator_config config = {};
+        const struct regulator_desc *supported_regulators;
+        unsigned int supported_regulators_size;
+        enum maxim_device_type dev_type = max14577->dev_type;
 
-        ret = max14577_regulator_dt_parse_pdata(pdev);
+        ret = max14577_regulator_dt_parse_pdata(pdev, dev_type);
         if (ret)
                 return ret;
 
+        switch (dev_type) {
+        case MAXIM_DEVICE_TYPE_MAX77836:
+                supported_regulators = max77836_supported_regulators;
+                supported_regulators_size = ARRAY_SIZE(max77836_supported_regulators);
+                break;
+        case MAXIM_DEVICE_TYPE_MAX14577:
+        default:
+                supported_regulators = max14577_supported_regulators;
+                supported_regulators_size = ARRAY_SIZE(max14577_supported_regulators);
+        }
+
         config.dev = &pdev->dev;
-        config.regmap = max14577->regmap;
+        config.driver_data = max14577;
 
-        for (i = 0; i < ARRAY_SIZE(supported_regulators); i++) {
+        for (i = 0; i < supported_regulators_size; i++) {
                 struct regulator_dev *regulator;
                 /*
                  * Index of supported_regulators[] is also the id and must
@@ -220,17 +404,19 @@ static int max14577_regulator_probe(struct platform_device *pdev)
                         config.init_data = pdata->regulators[i].initdata;
                         config.of_node = pdata->regulators[i].of_node;
                 } else {
-                        config.init_data = match_init_data(i);
-                        config.of_node = match_of_node(i);
+                        config.init_data = match_init_data(i, dev_type);
+                        config.of_node = match_of_node(i, dev_type);
                 }
+                config.regmap = max14577_get_regmap(max14577,
+                                supported_regulators[i].id);
 
                 regulator = devm_regulator_register(&pdev->dev,
                                 &supported_regulators[i], &config);
                 if (IS_ERR(regulator)) {
                         ret = PTR_ERR(regulator);
                         dev_err(&pdev->dev,
-                                        "Regulator init failed for ID %d with error: %d\n",
-                                        i, ret);
+                                        "Regulator init failed for %d/%s with error: %d\n",
+                                        i, supported_regulators[i].name, ret);
                         return ret;
                 }
         }
@@ -238,20 +424,41 @@ static int max14577_regulator_probe(struct platform_device *pdev)
         return ret;
 }
 
+static const struct platform_device_id max14577_regulator_id[] = {
+        { "max14577-regulator", MAXIM_DEVICE_TYPE_MAX14577, },
+        { "max77836-regulator", MAXIM_DEVICE_TYPE_MAX77836, },
+        { }
+};
+MODULE_DEVICE_TABLE(platform, max14577_regulator_id);
+
 static struct platform_driver max14577_regulator_driver = {
         .driver = {
                    .owner = THIS_MODULE,
                    .name = "max14577-regulator",
                    },
-        .probe  = max14577_regulator_probe,
+        .probe          = max14577_regulator_probe,
+        .id_table       = max14577_regulator_id,
 };
 
 static int __init max14577_regulator_init(void)
 {
+        /* Check for valid values for charger */
         BUILD_BUG_ON(MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START +
                         MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP * 0xf !=
                         MAX14577_REGULATOR_CURRENT_LIMIT_MAX);
-        BUILD_BUG_ON(ARRAY_SIZE(supported_regulators) != MAX14577_REG_MAX);
+        BUILD_BUG_ON(MAX77836_REGULATOR_CURRENT_LIMIT_HIGH_START +
+                        MAX77836_REGULATOR_CURRENT_LIMIT_HIGH_STEP * 0xf !=
+                        MAX77836_REGULATOR_CURRENT_LIMIT_MAX);
+        /* Valid charger current values must be provided for each chipset */
+        BUILD_BUG_ON(ARRAY_SIZE(maxim_charger_currents) != MAXIM_DEVICE_TYPE_NUM);
+
+        BUILD_BUG_ON(ARRAY_SIZE(max14577_supported_regulators) != MAX14577_REGULATOR_NUM);
+        BUILD_BUG_ON(ARRAY_SIZE(max77836_supported_regulators) != MAX77836_REGULATOR_NUM);
+
+        BUILD_BUG_ON(MAX77836_REGULATOR_LDO_VOLTAGE_MIN +
+                        (MAX77836_REGULATOR_LDO_VOLTAGE_STEP *
+                          (MAX77836_REGULATOR_LDO_VOLTAGE_STEPS_NUM - 1)) !=
+                        MAX77836_REGULATOR_LDO_VOLTAGE_MAX);
 
         return platform_driver_register(&max14577_regulator_driver);
 }
@@ -264,6 +471,6 @@ static void __exit max14577_regulator_exit(void)
 module_exit(max14577_regulator_exit);
 
 MODULE_AUTHOR("Krzysztof Kozlowski <k.kozlowski@samsung.com>");
-MODULE_DESCRIPTION("MAXIM 14577 regulator driver");
+MODULE_DESCRIPTION("Maxim 14577/77836 regulator driver");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:max14577-regulator");
diff --git a/drivers/regulator/pbias-regulator.c b/drivers/regulator/pbias-regulator.c
index ded3b3574209..6d38be3d970c 100644
--- a/drivers/regulator/pbias-regulator.c
+++ b/drivers/regulator/pbias-regulator.c
@@ -38,66 +38,24 @@ struct pbias_reg_info {
 struct pbias_regulator_data {
         struct regulator_desc desc;
         void __iomem *pbias_addr;
-        unsigned int pbias_reg;
         struct regulator_dev *dev;
         struct regmap *syscon;
         const struct pbias_reg_info *info;
         int voltage;
 };
 
-static int pbias_regulator_set_voltage(struct regulator_dev *dev,
-                        int min_uV, int max_uV, unsigned *selector)
-{
-        struct pbias_regulator_data *data = rdev_get_drvdata(dev);
-        const struct pbias_reg_info *info = data->info;
-        int ret, vmode;
-
-        if (min_uV <= 1800000)
-                vmode = 0;
-        else if (min_uV > 1800000)
-                vmode = info->vmode;
-
-        ret = regmap_update_bits(data->syscon, data->pbias_reg,
-                                                info->vmode, vmode);
-
-        return ret;
-}
-
-static int pbias_regulator_get_voltage(struct regulator_dev *rdev)
-{
-        struct pbias_regulator_data *data = rdev_get_drvdata(rdev);
-        const struct pbias_reg_info *info = data->info;
-        int value, voltage;
-
-        regmap_read(data->syscon, data->pbias_reg, &value);
-        value &= info->vmode;
-
-        voltage = value ? 3000000 : 1800000;
-
-        return voltage;
-}
+static const unsigned int pbias_volt_table[] = {
+        1800000,
+        3000000
+};
 
 static int pbias_regulator_enable(struct regulator_dev *rdev)
 {
         struct pbias_regulator_data *data = rdev_get_drvdata(rdev);
         const struct pbias_reg_info *info = data->info;
-        int ret;
-
-        ret = regmap_update_bits(data->syscon, data->pbias_reg,
-                                        info->enable_mask, info->enable);
-
-        return ret;
-}
-
-static int pbias_regulator_disable(struct regulator_dev *rdev)
-{
-        struct pbias_regulator_data *data = rdev_get_drvdata(rdev);
-        const struct pbias_reg_info *info = data->info;
-        int ret;
 
-        ret = regmap_update_bits(data->syscon, data->pbias_reg,
-                                                info->enable_mask, 0);
-        return ret;
+        return regmap_update_bits(data->syscon, rdev->desc->enable_reg,
+                                  info->enable_mask, info->enable);
 }
 
 static int pbias_regulator_is_enable(struct regulator_dev *rdev)
@@ -106,17 +64,18 @@ static int pbias_regulator_is_enable(struct regulator_dev *rdev)
         const struct pbias_reg_info *info = data->info;
         int value;
 
-        regmap_read(data->syscon, data->pbias_reg, &value);
+        regmap_read(data->syscon, rdev->desc->enable_reg, &value);
 
-        return (value & info->enable_mask) == info->enable_mask;
+        return (value & info->enable_mask) == info->enable;
 }
 
 static struct regulator_ops pbias_regulator_voltage_ops = {
-        .set_voltage    = pbias_regulator_set_voltage,
-        .get_voltage    = pbias_regulator_get_voltage,
-        .enable         = pbias_regulator_enable,
-        .disable        = pbias_regulator_disable,
-        .is_enabled     = pbias_regulator_is_enable,
+        .list_voltage = regulator_list_voltage_table,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .enable = pbias_regulator_enable,
+        .disable = regulator_disable_regmap,
+        .is_enabled = pbias_regulator_is_enable,
 };
 
 static const struct pbias_reg_info pbias_mmc_omap2430 = {
@@ -192,6 +151,7 @@ static int pbias_regulator_probe(struct platform_device *pdev)
         if (IS_ERR(syscon))
                 return PTR_ERR(syscon);
 
+        cfg.regmap = syscon;
         cfg.dev = &pdev->dev;
 
         for (idx = 0; idx < PBIAS_NUM_REGS && data_idx < count; idx++) {
@@ -207,15 +167,19 @@ static int pbias_regulator_probe(struct platform_device *pdev)
                 if (!res)
                         return -EINVAL;
 
-                drvdata[data_idx].pbias_reg = res->start;
                 drvdata[data_idx].syscon = syscon;
                 drvdata[data_idx].info = info;
                 drvdata[data_idx].desc.name = info->name;
                 drvdata[data_idx].desc.owner = THIS_MODULE;
                 drvdata[data_idx].desc.type = REGULATOR_VOLTAGE;
                 drvdata[data_idx].desc.ops = &pbias_regulator_voltage_ops;
+                drvdata[data_idx].desc.volt_table = pbias_volt_table;
                 drvdata[data_idx].desc.n_voltages = 2;
                 drvdata[data_idx].desc.enable_time = info->enable_time;
+                drvdata[data_idx].desc.vsel_reg = res->start;
+                drvdata[data_idx].desc.vsel_mask = info->vmode;
+                drvdata[data_idx].desc.enable_reg = res->start;
+                drvdata[data_idx].desc.enable_mask = info->enable_mask;
 
                 cfg.init_data = pbias_matches[idx].init_data;
                 cfg.driver_data = &drvdata[data_idx];
diff --git a/drivers/regulator/tps6586x-regulator.c b/drivers/regulator/tps6586x-regulator.c
index 32f38a63d944..e045b7fe5572 100644
--- a/drivers/regulator/tps6586x-regulator.c
+++ b/drivers/regulator/tps6586x-regulator.c
@@ -68,7 +68,7 @@ static inline struct device *to_tps6586x_dev(struct regulator_dev *rdev)
         return rdev_get_dev(rdev)->parent;
 }
 
-static struct regulator_ops tps6586x_regulator_ops = {
+static struct regulator_ops tps6586x_rw_regulator_ops = {
         .list_voltage = regulator_list_voltage_table,
         .map_voltage = regulator_map_voltage_ascend,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
@@ -79,6 +79,16 @@ static struct regulator_ops tps6586x_regulator_ops = {
         .disable = regulator_disable_regmap,
 };
 
+static struct regulator_ops tps6586x_ro_regulator_ops = {
+        .list_voltage = regulator_list_voltage_table,
+        .map_voltage = regulator_map_voltage_ascend,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+
+        .is_enabled = regulator_is_enabled_regmap,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+};
+
 static struct regulator_ops tps6586x_sys_regulator_ops = {
 };
 
@@ -106,6 +116,13 @@ static const unsigned int tps6586x_sm2_voltages[] = {
         4200000, 4250000, 4300000, 4350000, 4400000, 4450000, 4500000, 4550000,
 };
 
+static int tps658640_sm2_voltages[] = {
+        2150000, 2200000, 2250000, 2300000, 2350000, 2400000, 2450000, 2500000,
+        2550000, 2600000, 2650000, 2700000, 2750000, 2800000, 2850000, 2900000,
+        2950000, 3000000, 3050000, 3100000, 3150000, 3200000, 3250000, 3300000,
+        3350000, 3400000, 3450000, 3500000, 3550000, 3600000, 3650000, 3700000,
+};
+
 static const unsigned int tps658643_sm2_voltages[] = {
         1025000, 1050000, 1075000, 1100000, 1125000, 1150000, 1175000, 1200000,
         1225000, 1250000, 1275000, 1300000, 1325000, 1350000, 1375000, 1400000,
@@ -120,12 +137,16 @@ static const unsigned int tps6586x_dvm_voltages[] = {
         1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000,
 };
 
-#define TPS6586X_REGULATOR(_id, _pin_name, vdata, vreg, shift, nbits,   \
+static int tps658640_rtc_voltages[] = {
+        2500000, 2850000, 3100000, 3300000,
+};
+
+#define TPS6586X_REGULATOR(_id, _ops, _pin_name, vdata, vreg, shift, nbits, \
                            ereg0, ebit0, ereg1, ebit1, goreg, gobit)    \
         .desc   = {                                                     \
                 .supply_name = _pin_name,                               \
                 .name   = "REG-" #_id,                                  \
-                .ops    = &tps6586x_regulator_ops,                      \
+                .ops    = &tps6586x_## _ops ## _regulator_ops,          \
                 .type   = REGULATOR_VOLTAGE,                            \
                 .id     = TPS6586X_ID_##_id,                            \
                 .n_voltages = ARRAY_SIZE(vdata##_voltages),             \
@@ -146,14 +167,21 @@ static const unsigned int tps6586x_dvm_voltages[] = {
 #define TPS6586X_LDO(_id, _pname, vdata, vreg, shift, nbits,            \
                      ereg0, ebit0, ereg1, ebit1)                        \
 {                                                                       \
-        TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits,      \
+        TPS6586X_REGULATOR(_id, rw, _pname, vdata, vreg, shift, nbits,  \
+                           ereg0, ebit0, ereg1, ebit1, 0, 0)            \
+}
+
+#define TPS6586X_FIXED_LDO(_id, _pname, vdata, vreg, shift, nbits,      \
+                          ereg0, ebit0, ereg1, ebit1)                   \
+{                                                                       \
+        TPS6586X_REGULATOR(_id, ro, _pname, vdata, vreg, shift, nbits,  \
                            ereg0, ebit0, ereg1, ebit1, 0, 0)            \
 }
 
 #define TPS6586X_DVM(_id, _pname, vdata, vreg, shift, nbits,            \
                      ereg0, ebit0, ereg1, ebit1, goreg, gobit)          \
 {                                                                       \
-        TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits,      \
+        TPS6586X_REGULATOR(_id, rw, _pname, vdata, vreg, shift, nbits,  \
                            ereg0, ebit0, ereg1, ebit1, goreg, gobit)    \
 }
 
@@ -207,6 +235,26 @@ static struct tps6586x_regulator tps658623_regulator[] = {
                                         END, 7),
 };
 
+static struct tps6586x_regulator tps658640_regulator[] = {
+        TPS6586X_LDO(LDO_3, "vinldo23", tps6586x_ldo0, SUPPLYV4, 0, 3,
+                                        ENC, 2, END, 2),
+        TPS6586X_LDO(LDO_5, "REG-SYS", tps6586x_ldo0, SUPPLYV6, 0, 3,
+                                        ENE, 6, ENE, 6),
+        TPS6586X_LDO(LDO_6, "vinldo678", tps6586x_ldo0, SUPPLYV3, 0, 3,
+                                        ENC, 4, END, 4),
+        TPS6586X_LDO(LDO_7, "vinldo678", tps6586x_ldo0, SUPPLYV3, 3, 3,
+                                        ENC, 5, END, 5),
+        TPS6586X_LDO(LDO_8, "vinldo678", tps6586x_ldo0, SUPPLYV2, 5, 3,
+                                        ENC, 6, END, 6),
+        TPS6586X_LDO(LDO_9, "vinldo9", tps6586x_ldo0, SUPPLYV6, 3, 3,
+                                        ENE, 7, ENE, 7),
+        TPS6586X_LDO(SM_2, "vin-sm2", tps658640_sm2, SUPPLYV2, 0, 5,
+                                        ENC, 7, END, 7),
+
+        TPS6586X_FIXED_LDO(LDO_RTC, "REG-SYS", tps658640_rtc, SUPPLYV4, 3, 2,
+                                        V4, 7, V4, 7),
+};
+
 static struct tps6586x_regulator tps658643_regulator[] = {
         TPS6586X_LDO(SM_2, "vin-sm2", tps658643_sm2, SUPPLYV2, 0, 5, ENC, 7,
                                         END, 7),
@@ -295,6 +343,11 @@ static struct tps6586x_regulator *find_regulator_info(int id, int version)
                 table = tps658623_regulator;
                 num = ARRAY_SIZE(tps658623_regulator);
                 break;
+        case TPS658640:
+        case TPS658640v2:
+                table = tps658640_regulator;
+                num = ARRAY_SIZE(tps658640_regulator);
+                break;
         case TPS658643:
                 table = tps658643_regulator;
                 num = ARRAY_SIZE(tps658643_regulator);