2 * Regulator driver for National Semiconductors LP3972 PMIC chip
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
12 #include <linux/bug.h>
13 #include <linux/err.h>
14 #include <linux/i2c.h>
15 #include <linux/module.h>
16 #include <linux/kernel.h>
17 #include <linux/regulator/driver.h>
18 #include <linux/regulator/lp3972.h>
19 #include <linux/slab.h>
24 struct i2c_client *i2c;
26 struct regulator_dev **rdev;
29 /* LP3972 Control Registers */
30 #define LP3972_SCR_REG 0x07
31 #define LP3972_OVER1_REG 0x10
32 #define LP3972_OVSR1_REG 0x11
33 #define LP3972_OVER2_REG 0x12
34 #define LP3972_OVSR2_REG 0x13
35 #define LP3972_VCC1_REG 0x20
36 #define LP3972_ADTV1_REG 0x23
37 #define LP3972_ADTV2_REG 0x24
38 #define LP3972_AVRC_REG 0x25
39 #define LP3972_CDTC1_REG 0x26
40 #define LP3972_CDTC2_REG 0x27
41 #define LP3972_SDTV1_REG 0x29
42 #define LP3972_SDTV2_REG 0x2A
43 #define LP3972_MDTV1_REG 0x32
44 #define LP3972_MDTV2_REG 0x33
45 #define LP3972_L2VCR_REG 0x39
46 #define LP3972_L34VCR_REG 0x3A
47 #define LP3972_SCR1_REG 0x80
48 #define LP3972_SCR2_REG 0x81
49 #define LP3972_OEN3_REG 0x82
50 #define LP3972_OSR3_REG 0x83
51 #define LP3972_LOER4_REG 0x84
52 #define LP3972_B2TV_REG 0x85
53 #define LP3972_B3TV_REG 0x86
54 #define LP3972_B32RC_REG 0x87
55 #define LP3972_ISRA_REG 0x88
56 #define LP3972_BCCR_REG 0x89
57 #define LP3972_II1RR_REG 0x8E
58 #define LP3972_II2RR_REG 0x8F
60 #define LP3972_SYS_CONTROL1_REG LP3972_SCR1_REG
61 /* System control register 1 initial value,
62 * bits 5, 6 and 7 are EPROM programmable */
63 #define SYS_CONTROL1_INIT_VAL 0x02
64 #define SYS_CONTROL1_INIT_MASK 0x1F
66 #define LP3972_VOL_CHANGE_REG LP3972_VCC1_REG
67 #define LP3972_VOL_CHANGE_FLAG_GO 0x01
68 #define LP3972_VOL_CHANGE_FLAG_MASK 0x03
70 /* LDO output enable mask */
71 #define LP3972_OEN3_L1EN BIT(0)
72 #define LP3972_OVER2_LDO2_EN BIT(2)
73 #define LP3972_OVER2_LDO3_EN BIT(3)
74 #define LP3972_OVER2_LDO4_EN BIT(4)
75 #define LP3972_OVER1_S_EN BIT(2)
77 static const unsigned int ldo1_voltage_map[] = {
78 1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000,
79 1900000, 1925000, 1950000, 1975000, 2000000,
82 static const unsigned int ldo23_voltage_map[] = {
83 1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
84 2600000, 2700000, 2800000, 2900000, 3000000, 3100000, 3200000, 3300000,
87 static const unsigned int ldo4_voltage_map[] = {
88 1000000, 1050000, 1100000, 1150000, 1200000, 1250000, 1300000, 1350000,
89 1400000, 1500000, 1800000, 1900000, 2500000, 2800000, 3000000, 3300000,
92 static const unsigned int ldo5_voltage_map[] = {
93 0, 0, 0, 0, 0, 850000, 875000, 900000,
94 925000, 950000, 975000, 1000000, 1025000, 1050000, 1075000, 1100000,
95 1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000,
96 1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000,
99 static const unsigned int buck1_voltage_map[] = {
100 725000, 750000, 775000, 800000, 825000, 850000, 875000, 900000,
101 925000, 950000, 975000, 1000000, 1025000, 1050000, 1075000, 1100000,
102 1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000,
103 1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000,
106 static const unsigned int buck23_voltage_map[] = {
107 0, 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000,
108 1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
109 1550000, 1600000, 1650000, 1700000, 1800000, 1900000, 2500000, 2800000,
113 static const int ldo_output_enable_mask[] = {
115 LP3972_OVER2_LDO2_EN,
116 LP3972_OVER2_LDO3_EN,
117 LP3972_OVER2_LDO4_EN,
121 static const int ldo_output_enable_addr[] = {
129 static const int ldo_vol_ctl_addr[] = {
137 static const int buck_vol_enable_addr[] = {
143 static const int buck_base_addr[] = {
149 #define LP3972_LDO_OUTPUT_ENABLE_MASK(x) (ldo_output_enable_mask[x])
150 #define LP3972_LDO_OUTPUT_ENABLE_REG(x) (ldo_output_enable_addr[x])
152 /* LDO voltage control registers shift:
153 LP3972_LDO1 -> 0, LP3972_LDO2 -> 4
154 LP3972_LDO3 -> 0, LP3972_LDO4 -> 4
157 #define LP3972_LDO_VOL_CONTR_SHIFT(x) (((x) & 1) << 2)
158 #define LP3972_LDO_VOL_CONTR_REG(x) (ldo_vol_ctl_addr[x])
159 #define LP3972_LDO_VOL_CHANGE_SHIFT(x) ((x) ? 4 : 6)
161 #define LP3972_LDO_VOL_MASK(x) (((x) % 4) ? 0x0f : 0x1f)
162 #define LP3972_LDO_VOL_MIN_IDX(x) (((x) == 4) ? 0x05 : 0x00)
163 #define LP3972_LDO_VOL_MAX_IDX(x) ((x) ? (((x) == 4) ? 0x1f : 0x0f) : 0x0c)
165 #define LP3972_BUCK_VOL_ENABLE_REG(x) (buck_vol_enable_addr[x])
166 #define LP3972_BUCK_VOL1_REG(x) (buck_base_addr[x])
167 #define LP3972_BUCK_VOL_MASK 0x1f
169 static int lp3972_i2c_read(struct i2c_client *i2c, char reg, int count,
176 ret = i2c_smbus_read_byte_data(i2c, reg);
184 static int lp3972_i2c_write(struct i2c_client *i2c, char reg, int count,
189 return i2c_smbus_write_byte_data(i2c, reg, *src);
192 static u8 lp3972_reg_read(struct lp3972 *lp3972, u8 reg)
196 mutex_lock(&lp3972->io_lock);
198 lp3972_i2c_read(lp3972->i2c, reg, 1, &val);
200 dev_dbg(lp3972->dev, "reg read 0x%02x -> 0x%02x\n", (int)reg,
201 (unsigned)val & 0xff);
203 mutex_unlock(&lp3972->io_lock);
208 static int lp3972_set_bits(struct lp3972 *lp3972, u8 reg, u16 mask, u16 val)
213 mutex_lock(&lp3972->io_lock);
215 ret = lp3972_i2c_read(lp3972->i2c, reg, 1, &tmp);
216 tmp = (tmp & ~mask) | val;
218 ret = lp3972_i2c_write(lp3972->i2c, reg, 1, &tmp);
219 dev_dbg(lp3972->dev, "reg write 0x%02x -> 0x%02x\n", (int)reg,
220 (unsigned)val & 0xff);
222 mutex_unlock(&lp3972->io_lock);
227 static int lp3972_ldo_is_enabled(struct regulator_dev *dev)
229 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
230 int ldo = rdev_get_id(dev) - LP3972_LDO1;
231 u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo);
234 val = lp3972_reg_read(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo));
235 return !!(val & mask);
238 static int lp3972_ldo_enable(struct regulator_dev *dev)
240 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
241 int ldo = rdev_get_id(dev) - LP3972_LDO1;
242 u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo);
244 return lp3972_set_bits(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo),
248 static int lp3972_ldo_disable(struct regulator_dev *dev)
250 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
251 int ldo = rdev_get_id(dev) - LP3972_LDO1;
252 u16 mask = LP3972_LDO_OUTPUT_ENABLE_MASK(ldo);
254 return lp3972_set_bits(lp3972, LP3972_LDO_OUTPUT_ENABLE_REG(ldo),
258 static int lp3972_ldo_get_voltage_sel(struct regulator_dev *dev)
260 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
261 int ldo = rdev_get_id(dev) - LP3972_LDO1;
262 u16 mask = LP3972_LDO_VOL_MASK(ldo);
265 reg = lp3972_reg_read(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo));
266 val = (reg >> LP3972_LDO_VOL_CONTR_SHIFT(ldo)) & mask;
271 static int lp3972_ldo_set_voltage_sel(struct regulator_dev *dev,
272 unsigned int selector)
274 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
275 int ldo = rdev_get_id(dev) - LP3972_LDO1;
278 shift = LP3972_LDO_VOL_CONTR_SHIFT(ldo);
279 ret = lp3972_set_bits(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo),
280 LP3972_LDO_VOL_MASK(ldo) << shift, selector << shift);
286 * LDO1 and LDO5 support voltage control by either target voltage1
287 * or target voltage2 register.
288 * We use target voltage1 register for LDO1 and LDO5 in this driver.
289 * We need to update voltage change control register(0x20) to enable
290 * LDO1 and LDO5 to change to their programmed target values.
295 shift = LP3972_LDO_VOL_CHANGE_SHIFT(ldo);
296 ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
297 LP3972_VOL_CHANGE_FLAG_MASK << shift,
298 LP3972_VOL_CHANGE_FLAG_GO << shift);
302 ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
303 LP3972_VOL_CHANGE_FLAG_MASK << shift, 0);
310 static struct regulator_ops lp3972_ldo_ops = {
311 .list_voltage = regulator_list_voltage_table,
312 .is_enabled = lp3972_ldo_is_enabled,
313 .enable = lp3972_ldo_enable,
314 .disable = lp3972_ldo_disable,
315 .get_voltage_sel = lp3972_ldo_get_voltage_sel,
316 .set_voltage_sel = lp3972_ldo_set_voltage_sel,
319 static int lp3972_dcdc_is_enabled(struct regulator_dev *dev)
321 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
322 int buck = rdev_get_id(dev) - LP3972_DCDC1;
323 u16 mask = 1 << (buck * 2);
326 val = lp3972_reg_read(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck));
327 return !!(val & mask);
330 static int lp3972_dcdc_enable(struct regulator_dev *dev)
332 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
333 int buck = rdev_get_id(dev) - LP3972_DCDC1;
334 u16 mask = 1 << (buck * 2);
337 val = lp3972_set_bits(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck),
342 static int lp3972_dcdc_disable(struct regulator_dev *dev)
344 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
345 int buck = rdev_get_id(dev) - LP3972_DCDC1;
346 u16 mask = 1 << (buck * 2);
349 val = lp3972_set_bits(lp3972, LP3972_BUCK_VOL_ENABLE_REG(buck),
354 static int lp3972_dcdc_get_voltage_sel(struct regulator_dev *dev)
356 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
357 int buck = rdev_get_id(dev) - LP3972_DCDC1;
360 reg = lp3972_reg_read(lp3972, LP3972_BUCK_VOL1_REG(buck));
361 reg &= LP3972_BUCK_VOL_MASK;
366 static int lp3972_dcdc_set_voltage_sel(struct regulator_dev *dev,
367 unsigned int selector)
369 struct lp3972 *lp3972 = rdev_get_drvdata(dev);
370 int buck = rdev_get_id(dev) - LP3972_DCDC1;
373 ret = lp3972_set_bits(lp3972, LP3972_BUCK_VOL1_REG(buck),
374 LP3972_BUCK_VOL_MASK, selector);
381 ret = lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
382 LP3972_VOL_CHANGE_FLAG_MASK, LP3972_VOL_CHANGE_FLAG_GO);
386 return lp3972_set_bits(lp3972, LP3972_VOL_CHANGE_REG,
387 LP3972_VOL_CHANGE_FLAG_MASK, 0);
390 static struct regulator_ops lp3972_dcdc_ops = {
391 .list_voltage = regulator_list_voltage_table,
392 .is_enabled = lp3972_dcdc_is_enabled,
393 .enable = lp3972_dcdc_enable,
394 .disable = lp3972_dcdc_disable,
395 .get_voltage_sel = lp3972_dcdc_get_voltage_sel,
396 .set_voltage_sel = lp3972_dcdc_set_voltage_sel,
399 static const struct regulator_desc regulators[] = {
403 .ops = &lp3972_ldo_ops,
404 .n_voltages = ARRAY_SIZE(ldo1_voltage_map),
405 .volt_table = ldo1_voltage_map,
406 .type = REGULATOR_VOLTAGE,
407 .owner = THIS_MODULE,
412 .ops = &lp3972_ldo_ops,
413 .n_voltages = ARRAY_SIZE(ldo23_voltage_map),
414 .volt_table = ldo23_voltage_map,
415 .type = REGULATOR_VOLTAGE,
416 .owner = THIS_MODULE,
421 .ops = &lp3972_ldo_ops,
422 .n_voltages = ARRAY_SIZE(ldo23_voltage_map),
423 .volt_table = ldo23_voltage_map,
424 .type = REGULATOR_VOLTAGE,
425 .owner = THIS_MODULE,
430 .ops = &lp3972_ldo_ops,
431 .n_voltages = ARRAY_SIZE(ldo4_voltage_map),
432 .volt_table = ldo4_voltage_map,
433 .type = REGULATOR_VOLTAGE,
434 .owner = THIS_MODULE,
439 .ops = &lp3972_ldo_ops,
440 .n_voltages = ARRAY_SIZE(ldo5_voltage_map),
441 .volt_table = ldo5_voltage_map,
442 .type = REGULATOR_VOLTAGE,
443 .owner = THIS_MODULE,
448 .ops = &lp3972_dcdc_ops,
449 .n_voltages = ARRAY_SIZE(buck1_voltage_map),
450 .volt_table = buck1_voltage_map,
451 .type = REGULATOR_VOLTAGE,
452 .owner = THIS_MODULE,
457 .ops = &lp3972_dcdc_ops,
458 .n_voltages = ARRAY_SIZE(buck23_voltage_map),
459 .volt_table = buck23_voltage_map,
460 .type = REGULATOR_VOLTAGE,
461 .owner = THIS_MODULE,
466 .ops = &lp3972_dcdc_ops,
467 .n_voltages = ARRAY_SIZE(buck23_voltage_map),
468 .volt_table = buck23_voltage_map,
469 .type = REGULATOR_VOLTAGE,
470 .owner = THIS_MODULE,
474 static int setup_regulators(struct lp3972 *lp3972,
475 struct lp3972_platform_data *pdata)
479 lp3972->num_regulators = pdata->num_regulators;
480 lp3972->rdev = kcalloc(pdata->num_regulators,
481 sizeof(struct regulator_dev *), GFP_KERNEL);
487 /* Instantiate the regulators */
488 for (i = 0; i < pdata->num_regulators; i++) {
489 struct lp3972_regulator_subdev *reg = &pdata->regulators[i];
490 struct regulator_config config = { };
492 config.dev = lp3972->dev;
493 config.init_data = reg->initdata;
494 config.driver_data = lp3972;
496 lp3972->rdev[i] = regulator_register(®ulators[reg->id],
498 if (IS_ERR(lp3972->rdev[i])) {
499 err = PTR_ERR(lp3972->rdev[i]);
500 dev_err(lp3972->dev, "regulator init failed: %d\n",
509 regulator_unregister(lp3972->rdev[i]);
516 static int lp3972_i2c_probe(struct i2c_client *i2c,
517 const struct i2c_device_id *id)
519 struct lp3972 *lp3972;
520 struct lp3972_platform_data *pdata = i2c->dev.platform_data;
525 dev_dbg(&i2c->dev, "No platform init data supplied\n");
529 lp3972 = kzalloc(sizeof(struct lp3972), GFP_KERNEL);
534 lp3972->dev = &i2c->dev;
536 mutex_init(&lp3972->io_lock);
539 ret = lp3972_i2c_read(i2c, LP3972_SYS_CONTROL1_REG, 1, &val);
541 (val & SYS_CONTROL1_INIT_MASK) != SYS_CONTROL1_INIT_VAL) {
543 dev_err(&i2c->dev, "chip reported: val = 0x%x\n", val);
546 dev_err(&i2c->dev, "failed to detect device. ret = %d\n", ret);
550 ret = setup_regulators(lp3972, pdata);
554 i2c_set_clientdata(i2c, lp3972);
562 static int lp3972_i2c_remove(struct i2c_client *i2c)
564 struct lp3972 *lp3972 = i2c_get_clientdata(i2c);
567 for (i = 0; i < lp3972->num_regulators; i++)
568 regulator_unregister(lp3972->rdev[i]);
575 static const struct i2c_device_id lp3972_i2c_id[] = {
579 MODULE_DEVICE_TABLE(i2c, lp3972_i2c_id);
581 static struct i2c_driver lp3972_i2c_driver = {
584 .owner = THIS_MODULE,
586 .probe = lp3972_i2c_probe,
587 .remove = lp3972_i2c_remove,
588 .id_table = lp3972_i2c_id,
591 static int __init lp3972_module_init(void)
593 return i2c_add_driver(&lp3972_i2c_driver);
595 subsys_initcall(lp3972_module_init);
597 static void __exit lp3972_module_exit(void)
599 i2c_del_driver(&lp3972_i2c_driver);
601 module_exit(lp3972_module_exit);
603 MODULE_LICENSE("GPL");
604 MODULE_AUTHOR("Axel Lin <axel.lin@gmail.com>");
605 MODULE_DESCRIPTION("LP3972 PMIC driver");