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