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 <linux/regulator/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);
 294         u16 val;
 295         u16 mask,mask2;
 296
 297         switch(buck)
 298         {
 299         case LP8725_DCDC1:
 300                 mask = 1 << 0;
 301                 mask2 = 1 << 2;
 302                 val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
 303                 return ((val & mask) && (val & mask2)) != 0;
 304         case LP8725_DCDC2:
 305                 mask = 1 << 4;
 306                 mask2 = 1 << 3;
 307                 val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
 308                 return ((val & mask) && (val & mask2)) != 0;
 309         case LP8725_DCDC1_V2:
 310                 mask = 1 << 0;
 311                 mask2 = 1<< 2;
 312                 val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
 313                 return  ((val & mask) && (!(val & mask2))) !=0;
 314         case LP8725_DCDC2_V2:
 315                 mask = 1 << 4;
 316                 mask2 = 1 << 3;
 317                 val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
 318                 return ((val & mask) && (!(val & mask2))) !=0;
 319         }
 320 }
 321
 322 static int lp8725_dcdc_enable(struct regulator_dev *dev)
 323 {
 324         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 325         int buck = rdev_get_id(dev);
 326         u16 mask;
 327         int ret = 0;
 328         switch(buck)
 329         {
 330         case LP8725_DCDC1:
 331                 mask = 1 << 0;
 332                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
 333                 mask = 1 << 2;
 334                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
 335                 break;
 336         case LP8725_DCDC1_V2:
 337                 mask = 1 << 0;
 338                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
 339                 mask = 1 << 2;
 340                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, 0);
 341                 break;
 342         case LP8725_DCDC2:
 343                 mask = 1 << 4;
 344                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
 345                 mask = 1 << 3;
 346                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
 347                 break;
 348         case LP8725_DCDC2_V2:
 349                 mask = 1 << 4;
 350                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
 351                 mask = 1 << 3;
 352                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, 0);
 353                 break;
 354         }
 355         dev->use_count--;
 356         return ret;
 357 }
 358
 359 static int lp8725_dcdc_disable(struct regulator_dev *dev)
 360 {
 361         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 362         int buck = rdev_get_id(dev) ;
 363         u16 mask;
 364
 365         switch(buck)
 366         {
 367         case LP8725_DCDC1:
 368         case LP8725_DCDC1_V2:
 369                 mask = 1 << 0;
 370                 return lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, 0);
 371         case LP8725_DCDC2:
 372         case LP8725_DCDC2_V2:
 373                 mask = 1 << 4;
 374                 return lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask,0);
 375         }
 376 }
 377
 378 static int lp8725_dcdc_get_voltage(struct regulator_dev *dev)
 379 {
 380         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 381         int buck = rdev_get_id(dev) ;
 382         u16 reg = 0;
 383         int val;
 384
 385         switch(buck)
 386         {
 387         case LP8725_DCDC1:
 388         case LP8725_DCDC2:
 389                 buck -= LP8725_DCDC1;
 390                 reg = lp8725_reg_read(lp8725, LP8725_BUCK_TARGET_VOL1_REG(buck));
 391                 break;
 392         case LP8725_DCDC1_V2:
 393         case LP8725_DCDC2_V2:
 394                 buck -= LP8725_DCDC1_V2;
 395                 reg = lp8725_reg_read(lp8725, LP8725_BUCK_TARGET_VOL2_REG(buck));
 396                 break;
 397         }
 398
 399         reg &= BUCK_TARGET_VOL_MASK;
 400         val = 1000 * buck_voltage_map[reg];
 401
 402         return val;
 403 }
 404
 405 static int lp8725_dcdc_set_voltage(struct regulator_dev *dev,
 406                                   int min_uV, int max_uV)
 407 {
 408         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 409         int buck = rdev_get_id(dev);
 410         int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
 411         const int *vol_map = buck_voltage_map;
 412         u16 val;
 413         int ret = 0;
 414
 415         if (min_vol < vol_map[BUCK_TARGET_VOL_MIN_IDX] ||
 416             min_vol > vol_map[BUCK_TARGET_VOL_MAX_IDX])
 417                 return -EINVAL;
 418
 419         for (val = BUCK_TARGET_VOL_MIN_IDX; val <= BUCK_TARGET_VOL_MAX_IDX;
 420              val++)
 421                 if (vol_map[val] >= min_vol)
 422                         break;
 423
 424         if (vol_map[val] > max_vol)
 425                 return -EINVAL;
 426
 427         switch(buck)
 428         {
 429         case LP8725_DCDC1:
 430         case LP8725_DCDC2:
 431                 buck -= LP8725_DCDC1;
 432                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_TARGET_VOL1_REG(buck),
 433                 BUCK_TARGET_VOL_MASK, val);
 434                 if (ret)
 435                         return ret;
 436                 break;
 437         case LP8725_DCDC1_V2:
 438         case LP8725_DCDC2_V2:
 439                 buck -= LP8725_DCDC1_V2;
 440                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_TARGET_VOL2_REG(buck),
 441                 BUCK_TARGET_VOL_MASK, val);
 442                 if (ret)
 443                         return ret;
 444                 break;
 445         }
 446
 447         return ret;
 448 }
 449
 450 static int lp8725_dcdc_get_mode(struct regulator_dev *dev)
 451 {
 452         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 453         u16 mask = 1 << 1;
 454         u16 val;
 455         val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
 456         if ((val & mask) == 0)
 457                 return REGULATOR_MODE_NORMAL;
 458         else
 459                 return REGULATOR_MODE_IDLE;
 460 }
 461
 462 static int lp8725_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
 463 {
 464         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 465         u16 mask = 1 << 1;
 466         switch(mode)
 467         {
 468         case REGULATOR_MODE_NORMAL:
 469                 return lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, 0);
 470         case REGULATOR_MODE_IDLE:
 471                 return lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
 472         default:
 473                 printk("error:pmu_lp8725 only normal and idle mode\n");
 474                 return -EINVAL;
 475         }
 476 }
 477
 478 static struct regulator_ops lp8725_dcdc_ops = {
 479         .list_voltage = lp8725_dcdc_list_voltage,
 480         .is_enabled = lp8725_dcdc_is_enabled,
 481         .enable = lp8725_dcdc_enable,
 482         .disable = lp8725_dcdc_disable,
 483         .get_voltage = lp8725_dcdc_get_voltage,
 484         .set_voltage = lp8725_dcdc_set_voltage,
 485         .get_mode = lp8725_dcdc_get_mode,
 486         .set_mode = lp8725_dcdc_set_mode,
 487 };
 488
 489 static struct regulator_desc regulators[] = {
 490         {
 491                 .name = "LDO1",
 492                 .id = LP8725_LDO1,
 493                 .ops = &lp8725_ldo_ops,
 494                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 495                 .type = REGULATOR_VOLTAGE,
 496                 .owner = THIS_MODULE,
 497         },
 498         {
 499                 .name = "LDO2",
 500                 .id = LP8725_LDO2,
 501                 .ops = &lp8725_ldo_ops,
 502                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 503                 .type = REGULATOR_VOLTAGE,
 504                 .owner = THIS_MODULE,
 505         },
 506         {
 507                 .name = "LDO3",
 508                 .id = LP8725_LDO3,
 509                 .ops = &lp8725_ldo_ops,
 510                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 511                 .type = REGULATOR_VOLTAGE,
 512                 .owner = THIS_MODULE,
 513         },
 514         {
 515                 .name = "LDO4",
 516                 .id = LP8725_LDO4,
 517                 .ops = &lp8725_ldo_ops,
 518                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 519                 .type = REGULATOR_VOLTAGE,
 520                 .owner = THIS_MODULE,
 521         },
 522         {
 523                 .name = "LDO5",
 524                 .id = LP8725_LDO5,
 525                 .ops = &lp8725_ldo_ops,
 526                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 527                 .type = REGULATOR_VOLTAGE,
 528                 .owner = THIS_MODULE,
 529         },
 530         {
 531                 .name = "LILO1",
 532                 .id = LP8725_LILO1,
 533                 .ops = &lp8725_lilo_ops,
 534                 .n_voltages = ARRAY_SIZE(lilo_voltage_map),
 535                 .type = REGULATOR_VOLTAGE,
 536                 .owner = THIS_MODULE,
 537         },
 538         {
 539                 .name = "LILO2",
 540                 .id = LP8725_LILO2,
 541                 .ops = &lp8725_lilo_ops,
 542                 .n_voltages = ARRAY_SIZE(lilo_voltage_map),
 543                 .type = REGULATOR_VOLTAGE,
 544                 .owner = THIS_MODULE,
 545         },
 546         {
 547                 .name = "DCDC1",
 548                 .id = LP8725_DCDC1,
 549                 .ops = &lp8725_dcdc_ops,
 550                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 551                 .type = REGULATOR_VOLTAGE,
 552                 .owner = THIS_MODULE,
 553         },
 554         {
 555                 .name = "DCDC2",
 556                 .id = LP8725_DCDC2,
 557                 .ops = &lp8725_dcdc_ops,
 558                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 559                 .type = REGULATOR_VOLTAGE,
 560                 .owner = THIS_MODULE,
 561         },
 562         {
 563                 .name = "DCDC1_V2",
 564                 .id = LP8725_DCDC1_V2,
 565                 .ops = &lp8725_dcdc_ops,
 566                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 567                 .type = REGULATOR_VOLTAGE,
 568                 .owner = THIS_MODULE,
 569         },
 570         {
 571                 .name = "DCDC2_V2",
 572                 .id = LP8725_DCDC2_V2,
 573                 .ops = &lp8725_dcdc_ops,
 574                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 575                 .type = REGULATOR_VOLTAGE,
 576                 .owner = THIS_MODULE,
 577         },
 578 };
 579
 580 static int lp8725_i2c_read(struct i2c_client *i2c, char reg, int count, u16 *dest)
 581 {
 582     int ret;
 583     struct i2c_adapter *adap;
 584     struct i2c_msg msgs[2];
 585
 586     if(!i2c)
 587                 return ret;
 588
 589         if (count != 1)
 590                 return -EIO;
 591
 592     adap = i2c->adapter;
 593
 594     msgs[0].addr = i2c->addr;
 595     msgs[0].buf = &reg;
 596     msgs[0].flags = i2c->flags;
 597     msgs[0].len = 1;
 598     msgs[0].scl_rate = 200*1000;
 599
 600     msgs[1].buf = dest;
 601     msgs[1].addr = i2c->addr;
 602     msgs[1].flags = i2c->flags | I2C_M_RD;
 603     msgs[1].len = 1;
 604     msgs[1].scl_rate = 200*1000;
 605     ret = i2c_transfer(adap, msgs, 2);
 606
 607         DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
 608
 609         return 0;
 610 }
 611
 612 static int lp8725_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
 613 {
 614         int ret=-1;
 615
 616         struct i2c_adapter *adap;
 617         struct i2c_msg msg;
 618         char tx_buf[2];
 619
 620         if(!i2c)
 621                 return ret;
 622         if (count != 1)
 623                 return -EIO;
 624
 625         adap = i2c->adapter;
 626         tx_buf[0] = reg;
 627         tx_buf[1] = src;
 628
 629         msg.addr = i2c->addr;
 630         msg.buf = &tx_buf[0];
 631         msg.len = 1 +1;
 632         msg.flags = i2c->flags;
 633         msg.scl_rate = 200*1000;
 634
 635         ret = i2c_transfer(adap, &msg, 1);
 636         return ret;
 637 }
 638
 639 static u8 lp8725_reg_read(struct lp8725 *lp8725, u8 reg)
 640 {
 641         u16 val = 0;
 642
 643         mutex_lock(&lp8725->io_lock);
 644
 645         lp8725_i2c_read(lp8725->i2c, reg, 1, &val);
 646
 647         DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 648
 649         mutex_unlock(&lp8725->io_lock);
 650
 651         return val & 0xff;
 652 }
 653
 654 static int lp8725_set_bits(struct lp8725 *lp8725, u8 reg, u16 mask, u16 val)
 655 {
 656         u16 tmp;
 657         int ret;
 658
 659         mutex_lock(&lp8725->io_lock);
 660
 661         ret = lp8725_i2c_read(lp8725->i2c, reg, 1, &tmp);
 662         tmp = (tmp & ~mask) | val;
 663         if (ret == 0) {
 664                 ret = lp8725_i2c_write(lp8725->i2c, reg, 1, tmp);
 665                 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 666         }
 667         mutex_unlock(&lp8725->io_lock);
 668
 669         return ret;
 670 }
 671
 672
 673 static int lp8725_set_init(void)
 674 {
 675         int tmp = 0;
 676         struct regulator *ldo1,*ldo2,*ldo3,*ldo4,*ldo5;
 677         struct regulator *lilo1,*lilo2;
 678         struct regulator *buck1,*buck2;
 679
 680         DBG_INFO("***run in %s %d ",__FUNCTION__,__LINE__);
 681
 682         /*init ldo1*/
 683         DBG_INFO("***ldo1 vcc init\n");
 684         ldo1 = regulator_get(NULL, "ldo1");
 685         regulator_enable(ldo1);
 686 //      regulator_set_voltage(ldo1,2500000,2500000);
 687         tmp = regulator_get_voltage(ldo1);
 688         DBG_INFO("***regulator_set_init: ldo1 vcc =%d\n",tmp);
 689
 690         /*init ldo2*/
 691         DBG_INFO("***ldo2 vcc init\n");
 692         ldo2 = regulator_get(NULL, "ldo2");
 693         regulator_enable(ldo2);
 694 //      regulator_set_voltage(ldo2,3000000,3000000);
 695         tmp = regulator_get_voltage(ldo2);
 696         DBG_INFO("***regulator_set_init: ldo2 vcc =%d\n",tmp);
 697
 698         /*init ldo3*/
 699         DBG_INFO("***ldo3 vcc init\n");
 700         ldo3 = regulator_get(NULL, "ldo3");
 701         regulator_enable(ldo3);
 702 //      regulator_set_voltage(ldo3,3000000,3000000);
 703         tmp = regulator_get_voltage(ldo3);
 704         DBG_INFO("***regulator_set_init: ldo3 vcc =%d\n",tmp);
 705
 706         /*init ldo4*/
 707         DBG_INFO("***ldo4 vcc init\n");
 708         ldo4 = regulator_get(NULL, "ldo4");
 709         regulator_enable(ldo4);
 710 //      regulator_set_voltage(ldo4,1900000,1900000);
 711         tmp = regulator_get_voltage(ldo4);
 712         DBG_INFO("***regulator_set_init: ldo4 vcc =%d\n",tmp);
 713
 714         /*init ldo5*/
 715         DBG_INFO("***ldo5 vcc init\n");
 716         ldo5 = regulator_get(NULL, "ldo5");
 717         regulator_enable(ldo5);
 718         regulator_set_voltage(ldo5,1800000,1800000);
 719         tmp = regulator_get_voltage(ldo5);
 720         DBG_INFO("***regulator_set_init: ldo5 vcc =%d\n",tmp);
 721
 722         /*init lilo1*/
 723         DBG_INFO("***lilo1 vcc init\n");
 724         lilo1 = regulator_get(NULL, "lilo1");
 725         regulator_enable(lilo1);
 726 //      regulator_set_voltage(lilo1,3300000,3300000);
 727         tmp = regulator_get_voltage(lilo1);
 728         DBG_INFO("***regulator_set_init: lilo1 vcc =%d\n",tmp);
 729
 730         /*init lilo2*/
 731         DBG_INFO("***lilo2 vcc init\n");
 732         lilo2 = regulator_get(NULL, "lilo2");
 733         regulator_enable(lilo2);
 734 //      regulator_set_voltage(lilo2,3300000,3300000);
 735         tmp = regulator_get_voltage(lilo2);
 736         DBG_INFO("***regulator_set_init: lilo2 vcc =%d\n",tmp);
 737
 738         /*init buck1*/
 739         DBG_INFO("***buck1 vcc init\n");
 740         buck1 = regulator_get(NULL, "vdd12");
 741 //      regulator_set_voltage(buck1,1200000,1200000);
 742         tmp = regulator_get_voltage(buck1);
 743         DBG_INFO("***regulator_set_init: buck1 vcc =%d\n",tmp);
 744
 745         /*init buck2*/
 746         DBG_INFO("***buck2 vcc init\n");
 747         buck2 = regulator_get(NULL, "vccdr");
 748 //      regulator_set_voltage(buck1,1800000,1800000);
 749         tmp = regulator_get_voltage(buck2);
 750         DBG_INFO("***regulator_set_init: buck2 vcc =%d\n",tmp);
 751
 752         return(0);
 753 }
 754
 755
 756 static int setup_regulators(struct lp8725 *lp8725, struct lp8725_platform_data *pdata)
 757 {
 758         int i, err;
 759         int num_regulators = pdata->num_regulators;
 760         lp8725->num_regulators = num_regulators;
 761         lp8725->rdev = kzalloc(sizeof(struct regulator_dev *) * num_regulators,
 762                 GFP_KERNEL);
 763
 764         /* Instantiate the regulators */
 765         for (i = 0; i < num_regulators; i++) {
 766                 int id = pdata->regulators[i].id;
 767                 lp8725->rdev[i] = regulator_register(&regulators[id],
 768                         lp8725->dev, pdata->regulators[i].initdata, lp8725);
 769
 770                 err = IS_ERR(lp8725->rdev[i]);
 771                 if (err) {
 772                         dev_err(lp8725->dev, "regulator init failed: %d\n",
 773                                 err);
 774                         goto error;
 775                 }
 776         }
 777
 778         return 0;
 779 error:
 780         for (i = 0; i < num_regulators; i++)
 781                 if (lp8725->rdev[i])
 782                         regulator_unregister(lp8725->rdev[i]);
 783         kfree(lp8725->rdev);
 784         lp8725->rdev = NULL;
 785         return err;
 786 }
 787
 788 static int __devinit lp8725_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
 789 {
 790         struct lp8725 *lp8725;
 791         struct lp8725_platform_data *pdata = i2c->dev.platform_data;
 792         int ret;
 793
 794         lp8725 = kzalloc(sizeof(struct lp8725), GFP_KERNEL);
 795         if (lp8725 == NULL) {
 796                 ret = -ENOMEM;
 797                 goto err;
 798         }
 799
 800         lp8725->i2c = i2c;
 801         lp8725->dev = &i2c->dev;
 802         i2c_set_clientdata(i2c, lp8725);
 803
 804         mutex_init(&lp8725->io_lock);
 805
 806         if (pdata) {
 807                 ret = setup_regulators(lp8725, pdata);
 808                 if (ret < 0)
 809                         goto err;
 810         } else
 811                 dev_warn(lp8725->dev, "No platform init data supplied\n");
 812
 813         lp8725_set_init();
 814
 815         return 0;
 816
 817 err:
 818         return ret;
 819 }
 820
 821 static int __devexit lp8725_i2c_remove(struct i2c_client *i2c)
 822 {
 823         struct lp8725 *lp8725 = i2c_get_clientdata(i2c);
 824         int i;
 825         for (i = 0; i < lp8725->num_regulators; i++)
 826                 if (lp8725->rdev[i])
 827                         regulator_unregister(lp8725->rdev[i]);
 828         kfree(lp8725->rdev);
 829         i2c_set_clientdata(i2c, NULL);
 830         kfree(lp8725);
 831
 832         return 0;
 833 }
 834
 835 static const struct i2c_device_id lp8725_i2c_id[] = {
 836        { "lp8725", 0 },
 837        { }
 838 };
 839
 840 MODULE_DEVICE_TABLE(i2c, lp8725_i2c_id);
 841
 842 static struct i2c_driver lp8725_i2c_driver = {
 843         .driver = {
 844                 .name = "lp8725",
 845                 .owner = THIS_MODULE,
 846         },
 847         .probe    = lp8725_i2c_probe,
 848         .remove   = __devexit_p(lp8725_i2c_remove),
 849         .id_table = lp8725_i2c_id,
 850 };
 851
 852 static int __init lp8725_module_init(void)
 853 {
 854         int ret;
 855
 856         ret = i2c_add_driver(&lp8725_i2c_driver);
 857         if (ret != 0)
 858                 pr_err("Failed to register I2C driver: %d\n", ret);
 859
 860         return ret;
 861 }
 862 module_init(lp8725_module_init);
 863
 864 static void __exit lp8725_module_exit(void)
 865 {
 866         i2c_del_driver(&lp8725_i2c_driver);
 867 }
 868 module_exit(lp8725_module_exit);
 869
 870 MODULE_LICENSE("GPL");
 871 MODULE_AUTHOR("cym <cym@rock-chips.com>");
 872 MODULE_DESCRIPTION("LP8725 PMIC driver");