Merge tag 'mfd-for-linus-4.9' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd

Pull MFD updates from Lee Jones:
 "Core framework:
   - Add the MFD bindings doc to MAINTAINERS

  New drivers:
   - X-Powers AC100 Audio CODEC and RTC
   - TI LP873x PMIC
   - Rockchip RK808 PMIC
   - Samsung Exynos Low Power Audio

  New device support:
   - Add support for STMPE1600 variant to stmpe
   - Add support for PM8018 PMIC to pm8921-core
   - Add support for AXP806 PMIC in axp20x
   - Add support for AXP209 GPIO in axp20x

  New functionality:
   - Add support for Reset to all STMPE variants
   - Add support for MKBP event support to cros_ec
   - Add support for USB to intel_soc_pmic_bxtwc
   - Add support for IRQs and Power Button to tps65217

  Fix-ups:
   - Clean-up defunct author emails (da9063, max14577)
   - Kconfig fixups (wm8350-i2c, as37220
   - Constify (altera-a10sr, sm501)
   - Supply PCI IDs (intel-lpss-pci)
   - Improve clocking (qcom_rpm)
   - Fix IRQ probing (ucb1x00-core)
   - Ensure fault log is cleared (da9052)
   - Remove NO_IRQ check (ucb1x00-core)
   - Supply I2C properties (intel-lpss-acpi, intel-lpss-pci)
   - Non standard declaration (tps65217, max8997-irq)
   - Remove unused code (lp873x, db8500-prcmu, ab8500-debugfs,
     cros_ec_spi)
   - Make non-modular (altera-a10sr, intel_msic, smsc-ece1099,
     sun6i-prcm, twl-core)
   - OF bindings (ac100, stmpe, qcom-pm8xxx, qcom-rpm, rk808, axp20x,
     lp873x, exynos5433-lpass, act8945a, aspeed-scu, twl6040, arizona)

  Bugfixes:
   - Release OF pointer (qcom_rpm)
   - Avoid double shifting in suspend/resume (88pm80x)
   - Fix 'defined but not used' error (exynos-lpass)
   - Fix 'sleeping whilst attomic' (atmel-hlcdc)"

* tag 'mfd-for-linus-4.9' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd: (69 commits)
  mfd: arizona: Handle probe deferral for reset GPIO
  mfd: arizona: Remove arizona_of_get_named_gpio helper function
  mfd: arizona: Add DT options for max_channels_clocked and PDM speaker config
  mfd: twl6040: Register child device for twl6040-pdmclk
  mfd: cros_ec_spi: Remove unused variable 'request'
  mfd: omap-usb-host: Return value is not 'const int'
  mfd: ab8500-debugfs: Remove 'weak' function suspend_test_wake_cause_interrupt_is_mine()
  mfd: ab8500-debugfs: Remove ab8500_dump_all_banks_to_mem()
  mfd: db8500-prcmu: Remove unused *prcmu_set_ddr_opp() calls
  mfd: ab8500-debugfs: Prevent initialised field from being over-written
  mfd: max8997-irq: 'inline' should be at the beginning of the declaration
  mfd: rk808: Fix RK818_IRQ_DISCHG_ILIM initializer
  mfd: tps65217: Fix nonstandard declaration
  mfd: lp873x: Remove unused mutex lock from struct lp873x
  mfd: atmel-hlcdc: Do not sleep in atomic context
  mfd: exynos-lpass: Mark PM functions as __maybe_unused
  mfd: intel-lpss: Add default I2C device properties for Apollo Lake
  mfd: twl-core: Make it explicitly non-modular
  mfd: sun6i-prcm: Make it explicitly non-modular
  mfd: smsc-ece1099: Make it explicitly non-modular
  ...

4 files changed, 315 insertions, 16 deletions

diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index 06c75186af80..936f7ccc9736 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -643,11 +643,11 @@ config REGULATOR_RC5T583
           outputs which can be controlled by i2c communication.
 
 config REGULATOR_RK808
-        tristate "Rockchip RK808 Power regulators"
+        tristate "Rockchip RK808/RK818 Power regulators"
         depends on MFD_RK808
         help
           Select this option to enable the power regulator of ROCKCHIP
-          PMIC RK808.
+          PMIC RK808 and RK818.
           This driver supports the control of different power rails of device
           through regulator interface. The device supports multiple DCDC/LDO
           outputs which can be controlled by i2c communication.
diff --git a/drivers/regulator/axp20x-regulator.c b/drivers/regulator/axp20x-regulator.c
index 6d9ac76a772f..54382ef902c6 100644
--- a/drivers/regulator/axp20x-regulator.c
+++ b/drivers/regulator/axp20x-regulator.c
@@ -244,16 +244,64 @@ static const struct regulator_desc axp22x_drivevbus_regulator = {
         .ops            = &axp20x_ops_sw,
 };
 
-static const struct regulator_linear_range axp809_dcdc4_ranges[] = {
-        REGULATOR_LINEAR_RANGE(600000, 0x0, 0x2f, 20000),
-        REGULATOR_LINEAR_RANGE(1800000, 0x30, 0x38, 100000),
+static const struct regulator_linear_range axp806_dcdca_ranges[] = {
+        REGULATOR_LINEAR_RANGE(600000, 0x0, 0x32, 10000),
+        REGULATOR_LINEAR_RANGE(1120000, 0x33, 0x47, 20000),
 };
 
-static const struct regulator_linear_range axp809_dldo1_ranges[] = {
+static const struct regulator_linear_range axp806_dcdcd_ranges[] = {
+        REGULATOR_LINEAR_RANGE(600000, 0x0, 0x2d, 20000),
+        REGULATOR_LINEAR_RANGE(1600000, 0x2e, 0x3f, 100000),
+};
+
+static const struct regulator_linear_range axp806_cldo2_ranges[] = {
         REGULATOR_LINEAR_RANGE(700000, 0x0, 0x1a, 100000),
         REGULATOR_LINEAR_RANGE(3400000, 0x1b, 0x1f, 200000),
 };
 
+static const struct regulator_desc axp806_regulators[] = {
+        AXP_DESC_RANGES(AXP806, DCDCA, "dcdca", "vina", axp806_dcdca_ranges,
+                        72, AXP806_DCDCA_V_CTRL, 0x7f, AXP806_PWR_OUT_CTRL1,
+                        BIT(0)),
+        AXP_DESC(AXP806, DCDCB, "dcdcb", "vinb", 1000, 2550, 50,
+                 AXP806_DCDCB_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL1, BIT(1)),
+        AXP_DESC_RANGES(AXP806, DCDCC, "dcdcc", "vinc", axp806_dcdca_ranges,
+                        72, AXP806_DCDCC_V_CTRL, 0x7f, AXP806_PWR_OUT_CTRL1,
+                        BIT(2)),
+        AXP_DESC_RANGES(AXP806, DCDCD, "dcdcd", "vind", axp806_dcdcd_ranges,
+                        64, AXP806_DCDCD_V_CTRL, 0x3f, AXP806_PWR_OUT_CTRL1,
+                        BIT(3)),
+        AXP_DESC(AXP806, DCDCE, "dcdce", "vine", 1100, 3400, 100,
+                 AXP806_DCDCB_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL1, BIT(4)),
+        AXP_DESC(AXP806, ALDO1, "aldo1", "aldoin", 700, 3300, 100,
+                 AXP806_ALDO1_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL1, BIT(5)),
+        AXP_DESC(AXP806, ALDO2, "aldo2", "aldoin", 700, 3400, 100,
+                 AXP806_ALDO2_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL1, BIT(6)),
+        AXP_DESC(AXP806, ALDO3, "aldo3", "aldoin", 700, 3300, 100,
+                 AXP806_ALDO3_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL1, BIT(7)),
+        AXP_DESC(AXP806, BLDO1, "bldo1", "bldoin", 700, 1900, 100,
+                 AXP806_BLDO1_V_CTRL, 0x0f, AXP806_PWR_OUT_CTRL2, BIT(0)),
+        AXP_DESC(AXP806, BLDO2, "bldo2", "bldoin", 700, 1900, 100,
+                 AXP806_BLDO2_V_CTRL, 0x0f, AXP806_PWR_OUT_CTRL2, BIT(1)),
+        AXP_DESC(AXP806, BLDO3, "bldo3", "bldoin", 700, 1900, 100,
+                 AXP806_BLDO3_V_CTRL, 0x0f, AXP806_PWR_OUT_CTRL2, BIT(2)),
+        AXP_DESC(AXP806, BLDO4, "bldo4", "bldoin", 700, 1900, 100,
+                 AXP806_BLDO4_V_CTRL, 0x0f, AXP806_PWR_OUT_CTRL2, BIT(3)),
+        AXP_DESC(AXP806, CLDO1, "cldo1", "cldoin", 700, 3300, 100,
+                 AXP806_CLDO1_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL2, BIT(4)),
+        AXP_DESC_RANGES(AXP806, CLDO2, "cldo2", "cldoin", axp806_cldo2_ranges,
+                        32, AXP806_CLDO2_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL2,
+                        BIT(5)),
+        AXP_DESC(AXP806, CLDO3, "cldo3", "cldoin", 700, 3300, 100,
+                 AXP806_CLDO3_V_CTRL, 0x1f, AXP806_PWR_OUT_CTRL2, BIT(6)),
+        AXP_DESC_SW(AXP806, SW, "sw", "swin", AXP806_PWR_OUT_CTRL2, BIT(7)),
+};
+
+static const struct regulator_linear_range axp809_dcdc4_ranges[] = {
+        REGULATOR_LINEAR_RANGE(600000, 0x0, 0x2f, 20000),
+        REGULATOR_LINEAR_RANGE(1800000, 0x30, 0x38, 100000),
+};
+
 static const struct regulator_desc axp809_regulators[] = {
         AXP_DESC(AXP809, DCDC1, "dcdc1", "vin1", 1600, 3400, 100,
                  AXP22X_DCDC1_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL1, BIT(1)),
@@ -278,7 +326,7 @@ static const struct regulator_desc axp809_regulators[] = {
                  AXP22X_ALDO2_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL1, BIT(7)),
         AXP_DESC(AXP809, ALDO3, "aldo3", "aldoin", 700, 3300, 100,
                  AXP22X_ALDO3_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2, BIT(5)),
-        AXP_DESC_RANGES(AXP809, DLDO1, "dldo1", "dldoin", axp809_dldo1_ranges,
+        AXP_DESC_RANGES(AXP809, DLDO1, "dldo1", "dldoin", axp806_cldo2_ranges,
                         32, AXP22X_DLDO1_V_OUT, 0x1f, AXP22X_PWR_OUT_CTRL2,
                         BIT(3)),
         AXP_DESC(AXP809, DLDO2, "dldo2", "dldoin", 700, 3300, 100,
@@ -302,6 +350,7 @@ static const struct regulator_desc axp809_regulators[] = {
 static int axp20x_set_dcdc_freq(struct platform_device *pdev, u32 dcdcfreq)
 {
         struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
+        unsigned int reg = AXP20X_DCDC_FREQ;
         u32 min, max, def, step;
 
         switch (axp20x->variant) {
@@ -312,6 +361,14 @@ static int axp20x_set_dcdc_freq(struct platform_device *pdev, u32 dcdcfreq)
                 def = 1500;
                 step = 75;
                 break;
+        case AXP806_ID:
+                /*
+                 * AXP806 DCDC work frequency setting has the same range and
+                 * step as AXP22X, but at a different register.
+                 * Fall through to the check below.
+                 * (See include/linux/mfd/axp20x.h)
+                 */
+                reg = AXP806_DCDC_FREQ_CTRL;
         case AXP221_ID:
         case AXP223_ID:
         case AXP809_ID:
@@ -343,7 +400,7 @@ static int axp20x_set_dcdc_freq(struct platform_device *pdev, u32 dcdcfreq)
 
         dcdcfreq = (dcdcfreq - min) / step;
 
-        return regmap_update_bits(axp20x->regmap, AXP20X_DCDC_FREQ,
+        return regmap_update_bits(axp20x->regmap, reg,
                                   AXP20X_FREQ_DCDC_MASK, dcdcfreq);
 }
 
@@ -377,6 +434,7 @@ static int axp20x_regulator_parse_dt(struct platform_device *pdev)
 static int axp20x_set_dcdc_workmode(struct regulator_dev *rdev, int id, u32 workmode)
 {
         struct axp20x_dev *axp20x = rdev_get_drvdata(rdev);
+        unsigned int reg = AXP20X_DCDC_MODE;
         unsigned int mask;
 
         switch (axp20x->variant) {
@@ -392,6 +450,13 @@ static int axp20x_set_dcdc_workmode(struct regulator_dev *rdev, int id, u32 work
                 workmode <<= ffs(mask) - 1;
                 break;
 
+        case AXP806_ID:
+                reg = AXP806_DCDC_MODE_CTRL2;
+                /*
+                 * AXP806 DCDC regulator IDs have the same range as AXP22X.
+                 * Fall through to the check below.
+                 * (See include/linux/mfd/axp20x.h)
+                 */
         case AXP221_ID:
         case AXP223_ID:
         case AXP809_ID:
@@ -408,7 +473,34 @@ static int axp20x_set_dcdc_workmode(struct regulator_dev *rdev, int id, u32 work
                 return -EINVAL;
         }
 
-        return regmap_update_bits(rdev->regmap, AXP20X_DCDC_MODE, mask, workmode);
+        return regmap_update_bits(rdev->regmap, reg, mask, workmode);
+}
+
+/*
+ * This function checks whether a regulator is part of a poly-phase
+ * output setup based on the registers settings. Returns true if it is.
+ */
+static bool axp20x_is_polyphase_slave(struct axp20x_dev *axp20x, int id)
+{
+        u32 reg = 0;
+
+        /* Only AXP806 has poly-phase outputs */
+        if (axp20x->variant != AXP806_ID)
+                return false;
+
+        regmap_read(axp20x->regmap, AXP806_DCDC_MODE_CTRL2, &reg);
+
+        switch (id) {
+        case AXP806_DCDCB:
+                return (((reg & GENMASK(7, 6)) == BIT(6)) ||
+                        ((reg & GENMASK(7, 6)) == BIT(7)));
+        case AXP806_DCDCC:
+                return ((reg & GENMASK(7, 6)) == BIT(7));
+        case AXP806_DCDCE:
+                return !!(reg & BIT(5));
+        }
+
+        return false;
 }
 
 static int axp20x_regulator_probe(struct platform_device *pdev)
@@ -440,6 +532,10 @@ static int axp20x_regulator_probe(struct platform_device *pdev)
                 drivevbus = of_property_read_bool(pdev->dev.parent->of_node,
                                                   "x-powers,drive-vbus-en");
                 break;
+        case AXP806_ID:
+                regulators = axp806_regulators;
+                nregulators = AXP806_REG_ID_MAX;
+                break;
         case AXP809_ID:
                 regulators = axp809_regulators;
                 nregulators = AXP809_REG_ID_MAX;
@@ -458,6 +554,14 @@ static int axp20x_regulator_probe(struct platform_device *pdev)
                 struct regulator_desc *new_desc;
 
                 /*
+                 * If this regulator is a slave in a poly-phase setup,
+                 * skip it, as its controls are bound to the master
+                 * regulator and won't work.
+                 */
+                if (axp20x_is_polyphase_slave(axp20x, i))
+                        continue;
+
+                /*
                  * Regulators DC1SW and DC5LDO are connected internally,
                  * so we have to handle their supply names separately.
                  *
diff --git a/drivers/regulator/qcom_rpm-regulator.c b/drivers/regulator/qcom_rpm-regulator.c
index e254272585b2..1b2acc43fea1 100644
--- a/drivers/regulator/qcom_rpm-regulator.c
+++ b/drivers/regulator/qcom_rpm-regulator.c
@@ -448,6 +448,44 @@ static struct regulator_ops switch_ops = {
 };
 
 /*
+ * PM8018 regulators
+ */
+static const struct qcom_rpm_reg pm8018_pldo = {
+        .desc.linear_ranges = pldo_ranges,
+        .desc.n_linear_ranges = ARRAY_SIZE(pldo_ranges),
+        .desc.n_voltages = 161,
+        .desc.ops = &uV_ops,
+        .parts = &rpm8960_ldo_parts,
+        .supports_force_mode_auto = false,
+        .supports_force_mode_bypass = false,
+};
+
+static const struct qcom_rpm_reg pm8018_nldo = {
+        .desc.linear_ranges = nldo_ranges,
+        .desc.n_linear_ranges = ARRAY_SIZE(nldo_ranges),
+        .desc.n_voltages = 64,
+        .desc.ops = &uV_ops,
+        .parts = &rpm8960_ldo_parts,
+        .supports_force_mode_auto = false,
+        .supports_force_mode_bypass = false,
+};
+
+static const struct qcom_rpm_reg pm8018_smps = {
+        .desc.linear_ranges = smps_ranges,
+        .desc.n_linear_ranges = ARRAY_SIZE(smps_ranges),
+        .desc.n_voltages = 154,
+        .desc.ops = &uV_ops,
+        .parts = &rpm8960_smps_parts,
+        .supports_force_mode_auto = false,
+        .supports_force_mode_bypass = false,
+};
+
+static const struct qcom_rpm_reg pm8018_switch = {
+        .desc.ops = &switch_ops,
+        .parts = &rpm8960_switch_parts,
+};
+
+/*
  * PM8058 regulators
  */
 static const struct qcom_rpm_reg pm8058_pldo = {
@@ -755,6 +793,32 @@ struct rpm_regulator_data {
         const char *supply;
 };
 
+static const struct rpm_regulator_data rpm_pm8018_regulators[] = {
+        { "s1",  QCOM_RPM_PM8018_SMPS1, &pm8018_smps, "vdd_s1" },
+        { "s2",  QCOM_RPM_PM8018_SMPS2, &pm8018_smps, "vdd_s2" },
+        { "s3",  QCOM_RPM_PM8018_SMPS3, &pm8018_smps, "vdd_s3" },
+        { "s4",  QCOM_RPM_PM8018_SMPS4, &pm8018_smps, "vdd_s4" },
+        { "s5",  QCOM_RPM_PM8018_SMPS5, &pm8018_smps, "vdd_s5" },
+
+        { "l2",  QCOM_RPM_PM8018_LDO2,  &pm8018_pldo, "vdd_l2" },
+        { "l3",  QCOM_RPM_PM8018_LDO3,  &pm8018_pldo, "vdd_l3" },
+        { "l4",  QCOM_RPM_PM8018_LDO4,  &pm8018_pldo, "vdd_l4" },
+        { "l5",  QCOM_RPM_PM8018_LDO5,  &pm8018_pldo, "vdd_l5" },
+        { "l6",  QCOM_RPM_PM8018_LDO6,  &pm8018_pldo, "vdd_l7" },
+        { "l7",  QCOM_RPM_PM8018_LDO7,  &pm8018_pldo, "vdd_l7" },
+        { "l8",  QCOM_RPM_PM8018_LDO8,  &pm8018_nldo, "vdd_l8" },
+        { "l9",  QCOM_RPM_PM8018_LDO9,  &pm8921_nldo1200,
+                                                      "vdd_l9_l10_l11_l12" },
+        { "l10", QCOM_RPM_PM8018_LDO10, &pm8018_nldo, "vdd_l9_l10_l11_l12" },
+        { "l11", QCOM_RPM_PM8018_LDO11, &pm8018_nldo, "vdd_l9_l10_l11_l12" },
+        { "l12", QCOM_RPM_PM8018_LDO12, &pm8018_nldo, "vdd_l9_l10_l11_l12" },
+        { "l14", QCOM_RPM_PM8018_LDO14, &pm8018_pldo, "vdd_l14" },
+
+        { "lvs1", QCOM_RPM_PM8018_LVS1, &pm8018_switch, "lvs1_in" },
+
+        { }
+};
+
 static const struct rpm_regulator_data rpm_pm8058_regulators[] = {
         { "l0",   QCOM_RPM_PM8058_LDO0,   &pm8058_nldo, "vdd_l0_l1_lvs" },
         { "l1",   QCOM_RPM_PM8058_LDO1,   &pm8058_nldo, "vdd_l0_l1_lvs" },
@@ -870,6 +934,8 @@ static const struct rpm_regulator_data rpm_pm8921_regulators[] = {
 };
 
 static const struct of_device_id rpm_of_match[] = {
+        { .compatible = "qcom,rpm-pm8018-regulators",
+                .data = &rpm_pm8018_regulators },
         { .compatible = "qcom,rpm-pm8058-regulators", .data = &rpm_pm8058_regulators },
         { .compatible = "qcom,rpm-pm8901-regulators", .data = &rpm_pm8901_regulators },
         { .compatible = "qcom,rpm-pm8921-regulators", .data = &rpm_pm8921_regulators },
diff --git a/drivers/regulator/rk808-regulator.c b/drivers/regulator/rk808-regulator.c
index a6767494d39b..3314bf299a51 100644
--- a/drivers/regulator/rk808-regulator.c
+++ b/drivers/regulator/rk808-regulator.c
@@ -1,11 +1,15 @@
 /*
- * Regulator driver for Rockchip RK808
+ * Regulator driver for Rockchip RK808/RK818
  *
  * Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd
  *
  * Author: Chris Zhong <zyw@rock-chips.com>
  * Author: Zhang Qing <zhangqing@rock-chips.com>
  *
+ * Copyright (C) 2016 PHYTEC Messtechnik GmbH
+ *
+ * Author: Wadim Egorov <w.egorov@phytec.de>
+ *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
  * version 2, as published by the Free Software Foundation.
@@ -32,6 +36,12 @@
 #define RK808_BUCK4_VSEL_MASK   0xf
 #define RK808_LDO_VSEL_MASK     0x1f
 
+#define RK818_BUCK_VSEL_MASK            0x3f
+#define RK818_BUCK4_VSEL_MASK           0x1f
+#define RK818_LDO_VSEL_MASK             0x1f
+#define RK818_LDO3_ON_VSEL_MASK         0xf
+#define RK818_BOOST_ON_VSEL_MASK        0xe0
+
 /* Ramp rate definitions for buck1 / buck2 only */
 #define RK808_RAMP_RATE_OFFSET          3
 #define RK808_RAMP_RATE_MASK            (3 << RK808_RAMP_RATE_OFFSET)
@@ -454,6 +464,108 @@ static const struct regulator_desc rk808_reg[] = {
                 RK808_DCDC_EN_REG, BIT(6)),
 };
 
+static const struct regulator_desc rk818_reg[] = {
+        {
+                .name = "DCDC_REG1",
+                .supply_name = "vcc1",
+                .of_match = of_match_ptr("DCDC_REG1"),
+                .regulators_node = of_match_ptr("regulators"),
+                .id = RK818_ID_DCDC1,
+                .ops = &rk808_reg_ops,
+                .type = REGULATOR_VOLTAGE,
+                .min_uV = 712500,
+                .uV_step = 12500,
+                .n_voltages = 64,
+                .vsel_reg = RK818_BUCK1_ON_VSEL_REG,
+                .vsel_mask = RK818_BUCK_VSEL_MASK,
+                .enable_reg = RK818_DCDC_EN_REG,
+                .enable_mask = BIT(0),
+                .owner = THIS_MODULE,
+        }, {
+                .name = "DCDC_REG2",
+                .supply_name = "vcc2",
+                .of_match = of_match_ptr("DCDC_REG2"),
+                .regulators_node = of_match_ptr("regulators"),
+                .id = RK818_ID_DCDC2,
+                .ops = &rk808_reg_ops,
+                .type = REGULATOR_VOLTAGE,
+                .min_uV = 712500,
+                .uV_step = 12500,
+                .n_voltages = 64,
+                .vsel_reg = RK818_BUCK2_ON_VSEL_REG,
+                .vsel_mask = RK818_BUCK_VSEL_MASK,
+                .enable_reg = RK818_DCDC_EN_REG,
+                .enable_mask = BIT(1),
+                .owner = THIS_MODULE,
+        }, {
+                .name = "DCDC_REG3",
+                .supply_name = "vcc3",
+                .of_match = of_match_ptr("DCDC_REG3"),
+                .regulators_node = of_match_ptr("regulators"),
+                .id = RK818_ID_DCDC3,
+                .ops = &rk808_switch_ops,
+                .type = REGULATOR_VOLTAGE,
+                .n_voltages = 1,
+                .enable_reg = RK818_DCDC_EN_REG,
+                .enable_mask = BIT(2),
+                .owner = THIS_MODULE,
+        },
+        RK8XX_DESC(RK818_ID_DCDC4, "DCDC_REG4", "vcc4", 1800, 3600, 100,
+                RK818_BUCK4_ON_VSEL_REG, RK818_BUCK4_VSEL_MASK,
+                RK818_DCDC_EN_REG, BIT(3), 0),
+        RK8XX_DESC(RK818_ID_BOOST, "DCDC_BOOST", "boost", 4700, 5400, 100,
+                RK818_BOOST_LDO9_ON_VSEL_REG, RK818_BOOST_ON_VSEL_MASK,
+                RK818_DCDC_EN_REG, BIT(4), 0),
+        RK8XX_DESC(RK818_ID_LDO1, "LDO_REG1", "vcc6", 1800, 3400, 100,
+                RK818_LDO1_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
+                BIT(0), 400),
+        RK8XX_DESC(RK818_ID_LDO2, "LDO_REG2", "vcc6", 1800, 3400, 100,
+                RK818_LDO1_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
+                BIT(1), 400),
+        {
+                .name = "LDO_REG3",
+                .supply_name = "vcc7",
+                .of_match = of_match_ptr("LDO_REG3"),
+                .regulators_node = of_match_ptr("regulators"),
+                .id = RK818_ID_LDO3,
+                .ops = &rk808_reg_ops_ranges,
+                .type = REGULATOR_VOLTAGE,
+                .n_voltages = 16,
+                .linear_ranges = rk808_ldo3_voltage_ranges,
+                .n_linear_ranges = ARRAY_SIZE(rk808_ldo3_voltage_ranges),
+                .vsel_reg = RK818_LDO3_ON_VSEL_REG,
+                .vsel_mask = RK818_LDO3_ON_VSEL_MASK,
+                .enable_reg = RK818_LDO_EN_REG,
+                .enable_mask = BIT(2),
+                .enable_time = 400,
+                .owner = THIS_MODULE,
+        },
+        RK8XX_DESC(RK818_ID_LDO4, "LDO_REG4", "vcc8", 1800, 3400, 100,
+                RK818_LDO4_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
+                BIT(3), 400),
+        RK8XX_DESC(RK818_ID_LDO5, "LDO_REG5", "vcc7", 1800, 3400, 100,
+                RK818_LDO5_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
+                BIT(4), 400),
+        RK8XX_DESC(RK818_ID_LDO6, "LDO_REG6", "vcc8", 800, 2500, 100,
+                RK818_LDO6_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
+                BIT(5), 400),
+        RK8XX_DESC(RK818_ID_LDO7, "LDO_REG7", "vcc7", 800, 2500, 100,
+                RK818_LDO7_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
+                BIT(6), 400),
+        RK8XX_DESC(RK818_ID_LDO8, "LDO_REG8", "vcc8", 1800, 3400, 100,
+                RK818_LDO8_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
+                BIT(7), 400),
+        RK8XX_DESC(RK818_ID_LDO9, "LDO_REG9", "vcc9", 1800, 3400, 100,
+                RK818_BOOST_LDO9_ON_VSEL_REG, RK818_LDO_VSEL_MASK,
+                RK818_DCDC_EN_REG, BIT(5), 400),
+        RK8XX_DESC_SWITCH(RK818_ID_SWITCH, "SWITCH_REG", "vcc9",
+                RK818_DCDC_EN_REG, BIT(6)),
+        RK8XX_DESC_SWITCH(RK818_ID_HDMI_SWITCH, "HDMI_SWITCH", "h_5v",
+                RK818_H5V_EN_REG, BIT(0)),
+        RK8XX_DESC_SWITCH(RK818_ID_OTG_SWITCH, "OTG_SWITCH", "usb",
+                RK818_DCDC_EN_REG, BIT(7)),
+};
+
 static int rk808_regulator_dt_parse_pdata(struct device *dev,
                                    struct device *client_dev,
                                    struct regmap *map,
@@ -499,7 +611,8 @@ static int rk808_regulator_probe(struct platform_device *pdev)
         struct regulator_config config = {};
         struct regulator_dev *rk808_rdev;
         struct rk808_regulator_data *pdata;
-        int ret, i;
+        const struct regulator_desc *regulators;
+        int ret, i, nregulators;
 
         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
         if (!pdata)
@@ -512,14 +625,29 @@ static int rk808_regulator_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, pdata);
 
+        switch (rk808->variant) {
+        case RK808_ID:
+                regulators = rk808_reg;
+                nregulators = RK808_NUM_REGULATORS;
+                break;
+        case RK818_ID:
+                regulators = rk818_reg;
+                nregulators = RK818_NUM_REGULATORS;
+                break;
+        default:
+                dev_err(&client->dev, "unsupported RK8XX ID %lu\n",
+                        rk808->variant);
+                return -EINVAL;
+        }
+
         config.dev = &client->dev;
         config.driver_data = pdata;
         config.regmap = rk808->regmap;
 
         /* Instantiate the regulators */
-        for (i = 0; i < RK808_NUM_REGULATORS; i++) {
+        for (i = 0; i < nregulators; i++) {
                 rk808_rdev = devm_regulator_register(&pdev->dev,
-                                                     &rk808_reg[i], &config);
+                                                     &regulators[i], &config);
                 if (IS_ERR(rk808_rdev)) {
                         dev_err(&client->dev,
                                 "failed to register %d regulator\n", i);
@@ -539,8 +667,9 @@ static struct platform_driver rk808_regulator_driver = {
 
 module_platform_driver(rk808_regulator_driver);
 
-MODULE_DESCRIPTION("regulator driver for the rk808 series PMICs");
-MODULE_AUTHOR("Chris Zhong<zyw@rock-chips.com>");
-MODULE_AUTHOR("Zhang Qing<zhangqing@rock-chips.com>");
+MODULE_DESCRIPTION("regulator driver for the RK808/RK818 series PMICs");
+MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>");
+MODULE_AUTHOR("Zhang Qing <zhangqing@rock-chips.com>");
+MODULE_AUTHOR("Wadim Egorov <w.egorov@phytec.de>");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:rk808-regulator");