3 * Texas Instruments Incorporated, <www.ti.com>
5 * Keerthy <j-keerthy@ti.com>
7 * SPDX-License-Identifier: GPL-2.0+
15 #include <power/pmic.h>
16 #include <power/regulator.h>
17 #include <power/lp873x.h>
19 DECLARE_GLOBAL_DATA_PTR;
21 static const char lp873x_buck_ctrl[LP873X_BUCK_NUM] = {0x2, 0x4};
22 static const char lp873x_buck_volt[LP873X_BUCK_NUM] = {0x6, 0x7};
23 static const char lp873x_ldo_ctrl[LP873X_LDO_NUM] = {0x8, 0x9};
24 static const char lp873x_ldo_volt[LP873X_LDO_NUM] = {0xA, 0xB};
26 static int lp873x_buck_enable(struct udevice *dev, int op, bool *enable)
30 struct dm_regulator_uclass_platdata *uc_pdata;
32 uc_pdata = dev_get_uclass_platdata(dev);
33 adr = uc_pdata->ctrl_reg;
35 ret = pmic_reg_read(dev->parent, adr);
39 if (op == PMIC_OP_GET) {
40 ret &= LP873X_BUCK_MODE_MASK;
48 } else if (op == PMIC_OP_SET) {
50 ret |= LP873X_BUCK_MODE_MASK;
52 ret &= ~(LP873X_BUCK_MODE_MASK);
53 ret = pmic_reg_write(dev->parent, adr, ret);
61 static int lp873x_buck_volt2hex(int uV)
63 if (uV > LP873X_BUCK_VOLT_MAX)
65 else if (uV > 1400000)
66 return (uV - 1420000) / 20000 + 0x9E;
68 return (uV - 735000) / 5000 + 0x18;
69 else if (uV >= 700000)
70 return (uV - 700000) / 10000 + 0x1;
75 static int lp873x_buck_hex2volt(int hex)
77 if (hex > LP873X_BUCK_VOLT_MAX_HEX)
80 return 1400000 + (hex - 0x9D) * 20000;
82 return 730000 + (hex - 0x17) * 5000;
84 return 700000 + (hex - 0x14) * 10000;
89 static int lp873x_buck_val(struct udevice *dev, int op, int *uV)
91 unsigned int hex, adr;
93 struct dm_regulator_uclass_platdata *uc_pdata;
95 uc_pdata = dev_get_uclass_platdata(dev);
97 if (op == PMIC_OP_GET)
100 adr = uc_pdata->volt_reg;
102 ret = pmic_reg_read(dev->parent, adr);
106 if (op == PMIC_OP_GET) {
107 ret &= LP873X_BUCK_VOLT_MASK;
108 ret = lp873x_buck_hex2volt(ret);
116 hex = lp873x_buck_volt2hex(*uV);
123 ret = pmic_reg_write(dev->parent, adr, ret);
128 static int lp873x_ldo_enable(struct udevice *dev, int op, bool *enable)
132 struct dm_regulator_uclass_platdata *uc_pdata;
134 uc_pdata = dev_get_uclass_platdata(dev);
135 adr = uc_pdata->ctrl_reg;
137 ret = pmic_reg_read(dev->parent, adr);
141 if (op == PMIC_OP_GET) {
142 ret &= LP873X_LDO_MODE_MASK;
150 } else if (op == PMIC_OP_SET) {
152 ret |= LP873X_LDO_MODE_MASK;
154 ret &= ~(LP873X_LDO_MODE_MASK);
156 ret = pmic_reg_write(dev->parent, adr, ret);
164 static int lp873x_ldo_volt2hex(int uV)
166 if (uV > LP873X_LDO_VOLT_MAX)
169 return (uV - 800000) / 100000;
172 static int lp873x_ldo_hex2volt(int hex)
174 if (hex > LP873X_LDO_VOLT_MAX_HEX)
180 return (hex * 100000) + 800000;
183 static int lp873x_ldo_val(struct udevice *dev, int op, int *uV)
185 unsigned int hex, adr;
188 struct dm_regulator_uclass_platdata *uc_pdata;
190 if (op == PMIC_OP_GET)
193 uc_pdata = dev_get_uclass_platdata(dev);
195 adr = uc_pdata->volt_reg;
197 ret = pmic_reg_read(dev->parent, adr);
201 if (op == PMIC_OP_GET) {
202 ret &= LP873X_LDO_VOLT_MASK;
203 ret = lp873x_ldo_hex2volt(ret);
210 hex = lp873x_ldo_volt2hex(*uV);
214 ret &= ~LP873X_LDO_VOLT_MASK;
218 ret = pmic_reg_write(dev->parent, adr, ret);
223 static int lp873x_ldo_probe(struct udevice *dev)
225 struct dm_regulator_uclass_platdata *uc_pdata;
227 uc_pdata = dev_get_uclass_platdata(dev);
228 uc_pdata->type = REGULATOR_TYPE_LDO;
230 int idx = dev->driver_data;
231 if (idx >= LP873X_LDO_NUM) {
232 printf("Wrong ID for regulator\n");
236 uc_pdata->ctrl_reg = lp873x_ldo_ctrl[idx];
237 uc_pdata->volt_reg = lp873x_ldo_volt[idx];
242 static int ldo_get_value(struct udevice *dev)
247 ret = lp873x_ldo_val(dev, PMIC_OP_GET, &uV);
254 static int ldo_set_value(struct udevice *dev, int uV)
256 return lp873x_ldo_val(dev, PMIC_OP_SET, &uV);
259 static bool ldo_get_enable(struct udevice *dev)
264 ret = lp873x_ldo_enable(dev, PMIC_OP_GET, &enable);
271 static int ldo_set_enable(struct udevice *dev, bool enable)
273 return lp873x_ldo_enable(dev, PMIC_OP_SET, &enable);
276 static int lp873x_buck_probe(struct udevice *dev)
278 struct dm_regulator_uclass_platdata *uc_pdata;
281 uc_pdata = dev_get_uclass_platdata(dev);
282 uc_pdata->type = REGULATOR_TYPE_BUCK;
284 idx = dev->driver_data;
285 if (idx >= LP873X_BUCK_NUM) {
286 printf("Wrong ID for regulator\n");
290 uc_pdata->ctrl_reg = lp873x_buck_ctrl[idx];
291 uc_pdata->volt_reg = lp873x_buck_volt[idx];
296 static int buck_get_value(struct udevice *dev)
301 ret = lp873x_buck_val(dev, PMIC_OP_GET, &uV);
308 static int buck_set_value(struct udevice *dev, int uV)
310 return lp873x_buck_val(dev, PMIC_OP_SET, &uV);
313 static bool buck_get_enable(struct udevice *dev)
319 ret = lp873x_buck_enable(dev, PMIC_OP_GET, &enable);
326 static int buck_set_enable(struct udevice *dev, bool enable)
328 return lp873x_buck_enable(dev, PMIC_OP_SET, &enable);
331 static const struct dm_regulator_ops lp873x_ldo_ops = {
332 .get_value = ldo_get_value,
333 .set_value = ldo_set_value,
334 .get_enable = ldo_get_enable,
335 .set_enable = ldo_set_enable,
338 U_BOOT_DRIVER(lp873x_ldo) = {
339 .name = LP873X_LDO_DRIVER,
340 .id = UCLASS_REGULATOR,
341 .ops = &lp873x_ldo_ops,
342 .probe = lp873x_ldo_probe,
345 static const struct dm_regulator_ops lp873x_buck_ops = {
346 .get_value = buck_get_value,
347 .set_value = buck_set_value,
348 .get_enable = buck_get_enable,
349 .set_enable = buck_set_enable,
352 U_BOOT_DRIVER(lp873x_buck) = {
353 .name = LP873X_BUCK_DRIVER,
354 .id = UCLASS_REGULATOR,
355 .ops = &lp873x_buck_ops,
356 .probe = lp873x_buck_probe,