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
__read_reg(struct tps6524x * hw,int reg)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 = ∈
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
read_reg(struct tps6524x * hw,int reg)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
__write_reg(struct tps6524x * hw,int reg,int val)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
__rmw_reg(struct tps6524x * hw,int reg,int mask,int val)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
rmw_protect(struct tps6524x * hw,int reg,int mask,int val)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
read_field(struct tps6524x * hw,const struct field * field)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
write_field(struct tps6524x * hw,const struct field * field,int val)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
set_voltage_sel(struct regulator_dev * rdev,unsigned selector)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
get_voltage_sel(struct regulator_dev * rdev)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
set_current_limit(struct regulator_dev * rdev,int min_uA,int max_uA)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
get_current_limit(struct regulator_dev * rdev)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
enable_supply(struct regulator_dev * rdev)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
disable_supply(struct regulator_dev * rdev)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
is_supply_enabled(struct regulator_dev * rdev)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
pmic_probe(struct spi_device * spi)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 = ®ulator_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