1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2018 Fuzhou Rockchip Electronics Co., Ltd
4 */
5 #include <common.h>
6 #include <dm.h>
7 #include <errno.h>
8 #include <asm/gpio.h>
9 #include <power/regulator.h>
10 #include <i2c.h>
11 #include <asm/arch/clock.h>
12 #include <asm/io.h>
13 #include <syscon.h>
14
15 DECLARE_GLOBAL_DATA_PTR;
16
17 /* Voltage setting */
18 #define FAN53555_VSEL0 0x00
19 #define FAN53555_VSEL1 0x01
20
21 #define TCS452X_VSEL0 0x11
22 #define TCS452X_VSEL1 0x10
23 #define TCS452X_TIME 0x13
24 #define TCS452X_COMMAND 0x14
25
26 /* Control register */
27 #define FAN53555_CONTROL 0x02
28 /* IC Type */
29 #define FAN53555_ID1 0x03
30 /* IC mask version */
31 #define FAN53555_ID2 0x04
32 /* Monitor register */
33 #define FAN53555_MONITOR 0x05
34
35 /* VSEL bit definitions */
36 #define VSEL_BUCK_EN BIT(7)
37 #define VSEL_MODE BIT(6)
38 #define VSEL_NSEL_MASK 0x3F
39
40 /* Chip ID and Version */
41 #define DIE_ID 0x0F/* ID1 */
42 #define DIE_REV 0x0F/* ID2 */
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 TCS_VSEL_NSEL_MASK 0x7f
50 #define TCS_VSEL0_MODE BIT(7)
51 #define TCS_VSEL1_MODE BIT(6)
52
53 #define TCS_SLEW_SHIFT 3
54 #define TCS_SLEW_MASK (0x3 < 3)
55
56 #define FAN53555_NVOLTAGES_64 64/* Numbers of voltages */
57 #define FAN53555_NVOLTAGES_127 127/* Numbers of voltages */
58
59 enum fan53555_vendor {
60 FAN53555_VENDOR_FAIRCHILD = 0,
61 FAN53555_VENDOR_SILERGY,
62 FAN53555_VENDOR_TCS,
63 };
64
65 /* IC Type */
66 enum {
67 FAN53555_CHIP_ID_00 = 0,
68 FAN53555_CHIP_ID_01,
69 FAN53555_CHIP_ID_02,
70 FAN53555_CHIP_ID_03,
71 FAN53555_CHIP_ID_04,
72 FAN53555_CHIP_ID_05,
73 FAN53555_CHIP_ID_08 = 8,
74 };
75
76 /* IC mask revision */
77 enum {
78 FAN53555_CHIP_REV_00 = 0x3,
79 FAN53555_CHIP_REV_13 = 0xf,
80 };
81
82 enum {
83 SILERGY_SYR82X = 8,
84 };
85
86 enum {
87 FAN53555_VSEL_ID_0 = 0,
88 FAN53555_VSEL_ID_1,
89 };
90
91 struct fan53555_regulator_info {
92 enum fan53555_vendor vendor;
93 struct udevice *dev;
94 /* IC Type and Rev */
95 int chip_id;
96 int chip_rev;
97 /* Voltage setting register */
98 unsigned int vol_reg;
99 unsigned int sleep_reg;
100 unsigned int mode_reg;
101 unsigned int vol_mask;
102 unsigned int mode_mask;
103 /* Voltage range and step(linear) */
104 unsigned int vsel_min;
105 unsigned int vsel_step;
106 struct gpio_desc vsel_gpio;
107 unsigned int sleep_vsel_id;
108 };
109
fan53555_write(struct udevice * dev,uint reg,const uint8_t * buff,int len)110 static int fan53555_write(struct udevice *dev, uint reg, const uint8_t *buff,
111 int len)
112 {
113 int ret;
114
115 ret = dm_i2c_write(dev, reg, buff, len);
116 if (ret) {
117 debug("%s: write reg 0x%02x failed, ret=%d\n",
118 __func__, reg, ret);
119 return ret;
120 }
121
122 return 0;
123 }
124
fan53555_read(struct udevice * dev,uint reg,uint8_t * buff,int len)125 static int fan53555_read(struct udevice *dev, uint reg, uint8_t *buff, int len)
126 {
127 int ret;
128
129 ret = dm_i2c_read(dev, reg, buff, len);
130 if (ret) {
131 debug("%s: read reg 0x%02x failed, ret=%d\n",
132 __func__, reg, ret);
133 return ret;
134 }
135
136 return 0;
137 }
138
fan53555_reg_read(struct udevice * dev,uint reg)139 int fan53555_reg_read(struct udevice *dev, uint reg)
140 {
141 u8 byte;
142 int ret;
143
144 debug("%s: reg=%x", __func__, reg);
145 ret = fan53555_read(dev, reg, &byte, 1);
146 debug(", value=%x, ret=%d\n", byte, ret);
147
148 return ret ? ret : byte;
149 }
150
fan53555_reg_write(struct udevice * dev,uint reg,uint value)151 int fan53555_reg_write(struct udevice *dev, uint reg, uint value)
152 {
153 u8 byte = value;
154 int ret;
155
156 debug("%s: reg=%x, value=%x", __func__, reg, value);
157 ret = fan53555_write(dev, reg, &byte, 1);
158 debug(", ret=%d\n", ret);
159
160 return ret;
161 }
162
fan53555_clrsetbits(struct udevice * dev,uint reg,uint clr,uint set)163 int fan53555_clrsetbits(struct udevice *dev, uint reg, uint clr, uint set)
164 {
165 u8 byte;
166 int ret;
167
168 ret = fan53555_reg_read(dev, reg);
169 if (ret < 0)
170 return ret;
171 byte = (ret & ~clr) | set;
172
173 return fan53555_reg_write(dev, reg, byte);
174 }
175
fan53555_regulator_set_enable(struct udevice * dev,bool enable)176 static int fan53555_regulator_set_enable(struct udevice *dev, bool enable)
177 {
178 struct fan53555_regulator_info *priv = dev_get_priv(dev);
179 int val, sleep_vsel_id;
180
181 if (enable) {
182 val = VSEL_BUCK_EN;
183 sleep_vsel_id = !priv->sleep_vsel_id;
184 } else {
185 val = 0;
186 sleep_vsel_id = priv->sleep_vsel_id;
187 }
188
189 if (dm_gpio_is_valid(&priv->vsel_gpio)) {
190 dm_gpio_set_value(&priv->vsel_gpio, sleep_vsel_id);
191 return 0;
192 }
193 fan53555_clrsetbits(dev, priv->vol_reg, VSEL_BUCK_EN, val);
194
195 return 0;
196 }
197
fan53555_regulator_get_enable(struct udevice * dev)198 static int fan53555_regulator_get_enable(struct udevice *dev)
199 {
200 struct fan53555_regulator_info *priv = dev_get_priv(dev);
201 int val;
202
203 if (dm_gpio_is_valid(&priv->vsel_gpio)) {
204 if (priv->sleep_vsel_id)
205 return !dm_gpio_get_value(&priv->vsel_gpio);
206 else
207 return dm_gpio_get_value(&priv->vsel_gpio);
208 }
209
210 val = fan53555_reg_read(dev, priv->vol_reg);
211 if (val & VSEL_BUCK_EN)
212 return 1;
213 else
214 return 0;
215 }
216
fan53555_regulator_set_suspend_enable(struct udevice * dev,bool enable)217 static int fan53555_regulator_set_suspend_enable(struct udevice *dev,
218 bool enable)
219 {
220 struct fan53555_regulator_info *priv = dev_get_priv(dev);
221 int val;
222
223 if (enable)
224 val = VSEL_BUCK_EN;
225 else
226 val = 0;
227
228 fan53555_clrsetbits(dev, priv->sleep_reg, VSEL_BUCK_EN, val);
229
230 return 0;
231 }
232
fan53555_regulator_get_suspend_enable(struct udevice * dev)233 static int fan53555_regulator_get_suspend_enable(struct udevice *dev)
234 {
235 struct fan53555_regulator_info *priv = dev_get_priv(dev);
236 int val;
237
238 val = fan53555_reg_read(dev, priv->sleep_reg);
239 if (val & VSEL_BUCK_EN)
240 return 1;
241 else
242 return 0;
243 }
244
fan53555_regulator_get_voltage(struct udevice * dev)245 static int fan53555_regulator_get_voltage(struct udevice *dev)
246 {
247 struct fan53555_regulator_info *priv = dev_get_priv(dev);
248 int uvolt = 0, val;
249
250 val = fan53555_reg_read(dev, priv->vol_reg);
251 val &= priv->vol_mask;
252 uvolt = (val * priv->vsel_step) + priv->vsel_min;
253
254 return uvolt;
255 }
256
fan53555_regulator_set_voltage(struct udevice * dev,int uvolt)257 static int fan53555_regulator_set_voltage(struct udevice *dev, int uvolt)
258 {
259 struct fan53555_regulator_info *priv = dev_get_priv(dev);
260 int val;
261
262 val = ((uvolt - priv->vsel_min) / priv->vsel_step);
263 fan53555_clrsetbits(dev, priv->vol_reg, priv->vol_mask, val);
264
265 return 0;
266 }
267
fan53555_regulator_get_suspend_voltage(struct udevice * dev)268 static int fan53555_regulator_get_suspend_voltage(struct udevice *dev)
269 {
270 struct fan53555_regulator_info *priv = dev_get_priv(dev);
271 int uvolt = 0, val;
272
273 val = fan53555_reg_read(dev, priv->sleep_reg);
274 val &= priv->vol_mask;
275 uvolt = (val * priv->vsel_step) + priv->vsel_min;
276
277 return uvolt;
278 }
279
fan53555_regulator_set_suspend_voltage(struct udevice * dev,int uvolt)280 static int fan53555_regulator_set_suspend_voltage(struct udevice *dev,
281 int uvolt)
282 {
283 struct fan53555_regulator_info *priv = dev_get_priv(dev);
284 int val;
285
286 val = ((uvolt - priv->vsel_min) / priv->vsel_step);
287 fan53555_clrsetbits(dev, priv->sleep_reg, priv->vol_mask, val);
288
289 return 0;
290 }
291
fan53555_voltages_setup_fairchild(struct fan53555_regulator_info * di)292 static int fan53555_voltages_setup_fairchild(struct fan53555_regulator_info *di)
293 {
294 /* Init voltage range and step */
295 switch (di->chip_id) {
296 case FAN53555_CHIP_ID_00:
297 switch (di->chip_rev) {
298 case FAN53555_CHIP_REV_00:
299 di->vsel_min = 600000;
300 di->vsel_step = 10000;
301 break;
302 case FAN53555_CHIP_REV_13:
303 di->vsel_min = 800000;
304 di->vsel_step = 10000;
305 break;
306 default:
307 dev_err(di->dev,
308 "Chip ID %d with rev %d not supported!\n",
309 di->chip_id, di->chip_rev);
310 return -EINVAL;
311 }
312 break;
313 case FAN53555_CHIP_ID_01:
314 case FAN53555_CHIP_ID_03:
315 case FAN53555_CHIP_ID_05:
316 case FAN53555_CHIP_ID_08:
317 di->vsel_min = 600000;
318 di->vsel_step = 10000;
319 break;
320 case FAN53555_CHIP_ID_04:
321 di->vsel_min = 603000;
322 di->vsel_step = 12826;
323 break;
324 default:
325 dev_err(di->dev,
326 "Chip ID %d not supported!\n", di->chip_id);
327 return -EINVAL;
328 }
329 di->vol_mask = VSEL_NSEL_MASK;
330
331 return 0;
332 }
333
fan53555_voltages_setup_silergy(struct fan53555_regulator_info * di)334 static int fan53555_voltages_setup_silergy(struct fan53555_regulator_info *di)
335 {
336 /* Init voltage range and step */
337 di->vsel_min = 712500;
338 di->vsel_step = 12500;
339 di->vol_mask = VSEL_NSEL_MASK;
340
341 return 0;
342 }
343
fan53555_voltages_setup_tcs(struct fan53555_regulator_info * di)344 static int fan53555_voltages_setup_tcs(struct fan53555_regulator_info *di)
345 {
346 if (di->sleep_vsel_id) {
347 di->sleep_reg = TCS452X_VSEL1;
348 di->vol_reg = TCS452X_VSEL0;
349 } else {
350 di->sleep_reg = TCS452X_VSEL0;
351 di->vol_reg = TCS452X_VSEL1;
352 }
353
354 di->vol_mask = TCS_VSEL_NSEL_MASK;
355
356 /* Init voltage range and step */
357 di->vsel_min = 600000;
358 di->vsel_step = 6250;
359
360 return 0;
361 }
362
363 /* For 00,01,03,05 options:
364 * VOUT = 0.60V + NSELx * 10mV, from 0.60 to 1.23V.
365 * For 04 option:
366 * VOUT = 0.603V + NSELx * 12.826mV, from 0.603 to 1.411V.
367 *
368 */
369
fan53555_device_setup(struct fan53555_regulator_info * di)370 static int fan53555_device_setup(struct fan53555_regulator_info *di)
371 {
372 int ret = 0;
373
374 /* Setup voltage control register */
375 switch (di->sleep_vsel_id) {
376 case FAN53555_VSEL_ID_0:
377 di->sleep_reg = FAN53555_VSEL0;
378 di->vol_reg = FAN53555_VSEL1;
379 break;
380 case FAN53555_VSEL_ID_1:
381 di->sleep_reg = FAN53555_VSEL1;
382 di->vol_reg = FAN53555_VSEL0;
383 break;
384 default:
385 dev_err(di->dev, "Invalid VSEL ID!\n");
386 return -EINVAL;
387 }
388
389 switch (di->vendor) {
390 case FAN53555_VENDOR_FAIRCHILD:
391 ret = fan53555_voltages_setup_fairchild(di);
392 break;
393 case FAN53555_VENDOR_SILERGY:
394 ret = fan53555_voltages_setup_silergy(di);
395 break;
396 case FAN53555_VENDOR_TCS:
397 ret = fan53555_voltages_setup_tcs(di);
398 break;
399 default:
400 dev_err(di->dev, "vendor %d not supported!\n", di->vendor);
401 return -EINVAL;
402 }
403
404 return ret;
405 }
406
fan53555_regulator_ofdata_to_platdata(struct udevice * dev)407 static int fan53555_regulator_ofdata_to_platdata(struct udevice *dev)
408 {
409 struct fan53555_regulator_info *priv = dev_get_priv(dev);
410 int ret;
411
412 priv->sleep_vsel_id = dev_read_u32_default(dev,
413 "fcs,suspend-voltage-selector",
414 1);
415
416 ret = gpio_request_by_name(dev, "vsel-gpios", 0,
417 &priv->vsel_gpio, GPIOD_IS_OUT);
418 if (ret)
419 dev_err(dev, "vsel-gpios- not found! Error: %d\n", ret);
420
421 if (dm_gpio_is_valid(&priv->vsel_gpio))
422 dm_gpio_set_value(&priv->vsel_gpio, !priv->sleep_vsel_id);
423
424 priv->vendor = dev_get_driver_data(dev);
425
426 return 0;
427 }
428
fan53555_regulator_probe(struct udevice * dev)429 static int fan53555_regulator_probe(struct udevice *dev)
430 {
431 struct fan53555_regulator_info *di = dev_get_priv(dev);
432 struct dm_regulator_uclass_platdata *uc_pdata;
433 u8 val;
434 int ret;
435
436 uc_pdata = dev_get_uclass_platdata(dev);
437 uc_pdata->type = REGULATOR_TYPE_BUCK;
438 uc_pdata->mode_count = 0;
439
440 /* Get chip ID */
441 val = fan53555_reg_read(dev, FAN53555_ID1);
442 if (val < 0) {
443 dev_err(dev, "Failed to get chip ID!\n");
444 return val;
445 }
446 di->chip_id = val & DIE_ID;
447
448 /* Get chip revision */
449 val = fan53555_reg_read(dev, FAN53555_ID2);
450 if (val < 0) {
451 dev_err(dev, "Failed to get chip Rev!\n");
452 return val;
453 }
454 di->chip_rev = val & DIE_REV;
455
456 debug("FAN53555 Option[%d] Rev[%d] Detected!\n",
457 di->chip_id, di->chip_rev);
458
459 /* Device init */
460 ret = fan53555_device_setup(di);
461 if (ret < 0) {
462 dev_err(dev, "Failed to setup device!\n");
463 return ret;
464 }
465
466 return 0;
467 }
468
469 static const struct udevice_id fan53555_id[] = {
470 {
471 .compatible = "fan53555",
472 .data = FAN53555_VENDOR_FAIRCHILD,
473 }, {
474 .compatible = "silergy,syr827",
475 .data = FAN53555_VENDOR_SILERGY,
476 }, {
477 .compatible = "silergy,syr828",
478 .data = FAN53555_VENDOR_SILERGY,
479 }, {
480 .compatible = "tcs,tcs452x", /* tcs4525/4526 */
481 .data = FAN53555_VENDOR_TCS,
482 },
483 { },
484 };
485
486 static const struct dm_regulator_ops fan53555_regulator_ops = {
487 .get_value = fan53555_regulator_get_voltage,
488 .set_value = fan53555_regulator_set_voltage,
489 .set_suspend_value = fan53555_regulator_set_suspend_voltage,
490 .get_suspend_value = fan53555_regulator_get_suspend_voltage,
491 .set_enable = fan53555_regulator_set_enable,
492 .get_enable = fan53555_regulator_get_enable,
493 .set_suspend_enable = fan53555_regulator_set_suspend_enable,
494 .get_suspend_enable = fan53555_regulator_get_suspend_enable,
495 };
496
497 U_BOOT_DRIVER(fan53555_regulator) = {
498 .name = "fan53555_regulator",
499 .id = UCLASS_REGULATOR,
500 .ops = &fan53555_regulator_ops,
501 .probe = fan53555_regulator_probe,
502 .of_match = fan53555_id,
503 .ofdata_to_platdata = fan53555_regulator_ofdata_to_platdata,
504 .priv_auto_alloc_size = sizeof(struct fan53555_regulator_info),
505 };
506
507