1 // SPDX-License-Identifier: GPL-2.0+
4 * Texas Instruments Incorporated, <www.ti.com>
6 * Keerthy <j-keerthy@ti.com>
14 #include <power/pmic.h>
15 #include <power/regulator.h>
16 #include <power/lp873x.h>
18 static const char lp873x_buck_ctrl[LP873X_BUCK_NUM] = {0x2, 0x4};
19 static const char lp873x_buck_volt[LP873X_BUCK_NUM] = {0x6, 0x7};
20 static const char lp873x_ldo_ctrl[LP873X_LDO_NUM] = {0x8, 0x9};
21 static const char lp873x_ldo_volt[LP873X_LDO_NUM] = {0xA, 0xB};
23 static int lp873x_buck_enable(struct udevice *dev, int op, bool *enable)
27 struct dm_regulator_uclass_platdata *uc_pdata;
29 uc_pdata = dev_get_uclass_platdata(dev);
30 adr = uc_pdata->ctrl_reg;
32 ret = pmic_reg_read(dev->parent, adr);
36 if (op == PMIC_OP_GET) {
37 ret &= LP873X_BUCK_MODE_MASK;
45 } else if (op == PMIC_OP_SET) {
47 ret |= LP873X_BUCK_MODE_MASK;
49 ret &= ~(LP873X_BUCK_MODE_MASK);
50 ret = pmic_reg_write(dev->parent, adr, ret);
58 static int lp873x_buck_volt2hex(int uV)
60 if (uV > LP873X_BUCK_VOLT_MAX)
62 else if (uV > 1400000)
63 return (uV - 1420000) / 20000 + 0x9E;
65 return (uV - 735000) / 5000 + 0x18;
66 else if (uV >= 700000)
67 return (uV - 700000) / 10000 + 0x1;
72 static int lp873x_buck_hex2volt(int hex)
74 if (hex > LP873X_BUCK_VOLT_MAX_HEX)
77 return 1400000 + (hex - 0x9D) * 20000;
79 return 730000 + (hex - 0x17) * 5000;
81 return 700000 + (hex - 0x14) * 10000;
86 static int lp873x_buck_val(struct udevice *dev, int op, int *uV)
88 unsigned int hex, adr;
90 struct dm_regulator_uclass_platdata *uc_pdata;
92 uc_pdata = dev_get_uclass_platdata(dev);
94 if (op == PMIC_OP_GET)
97 adr = uc_pdata->volt_reg;
99 ret = pmic_reg_read(dev->parent, adr);
103 if (op == PMIC_OP_GET) {
104 ret &= LP873X_BUCK_VOLT_MASK;
105 ret = lp873x_buck_hex2volt(ret);
113 hex = lp873x_buck_volt2hex(*uV);
120 ret = pmic_reg_write(dev->parent, adr, ret);
125 static int lp873x_ldo_enable(struct udevice *dev, int op, bool *enable)
129 struct dm_regulator_uclass_platdata *uc_pdata;
131 uc_pdata = dev_get_uclass_platdata(dev);
132 adr = uc_pdata->ctrl_reg;
134 ret = pmic_reg_read(dev->parent, adr);
138 if (op == PMIC_OP_GET) {
139 ret &= LP873X_LDO_MODE_MASK;
147 } else if (op == PMIC_OP_SET) {
149 ret |= LP873X_LDO_MODE_MASK;
151 ret &= ~(LP873X_LDO_MODE_MASK);
153 ret = pmic_reg_write(dev->parent, adr, ret);
161 static int lp873x_ldo_volt2hex(int uV)
163 if (uV > LP873X_LDO_VOLT_MAX)
166 return (uV - 800000) / 100000;
169 static int lp873x_ldo_hex2volt(int hex)
171 if (hex > LP873X_LDO_VOLT_MAX_HEX)
177 return (hex * 100000) + 800000;
180 static int lp873x_ldo_val(struct udevice *dev, int op, int *uV)
182 unsigned int hex, adr;
185 struct dm_regulator_uclass_platdata *uc_pdata;
187 if (op == PMIC_OP_GET)
190 uc_pdata = dev_get_uclass_platdata(dev);
192 adr = uc_pdata->volt_reg;
194 ret = pmic_reg_read(dev->parent, adr);
198 if (op == PMIC_OP_GET) {
199 ret &= LP873X_LDO_VOLT_MASK;
200 ret = lp873x_ldo_hex2volt(ret);
207 hex = lp873x_ldo_volt2hex(*uV);
211 ret &= ~LP873X_LDO_VOLT_MASK;
215 ret = pmic_reg_write(dev->parent, adr, ret);
220 static int lp873x_ldo_probe(struct udevice *dev)
222 struct dm_regulator_uclass_platdata *uc_pdata;
224 uc_pdata = dev_get_uclass_platdata(dev);
225 uc_pdata->type = REGULATOR_TYPE_LDO;
227 int idx = dev->driver_data;
228 if (idx >= LP873X_LDO_NUM) {
229 printf("Wrong ID for regulator\n");
233 uc_pdata->ctrl_reg = lp873x_ldo_ctrl[idx];
234 uc_pdata->volt_reg = lp873x_ldo_volt[idx];
239 static int ldo_get_value(struct udevice *dev)
244 ret = lp873x_ldo_val(dev, PMIC_OP_GET, &uV);
251 static int ldo_set_value(struct udevice *dev, int uV)
253 return lp873x_ldo_val(dev, PMIC_OP_SET, &uV);
256 static int ldo_get_enable(struct udevice *dev)
261 ret = lp873x_ldo_enable(dev, PMIC_OP_GET, &enable);
268 static int ldo_set_enable(struct udevice *dev, bool enable)
270 return lp873x_ldo_enable(dev, PMIC_OP_SET, &enable);
273 static int lp873x_buck_probe(struct udevice *dev)
275 struct dm_regulator_uclass_platdata *uc_pdata;
278 uc_pdata = dev_get_uclass_platdata(dev);
279 uc_pdata->type = REGULATOR_TYPE_BUCK;
281 idx = dev->driver_data;
282 if (idx >= LP873X_BUCK_NUM) {
283 printf("Wrong ID for regulator\n");
287 uc_pdata->ctrl_reg = lp873x_buck_ctrl[idx];
288 uc_pdata->volt_reg = lp873x_buck_volt[idx];
293 static int buck_get_value(struct udevice *dev)
298 ret = lp873x_buck_val(dev, PMIC_OP_GET, &uV);
305 static int buck_set_value(struct udevice *dev, int uV)
307 return lp873x_buck_val(dev, PMIC_OP_SET, &uV);
310 static int buck_get_enable(struct udevice *dev)
316 ret = lp873x_buck_enable(dev, PMIC_OP_GET, &enable);
323 static int buck_set_enable(struct udevice *dev, bool enable)
325 return lp873x_buck_enable(dev, PMIC_OP_SET, &enable);
328 static const struct dm_regulator_ops lp873x_ldo_ops = {
329 .get_value = ldo_get_value,
330 .set_value = ldo_set_value,
331 .get_enable = ldo_get_enable,
332 .set_enable = ldo_set_enable,
335 U_BOOT_DRIVER(lp873x_ldo) = {
336 .name = LP873X_LDO_DRIVER,
337 .id = UCLASS_REGULATOR,
338 .ops = &lp873x_ldo_ops,
339 .probe = lp873x_ldo_probe,
342 static const struct dm_regulator_ops lp873x_buck_ops = {
343 .get_value = buck_get_value,
344 .set_value = buck_set_value,
345 .get_enable = buck_get_enable,
346 .set_enable = buck_set_enable,
349 U_BOOT_DRIVER(lp873x_buck) = {
350 .name = LP873X_BUCK_DRIVER,
351 .id = UCLASS_REGULATOR,
352 .ops = &lp873x_buck_ops,
353 .probe = lp873x_buck_probe,