1 /*
2  * Regulator driver for TPS6524x PMIC
3  *
4  * Copyright (C) 2010 Texas Instruments
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License as
8  * published by the Free Software Foundation version 2.
9  *
10  * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
11  * whether express or implied; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License for more details.
14  */
15 
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/err.h>
19 #include <linux/errno.h>
20 #include <linux/slab.h>
21 #include <linux/spi/spi.h>
22 #include <linux/regulator/driver.h>
23 #include <linux/regulator/machine.h>
24 
25 #define REG_LDO_SET		0x0
26 #define LDO_ILIM_MASK		1	/* 0 = 400-800, 1 = 900-1500 */
27 #define LDO_VSEL_MASK		0x0f
28 #define LDO2_ILIM_SHIFT		12
29 #define LDO2_VSEL_SHIFT		4
30 #define LDO1_ILIM_SHIFT		8
31 #define LDO1_VSEL_SHIFT		0
32 
33 #define REG_BLOCK_EN		0x1
34 #define BLOCK_MASK		1
35 #define BLOCK_LDO1_SHIFT	0
36 #define BLOCK_LDO2_SHIFT	1
37 #define BLOCK_LCD_SHIFT		2
38 #define BLOCK_USB_SHIFT		3
39 
40 #define REG_DCDC_SET		0x2
41 #define DCDC_VDCDC_MASK		0x1f
42 #define DCDC_VDCDC1_SHIFT	0
43 #define DCDC_VDCDC2_SHIFT	5
44 #define DCDC_VDCDC3_SHIFT	10
45 
46 #define REG_DCDC_EN		0x3
47 #define DCDCDCDC_EN_MASK	0x1
48 #define DCDCDCDC1_EN_SHIFT	0
49 #define DCDCDCDC1_PG_MSK	BIT(1)
50 #define DCDCDCDC2_EN_SHIFT	2
51 #define DCDCDCDC2_PG_MSK	BIT(3)
52 #define DCDCDCDC3_EN_SHIFT	4
53 #define DCDCDCDC3_PG_MSK	BIT(5)
54 
55 #define REG_USB			0x4
56 #define USB_ILIM_SHIFT		0
57 #define USB_ILIM_MASK		0x3
58 #define USB_TSD_SHIFT		2
59 #define USB_TSD_MASK		0x3
60 #define USB_TWARN_SHIFT		4
61 #define USB_TWARN_MASK		0x3
62 #define USB_IWARN_SD		BIT(6)
63 #define USB_FAST_LOOP		BIT(7)
64 
65 #define REG_ALARM		0x5
66 #define ALARM_LDO1		BIT(0)
67 #define ALARM_DCDC1		BIT(1)
68 #define ALARM_DCDC2		BIT(2)
69 #define ALARM_DCDC3		BIT(3)
70 #define ALARM_LDO2		BIT(4)
71 #define ALARM_USB_WARN		BIT(5)
72 #define ALARM_USB_ALARM		BIT(6)
73 #define ALARM_LCD		BIT(9)
74 #define ALARM_TEMP_WARM		BIT(10)
75 #define ALARM_TEMP_HOT		BIT(11)
76 #define ALARM_NRST		BIT(14)
77 #define ALARM_POWERUP		BIT(15)
78 
79 #define REG_INT_ENABLE		0x6
80 #define INT_LDO1		BIT(0)
81 #define INT_DCDC1		BIT(1)
82 #define INT_DCDC2		BIT(2)
83 #define INT_DCDC3		BIT(3)
84 #define INT_LDO2		BIT(4)
85 #define INT_USB_WARN		BIT(5)
86 #define INT_USB_ALARM		BIT(6)
87 #define INT_LCD			BIT(9)
88 #define INT_TEMP_WARM		BIT(10)
89 #define INT_TEMP_HOT		BIT(11)
90 #define INT_GLOBAL_EN		BIT(15)
91 
92 #define REG_INT_STATUS		0x7
93 #define STATUS_LDO1		BIT(0)
94 #define STATUS_DCDC1		BIT(1)
95 #define STATUS_DCDC2		BIT(2)
96 #define STATUS_DCDC3		BIT(3)
97 #define STATUS_LDO2		BIT(4)
98 #define STATUS_USB_WARN		BIT(5)
99 #define STATUS_USB_ALARM	BIT(6)
100 #define STATUS_LCD		BIT(9)
101 #define STATUS_TEMP_WARM	BIT(10)
102 #define STATUS_TEMP_HOT		BIT(11)
103 
104 #define REG_SOFTWARE_RESET	0xb
105 #define REG_WRITE_ENABLE	0xd
106 #define REG_REV_ID		0xf
107 
108 #define N_DCDC			3
109 #define N_LDO			2
110 #define N_SWITCH		2
111 #define N_REGULATORS		(N_DCDC + N_LDO + N_SWITCH)
112 
113 #define CMD_READ(reg)		((reg) << 6)
114 #define CMD_WRITE(reg)		(BIT(5) | (reg) << 6)
115 #define STAT_CLK		BIT(3)
116 #define STAT_WRITE		BIT(2)
117 #define STAT_INVALID		BIT(1)
118 #define STAT_WP			BIT(0)
119 
120 struct field {
121 	int		reg;
122 	int		shift;
123 	int		mask;
124 };
125 
126 struct supply_info {
127 	const char	*name;
128 	int		n_voltages;
129 	const unsigned int *voltages;
130 	int		n_ilimsels;
131 	const unsigned int *ilimsels;
132 	struct field	enable, voltage, ilimsel;
133 };
134 
135 struct tps6524x {
136 	struct device		*dev;
137 	struct spi_device	*spi;
138 	struct mutex		lock;
139 	struct regulator_desc	desc[N_REGULATORS];
140 };
141 
142 static int __read_reg(struct tps6524x *hw, int reg)
143 {
144 	int error = 0;
145 	u16 cmd = CMD_READ(reg), in;
146 	u8 status;
147 	struct spi_message m;
148 	struct spi_transfer t[3];
149 
150 	spi_message_init(&m);
151 	memset(t, 0, sizeof(t));
152 
153 	t[0].tx_buf = &cmd;
154 	t[0].len = 2;
155 	t[0].bits_per_word = 12;
156 	spi_message_add_tail(&t[0], &m);
157 
158 	t[1].rx_buf = &in;
159 	t[1].len = 2;
160 	t[1].bits_per_word = 16;
161 	spi_message_add_tail(&t[1], &m);
162 
163 	t[2].rx_buf = &status;
164 	t[2].len = 1;
165 	t[2].bits_per_word = 4;
166 	spi_message_add_tail(&t[2], &m);
167 
168 	error = spi_sync(hw->spi, &m);
169 	if (error < 0)
170 		return error;
171 
172 	dev_dbg(hw->dev, "read reg %d, data %x, status %x\n",
173 		reg, in, status);
174 
175 	if (!(status & STAT_CLK) || (status & STAT_WRITE))
176 		return -EIO;
177 
178 	if (status & STAT_INVALID)
179 		return -EINVAL;
180 
181 	return in;
182 }
183 
184 static int read_reg(struct tps6524x *hw, int reg)
185 {
186 	int ret;
187 
188 	mutex_lock(&hw->lock);
189 	ret = __read_reg(hw, reg);
190 	mutex_unlock(&hw->lock);
191 
192 	return ret;
193 }
194 
195 static int __write_reg(struct tps6524x *hw, int reg, int val)
196 {
197 	int error = 0;
198 	u16 cmd = CMD_WRITE(reg), out = val;
199 	u8 status;
200 	struct spi_message m;
201 	struct spi_transfer t[3];
202 
203 	spi_message_init(&m);
204 	memset(t, 0, sizeof(t));
205 
206 	t[0].tx_buf = &cmd;
207 	t[0].len = 2;
208 	t[0].bits_per_word = 12;
209 	spi_message_add_tail(&t[0], &m);
210 
211 	t[1].tx_buf = &out;
212 	t[1].len = 2;
213 	t[1].bits_per_word = 16;
214 	spi_message_add_tail(&t[1], &m);
215 
216 	t[2].rx_buf = &status;
217 	t[2].len = 1;
218 	t[2].bits_per_word = 4;
219 	spi_message_add_tail(&t[2], &m);
220 
221 	error = spi_sync(hw->spi, &m);
222 	if (error < 0)
223 		return error;
224 
225 	dev_dbg(hw->dev, "wrote reg %d, data %x, status %x\n",
226 		reg, out, status);
227 
228 	if (!(status & STAT_CLK) || !(status & STAT_WRITE))
229 		return -EIO;
230 
231 	if (status & (STAT_INVALID | STAT_WP))
232 		return -EINVAL;
233 
234 	return error;
235 }
236 
237 static int __rmw_reg(struct tps6524x *hw, int reg, int mask, int val)
238 {
239 	int ret;
240 
241 	ret = __read_reg(hw, reg);
242 	if (ret < 0)
243 		return ret;
244 
245 	ret &= ~mask;
246 	ret |= val;
247 
248 	ret = __write_reg(hw, reg, ret);
249 
250 	return (ret < 0) ? ret : 0;
251 }
252 
253 static int rmw_protect(struct tps6524x *hw, int reg, int mask, int val)
254 {
255 	int ret;
256 
257 	mutex_lock(&hw->lock);
258 
259 	ret = __write_reg(hw, REG_WRITE_ENABLE, 1);
260 	if (ret) {
261 		dev_err(hw->dev, "failed to set write enable\n");
262 		goto error;
263 	}
264 
265 	ret = __rmw_reg(hw, reg, mask, val);
266 	if (ret)
267 		dev_err(hw->dev, "failed to rmw register %d\n", reg);
268 
269 	ret = __write_reg(hw, REG_WRITE_ENABLE, 0);
270 	if (ret) {
271 		dev_err(hw->dev, "failed to clear write enable\n");
272 		goto error;
273 	}
274 
275 error:
276 	mutex_unlock(&hw->lock);
277 
278 	return ret;
279 }
280 
281 static int read_field(struct tps6524x *hw, const struct field *field)
282 {
283 	int tmp;
284 
285 	tmp = read_reg(hw, field->reg);
286 	if (tmp < 0)
287 		return tmp;
288 
289 	return (tmp >> field->shift) & field->mask;
290 }
291 
292 static int write_field(struct tps6524x *hw, const struct field *field,
293 		       int val)
294 {
295 	if (val & ~field->mask)
296 		return -EOVERFLOW;
297 
298 	return rmw_protect(hw, field->reg,
299 				    field->mask << field->shift,
300 				    val << field->shift);
301 }
302 
303 static const unsigned int dcdc1_voltages[] = {
304 	 800000,  825000,  850000,  875000,
305 	 900000,  925000,  950000,  975000,
306 	1000000, 1025000, 1050000, 1075000,
307 	1100000, 1125000, 1150000, 1175000,
308 	1200000, 1225000, 1250000, 1275000,
309 	1300000, 1325000, 1350000, 1375000,
310 	1400000, 1425000, 1450000, 1475000,
311 	1500000, 1525000, 1550000, 1575000,
312 };
313 
314 static const unsigned int dcdc2_voltages[] = {
315 	1400000, 1450000, 1500000, 1550000,
316 	1600000, 1650000, 1700000, 1750000,
317 	1800000, 1850000, 1900000, 1950000,
318 	2000000, 2050000, 2100000, 2150000,
319 	2200000, 2250000, 2300000, 2350000,
320 	2400000, 2450000, 2500000, 2550000,
321 	2600000, 2650000, 2700000, 2750000,
322 	2800000, 2850000, 2900000, 2950000,
323 };
324 
325 static const unsigned int dcdc3_voltages[] = {
326 	2400000, 2450000, 2500000, 2550000, 2600000,
327 	2650000, 2700000, 2750000, 2800000, 2850000,
328 	2900000, 2950000, 3000000, 3050000, 3100000,
329 	3150000, 3200000, 3250000, 3300000, 3350000,
330 	3400000, 3450000, 3500000, 3550000, 3600000,
331 };
332 
333 static const unsigned int ldo1_voltages[] = {
334 	4300000, 4350000, 4400000, 4450000,
335 	4500000, 4550000, 4600000, 4650000,
336 	4700000, 4750000, 4800000, 4850000,
337 	4900000, 4950000, 5000000, 5050000,
338 };
339 
340 static const unsigned int ldo2_voltages[] = {
341 	1100000, 1150000, 1200000, 1250000,
342 	1300000, 1700000, 1750000, 1800000,
343 	1850000, 1900000, 3150000, 3200000,
344 	3250000, 3300000, 3350000, 3400000,
345 };
346 
347 static const unsigned int fixed_5000000_voltage[] = {
348 	5000000
349 };
350 
351 static const unsigned int ldo_ilimsel[] = {
352 	400000, 1500000
353 };
354 
355 static const unsigned int usb_ilimsel[] = {
356 	200000, 400000, 800000, 1000000
357 };
358 
359 static const unsigned int fixed_2400000_ilimsel[] = {
360 	2400000
361 };
362 
363 static const unsigned int fixed_1200000_ilimsel[] = {
364 	1200000
365 };
366 
367 static const unsigned int fixed_400000_ilimsel[] = {
368 	400000
369 };
370 
371 #define __MK_FIELD(_reg, _mask, _shift) \
372 	{ .reg = (_reg), .mask = (_mask), .shift = (_shift), }
373 
374 static const struct supply_info supply_info[N_REGULATORS] = {
375 	{
376 		.name		= "DCDC1",
377 		.n_voltages	= ARRAY_SIZE(dcdc1_voltages),
378 		.voltages	= dcdc1_voltages,
379 		.n_ilimsels	= ARRAY_SIZE(fixed_2400000_ilimsel),
380 		.ilimsels	= fixed_2400000_ilimsel,
381 		.enable		= __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
382 					     DCDCDCDC1_EN_SHIFT),
383 		.voltage	= __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
384 					     DCDC_VDCDC1_SHIFT),
385 	},
386 	{
387 		.name		= "DCDC2",
388 		.n_voltages	= ARRAY_SIZE(dcdc2_voltages),
389 		.voltages	= dcdc2_voltages,
390 		.n_ilimsels	= ARRAY_SIZE(fixed_1200000_ilimsel),
391 		.ilimsels	= fixed_1200000_ilimsel,
392 		.enable		= __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
393 					     DCDCDCDC2_EN_SHIFT),
394 		.voltage	= __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
395 					     DCDC_VDCDC2_SHIFT),
396 	},
397 	{
398 		.name		= "DCDC3",
399 		.n_voltages	= ARRAY_SIZE(dcdc3_voltages),
400 		.voltages	= dcdc3_voltages,
401 		.n_ilimsels	= ARRAY_SIZE(fixed_1200000_ilimsel),
402 		.ilimsels	= fixed_1200000_ilimsel,
403 		.enable		= __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
404 					DCDCDCDC3_EN_SHIFT),
405 		.voltage	= __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
406 					     DCDC_VDCDC3_SHIFT),
407 	},
408 	{
409 		.name		= "LDO1",
410 		.n_voltages	= ARRAY_SIZE(ldo1_voltages),
411 		.voltages	= ldo1_voltages,
412 		.n_ilimsels	= ARRAY_SIZE(ldo_ilimsel),
413 		.ilimsels	= ldo_ilimsel,
414 		.enable		= __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
415 					     BLOCK_LDO1_SHIFT),
416 		.voltage	= __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK,
417 					     LDO1_VSEL_SHIFT),
418 		.ilimsel	= __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK,
419 					     LDO1_ILIM_SHIFT),
420 	},
421 	{
422 		.name		= "LDO2",
423 		.n_voltages	= ARRAY_SIZE(ldo2_voltages),
424 		.voltages	= ldo2_voltages,
425 		.n_ilimsels	= ARRAY_SIZE(ldo_ilimsel),
426 		.ilimsels	= ldo_ilimsel,
427 		.enable		= __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
428 					     BLOCK_LDO2_SHIFT),
429 		.voltage	= __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK,
430 					     LDO2_VSEL_SHIFT),
431 		.ilimsel	= __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK,
432 					     LDO2_ILIM_SHIFT),
433 	},
434 	{
435 		.name		= "USB",
436 		.n_voltages	= ARRAY_SIZE(fixed_5000000_voltage),
437 		.voltages	= fixed_5000000_voltage,
438 		.n_ilimsels	= ARRAY_SIZE(usb_ilimsel),
439 		.ilimsels	= usb_ilimsel,
440 		.enable		= __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
441 					     BLOCK_USB_SHIFT),
442 		.ilimsel	= __MK_FIELD(REG_USB, USB_ILIM_MASK,
443 					     USB_ILIM_SHIFT),
444 	},
445 	{
446 		.name		= "LCD",
447 		.n_voltages	= ARRAY_SIZE(fixed_5000000_voltage),
448 		.voltages	= fixed_5000000_voltage,
449 		.n_ilimsels	= ARRAY_SIZE(fixed_400000_ilimsel),
450 		.ilimsels	= fixed_400000_ilimsel,
451 		.enable		= __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
452 					     BLOCK_LCD_SHIFT),
453 	},
454 };
455 
456 static int set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
457 {
458 	const struct supply_info *info;
459 	struct tps6524x *hw;
460 
461 	hw	= rdev_get_drvdata(rdev);
462 	info	= &supply_info[rdev_get_id(rdev)];
463 
464 	if (rdev->desc->n_voltages == 1)
465 		return -EINVAL;
466 
467 	return write_field(hw, &info->voltage, selector);
468 }
469 
470 static int get_voltage_sel(struct regulator_dev *rdev)
471 {
472 	const struct supply_info *info;
473 	struct tps6524x *hw;
474 	int ret;
475 
476 	hw	= rdev_get_drvdata(rdev);
477 	info	= &supply_info[rdev_get_id(rdev)];
478 
479 	if (rdev->desc->n_voltages == 1)
480 		return 0;
481 
482 	ret = read_field(hw, &info->voltage);
483 	if (ret < 0)
484 		return ret;
485 	if (WARN_ON(ret >= info->n_voltages))
486 		return -EIO;
487 
488 	return ret;
489 }
490 
491 static int set_current_limit(struct regulator_dev *rdev, int min_uA,
492 			     int max_uA)
493 {
494 	const struct supply_info *info;
495 	struct tps6524x *hw;
496 	int i;
497 
498 	hw	= rdev_get_drvdata(rdev);
499 	info	= &supply_info[rdev_get_id(rdev)];
500 
501 	if (info->n_ilimsels == 1)
502 		return -EINVAL;
503 
504 	for (i = info->n_ilimsels - 1; i >= 0; i--) {
505 		if (min_uA <= info->ilimsels[i] &&
506 		    max_uA >= info->ilimsels[i])
507 			return write_field(hw, &info->ilimsel, i);
508 	}
509 
510 	return -EINVAL;
511 }
512 
513 static int get_current_limit(struct regulator_dev *rdev)
514 {
515 	const struct supply_info *info;
516 	struct tps6524x *hw;
517 	int ret;
518 
519 	hw	= rdev_get_drvdata(rdev);
520 	info	= &supply_info[rdev_get_id(rdev)];
521 
522 	if (info->n_ilimsels == 1)
523 		return info->ilimsels[0];
524 
525 	ret = read_field(hw, &info->ilimsel);
526 	if (ret < 0)
527 		return ret;
528 	if (WARN_ON(ret >= info->n_ilimsels))
529 		return -EIO;
530 
531 	return info->ilimsels[ret];
532 }
533 
534 static int enable_supply(struct regulator_dev *rdev)
535 {
536 	const struct supply_info *info;
537 	struct tps6524x *hw;
538 
539 	hw	= rdev_get_drvdata(rdev);
540 	info	= &supply_info[rdev_get_id(rdev)];
541 
542 	return write_field(hw, &info->enable, 1);
543 }
544 
545 static int disable_supply(struct regulator_dev *rdev)
546 {
547 	const struct supply_info *info;
548 	struct tps6524x *hw;
549 
550 	hw	= rdev_get_drvdata(rdev);
551 	info	= &supply_info[rdev_get_id(rdev)];
552 
553 	return write_field(hw, &info->enable, 0);
554 }
555 
556 static int is_supply_enabled(struct regulator_dev *rdev)
557 {
558 	const struct supply_info *info;
559 	struct tps6524x *hw;
560 
561 	hw	= rdev_get_drvdata(rdev);
562 	info	= &supply_info[rdev_get_id(rdev)];
563 
564 	return read_field(hw, &info->enable);
565 }
566 
567 static const struct regulator_ops regulator_ops = {
568 	.is_enabled		= is_supply_enabled,
569 	.enable			= enable_supply,
570 	.disable		= disable_supply,
571 	.get_voltage_sel	= get_voltage_sel,
572 	.set_voltage_sel	= set_voltage_sel,
573 	.list_voltage		= regulator_list_voltage_table,
574 	.map_voltage		= regulator_map_voltage_ascend,
575 	.set_current_limit	= set_current_limit,
576 	.get_current_limit	= get_current_limit,
577 };
578 
579 static int pmic_probe(struct spi_device *spi)
580 {
581 	struct tps6524x *hw;
582 	struct device *dev = &spi->dev;
583 	const struct supply_info *info = supply_info;
584 	struct regulator_init_data *init_data;
585 	struct regulator_config config = { };
586 	struct regulator_dev *rdev;
587 	int i;
588 
589 	init_data = dev_get_platdata(dev);
590 	if (!init_data) {
591 		dev_err(dev, "could not find regulator platform data\n");
592 		return -EINVAL;
593 	}
594 
595 	hw = devm_kzalloc(&spi->dev, sizeof(struct tps6524x), GFP_KERNEL);
596 	if (!hw)
597 		return -ENOMEM;
598 
599 	spi_set_drvdata(spi, hw);
600 
601 	memset(hw, 0, sizeof(struct tps6524x));
602 	hw->dev = dev;
603 	hw->spi = spi;
604 	mutex_init(&hw->lock);
605 
606 	for (i = 0; i < N_REGULATORS; i++, info++, init_data++) {
607 		hw->desc[i].name	= info->name;
608 		hw->desc[i].id		= i;
609 		hw->desc[i].n_voltages	= info->n_voltages;
610 		hw->desc[i].volt_table	= info->voltages;
611 		hw->desc[i].ops		= &regulator_ops;
612 		hw->desc[i].type	= REGULATOR_VOLTAGE;
613 		hw->desc[i].owner	= THIS_MODULE;
614 
615 		config.dev = dev;
616 		config.init_data = init_data;
617 		config.driver_data = hw;
618 
619 		rdev = devm_regulator_register(dev, &hw->desc[i], &config);
620 		if (IS_ERR(rdev))
621 			return PTR_ERR(rdev);
622 	}
623 
624 	return 0;
625 }
626 
627 static struct spi_driver pmic_driver = {
628 	.probe		= pmic_probe,
629 	.driver		= {
630 		.name	= "tps6524x",
631 		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
632 	},
633 };
634 
635 module_spi_driver(pmic_driver);
636 
637 MODULE_DESCRIPTION("TPS6524X PMIC Driver");
638 MODULE_AUTHOR("Cyril Chemparathy");
639 MODULE_LICENSE("GPL");
640 MODULE_ALIAS("spi:tps6524x");
641