1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2021 Rockchip Electronics Co., Ltd
4 */
5 #include <common.h>
6 #include <dm.h>
7 #include <errno.h>
8 #include <i2c.h>
9 #include <syscon.h>
10 #include <asm/gpio.h>
11 #include <power/regulator.h>
12 #include <asm/arch/clock.h>
13 #include <asm/io.h>
14
15 DECLARE_GLOBAL_DATA_PTR;
16
17 /* Voltage setting */
18
19 #define RK860X_VSEL0_A 0x00
20 #define RK860X_VSEL1_A 0x01
21 #define RK860X_VSEL0_B 0x06
22 #define RK860X_VSEL1_B 0x07
23 #define RK860X_MAX_SET 0x08
24
25 /* Control register */
26 #define RK860X_CONTROL 0x02
27 /* IC Type */
28 #define RK860X_ID1 0x03
29 /* IC mask version */
30 #define RK860X_ID2 0x04
31 /* Monitor register */
32 #define RK860X_MONITOR 0x05
33
34 /* VSEL bit definitions */
35 #define VSEL_BUCK_EN BIT(7)
36 #define VSEL_MODE BIT(6)
37 #define VSEL_A_NSEL_MASK 0x3F
38 #define VSEL_B_NSEL_MASK 0xff
39
40 /* Chip ID */
41 #define DIE_ID 0x0F
42 #define DIE_REV 0x0F
43 /* Control bit definitions */
44 #define CTL_OUTPUT_DISCHG BIT(7)
45 #define CTL_SLEW_MASK (0x7 << 4)
46 #define CTL_SLEW_SHIFT 4
47 #define CTL_RESET BIT(2)
48
49 #define RK860X_NVOLTAGES_64 64
50 #define RK860X_NVOLTAGES_160 160
51
52 /* IC Type */
53 enum {
54 RK860X_CHIP_ID_00 = 0,
55 RK860X_CHIP_ID_01,
56 RK860X_CHIP_ID_02,
57 RK860X_CHIP_ID_03,
58 };
59
60 struct rk860x_regulator_info {
61 struct udevice *dev;
62 /* IC Type and Rev */
63 int chip_id;
64 /* Voltage setting register */
65 unsigned int vol_reg;
66 unsigned int sleep_reg;
67 unsigned int en_reg;
68 unsigned int sleep_en_reg;
69 unsigned int mode_reg;
70 unsigned int vol_mask;
71 unsigned int mode_mask;
72 unsigned int n_voltages;
73 /* Voltage range and step(linear) */
74 unsigned int vsel_min;
75 unsigned int vsel_step;
76 struct gpio_desc vsel_gpio;
77 struct gpio_desc en_gpio;
78 unsigned int sleep_vsel_id;
79 };
80
rk860x_write(struct udevice * dev,uint reg,const uint8_t * buff,int len)81 static int rk860x_write(struct udevice *dev, uint reg, const uint8_t *buff,
82 int len)
83 {
84 int ret;
85
86 ret = dm_i2c_write(dev, reg, buff, len);
87 if (ret) {
88 dev_err(dev, "write reg[0x%02x] failed, ret=%d\n", reg, ret);
89 return ret;
90 }
91
92 return 0;
93 }
94
rk860x_read(struct udevice * dev,uint reg,uint8_t * buff,int len)95 static int rk860x_read(struct udevice *dev, uint reg, uint8_t *buff, int len)
96 {
97 int ret;
98
99 ret = dm_i2c_read(dev, reg, buff, len);
100 if (ret) {
101 dev_err(dev, "read reg[0x%02x] failed, ret=%d\n", reg, ret);
102 return ret;
103 }
104
105 return 0;
106 }
107
rk860x_reg_read(struct udevice * dev,uint reg,u8 * val)108 static int rk860x_reg_read(struct udevice *dev, uint reg, u8 *val)
109 {
110 int ret;
111
112 debug("%s: reg=%x", __func__, reg);
113 ret = rk860x_read(dev, reg, val, 1);
114 debug(", value=%x, ret=%d\n", *val, ret);
115
116 return ret;
117 }
118
rk860x_reg_write(struct udevice * dev,uint reg,uint value)119 static int rk860x_reg_write(struct udevice *dev, uint reg, uint value)
120 {
121 u8 byte = value;
122 int ret;
123
124 debug("%s: reg=%x, value=%x", __func__, reg, value);
125 ret = rk860x_write(dev, reg, &byte, 1);
126 debug(", ret=%d\n", ret);
127
128 return ret;
129 }
130
rk860x_clrsetbits(struct udevice * dev,uint reg,uint clr,uint set)131 static int rk860x_clrsetbits(struct udevice *dev, uint reg, uint clr, uint set)
132 {
133 u8 byte, val;
134 int ret;
135
136 ret = rk860x_reg_read(dev, reg, &val);
137 if (ret < 0)
138 return ret;
139
140 byte = (val & ~clr) | set;
141
142 return rk860x_reg_write(dev, reg, byte);
143 }
144
rk860x_regulator_set_enable(struct udevice * dev,bool enable)145 static int rk860x_regulator_set_enable(struct udevice *dev, bool enable)
146 {
147 struct rk860x_regulator_info *priv = dev_get_priv(dev);
148 int val, sleep_vsel_id;
149
150 if (enable) {
151 val = VSEL_BUCK_EN;
152 sleep_vsel_id = !priv->sleep_vsel_id;
153 } else {
154 val = 0;
155 sleep_vsel_id = priv->sleep_vsel_id;
156 }
157
158 if (dm_gpio_is_valid(&priv->vsel_gpio)) {
159 dm_gpio_set_value(&priv->vsel_gpio, sleep_vsel_id);
160 return 0;
161 }
162 rk860x_clrsetbits(dev, priv->en_reg, VSEL_BUCK_EN, val);
163
164 return 0;
165 }
166
rk860x_regulator_get_enable(struct udevice * dev)167 static int rk860x_regulator_get_enable(struct udevice *dev)
168 {
169 struct rk860x_regulator_info *priv = dev_get_priv(dev);
170 u8 val;
171 int ret;
172
173 if (dm_gpio_is_valid(&priv->vsel_gpio)) {
174 if (priv->sleep_vsel_id)
175 return !dm_gpio_get_value(&priv->vsel_gpio);
176 else
177 return dm_gpio_get_value(&priv->vsel_gpio);
178 }
179
180 ret = rk860x_reg_read(dev, priv->en_reg, &val);
181 if (ret)
182 return ret;
183
184 if (val & VSEL_BUCK_EN)
185 return 1;
186 else
187 return 0;
188 }
189
rk860x_regulator_set_suspend_enable(struct udevice * dev,bool enable)190 static int rk860x_regulator_set_suspend_enable(struct udevice *dev,
191 bool enable)
192 {
193 struct rk860x_regulator_info *priv = dev_get_priv(dev);
194 int val;
195
196 if (enable)
197 val = VSEL_BUCK_EN;
198 else
199 val = 0;
200
201 rk860x_clrsetbits(dev, priv->sleep_en_reg, VSEL_BUCK_EN, val);
202
203 return 0;
204 }
205
rk860x_regulator_get_suspend_enable(struct udevice * dev)206 static int rk860x_regulator_get_suspend_enable(struct udevice *dev)
207 {
208 struct rk860x_regulator_info *priv = dev_get_priv(dev);
209 int ret;
210 u8 val;
211
212 ret = rk860x_reg_read(dev, priv->sleep_en_reg, &val);
213 if (ret)
214 return ret;
215
216 if (val & VSEL_BUCK_EN)
217 return 1;
218 else
219 return 0;
220 }
221
rk860x_regulator_get_voltage(struct udevice * dev)222 static int rk860x_regulator_get_voltage(struct udevice *dev)
223 {
224 struct rk860x_regulator_info *priv = dev_get_priv(dev);
225 int uvolt = 0, ret;
226 u8 val;
227
228 ret = rk860x_reg_read(dev, priv->vol_reg, &val);
229 if (ret)
230 return ret;
231
232 val &= priv->vol_mask;
233 uvolt = (val * priv->vsel_step) + priv->vsel_min;
234
235 return uvolt;
236 }
237
rk860x_regulator_set_voltage(struct udevice * dev,int uvolt)238 static int rk860x_regulator_set_voltage(struct udevice *dev, int uvolt)
239 {
240 struct rk860x_regulator_info *priv = dev_get_priv(dev);
241 int val;
242
243 val = ((uvolt - priv->vsel_min) / priv->vsel_step);
244 rk860x_clrsetbits(dev, priv->vol_reg, priv->vol_mask, val);
245
246 return 0;
247 }
248
rk860x_regulator_get_suspend_voltage(struct udevice * dev)249 static int rk860x_regulator_get_suspend_voltage(struct udevice *dev)
250 {
251 struct rk860x_regulator_info *priv = dev_get_priv(dev);
252 int uvolt = 0, ret;
253 u8 val;
254
255 ret = rk860x_reg_read(dev, priv->sleep_reg, &val);
256 if (ret)
257 return ret;
258
259 val &= priv->vol_mask;
260 uvolt = (val * priv->vsel_step) + priv->vsel_min;
261
262 return uvolt;
263 }
264
rk860x_regulator_set_suspend_voltage(struct udevice * dev,int uvolt)265 static int rk860x_regulator_set_suspend_voltage(struct udevice *dev,
266 int uvolt)
267 {
268 struct rk860x_regulator_info *priv = dev_get_priv(dev);
269 int val;
270
271 val = ((uvolt - priv->vsel_min) / priv->vsel_step);
272 rk860x_clrsetbits(dev, priv->sleep_reg, priv->vol_mask, val);
273
274 return 0;
275 }
276
277 /* For 00,01 options:
278 * VOUT = 0.7125V + NSELx * 12.5mV, from 0.7125 to 1.5V.
279 * For 02,03 options:
280 * VOUT = 0.5V + NSELx * 6.25mV, from 0.5 to 1.5V.
281 */
rk860x_device_setup(struct rk860x_regulator_info * di)282 static int rk860x_device_setup(struct rk860x_regulator_info *di)
283 {
284 int ret = 0;
285
286 switch (di->chip_id) {
287 case RK860X_CHIP_ID_00:
288 case RK860X_CHIP_ID_01:
289 di->vsel_min = 712500;
290 di->vsel_step = 12500;
291 di->n_voltages = RK860X_NVOLTAGES_64;
292 di->vol_mask = VSEL_A_NSEL_MASK;
293 if (di->sleep_vsel_id) {
294 di->sleep_reg = RK860X_VSEL1_A;
295 di->vol_reg = RK860X_VSEL0_A;
296 di->mode_reg = RK860X_VSEL0_A;
297 di->en_reg = RK860X_VSEL0_A;
298 di->sleep_en_reg = RK860X_VSEL1_A;
299 } else {
300 di->sleep_reg = RK860X_VSEL0_A;
301 di->vol_reg = RK860X_VSEL1_A;
302 di->mode_reg = RK860X_VSEL1_A;
303 di->en_reg = RK860X_VSEL1_A;
304 di->sleep_en_reg = RK860X_VSEL0_A;
305 }
306 break;
307 case RK860X_CHIP_ID_02:
308 case RK860X_CHIP_ID_03:
309 di->vsel_min = 500000;
310 di->vsel_step = 6250;
311 di->n_voltages = RK860X_NVOLTAGES_160;
312 di->vol_mask = VSEL_B_NSEL_MASK;
313 if (di->sleep_vsel_id) {
314 di->sleep_reg = RK860X_VSEL1_B;
315 di->vol_reg = RK860X_VSEL0_B;
316 di->mode_reg = RK860X_VSEL0_A;
317 di->en_reg = RK860X_VSEL0_A;
318 di->sleep_en_reg = RK860X_VSEL1_A;
319 } else {
320 di->sleep_reg = RK860X_VSEL0_B;
321 di->vol_reg = RK860X_VSEL1_B;
322 di->mode_reg = RK860X_VSEL1_A;
323 di->en_reg = RK860X_VSEL1_A;
324 di->sleep_en_reg = RK860X_VSEL0_A;
325 }
326 break;
327 default:
328 dev_err(di->dev,
329 "Chip ID %d not supported!\n",
330 di->chip_id);
331 return -EINVAL;
332 }
333
334 di->mode_mask = VSEL_MODE;
335
336 return ret;
337 }
338
rk860x_regulator_ofdata_to_platdata(struct udevice * dev)339 static int rk860x_regulator_ofdata_to_platdata(struct udevice *dev)
340 {
341 struct rk860x_regulator_info *priv = dev_get_priv(dev);
342 int ret;
343
344 priv->sleep_vsel_id = dev_read_u32_default(dev,
345 "rockchip,suspend-voltage-selector",
346 1);
347
348 ret = gpio_request_by_name(dev, "vsel-gpios", 0,
349 &priv->vsel_gpio, GPIOD_IS_OUT);
350 if (ret)
351 dev_err(dev, "vsel-gpios- not found!\n");
352
353 if (dm_gpio_is_valid(&priv->vsel_gpio))
354 dm_gpio_set_value(&priv->vsel_gpio, !priv->sleep_vsel_id);
355
356 ret = gpio_request_by_name(dev, "en-gpios", 0,
357 &priv->en_gpio, GPIOD_IS_OUT);
358 if (ret)
359 dev_err(dev, "en-gpios- not found!\n");
360
361 if (dm_gpio_is_valid(&priv->en_gpio))
362 dm_gpio_set_value(&priv->en_gpio, 1);
363
364 return 0;
365 }
366
rk860x_regulator_probe(struct udevice * dev)367 static int rk860x_regulator_probe(struct udevice *dev)
368 {
369 struct rk860x_regulator_info *di = dev_get_priv(dev);
370 struct dm_regulator_uclass_platdata *uc_pdata;
371 u8 val;
372 int ret;
373
374 uc_pdata = dev_get_uclass_platdata(dev);
375 uc_pdata->type = REGULATOR_TYPE_BUCK;
376 uc_pdata->mode_count = 0;
377
378 /* Get chip ID */
379 ret = rk860x_reg_read(dev, RK860X_ID1, &val);
380 if (ret) {
381 dev_err(dev, "Failed to get chip ID!\n");
382 return ret;
383 }
384
385 if ((val & DIE_ID) == 0x8)
386 di->chip_id = RK860X_CHIP_ID_00;
387 else
388 di->chip_id = RK860X_CHIP_ID_02;
389
390 debug("RK860X Option[%d] Detected!\n", val & DIE_ID);
391
392 /* Device init */
393 ret = rk860x_device_setup(di);
394 if (ret < 0) {
395 dev_err(dev, "Failed to setup device!\n");
396 return ret;
397 }
398
399 return 0;
400 }
401
402 static const struct udevice_id rk860x_id[] = {
403 {
404 .compatible = "rockchip,rk8600",
405 },
406 {
407 .compatible = "rockchip,rk8601",
408 },
409 {
410 .compatible = "rockchip,rk8602",
411 },
412 {
413 .compatible = "rockchip,rk8603",
414 },
415 { },
416 };
417
418 static const struct dm_regulator_ops rk860x_regulator_ops = {
419 .get_value = rk860x_regulator_get_voltage,
420 .set_value = rk860x_regulator_set_voltage,
421 .set_suspend_value = rk860x_regulator_set_suspend_voltage,
422 .get_suspend_value = rk860x_regulator_get_suspend_voltage,
423 .set_enable = rk860x_regulator_set_enable,
424 .get_enable = rk860x_regulator_get_enable,
425 .set_suspend_enable = rk860x_regulator_set_suspend_enable,
426 .get_suspend_enable = rk860x_regulator_get_suspend_enable,
427 };
428
429 U_BOOT_DRIVER(rk860x_regulator) = {
430 .name = "rk860x_regulator",
431 .id = UCLASS_REGULATOR,
432 .ops = &rk860x_regulator_ops,
433 .probe = rk860x_regulator_probe,
434 .of_match = rk860x_id,
435 .ofdata_to_platdata = rk860x_regulator_ofdata_to_platdata,
436 .priv_auto_alloc_size = sizeof(struct rk860x_regulator_info),
437 };
438
439