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