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 #include <mach/gpio.h>
  35 #include <linux/delay.h>
  36
  37 //add by robert for reboot notifier
  38 #include <linux/notifier.h>
  39 #include <linux/reboot.h>
  40
  41 //end add
  42
  43
  44
  45 #if 0
  46 #define DBG(x...)       printk(KERN_INFO x)
  47 #else
  48 #define DBG(x...)
  49 #endif
  50 #if 1
  51 #define DBG_INFO(x...)  printk(KERN_INFO x)
  52 #else
  53 #define DBG_INFO(x...)
  54 #endif
  55
  56
  57
  58
  59 struct lp8725 {
  60         struct device *dev;
  61         struct mutex io_lock;
  62         struct i2c_client *i2c;
  63         int num_regulators;
  64         struct regulator_dev **rdev;
  65 };
  66
  67 static u8 lp8725_reg_read(struct lp8725 *lp8725, u8 reg);
  68 static int lp8725_set_bits(struct lp8725 *lp8725, u8 reg, u16 mask, u16 val);
  69
  70
  71
  72 #define LP8725_BUCK_VOL_ENABLE_REG 0x00
  73 #define LP8725_BUCK1_BASE 0x08
  74 #define LP8725_BUCK2_BASE 0x0A
  75
  76 const static int buck_base_addr[] = {
  77         LP8725_BUCK1_BASE,
  78         LP8725_BUCK2_BASE,
  79 };
  80
  81
  82
  83 #define LP8725_BUCK_TARGET_VOL1_REG(x) (buck_base_addr[x])
  84 #define LP8725_BUCK_TARGET_VOL2_REG(x) (buck_base_addr[x]+1)
  85
  86 const static int buck_voltage_map[] = {
  87          800,  850,  900,  950, 1000, 1050, 1100, 1150,
  88         1200, 1250, 1300, 1350, 1400, 1500, 1600, 1700,
  89         1750, 1800, 1850, 1900, 2000, 2100, 2200, 2300,
  90         2400, 2500, 2600, 2700, 2800, 2850, 2900, 3000,
  91 };
  92
  93 #define BUCK_TARGET_VOL_MASK 0x1f
  94 #define BUCK_TARGET_VOL_MIN_IDX 0x00
  95 #define BUCK_TARGET_VOL_MAX_IDX 0x1f
  96
  97
  98
  99 #define LP8725_LDO_ENABLE_REG 0x0d
 100 #define LP8725_LDO_VOL_CONTR_BASE 0x01
 101
 102 #define LP8725_LDO_VOL_CONTR_REG(x)     (LP8725_LDO_VOL_CONTR_BASE + x)
 103
 104 const static int ldo_voltage_map[] = {
 105         1200, 1250, 1300, 1350, 1400, 1450, 1500, 1550,
 106         1600, 1650, 1700, 1750, 1800, 1850, 1900, 2000,
 107         2100, 2200, 2300, 2400, 2500, 2600, 2650, 2700,
 108         2750, 2800, 2850, 2900, 2950, 3000, 3100, 3300,
 109 };
 110
 111 #define LDO_VOL_CONTR_MASK 0x1f
 112 #define LDO_VOL_MIN_IDX 0x00
 113 #define LDO_VOL_MAX_IDX 0x1f
 114
 115 #define LP8725_LILO_ENABLE_REG 0x0d
 116 #define LP8725_LILO_VOL_CONTR_BASE 0x06
 117
 118 #define LP8725_LILO_VOL_CONTR_REG(x)    (LP8725_LILO_VOL_CONTR_BASE + x)
 119
 120 const static int lilo_voltage_map[] = {
 121          800,  850,  900,  950, 1000, 1050, 1100, 1150,
 122         1200, 1250, 1300, 1350, 1400, 1500, 1600, 1700,
 123         1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500,
 124         2600, 2700, 2800, 2850, 2900, 3000, 3100, 3300,
 125 };
 126
 127 #define LILO_VOL_CONTR_MASK 0x1f
 128 #define LILO_VOL_MIN_IDX 0x00
 129 #define LILO_VOL_MAX_IDX 0x1f
 130
 131
 132 static int lp8725_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
 133 {
 134         return 1000 * ldo_voltage_map[index];
 135 }
 136
 137 static int lp8725_ldo_is_enabled(struct regulator_dev *dev)
 138 {
 139         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 140         int ldo = rdev_get_id(dev) - LP8725_LDO1;
 141         u16 mask = 1 << (ldo);
 142         u16 val;
 143
 144         val = lp8725_reg_read(lp8725, LP8725_LDO_ENABLE_REG);
 145         return (val & mask) != 0;
 146 }
 147
 148 static int lp8725_ldo_enable(struct regulator_dev *dev)
 149 {
 150         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 151         int ldo = rdev_get_id(dev) - LP8725_LDO1;
 152         u16 mask = 1 << (ldo);
 153         return lp8725_set_bits(lp8725, LP8725_LDO_ENABLE_REG, mask, mask);
 154 }
 155
 156 static int lp8725_ldo_disable(struct regulator_dev *dev)
 157 {
 158         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 159         int ldo = rdev_get_id(dev) - LP8725_LDO1;
 160         u16 mask = 1 << (ldo);
 161         return lp8725_set_bits(lp8725, LP8725_LDO_ENABLE_REG, mask, 0);
 162 }
 163
 164 static int lp8725_ldo_get_voltage(struct regulator_dev *dev)
 165 {
 166         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 167         int ldo = rdev_get_id(dev) - LP8725_LDO1;
 168         u16 reg;
 169         u32 val;
 170
 171         reg = lp8725_reg_read(lp8725, LP8725_LDO_VOL_CONTR_REG(ldo));
 172         reg &= BUCK_TARGET_VOL_MASK;
 173
 174         val = 1000 * ldo_voltage_map[reg];
 175         return val;
 176 }
 177
 178 static int lp8725_ldo_set_voltage(struct regulator_dev *dev,
 179                                   int min_uV, int max_uV)
 180 {
 181         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 182         int ldo = rdev_get_id(dev) - LP8725_LDO1;
 183         int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
 184         const int *vol_map = ldo_voltage_map;
 185         u16 val;
 186
 187         if (min_vol < vol_map[LDO_VOL_MIN_IDX] ||
 188             min_vol > vol_map[LDO_VOL_MAX_IDX])
 189                 return -EINVAL;
 190
 191         for (val = LDO_VOL_MIN_IDX; val <= LDO_VOL_MAX_IDX; val++)
 192                 if (vol_map[val] >= min_vol)
 193                         break;
 194
 195         if (vol_map[val] > max_vol)
 196                 return -EINVAL;
 197
 198         DBG("***run in %s %d reg=0x%x val=0x%x",__FUNCTION__,__LINE__,LP8725_LDO_VOL_CONTR_REG(ldo),val);
 199
 200         return lp8725_set_bits(lp8725, LP8725_LDO_VOL_CONTR_REG(ldo),
 201                 LDO_VOL_CONTR_MASK, val);
 202 }
 203
 204 static struct regulator_ops lp8725_ldo_ops = {
 205         .list_voltage = lp8725_ldo_list_voltage,
 206         .is_enabled = lp8725_ldo_is_enabled,
 207         .enable = lp8725_ldo_enable,
 208         .disable = lp8725_ldo_disable,
 209         .get_voltage = lp8725_ldo_get_voltage,
 210         .set_voltage = lp8725_ldo_set_voltage,
 211 };
 212
 213 static int lp8725_lilo_list_voltage(struct regulator_dev *dev, unsigned index)
 214 {
 215         return 1000 * lilo_voltage_map[index];
 216 }
 217
 218 static int lp8725_lilo_is_enabled(struct regulator_dev *dev)
 219 {
 220         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 221         int lilo = rdev_get_id(dev) - LP8725_LILO1;
 222         u16 mask = 1 << (lilo+5);
 223         u16 val;
 224
 225         val = lp8725_reg_read(lp8725, LP8725_LILO_ENABLE_REG);
 226         return (val & mask) != 0;
 227 }
 228
 229 static int lp8725_lilo_enable(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+5);
 234
 235         return lp8725_set_bits(lp8725, LP8725_LILO_ENABLE_REG, mask, mask);
 236 }
 237
 238 static int lp8725_lilo_disable(struct regulator_dev *dev)
 239 {
 240         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 241         int lilo = rdev_get_id(dev) - LP8725_LILO1;
 242         u16 mask = 1 << (lilo+5);
 243
 244         return lp8725_set_bits(lp8725, LP8725_LILO_ENABLE_REG, mask, 0);
 245 }
 246
 247 static int lp8725_lilo_get_voltage(struct regulator_dev *dev)
 248 {
 249         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 250         int lilo = rdev_get_id(dev) - LP8725_LILO1;
 251         u16 reg;
 252         u32 val;
 253
 254         reg = lp8725_reg_read(lp8725, LP8725_LILO_VOL_CONTR_REG(lilo));
 255         reg &= BUCK_TARGET_VOL_MASK;
 256
 257         val = 1000 * lilo_voltage_map[reg];
 258         return val;
 259 }
 260
 261 static int lp8725_lilo_set_voltage(struct regulator_dev *dev,
 262                                   int min_uV, int max_uV)
 263 {
 264         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 265         int lilo = rdev_get_id(dev) - LP8725_LILO1;
 266         int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
 267         const int *vol_map = lilo_voltage_map;
 268         u16 val;
 269
 270         if (min_vol < vol_map[LILO_VOL_MIN_IDX] ||
 271             min_vol > vol_map[LILO_VOL_MAX_IDX])
 272                 return -EINVAL;
 273
 274         for (val = LILO_VOL_MIN_IDX; val <= LILO_VOL_MAX_IDX; val++)
 275                 if (vol_map[val] >= min_vol)
 276                         break;
 277
 278         if (vol_map[val] > max_vol)
 279                 return -EINVAL;
 280
 281         return lp8725_set_bits(lp8725, LP8725_LILO_VOL_CONTR_REG(lilo),
 282                 LILO_VOL_CONTR_MASK, val);
 283 }
 284
 285 static struct regulator_ops lp8725_lilo_ops = {
 286         .list_voltage = lp8725_lilo_list_voltage,
 287         .is_enabled = lp8725_lilo_is_enabled,
 288         .enable = lp8725_lilo_enable,
 289         .disable = lp8725_lilo_disable,
 290         .get_voltage = lp8725_lilo_get_voltage,
 291         .set_voltage = lp8725_lilo_set_voltage,
 292 };
 293
 294 static int lp8725_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
 295 {
 296         return 1000 * buck_voltage_map[index];
 297 }
 298
 299 static int lp8725_dcdc_is_enabled(struct regulator_dev *dev)
 300 {
 301         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 302         int buck = rdev_get_id(dev);
 303         u16 val;
 304         u16 mask,mask2;
 305
 306         switch(buck)
 307         {
 308         case LP8725_DCDC1:
 309                 mask = 1 << 0;
 310                 mask2 = 1 << 2;
 311                 val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
 312                 return ((val & mask) && (val & mask2)) != 0;
 313         case LP8725_DCDC2:
 314                 mask = 1 << 4;
 315                 mask2 = 1 << 3;
 316                 val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
 317                 return ((val & mask) && (val & mask2)) != 0;
 318         case LP8725_DCDC1_V2:
 319                 mask = 1 << 0;
 320                 mask2 = 1<< 2;
 321                 val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
 322                 return  ((val & mask) && (!(val & mask2))) !=0;
 323         case LP8725_DCDC2_V2:
 324                 mask = 1 << 4;
 325                 mask2 = 1 << 3;
 326                 val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
 327                 return ((val & mask) && (!(val & mask2))) !=0;
 328         }
 329 }
 330
 331 static int lp8725_dcdc_enable(struct regulator_dev *dev)
 332 {
 333         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 334         int buck = rdev_get_id(dev);
 335         u16 mask;
 336         int ret = 0;
 337         switch(buck)
 338         {
 339         case LP8725_DCDC1:
 340                 mask = 1 << 0;
 341                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
 342                 mask = 1 << 2;
 343                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
 344                 break;
 345         case LP8725_DCDC1_V2:
 346                 mask = 1 << 0;
 347                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
 348                 mask = 1 << 2;
 349                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, 0);
 350                 break;
 351         case LP8725_DCDC2:
 352                 mask = 1 << 4;
 353                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
 354                 mask = 1 << 3;
 355                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
 356                 break;
 357         case LP8725_DCDC2_V2:
 358                 mask = 1 << 4;
 359                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
 360                 mask = 1 << 3;
 361                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, 0);
 362                 break;
 363         }
 364         dev->use_count--;
 365         return ret;
 366 }
 367
 368 static int lp8725_dcdc_disable(struct regulator_dev *dev)
 369 {
 370         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 371         int buck = rdev_get_id(dev) ;
 372         u16 mask;
 373
 374         switch(buck)
 375         {
 376         case LP8725_DCDC1:
 377         case LP8725_DCDC1_V2:
 378                 mask = 1 << 0;
 379                 return lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, 0);
 380         case LP8725_DCDC2:
 381         case LP8725_DCDC2_V2:
 382                 mask = 1 << 4;
 383                 return lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask,0);
 384         }
 385 }
 386
 387 static int lp8725_dcdc_get_voltage(struct regulator_dev *dev)
 388 {
 389         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 390         int buck = rdev_get_id(dev) ;
 391         u16 reg = 0;
 392         int val;
 393
 394         switch(buck)
 395         {
 396         case LP8725_DCDC1:
 397         case LP8725_DCDC2:
 398                 buck -= LP8725_DCDC1;
 399                 reg = lp8725_reg_read(lp8725, LP8725_BUCK_TARGET_VOL1_REG(buck));
 400                 break;
 401         case LP8725_DCDC1_V2:
 402         case LP8725_DCDC2_V2:
 403                 buck -= LP8725_DCDC1_V2;
 404                 reg = lp8725_reg_read(lp8725, LP8725_BUCK_TARGET_VOL2_REG(buck));
 405                 break;
 406         }
 407
 408         reg &= BUCK_TARGET_VOL_MASK;
 409         val = 1000 * buck_voltage_map[reg];
 410
 411         return val;
 412 }
 413
 414 static int lp8725_dcdc_set_voltage(struct regulator_dev *dev,
 415                                   int min_uV, int max_uV)
 416 {
 417         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 418         int buck = rdev_get_id(dev);
 419         int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
 420         const int *vol_map = buck_voltage_map;
 421         u16 val;
 422         int ret = 0;
 423
 424         if (min_vol < vol_map[BUCK_TARGET_VOL_MIN_IDX] ||
 425             min_vol > vol_map[BUCK_TARGET_VOL_MAX_IDX])
 426                 return -EINVAL;
 427
 428         for (val = BUCK_TARGET_VOL_MIN_IDX; val <= BUCK_TARGET_VOL_MAX_IDX;
 429              val++)
 430                 if (vol_map[val] >= min_vol)
 431                         break;
 432
 433         if (vol_map[val] > max_vol)
 434                 return -EINVAL;
 435
 436         switch(buck)
 437         {
 438         case LP8725_DCDC1:
 439         case LP8725_DCDC2:
 440                 buck -= LP8725_DCDC1;
 441                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_TARGET_VOL1_REG(buck),
 442                 BUCK_TARGET_VOL_MASK, val);
 443                 if (ret)
 444                         return ret;
 445                 break;
 446         case LP8725_DCDC1_V2:
 447         case LP8725_DCDC2_V2:
 448                 buck -= LP8725_DCDC1_V2;
 449                 ret = lp8725_set_bits(lp8725, LP8725_BUCK_TARGET_VOL2_REG(buck),
 450                 BUCK_TARGET_VOL_MASK, val);
 451                 if (ret)
 452                         return ret;
 453                 break;
 454         }
 455
 456         return ret;
 457 }
 458
 459 static unsigned int lp8725_dcdc_get_mode(struct regulator_dev *dev)
 460 {
 461         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 462         u16 mask = 1 << 1;
 463         u16 val;
 464         val = lp8725_reg_read(lp8725, LP8725_BUCK_VOL_ENABLE_REG);
 465         if ((val & mask) == 0)
 466                 return REGULATOR_MODE_NORMAL;
 467         else
 468                 return REGULATOR_MODE_IDLE;
 469 }
 470
 471 static int lp8725_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
 472 {
 473         struct lp8725 *lp8725 = rdev_get_drvdata(dev);
 474         u16 mask = 1 << 1;
 475         switch(mode)
 476         {
 477         case REGULATOR_MODE_NORMAL:
 478                 return lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, 0);
 479         case REGULATOR_MODE_IDLE:
 480                 return lp8725_set_bits(lp8725, LP8725_BUCK_VOL_ENABLE_REG, mask, mask);
 481         default:
 482                 printk("error:pmu_lp8725 only normal and idle mode\n");
 483                 return -EINVAL;
 484         }
 485 }
 486
 487 static struct regulator_ops lp8725_dcdc_ops = {
 488         .list_voltage = lp8725_dcdc_list_voltage,
 489         .is_enabled = lp8725_dcdc_is_enabled,
 490         .enable = lp8725_dcdc_enable,
 491         .disable = lp8725_dcdc_disable,
 492         .get_voltage = lp8725_dcdc_get_voltage,
 493         .set_voltage = lp8725_dcdc_set_voltage,
 494         .get_mode = lp8725_dcdc_get_mode,
 495         .set_mode = lp8725_dcdc_set_mode,
 496 };
 497
 498 static struct regulator_desc regulators[] = {
 499         {
 500                 .name = "LDO1",
 501                 .id = LP8725_LDO1,
 502                 .ops = &lp8725_ldo_ops,
 503                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 504                 .type = REGULATOR_VOLTAGE,
 505                 .owner = THIS_MODULE,
 506         },
 507         {
 508                 .name = "LDO2",
 509                 .id = LP8725_LDO2,
 510                 .ops = &lp8725_ldo_ops,
 511                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 512                 .type = REGULATOR_VOLTAGE,
 513                 .owner = THIS_MODULE,
 514         },
 515         {
 516                 .name = "LDO3",
 517                 .id = LP8725_LDO3,
 518                 .ops = &lp8725_ldo_ops,
 519                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 520                 .type = REGULATOR_VOLTAGE,
 521                 .owner = THIS_MODULE,
 522         },
 523         {
 524                 .name = "LDO4",
 525                 .id = LP8725_LDO4,
 526                 .ops = &lp8725_ldo_ops,
 527                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 528                 .type = REGULATOR_VOLTAGE,
 529                 .owner = THIS_MODULE,
 530         },
 531         {
 532                 .name = "LDO5",
 533                 .id = LP8725_LDO5,
 534                 .ops = &lp8725_ldo_ops,
 535                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 536                 .type = REGULATOR_VOLTAGE,
 537                 .owner = THIS_MODULE,
 538         },
 539         {
 540                 .name = "LILO1",
 541                 .id = LP8725_LILO1,
 542                 .ops = &lp8725_lilo_ops,
 543                 .n_voltages = ARRAY_SIZE(lilo_voltage_map),
 544                 .type = REGULATOR_VOLTAGE,
 545                 .owner = THIS_MODULE,
 546         },
 547         {
 548                 .name = "LILO2",
 549                 .id = LP8725_LILO2,
 550                 .ops = &lp8725_lilo_ops,
 551                 .n_voltages = ARRAY_SIZE(lilo_voltage_map),
 552                 .type = REGULATOR_VOLTAGE,
 553                 .owner = THIS_MODULE,
 554         },
 555         {
 556                 .name = "DCDC1",
 557                 .id = LP8725_DCDC1,
 558                 .ops = &lp8725_dcdc_ops,
 559                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 560                 .type = REGULATOR_VOLTAGE,
 561                 .owner = THIS_MODULE,
 562         },
 563         {
 564                 .name = "DCDC2",
 565                 .id = LP8725_DCDC2,
 566                 .ops = &lp8725_dcdc_ops,
 567                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 568                 .type = REGULATOR_VOLTAGE,
 569                 .owner = THIS_MODULE,
 570         },
 571         {
 572                 .name = "DCDC1_V2",
 573                 .id = LP8725_DCDC1_V2,
 574                 .ops = &lp8725_dcdc_ops,
 575                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 576                 .type = REGULATOR_VOLTAGE,
 577                 .owner = THIS_MODULE,
 578         },
 579         {
 580                 .name = "DCDC2_V2",
 581                 .id = LP8725_DCDC2_V2,
 582                 .ops = &lp8725_dcdc_ops,
 583                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 584                 .type = REGULATOR_VOLTAGE,
 585                 .owner = THIS_MODULE,
 586         },
 587 };
 588
 589 static int lp8725_i2c_read(struct i2c_client *i2c, char reg, int count, u16 *dest)
 590 {
 591     int ret;
 592     struct i2c_adapter *adap;
 593     struct i2c_msg msgs[2];
 594
 595     if(!i2c)
 596                 return ret;
 597
 598         if (count != 1)
 599                 return -EIO;
 600
 601     adap = i2c->adapter;
 602
 603     msgs[0].addr = i2c->addr;
 604     msgs[0].buf = &reg;
 605     msgs[0].flags = i2c->flags;
 606     msgs[0].len = 1;
 607     msgs[0].scl_rate = 200*1000;
 608
 609     msgs[1].buf = dest;
 610     msgs[1].addr = i2c->addr;
 611     msgs[1].flags = i2c->flags | I2C_M_RD;
 612     msgs[1].len = 1;
 613     msgs[1].scl_rate = 200*1000;
 614     ret = i2c_transfer(adap, msgs, 2);
 615
 616         DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
 617
 618         return 0;
 619 }
 620
 621 static int lp8725_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
 622 {
 623         int ret=-1;
 624
 625         struct i2c_adapter *adap;
 626         struct i2c_msg msg;
 627         char tx_buf[2];
 628
 629         if(!i2c)
 630                 return ret;
 631         if (count != 1)
 632                 return -EIO;
 633
 634         adap = i2c->adapter;
 635         tx_buf[0] = reg;
 636         tx_buf[1] = src;
 637
 638         msg.addr = i2c->addr;
 639         msg.buf = &tx_buf[0];
 640         msg.len = 1 +1;
 641         msg.flags = i2c->flags;
 642         msg.scl_rate = 200*1000;
 643
 644         ret = i2c_transfer(adap, &msg, 1);
 645         return ret;
 646 }
 647
 648 static u8 lp8725_reg_read(struct lp8725 *lp8725, u8 reg)
 649 {
 650         u16 val = 0;
 651
 652         mutex_lock(&lp8725->io_lock);
 653
 654         lp8725_i2c_read(lp8725->i2c, reg, 1, &val);
 655
 656         DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 657
 658         mutex_unlock(&lp8725->io_lock);
 659
 660         return val & 0xff;
 661 }
 662
 663 static int lp8725_set_bits(struct lp8725 *lp8725, u8 reg, u16 mask, u16 val)
 664 {
 665         u16 tmp;
 666         int ret;
 667
 668         mutex_lock(&lp8725->io_lock);
 669
 670         ret = lp8725_i2c_read(lp8725->i2c, reg, 1, &tmp);
 671         tmp = (tmp & ~mask) | val;
 672         if (ret == 0) {
 673                 ret = lp8725_i2c_write(lp8725->i2c, reg, 1, tmp);
 674                 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 675         }
 676         mutex_unlock(&lp8725->io_lock);
 677
 678         return ret;
 679 }
 680
 681
 682 //add by robert for power on bp
 683 #define AP_TD_UNDEFINED_GBIN5 FPGA_PIO2_02
 684 #define AP_RESET_TD FPGA_PIO2_04
 685 #define AP_SHUTDOWN_TD_PMU FPGA_PIO2_05
 686 #define AP_PW_EN_TD FPGA_PIO2_03
 687
 688 static int bp_power_on(void)
 689 {
 690         int ret=0;
 691
 692         ret = gpio_request(AP_TD_UNDEFINED_GBIN5, NULL);
 693         if (ret) {
 694                 printk("%s:failed to request fpga s %d\n",__FUNCTION__,__LINE__);
 695                 goto err;
 696         }
 697         ret = gpio_request(AP_RESET_TD, NULL);
 698         if (ret) {
 699                 printk("%s:failed to request fpga s %d\n",__FUNCTION__,__LINE__);
 700                 goto err0;
 701         }
 702
 703
 704         ret = gpio_request(AP_SHUTDOWN_TD_PMU, NULL);
 705         if (ret) {
 706                 printk("%s:failed to request fpga %d\n",__FUNCTION__,__LINE__);
 707                 goto err1;
 708         }
 709
 710         ret = gpio_request(AP_PW_EN_TD, NULL);
 711         if (ret) {
 712                 printk("%s:failed to request fpga  %d\n",__FUNCTION__,__LINE__);
 713                 goto err2;
 714         }
 715
 716         gpio_set_value(AP_TD_UNDEFINED_GBIN5, 1);
 717        gpio_direction_output(AP_TD_UNDEFINED_GBIN5, 1);
 718         gpio_direction_input(AP_RESET_TD);
 719
 720          gpio_set_value(AP_SHUTDOWN_TD_PMU, 0);
 721         gpio_direction_output(AP_SHUTDOWN_TD_PMU, 0);
 722
 723         gpio_set_value(AP_PW_EN_TD, 0);
 724         gpio_direction_output(AP_PW_EN_TD, 0);
 725         mdelay(1);
 726         gpio_set_value(AP_PW_EN_TD, 1);
 727         mdelay(1200);
 728         gpio_set_value(AP_PW_EN_TD, 0);
 729
 730         return true;
 731 err2:
 732         gpio_free(AP_SHUTDOWN_TD_PMU);
 733 err1:
 734         gpio_free(AP_RESET_TD);
 735 err0:
 736         gpio_free(AP_TD_UNDEFINED_GBIN5);
 737 err:
 738         return false;
 739 }
 740
 741
 742
 743 static int bp_power_off(struct notifier_block *this,
 744                                         unsigned long code, void *unused)
 745 {
 746         printk("+++--++++++%s_________%d \r\n",__FUNCTION__,code);
 747
 748          gpio_set_value(AP_TD_UNDEFINED_GBIN5, 0);
 749
 750         gpio_set_value(AP_PW_EN_TD, 0);
 751         //gpio_direction_output(AP_PW_EN_TD, 0);
 752         mdelay(1);
 753         gpio_set_value(AP_PW_EN_TD, 1);
 754         mdelay(1200);
 755         gpio_set_value(AP_PW_EN_TD, 0);
 756
 757         mdelay(5000);
 758          gpio_set_value(AP_SHUTDOWN_TD_PMU, 1);
 759         mdelay(1200);
 760         // gpio_free(AP_PW_EN_TD);
 761 printk("++++--+++++%s   ok_________\r\n",__FUNCTION__);
 762          return NOTIFY_DONE;
 763 }
 764 //add end
 765
 766 static int lp8725_set_init(void)
 767 {
 768         int tmp = 0;
 769         struct regulator *ldo1,*ldo2,*ldo3,*ldo4,*ldo5;
 770         struct regulator *lilo1,*lilo2;
 771         struct regulator *buck1,*buck2;
 772
 773         DBG_INFO("***run in %s %d ",__FUNCTION__,__LINE__);
 774
 775         /*init ldo1*/
 776         DBG_INFO("***ldo1 vcc init\n");
 777         ldo1 = regulator_get(NULL, "ldo1");
 778         regulator_enable(ldo1);
 779 //      regulator_set_voltage(ldo1,2500000,2500000);
 780         tmp = regulator_get_voltage(ldo1);
 781         DBG_INFO("***regulator_set_init: ldo1 vcc =%d\n",tmp);
 782
 783         /*init ldo2*/
 784         DBG_INFO("***ldo2 vcc init\n");
 785         ldo2 = regulator_get(NULL, "ldo2");
 786         regulator_enable(ldo2);
 787 //      regulator_set_voltage(ldo2,3000000,3000000);
 788         tmp = regulator_get_voltage(ldo2);
 789         DBG_INFO("***regulator_set_init: ldo2 vcc =%d\n",tmp);
 790
 791         /*init ldo3*/
 792         DBG_INFO("***ldo3 vcc init\n");
 793         ldo3 = regulator_get(NULL, "ldo3");
 794         regulator_enable(ldo3);
 795 //      regulator_set_voltage(ldo3,3000000,3000000);
 796         tmp = regulator_get_voltage(ldo3);
 797         DBG_INFO("***regulator_set_init: ldo3 vcc =%d\n",tmp);
 798
 799         /*init ldo4*/
 800         DBG_INFO("***ldo4 vcc init\n");
 801         ldo4 = regulator_get(NULL, "ldo4");
 802         regulator_enable(ldo4);
 803 //      regulator_set_voltage(ldo4,1900000,1900000);
 804         tmp = regulator_get_voltage(ldo4);
 805         DBG_INFO("***regulator_set_init: ldo4 vcc =%d\n",tmp);
 806
 807         /*init ldo5*/
 808         DBG_INFO("***ldo5 vcc init\n");
 809         ldo5 = regulator_get(NULL, "ldo5");
 810         regulator_enable(ldo5);
 811         regulator_set_voltage(ldo5,1800000,1800000);
 812         tmp = regulator_get_voltage(ldo5);
 813         DBG_INFO("***regulator_set_init: ldo5 vcc =%d\n",tmp);
 814
 815         /*init lilo1*/
 816         DBG_INFO("***lilo1 vcc init\n");
 817         lilo1 = regulator_get(NULL, "lilo1");
 818         regulator_enable(lilo1);
 819 //      regulator_set_voltage(lilo1,3300000,3300000);
 820         tmp = regulator_get_voltage(lilo1);
 821         DBG_INFO("***regulator_set_init: lilo1 vcc =%d\n",tmp);
 822
 823         /*init lilo2*/
 824         DBG_INFO("***lilo2 vcc init\n");
 825         lilo2 = regulator_get(NULL, "lilo2");
 826         regulator_enable(lilo2);
 827 //      regulator_set_voltage(lilo2,3300000,3300000);
 828         tmp = regulator_get_voltage(lilo2);
 829         DBG_INFO("***regulator_set_init: lilo2 vcc =%d\n",tmp);
 830
 831         /*init buck1*/
 832         DBG_INFO("***buck1 vcc init\n");
 833         buck1 = regulator_get(NULL, "vdd12");
 834 //      regulator_set_voltage(buck1,1200000,1200000);
 835         tmp = regulator_get_voltage(buck1);
 836         DBG_INFO("***regulator_set_init: buck1 vcc =%d\n",tmp);
 837
 838         /*init buck2*/
 839         DBG_INFO("***buck2 vcc init\n");
 840         buck2 = regulator_get(NULL, "vccdr");
 841 //      regulator_set_voltage(buck1,1800000,1800000);
 842         tmp = regulator_get_voltage(buck2);
 843         DBG_INFO("***regulator_set_init: buck2 vcc =%d\n",tmp);
 844
 845
 846 //add by robert for power on bp
 847         bp_power_on();
 848 //end add
 849
 850         return(0);
 851 }
 852
 853
 854 static int __devinit setup_regulators(struct lp8725 *lp8725, struct lp8725_platform_data *pdata)
 855 {
 856         int i, err;
 857
 858         lp8725->num_regulators = pdata->num_regulators;
 859         lp8725->rdev = kcalloc(pdata->num_regulators,
 860                                sizeof(struct regulator_dev *), GFP_KERNEL);
 861         if (!lp8725->rdev) {
 862                 return -ENOMEM;
 863         }
 864
 865         /* Instantiate the regulators */
 866         for (i = 0; i < pdata->num_regulators; i++) {
 867                 int id = pdata->regulators[i].id;
 868                 lp8725->rdev[i] = regulator_register(&regulators[id],
 869                         lp8725->dev, pdata->regulators[i].initdata, lp8725);
 870
 871                 if (IS_ERR(lp8725->rdev[i])) {
 872                         err = PTR_ERR(lp8725->rdev[i]);
 873                         dev_err(lp8725->dev, "regulator init failed: %d\n",
 874                                 err);
 875                         goto error;
 876                 }
 877         }
 878
 879         return 0;
 880 error:
 881         while (--i >= 0)
 882                 regulator_unregister(lp8725->rdev[i]);
 883         kfree(lp8725->rdev);
 884         lp8725->rdev = NULL;
 885         return err;
 886 }
 887
 888 static int __devinit lp8725_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
 889 {
 890         struct lp8725 *lp8725;
 891         struct lp8725_platform_data *pdata = i2c->dev.platform_data;
 892         int ret;
 893
 894         lp8725 = kzalloc(sizeof(struct lp8725), GFP_KERNEL);
 895         if (lp8725 == NULL) {
 896                 ret = -ENOMEM;
 897                 goto err;
 898         }
 899
 900         lp8725->i2c = i2c;
 901         lp8725->dev = &i2c->dev;
 902         i2c_set_clientdata(i2c, lp8725);
 903
 904         mutex_init(&lp8725->io_lock);
 905
 906         if (pdata) {
 907                 ret = setup_regulators(lp8725, pdata);
 908                 if (ret < 0)
 909                         goto err;
 910         } else
 911                 dev_warn(lp8725->dev, "No platform init data supplied\n");
 912
 913         lp8725_set_init();
 914
 915         return 0;
 916
 917 err:
 918         return ret;
 919 }
 920
 921 static int __devexit lp8725_i2c_remove(struct i2c_client *i2c)
 922 {
 923         struct lp8725 *lp8725 = i2c_get_clientdata(i2c);
 924         int i;
 925
 926         for (i = 0; i < lp8725->num_regulators; i++)
 927                 if (lp8725->rdev[i])
 928                         regulator_unregister(lp8725->rdev[i]);
 929         kfree(lp8725->rdev);
 930         i2c_set_clientdata(i2c, NULL);
 931         kfree(lp8725);
 932
 933         return 0;
 934 }
 935
 936 static const struct i2c_device_id lp8725_i2c_id[] = {
 937        { "lp8725", 0 },
 938        { }
 939 };
 940
 941 MODULE_DEVICE_TABLE(i2c, lp8725_i2c_id);
 942
 943 static struct i2c_driver lp8725_i2c_driver = {
 944         .driver = {
 945                 .name = "lp8725",
 946                 .owner = THIS_MODULE,
 947         },
 948         .probe    = lp8725_i2c_probe,
 949         .remove   = __devexit_p(lp8725_i2c_remove),
 950         .id_table = lp8725_i2c_id,
 951 };
 952
 953
 954 //add by robert for bp powerdown register
 955 static struct notifier_block BP_powerdown_notifier = {
 956         .notifier_call =        bp_power_off,
 957 };
 958 //end add
 959
 960
 961
 962 static int __init lp8725_module_init(void)
 963 {
 964         int ret;
 965
 966         ret = i2c_add_driver(&lp8725_i2c_driver);
 967         if (ret != 0)
 968                 pr_err("Failed to register I2C driver: %d\n", ret);
 969
 970         //add by robert for bp powerdown register
 971         ret = register_reboot_notifier(&BP_powerdown_notifier);
 972         if (ret != 0)
 973                 {
 974                 printk("cannot register reboot notifier (err=%d), %s\n", ret,__FUNCTION__);
 975                 }
 976         //end add
 977
 978
 979         return ret;
 980 }
 981 module_init(lp8725_module_init);
 982
 983 static void __exit lp8725_module_exit(void)
 984 {
 985 //add by robert for bp power down
 986         unregister_reboot_notifier(&BP_powerdown_notifier);
 987 //end add
 988
 989         i2c_del_driver(&lp8725_i2c_driver);
 990 }
 991 module_exit(lp8725_module_exit);
 992
 993 MODULE_LICENSE("GPL");
 994 MODULE_AUTHOR("cym <cym@rock-chips.com>");
 995 MODULE_DESCRIPTION("LP8725 PMIC driver");