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		(3 /* DCDC */ + \
112				 2 /* LDO */  + \
113				 2 /* switch */)
114
115#define FIXED_ILIMSEL		BIT(0)
116#define FIXED_VOLTAGE		BIT(1)
117
118#define CMD_READ(reg)		((reg) << 6)
119#define CMD_WRITE(reg)		(BIT(5) | (reg) << 6)
120#define STAT_CLK		BIT(3)
121#define STAT_WRITE		BIT(2)
122#define STAT_INVALID		BIT(1)
123#define STAT_WP			BIT(0)
124
125struct field {
126	int		reg;
127	int		shift;
128	int		mask;
129};
130
131struct supply_info {
132	const char	*name;
133	int		n_voltages;
134	const int	*voltages;
135	int		fixed_voltage;
136	int		n_ilimsels;
137	const int	*ilimsels;
138	int		fixed_ilimsel;
139	int		flags;
140	struct field	enable, voltage, ilimsel;
141};
142
143struct tps6524x {
144	struct device		*dev;
145	struct spi_device	*spi;
146	struct mutex		lock;
147	struct regulator_desc	desc[N_REGULATORS];
148	struct regulator_dev	*rdev[N_REGULATORS];
149};
150
151static int __read_reg(struct tps6524x *hw, int reg)
152{
153	int error = 0;
154	u16 cmd = CMD_READ(reg), in;
155	u8 status;
156	struct spi_message m;
157	struct spi_transfer t[3];
158
159	spi_message_init(&m);
160	memset(t, 0, sizeof(t));
161
162	t[0].tx_buf = &cmd;
163	t[0].len = 2;
164	t[0].bits_per_word = 12;
165	spi_message_add_tail(&t[0], &m);
166
167	t[1].rx_buf = &in;
168	t[1].len = 2;
169	t[1].bits_per_word = 16;
170	spi_message_add_tail(&t[1], &m);
171
172	t[2].rx_buf = &status;
173	t[2].len = 1;
174	t[2].bits_per_word = 4;
175	spi_message_add_tail(&t[2], &m);
176
177	error = spi_sync(hw->spi, &m);
178	if (error < 0)
179		return error;
180
181	dev_dbg(hw->dev, "read reg %d, data %x, status %x\n",
182		reg, in, status);
183
184	if (!(status & STAT_CLK) || (status & STAT_WRITE))
185		return -EIO;
186
187	if (status & STAT_INVALID)
188		return -EINVAL;
189
190	return in;
191}
192
193static int read_reg(struct tps6524x *hw, int reg)
194{
195	int ret;
196
197	mutex_lock(&hw->lock);
198	ret = __read_reg(hw, reg);
199	mutex_unlock(&hw->lock);
200
201	return ret;
202}
203
204static int __write_reg(struct tps6524x *hw, int reg, int val)
205{
206	int error = 0;
207	u16 cmd = CMD_WRITE(reg), out = val;
208	u8 status;
209	struct spi_message m;
210	struct spi_transfer t[3];
211
212	spi_message_init(&m);
213	memset(t, 0, sizeof(t));
214
215	t[0].tx_buf = &cmd;
216	t[0].len = 2;
217	t[0].bits_per_word = 12;
218	spi_message_add_tail(&t[0], &m);
219
220	t[1].tx_buf = &out;
221	t[1].len = 2;
222	t[1].bits_per_word = 16;
223	spi_message_add_tail(&t[1], &m);
224
225	t[2].rx_buf = &status;
226	t[2].len = 1;
227	t[2].bits_per_word = 4;
228	spi_message_add_tail(&t[2], &m);
229
230	error = spi_sync(hw->spi, &m);
231	if (error < 0)
232		return error;
233
234	dev_dbg(hw->dev, "wrote reg %d, data %x, status %x\n",
235		reg, out, status);
236
237	if (!(status & STAT_CLK) || !(status & STAT_WRITE))
238		return -EIO;
239
240	if (status & (STAT_INVALID | STAT_WP))
241		return -EINVAL;
242
243	return error;
244}
245
246static int __rmw_reg(struct tps6524x *hw, int reg, int mask, int val)
247{
248	int ret;
249
250	ret = __read_reg(hw, reg);
251	if (ret < 0)
252		return ret;
253
254	ret &= ~mask;
255	ret |= val;
256
257	ret = __write_reg(hw, reg, ret);
258
259	return (ret < 0) ? ret : 0;
260}
261
262static int rmw_protect(struct tps6524x *hw, int reg, int mask, int val)
263{
264	int ret;
265
266	mutex_lock(&hw->lock);
267
268	ret = __write_reg(hw, REG_WRITE_ENABLE, 1);
269	if (ret) {
270		dev_err(hw->dev, "failed to set write enable\n");
271		goto error;
272	}
273
274	ret = __rmw_reg(hw, reg, mask, val);
275	if (ret)
276		dev_err(hw->dev, "failed to rmw register %d\n", reg);
277
278	ret = __write_reg(hw, REG_WRITE_ENABLE, 0);
279	if (ret) {
280		dev_err(hw->dev, "failed to clear write enable\n");
281		goto error;
282	}
283
284error:
285	mutex_unlock(&hw->lock);
286
287	return ret;
288}
289
290static int read_field(struct tps6524x *hw, const struct field *field)
291{
292	int tmp;
293
294	tmp = read_reg(hw, field->reg);
295	if (tmp < 0)
296		return tmp;
297
298	return (tmp >> field->shift) & field->mask;
299}
300
301static int write_field(struct tps6524x *hw, const struct field *field,
302		       int val)
303{
304	if (val & ~field->mask)
305		return -EOVERFLOW;
306
307	return rmw_protect(hw, field->reg,
308				    field->mask << field->shift,
309				    val << field->shift);
310}
311
312static const int dcdc1_voltages[] = {
313	 800000,  825000,  850000,  875000,
314	 900000,  925000,  950000,  975000,
315	1000000, 1025000, 1050000, 1075000,
316	1100000, 1125000, 1150000, 1175000,
317	1200000, 1225000, 1250000, 1275000,
318	1300000, 1325000, 1350000, 1375000,
319	1400000, 1425000, 1450000, 1475000,
320	1500000, 1525000, 1550000, 1575000,
321};
322
323static const int dcdc2_voltages[] = {
324	1400000, 1450000, 1500000, 1550000,
325	1600000, 1650000, 1700000, 1750000,
326	1800000, 1850000, 1900000, 1950000,
327	2000000, 2050000, 2100000, 2150000,
328	2200000, 2250000, 2300000, 2350000,
329	2400000, 2450000, 2500000, 2550000,
330	2600000, 2650000, 2700000, 2750000,
331	2800000, 2850000, 2900000, 2950000,
332};
333
334static const int dcdc3_voltages[] = {
335	2400000, 2450000, 2500000, 2550000, 2600000,
336	2650000, 2700000, 2750000, 2800000, 2850000,
337	2900000, 2950000, 3000000, 3050000, 3100000,
338	3150000, 3200000, 3250000, 3300000, 3350000,
339	3400000, 3450000, 3500000, 3550000, 3600000,
340};
341
342static const int ldo1_voltages[] = {
343	4300000, 4350000, 4400000, 4450000,
344	4500000, 4550000, 4600000, 4650000,
345	4700000, 4750000, 4800000, 4850000,
346	4900000, 4950000, 5000000, 5050000,
347};
348
349static const int ldo2_voltages[] = {
350	1100000, 1150000, 1200000, 1250000,
351	1300000, 1700000, 1750000, 1800000,
352	1850000, 1900000, 3150000, 3200000,
353	3250000, 3300000, 3350000, 3400000,
354};
355
356static const int ldo_ilimsel[] = {
357	400000, 1500000
358};
359
360static const int usb_ilimsel[] = {
361	200000, 400000, 800000, 1000000
362};
363
364#define __MK_FIELD(_reg, _mask, _shift) \
365	{ .reg = (_reg), .mask = (_mask), .shift = (_shift), }
366
367static const struct supply_info supply_info[N_REGULATORS] = {
368	{
369		.name		= "DCDC1",
370		.flags		= FIXED_ILIMSEL,
371		.n_voltages	= ARRAY_SIZE(dcdc1_voltages),
372		.voltages	= dcdc1_voltages,
373		.fixed_ilimsel	= 2400000,
374		.enable		= __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
375					     DCDCDCDC1_EN_SHIFT),
376		.voltage	= __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
377					     DCDC_VDCDC1_SHIFT),
378	},
379	{
380		.name		= "DCDC2",
381		.flags		= FIXED_ILIMSEL,
382		.n_voltages	= ARRAY_SIZE(dcdc2_voltages),
383		.voltages	= dcdc2_voltages,
384		.fixed_ilimsel	= 1200000,
385		.enable		= __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
386					     DCDCDCDC2_EN_SHIFT),
387		.voltage	= __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
388					     DCDC_VDCDC2_SHIFT),
389	},
390	{
391		.name		= "DCDC3",
392		.flags		= FIXED_ILIMSEL,
393		.n_voltages	= ARRAY_SIZE(dcdc3_voltages),
394		.voltages	= dcdc3_voltages,
395		.fixed_ilimsel	= 1200000,
396		.enable		= __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
397					DCDCDCDC3_EN_SHIFT),
398		.voltage	= __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
399					     DCDC_VDCDC3_SHIFT),
400	},
401	{
402		.name		= "LDO1",
403		.n_voltages	= ARRAY_SIZE(ldo1_voltages),
404		.voltages	= ldo1_voltages,
405		.n_ilimsels	= ARRAY_SIZE(ldo_ilimsel),
406		.ilimsels	= ldo_ilimsel,
407		.enable		= __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
408					     BLOCK_LDO1_SHIFT),
409		.voltage	= __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK,
410					     LDO1_VSEL_SHIFT),
411		.ilimsel	= __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK,
412					     LDO1_ILIM_SHIFT),
413	},
414	{
415		.name		= "LDO2",
416		.n_voltages	= ARRAY_SIZE(ldo2_voltages),
417		.voltages	= ldo2_voltages,
418		.n_ilimsels	= ARRAY_SIZE(ldo_ilimsel),
419		.ilimsels	= ldo_ilimsel,
420		.enable		= __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
421					     BLOCK_LDO2_SHIFT),
422		.voltage	= __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK,
423					     LDO2_VSEL_SHIFT),
424		.ilimsel	= __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK,
425					     LDO2_ILIM_SHIFT),
426	},
427	{
428		.name		= "USB",
429		.flags		= FIXED_VOLTAGE,
430		.fixed_voltage	= 5000000,
431		.n_ilimsels	= ARRAY_SIZE(usb_ilimsel),
432		.ilimsels	= usb_ilimsel,
433		.enable		= __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
434					     BLOCK_USB_SHIFT),
435		.ilimsel	= __MK_FIELD(REG_USB, USB_ILIM_MASK,
436					     USB_ILIM_SHIFT),
437	},
438	{
439		.name		= "LCD",
440		.flags		= FIXED_VOLTAGE | FIXED_ILIMSEL,
441		.fixed_voltage	= 5000000,
442		.fixed_ilimsel	=  400000,
443		.enable		= __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
444					     BLOCK_LCD_SHIFT),
445	},
446};
447
448static int list_voltage(struct regulator_dev *rdev, unsigned selector)
449{
450	const struct supply_info *info;
451	struct tps6524x *hw;
452
453	hw	= rdev_get_drvdata(rdev);
454	info	= &supply_info[rdev_get_id(rdev)];
455
456	if (info->flags & FIXED_VOLTAGE)
457		return selector ? -EINVAL : info->fixed_voltage;
458
459	return ((selector < info->n_voltages) ?
460		info->voltages[selector] : -EINVAL);
461}
462
463static int set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV,
464		       unsigned *selector)
465{
466	const struct supply_info *info;
467	struct tps6524x *hw;
468	unsigned i;
469
470	hw	= rdev_get_drvdata(rdev);
471	info	= &supply_info[rdev_get_id(rdev)];
472
473	if (info->flags & FIXED_VOLTAGE)
474		return -EINVAL;
475
476	for (i = 0; i < info->n_voltages; i++)
477		if (min_uV <= info->voltages[i] &&
478		    max_uV >= info->voltages[i])
479			break;
480
481	if (i >= info->n_voltages)
482		i = info->n_voltages - 1;
483
484	*selector = info->voltages[i];
485
486	return write_field(hw, &info->voltage, i);
487}
488
489static int get_voltage(struct regulator_dev *rdev)
490{
491	const struct supply_info *info;
492	struct tps6524x *hw;
493	int ret;
494
495	hw	= rdev_get_drvdata(rdev);
496	info	= &supply_info[rdev_get_id(rdev)];
497
498	if (info->flags & FIXED_VOLTAGE)
499		return info->fixed_voltage;
500
501	ret = read_field(hw, &info->voltage);
502	if (ret < 0)
503		return ret;
504	if (WARN_ON(ret >= info->n_voltages))
505		return -EIO;
506
507	return info->voltages[ret];
508}
509
510static int set_current_limit(struct regulator_dev *rdev, int min_uA,
511			     int max_uA)
512{
513	const struct supply_info *info;
514	struct tps6524x *hw;
515	int i;
516
517	hw	= rdev_get_drvdata(rdev);
518	info	= &supply_info[rdev_get_id(rdev)];
519
520	if (info->flags & FIXED_ILIMSEL)
521		return -EINVAL;
522
523	for (i = 0; i < info->n_ilimsels; i++)
524		if (min_uA <= info->ilimsels[i] &&
525		    max_uA >= info->ilimsels[i])
526			break;
527
528	if (i >= info->n_ilimsels)
529		return -EINVAL;
530
531	return write_field(hw, &info->ilimsel, i);
532}
533
534static int get_current_limit(struct regulator_dev *rdev)
535{
536	const struct supply_info *info;
537	struct tps6524x *hw;
538	int ret;
539
540	hw	= rdev_get_drvdata(rdev);
541	info	= &supply_info[rdev_get_id(rdev)];
542
543	if (info->flags & FIXED_ILIMSEL)
544		return info->fixed_ilimsel;
545
546	ret = read_field(hw, &info->ilimsel);
547	if (ret < 0)
548		return ret;
549	if (WARN_ON(ret >= info->n_ilimsels))
550		return -EIO;
551
552	return info->ilimsels[ret];
553}
554
555static int enable_supply(struct regulator_dev *rdev)
556{
557	const struct supply_info *info;
558	struct tps6524x *hw;
559
560	hw	= rdev_get_drvdata(rdev);
561	info	= &supply_info[rdev_get_id(rdev)];
562
563	return write_field(hw, &info->enable, 1);
564}
565
566static int disable_supply(struct regulator_dev *rdev)
567{
568	const struct supply_info *info;
569	struct tps6524x *hw;
570
571	hw	= rdev_get_drvdata(rdev);
572	info	= &supply_info[rdev_get_id(rdev)];
573
574	return write_field(hw, &info->enable, 0);
575}
576
577static int is_supply_enabled(struct regulator_dev *rdev)
578{
579	const struct supply_info *info;
580	struct tps6524x *hw;
581
582	hw	= rdev_get_drvdata(rdev);
583	info	= &supply_info[rdev_get_id(rdev)];
584
585	return read_field(hw, &info->enable);
586}
587
588static struct regulator_ops regulator_ops = {
589	.is_enabled		= is_supply_enabled,
590	.enable			= enable_supply,
591	.disable		= disable_supply,
592	.get_voltage		= get_voltage,
593	.set_voltage		= set_voltage,
594	.list_voltage		= list_voltage,
595	.set_current_limit	= set_current_limit,
596	.get_current_limit	= get_current_limit,
597};
598
599static int pmic_remove(struct spi_device *spi)
600{
601	struct tps6524x *hw = spi_get_drvdata(spi);
602	int i;
603
604	if (!hw)
605		return 0;
606	for (i = 0; i < N_REGULATORS; i++) {
607		if (hw->rdev[i])
608			regulator_unregister(hw->rdev[i]);
609		hw->rdev[i] = NULL;
610	}
611	spi_set_drvdata(spi, NULL);
612	kfree(hw);
613	return 0;
614}
615
616static int __devinit pmic_probe(struct spi_device *spi)
617{
618	struct tps6524x *hw;
619	struct device *dev = &spi->dev;
620	const struct supply_info *info = supply_info;
621	struct regulator_init_data *init_data;
622	int ret = 0, i;
623
624	init_data = dev->platform_data;
625	if (!init_data) {
626		dev_err(dev, "could not find regulator platform data\n");
627		return -EINVAL;
628	}
629
630	hw = kzalloc(sizeof(struct tps6524x), GFP_KERNEL);
631	if (!hw) {
632		dev_err(dev, "cannot allocate regulator private data\n");
633		return -ENOMEM;
634	}
635	spi_set_drvdata(spi, hw);
636
637	memset(hw, 0, sizeof(struct tps6524x));
638	hw->dev = dev;
639	hw->spi = spi_dev_get(spi);
640	mutex_init(&hw->lock);
641
642	for (i = 0; i < N_REGULATORS; i++, info++, init_data++) {
643		hw->desc[i].name	= info->name;
644		hw->desc[i].id		= i;
645		hw->desc[i].n_voltages	= info->n_voltages;
646		hw->desc[i].ops		= &regulator_ops;
647		hw->desc[i].type	= REGULATOR_VOLTAGE;
648		hw->desc[i].owner	= THIS_MODULE;
649
650		if (info->flags & FIXED_VOLTAGE)
651			hw->desc[i].n_voltages = 1;
652
653		hw->rdev[i] = regulator_register(&hw->desc[i], dev,
654						 init_data, hw, NULL);
655		if (IS_ERR(hw->rdev[i])) {
656			ret = PTR_ERR(hw->rdev[i]);
657			hw->rdev[i] = NULL;
658			goto fail;
659		}
660	}
661
662	return 0;
663
664fail:
665	pmic_remove(spi);
666	return ret;
667}
668
669static struct spi_driver pmic_driver = {
670	.probe		= pmic_probe,
671	.remove		= __devexit_p(pmic_remove),
672	.driver		= {
673		.name	= "tps6524x",
674		.owner	= THIS_MODULE,
675	},
676};
677
678static int __init pmic_driver_init(void)
679{
680	return spi_register_driver(&pmic_driver);
681}
682module_init(pmic_driver_init);
683
684static void __exit pmic_driver_exit(void)
685{
686	spi_unregister_driver(&pmic_driver);
687}
688module_exit(pmic_driver_exit);
689
690MODULE_DESCRIPTION("TPS6524X PMIC Driver");
691MODULE_AUTHOR("Cyril Chemparathy");
692MODULE_LICENSE("GPL");
693MODULE_ALIAS("spi:tps6524x");
694