adp5055-regulator.c

  1// SPDX-License-Identifier: GPL-2.0
  2//
  3// Regulator driver for Analog Devices ADP5055
  4//
  5// Copyright (C) 2025 Analog Devices, Inc.
  6
  7#include <linux/bitfield.h>
  8#include <linux/device.h>
  9#include <linux/gpio/consumer.h>
 10#include <linux/i2c.h>
 11#include <linux/module.h>
 12#include <linux/mod_devicetable.h>
 13#include <linux/regmap.h>
 14#include <linux/regulator/driver.h>
 15#include <linux/regulator/machine.h>
 16#include <linux/regulator/of_regulator.h>
 17
 18// ADP5055 Register Map.
 19
 20#define ADP5055_CTRL123         0xD1
 21#define ADP5055_CTRL_MODE1      0xD3
 22#define ADP5055_CTRL_MODE2      0xD4
 23#define ADP5055_DLY0            0xD5
 24#define ADP5055_DLY1            0xD6
 25#define ADP5055_DLY2            0xD7
 26#define ADP5055_VID0            0xD8
 27#define ADP5055_VID1            0xD9
 28#define ADP5055_VID2            0xDA
 29#define ADP5055_DVS_LIM0        0xDC
 30#define ADP5055_DVS_LIM1        0xDD
 31#define ADP5055_DVS_LIM2        0xDE
 32#define ADP5055_FT_CFG          0xDF
 33#define ADP5055_PG_CFG          0xE0
 34
 35// ADP5055 Field Masks.
 36
 37#define	ADP5055_MASK_EN_MODE		BIT(0)
 38#define	ADP5055_MASK_OCP_BLANKING	BIT(7)
 39#define	ADP5055_MASK_PSM		BIT(4)
 40#define	ADP5055_MASK_DIS2		BIT(2)
 41#define	ADP5055_MASK_DIS1		BIT(1)
 42#define	ADP5055_MASK_DIS0		BIT(0)
 43#define	ADP5055_MASK_DIS_DLY		GENMASK(6, 4)
 44#define	ADP5055_MASK_EN_DLY		GENMASK(2, 0)
 45#define	ADP5055_MASK_DVS_LIM_UPPER	GENMASK(7, 4)
 46#define	ADP5055_MASK_DVS_LIM_LOWER	GENMASK(3, 0)
 47#define	ADP5055_MASK_FAST_TRANSIENT2	GENMASK(5, 4)
 48#define	ADP5055_MASK_FAST_TRANSIENT1	GENMASK(3, 2)
 49#define	ADP5055_MASK_FAST_TRANSIENT0	GENMASK(1, 0)
 50#define	ADP5055_MASK_DLY_PWRGD		BIT(4)
 51#define	ADP5055_MASK_PWRGD2		BIT(2)
 52#define	ADP5055_MASK_PWRGD1		BIT(1)
 53#define	ADP5055_MASK_PWRGD0		BIT(0)
 54
 55#define	ADP5055_MIN_VOUT		408000
 56#define ADP5055_NUM_CH			3
 57
 58struct adp5055 {
 59	struct device *dev;
 60	struct regmap *regmap;
 61	u32 tset;
 62	struct gpio_desc *en_gpiod[ADP5055_NUM_CH];
 63	bool en_mode_software;
 64	int dvs_limit_upper[ADP5055_NUM_CH];
 65	int dvs_limit_lower[ADP5055_NUM_CH];
 66	u32 fast_transient[ADP5055_NUM_CH];
 67	bool mask_power_good[ADP5055_NUM_CH];
 68};
 69
 70static const unsigned int adp5055_tset_vals[] = {
 71	2600,
 72	20800,
 73};
 74
 75static const unsigned int adp5055_enable_delay_vals_2_6[] = {
 76	0,
 77	2600,
 78	5200,
 79	7800,
 80	10400,
 81	13000,
 82	15600,
 83	18200,
 84};
 85
 86static const unsigned int adp5055_enable_delay_vals_20_8[] = {
 87	0,
 88	20800,
 89	41600,
 90	62400,
 91	83200,
 92	104000,
 93	124800,
 94	145600,
 95};
 96
 97static const char * const adp5055_fast_transient_vals[] = {
 98	"none",
 99	"3G_1.5%",
100	"5G_1.5%",
101	"5G_2.5%",
102};
103
104static int adp5055_get_prop_index(const u32 *table, size_t table_size,
105				  u32 value)
106{
107	int i;
108
109	for (i = 0; i < table_size; i++)
110		if (table[i] == value)
111			return i;
112
113	return -EINVAL;
114}
115
116static const struct regmap_range adp5055_reg_ranges[] = {
117	regmap_reg_range(0xD1, 0xE0),
118};
119
120static const struct regmap_access_table adp5055_access_ranges_table = {
121	.yes_ranges	= adp5055_reg_ranges,
122	.n_yes_ranges	= ARRAY_SIZE(adp5055_reg_ranges),
123};
124
125static const struct regmap_config adp5055_regmap_config = {
126	.reg_bits = 8,
127	.val_bits = 8,
128	.max_register = 0xE0,
129	.wr_table = &adp5055_access_ranges_table,
130	.rd_table = &adp5055_access_ranges_table,
131};
132
133static const struct linear_range adp5055_voltage_ranges[] = {
134	REGULATOR_LINEAR_RANGE(ADP5055_MIN_VOUT, 0, 255, 1500),
135};
136
137static int adp5055_parse_fw(struct device *dev, struct  adp5055 *adp5055)
138{
139	int i, ret;
140	struct regmap *regmap = adp5055->regmap;
141	int val;
142	bool ocp_blanking;
143	bool delay_power_good;
144
145	ret = device_property_read_u32(dev, "adi,tset-us", &adp5055->tset);
146	if (!ret) {
147		ret = adp5055_get_prop_index(adp5055_tset_vals,
148					ARRAY_SIZE(adp5055_tset_vals), adp5055->tset);
149		if (ret < 0)
150			return dev_err_probe(dev, ret,
151				"Failed to initialize tset.");
152		adp5055->tset = adp5055_tset_vals[ret];
153	}
154
155	ocp_blanking = device_property_read_bool(dev, "adi,ocp-blanking");
156
157	delay_power_good = device_property_read_bool(dev,
158				    "adi,delay-power-good");
159
160	for (i = 0; i < ADP5055_NUM_CH; i++) {
161		val = FIELD_PREP(ADP5055_MASK_DVS_LIM_UPPER,
162				DIV_ROUND_CLOSEST_ULL(192000 - adp5055->dvs_limit_upper[i], 12000));
163		val |= FIELD_PREP(ADP5055_MASK_DVS_LIM_LOWER,
164				DIV_ROUND_CLOSEST_ULL(adp5055->dvs_limit_lower[i] + 190500, 12000));
165		ret = regmap_write(regmap, ADP5055_DVS_LIM0 + i, val);
166		if (ret)
167			return ret;
168	}
169
170	val = FIELD_PREP(ADP5055_MASK_EN_MODE, adp5055->en_mode_software);
171	ret = regmap_write(regmap, ADP5055_CTRL_MODE1, val);
172	if (ret)
173		return ret;
174
175	val = FIELD_PREP(ADP5055_MASK_OCP_BLANKING, ocp_blanking);
176	ret = regmap_update_bits(regmap, ADP5055_CTRL_MODE2,
177				ADP5055_MASK_OCP_BLANKING, val);
178	if (ret)
179		return ret;
180
181	val = FIELD_PREP(ADP5055_MASK_FAST_TRANSIENT2, adp5055->fast_transient[2]);
182	val |= FIELD_PREP(ADP5055_MASK_FAST_TRANSIENT1, adp5055->fast_transient[1]);
183	val |= FIELD_PREP(ADP5055_MASK_FAST_TRANSIENT0, adp5055->fast_transient[0]);
184	ret = regmap_write(regmap, ADP5055_FT_CFG, val);
185	if (ret)
186		return ret;
187
188	val = FIELD_PREP(ADP5055_MASK_DLY_PWRGD, delay_power_good);
189	val |= FIELD_PREP(ADP5055_MASK_PWRGD2, adp5055->mask_power_good[2]);
190	val |= FIELD_PREP(ADP5055_MASK_PWRGD1, adp5055->mask_power_good[1]);
191	val |= FIELD_PREP(ADP5055_MASK_PWRGD0, adp5055->mask_power_good[0]);
192	ret = regmap_write(regmap, ADP5055_PG_CFG, val);
193	if (ret)
194		return ret;
195
196	return 0;
197}
198
199static int adp5055_of_parse_cb(struct device_node *np,
200			      const struct regulator_desc *desc,
201			      struct regulator_config *config)
202{
203	struct adp5055 *adp5055 = config->driver_data;
204	int id, ret, pval, i;
205
206	id = desc->id;
207
208	if (of_property_read_bool(np, "enable-gpios")) {
209		adp5055->en_gpiod[id] = devm_fwnode_gpiod_get(config->dev,
210						of_fwnode_handle(np), "enable",
211						GPIOD_OUT_LOW, "enable");
212		if (IS_ERR(adp5055->en_gpiod[id]))
213			return dev_err_probe(config->dev, PTR_ERR(adp5055->en_gpiod[id]),
214					"Failed to get enable GPIO\n");
215
216		config->ena_gpiod = adp5055->en_gpiod[id];
217	} else {
218		adp5055->en_mode_software = true;
219	}
220
221	ret = of_property_read_u32(np, "adi,dvs-limit-upper-microvolt", &pval);
222	if (ret)
223		adp5055->dvs_limit_upper[id] = 192000;
224	else
225		adp5055->dvs_limit_upper[id] = pval;
226
227	if (adp5055->dvs_limit_upper[id] > 192000 || adp5055->dvs_limit_upper[id] < 12000)
228		return dev_err_probe(config->dev, adp5055->dvs_limit_upper[id],
229			"Out of range - dvs-limit-upper-microvolt value.");
230
231	ret = of_property_read_u32(np, "adi,dvs-limit-lower-microvolt", &pval);
232	if (ret)
233		adp5055->dvs_limit_lower[id] = -190500;
234	else
235		adp5055->dvs_limit_lower[id] = pval;
236
237	if (adp5055->dvs_limit_lower[id] > -10500 || adp5055->dvs_limit_lower[id] < -190500)
238		return dev_err_probe(config->dev, adp5055->dvs_limit_lower[id],
239			"Out of range - dvs-limit-lower-microvolt value.");
240
241	for (i = 0; i < 4; i++) {
242		ret = of_property_match_string(np, "adi,fast-transient",
243					adp5055_fast_transient_vals[i]);
244		if (!ret)
245			break;
246	}
247
248	if (ret < 0)
249		adp5055->fast_transient[id] = 3;
250	else
251		adp5055->fast_transient[id] = i;
252
253	adp5055->mask_power_good[id] = of_property_read_bool(np, "adi,mask-power-good");
254
255	return 0;
256}
257
258static int adp5055_set_mode(struct regulator_dev *rdev, u32 mode)
259{
260	struct adp5055 *adp5055 = rdev_get_drvdata(rdev);
261	int id, ret;
262
263	id = rdev_get_id(rdev);
264
265	switch (mode) {
266	case REGULATOR_MODE_NORMAL:
267		ret = regmap_update_bits(adp5055->regmap, ADP5055_CTRL_MODE2,
268					ADP5055_MASK_PSM << id, 0);
269		break;
270	case REGULATOR_MODE_IDLE:
271		ret = regmap_update_bits(adp5055->regmap, ADP5055_CTRL_MODE2,
272					ADP5055_MASK_PSM << id, ADP5055_MASK_PSM << id);
273		break;
274	default:
275		return dev_err_probe(&rdev->dev, -EINVAL,
276				"Unsupported mode: %d\n", mode);
277	}
278
279	return ret;
280}
281
282static unsigned int adp5055_get_mode(struct regulator_dev *rdev)
283{
284	struct adp5055 *adp5055 = rdev_get_drvdata(rdev);
285	int id, ret, regval;
286
287	id = rdev_get_id(rdev);
288
289	ret = regmap_read(adp5055->regmap, ADP5055_CTRL_MODE2, &regval);
290	if (ret)
291		return ret;
292
293	if (regval & (ADP5055_MASK_PSM << id))
294		return REGULATOR_MODE_IDLE;
295	else
296		return REGULATOR_MODE_NORMAL;
297}
298
299static const struct regulator_ops adp5055_ops = {
300	.list_voltage = regulator_list_voltage_linear_range,
301	.map_voltage = regulator_map_voltage_linear_range,
302	.set_voltage_sel = regulator_set_voltage_sel_regmap,
303	.get_voltage_sel = regulator_get_voltage_sel_regmap,
304	.set_active_discharge = regulator_set_active_discharge_regmap,
305	.enable = regulator_enable_regmap,
306	.disable = regulator_disable_regmap,
307	.is_enabled = regulator_is_enabled_regmap,
308	.set_mode = adp5055_set_mode,
309	.get_mode = adp5055_get_mode,
310	.set_ramp_delay = regulator_set_ramp_delay_regmap,
311};
312
313#define ADP5055_REG_(_name, _id, _ch, _ops) \
314	[_id] = { \
315		.name = _name, \
316		.of_match = of_match_ptr(_name), \
317		.of_parse_cb = adp5055_of_parse_cb, \
318		.id = _id, \
319		.ops = _ops, \
320		.linear_ranges = adp5055_voltage_ranges, \
321		.n_linear_ranges = ARRAY_SIZE(adp5055_voltage_ranges), \
322		.vsel_reg = ADP5055_VID##_ch, \
323		.vsel_mask = GENMASK(7, 0), \
324		.enable_reg = ADP5055_CTRL123, \
325		.enable_mask = BIT(_ch), \
326		.active_discharge_on = ADP5055_MASK_DIS##_id, \
327		.active_discharge_off = 0, \
328		.active_discharge_mask = ADP5055_MASK_DIS##_id, \
329		.active_discharge_reg = ADP5055_CTRL_MODE2, \
330		.ramp_reg = ADP5055_DLY##_ch, \
331		.ramp_mask = ADP5055_MASK_EN_DLY, \
332		.n_ramp_values = ARRAY_SIZE(adp5055_enable_delay_vals_2_6), \
333		.type = REGULATOR_VOLTAGE, \
334		.owner = THIS_MODULE, \
335	}
336
337#define ADP5055_REG(_name, _id, _ch) \
338	ADP5055_REG_(_name, _id, _ch, &adp5055_ops)
339
340static struct regulator_desc adp5055_regulators[] = {
341	ADP5055_REG("buck0", 0, 0),
342	ADP5055_REG("buck1", 1, 1),
343	ADP5055_REG("buck2", 2, 2),
344};
345
346static int adp5055_probe(struct i2c_client *client)
347{
348	struct regulator_init_data *init_data;
349	struct device *dev = &client->dev;
350	struct adp5055 *adp5055;
351	int i, ret;
352
353	init_data = of_get_regulator_init_data(dev, client->dev.of_node,
354					       &adp5055_regulators[0]);
355	if (!init_data)
356		return -EINVAL;
357
358	adp5055 = devm_kzalloc(dev, sizeof(struct adp5055), GFP_KERNEL);
359	if (!adp5055)
360		return -ENOMEM;
361
362	adp5055->tset = 2600;
363	adp5055->en_mode_software = false;
364
365	adp5055->regmap = devm_regmap_init_i2c(client, &adp5055_regmap_config);
366	if (IS_ERR(adp5055->regmap))
367		return dev_err_probe(dev, PTR_ERR(adp5055->regmap), "Failed to allocate reg map");
368
369	for (i = 0; i < ADP5055_NUM_CH; i++) {
370		const struct regulator_desc *desc;
371		struct regulator_config config = { };
372		struct regulator_dev *rdev;
373
374		if (adp5055->tset == 2600)
375			adp5055_regulators[i].ramp_delay_table = adp5055_enable_delay_vals_2_6;
376		else
377			adp5055_regulators[i].ramp_delay_table = adp5055_enable_delay_vals_20_8;
378
379		desc = &adp5055_regulators[i];
380
381		config.dev = dev;
382		config.driver_data = adp5055;
383		config.regmap = adp5055->regmap;
384		config.init_data = init_data;
385
386		rdev = devm_regulator_register(dev, desc, &config);
387		if (IS_ERR(rdev)) {
388			return dev_err_probe(dev, PTR_ERR(rdev),
389					"Failed to register %s\n", desc->name);
390		}
391	}
392
393	ret = adp5055_parse_fw(dev, adp5055);
394	if (ret < 0)
395		return ret;
396
397	return 0;
398}
399
400static const struct of_device_id adp5055_of_match[] = {
401	{ .compatible = "adi,adp5055", },
402	{ }
403};
404MODULE_DEVICE_TABLE(of, adp5055_of_match);
405
406static const struct i2c_device_id adp5055_ids[] = {
407	{ .name = "adp5055"},
408	{ },
409};
410MODULE_DEVICE_TABLE(i2c, adp5055_ids);
411
412static struct i2c_driver adp5055_driver = {
413	.driver	= {
414		.name	= "adp5055",
415		.of_match_table = adp5055_of_match,
416	},
417	.probe		= adp5055_probe,
418	.id_table	= adp5055_ids,
419};
420module_i2c_driver(adp5055_driver);
421
422MODULE_DESCRIPTION("ADP5055 Voltage Regulator Driver");
423MODULE_AUTHOR("Alexis Czezar Torreno <alexisczezar.torreno@analog.com>");
424MODULE_LICENSE("GPL");