1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  Copyright (C) 2018 Samsung Electronics
4  *  Jaehoon Chung <jh80.chung@samsung.com>
5  */
6 
7 #include <common.h>
8 #include <fdtdec.h>
9 #include <errno.h>
10 #include <dm.h>
11 #include <i2c.h>
12 #include <power/pmic.h>
13 #include <power/regulator.h>
14 #include <power/s2mps11.h>
15 
16 #define MODE(_id, _val, _name) { \
17 	.id = _id, \
18 	.register_value = _val, \
19 	.name = _name, \
20 }
21 
22 /* BUCK : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 */
23 static struct dm_regulator_mode s2mps11_buck_modes[] = {
24 	MODE(OP_OFF, S2MPS11_BUCK_MODE_OFF, "OFF"),
25 	MODE(OP_STANDBY, S2MPS11_BUCK_MODE_STANDBY, "ON/OFF"),
26 	MODE(OP_ON, S2MPS11_BUCK_MODE_STANDBY, "ON"),
27 };
28 
29 static struct dm_regulator_mode s2mps11_ldo_modes[] = {
30 	MODE(OP_OFF, S2MPS11_LDO_MODE_OFF, "OFF"),
31 	MODE(OP_STANDBY, S2MPS11_LDO_MODE_STANDBY, "ON/OFF"),
32 	MODE(OP_STANDBY_LPM, S2MPS11_LDO_MODE_STANDBY_LPM, "ON/LPM"),
33 	MODE(OP_ON, S2MPS11_LDO_MODE_ON, "ON"),
34 };
35 
36 static const char s2mps11_buck_ctrl[] = {
37 	0xff, 0x25, 0x27, 0x29, 0x2b, 0x2d, 0x33, 0x35, 0x37, 0x39, 0x3b
38 };
39 
40 static const char s2mps11_buck_out[] = {
41 	0xff, 0x26, 0x28, 0x2a, 0x2c, 0x2f, 0x34, 0x36, 0x38, 0x3a, 0x3c
42 };
43 
s2mps11_buck_hex2volt(int buck,int hex)44 static int s2mps11_buck_hex2volt(int buck, int hex)
45 {
46 	unsigned int uV = 0;
47 
48 	if (hex < 0)
49 		goto bad;
50 
51 	switch (buck) {
52 	case 7:
53 	case 8:
54 	case 10:
55 		if (hex > S2MPS11_BUCK7_8_10_VOLT_MAX_HEX)
56 			goto bad;
57 
58 		uV = hex * S2MPS11_BUCK_HSTEP + S2MPS11_BUCK_UV_HMIN;
59 		break;
60 	case 9:
61 		if (hex > S2MPS11_BUCK9_VOLT_MAX_HEX)
62 			goto bad;
63 		uV = hex * S2MPS11_BUCK9_STEP * 2 + S2MPS11_BUCK9_UV_MIN;
64 		break;
65 	default:
66 		if (buck == 5 && hex > S2MPS11_BUCK5_VOLT_MAX_HEX)
67 			goto bad;
68 		else if (buck != 5 && hex > S2MPS11_BUCK_VOLT_MAX_HEX)
69 			goto bad;
70 
71 		uV = hex * S2MPS11_BUCK_LSTEP + S2MPS11_BUCK_UV_MIN;
72 		break;
73 	}
74 
75 	return uV;
76 bad:
77 	pr_err("Value: %#x is wrong for BUCK%d", hex, buck);
78 	return -EINVAL;
79 }
80 
s2mps11_buck_volt2hex(int buck,int uV)81 static int s2mps11_buck_volt2hex(int buck, int uV)
82 {
83 	int hex;
84 
85 	switch (buck) {
86 	case 7:
87 	case 8:
88 	case 10:
89 		hex = (uV - S2MPS11_BUCK_UV_HMIN) / S2MPS11_BUCK_HSTEP;
90 		if (hex > S2MPS11_BUCK7_8_10_VOLT_MAX_HEX)
91 			goto bad;
92 
93 		break;
94 	case 9:
95 		hex = (uV - S2MPS11_BUCK9_UV_MIN) / S2MPS11_BUCK9_STEP;
96 		if (hex > S2MPS11_BUCK9_VOLT_MAX_HEX)
97 			goto bad;
98 		break;
99 	default:
100 		hex = (uV - S2MPS11_BUCK_UV_MIN) / S2MPS11_BUCK_LSTEP;
101 		if (buck == 5 && hex > S2MPS11_BUCK5_VOLT_MAX_HEX)
102 			goto bad;
103 		else if (buck != 5 && hex > S2MPS11_BUCK_VOLT_MAX_HEX)
104 			goto bad;
105 		break;
106 	};
107 
108 	if (hex >= 0)
109 		return hex;
110 
111 bad:
112 	pr_err("Value: %d uV is wrong for BUCK%d", uV, buck);
113 	return -EINVAL;
114 }
115 
s2mps11_buck_val(struct udevice * dev,int op,int * uV)116 static int s2mps11_buck_val(struct udevice *dev, int op, int *uV)
117 {
118 	int hex, buck, ret;
119 	u32 mask, addr;
120 	u8 val;
121 
122 	buck = dev->driver_data;
123 	if (buck < 1 || buck > S2MPS11_BUCK_NUM) {
124 		pr_err("Wrong buck number: %d\n", buck);
125 		return -EINVAL;
126 	}
127 
128 	if (op == PMIC_OP_GET)
129 		*uV = 0;
130 
131 	addr = s2mps11_buck_out[buck];
132 
133 	switch (buck) {
134 	case 9:
135 		mask = S2MPS11_BUCK9_VOLT_MASK;
136 		break;
137 	default:
138 		mask = S2MPS11_BUCK_VOLT_MASK;
139 		break;
140 	}
141 
142 	ret = pmic_read(dev->parent, addr, &val, 1);
143 	if (ret)
144 		return ret;
145 
146 	if (op == PMIC_OP_GET) {
147 		val &= mask;
148 		ret = s2mps11_buck_hex2volt(buck, val);
149 		if (ret < 0)
150 			return ret;
151 		*uV = ret;
152 		return 0;
153 	}
154 
155 	hex = s2mps11_buck_volt2hex(buck, *uV);
156 	if (hex < 0)
157 		return hex;
158 
159 	val &= ~mask;
160 	val |= hex;
161 	ret = pmic_write(dev->parent, addr, &val, 1);
162 
163 	return ret;
164 }
165 
s2mps11_buck_mode(struct udevice * dev,int op,int * opmode)166 static int s2mps11_buck_mode(struct udevice *dev, int op, int *opmode)
167 {
168 	unsigned int addr, mode;
169 	unsigned char val;
170 	int buck, ret;
171 
172 	buck = dev->driver_data;
173 	if (buck < 1 || buck > S2MPS11_BUCK_NUM) {
174 		pr_err("Wrong buck number: %d\n", buck);
175 		return -EINVAL;
176 	}
177 
178 	addr = s2mps11_buck_ctrl[buck];
179 
180 	ret = pmic_read(dev->parent, addr, &val, 1);
181 	if (ret)
182 		return ret;
183 
184 	if (op == PMIC_OP_GET) {
185 		val &= (S2MPS11_BUCK_MODE_MASK << S2MPS11_BUCK_MODE_SHIFT);
186 		switch (val) {
187 		case S2MPS11_BUCK_MODE_OFF:
188 			*opmode = OP_OFF;
189 			break;
190 		case S2MPS11_BUCK_MODE_STANDBY:
191 			*opmode = OP_STANDBY;
192 			break;
193 		case S2MPS11_BUCK_MODE_ON:
194 			*opmode = OP_ON;
195 			break;
196 		default:
197 			return -EINVAL;
198 		}
199 		return 0;
200 	}
201 
202 	switch (*opmode) {
203 	case OP_OFF:
204 		mode = S2MPS11_BUCK_MODE_OFF;
205 		break;
206 	case OP_STANDBY:
207 		mode = S2MPS11_BUCK_MODE_STANDBY;
208 		break;
209 	case OP_ON:
210 		mode = S2MPS11_BUCK_MODE_ON;
211 		break;
212 	default:
213 		pr_err("Wrong mode: %d for buck: %d\n", *opmode, buck);
214 		return -EINVAL;
215 	}
216 
217 	val &= ~(S2MPS11_BUCK_MODE_MASK << S2MPS11_BUCK_MODE_SHIFT);
218 	val |= mode;
219 	ret = pmic_write(dev->parent, addr, &val, 1);
220 
221 	return ret;
222 }
223 
s2mps11_buck_enable(struct udevice * dev,int op,bool * enable)224 static int s2mps11_buck_enable(struct udevice *dev, int op, bool *enable)
225 {
226 	int ret, on_off;
227 
228 	if (op == PMIC_OP_GET) {
229 		ret = s2mps11_buck_mode(dev, op, &on_off);
230 		if (ret)
231 			return ret;
232 		switch (on_off) {
233 		case OP_OFF:
234 			*enable = false;
235 			break;
236 		case OP_ON:
237 			*enable = true;
238 			break;
239 		default:
240 			return -EINVAL;
241 		}
242 	} else if (op == PMIC_OP_SET) {
243 		if (*enable)
244 			on_off = OP_ON;
245 		else
246 			on_off = OP_OFF;
247 
248 		ret = s2mps11_buck_mode(dev, op, &on_off);
249 		if (ret)
250 			return ret;
251 	}
252 
253 	return 0;
254 }
255 
buck_get_value(struct udevice * dev)256 static int buck_get_value(struct udevice *dev)
257 {
258 	int uV;
259 	int ret;
260 
261 	ret = s2mps11_buck_val(dev, PMIC_OP_GET, &uV);
262 	if (ret)
263 		return ret;
264 	return uV;
265 }
266 
buck_set_value(struct udevice * dev,int uV)267 static int buck_set_value(struct udevice *dev, int uV)
268 {
269 	return s2mps11_buck_val(dev, PMIC_OP_SET, &uV);
270 }
271 
buck_get_enable(struct udevice * dev)272 static int buck_get_enable(struct udevice *dev)
273 {
274 	bool enable = false;
275 	int ret;
276 
277 	ret = s2mps11_buck_enable(dev, PMIC_OP_GET, &enable);
278 	if (ret)
279 		return ret;
280 	return enable;
281 }
282 
buck_set_enable(struct udevice * dev,bool enable)283 static int buck_set_enable(struct udevice *dev, bool enable)
284 {
285 	return s2mps11_buck_enable(dev, PMIC_OP_SET, &enable);
286 }
287 
buck_get_mode(struct udevice * dev)288 static int buck_get_mode(struct udevice *dev)
289 {
290 	int mode;
291 	int ret;
292 
293 	ret = s2mps11_buck_mode(dev, PMIC_OP_GET, &mode);
294 	if (ret)
295 		return ret;
296 
297 	return mode;
298 }
299 
buck_set_mode(struct udevice * dev,int mode)300 static int buck_set_mode(struct udevice *dev, int mode)
301 {
302 	return s2mps11_buck_mode(dev, PMIC_OP_SET, &mode);
303 }
304 
s2mps11_buck_probe(struct udevice * dev)305 static int s2mps11_buck_probe(struct udevice *dev)
306 {
307 	struct dm_regulator_uclass_platdata *uc_pdata;
308 
309 	uc_pdata = dev_get_uclass_platdata(dev);
310 
311 	uc_pdata->type = REGULATOR_TYPE_BUCK;
312 	uc_pdata->mode = s2mps11_buck_modes;
313 	uc_pdata->mode_count = ARRAY_SIZE(s2mps11_buck_modes);
314 
315 	return 0;
316 }
317 
318 static const struct dm_regulator_ops s2mps11_buck_ops = {
319 	.get_value	= buck_get_value,
320 	.set_value	= buck_set_value,
321 	.get_enable	= buck_get_enable,
322 	.set_enable	= buck_set_enable,
323 	.get_mode	= buck_get_mode,
324 	.set_mode	= buck_set_mode,
325 };
326 
327 U_BOOT_DRIVER(s2mps11_buck) = {
328 	.name = S2MPS11_BUCK_DRIVER,
329 	.id = UCLASS_REGULATOR,
330 	.ops = &s2mps11_buck_ops,
331 	.probe = s2mps11_buck_probe,
332 };
333 
s2mps11_ldo_hex2volt(int ldo,int hex)334 static int s2mps11_ldo_hex2volt(int ldo, int hex)
335 {
336 	unsigned int uV = 0;
337 
338 	if (hex > S2MPS11_LDO_VOLT_MAX_HEX) {
339 		pr_err("Value: %#x is wrong for LDO%d", hex, ldo);
340 		return -EINVAL;
341 	}
342 
343 	switch (ldo) {
344 	case 1:
345 	case 6:
346 	case 11:
347 	case 22:
348 	case 23:
349 	case 27:
350 	case 35:
351 		uV = hex * S2MPS11_LDO_STEP + S2MPS11_LDO_UV_MIN;
352 		break;
353 	default:
354 		uV = hex * S2MPS11_LDO_STEP * 2 + S2MPS11_LDO_UV_MIN;
355 		break;
356 	}
357 
358 	return uV;
359 }
360 
s2mps11_ldo_volt2hex(int ldo,int uV)361 static int s2mps11_ldo_volt2hex(int ldo, int uV)
362 {
363 	int hex = 0;
364 
365 	switch (ldo) {
366 	case 1:
367 	case 6:
368 	case 11:
369 	case 22:
370 	case 23:
371 	case 27:
372 	case 35:
373 		hex = (uV - S2MPS11_LDO_UV_MIN) / S2MPS11_LDO_STEP;
374 		break;
375 	default:
376 		hex = (uV - S2MPS11_LDO_UV_MIN) / (S2MPS11_LDO_STEP * 2);
377 		break;
378 	}
379 
380 	if (hex >= 0 && hex <= S2MPS11_LDO_VOLT_MAX_HEX)
381 		return hex;
382 
383 	pr_err("Value: %d uV is wrong for LDO%d", uV, ldo);
384 	return -EINVAL;
385 
386 	return 0;
387 }
388 
s2mps11_ldo_val(struct udevice * dev,int op,int * uV)389 static int s2mps11_ldo_val(struct udevice *dev, int op, int *uV)
390 {
391 	unsigned int addr;
392 	unsigned char val;
393 	int hex, ldo, ret;
394 
395 	ldo = dev->driver_data;
396 	if (ldo < 1 || ldo > S2MPS11_LDO_NUM) {
397 		pr_err("Wrong ldo number: %d\n", ldo);
398 		return -EINVAL;
399 	}
400 
401 	addr = S2MPS11_REG_L1CTRL + ldo - 1;
402 
403 	ret = pmic_read(dev->parent, addr, &val, 1);
404 	if (ret)
405 		return ret;
406 
407 	if (op == PMIC_OP_GET) {
408 		*uV = 0;
409 		val &= S2MPS11_LDO_VOLT_MASK;
410 		ret = s2mps11_ldo_hex2volt(ldo, val);
411 		if (ret < 0)
412 			return ret;
413 
414 		*uV = ret;
415 		return 0;
416 	}
417 
418 	hex = s2mps11_ldo_volt2hex(ldo, *uV);
419 	if (hex < 0)
420 		return hex;
421 
422 	val &= ~S2MPS11_LDO_VOLT_MASK;
423 	val |= hex;
424 	ret = pmic_write(dev->parent, addr, &val, 1);
425 
426 	return ret;
427 }
428 
s2mps11_ldo_mode(struct udevice * dev,int op,int * opmode)429 static int s2mps11_ldo_mode(struct udevice *dev, int op, int *opmode)
430 {
431 	unsigned int addr, mode;
432 	unsigned char val;
433 	int ldo, ret;
434 
435 	ldo = dev->driver_data;
436 	if (ldo < 1 || ldo > S2MPS11_LDO_NUM) {
437 		pr_err("Wrong ldo number: %d\n", ldo);
438 		return -EINVAL;
439 	}
440 	addr = S2MPS11_REG_L1CTRL + ldo - 1;
441 
442 	ret = pmic_read(dev->parent, addr, &val, 1);
443 	if (ret)
444 		return ret;
445 
446 	if (op == PMIC_OP_GET) {
447 		val &= (S2MPS11_LDO_MODE_MASK << S2MPS11_LDO_MODE_SHIFT);
448 		switch (val) {
449 		case S2MPS11_LDO_MODE_OFF:
450 			*opmode = OP_OFF;
451 			break;
452 		case S2MPS11_LDO_MODE_STANDBY:
453 			*opmode = OP_STANDBY;
454 			break;
455 		case S2MPS11_LDO_MODE_STANDBY_LPM:
456 			*opmode = OP_STANDBY_LPM;
457 			break;
458 		case S2MPS11_LDO_MODE_ON:
459 			*opmode = OP_ON;
460 			break;
461 		default:
462 			return -EINVAL;
463 		}
464 		return 0;
465 	}
466 
467 	switch (*opmode) {
468 	case OP_OFF:
469 		mode = S2MPS11_LDO_MODE_OFF;
470 		break;
471 	case OP_STANDBY:
472 		mode = S2MPS11_LDO_MODE_STANDBY;
473 		break;
474 	case OP_STANDBY_LPM:
475 		mode = S2MPS11_LDO_MODE_STANDBY_LPM;
476 		break;
477 	case OP_ON:
478 		mode = S2MPS11_LDO_MODE_ON;
479 		break;
480 	default:
481 		pr_err("Wrong mode: %d for ldo: %d\n", *opmode, ldo);
482 		return -EINVAL;
483 	}
484 
485 	val &= ~(S2MPS11_LDO_MODE_MASK << S2MPS11_LDO_MODE_SHIFT);
486 	val |= mode;
487 	ret = pmic_write(dev->parent, addr, &val, 1);
488 
489 	return ret;
490 }
491 
s2mps11_ldo_enable(struct udevice * dev,int op,bool * enable)492 static int s2mps11_ldo_enable(struct udevice *dev, int op, bool *enable)
493 {
494 	int ret, on_off;
495 
496 	if (op == PMIC_OP_GET) {
497 		ret = s2mps11_ldo_mode(dev, op, &on_off);
498 		if (ret)
499 			return ret;
500 		switch (on_off) {
501 		case OP_OFF:
502 			*enable = false;
503 			break;
504 		case OP_ON:
505 			*enable = true;
506 			break;
507 		default:
508 			return -EINVAL;
509 		}
510 	} else if (op == PMIC_OP_SET) {
511 		if (*enable)
512 			on_off = OP_ON;
513 		else
514 			on_off = OP_OFF;
515 
516 		ret = s2mps11_ldo_mode(dev, op, &on_off);
517 		if (ret)
518 			return ret;
519 	}
520 
521 	return 0;
522 }
523 
ldo_get_value(struct udevice * dev)524 static int ldo_get_value(struct udevice *dev)
525 {
526 	int uV;
527 	int ret;
528 
529 	ret = s2mps11_ldo_val(dev, PMIC_OP_GET, &uV);
530 	if (ret)
531 		return ret;
532 
533 	return uV;
534 }
535 
ldo_set_value(struct udevice * dev,int uV)536 static int ldo_set_value(struct udevice *dev, int uV)
537 {
538 	return s2mps11_ldo_val(dev, PMIC_OP_SET, &uV);
539 }
540 
ldo_get_enable(struct udevice * dev)541 static int ldo_get_enable(struct udevice *dev)
542 {
543 	bool enable = false;
544 	int ret;
545 
546 	ret = s2mps11_ldo_enable(dev, PMIC_OP_GET, &enable);
547 	if (ret)
548 		return ret;
549 	return enable;
550 }
551 
ldo_set_enable(struct udevice * dev,bool enable)552 static int ldo_set_enable(struct udevice *dev, bool enable)
553 {
554 	int ret;
555 
556 	ret = s2mps11_ldo_enable(dev, PMIC_OP_SET, &enable);
557 	if (ret)
558 		return ret;
559 
560 	/* Wait the "enable delay" for voltage to start to rise */
561 	udelay(15);
562 
563 	return 0;
564 }
565 
ldo_get_mode(struct udevice * dev)566 static int ldo_get_mode(struct udevice *dev)
567 {
568 	int mode, ret;
569 
570 	ret = s2mps11_ldo_mode(dev, PMIC_OP_GET, &mode);
571 	if (ret)
572 		return ret;
573 	return mode;
574 }
575 
ldo_set_mode(struct udevice * dev,int mode)576 static int ldo_set_mode(struct udevice *dev, int mode)
577 {
578 	return s2mps11_ldo_mode(dev, PMIC_OP_SET, &mode);
579 }
580 
s2mps11_ldo_probe(struct udevice * dev)581 static int s2mps11_ldo_probe(struct udevice *dev)
582 {
583 	struct dm_regulator_uclass_platdata *uc_pdata;
584 
585 	uc_pdata = dev_get_uclass_platdata(dev);
586 	uc_pdata->type = REGULATOR_TYPE_LDO;
587 	uc_pdata->mode = s2mps11_ldo_modes;
588 	uc_pdata->mode_count = ARRAY_SIZE(s2mps11_ldo_modes);
589 
590 	return 0;
591 }
592 
593 static const struct dm_regulator_ops s2mps11_ldo_ops = {
594 	.get_value	= ldo_get_value,
595 	.set_value	= ldo_set_value,
596 	.get_enable	= ldo_get_enable,
597 	.set_enable	= ldo_set_enable,
598 	.get_mode	= ldo_get_mode,
599 	.set_mode	= ldo_set_mode,
600 };
601 
602 U_BOOT_DRIVER(s2mps11_ldo) = {
603 	.name = S2MPS11_LDO_DRIVER,
604 	.id = UCLASS_REGULATOR,
605 	.ops = &s2mps11_ldo_ops,
606 	.probe = s2mps11_ldo_probe,
607 };
608