Skip to content

Commit

Permalink
regulator: Support ROHM BD9576MUF and BD9573MUF
Browse files Browse the repository at this point in the history 
Add initial support for ROHM BD9576MUF and BD9573MUF PMICs regulators.
These PMICs are mainly used to power the R-Car series processors.

The BD9576 includes some functional-safety features which are not
present on BD9573.

Signed-off-by: Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>
Link: https://lore.kernel.org/r/78baea1d7922506827ca717e277e4e6b391bbb78.1600329307.git.matti.vaittinen@fi.rohmeurope.com
Signed-off-by: Mark Brown <broonie@kernel.org>
  • Loading branch information
Matti Vaittinen authored and Mark Brown committed Sep 17, 2020
1 parent fdb2f9f commit b014e9f
Show file tree
Hide file tree
Showing 3 changed files with 348 additions and 0 deletions.
10 changes: 10 additions & 0 deletions drivers/regulator/Kconfig
View file
Original file line number Diff line number Diff line change
Expand Up @@ -231,6 +231,16 @@ config REGULATOR_BD9571MWV
This driver can also be built as a module. If so, the module
will be called bd9571mwv-regulator.

config REGULATOR_BD957XMUF
tristate "ROHM BD9576MUF and BD9573MUF Regulators"
depends on MFD_ROHM_BD957XMUF
help
This driver supports voltage regulators on ROHM BD9576MUF and
BD9573MUF PMICs.

This driver can also be built as a module. If so, the module
will be called bd9576-regulator.

config REGULATOR_CPCAP
tristate "Motorola CPCAP regulator"
depends on MFD_CPCAP
Expand Down
1 change: 1 addition & 0 deletions drivers/regulator/Makefile
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,6 +32,7 @@ obj-$(CONFIG_REGULATOR_BD70528) += bd70528-regulator.o
obj-$(CONFIG_REGULATOR_BD71828) += bd71828-regulator.o
obj-$(CONFIG_REGULATOR_BD718XX) += bd718x7-regulator.o
obj-$(CONFIG_REGULATOR_BD9571MWV) += bd9571mwv-regulator.o
obj-$(CONFIG_REGULATOR_BD957XMUF) += bd9576-regulator.o
obj-$(CONFIG_REGULATOR_DA903X) += da903x-regulator.o
obj-$(CONFIG_REGULATOR_DA9052) += da9052-regulator.o
obj-$(CONFIG_REGULATOR_DA9055) += da9055-regulator.o
Expand Down
337 changes: 337 additions & 0 deletions drivers/regulator/bd9576-regulator.c
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,337 @@
// SPDX-License-Identifier: GPL-2.0
// Copyright (C) 2020 ROHM Semiconductors
// ROHM BD9576MUF/BD9573MUF regulator driver

#include <linux/delay.h>
#include <linux/err.h>
#include <linux/gpio/consumer.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/mfd/rohm-bd957x.h>
#include <linux/mfd/rohm-generic.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/of_regulator.h>
#include <linux/slab.h>

#define BD957X_VOUTS1_VOLT 3300000
#define BD957X_VOUTS4_BASE_VOLT 1030000
#define BD957X_VOUTS34_NUM_VOLT 32

static int vout1_volt_table[] = {5000000, 4900000, 4800000, 4700000, 4600000,
4500000, 4500000, 4500000, 5000000, 5100000,
5200000, 5300000, 5400000, 5500000, 5500000,
5500000};

static int vout2_volt_table[] = {1800000, 1780000, 1760000, 1740000, 1720000,
1700000, 1680000, 1660000, 1800000, 1820000,
1840000, 1860000, 1880000, 1900000, 1920000,
1940000};

static int voutl1_volt_table[] = {2500000, 2540000, 2580000, 2620000, 2660000,
2700000, 2740000, 2780000, 2500000, 2460000,
2420000, 2380000, 2340000, 2300000, 2260000,
2220000};

struct bd957x_regulator_data {
struct regulator_desc desc;
int base_voltage;
};

static int bd957x_vout34_list_voltage(struct regulator_dev *rdev,
unsigned int selector)
{
const struct regulator_desc *desc = rdev->desc;
int multiplier = selector & desc->vsel_mask & 0x7f;
int tune;

/* VOUT3 and 4 has 10mV step */
tune = multiplier * 10000;

if (!(selector & 0x80))
return desc->fixed_uV - tune;

return desc->fixed_uV + tune;
}

static int bd957x_list_voltage(struct regulator_dev *rdev,
unsigned int selector)
{
const struct regulator_desc *desc = rdev->desc;
int index = selector & desc->vsel_mask & 0x7f;

if (!(selector & 0x80))
index += desc->n_voltages/2;

if (index >= desc->n_voltages)
return -EINVAL;

return desc->volt_table[index];
}

