Loading...
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 = ∈
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 = ®ulator_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);
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");
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 = ∈
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_sel(struct regulator_dev *rdev, unsigned selector)
462{
463 const struct supply_info *info;
464 struct tps6524x *hw;
465
466 hw = rdev_get_drvdata(rdev);
467 info = &supply_info[rdev_get_id(rdev)];
468
469 if (info->flags & FIXED_VOLTAGE)
470 return -EINVAL;
471
472 return write_field(hw, &info->voltage, selector);
473}
474
475static int get_voltage_sel(struct regulator_dev *rdev)
476{
477 const struct supply_info *info;
478 struct tps6524x *hw;
479 int ret;
480
481 hw = rdev_get_drvdata(rdev);
482 info = &supply_info[rdev_get_id(rdev)];
483
484 if (info->flags & FIXED_VOLTAGE)
485 return 0;
486
487 ret = read_field(hw, &info->voltage);
488 if (ret < 0)
489 return ret;
490 if (WARN_ON(ret >= info->n_voltages))
491 return -EIO;
492
493 return ret;
494}
495
496static int set_current_limit(struct regulator_dev *rdev, int min_uA,
497 int max_uA)
498{
499 const struct supply_info *info;
500 struct tps6524x *hw;
501 int i;
502
503 hw = rdev_get_drvdata(rdev);
504 info = &supply_info[rdev_get_id(rdev)];
505
506 if (info->flags & FIXED_ILIMSEL)
507 return -EINVAL;
508
509 for (i = 0; i < info->n_ilimsels; i++)
510 if (min_uA <= info->ilimsels[i] &&
511 max_uA >= info->ilimsels[i])
512 break;
513
514 if (i >= info->n_ilimsels)
515 return -EINVAL;
516
517 return write_field(hw, &info->ilimsel, i);
518}
519
520static int get_current_limit(struct regulator_dev *rdev)
521{
522 const struct supply_info *info;
523 struct tps6524x *hw;
524 int ret;
525
526 hw = rdev_get_drvdata(rdev);
527 info = &supply_info[rdev_get_id(rdev)];
528
529 if (info->flags & FIXED_ILIMSEL)
530 return info->fixed_ilimsel;
531
532 ret = read_field(hw, &info->ilimsel);
533 if (ret < 0)
534 return ret;
535 if (WARN_ON(ret >= info->n_ilimsels))
536 return -EIO;
537
538 return info->ilimsels[ret];
539}
540
541static int enable_supply(struct regulator_dev *rdev)
542{
543 const struct supply_info *info;
544 struct tps6524x *hw;
545
546 hw = rdev_get_drvdata(rdev);
547 info = &supply_info[rdev_get_id(rdev)];
548
549 return write_field(hw, &info->enable, 1);
550}
551
552static int disable_supply(struct regulator_dev *rdev)
553{
554 const struct supply_info *info;
555 struct tps6524x *hw;
556
557 hw = rdev_get_drvdata(rdev);
558 info = &supply_info[rdev_get_id(rdev)];
559
560 return write_field(hw, &info->enable, 0);
561}
562
563static int is_supply_enabled(struct regulator_dev *rdev)
564{
565 const struct supply_info *info;
566 struct tps6524x *hw;
567
568 hw = rdev_get_drvdata(rdev);
569 info = &supply_info[rdev_get_id(rdev)];
570
571 return read_field(hw, &info->enable);
572}
573
574static struct regulator_ops regulator_ops = {
575 .is_enabled = is_supply_enabled,
576 .enable = enable_supply,
577 .disable = disable_supply,
578 .get_voltage_sel = get_voltage_sel,
579 .set_voltage_sel = set_voltage_sel,
580 .list_voltage = list_voltage,
581 .set_current_limit = set_current_limit,
582 .get_current_limit = get_current_limit,
583};
584
585static int pmic_remove(struct spi_device *spi)
586{
587 struct tps6524x *hw = spi_get_drvdata(spi);
588 int i;
589
590 if (!hw)
591 return 0;
592 for (i = 0; i < N_REGULATORS; i++) {
593 if (hw->rdev[i])
594 regulator_unregister(hw->rdev[i]);
595 hw->rdev[i] = NULL;
596 }
597 spi_set_drvdata(spi, NULL);
598 return 0;
599}
600
601static int __devinit pmic_probe(struct spi_device *spi)
602{
603 struct tps6524x *hw;
604 struct device *dev = &spi->dev;
605 const struct supply_info *info = supply_info;
606 struct regulator_init_data *init_data;
607 struct regulator_config config = { };
608 int ret = 0, i;
609
610 init_data = dev->platform_data;
611 if (!init_data) {
612 dev_err(dev, "could not find regulator platform data\n");
613 return -EINVAL;
614 }
615
616 hw = devm_kzalloc(&spi->dev, sizeof(struct tps6524x), GFP_KERNEL);
617 if (!hw) {
618 dev_err(dev, "cannot allocate regulator private data\n");
619 return -ENOMEM;
620 }
621 spi_set_drvdata(spi, hw);
622
623 memset(hw, 0, sizeof(struct tps6524x));
624 hw->dev = dev;
625 hw->spi = spi_dev_get(spi);
626 mutex_init(&hw->lock);
627
628 for (i = 0; i < N_REGULATORS; i++, info++, init_data++) {
629 hw->desc[i].name = info->name;
630 hw->desc[i].id = i;
631 hw->desc[i].n_voltages = info->n_voltages;
632 hw->desc[i].ops = ®ulator_ops;
633 hw->desc[i].type = REGULATOR_VOLTAGE;
634 hw->desc[i].owner = THIS_MODULE;
635
636 if (info->flags & FIXED_VOLTAGE)
637 hw->desc[i].n_voltages = 1;
638
639 config.dev = dev;
640 config.init_data = init_data;
641 config.driver_data = hw;
642
643 hw->rdev[i] = regulator_register(&hw->desc[i], &config);
644 if (IS_ERR(hw->rdev[i])) {
645 ret = PTR_ERR(hw->rdev[i]);
646 hw->rdev[i] = NULL;
647 goto fail;
648 }
649 }
650
651 return 0;
652
653fail:
654 pmic_remove(spi);
655 return ret;
656}
657
658static struct spi_driver pmic_driver = {
659 .probe = pmic_probe,
660 .remove = __devexit_p(pmic_remove),
661 .driver = {
662 .name = "tps6524x",
663 .owner = THIS_MODULE,
664 },
665};
666
667module_spi_driver(pmic_driver);
668
669MODULE_DESCRIPTION("TPS6524X PMIC Driver");
670MODULE_AUTHOR("Cyril Chemparathy");
671MODULE_LICENSE("GPL");
672MODULE_ALIAS("spi:tps6524x");