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}()
  ...

4 files changed, 99 insertions, 47 deletions

diff --git a/drivers/mfd/arizona-core.c b/drivers/mfd/arizona-core.c
index 1c3ae57082ed..07e6e27be23c 100644
--- a/drivers/mfd/arizona-core.c
+++ b/drivers/mfd/arizona-core.c
@@ -508,19 +508,31 @@ int arizona_of_get_type(struct device *dev)
 }
 EXPORT_SYMBOL_GPL(arizona_of_get_type);
 
+int arizona_of_get_named_gpio(struct arizona *arizona, const char *prop,
+                              bool mandatory)
+{
+        int gpio;
+
+        gpio = of_get_named_gpio(arizona->dev->of_node, prop, 0);
+        if (gpio < 0) {
+                if (mandatory)
+                        dev_err(arizona->dev,
+                                "Mandatory DT gpio %s missing/malformed: %d\n",
+                                prop, gpio);
+
+                gpio = 0;
+        }
+
+        return gpio;
+}
+EXPORT_SYMBOL_GPL(arizona_of_get_named_gpio);
+
 static int arizona_of_get_core_pdata(struct arizona *arizona)
 {
+        struct arizona_pdata *pdata = &arizona->pdata;
         int ret, i;
 
-        arizona->pdata.reset = of_get_named_gpio(arizona->dev->of_node,
-                                                 "wlf,reset", 0);
-        if (arizona->pdata.reset < 0)
-                arizona->pdata.reset = 0;
-
-        arizona->pdata.ldoena = of_get_named_gpio(arizona->dev->of_node,
-                                                  "wlf,ldoena", 0);
-        if (arizona->pdata.ldoena < 0)
-                arizona->pdata.ldoena = 0;
+        pdata->reset = arizona_of_get_named_gpio(arizona, "wlf,reset", true);
 
         ret = of_property_read_u32_array(arizona->dev->of_node,
                                          "wlf,gpio-defaults",
@@ -652,6 +664,9 @@ int arizona_dev_init(struct arizona *arizona)
                 return -EINVAL;
         }
 
+        /* Mark DCVDD as external, LDO1 driver will clear if internal */
+        arizona->external_dcvdd = true;
+
         ret = mfd_add_devices(arizona->dev, -1, early_devs,
                               ARRAY_SIZE(early_devs), NULL, 0, NULL);
         if (ret != 0) {
@@ -851,14 +866,6 @@ int arizona_dev_init(struct arizona *arizona)
                              arizona->pdata.gpio_defaults[i]);
         }
 
-        /*
-         * LDO1 can only be used to supply DCVDD so if it has no
-         * consumers then DCVDD is supplied externally.
-         */
-        if (arizona->pdata.ldo1 &&
-            arizona->pdata.ldo1->num_consumer_supplies == 0)
-                arizona->external_dcvdd = true;
-
         pm_runtime_set_autosuspend_delay(arizona->dev, 100);
         pm_runtime_use_autosuspend(arizona->dev);
         pm_runtime_enable(arizona->dev);
diff --git a/drivers/mfd/bcm590xx.c b/drivers/mfd/bcm590xx.c
index e9a33c79431b..43cba1a1973c 100644
--- a/drivers/mfd/bcm590xx.c
+++ b/drivers/mfd/bcm590xx.c
@@ -28,39 +28,71 @@ static const struct mfd_cell bcm590xx_devs[] = {
         },
 };
 
