1 /* drivers/regulator/rk2818_lp8725.c
3 * Copyright (C) 2010 ROCKCHIP, Inc.
5 * This software is licensed under the terms of the GNU General Public
6 * License version 2, as published by the Free Software Foundation, and
7 * may be copied, distributed, and modified under those terms.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
15 /*******************************************************************/
16 /* COPYRIGHT (C) ROCK-CHIPS FUZHOU . ALL RIGHTS RESERVED. */
17 /*******************************************************************
18 FILE : rk2818_lp8725.c
19 DESC : LP8725 PMIC driver
25 ********************************************************************/
28 #include <linux/bug.h>
29 #include <linux/err.h>
30 #include <linux/i2c.h>
31 #include <linux/kernel.h>
32 #include <linux/regulator/driver.h>
33 #include <linux/regulator/rk2818_lp8725.h>
37 #define DBG(x...) printk(KERN_INFO x)
42 #define DBG_INFO(x...) printk(KERN_INFO x)
44 #define DBG_INFO(x...)
53 struct i2c_client *i2c;
55 struct regulator_dev **rdev;
58 static u8 lp8725_reg_read(struct lp8725 *lp8725, u8 reg);
59 static int lp8725_set_bits(struct lp8725 *lp8725, u8 reg, u16 mask, u16 val);
63 #define LP8725_BUCK_VOL_ENABLE_REG 0x00
64 #define LP8725_BUCK1_BASE 0x08
65 #define LP8725_BUCK2_BASE 0x0A
67 const static int buck_base_addr[] = {
74 #define LP8725_BUCK_TARGET_VOL1_REG(x) (buck_base_addr[x])
75 #define LP8725_BUCK_TARGET_VOL2_REG(x) (buck_base_addr[x]+1)
77 const static int buck_voltage_map[] = {
78 800, 850, 900, 950, 1000, 1050, 1100, 1150,
79 1200, 1250, 1300, 1350, 1400, 1500, 1600, 1700,
80 1750, 1800, 1850, 1900, 2000, 2100, 2200, 2300,
81 2400, 2500, 2600, 2700, 2800, 2850, 2900, 3000,
84 #define BUCK_TARGET_VOL_MASK 0x1f
85 #define BUCK_TARGET_VOL_MIN_IDX 0x00
86 #define BUCK_TARGET_VOL_MAX_IDX 0x1f
90 #define LP8725_LDO_ENABLE_REG 0x0d
91 #define LP8725_LDO_VOL_CONTR_BASE 0x01
93 #define LP8725_LDO_VOL_CONTR_REG(x) (LP8725_LDO_VOL_CONTR_BASE + x)
95 const static int ldo_voltage_map[] = {
96 1200, 1250, 1300, 1350, 1400, 1450, 1500, 1550,
97 1600, 1650, 1700, 1750, 1800, 1850, 1900, 2000,
98 2100, 2200, 2300, 2400, 2500, 2600, 2650, 2700,
99 2750, 2800, 2850, 2900, 2950, 3000, 3100, 3300,
102 #define LDO_VOL_CONTR_MASK 0x1f
103 #define LDO_VOL_MIN_IDX 0x00
104 #define LDO_VOL_MAX_IDX 0x1f
106 #define LP8725_LILO_ENABLE_REG 0x0d
107 #define LP8725_LILO_VOL_CONTR_BASE 0x06
109 #define LP8725_LILO_VOL_CONTR_REG(x) (LP8725_LILO_VOL_CONTR_BASE + x)
111 const static int lilo_voltage_map[] = {
112 800, 850, 900, 950, 1000, 1050, 1100, 1150,
113 1200, 1250, 1300, 1350, 1400, 1500, 1600, 1700,
114 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500,
115 2600, 2700, 2800, 2850, 2900, 3000, 3100, 3300,
118 #define LILO_VOL_CONTR_MASK 0x1f
119 #define LILO_VOL_MIN_IDX 0x00
120 #define LILO_VOL_MAX_IDX 0x1f
123 static int lp8725_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
125 return 1000 * ldo_voltage_map[index];
128 static int lp8725_ldo_is_enabled(struct regulator_dev *dev)
130 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
131 int ldo = rdev_get_id(dev) - LP8725_LDO1;
132 u16 mask = 1 << (ldo);
135 val = lp8725_reg_read(lp8725, LP8725_LDO_ENABLE_REG);
136 return (val & mask) != 0;
139 static int lp8725_ldo_enable(struct regulator_dev *dev)
141 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
142 int ldo = rdev_get_id(dev) - LP8725_LDO1;
143 u16 mask = 1 << (ldo);
144 return lp8725_set_bits(lp8725, LP8725_LDO_ENABLE_REG, mask, mask);
147 static int lp8725_ldo_disable(struct regulator_dev *dev)
149 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
150 int ldo = rdev_get_id(dev) - LP8725_LDO1;
151 u16 mask = 1 << (ldo);
152 return lp8725_set_bits(lp8725, LP8725_LDO_ENABLE_REG, mask, 0);
155 static int lp8725_ldo_get_voltage(struct regulator_dev *dev)
157 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
158 int ldo = rdev_get_id(dev) - LP8725_LDO1;
162 reg = lp8725_reg_read(lp8725, LP8725_LDO_VOL_CONTR_REG(ldo));
163 reg &= BUCK_TARGET_VOL_MASK;
165 val = 1000 * ldo_voltage_map[reg];
169 static int lp8725_ldo_set_voltage(struct regulator_dev *dev,
170 int min_uV, int max_uV)
172 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
173 int ldo = rdev_get_id(dev) - LP8725_LDO1;
174 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
175 const int *vol_map = ldo_voltage_map;
178 if (min_vol < vol_map[LDO_VOL_MIN_IDX] ||
179 min_vol > vol_map[LDO_VOL_MAX_IDX])
182 for (val = LDO_VOL_MIN_IDX; val <= LDO_VOL_MAX_IDX; val++)
183 if (vol_map[val] >= min_vol)
186 if (vol_map[val] > max_vol)
189 DBG("***run in %s %d reg=0x%x val=0x%x",__FUNCTION__,__LINE__,LP8725_LDO_VOL_CONTR_REG(ldo),val);
191 return lp8725_set_bits(lp8725, LP8725_LDO_VOL_CONTR_REG(ldo),
192 LDO_VOL_CONTR_MASK, val);
195 static struct regulator_ops lp8725_ldo_ops = {
196 .list_voltage = lp8725_ldo_list_voltage,
197 .is_enabled = lp8725_ldo_is_enabled,
198 .enable = lp8725_ldo_enable,
199 .disable = lp8725_ldo_disable,
200 .get_voltage = lp8725_ldo_get_voltage,
201 .set_voltage = lp8725_ldo_set_voltage,
204 static int lp8725_lilo_list_voltage(struct regulator_dev *dev, unsigned index)
206 return 1000 * lilo_voltage_map[index];
209 static int lp8725_lilo_is_enabled(struct regulator_dev *dev)
211 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
212 int lilo = rdev_get_id(dev) - LP8725_LILO1;
213 u16 mask = 1 << (lilo+4);
216 val = lp8725_reg_read(lp8725, LP8725_LILO_ENABLE_REG);
217 return (val & mask) != 0;
220 static int lp8725_lilo_enable(struct regulator_dev *dev)
222 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
223 int lilo = rdev_get_id(dev) - LP8725_LILO1;
224 u16 mask = 1 << (lilo+4);
226 return lp8725_set_bits(lp8725, LP8725_LILO_ENABLE_REG, mask, mask);
229 static int lp8725_lilo_disable(struct regulator_dev *dev)
231 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
232 int lilo = rdev_get_id(dev) - LP8725_LILO1;
233 u16 mask = 1 << (lilo+4);
235 return lp8725_set_bits(lp8725, LP8725_LILO_ENABLE_REG, mask, 0);
238 static int lp8725_lilo_get_voltage(struct regulator_dev *dev)
240 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
241 int lilo = rdev_get_id(dev) - LP8725_LILO1;
245 reg = lp8725_reg_read(lp8725, LP8725_LILO_VOL_CONTR_REG(lilo));
246 reg &= BUCK_TARGET_VOL_MASK;
248 val = 1000 * lilo_voltage_map[reg];
252 static int lp8725_lilo_set_voltage(struct regulator_dev *dev,
253 int min_uV, int max_uV)
255 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
256 int lilo = rdev_get_id(dev) - LP8725_LILO1;
257 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
258 const int *vol_map = lilo_voltage_map;
261 if (min_vol < vol_map[LILO_VOL_MIN_IDX] ||
262 min_vol > vol_map[LILO_VOL_MAX_IDX])
265 for (val = LILO_VOL_MIN_IDX; val <= LILO_VOL_MAX_IDX; val++)
266 if (vol_map[val] >= min_vol)
269 if (vol_map[val] > max_vol)
272 return lp8725_set_bits(lp8725, LP8725_LILO_VOL_CONTR_REG(lilo),
273 LILO_VOL_CONTR_MASK, val);
276 static struct regulator_ops lp8725_lilo_ops = {
277 .list_voltage = lp8725_lilo_list_voltage,
278 .is_enabled = lp8725_lilo_is_enabled,
279 .enable = lp8725_lilo_enable,
280 .disable = lp8725_lilo_disable,
281 .get_voltage = lp8725_lilo_get_voltage,
282 .set_voltage = lp8725_lilo_set_voltage,
285 static int lp8725_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
287 return 1000 * buck_voltage_map[index];
290 static int lp8725_dcdc_is_enabled(struct regulator_dev *dev)
292 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
293 int buck = rdev_get_id(dev) - LP8725_DCDC1;
294 u16 mask = 1 << (buck * 2);
297 val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
298 return (val & mask) != 0;
301 static int lp8725_dcdc_enable(struct regulator_dev *dev)
303 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
304 int buck = rdev_get_id(dev) - LP8725_DCDC1;
305 u16 mask = 1 << (buck * 2);
307 return lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
310 static int lp8725_dcdc_disable(struct regulator_dev *dev)
312 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
313 int buck = rdev_get_id(dev) - LP8725_DCDC1;
314 u16 mask = 1 << (buck * 2);
316 return lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, 0);
319 static int lp8725_dcdc_get_voltage(struct regulator_dev *dev)
321 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
322 int buck = rdev_get_id(dev) - LP8725_DCDC1;
326 reg = lp8725_reg_read(lp8725, LP8725_BUCK_TARGET_VOL1_REG(buck));
327 reg &= BUCK_TARGET_VOL_MASK;
329 val = 1000 * buck_voltage_map[reg];
334 static int lp8725_dcdc_set_voltage(struct regulator_dev *dev,
335 int min_uV, int max_uV)
337 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
338 int buck = rdev_get_id(dev) - LP8725_DCDC1;
339 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
340 const int *vol_map = buck_voltage_map;
344 if (min_vol < vol_map[BUCK_TARGET_VOL_MIN_IDX] ||
345 min_vol > vol_map[BUCK_TARGET_VOL_MAX_IDX])
348 for (val = BUCK_TARGET_VOL_MIN_IDX; val <= BUCK_TARGET_VOL_MAX_IDX;
350 if (vol_map[val] >= min_vol)
353 if (vol_map[val] > max_vol)
356 ret = lp8725_set_bits(lp8725, LP8725_BUCK_TARGET_VOL1_REG(buck),
357 BUCK_TARGET_VOL_MASK, val);
361 ret = lp8725_set_bits(lp8725, LP8725_BUCK_TARGET_VOL2_REG(buck),
362 BUCK_TARGET_VOL_MASK, val);
369 static struct regulator_ops lp8725_dcdc_ops = {
370 .list_voltage = lp8725_dcdc_list_voltage,
371 .is_enabled = lp8725_dcdc_is_enabled,
372 .enable = lp8725_dcdc_enable,
373 .disable = lp8725_dcdc_disable,
374 .get_voltage = lp8725_dcdc_get_voltage,
375 .set_voltage = lp8725_dcdc_set_voltage,
378 static struct regulator_desc regulators[] = {
382 .ops = &lp8725_ldo_ops,
383 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
384 .type = REGULATOR_VOLTAGE,
385 .owner = THIS_MODULE,
390 .ops = &lp8725_ldo_ops,
391 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
392 .type = REGULATOR_VOLTAGE,
393 .owner = THIS_MODULE,
398 .ops = &lp8725_ldo_ops,
399 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
400 .type = REGULATOR_VOLTAGE,
401 .owner = THIS_MODULE,
406 .ops = &lp8725_ldo_ops,
407 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
408 .type = REGULATOR_VOLTAGE,
409 .owner = THIS_MODULE,
414 .ops = &lp8725_ldo_ops,
415 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
416 .type = REGULATOR_VOLTAGE,
417 .owner = THIS_MODULE,
422 .ops = &lp8725_lilo_ops,
423 .n_voltages = ARRAY_SIZE(lilo_voltage_map),
424 .type = REGULATOR_VOLTAGE,
425 .owner = THIS_MODULE,
430 .ops = &lp8725_lilo_ops,
431 .n_voltages = ARRAY_SIZE(lilo_voltage_map),
432 .type = REGULATOR_VOLTAGE,
433 .owner = THIS_MODULE,
438 .ops = &lp8725_dcdc_ops,
439 .n_voltages = ARRAY_SIZE(buck_voltage_map),
440 .type = REGULATOR_VOLTAGE,
441 .owner = THIS_MODULE,
446 .ops = &lp8725_dcdc_ops,
447 .n_voltages = ARRAY_SIZE(buck_voltage_map),
448 .type = REGULATOR_VOLTAGE,
449 .owner = THIS_MODULE,
453 static int lp8725_i2c_read(struct i2c_client *i2c, char reg, int count, u16 *dest)
456 struct i2c_adapter *adap;
457 struct i2c_msg msgs[2];
467 msgs[0].addr = i2c->addr;
469 msgs[0].flags = i2c->flags;
471 msgs[0].scl_rate = 200*1000;
474 msgs[1].addr = i2c->addr;
475 msgs[1].flags = i2c->flags | I2C_M_RD;
477 msgs[1].scl_rate = 200*1000;
478 ret = i2c_transfer(adap, msgs, 2);
480 DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
485 static int lp8725_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
489 struct i2c_adapter *adap;
502 msg.addr = i2c->addr;
503 msg.buf = &tx_buf[0];
505 msg.flags = i2c->flags;
506 msg.scl_rate = 200*1000;
508 ret = i2c_transfer(adap, &msg, 1);
512 static u8 lp8725_reg_read(struct lp8725 *lp8725, u8 reg)
516 mutex_lock(&lp8725->io_lock);
518 lp8725_i2c_read(lp8725->i2c, reg, 1, &val);
520 DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
522 mutex_unlock(&lp8725->io_lock);
527 static int lp8725_set_bits(struct lp8725 *lp8725, u8 reg, u16 mask, u16 val)
532 mutex_lock(&lp8725->io_lock);
534 ret = lp8725_i2c_read(lp8725->i2c, reg, 1, &tmp);
535 tmp = (tmp & ~mask) | val;
537 ret = lp8725_i2c_write(lp8725->i2c, reg, 1, tmp);
538 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
540 mutex_unlock(&lp8725->io_lock);
546 static int lp8725_set_init(void)
550 struct regulator *ldo1,*ldo2,*ldo3,*ldo4,*ldo5;
551 struct regulator *lilo1,*lilo2;
552 struct regulator *buck1,*buck2;
554 DBG_INFO("***run in %s %d ",__FUNCTION__,__LINE__);
557 DBG_INFO("***ldo1 vcc init\n");
558 ldo1 = regulator_get(NULL, "ldo1");
559 regulator_enable(ldo1);
560 // regulator_set_voltage(ldo1,2500000,2500000);
561 tmp = regulator_get_voltage(ldo1);
562 DBG_INFO("***regulator_set_init: ldo1 vcc =%d\n",tmp);
565 DBG_INFO("***ldo2 vcc init\n");
566 ldo2 = regulator_get(NULL, "ldo2");
567 regulator_enable(ldo2);
568 // regulator_set_voltage(ldo2,3000000,3000000);
569 tmp = regulator_get_voltage(ldo2);
570 DBG_INFO("***regulator_set_init: ldo2 vcc =%d\n",tmp);
573 DBG_INFO("***ldo3 vcc init\n");
574 ldo3 = regulator_get(NULL, "ldo3");
575 regulator_enable(ldo3);
576 // regulator_set_voltage(ldo3,3000000,3000000);
577 tmp = regulator_get_voltage(ldo3);
578 DBG_INFO("***regulator_set_init: ldo3 vcc =%d\n",tmp);
581 DBG_INFO("***ldo4 vcc init\n");
582 ldo4 = regulator_get(NULL, "ldo4");
583 regulator_enable(ldo4);
584 // regulator_set_voltage(ldo4,1900000,1900000);
585 tmp = regulator_get_voltage(ldo4);
586 DBG_INFO("***regulator_set_init: ldo4 vcc =%d\n",tmp);
589 DBG_INFO("***ldo5 vcc init\n");
590 ldo5 = regulator_get(NULL, "ldo5");
591 regulator_enable(ldo5);
592 regulator_set_voltage(ldo5,1800000,1800000);
593 tmp = regulator_get_voltage(ldo5);
594 DBG_INFO("***regulator_set_init: ldo5 vcc =%d\n",tmp);
597 DBG_INFO("***lilo1 vcc init\n");
598 lilo1 = regulator_get(NULL, "lilo1");
599 regulator_enable(lilo1);
600 // regulator_set_voltage(lilo1,3300000,3300000);
601 tmp = regulator_get_voltage(lilo1);
602 DBG_INFO("***regulator_set_init: lilo1 vcc =%d\n",tmp);
605 DBG_INFO("***lilo2 vcc init\n");
606 lilo2 = regulator_get(NULL, "lilo2");
607 regulator_enable(lilo2);
608 // regulator_set_voltage(lilo2,3300000,3300000);
609 tmp = regulator_get_voltage(lilo2);
610 DBG_INFO("***regulator_set_init: lilo2 vcc =%d\n",tmp);
613 DBG_INFO("***buck1 vcc init\n");
614 buck1 = regulator_get(NULL, "vdd12");
615 // regulator_set_voltage(buck1,1200000,1200000);
616 tmp = regulator_get_voltage(buck1);
617 DBG_INFO("***regulator_set_init: buck1 vcc =%d\n",tmp);
620 DBG_INFO("***buck2 vcc init\n");
621 buck2 = regulator_get(NULL, "vccdr");
622 // regulator_set_voltage(buck1,1800000,1800000);
623 tmp = regulator_get_voltage(buck2);
624 DBG_INFO("***regulator_set_init: buck2 vcc =%d\n",tmp);
630 static int setup_regulators(struct lp8725 *lp8725, struct lp8725_platform_data *pdata)
633 int num_regulators = pdata->num_regulators;
634 lp8725->num_regulators = num_regulators;
635 lp8725->rdev = kzalloc(sizeof(struct regulator_dev *) * num_regulators,
638 /* Instantiate the regulators */
639 for (i = 0; i < num_regulators; i++) {
640 int id = pdata->regulators[i].id;
641 lp8725->rdev[i] = regulator_register(®ulators[id],
642 lp8725->dev, pdata->regulators[i].initdata, lp8725);
644 err = IS_ERR(lp8725->rdev[i]);
646 dev_err(lp8725->dev, "regulator init failed: %d\n",
654 for (i = 0; i < num_regulators; i++)
656 regulator_unregister(lp8725->rdev[i]);
662 static int __devinit lp8725_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
664 struct lp8725 *lp8725;
665 struct lp8725_platform_data *pdata = i2c->dev.platform_data;
668 lp8725 = kzalloc(sizeof(struct lp8725), GFP_KERNEL);
669 if (lp8725 == NULL) {
675 lp8725->dev = &i2c->dev;
676 i2c_set_clientdata(i2c, lp8725);
678 mutex_init(&lp8725->io_lock);
681 ret = setup_regulators(lp8725, pdata);
685 dev_warn(lp8725->dev, "No platform init data supplied\n");
695 static int __devexit lp8725_i2c_remove(struct i2c_client *i2c)
697 struct lp8725 *lp8725 = i2c_get_clientdata(i2c);
699 for (i = 0; i < lp8725->num_regulators; i++)
701 regulator_unregister(lp8725->rdev[i]);
703 i2c_set_clientdata(i2c, NULL);
709 static const struct i2c_device_id lp8725_i2c_id[] = {
714 MODULE_DEVICE_TABLE(i2c, lp8725_i2c_id);
716 static struct i2c_driver lp8725_i2c_driver = {
719 .owner = THIS_MODULE,
721 .probe = lp8725_i2c_probe,
722 .remove = __devexit_p(lp8725_i2c_remove),
723 .id_table = lp8725_i2c_id,
726 static int __init lp8725_module_init(void)
730 ret = i2c_add_driver(&lp8725_i2c_driver);
732 pr_err("Failed to register I2C driver: %d\n", ret);
736 module_init(lp8725_module_init);
738 static void __exit lp8725_module_exit(void)
740 i2c_del_driver(&lp8725_i2c_driver);
742 module_exit(lp8725_module_exit);
744 MODULE_LICENSE("GPL");
745 MODULE_AUTHOR("cym <cym@rock-chips.com>");
746 MODULE_DESCRIPTION("LP8725 PMIC driver");