1 /*
2  * tps65912.c  --  TI tps65912
3  *
4  * Copyright 2011 Texas Instruments Inc.
5  *
6  * Author: Margarita Olaya Cabrera <magi@slimlogic.co.uk>
7  *
8  *  This program is free software; you can redistribute it and/or modify it
9  *  under  the terms of the GNU General  Public License as published by the
10  *  Free Software Foundation;  either version 2 of the License, or (at your
11  *  option) any later version.
12  *
13  * This driver is based on wm8350 implementation.
14  */
15 
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/init.h>
19 #include <linux/err.h>
20 #include <linux/platform_device.h>
21 #include <linux/regulator/driver.h>
22 #include <linux/regulator/machine.h>
23 #include <linux/delay.h>
24 #include <linux/slab.h>
25 #include <linux/gpio.h>
26 #include <linux/mfd/tps65912.h>
27 
28 /* DCDC's */
29 #define TPS65912_REG_DCDC1	0
30 #define TPS65912_REG_DCDC2	1
31 #define TPS65912_REG_DCDC3	2
32 #define TPS65912_REG_DCDC4	3
33 
34 /* LDOs */
35 #define TPS65912_REG_LDO1	4
36 #define TPS65912_REG_LDO2	5
37 #define TPS65912_REG_LDO3	6
38 #define TPS65912_REG_LDO4	7
39 #define TPS65912_REG_LDO5	8
40 #define TPS65912_REG_LDO6	9
41 #define TPS65912_REG_LDO7	10
42 #define TPS65912_REG_LDO8	11
43 #define TPS65912_REG_LDO9	12
44 #define TPS65912_REG_LDO10	13
45 
46 /* Number of step-down converters available */
47 #define TPS65912_NUM_DCDC	4
48 
49 /* Number of LDO voltage regulators  available */
50 #define TPS65912_NUM_LDO	10
51 
52 /* Number of total regulators available */
53 #define TPS65912_NUM_REGULATOR		(TPS65912_NUM_DCDC + TPS65912_NUM_LDO)
54 
55 #define TPS65912_REG_ENABLED	0x80
56 #define OP_SELREG_MASK		0x40
57 #define OP_SELREG_SHIFT		6
58 
59 struct tps_info {
60 	const char *name;
61 };
62 
63 static struct tps_info tps65912_regs[] = {
64 	{
65 		.name = "DCDC1",
66 	},
67 	{
68 		.name = "DCDC2",
69 	},
70 	{
71 		.name = "DCDC3",
72 	},
73 	{
74 		.name = "DCDC4",
75 	},
76 	{
77 		.name = "LDO1",
78 	},
79 	{
80 		.name = "LDO2",
81 	},
82 	{
83 		.name = "LDO3",
84 	},
85 	{
86 		.name = "LDO4",
87 	},
88 	{
89 		.name = "LDO5",
90 	},
91 	{
92 		.name = "LDO6",
93 	},
94 	{
95 		.name = "LDO7",
96 	},
97 	{
98 		.name = "LDO8",
99 	},
100 	{
101 		.name = "LDO9",
102 	},
103 	{
104 		.name = "LDO10",
105 	},
106 };
107 
108 struct tps65912_reg {
109 	struct regulator_desc desc[TPS65912_NUM_REGULATOR];
110 	struct tps65912 *mfd;
111 	struct regulator_dev *rdev[TPS65912_NUM_REGULATOR];
112 	struct tps_info *info[TPS65912_NUM_REGULATOR];
113 	/* for read/write access */
114 	struct mutex io_lock;
115 	int mode;
116 	int (*get_ctrl_reg)(int);
117 	int dcdc_range[TPS65912_NUM_DCDC];
118 	int pwm_mode_reg;
119 	int eco_reg;
120 };
121 
122 static int tps65912_get_range(struct tps65912_reg *pmic, int id)
123 {
124 	struct tps65912 *mfd = pmic->mfd;
125 	int range;
126 
127 	switch (id) {
128 	case TPS65912_REG_DCDC1:
129 		range = tps65912_reg_read(mfd, TPS65912_DCDC1_LIMIT);
130 		break;
131 	case TPS65912_REG_DCDC2:
132 		range = tps65912_reg_read(mfd, TPS65912_DCDC2_LIMIT);
133 		break;
134 	case TPS65912_REG_DCDC3:
135 		range = tps65912_reg_read(mfd, TPS65912_DCDC3_LIMIT);
136 		break;
137 	case TPS65912_REG_DCDC4:
138 		range = tps65912_reg_read(mfd, TPS65912_DCDC4_LIMIT);
139 		break;
140 	default:
141 		return 0;
142 	}
143 
144 	if (range >= 0)
145 		range = (range & DCDC_LIMIT_RANGE_MASK)
146 			>> DCDC_LIMIT_RANGE_SHIFT;
147 
148 	pmic->dcdc_range[id] = range;
149 	return range;
150 }
151 
152 static unsigned long tps65912_vsel_to_uv_range0(u8 vsel)
153 {
154 	unsigned long uv;
155 
156 	uv = ((vsel * 12500) + 500000);
157 	return uv;
158 }
159 
160 static unsigned long tps65912_vsel_to_uv_range1(u8 vsel)
161 {
162 	unsigned long uv;
163 
164 	 uv = ((vsel * 12500) + 700000);
165 	return uv;
166 }
167 
168 static unsigned long tps65912_vsel_to_uv_range2(u8 vsel)
169 {
170 	unsigned long uv;
171 
172 	uv = ((vsel * 25000) + 500000);
173 	return uv;
174 }
175 
176 static unsigned long tps65912_vsel_to_uv_range3(u8 vsel)
177 {
178 	unsigned long uv;
179 
180 	if (vsel == 0x3f)
181 		uv = 3800000;
182 	else
183 		uv = ((vsel * 50000) + 500000);
184 
185 	return uv;
186 }
187 
188 static unsigned long tps65912_vsel_to_uv_ldo(u8 vsel)
189 {
190 	unsigned long uv = 0;
191 
192 	if (vsel <= 32)
193 		uv = ((vsel * 25000) + 800000);
194 	else if (vsel > 32 && vsel <= 60)
195 		uv = (((vsel - 32) * 50000) + 1600000);
196 	else if (vsel > 60)
197 		uv = (((vsel - 60) * 100000) + 3000000);
198 
199 	return uv;
200 }
201 
202 static int tps65912_get_ctrl_register(int id)
203 {
204 	if (id >= TPS65912_REG_DCDC1 && id <= TPS65912_REG_LDO4)
205 		return id * 3 + TPS65912_DCDC1_AVS;
206 	else if (id >= TPS65912_REG_LDO5 && id <= TPS65912_REG_LDO10)
207 		return id - TPS65912_REG_LDO5 + TPS65912_LDO5;
208 	else
209 		return -EINVAL;
210 }
211 
212 static int tps65912_get_sel_register(struct tps65912_reg *pmic, int id)
213 {
214 	struct tps65912 *mfd = pmic->mfd;
215 	int opvsel;
216 	u8 reg = 0;
217 
218 	if (id >= TPS65912_REG_DCDC1 && id <= TPS65912_REG_LDO4) {
219 		opvsel = tps65912_reg_read(mfd, id * 3 + TPS65912_DCDC1_OP);
220 		if (opvsel & OP_SELREG_MASK)
221 			reg = id * 3 + TPS65912_DCDC1_AVS;
222 		else
223 			reg = id * 3 + TPS65912_DCDC1_OP;
224 	} else if (id >= TPS65912_REG_LDO5 && id <= TPS65912_REG_LDO10) {
225 		reg = id - TPS65912_REG_LDO5 + TPS65912_LDO5;
226 	} else {
227 		return -EINVAL;
228 	}
229 
230 	return reg;
231 }
232 
233 static int tps65912_get_mode_regiters(struct tps65912_reg *pmic, int id)
234 {
235 	switch (id) {
236 	case TPS65912_REG_DCDC1:
237 		pmic->pwm_mode_reg = TPS65912_DCDC1_CTRL;
238 		pmic->eco_reg = TPS65912_DCDC1_AVS;
239 		break;
240 	case TPS65912_REG_DCDC2:
241 		pmic->pwm_mode_reg = TPS65912_DCDC2_CTRL;
242 		pmic->eco_reg = TPS65912_DCDC2_AVS;
243 		break;
244 	case TPS65912_REG_DCDC3:
245 		pmic->pwm_mode_reg = TPS65912_DCDC3_CTRL;
246 		pmic->eco_reg = TPS65912_DCDC3_AVS;
247 		break;
248 	case TPS65912_REG_DCDC4:
249 		pmic->pwm_mode_reg = TPS65912_DCDC4_CTRL;
250 		pmic->eco_reg = TPS65912_DCDC4_AVS;
251 		break;
252 	default:
253 		return -EINVAL;
254 	}
255 
256 	return 0;
257 }
258 
259 static int tps65912_reg_is_enabled(struct regulator_dev *dev)
260 {
261 	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
262 	struct tps65912 *mfd = pmic->mfd;
263 	int reg, value, id = rdev_get_id(dev);
264 
265 	if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_LDO10)
266 		return -EINVAL;
267 
268 	reg = pmic->get_ctrl_reg(id);
269 	if (reg < 0)
270 		return reg;
271 
272 	value = tps65912_reg_read(mfd, reg);
273 	if (value < 0)
274 		return value;
275 
276 	return value & TPS65912_REG_ENABLED;
277 }
278 
279 static int tps65912_reg_enable(struct regulator_dev *dev)
280 {
281 	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
282 	struct tps65912 *mfd = pmic->mfd;
283 	int id = rdev_get_id(dev);
284 	int reg;
285 
286 	if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_LDO10)
287 		return -EINVAL;
288 
289 	reg = pmic->get_ctrl_reg(id);
290 	if (reg < 0)
291 		return reg;
292 
293 	return tps65912_set_bits(mfd, reg, TPS65912_REG_ENABLED);
294 }
295 
296 static int tps65912_reg_disable(struct regulator_dev *dev)
297 {
298 	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
299 	struct tps65912 *mfd = pmic->mfd;
300 	int id = rdev_get_id(dev), reg;
301 
302 	reg = pmic->get_ctrl_reg(id);
303 	if (reg < 0)
304 		return reg;
305 
306 	return tps65912_clear_bits(mfd, reg, TPS65912_REG_ENABLED);
307 }
308 
309 static int tps65912_set_mode(struct regulator_dev *dev, unsigned int mode)
310 {
311 	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
312 	struct tps65912 *mfd = pmic->mfd;
313 	int pwm_mode, eco, id = rdev_get_id(dev);
314 
315 	tps65912_get_mode_regiters(pmic, id);
316 
317 	pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg);
318 	eco = tps65912_reg_read(mfd, pmic->eco_reg);
319 
320 	pwm_mode &= DCDCCTRL_DCDC_MODE_MASK;
321 	eco &= DCDC_AVS_ECO_MASK;
322 
323 	switch (mode) {
324 	case REGULATOR_MODE_FAST:
325 		/* Verify if mode alredy set */
326 		if (pwm_mode && !eco)
327 			break;
328 		tps65912_set_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
329 		tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
330 		break;
331 	case REGULATOR_MODE_NORMAL:
332 	case REGULATOR_MODE_IDLE:
333 		if (!pwm_mode && !eco)
334 			break;
335 		tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
336 		tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
337 		break;
338 	case REGULATOR_MODE_STANDBY:
339 		if (!pwm_mode && eco)
340 			break;
341 		tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
342 		tps65912_set_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
343 		break;
344 	default:
345 		return -EINVAL;
346 	}
347 
348 	return 0;
349 }
350 
351 static unsigned int tps65912_get_mode(struct regulator_dev *dev)
352 {
353 	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
354 	struct tps65912 *mfd = pmic->mfd;
355 	int pwm_mode, eco, mode = 0, id = rdev_get_id(dev);
356 
357 	tps65912_get_mode_regiters(pmic, id);
358 
359 	pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg);
360 	eco = tps65912_reg_read(mfd, pmic->eco_reg);
361 
362 	pwm_mode &= DCDCCTRL_DCDC_MODE_MASK;
363 	eco &= DCDC_AVS_ECO_MASK;
364 
365 	if (pwm_mode && !eco)
366 		mode = REGULATOR_MODE_FAST;
367 	else if (!pwm_mode && !eco)
368 		mode = REGULATOR_MODE_NORMAL;
369 	else if (!pwm_mode && eco)
370 		mode = REGULATOR_MODE_STANDBY;
371 
372 	return mode;
373 }
374 
375 static int tps65912_list_voltage_dcdc(struct regulator_dev *dev,
376 					unsigned selector)
377 {
378 	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
379 	int range, voltage = 0, id = rdev_get_id(dev);
380 
381 	if (id > TPS65912_REG_DCDC4)
382 		return -EINVAL;
383 
384 	range = pmic->dcdc_range[id];
385 
386 	switch (range) {
387 	case 0:
388 		/* 0.5 - 1.2875V in 12.5mV steps */
389 		voltage = tps65912_vsel_to_uv_range0(selector);
390 		break;
391 	case 1:
392 		/* 0.7 - 1.4875V in 12.5mV steps */
393 		voltage = tps65912_vsel_to_uv_range1(selector);
394 		break;
395 	case 2:
396 		/* 0.5 - 2.075V in 25mV steps */
397 		voltage = tps65912_vsel_to_uv_range2(selector);
398 		break;
399 	case 3:
400 		/* 0.5 - 3.8V in 50mV steps */
401 		voltage = tps65912_vsel_to_uv_range3(selector);
402 		break;
403 	}
404 	return voltage;
405 }
406 
407 static int tps65912_get_voltage_dcdc(struct regulator_dev *dev)
408 {
409 	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
410 	struct tps65912 *mfd = pmic->mfd;
411 	int id = rdev_get_id(dev);
412 	int reg, vsel;
413 
414 	reg = tps65912_get_sel_register(pmic, id);
415 	if (reg < 0)
416 		return reg;
417 
418 	vsel = tps65912_reg_read(mfd, reg);
419 	vsel &= 0x3F;
420 
421 	return tps65912_list_voltage_dcdc(dev, vsel);
422 }
423 
424 static int tps65912_set_voltage_sel(struct regulator_dev *dev,
425 					 unsigned selector)
426 {
427 	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
428 	struct tps65912 *mfd = pmic->mfd;
429 	int id = rdev_get_id(dev);
430 	int value;
431 	u8 reg;
432 
433 	reg = tps65912_get_sel_register(pmic, id);
434 	value = tps65912_reg_read(mfd, reg);
435 	value &= 0xC0;
436 	return tps65912_reg_write(mfd, reg, selector | value);
437 }
438 
439 static int tps65912_get_voltage_ldo(struct regulator_dev *dev)
440 {
441 	struct tps65912_reg *pmic = rdev_get_drvdata(dev);
442 	struct tps65912 *mfd = pmic->mfd;
443 	int id = rdev_get_id(dev);
444 	int vsel = 0;
445 	u8 reg;
446 
447 	reg = tps65912_get_sel_register(pmic, id);
448 	vsel = tps65912_reg_read(mfd, reg);
449 	vsel &= 0x3F;
450 
451 	return tps65912_vsel_to_uv_ldo(vsel);
452 }
453 
454 static int tps65912_list_voltage_ldo(struct regulator_dev *dev,
455 					unsigned selector)
456 {
457 	int ldo = rdev_get_id(dev);
458 
459 	if (ldo < TPS65912_REG_LDO1 || ldo > TPS65912_REG_LDO10)
460 		return -EINVAL;
461 
462 	return tps65912_vsel_to_uv_ldo(selector);
463 }
464 
465 /* Operations permitted on DCDCx */
466 static struct regulator_ops tps65912_ops_dcdc = {
467 	.is_enabled = tps65912_reg_is_enabled,
468 	.enable = tps65912_reg_enable,
469 	.disable = tps65912_reg_disable,
470 	.set_mode = tps65912_set_mode,
471 	.get_mode = tps65912_get_mode,
472 	.get_voltage = tps65912_get_voltage_dcdc,
473 	.set_voltage_sel = tps65912_set_voltage_sel,
474 	.list_voltage = tps65912_list_voltage_dcdc,
475 };
476 
477 /* Operations permitted on LDOx */
478 static struct regulator_ops tps65912_ops_ldo = {
479 	.is_enabled = tps65912_reg_is_enabled,
480 	.enable = tps65912_reg_enable,
481 	.disable = tps65912_reg_disable,
482 	.get_voltage = tps65912_get_voltage_ldo,
483 	.set_voltage_sel = tps65912_set_voltage_sel,
484 	.list_voltage = tps65912_list_voltage_ldo,
485 };
486 
487 static __devinit int tps65912_probe(struct platform_device *pdev)
488 {
489 	struct tps65912 *tps65912 = dev_get_drvdata(pdev->dev.parent);
490 	struct tps_info *info;
491 	struct regulator_init_data *reg_data;
492 	struct regulator_dev *rdev;
493 	struct tps65912_reg *pmic;
494 	struct tps65912_board *pmic_plat_data;
495 	int i, err;
496 
497 	pmic_plat_data = dev_get_platdata(tps65912->dev);
498 	if (!pmic_plat_data)
499 		return -EINVAL;
500 
501 	reg_data = pmic_plat_data->tps65912_pmic_init_data;
502 
503 	pmic = kzalloc(sizeof(*pmic), GFP_KERNEL);
504 	if (!pmic)
505 		return -ENOMEM;
506 
507 	mutex_init(&pmic->io_lock);
508 	pmic->mfd = tps65912;
509 	platform_set_drvdata(pdev, pmic);
510 
511 	pmic->get_ctrl_reg = &tps65912_get_ctrl_register;
512 	info = tps65912_regs;
513 
514 	for (i = 0; i < TPS65912_NUM_REGULATOR; i++, info++, reg_data++) {
515 		int range = 0;
516 		/* Register the regulators */
517 		pmic->info[i] = info;
518 
519 		pmic->desc[i].name = info->name;
520 		pmic->desc[i].id = i;
521 		pmic->desc[i].n_voltages = 64;
522 		pmic->desc[i].ops = (i > TPS65912_REG_DCDC4 ?
523 			&tps65912_ops_ldo : &tps65912_ops_dcdc);
524 		pmic->desc[i].type = REGULATOR_VOLTAGE;
525 		pmic->desc[i].owner = THIS_MODULE;
526 		range = tps65912_get_range(pmic, i);
527 		rdev = regulator_register(&pmic->desc[i],
528 					tps65912->dev, reg_data, pmic, NULL);
529 		if (IS_ERR(rdev)) {
530 			dev_err(tps65912->dev,
531 				"failed to register %s regulator\n",
532 				pdev->name);
533 			err = PTR_ERR(rdev);
534 			goto err;
535 		}
536 
537 		/* Save regulator for cleanup */
538 		pmic->rdev[i] = rdev;
539 	}
540 	return 0;
541 
542 err:
543 	while (--i >= 0)
544 		regulator_unregister(pmic->rdev[i]);
545 
546 	kfree(pmic);
547 	return err;
548 }
549 
550 static int __devexit tps65912_remove(struct platform_device *pdev)
551 {
552 	struct tps65912_reg *tps65912_reg = platform_get_drvdata(pdev);
553 	int i;
554 
555 	for (i = 0; i < TPS65912_NUM_REGULATOR; i++)
556 		regulator_unregister(tps65912_reg->rdev[i]);
557 
558 	kfree(tps65912_reg);
559 	return 0;
560 }
561 
562 static struct platform_driver tps65912_driver = {
563 	.driver = {
564 		.name = "tps65912-pmic",
565 		.owner = THIS_MODULE,
566 	},
567 	.probe = tps65912_probe,
568 	.remove = __devexit_p(tps65912_remove),
569 };
570 
571 static int __init tps65912_init(void)
572 {
573 	return platform_driver_register(&tps65912_driver);
574 }
575 subsys_initcall(tps65912_init);
576 
577 static void __exit tps65912_cleanup(void)
578 {
579 	platform_driver_unregister(&tps65912_driver);
580 }
581 module_exit(tps65912_cleanup);
582 
583 MODULE_AUTHOR("Margarita Olaya Cabrera <magi@slimlogic.co.uk>");
584 MODULE_DESCRIPTION("TPS65912 voltage regulator driver");
585 MODULE_LICENSE("GPL v2");
586 MODULE_ALIAS("platform:tps65912-pmic");
587