[mirror_ubuntu-jammy-kernel.git] / drivers / regulator / bd9576-regulator.c

// 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");
Commit	Line	Data
b014e9fa MV	1	// SPDX-License-Identifier: GPL-2.0
	2	// Copyright (C) 2020 ROHM Semiconductors
	3	// ROHM BD9576MUF/BD9573MUF regulator driver
	4
	5	#include <linux/delay.h>
	6	#include <linux/err.h>
	7	#include <linux/gpio/consumer.h>
	8	#include <linux/interrupt.h>
	9	#include <linux/kernel.h>
	10	#include <linux/mfd/rohm-bd957x.h>
	11	#include <linux/mfd/rohm-generic.h>
	12	#include <linux/module.h>
	13	#include <linux/of.h>
	14	#include <linux/platform_device.h>
	15	#include <linux/regulator/driver.h>
	16	#include <linux/regulator/machine.h>
	17	#include <linux/regulator/of_regulator.h>
	18	#include <linux/slab.h>
	19
	20	#define BD957X_VOUTS1_VOLT 3300000
	21	#define BD957X_VOUTS4_BASE_VOLT 1030000
	22	#define BD957X_VOUTS34_NUM_VOLT 32
	23
	24	static int vout1_volt_table[] = {5000000, 4900000, 4800000, 4700000, 4600000,
	25	4500000, 4500000, 4500000, 5000000, 5100000,
	26	5200000, 5300000, 5400000, 5500000, 5500000,
	27	5500000};
	28
	29	static int vout2_volt_table[] = {1800000, 1780000, 1760000, 1740000, 1720000,
	30	1700000, 1680000, 1660000, 1800000, 1820000,
	31	1840000, 1860000, 1880000, 1900000, 1920000,
	32	1940000};
	33
	34	static int voutl1_volt_table[] = {2500000, 2540000, 2580000, 2620000, 2660000,
	35	2700000, 2740000, 2780000, 2500000, 2460000,
	36	2420000, 2380000, 2340000, 2300000, 2260000,
	37	2220000};
	38
	39	struct bd957x_regulator_data {
	40	struct regulator_desc desc;
	41	int base_voltage;
	42	};
	43
	44	static int bd957x_vout34_list_voltage(struct regulator_dev *rdev,
	45	unsigned int selector)
	46	{
	47	const struct regulator_desc *desc = rdev->desc;
	48	int multiplier = selector & desc->vsel_mask & 0x7f;
	49	int tune;
	50
	51	/* VOUT3 and 4 has 10mV step */
	52	tune = multiplier * 10000;
	53
	54	if (!(selector & 0x80))
	55	return desc->fixed_uV - tune;
	56
	57	return desc->fixed_uV + tune;
	58	}
	59
	60	static int bd957x_list_voltage(struct regulator_dev *rdev,
	61	unsigned int selector)
	62	{
	63	const struct regulator_desc *desc = rdev->desc;
	64	int index = selector & desc->vsel_mask & 0x7f;
65
66	if (!(selector & 0x80))
67	index += desc->n_voltages/2;
68
69	if (index >= desc->n_voltages)
70	return -EINVAL;
71
72	return desc->volt_table[index];
73	}
74
75	static const struct regulator_ops bd957x_vout34_ops = {
76	.is_enabled = regulator_is_enabled_regmap,
77	.list_voltage = bd957x_vout34_list_voltage,
78	.get_voltage_sel = regulator_get_voltage_sel_regmap,
79	};
80
81	static const struct regulator_ops bd957X_vouts1_regulator_ops = {
82	.is_enabled = regulator_is_enabled_regmap,
83	};
84
85	static const struct regulator_ops bd957x_ops = {
86	.is_enabled = regulator_is_enabled_regmap,
87	.list_voltage = bd957x_list_voltage,
88	.get_voltage_sel = regulator_get_voltage_sel_regmap,
89	};
90
91	static struct bd957x_regulator_data bd9576_regulators[] = {
92	{
93	.desc = {
94	.name = "VD50",
95	.of_match = of_match_ptr("regulator-vd50"),
96	.regulators_node = of_match_ptr("regulators"),
97	.id = BD957X_VD50,
98	.type = REGULATOR_VOLTAGE,
99	.ops = &bd957x_ops,
100	.volt_table = &vout1_volt_table[0],
101	.n_voltages = ARRAY_SIZE(vout1_volt_table),
102	.vsel_reg = BD957X_REG_VOUT1_TUNE,
103	.vsel_mask = BD957X_MASK_VOUT1_TUNE,
104	.enable_reg = BD957X_REG_POW_TRIGGER1,
105	.enable_mask = BD957X_REGULATOR_EN_MASK,
106	.enable_val = BD957X_REGULATOR_DIS_VAL,
107	.enable_is_inverted = true,
108	.owner = THIS_MODULE,
109	},
110	},
111	{
112	.desc = {
113	.name = "VD18",
114	.of_match = of_match_ptr("regulator-vd18"),
115	.regulators_node = of_match_ptr("regulators"),
116	.id = BD957X_VD18,
117	.type = REGULATOR_VOLTAGE,
118	.ops = &bd957x_ops,
119	.volt_table = &vout2_volt_table[0],
120	.n_voltages = ARRAY_SIZE(vout2_volt_table),
121	.vsel_reg = BD957X_REG_VOUT2_TUNE,
122	.vsel_mask = BD957X_MASK_VOUT2_TUNE,
123	.enable_reg = BD957X_REG_POW_TRIGGER2,
124	.enable_mask = BD957X_REGULATOR_EN_MASK,
125	.enable_val = BD957X_REGULATOR_DIS_VAL,
126	.enable_is_inverted = true,
127	.owner = THIS_MODULE,
128	},
129	},
130	{
131	.desc = {
132	.name = "VDDDR",
133	.of_match = of_match_ptr("regulator-vdddr"),
134	.regulators_node = of_match_ptr("regulators"),
135	.id = BD957X_VDDDR,
136	.ops = &bd957x_vout34_ops,
137	.type = REGULATOR_VOLTAGE,
138	.n_voltages = BD957X_VOUTS34_NUM_VOLT,
139	.vsel_reg = BD957X_REG_VOUT3_TUNE,
140	.vsel_mask = BD957X_MASK_VOUT3_TUNE,
141	.enable_reg = BD957X_REG_POW_TRIGGER3,
142	.enable_mask = BD957X_REGULATOR_EN_MASK,
143	.enable_val = BD957X_REGULATOR_DIS_VAL,
144	.enable_is_inverted = true,
145	.owner = THIS_MODULE,
146	},
147	},
148	{
149	.desc = {
150	.name = "VD10",
151	.of_match = of_match_ptr("regulator-vd10"),
152	.regulators_node = of_match_ptr("regulators"),
153	.id = BD957X_VD10,
154	.ops = &bd957x_vout34_ops,
155	.type = REGULATOR_VOLTAGE,
156	.fixed_uV = BD957X_VOUTS4_BASE_VOLT,
157	.n_voltages = BD957X_VOUTS34_NUM_VOLT,
158	.vsel_reg = BD957X_REG_VOUT4_TUNE,
159	.vsel_mask = BD957X_MASK_VOUT4_TUNE,
160	.enable_reg = BD957X_REG_POW_TRIGGER4,
161	.enable_mask = BD957X_REGULATOR_EN_MASK,
162	.enable_val = BD957X_REGULATOR_DIS_VAL,
163	.enable_is_inverted = true,
164	.owner = THIS_MODULE,
165	},
166	},
167	{
168	.desc = {
169	.name = "VOUTL1",
170	.of_match = of_match_ptr("regulator-voutl1"),
171	.regulators_node = of_match_ptr("regulators"),
172	.id = BD957X_VOUTL1,
173	.ops = &bd957x_ops,
174	.type = REGULATOR_VOLTAGE,
175	.volt_table = &voutl1_volt_table[0],
176	.n_voltages = ARRAY_SIZE(voutl1_volt_table),
177	.vsel_reg = BD957X_REG_VOUTL1_TUNE,
178	.vsel_mask = BD957X_MASK_VOUTL1_TUNE,
179	.enable_reg = BD957X_REG_POW_TRIGGERL1,
180	.enable_mask = BD957X_REGULATOR_EN_MASK,
181	.enable_val = BD957X_REGULATOR_DIS_VAL,
182	.enable_is_inverted = true,
183	.owner = THIS_MODULE,
184	},
185	},
186	{
187	.desc = {
188	.name = "VOUTS1",
189	.of_match = of_match_ptr("regulator-vouts1"),
190	.regulators_node = of_match_ptr("regulators"),
191	.id = BD957X_VOUTS1,
192	.ops = &bd957X_vouts1_regulator_ops,
193	.type = REGULATOR_VOLTAGE,
194	.n_voltages = 1,
195	.fixed_uV = BD957X_VOUTS1_VOLT,
196	.enable_reg = BD957X_REG_POW_TRIGGERS1,
197	.enable_mask = BD957X_REGULATOR_EN_MASK,
198	.enable_val = BD957X_REGULATOR_DIS_VAL,
199	.enable_is_inverted = true,
200	.owner = THIS_MODULE,
201	},
202	},
203	};
204
205	static int bd957x_probe(struct platform_device *pdev)
206	{
207	struct regmap *regmap;
208	struct regulator_config config = { 0 };
209	int i, err;
210	bool vout_mode, ddr_sel;
211	const struct bd957x_regulator_data *reg_data = &bd9576_regulators[0];
212	unsigned int num_reg_data = ARRAY_SIZE(bd9576_regulators);
213	enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data;
214
215	regmap = dev_get_regmap(pdev->dev.parent, NULL);
216	if (!regmap) {
217	dev_err(&pdev->dev, "No regmap\n");
218	return -EINVAL;
219	}
220	vout_mode = of_property_read_bool(pdev->dev.parent->of_node,
221	"rohm,vout1-en-low");
222	if (vout_mode) {
223	struct gpio_desc *en;
224
225	dev_dbg(&pdev->dev, "GPIO controlled mode\n");
226
227	/* VOUT1 enable state judged by VOUT1_EN pin */
228	/* See if we have GPIO defined */
229	en = devm_gpiod_get_from_of_node(&pdev->dev,
230	pdev->dev.parent->of_node,
231	"rohm,vout1-en-gpios", 0,
232	GPIOD_OUT_LOW, "vout1-en");
233	if (!IS_ERR(en)) {
234	/* VOUT1_OPS gpio ctrl */
235	/*
236	* Regulator core prioritizes the ena_gpio over
237	* enable/disable/is_enabled callbacks so no need to
238	* clear them. We can still use same ops
239	*/
240	config.ena_gpiod = en;
241	} else {
242	/*
243	* In theory it is possible someone wants to set
244	* vout1-en LOW during OTP loading and set VOUT1 to be
245	* controlled by GPIO - but control the GPIO from some
246	* where else than this driver. For that to work we
247	* should unset the is_enabled callback here.
248	*
249	* I believe such case where rohm,vout1-en-low is set
250	* and vout1-en-gpios is not is likely to be a
251	* misconfiguration. So let's just err out for now.
252	*/
253	dev_err(&pdev->dev,
254	"Failed to get VOUT1 control GPIO\n");
255	return PTR_ERR(en);
256	}
257	}
258
259	/*
260	* If more than one PMIC needs to be controlled by same processor then
261	* allocate the regulator data array here and use bd9576_regulators as
262	* template. At the moment I see no such use-case so I spare some
263	* bytes and use bd9576_regulators directly for non-constant configs
264	* like DDR voltage selection.
265	*/
266	ddr_sel = of_property_read_bool(pdev->dev.parent->of_node,
267	"rohm,ddr-sel-low");
268	if (ddr_sel)
269	bd9576_regulators[2].desc.fixed_uV = 1350000;
270	else
271	bd9576_regulators[2].desc.fixed_uV = 1500000;
272
273	switch (chip) {
274	case ROHM_CHIP_TYPE_BD9576:
275	dev_dbg(&pdev->dev, "Found BD9576MUF\n");
276	break;
277	case ROHM_CHIP_TYPE_BD9573:
278	pr_info(&pdev->dev, "Found BD9573MUF\n");
279	break;
280	default:
281	dev_err(&pdev->dev, "Unsupported chip type\n");
282	err = -EINVAL;
283	goto err;
284	}
285
286	config.dev = pdev->dev.parent;
287	config.regmap = regmap;
288
289	for (i = 0; i < num_reg_data; i++) {
290
291	const struct regulator_desc *desc;
292	struct regulator_dev *rdev;
293	const struct bd957x_regulator_data *r;
294
295	r = &reg_data[i];
296	desc = &r->desc;
297
298	rdev = devm_regulator_register(&pdev->dev, desc, &config);
299	if (IS_ERR(rdev)) {
300	dev_err(&pdev->dev,
301	"failed to register %s regulator\n",
302	desc->name);
303	err = PTR_ERR(rdev);
304	goto err;
305	}
306	/*
307	* Clear the VOUT1 GPIO setting - rest of the regulators do not
308	* support GPIO control
309	*/
310	config.ena_gpiod = NULL;
311	}
312
313	err:
314	return err;
315	}
316
317	static const struct platform_device_id bd957x_pmic_id[] = {
318	{ "bd9573-pmic", ROHM_CHIP_TYPE_BD9573 },
319	{ "bd9576-pmic", ROHM_CHIP_TYPE_BD9576 },
320	{ },
321	};
322	MODULE_DEVICE_TABLE(platform, bd957x_pmic_id);
323
324	static struct platform_driver bd957x_regulator = {
325	.driver = {
326	.name = "bd957x-pmic",
327	},
328	.probe = bd957x_probe,
329	.id_table = bd957x_pmic_id,
330	};
331
332	module_platform_driver(bd957x_regulator);
333
334	MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
335	MODULE_DESCRIPTION("ROHM BD9576/BD9573 voltage regulator driver");
336	MODULE_LICENSE("GPL");
337	MODULE_ALIAS("platform:bd957x-pmic");