static const struct regulator_ops bd957x_vout34_ops = {
.is_enabled = regulator_is_enabled_regmap,
.list_voltage = bd957x_vout34_list_voltage,
.get_voltage_sel = regulator_get_voltage_sel_regmap,
};

static const struct regulator_ops bd957X_vouts1_regulator_ops = {
.is_enabled = regulator_is_enabled_regmap,
};

static const struct regulator_ops bd957x_ops = {
.is_enabled = regulator_is_enabled_regmap,
.list_voltage = bd957x_list_voltage,
.get_voltage_sel = regulator_get_voltage_sel_regmap,
};

static struct bd957x_regulator_data bd9576_regulators[] = {
{
.desc = {
.name = "VD50",
.of_match = of_match_ptr("regulator-vd50"),
.regulators_node = of_match_ptr("regulators"),
.id = BD957X_VD50,
.type = REGULATOR_VOLTAGE,
.ops = &bd957x_ops,
.volt_table = &vout1_volt_table[0],
.n_voltages = ARRAY_SIZE(vout1_volt_table),
.vsel_reg = BD957X_REG_VOUT1_TUNE,
.vsel_mask = BD957X_MASK_VOUT1_TUNE,
.enable_reg = BD957X_REG_POW_TRIGGER1,
.enable_mask = BD957X_REGULATOR_EN_MASK,
.enable_val = BD957X_REGULATOR_DIS_VAL,
.enable_is_inverted = true,
.owner = THIS_MODULE,
},
},
{
.desc = {
.name = "VD18",
.of_match = of_match_ptr("regulator-vd18"),
.regulators_node = of_match_ptr("regulators"),
.id = BD957X_VD18,
.type = REGULATOR_VOLTAGE,
.ops = &bd957x_ops,
.volt_table = &vout2_volt_table[0],
.n_voltages = ARRAY_SIZE(vout2_volt_table),
.vsel_reg = BD957X_REG_VOUT2_TUNE,
.vsel_mask = BD957X_MASK_VOUT2_TUNE,
.enable_reg = BD957X_REG_POW_TRIGGER2,
.enable_mask = BD957X_REGULATOR_EN_MASK,
.enable_val = BD957X_REGULATOR_DIS_VAL,
.enable_is_inverted = true,
.owner = THIS_MODULE,
},
},
{
.desc = {
.name = "VDDDR",
.of_match = of_match_ptr("regulator-vdddr"),
.regulators_node = of_match_ptr("regulators"),
.id = BD957X_VDDDR,
.ops = &bd957x_vout34_ops,
.type = REGULATOR_VOLTAGE,
.n_voltages = BD957X_VOUTS34_NUM_VOLT,
.vsel_reg = BD957X_REG_VOUT3_TUNE,
.vsel_mask = BD957X_MASK_VOUT3_TUNE,
.enable_reg = BD957X_REG_POW_TRIGGER3,
.enable_mask = BD957X_REGULATOR_EN_MASK,
.enable_val = BD957X_REGULATOR_DIS_VAL,
.enable_is_inverted = true,
.owner = THIS_MODULE,
},
},
{
.desc = {
.name = "VD10",
.of_match = of_match_ptr("regulator-vd10"),
.regulators_node = of_match_ptr("regulators"),
.id = BD957X_VD10,
.ops = &bd957x_vout34_ops,
.type = REGULATOR_VOLTAGE,
.fixed_uV = BD957X_VOUTS4_BASE_VOLT,
.n_voltages = BD957X_VOUTS34_NUM_VOLT,
.vsel_reg = BD957X_REG_VOUT4_TUNE,
.vsel_mask = BD957X_MASK_VOUT4_TUNE,
.enable_reg = BD957X_REG_POW_TRIGGER4,
.enable_mask = BD957X_REGULATOR_EN_MASK,
.enable_val = BD957X_REGULATOR_DIS_VAL,
.enable_is_inverted = true,
.owner = THIS_MODULE,
},
},
{
.desc = {
.name = "VOUTL1",
.of_match = of_match_ptr("regulator-voutl1"),
.regulators_node = of_match_ptr("regulators"),
.id = BD957X_VOUTL1,
.ops = &bd957x_ops,
.type = REGULATOR_VOLTAGE,
.volt_table = &voutl1_volt_table[0],
.n_voltages = ARRAY_SIZE(voutl1_volt_table),
.vsel_reg = BD957X_REG_VOUTL1_TUNE,
.vsel_mask = BD957X_MASK_VOUTL1_TUNE,
.enable_reg = BD957X_REG_POW_TRIGGERL1,
.enable_mask = BD957X_REGULATOR_EN_MASK,
.enable_val = BD957X_REGULATOR_DIS_VAL,
.enable_is_inverted = true,
.owner = THIS_MODULE,
},
},
{
.desc = {
.name = "VOUTS1",
.of_match = of_match_ptr("regulator-vouts1"),
.regulators_node = of_match_ptr("regulators"),
.id = BD957X_VOUTS1,
.ops = &bd957X_vouts1_regulator_ops,
.type = REGULATOR_VOLTAGE,
.n_voltages = 1,
.fixed_uV = BD957X_VOUTS1_VOLT,
.enable_reg = BD957X_REG_POW_TRIGGERS1,
.enable_mask = BD957X_REGULATOR_EN_MASK,
.enable_val = BD957X_REGULATOR_DIS_VAL,
.enable_is_inverted = true,
.owner = THIS_MODULE,
},
},
};

