1 /*
2  * Regulator driver for TI TPS6586x
3  *
4  * Copyright (C) 2010 Compulab Ltd.
5  * Author: Mike Rapoport <mike@compulab.co.il>
6  *
7  * Based on da903x
8  * Copyright (C) 2006-2008 Marvell International Ltd.
9  * Copyright (C) 2008 Compulab Ltd.
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License version 2 as
13  * published by the Free Software Foundation.
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/of.h>
21 #include <linux/slab.h>
22 #include <linux/platform_device.h>
23 #include <linux/regulator/driver.h>
24 #include <linux/regulator/machine.h>
25 #include <linux/regulator/of_regulator.h>
26 #include <linux/mfd/tps6586x.h>
27 
28 /* supply control and voltage setting  */
29 #define TPS6586X_SUPPLYENA	0x10
30 #define TPS6586X_SUPPLYENB	0x11
31 #define TPS6586X_SUPPLYENC	0x12
32 #define TPS6586X_SUPPLYEND	0x13
33 #define TPS6586X_SUPPLYENE	0x14
34 #define TPS6586X_VCC1		0x20
35 #define TPS6586X_VCC2		0x21
36 #define TPS6586X_SM1V1		0x23
37 #define TPS6586X_SM1V2		0x24
38 #define TPS6586X_SM1SL		0x25
39 #define TPS6586X_SM0V1		0x26
40 #define TPS6586X_SM0V2		0x27
41 #define TPS6586X_SM0SL		0x28
42 #define TPS6586X_LDO2AV1	0x29
43 #define TPS6586X_LDO2AV2	0x2A
44 #define TPS6586X_LDO2BV1	0x2F
45 #define TPS6586X_LDO2BV2	0x30
46 #define TPS6586X_LDO4V1		0x32
47 #define TPS6586X_LDO4V2		0x33
48 
49 /* converter settings  */
50 #define TPS6586X_SUPPLYV1	0x41
51 #define TPS6586X_SUPPLYV2	0x42
52 #define TPS6586X_SUPPLYV3	0x43
53 #define TPS6586X_SUPPLYV4	0x44
54 #define TPS6586X_SUPPLYV5	0x45
55 #define TPS6586X_SUPPLYV6	0x46
56 #define TPS6586X_SMODE1		0x47
57 #define TPS6586X_SMODE2		0x48
58 
59 struct tps6586x_regulator {
60 	struct regulator_desc desc;
61 
62 	int enable_bit[2];
63 	int enable_reg[2];
64 };
65 
66 static inline struct device *to_tps6586x_dev(struct regulator_dev *rdev)
67 {
68 	return rdev_get_dev(rdev)->parent;
69 }
70 
71 static struct regulator_ops tps6586x_regulator_ops = {
72 	.list_voltage = regulator_list_voltage_table,
73 	.map_voltage = regulator_map_voltage_ascend,
74 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
75 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
76 
77 	.is_enabled = regulator_is_enabled_regmap,
78 	.enable = regulator_enable_regmap,
79 	.disable = regulator_disable_regmap,
80 };
81 
82 static struct regulator_ops tps6586x_sys_regulator_ops = {
83 };
84 
85 static const unsigned int tps6586x_ldo0_voltages[] = {
86 	1200000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
87 };
88 
89 static const unsigned int tps6586x_ldo4_voltages[] = {
90 	1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000,
91 	1900000, 1925000, 1950000, 1975000, 2000000, 2025000, 2050000, 2075000,
92 	2100000, 2125000, 2150000, 2175000, 2200000, 2225000, 2250000, 2275000,
93 	2300000, 2325000, 2350000, 2375000, 2400000, 2425000, 2450000, 2475000,
94 };
95 
96 #define tps658623_sm2_voltages tps6586x_ldo4_voltages
97 
98 static const unsigned int tps6586x_ldo_voltages[] = {
99 	1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
100 };
101 
102 static const unsigned int tps6586x_sm2_voltages[] = {
103 	3000000, 3050000, 3100000, 3150000, 3200000, 3250000, 3300000, 3350000,
104 	3400000, 3450000, 3500000, 3550000, 3600000, 3650000, 3700000, 3750000,
105 	3800000, 3850000, 3900000, 3950000, 4000000, 4050000, 4100000, 4150000,
106 	4200000, 4250000, 4300000, 4350000, 4400000, 4450000, 4500000, 4550000,
107 };
108 
109 static const unsigned int tps658643_sm2_voltages[] = {
110 	1025000, 1050000, 1075000, 1100000, 1125000, 1150000, 1175000, 1200000,
111 	1225000, 1250000, 1275000, 1300000, 1325000, 1350000, 1375000, 1400000,
112 	1425000, 1450000, 1475000, 1500000, 1525000, 1550000, 1575000, 1600000,
113 	1625000, 1650000, 1675000, 1700000, 1725000, 1750000, 1775000, 1800000,
114 };
115 
116 static const unsigned int tps6586x_dvm_voltages[] = {
117 	 725000,  750000,  775000,  800000,  825000,  850000,  875000,  900000,
118 	 925000,  950000,  975000, 1000000, 1025000, 1050000, 1075000, 1100000,
119 	1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000,
120 	1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000,
121 };
122 
123 #define TPS6586X_REGULATOR(_id, _pin_name, vdata, vreg, shift, nbits,	\
124 			   ereg0, ebit0, ereg1, ebit1, goreg, gobit)	\
125 	.desc	= {							\
126 		.supply_name = _pin_name,				\
127 		.name	= "REG-" #_id,					\
128 		.ops	= &tps6586x_regulator_ops,			\
129 		.type	= REGULATOR_VOLTAGE,				\
130 		.id	= TPS6586X_ID_##_id,				\
131 		.n_voltages = ARRAY_SIZE(vdata##_voltages),		\
132 		.volt_table = vdata##_voltages,				\
133 		.owner	= THIS_MODULE,					\
134 		.enable_reg = TPS6586X_SUPPLY##ereg0,			\
135 		.enable_mask = 1 << (ebit0),				\
136 		.vsel_reg = TPS6586X_##vreg,				\
137 		.vsel_mask = ((1 << (nbits)) - 1) << (shift),		\
138 		.apply_reg = (goreg),				\
139 		.apply_bit = (gobit),				\
140 	},								\
141 	.enable_reg[0]	= TPS6586X_SUPPLY##ereg0,			\
142 	.enable_bit[0]	= (ebit0),					\
143 	.enable_reg[1]	= TPS6586X_SUPPLY##ereg1,			\
144 	.enable_bit[1]	= (ebit1),
145 
146 #define TPS6586X_LDO(_id, _pname, vdata, vreg, shift, nbits,		\
147 		     ereg0, ebit0, ereg1, ebit1)			\
148 {									\
149 	TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits,	\
150 			   ereg0, ebit0, ereg1, ebit1, 0, 0)		\
151 }
152 
153 #define TPS6586X_DVM(_id, _pname, vdata, vreg, shift, nbits,		\
154 		     ereg0, ebit0, ereg1, ebit1, goreg, gobit)		\
155 {									\
156 	TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits,	\
157 			   ereg0, ebit0, ereg1, ebit1, goreg, gobit)	\
158 }
159 
160 #define TPS6586X_SYS_REGULATOR()					\
161 {									\
162 	.desc	= {							\
163 		.supply_name = "sys",					\
164 		.name	= "REG-SYS",					\
165 		.ops	= &tps6586x_sys_regulator_ops,			\
166 		.type	= REGULATOR_VOLTAGE,				\
167 		.id	= TPS6586X_ID_SYS,				\
168 		.owner	= THIS_MODULE,					\
169 	},								\
170 }
171 
172 static struct tps6586x_regulator tps6586x_regulator[] = {
173 	TPS6586X_SYS_REGULATOR(),
174 	TPS6586X_LDO(LDO_0, "vinldo01", tps6586x_ldo0, SUPPLYV1, 5, 3, ENC, 0,
175 					END, 0),
176 	TPS6586X_LDO(LDO_3, "vinldo23", tps6586x_ldo, SUPPLYV4, 0, 3, ENC, 2,
177 					END, 2),
178 	TPS6586X_LDO(LDO_5, "REG-SYS", tps6586x_ldo, SUPPLYV6, 0, 3, ENE, 6,
179 					ENE, 6),
180 	TPS6586X_LDO(LDO_6, "vinldo678", tps6586x_ldo, SUPPLYV3, 0, 3, ENC, 4,
181 					END, 4),
182 	TPS6586X_LDO(LDO_7, "vinldo678", tps6586x_ldo, SUPPLYV3, 3, 3, ENC, 5,
183 					END, 5),
184 	TPS6586X_LDO(LDO_8, "vinldo678", tps6586x_ldo, SUPPLYV2, 5, 3, ENC, 6,
185 					END, 6),
186 	TPS6586X_LDO(LDO_9, "vinldo9", tps6586x_ldo, SUPPLYV6, 3, 3, ENE, 7,
187 					ENE, 7),
188 	TPS6586X_LDO(LDO_RTC, "REG-SYS", tps6586x_ldo, SUPPLYV4, 3, 3, V4, 7,
189 					V4, 7),
190 	TPS6586X_LDO(LDO_1, "vinldo01", tps6586x_dvm, SUPPLYV1, 0, 5, ENC, 1,
191 					END, 1),
192 	TPS6586X_LDO(SM_2, "vin-sm2", tps6586x_sm2, SUPPLYV2, 0, 5, ENC, 7,
193 					END, 7),
194 
195 	TPS6586X_DVM(LDO_2, "vinldo23", tps6586x_dvm, LDO2BV1, 0, 5, ENA, 3,
196 					ENB, 3, TPS6586X_VCC2, BIT(6)),
197 	TPS6586X_DVM(LDO_4, "vinldo4", tps6586x_ldo4, LDO4V1, 0, 5, ENC, 3,
198 					END, 3, TPS6586X_VCC1, BIT(6)),
199 	TPS6586X_DVM(SM_0, "vin-sm0", tps6586x_dvm, SM0V1, 0, 5, ENA, 1,
200 					ENB, 1, TPS6586X_VCC1, BIT(2)),
201 	TPS6586X_DVM(SM_1, "vin-sm1", tps6586x_dvm, SM1V1, 0, 5, ENA, 0,
202 					ENB, 0, TPS6586X_VCC1, BIT(0)),
203 };
204 
205 static struct tps6586x_regulator tps658623_regulator[] = {
206 	TPS6586X_LDO(SM_2, "vin-sm2", tps658623_sm2, SUPPLYV2, 0, 5, ENC, 7,
207 					END, 7),
208 };
209 
210 static struct tps6586x_regulator tps658643_regulator[] = {
211 	TPS6586X_LDO(SM_2, "vin-sm2", tps658643_sm2, SUPPLYV2, 0, 5, ENC, 7,
212 					END, 7),
213 };
214 
215 /*
216  * TPS6586X has 2 enable bits that are OR'ed to determine the actual
217  * regulator state. Clearing one of this bits allows switching
218  * regulator on and of with single register write.
219  */
220 static inline int tps6586x_regulator_preinit(struct device *parent,
221 					     struct tps6586x_regulator *ri)
222 {
223 	uint8_t val1, val2;
224 	int ret;
225 
226 	if (ri->enable_reg[0] == ri->enable_reg[1] &&
227 	    ri->enable_bit[0] == ri->enable_bit[1])
228 			return 0;
229 
230 	ret = tps6586x_read(parent, ri->enable_reg[0], &val1);
231 	if (ret)
232 		return ret;
233 
234 	ret = tps6586x_read(parent, ri->enable_reg[1], &val2);
235 	if (ret)
236 		return ret;
237 
238 	if (!(val2 & (1 << ri->enable_bit[1])))
239 		return 0;
240 
241 	/*
242 	 * The regulator is on, but it's enabled with the bit we don't
243 	 * want to use, so we switch the enable bits
244 	 */
245 	if (!(val1 & (1 << ri->enable_bit[0]))) {
246 		ret = tps6586x_set_bits(parent, ri->enable_reg[0],
247 					1 << ri->enable_bit[0]);
248 		if (ret)
249 			return ret;
250 	}
251 
252 	return tps6586x_clr_bits(parent, ri->enable_reg[1],
253 				 1 << ri->enable_bit[1]);
254 }
255 
256 static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev,
257 			int id, struct regulator_init_data *p)
258 {
259 	struct device *parent = pdev->dev.parent;
260 	struct tps6586x_settings *setting = p->driver_data;
261 	uint8_t reg;
262 
263 	if (setting == NULL)
264 		return 0;
265 
266 	if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET))
267 		return 0;
268 
269 	/* only SM0 and SM1 can have the slew rate settings */
270 	switch (id) {
271 	case TPS6586X_ID_SM_0:
272 		reg = TPS6586X_SM0SL;
273 		break;
274 	case TPS6586X_ID_SM_1:
275 		reg = TPS6586X_SM1SL;
276 		break;
277 	default:
278 		dev_err(&pdev->dev, "Only SM0/SM1 can set slew rate\n");
279 		return -EINVAL;
280 	}
281 
282 	return tps6586x_write(parent, reg,
283 			setting->slew_rate & TPS6586X_SLEW_RATE_MASK);
284 }
285 
286 static struct tps6586x_regulator *find_regulator_info(int id, int version)
287 {
288 	struct tps6586x_regulator *ri;
289 	struct tps6586x_regulator *table = NULL;
290 	int num;
291 	int i;
292 
293 	switch (version) {
294 	case TPS658623:
295 		table = tps658623_regulator;
296 		num = ARRAY_SIZE(tps658623_regulator);
297 		break;
298 	case TPS658643:
299 		table = tps658643_regulator;
300 		num = ARRAY_SIZE(tps658643_regulator);
301 		break;
302 	}
303 
304 	/* Search version specific table first */
305 	if (table) {
306 		for (i = 0; i < num; i++) {
307 			ri = &table[i];
308 			if (ri->desc.id == id)
309 				return ri;
310 		}
311 	}
312 
313 	for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
314 		ri = &tps6586x_regulator[i];
315 		if (ri->desc.id == id)
316 			return ri;
317 	}
318 	return NULL;
319 }
320 
321 #ifdef CONFIG_OF
322 static struct of_regulator_match tps6586x_matches[] = {
323 	{ .name = "sys",     .driver_data = (void *)TPS6586X_ID_SYS     },
324 	{ .name = "sm0",     .driver_data = (void *)TPS6586X_ID_SM_0    },
325 	{ .name = "sm1",     .driver_data = (void *)TPS6586X_ID_SM_1    },
326 	{ .name = "sm2",     .driver_data = (void *)TPS6586X_ID_SM_2    },
327 	{ .name = "ldo0",    .driver_data = (void *)TPS6586X_ID_LDO_0   },
328 	{ .name = "ldo1",    .driver_data = (void *)TPS6586X_ID_LDO_1   },
329 	{ .name = "ldo2",    .driver_data = (void *)TPS6586X_ID_LDO_2   },
330 	{ .name = "ldo3",    .driver_data = (void *)TPS6586X_ID_LDO_3   },
331 	{ .name = "ldo4",    .driver_data = (void *)TPS6586X_ID_LDO_4   },
332 	{ .name = "ldo5",    .driver_data = (void *)TPS6586X_ID_LDO_5   },
333 	{ .name = "ldo6",    .driver_data = (void *)TPS6586X_ID_LDO_6   },
334 	{ .name = "ldo7",    .driver_data = (void *)TPS6586X_ID_LDO_7   },
335 	{ .name = "ldo8",    .driver_data = (void *)TPS6586X_ID_LDO_8   },
336 	{ .name = "ldo9",    .driver_data = (void *)TPS6586X_ID_LDO_9   },
337 	{ .name = "ldo_rtc", .driver_data = (void *)TPS6586X_ID_LDO_RTC },
338 };
339 
340 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
341 		struct platform_device *pdev,
342 		struct of_regulator_match **tps6586x_reg_matches)
343 {
344 	const unsigned int num = ARRAY_SIZE(tps6586x_matches);
345 	struct device_node *np = pdev->dev.parent->of_node;
346 	struct device_node *regs;
347 	const char *sys_rail = NULL;
348 	unsigned int i;
349 	struct tps6586x_platform_data *pdata;
350 	int err;
351 
352 	regs = of_get_child_by_name(np, "regulators");
353 	if (!regs) {
354 		dev_err(&pdev->dev, "regulator node not found\n");
355 		return NULL;
356 	}
357 
358 	err = of_regulator_match(&pdev->dev, regs, tps6586x_matches, num);
359 	of_node_put(regs);
360 	if (err < 0) {
361 		dev_err(&pdev->dev, "Regulator match failed, e %d\n", err);
362 		return NULL;
363 	}
364 
365 	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
366 	if (!pdata)
367 		return NULL;
368 
369 	for (i = 0; i < num; i++) {
370 		int id;
371 		if (!tps6586x_matches[i].init_data)
372 			continue;
373 
374 		pdata->reg_init_data[i] = tps6586x_matches[i].init_data;
375 		id = (int)tps6586x_matches[i].driver_data;
376 		if (id == TPS6586X_ID_SYS)
377 			sys_rail = pdata->reg_init_data[i]->constraints.name;
378 
379 		if ((id == TPS6586X_ID_LDO_5) || (id == TPS6586X_ID_LDO_RTC))
380 			pdata->reg_init_data[i]->supply_regulator = sys_rail;
381 	}
382 	*tps6586x_reg_matches = tps6586x_matches;
383 	return pdata;
384 }
385 #else
386 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
387 		struct platform_device *pdev,
388 		struct of_regulator_match **tps6586x_reg_matches)
389 {
390 	*tps6586x_reg_matches = NULL;
391 	return NULL;
392 }
393 #endif
394 
395 static int tps6586x_regulator_probe(struct platform_device *pdev)
396 {
397 	struct tps6586x_regulator *ri = NULL;
398 	struct regulator_config config = { };
399 	struct regulator_dev *rdev;
400 	struct regulator_init_data *reg_data;
401 	struct tps6586x_platform_data *pdata;
402 	struct of_regulator_match *tps6586x_reg_matches = NULL;
403 	int version;
404 	int id;
405 	int err;
406 
407 	dev_dbg(&pdev->dev, "Probing regulator\n");
408 
409 	pdata = dev_get_platdata(pdev->dev.parent);
410 	if ((!pdata) && (pdev->dev.parent->of_node))
411 		pdata = tps6586x_parse_regulator_dt(pdev,
412 					&tps6586x_reg_matches);
413 
414 	if (!pdata) {
415 		dev_err(&pdev->dev, "Platform data not available, exiting\n");
416 		return -ENODEV;
417 	}
418 
419 	version = tps6586x_get_version(pdev->dev.parent);
420 
421 	for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) {
422 		reg_data = pdata->reg_init_data[id];
423 
424 		ri = find_regulator_info(id, version);
425 
426 		if (!ri) {
427 			dev_err(&pdev->dev, "invalid regulator ID specified\n");
428 			return -EINVAL;
429 		}
430 
431 		err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
432 		if (err) {
433 			dev_err(&pdev->dev,
434 				"regulator %d preinit failed, e %d\n", id, err);
435 			return err;
436 		}
437 
438 		config.dev = pdev->dev.parent;
439 		config.init_data = reg_data;
440 		config.driver_data = ri;
441 
442 		if (tps6586x_reg_matches)
443 			config.of_node = tps6586x_reg_matches[id].of_node;
444 
445 		rdev = devm_regulator_register(&pdev->dev, &ri->desc, &config);
446 		if (IS_ERR(rdev)) {
447 			dev_err(&pdev->dev, "failed to register regulator %s\n",
448 					ri->desc.name);
449 			return PTR_ERR(rdev);
450 		}
451 
452 		if (reg_data) {
453 			err = tps6586x_regulator_set_slew_rate(pdev, id,
454 					reg_data);
455 			if (err < 0) {
456 				dev_err(&pdev->dev,
457 					"Slew rate config failed, e %d\n", err);
458 				return err;
459 			}
460 		}
461 	}
462 
463 	platform_set_drvdata(pdev, rdev);
464 	return 0;
465 }
466 
467 static struct platform_driver tps6586x_regulator_driver = {
468 	.driver	= {
469 		.name	= "tps6586x-regulator",
470 		.owner	= THIS_MODULE,
471 	},
472 	.probe		= tps6586x_regulator_probe,
473 };
474 
475 static int __init tps6586x_regulator_init(void)
476 {
477 	return platform_driver_register(&tps6586x_regulator_driver);
478 }
479 subsys_initcall(tps6586x_regulator_init);
480 
481 static void __exit tps6586x_regulator_exit(void)
482 {
483 	platform_driver_unregister(&tps6586x_regulator_driver);
484 }
485 module_exit(tps6586x_regulator_exit);
486 
487 MODULE_LICENSE("GPL");
488 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
489 MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
490 MODULE_ALIAS("platform:tps6586x-regulator");
491