drivers/regulator/rk2818_lp8725.c

   1 /* drivers/regulator/rk2818_lp8725.c
   2  *
   3  * Copyright (C) 2010 ROCKCHIP, Inc.
   4  *
   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.
   8  *
   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.
  13  *
  14  */
  15 /*******************************************************************/
  16 /*        COPYRIGHT (C)  ROCK-CHIPS FUZHOU . ALL RIGHTS RESERVED.                         */
  17 /*******************************************************************
  18 FILE            :         rk2818_lp8725.c
  19 DESC            :         LP8725 PMIC driver
  20 AUTHOR          :         cym
  21 DATE            :         2010-08-06
  22 NOTES           :
  23 $LOG: GPIO.C,V $
  24 REVISION 0.01
  25 ********************************************************************/
  26
  27
  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 "rk2818_lp8725.h"
  34
  35
  36 #if 0
  37 #define DBG(x...)       printk(KERN_INFO x)
  38 #else
  39 #define DBG(x...)
  40 #endif
  41 #if 1
  42 #define DBG_INFO(x...)  printk(KERN_INFO x)
  43 #else
  44 #define DBG_INFO(x...)
  45 #endif
  46
  47
  48
  49
  50 struct lp8725 {
  51         struct device *dev;
  52         struct mutex io_lock;
  53         struct i2c_client *i2c;
  54         int num_regulators;
  55         struct regulator_dev **rdev;
  56 };
  57
  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);
  60
  61
  62
  63 #define LP8725_BUCK_VOL_ENABLE_REG 0x00
  64 #define LP8725_BUCK1_BASE 0x08
  65 #define LP8725_BUCK2_BASE 0x0A
  66
  67 const static int buck_base_addr[] = {
  68         LP8725_BUCK1_BASE,
  69         LP8725_BUCK2_BASE,
  70 };
  71
  72
  73
  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)
  76
  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,
  82 };
  83
  84 #define BUCK_TARGET_VOL_MASK 0x1f
  85 #define BUCK_TARGET_VOL_MIN_IDX 0x00
  86 #define BUCK_TARGET_VOL_MAX_IDX 0x1f
  87
  88
  89
  90 #define LP8725_LDO_ENABLE_REG 0x0d
  91 #define LP8725_LDO_VOL_CONTR_BASE 0x01
  92
  93 #define LP8725_LDO_VOL_CONTR_REG(x)     (LP8725_LDO_VOL_CONTR_BASE + x)
  94
  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,
 100 };
 101
 102 #define LDO_VOL_CONTR_MASK 0x1f
 103 #define LDO_VOL_MIN_IDX 0x00
 104 #define LDO_VOL_MAX_IDX 0x1f
 105
 106 #define LP8725_LILO_ENABLE_REG 0x0d
 107 #define LP8725_LILO_VOL_CONTR_BASE 0x06
 108
 109 #define LP8725_LILO_VOL_CONTR_REG(x)    (LP8725_LILO_VOL_CONTR_BASE + x)
 110
 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,
 116 };
 117
 118 #define LILO_VOL_CONTR_MASK 0x1f
 119 #define LILO_VOL_MIN_IDX 0x00
 120 #define LILO_VOL_MAX_IDX 0x1f
 121
 122
 123 static int lp8725_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
 124 {
 125         return 1000 * ldo_voltage_map[index];
 126 }
 127
 128 static int lp8725_ldo_is_enabled(struct regulator_dev *dev)
 129 {
 130         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 131         int ldo = rdev_get_id(dev) - LP8725_LDO1;
 132         u16 mask = 1 << (ldo);
 133         u16 val;
 134
 135         val = lp8725_reg_read(lp8725, LP8725_LDO_ENABLE_REG);
 136         return (val & mask) != 0;
 137 }
 138
 139 static int lp8725_ldo_enable(struct regulator_dev *dev)
 140 {
 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);
 145 }
 146
 147 static int lp8725_ldo_disable(struct regulator_dev *dev)
 148 {
 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);
 153 }
 154
 155 static int lp8725_ldo_get_voltage(struct regulator_dev *dev)
 156 {
 157         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 158         int ldo = rdev_get_id(dev) - LP8725_LDO1;
 159         u16 reg;
 160         u32 val;
 161
 162         reg = lp8725_reg_read(lp8725, LP8725_LDO_VOL_CONTR_REG(ldo));
 163         reg &= BUCK_TARGET_VOL_MASK;
 164
 165         val = 1000 * ldo_voltage_map[reg];
 166         return val;
 167 }
 168
 169 static int lp8725_ldo_set_voltage(struct regulator_dev *dev,
 170                                   int min_uV, int max_uV)
 171 {
 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;
 176         u16 val;
 177
 178         if (min_vol < vol_map[LDO_VOL_MIN_IDX] ||
 179             min_vol > vol_map[LDO_VOL_MAX_IDX])
 180                 return -EINVAL;
 181
 182         for (val = LDO_VOL_MIN_IDX; val <= LDO_VOL_MAX_IDX; val++)
 183                 if (vol_map[val] >= min_vol)
 184                         break;
 185
 186         if (vol_map[val] > max_vol)
 187                 return -EINVAL;
 188
 189         DBG("***run in %s %d reg=0x%x val=0x%x",__FUNCTION__,__LINE__,LP8725_LDO_VOL_CONTR_REG(ldo),val);
 190
 191         return lp8725_set_bits(lp8725, LP8725_LDO_VOL_CONTR_REG(ldo),
 192                 LDO_VOL_CONTR_MASK, val);
 193 }
 194
 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,
 202 };
 203
 204 static int lp8725_lilo_list_voltage(struct regulator_dev *dev, unsigned index)
 205 {
 206         return 1000 * lilo_voltage_map[index];
 207 }
 208
 209 static int lp8725_lilo_is_enabled(struct regulator_dev *dev)
 210 {
 211         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 212         int lilo = rdev_get_id(dev) - LP8725_LILO1;
 213         u16 mask = 1 << (lilo+4);
 214         u16 val;
 215
 216         val = lp8725_reg_read(lp8725, LP8725_LILO_ENABLE_REG);
 217         return (val & mask) != 0;
 218 }
 219
 220 static int lp8725_lilo_enable(struct regulator_dev *dev)
 221 {
 222         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 223         int lilo = rdev_get_id(dev) - LP8725_LILO1;
 224         u16 mask = 1 << (lilo+4);
 225
 226         return lp8725_set_bits(lp8725, LP8725_LILO_ENABLE_REG, mask, mask);
 227 }
 228
 229 static int lp8725_lilo_disable(struct regulator_dev *dev)
 230 {
 231         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 232         int lilo = rdev_get_id(dev) - LP8725_LILO1;
 233         u16 mask = 1 << (lilo+4);
 234
 235         return lp8725_set_bits(lp8725, LP8725_LILO_ENABLE_REG, mask, 0);
 236 }
 237
 238 static int lp8725_lilo_get_voltage(struct regulator_dev *dev)
 239 {
 240         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 241         int lilo = rdev_get_id(dev) - LP8725_LILO1;
 242         u16 reg;
 243         u32 val;
 244
 245         reg = lp8725_reg_read(lp8725, LP8725_LILO_VOL_CONTR_REG(lilo));
 246         reg &= BUCK_TARGET_VOL_MASK;
 247
 248         val = 1000 * lilo_voltage_map[reg];
 249         return val;
 250 }
 251
 252 static int lp8725_lilo_set_voltage(struct regulator_dev *dev,
 253                                   int min_uV, int max_uV)
 254 {
 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;
 259         u16 val;
 260
 261         if (min_vol < vol_map[LILO_VOL_MIN_IDX] ||
 262             min_vol > vol_map[LILO_VOL_MAX_IDX])
 263                 return -EINVAL;
 264
 265         for (val = LILO_VOL_MIN_IDX; val <= LILO_VOL_MAX_IDX; val++)
 266                 if (vol_map[val] >= min_vol)
 267                         break;
 268
 269         if (vol_map[val] > max_vol)
 270                 return -EINVAL;
 271
 272         return lp8725_set_bits(lp8725, LP8725_LILO_VOL_CONTR_REG(lilo),
 273                 LILO_VOL_CONTR_MASK, val);
 274 }
 275
 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,
 283 };
 284
 285 static int lp8725_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
 286 {
 287         return 1000 * buck_voltage_map[index];
 288 }
 289
 290 static int lp8725_dcdc_is_enabled(struct regulator_dev *dev)
 291 {
 292         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 293         int buck = rdev_get_id(dev) - LP8725_DCDC1;
 294         u16 mask = 1 << (buck * 2);
 295         u16 val;
 296
 297         val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
 298         return (val & mask) != 0;
 299 }
 300
 301 static int lp8725_dcdc_enable(struct regulator_dev *dev)
 302 {
 303         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 304         int buck = rdev_get_id(dev) - LP8725_DCDC1;
 305         u16 mask = 1 << (buck * 2);
 306
 307         return lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
 308 }
 309
 310 static int lp8725_dcdc_disable(struct regulator_dev *dev)
 311 {
 312         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 313         int buck = rdev_get_id(dev) - LP8725_DCDC1;
 314         u16 mask = 1 << (buck * 2);
 315
 316         return lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, 0);
 317 }
 318
 319 static int lp8725_dcdc_get_voltage(struct regulator_dev *dev)
 320 {
 321         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 322         int buck = rdev_get_id(dev) - LP8725_DCDC1;
 323         u16 reg;
 324         int val;
 325
 326         reg = lp8725_reg_read(lp8725, LP8725_BUCK_TARGET_VOL1_REG(buck));
 327         reg &= BUCK_TARGET_VOL_MASK;
 328
 329         val = 1000 * buck_voltage_map[reg];
 330
 331         return val;
 332 }
 333
 334 static int lp8725_dcdc_set_voltage(struct regulator_dev *dev,
 335                                   int min_uV, int max_uV)
 336 {
 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;
 341         u16 val;
 342         int ret;
 343
 344         if (min_vol < vol_map[BUCK_TARGET_VOL_MIN_IDX] ||
 345             min_vol > vol_map[BUCK_TARGET_VOL_MAX_IDX])
 346                 return -EINVAL;
 347
 348         for (val = BUCK_TARGET_VOL_MIN_IDX; val <= BUCK_TARGET_VOL_MAX_IDX;
 349              val++)
 350                 if (vol_map[val] >= min_vol)
 351                         break;
 352
 353         if (vol_map[val] > max_vol)
 354                 return -EINVAL;
 355
 356         ret = lp8725_set_bits(lp8725, LP8725_BUCK_TARGET_VOL1_REG(buck),
 357                BUCK_TARGET_VOL_MASK, val);
 358         if (ret)
 359                 return ret;
 360
 361         ret = lp8725_set_bits(lp8725, LP8725_BUCK_TARGET_VOL2_REG(buck),
 362                BUCK_TARGET_VOL_MASK, val);
 363         if (ret)
 364                 return ret;
 365
 366                 return ret;
 367 }
 368
 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,
 376 };
 377
 378 static struct regulator_desc regulators[] = {
 379         {
 380                 .name = "LDO1",
 381                 .id = LP8725_LDO1,
 382                 .ops = &lp8725_ldo_ops,
 383                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 384                 .type = REGULATOR_VOLTAGE,
 385                 .owner = THIS_MODULE,
 386         },
 387         {
 388                 .name = "LDO2",
 389                 .id = LP8725_LDO2,
 390                 .ops = &lp8725_ldo_ops,
 391                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 392                 .type = REGULATOR_VOLTAGE,
 393                 .owner = THIS_MODULE,
 394         },
 395         {
 396                 .name = "LDO3",
 397                 .id = LP8725_LDO3,
 398                 .ops = &lp8725_ldo_ops,
 399                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 400                 .type = REGULATOR_VOLTAGE,
 401                 .owner = THIS_MODULE,
 402         },
 403         {
 404                 .name = "LDO4",
 405                 .id = LP8725_LDO4,
 406                 .ops = &lp8725_ldo_ops,
 407                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 408                 .type = REGULATOR_VOLTAGE,
 409                 .owner = THIS_MODULE,
 410         },
 411         {
 412                 .name = "LDO5",
 413                 .id = LP8725_LDO5,
 414                 .ops = &lp8725_ldo_ops,
 415                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 416                 .type = REGULATOR_VOLTAGE,
 417                 .owner = THIS_MODULE,
 418         },
 419         {
 420                 .name = "LILO1",
 421                 .id = LP8725_LILO1,
 422                 .ops = &lp8725_lilo_ops,
 423                 .n_voltages = ARRAY_SIZE(lilo_voltage_map),
 424                 .type = REGULATOR_VOLTAGE,
 425                 .owner = THIS_MODULE,
 426         },
 427         {
 428                 .name = "LILO2",
 429                 .id = LP8725_LILO2,
 430                 .ops = &lp8725_lilo_ops,
 431                 .n_voltages = ARRAY_SIZE(lilo_voltage_map),
 432                 .type = REGULATOR_VOLTAGE,
 433                 .owner = THIS_MODULE,
 434         },
 435         {
 436                 .name = "DCDC1",
 437                 .id = LP8725_DCDC1,
 438                 .ops = &lp8725_dcdc_ops,
 439                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 440                 .type = REGULATOR_VOLTAGE,
 441                 .owner = THIS_MODULE,
 442         },
 443         {
 444                 .name = "DCDC2",
 445                 .id = LP8725_DCDC2,
 446                 .ops = &lp8725_dcdc_ops,
 447                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 448                 .type = REGULATOR_VOLTAGE,
 449                 .owner = THIS_MODULE,
 450         },
 451 };
 452
 453 static int lp8725_i2c_read(struct i2c_client *i2c, char reg, int count, u16 *dest)
 454 {
 455     int ret;
 456     struct i2c_adapter *adap;
 457     struct i2c_msg msgs[2];
 458
 459     if(!i2c)
 460                 return ret;
 461
 462         if (count != 1)
 463                 return -EIO;
 464
 465     adap = i2c->adapter;
 466
 467     msgs[0].addr = i2c->addr;
 468     msgs[0].buf = &reg;
 469     msgs[0].flags = i2c->flags;
 470     msgs[0].len = 1;
 471     msgs[0].scl_rate = 200*1000;
 472
 473     msgs[1].buf = dest;
 474     msgs[1].addr = i2c->addr;
 475     msgs[1].flags = i2c->flags | I2C_M_RD;
 476     msgs[1].len = 1;
 477     msgs[1].scl_rate = 200*1000;
 478     ret = i2c_transfer(adap, msgs, 2);
 479
 480         DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
 481
 482         return 0;
 483 }
 484
 485 static int lp8725_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
 486 {
 487         int ret=-1;
 488
 489         struct i2c_adapter *adap;
 490         struct i2c_msg msg;
 491         char tx_buf[2];
 492
 493         if(!i2c)
 494                 return ret;
 495         if (count != 1)
 496                 return -EIO;
 497
 498         adap = i2c->adapter;
 499         tx_buf[0] = reg;
 500         tx_buf[1] = src;
 501
 502         msg.addr = i2c->addr;
 503         msg.buf = &tx_buf[0];
 504         msg.len = 1 +1;
 505         msg.flags = i2c->flags;
 506         msg.scl_rate = 200*1000;
 507
 508         ret = i2c_transfer(adap, &msg, 1);
 509         return ret;
 510 }
 511
 512 static u8 lp8725_reg_read(struct lp8725 *lp8725, u8 reg)
 513 {
 514         u16 val = 0;
 515
 516         mutex_lock(&lp8725->io_lock);
 517
 518         lp8725_i2c_read(lp8725->i2c, reg, 1, &val);
 519
 520         DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 521
 522         mutex_unlock(&lp8725->io_lock);
 523
 524         return val & 0xff;
 525 }
 526
 527 static int lp8725_set_bits(struct lp8725 *lp8725, u8 reg, u16 mask, u16 val)
 528 {
 529         u16 tmp;
 530         int ret;
 531
 532         mutex_lock(&lp8725->io_lock);
 533
 534         ret = lp8725_i2c_read(lp8725->i2c, reg, 1, &tmp);
 535         tmp = (tmp & ~mask) | val;
 536         if (ret == 0) {
 537                 ret = lp8725_i2c_write(lp8725->i2c, reg, 1, tmp);
 538                 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 539         }
 540         mutex_unlock(&lp8725->io_lock);
 541
 542         return ret;
 543 }
 544
 545
 546 static int lp8725_set_init(void)
 547 {
 548         int ret;
 549         int tmp = 0;
 550         struct regulator *ldo1,*ldo2,*ldo3,*ldo4,*ldo5;
 551         struct regulator *lilo1,*lilo2;
 552         struct regulator *buck1,*buck2;
 553
 554         DBG_INFO("***run in %s %d ",__FUNCTION__,__LINE__);
 555
 556         /*init ldo1*/
 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);
 563
 564         /*init ldo2*/
 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);
 571
 572         /*init ldo3*/
 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);
 579
 580         /*init ldo4*/
 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);
 587
 588         /*init ldo5*/
 589         DBG_INFO("***ldo5 vcc init\n");
 590         ldo5 = regulator_get(NULL, "ldo5");
 591         regulator_enable(ldo5);
 592 //      regulator_set_voltage(ldo5,1900000,1900000);
 593         tmp = regulator_get_voltage(ldo5);
 594         DBG_INFO("***regulator_set_init: ldo5 vcc =%d\n",tmp);
 595
 596         /*init lilo1*/
 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);
 603
 604         /*init lilo2*/
 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);
 611
 612         /*init buck1*/
 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);
 618
 619         /*init buck2*/
 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);
 625
 626         return(0);
 627 }
 628
 629
 630 static int setup_regulators(struct lp8725 *lp8725, struct lp8725_platform_data *pdata)
 631 {
 632         int i, err;
 633         int num_regulators = pdata->num_regulators;
 634         lp8725->num_regulators = num_regulators;
 635         lp8725->rdev = kzalloc(sizeof(struct regulator_dev *) * num_regulators,
 636                 GFP_KERNEL);
 637
 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(&regulators[id],
 642                         lp8725->dev, pdata->regulators[i].initdata, lp8725);
 643
 644                 err = IS_ERR(lp8725->rdev[i]);
 645                 if (err) {
 646                         dev_err(lp8725->dev, "regulator init failed: %d\n",
 647                                 err);
 648                         goto error;
 649                 }
 650         }
 651
 652         return 0;
 653 error:
 654         for (i = 0; i < num_regulators; i++)
 655                 if (lp8725->rdev[i])
 656                         regulator_unregister(lp8725->rdev[i]);
 657         kfree(lp8725->rdev);
 658         lp8725->rdev = NULL;
 659         return err;
 660 }
 661
 662 static int __devinit lp8725_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
 663 {
 664         struct lp8725 *lp8725;
 665         struct lp8725_platform_data *pdata = i2c->dev.platform_data;
 666         int ret;
 667
 668         lp8725 = kzalloc(sizeof(struct lp8725), GFP_KERNEL);
 669         if (lp8725 == NULL) {
 670                 ret = -ENOMEM;
 671                 goto err;
 672         }
 673
 674         lp8725->i2c = i2c;
 675         lp8725->dev = &i2c->dev;
 676         i2c_set_clientdata(i2c, lp8725);
 677
 678         mutex_init(&lp8725->io_lock);
 679
 680         if (pdata) {
 681                 ret = setup_regulators(lp8725, pdata);
 682                 if (ret < 0)
 683                         goto err;
 684         } else
 685                 dev_warn(lp8725->dev, "No platform init data supplied\n");
 686
 687         lp8725_set_init();
 688
 689         return 0;
 690
 691 err:
 692         return ret;
 693 }
 694
 695 static int __devexit lp8725_i2c_remove(struct i2c_client *i2c)
 696 {
 697         struct lp8725 *lp8725 = i2c_get_clientdata(i2c);
 698         int i;
 699         for (i = 0; i < lp8725->num_regulators; i++)
 700                 if (lp8725->rdev[i])
 701                         regulator_unregister(lp8725->rdev[i]);
 702         kfree(lp8725->rdev);
 703         i2c_set_clientdata(i2c, NULL);
 704         kfree(lp8725);
 705
 706         return 0;
 707 }
 708
 709 static const struct i2c_device_id lp8725_i2c_id[] = {
 710        { "lp8725", 0 },
 711        { }
 712 };
 713
 714 MODULE_DEVICE_TABLE(i2c, lp8725_i2c_id);
 715
 716 static struct i2c_driver lp8725_i2c_driver = {
 717         .driver = {
 718                 .name = "lp8725",
 719                 .owner = THIS_MODULE,
 720         },
 721         .probe    = lp8725_i2c_probe,
 722         .remove   = __devexit_p(lp8725_i2c_remove),
 723         .id_table = lp8725_i2c_id,
 724 };
 725
 726 static int __init lp8725_module_init(void)
 727 {
 728         int ret;
 729
 730         ret = i2c_add_driver(&lp8725_i2c_driver);
 731         if (ret != 0)
 732                 pr_err("Failed to register I2C driver: %d\n", ret);
 733
 734         return ret;
 735 }
 736 module_init(lp8725_module_init);
 737
 738 static void __exit lp8725_module_exit(void)
 739 {
 740         i2c_del_driver(&lp8725_i2c_driver);
 741 }
 742 module_exit(lp8725_module_exit);
 743
 744 MODULE_LICENSE("GPL");
 745 MODULE_AUTHOR("cym <cym@rock-chips.com>");
 746 MODULE_DESCRIPTION("LP8725 PMIC driver");