static int bd957x_probe(struct platform_device *pdev)
{
struct regmap *regmap;
struct regulator_config config = { 0 };
int i, err;
bool vout_mode, ddr_sel;
const struct bd957x_regulator_data *reg_data = &bd9576_regulators[0];
unsigned int num_reg_data = ARRAY_SIZE(bd9576_regulators);
enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data;

regmap = dev_get_regmap(pdev->dev.parent, NULL);
if (!regmap) {
dev_err(&pdev->dev, "No regmap\n");
return -EINVAL;
}
vout_mode = of_property_read_bool(pdev->dev.parent->of_node,
"rohm,vout1-en-low");
if (vout_mode) {
struct gpio_desc *en;

dev_dbg(&pdev->dev, "GPIO controlled mode\n");

/* VOUT1 enable state judged by VOUT1_EN pin */
/* See if we have GPIO defined */
en = devm_gpiod_get_from_of_node(&pdev->dev,
pdev->dev.parent->of_node,
"rohm,vout1-en-gpios", 0,
GPIOD_OUT_LOW, "vout1-en");
if (!IS_ERR(en)) {
/* VOUT1_OPS gpio ctrl */
/*
* Regulator core prioritizes the ena_gpio over
* enable/disable/is_enabled callbacks so no need to
* clear them. We can still use same ops
*/
config.ena_gpiod = en;
} else {
/*
* In theory it is possible someone wants to set
* vout1-en LOW during OTP loading and set VOUT1 to be
* controlled by GPIO - but control the GPIO from some
* where else than this driver. For that to work we
* should unset the is_enabled callback here.
*
* I believe such case where rohm,vout1-en-low is set
* and vout1-en-gpios is not is likely to be a
* misconfiguration. So let's just err out for now.
*/
dev_err(&pdev->dev,
"Failed to get VOUT1 control GPIO\n");
return PTR_ERR(en);
}
}

/*
* If more than one PMIC needs to be controlled by same processor then
* allocate the regulator data array here and use bd9576_regulators as
* template. At the moment I see no such use-case so I spare some
* bytes and use bd9576_regulators directly for non-constant configs
* like DDR voltage selection.
*/
ddr_sel = of_property_read_bool(pdev->dev.parent->of_node,
"rohm,ddr-sel-low");
if (ddr_sel)
bd9576_regulators[2].desc.fixed_uV = 1350000;
else
bd9576_regulators[2].desc.fixed_uV = 1500000;

switch (chip) {
case ROHM_CHIP_TYPE_BD9576:
dev_dbg(&pdev->dev, "Found BD9576MUF\n");
break;
case ROHM_CHIP_TYPE_BD9573:
pr_info(&pdev->dev, "Found BD9573MUF\n");
break;
default:
dev_err(&pdev->dev, "Unsupported chip type\n");
err = -EINVAL;
goto err;
}

config.dev = pdev->dev.parent;
config.regmap = regmap;

for (i = 0; i < num_reg_data; i++) {

const struct regulator_desc *desc;
struct regulator_dev *rdev;
const struct bd957x_regulator_data *r;

r = &reg_data[i];
desc = &r->desc;

rdev = devm_regulator_register(&pdev->dev, desc, &config);
if (IS_ERR(rdev)) {
dev_err(&pdev->dev,
"failed to register %s regulator\n",
desc->name);
err = PTR_ERR(rdev);
goto err;
}
/*
* Clear the VOUT1 GPIO setting - rest of the regulators do not
* support GPIO control
*/
config.ena_gpiod = NULL;
}

err:
return err;
}

static const struct platform_device_id bd957x_pmic_id[] = {
{ "bd9573-pmic", ROHM_CHIP_TYPE_BD9573 },
{ "bd9576-pmic", ROHM_CHIP_TYPE_BD9576 },
{ },
};
MODULE_DEVICE_TABLE(platform, bd957x_pmic_id);

static struct platform_driver bd957x_regulator = {
.driver = {
.name = "bd957x-pmic",
},
.probe = bd957x_probe,
.id_table = bd957x_pmic_id,
};

module_platform_driver(bd957x_regulator);

MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
MODULE_DESCRIPTION("ROHM BD9576/BD9573 voltage regulator driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:bd957x-pmic");

0 comments on commit b014e9f

Please sign in to comment.