2 * Copyright (C) 2015 Google, Inc
3 * Written by Simon Glass <sjg@chromium.org>
5 * Based on Rockchip's drivers/power/pmic/pmic_rk808.c:
6 * Copyright (C) 2012 rockchips
7 * zyw <zyw@rock-chips.com>
9 * SPDX-License-Identifier: GPL-2.0+
15 #include <power/rk808_pmic.h>
16 #include <power/pmic.h>
17 #include <power/regulator.h>
19 #ifndef CONFIG_SPL_BUILD
23 struct rk808_reg_info {
30 static const struct rk808_reg_info rk808_buck[] = {
31 { 712500, 12500, REG_BUCK1_ON_VSEL, 6, },
32 { 712500, 12500, REG_BUCK2_ON_VSEL, 6, },
33 { 712500, 12500, -1, 6, },
34 { 1800000, 100000, REG_BUCK4_ON_VSEL, 4, },
37 static const struct rk808_reg_info rk808_ldo[] = {
38 { 1800000, 100000, LDO1_ON_VSEL, 5, },
39 { 1800000, 100000, LDO2_ON_VSEL, 5, },
40 { 800000, 100000, LDO3_ON_VSEL, 4, },
41 { 1800000, 100000, LDO4_ON_VSEL, 5, },
42 { 1800000, 100000, LDO5_ON_VSEL, 5, },
43 { 800000, 100000, LDO6_ON_VSEL, 5, },
44 { 800000, 100000, LDO7_ON_VSEL, 5, },
45 { 1800000, 100000, LDO8_ON_VSEL, 5, },
49 static int _buck_set_value(struct udevice *pmic, int buck, int uvolt)
51 const struct rk808_reg_info *info = &rk808_buck[buck - 1];
52 int mask = (1 << info->vsel_bits) - 1;
55 if (info->vsel_reg == -1)
57 val = (uvolt - info->min_uv) / info->step_uv;
58 debug("%s: reg=%x, mask=%x, val=%x\n", __func__, info->vsel_reg, mask,
61 return pmic_clrsetbits(pmic, info->vsel_reg, mask, val);
64 static int _buck_set_enable(struct udevice *pmic, int buck, bool enable)
72 ret = pmic_clrsetbits(pmic, DCDC_ILMAX, 0, 3 << (buck * 2));
75 ret = pmic_clrsetbits(pmic, REG_DCDC_UV_ACT, 1 << buck, 0);
80 return pmic_clrsetbits(pmic, REG_DCDC_EN, mask, enable ? mask : 0);
84 static int buck_get_value(struct udevice *dev)
86 int buck = dev->driver_data - 1;
87 const struct rk808_reg_info *info = &rk808_buck[buck];
88 int mask = (1 << info->vsel_bits) - 1;
91 if (info->vsel_reg == -1)
93 ret = pmic_reg_read(dev->parent, info->vsel_reg);
98 return info->min_uv + val * info->step_uv;
101 static int buck_set_value(struct udevice *dev, int uvolt)
103 int buck = dev->driver_data;
105 return _buck_set_value(dev->parent, buck, uvolt);
108 static int buck_set_enable(struct udevice *dev, bool enable)
110 int buck = dev->driver_data;
112 return _buck_set_enable(dev->parent, buck, enable);
115 static bool buck_get_enable(struct udevice *dev)
117 int buck = dev->driver_data - 1;
123 ret = pmic_reg_read(dev->parent, REG_DCDC_EN);
127 return ret & mask ? true : false;
130 static int ldo_get_value(struct udevice *dev)
132 int ldo = dev->driver_data - 1;
133 const struct rk808_reg_info *info = &rk808_ldo[ldo];
134 int mask = (1 << info->vsel_bits) - 1;
137 if (info->vsel_reg == -1)
139 ret = pmic_reg_read(dev->parent, info->vsel_reg);
144 return info->min_uv + val * info->step_uv;
147 static int ldo_set_value(struct udevice *dev, int uvolt)
149 int ldo = dev->driver_data - 1;
150 const struct rk808_reg_info *info = &rk808_ldo[ldo];
151 int mask = (1 << info->vsel_bits) - 1;
154 if (info->vsel_reg == -1)
156 val = (uvolt - info->min_uv) / info->step_uv;
157 debug("%s: reg=%x, mask=%x, val=%x\n", __func__, info->vsel_reg, mask,
160 return pmic_clrsetbits(dev->parent, info->vsel_reg, mask, val);
163 static int ldo_set_enable(struct udevice *dev, bool enable)
165 int ldo = dev->driver_data - 1;
170 return pmic_clrsetbits(dev->parent, REG_LDO_EN, mask,
174 static bool ldo_get_enable(struct udevice *dev)
176 int ldo = dev->driver_data - 1;
182 ret = pmic_reg_read(dev->parent, REG_LDO_EN);
186 return ret & mask ? true : false;
189 static int switch_set_enable(struct udevice *dev, bool enable)
191 int sw = dev->driver_data - 1;
194 mask = 1 << (sw + 5);
196 return pmic_clrsetbits(dev->parent, REG_DCDC_EN, mask,
200 static bool switch_get_enable(struct udevice *dev)
202 int sw = dev->driver_data - 1;
206 mask = 1 << (sw + 5);
208 ret = pmic_reg_read(dev->parent, REG_DCDC_EN);
212 return ret & mask ? true : false;
215 static int rk808_buck_probe(struct udevice *dev)
217 struct dm_regulator_uclass_platdata *uc_pdata;
219 uc_pdata = dev_get_uclass_platdata(dev);
221 uc_pdata->type = REGULATOR_TYPE_BUCK;
222 uc_pdata->mode_count = 0;
227 static int rk808_ldo_probe(struct udevice *dev)
229 struct dm_regulator_uclass_platdata *uc_pdata;
231 uc_pdata = dev_get_uclass_platdata(dev);
233 uc_pdata->type = REGULATOR_TYPE_LDO;
234 uc_pdata->mode_count = 0;
239 static int rk808_switch_probe(struct udevice *dev)
241 struct dm_regulator_uclass_platdata *uc_pdata;
243 uc_pdata = dev_get_uclass_platdata(dev);
245 uc_pdata->type = REGULATOR_TYPE_FIXED;
246 uc_pdata->mode_count = 0;
251 static const struct dm_regulator_ops rk808_buck_ops = {
252 .get_value = buck_get_value,
253 .set_value = buck_set_value,
254 .get_enable = buck_get_enable,
255 .set_enable = buck_set_enable,
258 static const struct dm_regulator_ops rk808_ldo_ops = {
259 .get_value = ldo_get_value,
260 .set_value = ldo_set_value,
261 .get_enable = ldo_get_enable,
262 .set_enable = ldo_set_enable,
265 static const struct dm_regulator_ops rk808_switch_ops = {
266 .get_enable = switch_get_enable,
267 .set_enable = switch_set_enable,
270 U_BOOT_DRIVER(rk808_buck) = {
271 .name = "rk808_buck",
272 .id = UCLASS_REGULATOR,
273 .ops = &rk808_buck_ops,
274 .probe = rk808_buck_probe,
277 U_BOOT_DRIVER(rk808_ldo) = {
279 .id = UCLASS_REGULATOR,
280 .ops = &rk808_ldo_ops,
281 .probe = rk808_ldo_probe,
284 U_BOOT_DRIVER(rk808_switch) = {
285 .name = "rk808_switch",
286 .id = UCLASS_REGULATOR,
287 .ops = &rk808_switch_ops,
288 .probe = rk808_switch_probe,
292 int rk808_spl_configure_buck(struct udevice *pmic, int buck, int uvolt)
296 ret = _buck_set_value(pmic, buck, uvolt);
300 return _buck_set_enable(pmic, buck, true);