-static const struct regmap_config bcm590xx_regmap_config = {
+static const struct regmap_config bcm590xx_regmap_config_pri = {
         .reg_bits       = 8,
         .val_bits       = 8,
-        .max_register   = BCM590XX_MAX_REGISTER,
+        .max_register   = BCM590XX_MAX_REGISTER_PRI,
         .cache_type     = REGCACHE_RBTREE,
 };
 
-static int bcm590xx_i2c_probe(struct i2c_client *i2c,
+static const struct regmap_config bcm590xx_regmap_config_sec = {
+        .reg_bits       = 8,
+        .val_bits       = 8,
+        .max_register   = BCM590XX_MAX_REGISTER_SEC,
+        .cache_type     = REGCACHE_RBTREE,
+};
+
+static int bcm590xx_i2c_probe(struct i2c_client *i2c_pri,
                               const struct i2c_device_id *id)
 {
         struct bcm590xx *bcm590xx;
         int ret;
 
-        bcm590xx = devm_kzalloc(&i2c->dev, sizeof(*bcm590xx), GFP_KERNEL);
+        bcm590xx = devm_kzalloc(&i2c_pri->dev, sizeof(*bcm590xx), GFP_KERNEL);
         if (!bcm590xx)
                 return -ENOMEM;
 
-        i2c_set_clientdata(i2c, bcm590xx);
-        bcm590xx->dev = &i2c->dev;
-        bcm590xx->i2c_client = i2c;
+        i2c_set_clientdata(i2c_pri, bcm590xx);
+        bcm590xx->dev = &i2c_pri->dev;
+        bcm590xx->i2c_pri = i2c_pri;
 
-        bcm590xx->regmap = devm_regmap_init_i2c(i2c, &bcm590xx_regmap_config);
-        if (IS_ERR(bcm590xx->regmap)) {
-                ret = PTR_ERR(bcm590xx->regmap);
-                dev_err(&i2c->dev, "regmap initialization failed: %d\n", ret);
+        bcm590xx->regmap_pri = devm_regmap_init_i2c(i2c_pri,
+                                                 &bcm590xx_regmap_config_pri);
+        if (IS_ERR(bcm590xx->regmap_pri)) {
+                ret = PTR_ERR(bcm590xx->regmap_pri);
+                dev_err(&i2c_pri->dev, "primary regmap init failed: %d\n", ret);
                 return ret;
         }
 
-        ret = mfd_add_devices(&i2c->dev, -1, bcm590xx_devs,
+        /* Secondary I2C slave address is the base address with A(2) asserted */
+        bcm590xx->i2c_sec = i2c_new_dummy(i2c_pri->adapter,
+                                          i2c_pri->addr | BIT(2));
+        if (IS_ERR_OR_NULL(bcm590xx->i2c_sec)) {
+                dev_err(&i2c_pri->dev, "failed to add secondary I2C device\n");
+                return -ENODEV;
+        }
+        i2c_set_clientdata(bcm590xx->i2c_sec, bcm590xx);
+
+        bcm590xx->regmap_sec = devm_regmap_init_i2c(bcm590xx->i2c_sec,
+                                                &bcm590xx_regmap_config_sec);
+        if (IS_ERR(bcm590xx->regmap_sec)) {
+                ret = PTR_ERR(bcm590xx->regmap_sec);
+                dev_err(&bcm590xx->i2c_sec->dev,
+                        "secondary regmap init failed: %d\n", ret);
+                goto err;
+        }
+
+        ret = mfd_add_devices(&i2c_pri->dev, -1, bcm590xx_devs,
                               ARRAY_SIZE(bcm590xx_devs), NULL, 0, NULL);
-        if (ret < 0)
-                dev_err(&i2c->dev, "failed to add sub-devices: %d\n", ret);
+        if (ret < 0) {
+                dev_err(&i2c_pri->dev, "failed to add sub-devices: %d\n", ret);
+                goto err;
+        }
+
+        return 0;
 
+err:
+        i2c_unregister_device(bcm590xx->i2c_sec);
         return ret;
 }
 
diff --git a/drivers/mfd/tps65090.c b/drivers/mfd/tps65090.c
index ba1a25d758c1..1c3e6e2efe41 100644
--- a/drivers/mfd/tps65090.c
+++ b/drivers/mfd/tps65090.c
@@ -32,14 +32,6 @@
 #define NUM_INT_REG 2
 #define TOTAL_NUM_REG 0x18
 
-/* interrupt status registers */
-#define TPS65090_INT_STS        0x0
-#define TPS65090_INT_STS2       0x1
-
-/* interrupt mask registers */
-#define TPS65090_INT_MSK        0x2
-#define TPS65090_INT_MSK2       0x3
-
 #define TPS65090_INT1_MASK_VAC_STATUS_CHANGE            1
 #define TPS65090_INT1_MASK_VSYS_STATUS_CHANGE           2
 #define TPS65090_INT1_MASK_BAT_STATUS_CHANGE            3
@@ -64,11 +56,16 @@ static struct resource charger_resources[] = {
         }
 };
 
-static const struct mfd_cell tps65090s[] = {
-        {
+enum tps65090_cells {
+        PMIC = 0,
+        CHARGER = 1,
+};
+
+static struct mfd_cell tps65090s[] = {
+        [PMIC] = {
                 .name = "tps65090-pmic",
         },
-        {
+        [CHARGER] = {
                 .name = "tps65090-charger",
                 .num_resources = ARRAY_SIZE(charger_resources),
                 .resources = &charger_resources[0],
@@ -139,17 +136,26 @@ static struct regmap_irq_chip tps65090_irq_chip = {
         .irqs = tps65090_irqs,
         .num_irqs = ARRAY_SIZE(tps65090_irqs),
         .num_regs = NUM_INT_REG,
-        .status_base = TPS65090_INT_STS,
-        .mask_base = TPS65090_INT_MSK,
+        .status_base = TPS65090_REG_INTR_STS,
+        .mask_base = TPS65090_REG_INTR_MASK,
         .mask_invert = true,
 };
 
 static bool is_volatile_reg(struct device *dev, unsigned int reg)
 {
-        if ((reg == TPS65090_INT_STS) || (reg == TPS65090_INT_STS2))
-                return true;
-        else
+        /* Nearly all registers have status bits mixed in, except a few */
+        switch (reg) {
+        case TPS65090_REG_INTR_MASK:
+        case TPS65090_REG_INTR_MASK2:
+        case TPS65090_REG_CG_CTRL0:
+        case TPS65090_REG_CG_CTRL1:
+        case TPS65090_REG_CG_CTRL2:
+        case TPS65090_REG_CG_CTRL3:
+        case TPS65090_REG_CG_CTRL4:
+        case TPS65090_REG_CG_CTRL5:
                 return false;
+        }
+        return true;
 }
 
 static const struct regmap_config tps65090_regmap_config = {
@@ -211,6 +217,9 @@ static int tps65090_i2c_probe(struct i2c_client *client,
                                         "IRQ init failed with err: %d\n", ret);
                         return ret;
                 }
+        } else {
+                /* Don't tell children they have an IRQ that'll never fire */
+                tps65090s[CHARGER].num_resources = 0;
         }
 
         ret = mfd_add_devices(tps65090->dev, -1, tps65090s,
diff --git a/drivers/mfd/tps6586x.c b/drivers/mfd/tps6586x.c
index bbd54414a75d..835e5549ecdd 100644
--- a/drivers/mfd/tps6586x.c
+++ b/drivers/mfd/tps6586x.c
@@ -495,6 +495,10 @@ static void tps6586x_print_version(struct i2c_client *client, int version)
         case TPS658623:
                 name = "TPS658623";
                 break;
+        case TPS658640:
+        case TPS658640v2:
+                name = "TPS658640";
+                break;
         case TPS658643:
                 name = "TPS658643";
                 break;