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>
34 #include <mach/gpio.h>
35 #include <linux/delay.h>
36 #include <mach/iomux.h>
38 //add by robert for reboot notifier
39 #include <linux/notifier.h>
40 #include <linux/reboot.h>
47 #define DBG(x...) printk(KERN_INFO x)
52 #define DBG_INFO(x...) printk(KERN_INFO x)
54 #define DBG_INFO(x...)
63 struct i2c_client *i2c;
65 struct regulator_dev **rdev;
68 static u8 lp8725_reg_read(struct lp8725 *lp8725, u8 reg);
69 static int lp8725_set_bits(struct lp8725 *lp8725, u8 reg, u16 mask, u16 val);
73 #define LP8725_BUCK_VOL_ENABLE_REG 0x00
74 #define LP8725_BUCK1_BASE 0x08
75 #define LP8725_BUCK2_BASE 0x0A
77 const static int buck_base_addr[] = {
84 #define LP8725_BUCK_TARGET_VOL1_REG(x) (buck_base_addr[x])
85 #define LP8725_BUCK_TARGET_VOL2_REG(x) (buck_base_addr[x]+1)
87 const static int buck_voltage_map[] = {
88 800, 850, 900, 950, 1000, 1050, 1100, 1150,
89 1200, 1250, 1300, 1350, 1400, 1500, 1600, 1700,
90 1750, 1800, 1850, 1900, 2000, 2100, 2200, 2300,
91 2400, 2500, 2600, 2700, 2800, 2850, 2900, 3000,
94 #define BUCK_TARGET_VOL_MASK 0x1f
95 #define BUCK_TARGET_VOL_MIN_IDX 0x00
96 #define BUCK_TARGET_VOL_MAX_IDX 0x1f
100 #define LP8725_LDO_ENABLE_REG 0x0d
101 #define LP8725_LDO_VOL_CONTR_BASE 0x01
103 #define LP8725_LDO_VOL_CONTR_REG(x) (LP8725_LDO_VOL_CONTR_BASE + x)
105 const static int ldo_voltage_map[] = {
106 1200, 1250, 1300, 1350, 1400, 1450, 1500, 1550,
107 1600, 1650, 1700, 1750, 1800, 1850, 1900, 2000,
108 2100, 2200, 2300, 2400, 2500, 2600, 2650, 2700,
109 2750, 2800, 2850, 2900, 2950, 3000, 3100, 3300,
112 #define LDO_VOL_CONTR_MASK 0x1f
113 #define LDO_VOL_MIN_IDX 0x00
114 #define LDO_VOL_MAX_IDX 0x1f
116 #define LP8725_LILO_ENABLE_REG 0x0d
117 #define LP8725_LILO_VOL_CONTR_BASE 0x06
119 #define LP8725_LILO_VOL_CONTR_REG(x) (LP8725_LILO_VOL_CONTR_BASE + x)
121 const static int lilo_voltage_map[] = {
122 800, 850, 900, 950, 1000, 1050, 1100, 1150,
123 1200, 1250, 1300, 1350, 1400, 1500, 1600, 1700,
124 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500,
125 2600, 2700, 2800, 2850, 2900, 3000, 3100, 3300,
128 #define LILO_VOL_CONTR_MASK 0x1f
129 #define LILO_VOL_MIN_IDX 0x00
130 #define LILO_VOL_MAX_IDX 0x1f
133 static int lp8725_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
135 return 1000 * ldo_voltage_map[index];
138 static int lp8725_ldo_is_enabled(struct regulator_dev *dev)
140 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
141 int ldo = rdev_get_id(dev) - LP8725_LDO1;
142 u16 mask = 1 << (ldo);
145 val = lp8725_reg_read(lp8725, LP8725_LDO_ENABLE_REG);
146 return (val & mask) != 0;
149 static int lp8725_ldo_enable(struct regulator_dev *dev)
151 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
152 int ldo = rdev_get_id(dev) - LP8725_LDO1;
153 u16 mask = 1 << (ldo);
154 return lp8725_set_bits(lp8725, LP8725_LDO_ENABLE_REG, mask, mask);
157 static int lp8725_ldo_disable(struct regulator_dev *dev)
159 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
160 int ldo = rdev_get_id(dev) - LP8725_LDO1;
161 u16 mask = 1 << (ldo);
162 return lp8725_set_bits(lp8725, LP8725_LDO_ENABLE_REG, mask, 0);
165 static int lp8725_ldo_get_voltage(struct regulator_dev *dev)
167 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
168 int ldo = rdev_get_id(dev) - LP8725_LDO1;
172 reg = lp8725_reg_read(lp8725, LP8725_LDO_VOL_CONTR_REG(ldo));
173 reg &= BUCK_TARGET_VOL_MASK;
175 val = 1000 * ldo_voltage_map[reg];
179 static int lp8725_ldo_set_voltage(struct regulator_dev *dev,
180 int min_uV, int max_uV)
182 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
183 int ldo = rdev_get_id(dev) - LP8725_LDO1;
184 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
185 const int *vol_map = ldo_voltage_map;
188 if (min_vol < vol_map[LDO_VOL_MIN_IDX] ||
189 min_vol > vol_map[LDO_VOL_MAX_IDX])
192 for (val = LDO_VOL_MIN_IDX; val <= LDO_VOL_MAX_IDX; val++)
193 if (vol_map[val] >= min_vol)
196 if (vol_map[val] > max_vol)
199 DBG("***run in %s %d reg=0x%x val=0x%x",__FUNCTION__,__LINE__,LP8725_LDO_VOL_CONTR_REG(ldo),val);
201 return lp8725_set_bits(lp8725, LP8725_LDO_VOL_CONTR_REG(ldo),
202 LDO_VOL_CONTR_MASK, val);
205 static struct regulator_ops lp8725_ldo_ops = {
206 .list_voltage = lp8725_ldo_list_voltage,
207 .is_enabled = lp8725_ldo_is_enabled,
208 .enable = lp8725_ldo_enable,
209 .disable = lp8725_ldo_disable,
210 .get_voltage = lp8725_ldo_get_voltage,
211 .set_voltage = lp8725_ldo_set_voltage,
214 static int lp8725_lilo_list_voltage(struct regulator_dev *dev, unsigned index)
216 return 1000 * lilo_voltage_map[index];
219 static int lp8725_lilo_is_enabled(struct regulator_dev *dev)
221 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
222 int lilo = rdev_get_id(dev) - LP8725_LILO1;
223 u16 mask = 1 << (lilo+5);
226 val = lp8725_reg_read(lp8725, LP8725_LILO_ENABLE_REG);
227 return (val & mask) != 0;
230 static int lp8725_lilo_enable(struct regulator_dev *dev)
232 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
233 int lilo = rdev_get_id(dev) - LP8725_LILO1;
234 u16 mask = 1 << (lilo+5);
236 return lp8725_set_bits(lp8725, LP8725_LILO_ENABLE_REG, mask, mask);
239 static int lp8725_lilo_disable(struct regulator_dev *dev)
241 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
242 int lilo = rdev_get_id(dev) - LP8725_LILO1;
243 u16 mask = 1 << (lilo+5);
245 return lp8725_set_bits(lp8725, LP8725_LILO_ENABLE_REG, mask, 0);
248 static int lp8725_lilo_get_voltage(struct regulator_dev *dev)
250 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
251 int lilo = rdev_get_id(dev) - LP8725_LILO1;
255 reg = lp8725_reg_read(lp8725, LP8725_LILO_VOL_CONTR_REG(lilo));
256 reg &= BUCK_TARGET_VOL_MASK;
258 val = 1000 * lilo_voltage_map[reg];
262 static int lp8725_lilo_set_voltage(struct regulator_dev *dev,
263 int min_uV, int max_uV)
265 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
266 int lilo = rdev_get_id(dev) - LP8725_LILO1;
267 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
268 const int *vol_map = lilo_voltage_map;
271 if (min_vol < vol_map[LILO_VOL_MIN_IDX] ||
272 min_vol > vol_map[LILO_VOL_MAX_IDX])
275 for (val = LILO_VOL_MIN_IDX; val <= LILO_VOL_MAX_IDX; val++)
276 if (vol_map[val] >= min_vol)
279 if (vol_map[val] > max_vol)
282 return lp8725_set_bits(lp8725, LP8725_LILO_VOL_CONTR_REG(lilo),
283 LILO_VOL_CONTR_MASK, val);
286 static struct regulator_ops lp8725_lilo_ops = {
287 .list_voltage = lp8725_lilo_list_voltage,
288 .is_enabled = lp8725_lilo_is_enabled,
289 .enable = lp8725_lilo_enable,
290 .disable = lp8725_lilo_disable,
291 .get_voltage = lp8725_lilo_get_voltage,
292 .set_voltage = lp8725_lilo_set_voltage,
295 static int lp8725_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
297 return 1000 * buck_voltage_map[index];
300 static int lp8725_dcdc_is_enabled(struct regulator_dev *dev)
302 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
303 int buck = rdev_get_id(dev);
312 val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
313 return ((val & mask) && (val & mask2)) != 0;
317 val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
318 return ((val & mask) && (val & mask2)) != 0;
319 case LP8725_DCDC1_V2:
322 val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
323 return ((val & mask) && (!(val & mask2))) !=0;
324 case LP8725_DCDC2_V2:
327 val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
328 return ((val & mask) && (!(val & mask2))) !=0;
332 static int lp8725_dcdc_enable(struct regulator_dev *dev)
334 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
335 int buck = rdev_get_id(dev);
342 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
344 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
346 case LP8725_DCDC1_V2:
348 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
350 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, 0);
354 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
356 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
358 case LP8725_DCDC2_V2:
360 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
362 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, 0);
369 static int lp8725_dcdc_disable(struct regulator_dev *dev)
371 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
372 int buck = rdev_get_id(dev) ;
378 case LP8725_DCDC1_V2:
380 return lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, 0);
382 case LP8725_DCDC2_V2:
384 return lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask,0);
388 static int lp8725_dcdc_get_voltage(struct regulator_dev *dev)
390 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
391 int buck = rdev_get_id(dev) ;
399 buck -= LP8725_DCDC1;
400 reg = lp8725_reg_read(lp8725, LP8725_BUCK_TARGET_VOL1_REG(buck));
402 case LP8725_DCDC1_V2:
403 case LP8725_DCDC2_V2:
404 buck -= LP8725_DCDC1_V2;
405 reg = lp8725_reg_read(lp8725, LP8725_BUCK_TARGET_VOL2_REG(buck));
409 reg &= BUCK_TARGET_VOL_MASK;
410 val = 1000 * buck_voltage_map[reg];
415 static int lp8725_dcdc_set_voltage(struct regulator_dev *dev,
416 int min_uV, int max_uV)
418 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
419 int buck = rdev_get_id(dev);
420 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
421 const int *vol_map = buck_voltage_map;
425 if (min_vol < vol_map[BUCK_TARGET_VOL_MIN_IDX] ||
426 min_vol > vol_map[BUCK_TARGET_VOL_MAX_IDX])
429 for (val = BUCK_TARGET_VOL_MIN_IDX; val <= BUCK_TARGET_VOL_MAX_IDX;
431 if (vol_map[val] >= min_vol)
434 if (vol_map[val] > max_vol)
441 buck -= LP8725_DCDC1;
442 ret = lp8725_set_bits(lp8725, LP8725_BUCK_TARGET_VOL1_REG(buck),
443 BUCK_TARGET_VOL_MASK, val);
447 case LP8725_DCDC1_V2:
448 case LP8725_DCDC2_V2:
449 buck -= LP8725_DCDC1_V2;
450 ret = lp8725_set_bits(lp8725, LP8725_BUCK_TARGET_VOL2_REG(buck),
451 BUCK_TARGET_VOL_MASK, val);
460 static unsigned int lp8725_dcdc_get_mode(struct regulator_dev *dev)
462 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
465 val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
466 if ((val & mask) == 0)
467 return REGULATOR_MODE_NORMAL;
469 return REGULATOR_MODE_IDLE;
472 static int lp8725_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
474 struct lp8725 *lp8725 = rdev_get_drvdata(dev);
478 case REGULATOR_MODE_NORMAL:
479 return lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, 0);
480 case REGULATOR_MODE_IDLE:
481 return lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
483 printk("error:pmu_lp8725 only normal and idle mode\n");
488 static struct regulator_ops lp8725_dcdc_ops = {
489 .list_voltage = lp8725_dcdc_list_voltage,
490 .is_enabled = lp8725_dcdc_is_enabled,
491 .enable = lp8725_dcdc_enable,
492 .disable = lp8725_dcdc_disable,
493 .get_voltage = lp8725_dcdc_get_voltage,
494 .set_voltage = lp8725_dcdc_set_voltage,
495 .get_mode = lp8725_dcdc_get_mode,
496 .set_mode = lp8725_dcdc_set_mode,
499 static struct regulator_desc regulators[] = {
503 .ops = &lp8725_ldo_ops,
504 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
505 .type = REGULATOR_VOLTAGE,
506 .owner = THIS_MODULE,
511 .ops = &lp8725_ldo_ops,
512 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
513 .type = REGULATOR_VOLTAGE,
514 .owner = THIS_MODULE,
519 .ops = &lp8725_ldo_ops,
520 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
521 .type = REGULATOR_VOLTAGE,
522 .owner = THIS_MODULE,
527 .ops = &lp8725_ldo_ops,
528 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
529 .type = REGULATOR_VOLTAGE,
530 .owner = THIS_MODULE,
535 .ops = &lp8725_ldo_ops,
536 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
537 .type = REGULATOR_VOLTAGE,
538 .owner = THIS_MODULE,
543 .ops = &lp8725_lilo_ops,
544 .n_voltages = ARRAY_SIZE(lilo_voltage_map),
545 .type = REGULATOR_VOLTAGE,
546 .owner = THIS_MODULE,
551 .ops = &lp8725_lilo_ops,
552 .n_voltages = ARRAY_SIZE(lilo_voltage_map),
553 .type = REGULATOR_VOLTAGE,
554 .owner = THIS_MODULE,
559 .ops = &lp8725_dcdc_ops,
560 .n_voltages = ARRAY_SIZE(buck_voltage_map),
561 .type = REGULATOR_VOLTAGE,
562 .owner = THIS_MODULE,
567 .ops = &lp8725_dcdc_ops,
568 .n_voltages = ARRAY_SIZE(buck_voltage_map),
569 .type = REGULATOR_VOLTAGE,
570 .owner = THIS_MODULE,
574 .id = LP8725_DCDC1_V2,
575 .ops = &lp8725_dcdc_ops,
576 .n_voltages = ARRAY_SIZE(buck_voltage_map),
577 .type = REGULATOR_VOLTAGE,
578 .owner = THIS_MODULE,
582 .id = LP8725_DCDC2_V2,
583 .ops = &lp8725_dcdc_ops,
584 .n_voltages = ARRAY_SIZE(buck_voltage_map),
585 .type = REGULATOR_VOLTAGE,
586 .owner = THIS_MODULE,
590 static int lp8725_i2c_read(struct i2c_client *i2c, char reg, int count, u16 *dest)
593 struct i2c_adapter *adap;
594 struct i2c_msg msgs[2];
604 msgs[0].addr = i2c->addr;
606 msgs[0].flags = i2c->flags;
608 msgs[0].scl_rate = 200*1000;
611 msgs[1].addr = i2c->addr;
612 msgs[1].flags = i2c->flags | I2C_M_RD;
614 msgs[1].scl_rate = 200*1000;
615 ret = i2c_transfer(adap, msgs, 2);
617 DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
622 static int lp8725_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
626 struct i2c_adapter *adap;
639 msg.addr = i2c->addr;
640 msg.buf = &tx_buf[0];
642 msg.flags = i2c->flags;
643 msg.scl_rate = 200*1000;
645 ret = i2c_transfer(adap, &msg, 1);
649 static u8 lp8725_reg_read(struct lp8725 *lp8725, u8 reg)
653 mutex_lock(&lp8725->io_lock);
655 lp8725_i2c_read(lp8725->i2c, reg, 1, &val);
657 DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
659 mutex_unlock(&lp8725->io_lock);
664 static int lp8725_set_bits(struct lp8725 *lp8725, u8 reg, u16 mask, u16 val)
669 mutex_lock(&lp8725->io_lock);
671 ret = lp8725_i2c_read(lp8725->i2c, reg, 1, &tmp);
672 tmp = (tmp & ~mask) | val;
674 ret = lp8725_i2c_write(lp8725->i2c, reg, 1, tmp);
675 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
677 mutex_unlock(&lp8725->io_lock);
683 //add by robert for power on bp
684 #define AP_TD_UNDEFINED_GBIN5 FPGA_PIO2_02
685 #define AP_RESET_TD FPGA_PIO2_04
686 #define AP_SHUTDOWN_TD_PMU FPGA_PIO2_05
687 #define AP_PW_EN_TD FPGA_PIO2_03
689 static int bp_power_on(void)
693 ret = gpio_request(AP_TD_UNDEFINED_GBIN5, NULL);
695 printk("%s:failed to request fpga s %d\n",__FUNCTION__,__LINE__);
698 ret = gpio_request(AP_RESET_TD, NULL);
700 printk("%s:failed to request fpga s %d\n",__FUNCTION__,__LINE__);
705 ret = gpio_request(AP_SHUTDOWN_TD_PMU, NULL);
707 printk("%s:failed to request fpga %d\n",__FUNCTION__,__LINE__);
711 ret = gpio_request(AP_PW_EN_TD, NULL);
713 printk("%s:failed to request fpga %d\n",__FUNCTION__,__LINE__);
717 gpio_set_value(AP_TD_UNDEFINED_GBIN5, 1);
718 gpio_direction_output(AP_TD_UNDEFINED_GBIN5, 1);
719 gpio_direction_input(AP_RESET_TD);
721 gpio_set_value(AP_SHUTDOWN_TD_PMU, 0);
722 gpio_direction_output(AP_SHUTDOWN_TD_PMU, 0);
724 gpio_set_value(AP_PW_EN_TD, 0);
725 gpio_direction_output(AP_PW_EN_TD, 0);
727 gpio_set_value(AP_PW_EN_TD, 1);
729 gpio_set_value(AP_PW_EN_TD, 0);
733 gpio_free(AP_SHUTDOWN_TD_PMU);
735 gpio_free(AP_RESET_TD);
737 gpio_free(AP_TD_UNDEFINED_GBIN5);
744 static int bp_power_off(struct notifier_block *this,
745 unsigned long code, void *unused)
747 printk("+++--++++++%s_________%d \r\n",__FUNCTION__,code);
749 gpio_set_value(AP_TD_UNDEFINED_GBIN5, 0);
751 gpio_set_value(AP_PW_EN_TD, 0);
752 //gpio_direction_output(AP_PW_EN_TD, 0);
754 gpio_set_value(AP_PW_EN_TD, 1);
756 gpio_set_value(AP_PW_EN_TD, 0);
759 gpio_set_value(AP_SHUTDOWN_TD_PMU, 1);
761 // gpio_free(AP_PW_EN_TD);
762 printk("++++--+++++%s ok_________\r\n",__FUNCTION__);
767 static int lp8725_set_init(void)
770 struct regulator *ldo1,*ldo2,*ldo3,*ldo4,*ldo5;
771 struct regulator *lilo1,*lilo2;
772 struct regulator *buck1,*buck1_v2,*buck2;
774 DBG_INFO("***run in %s %d ",__FUNCTION__,__LINE__);
777 DBG_INFO("***ldo1 vcc init\n");
778 ldo1 = regulator_get(NULL, "ldo1");
779 regulator_enable(ldo1);
780 // regulator_set_voltage(ldo1,2500000,2500000);
781 tmp = regulator_get_voltage(ldo1);
782 DBG_INFO("***regulator_set_init: ldo1 vcc =%d\n",tmp);
785 DBG_INFO("***ldo2 vcc init\n");
786 ldo2 = regulator_get(NULL, "ldo2");
787 regulator_enable(ldo2);
788 // regulator_set_voltage(ldo2,3000000,3000000);
789 tmp = regulator_get_voltage(ldo2);
790 DBG_INFO("***regulator_set_init: ldo2 vcc =%d\n",tmp);
793 DBG_INFO("***ldo3 vcc init\n");
794 ldo3 = regulator_get(NULL, "ldo3");
795 regulator_enable(ldo3);
796 // regulator_set_voltage(ldo3,3000000,3000000);
797 tmp = regulator_get_voltage(ldo3);
798 DBG_INFO("***regulator_set_init: ldo3 vcc =%d\n",tmp);
801 DBG_INFO("***ldo4 vcc init\n");
802 ldo4 = regulator_get(NULL, "ldo4");
803 regulator_enable(ldo4);
804 // regulator_set_voltage(ldo4,1900000,1900000);
805 tmp = regulator_get_voltage(ldo4);
806 DBG_INFO("***regulator_set_init: ldo4 vcc =%d\n",tmp);
809 DBG_INFO("***ldo5 vcc init\n");
810 ldo5 = regulator_get(NULL, "ldo5");
811 regulator_enable(ldo5);
812 regulator_set_voltage(ldo5,1800000,1800000);
813 tmp = regulator_get_voltage(ldo5);
814 DBG_INFO("***regulator_set_init: ldo5 vcc =%d\n",tmp);
817 DBG_INFO("***lilo1 vcc init\n");
818 lilo1 = regulator_get(NULL, "lilo1");
819 regulator_enable(lilo1);
820 // regulator_set_voltage(lilo1,3300000,3300000);
821 tmp = regulator_get_voltage(lilo1);
822 DBG_INFO("***regulator_set_init: lilo1 vcc =%d\n",tmp);
825 DBG_INFO("***lilo2 vcc init\n");
826 lilo2 = regulator_get(NULL, "lilo2");
827 regulator_enable(lilo2);
828 // regulator_set_voltage(lilo2,3300000,3300000);
829 tmp = regulator_get_voltage(lilo2);
830 DBG_INFO("***regulator_set_init: lilo2 vcc =%d\n",tmp);
833 DBG_INFO("***buck1 vcc init\n");
834 buck1 = regulator_get(NULL, "vdd12");
835 // regulator_set_voltage(buck1,1200000,1200000);
836 tmp = regulator_get_voltage(buck1);
837 DBG_INFO("***regulator_set_init: buck1 vcc =%d\n",tmp);
840 DBG_INFO("***buck1 v2 init\n");
841 buck1_v2 = regulator_get(NULL, "vdd12_v2");// dvs 0
842 regulator_enable(buck1_v2);
843 regulator_set_voltage(buck1_v2,1000000,1000000);//1300000
844 tmp = regulator_get_voltage(buck1_v2);
845 DBG_INFO("***regulator_set_init: buck1 v2 =%d\n",tmp);
849 DBG_INFO("***buck2 vcc init\n");
850 buck2 = regulator_get(NULL, "vccdr");
851 // regulator_set_voltage(buck1,1800000,1800000);
852 tmp = regulator_get_voltage(buck2);
853 DBG_INFO("***regulator_set_init: buck2 vcc =%d\n",tmp);
856 //add by robert for power on bp
864 static int __devinit setup_regulators(struct lp8725 *lp8725, struct lp8725_platform_data *pdata)
868 lp8725->num_regulators = pdata->num_regulators;
869 lp8725->rdev = kcalloc(pdata->num_regulators,
870 sizeof(struct regulator_dev *), GFP_KERNEL);
875 /* Instantiate the regulators */
876 for (i = 0; i < pdata->num_regulators; i++) {
877 int id = pdata->regulators[i].id;
878 lp8725->rdev[i] = regulator_register(®ulators[id],
879 lp8725->dev, pdata->regulators[i].initdata, lp8725);
881 if (IS_ERR(lp8725->rdev[i])) {
882 err = PTR_ERR(lp8725->rdev[i]);
883 dev_err(lp8725->dev, "regulator init failed: %d\n",
892 regulator_unregister(lp8725->rdev[i]);
898 static int __devinit lp8725_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
900 struct lp8725 *lp8725;
901 struct lp8725_platform_data *pdata = i2c->dev.platform_data;
904 lp8725 = kzalloc(sizeof(struct lp8725), GFP_KERNEL);
905 if (lp8725 == NULL) {
911 lp8725->dev = &i2c->dev;
912 i2c_set_clientdata(i2c, lp8725);
914 mutex_init(&lp8725->io_lock);
917 ret = setup_regulators(lp8725, pdata);
921 dev_warn(lp8725->dev, "No platform init data supplied\n");
923 //DVS pin control, make sure it is high level at start.
925 rk2818_mux_api_set(GPIOC_LCDC24BIT_SEL_NAME, IOMUXB_GPIO0_C2_7);
926 ret=gpio_request(RK2818_PIN_PC2,NULL);
927 gpio_direction_output(RK2818_PIN_PC2,1);
928 gpio_set_value(RK2818_PIN_PC2,1);
938 static int __devexit lp8725_i2c_remove(struct i2c_client *i2c)
940 struct lp8725 *lp8725 = i2c_get_clientdata(i2c);
943 for (i = 0; i < lp8725->num_regulators; i++)
945 regulator_unregister(lp8725->rdev[i]);
947 i2c_set_clientdata(i2c, NULL);
953 static const struct i2c_device_id lp8725_i2c_id[] = {
958 MODULE_DEVICE_TABLE(i2c, lp8725_i2c_id);
960 static struct i2c_driver lp8725_i2c_driver = {
963 .owner = THIS_MODULE,
965 .probe = lp8725_i2c_probe,
966 .remove = __devexit_p(lp8725_i2c_remove),
967 .id_table = lp8725_i2c_id,
971 //add by robert for bp powerdown register
972 static struct notifier_block BP_powerdown_notifier = {
973 .notifier_call = bp_power_off,
979 static int __init lp8725_module_init(void)
983 ret = i2c_add_driver(&lp8725_i2c_driver);
985 pr_err("Failed to register I2C driver: %d\n", ret);
987 //add by robert for bp powerdown register
988 ret = register_reboot_notifier(&BP_powerdown_notifier);
991 printk("cannot register reboot notifier (err=%d), %s\n", ret,__FUNCTION__);
998 module_init(lp8725_module_init);
1000 static void __exit lp8725_module_exit(void)
1002 //add by robert for bp power down
1003 unregister_reboot_notifier(&BP_powerdown_notifier);
1006 i2c_del_driver(&lp8725_i2c_driver);
1008 module_exit(lp8725_module_exit);
1010 MODULE_LICENSE("GPL");
1011 MODULE_AUTHOR("cym <cym@rock-chips.com>");
1012 MODULE_DESCRIPTION("LP8725 PMIC driver");