drivers/mfd/rk818.c

   1 /*
   2  * Regulator driver for rk818 PMIC chip for rk31xx
   3  *
   4  * Based on rk818.c that is work by zhangqing<zhangqing@rock-chips.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  */
  11
  12 #include <linux/bug.h>
  13 #include <linux/err.h>
  14 #include <linux/i2c.h>
  15 #include <linux/kernel.h>
  16 #include <linux/regulator/driver.h>
  17 #include <linux/mfd/rk818.h>
  18 #include <linux/mfd/core.h>
  19 #include <linux/delay.h>
  20 #include <linux/slab.h>
  21 #include <linux/mutex.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/module.h>
  24 #include <linux/of_irq.h>
  25 #include <linux/of_gpio.h>
  26 #include <linux/of.h>
  27 #include <linux/of_device.h>
  28 #include <linux/regulator/of_regulator.h>
  29 #include <linux/regulator/driver.h>
  30 #include <linux/regulator/machine.h>
  31 #include <linux/regmap.h>
  32 #include <linux/syscore_ops.h>
  33
  34
  35 #if 0
  36 #define DBG(x...)       printk(KERN_INFO x)
  37 #else
  38 #define DBG(x...)
  39 #endif
  40 #if 1
  41 #define DBG_INFO(x...)  printk(KERN_INFO x)
  42 #else
  43 #define DBG_INFO(x...)
  44 #endif
  45 #define PM_CONTROL
  46
  47 struct rk818 *g_rk818;
  48
  49 static struct mfd_cell rk818s[] = {
  50         {
  51                 .name = "rk818-rtc",
  52         },
  53
  54         {
  55                 .name = "rk818-battery",
  56         },
  57         /*      {
  58                 .name = "rk818-power",
  59         },
  60         */
  61 };
  62
  63 #define BUCK_VOL_MASK 0x3f
  64 #define LDO_VOL_MASK 0x3f
  65 #define LDO9_VOL_MASK 0x1f
  66 #define BOOST_VOL_MASK 0xe0
  67
  68 #define VOL_MIN_IDX 0x00
  69 #define VOL_MAX_IDX 0x3f
  70 #define RK818_I2C_ADDR_RATE  200*1000
  71
  72 const static int buck_set_vol_base_addr[] = {
  73         RK818_BUCK1_ON_REG,
  74         RK818_BUCK2_ON_REG,
  75         RK818_BUCK3_CONFIG_REG,
  76         RK818_BUCK4_ON_REG,
  77 };
  78 const static int buck_set_slp_vol_base_addr[] = {
  79         RK818_BUCK1_SLP_REG,
  80         RK818_BUCK2_SLP_REG,
  81         RK818_BUCK3_CONFIG_REG,
  82         RK818_BUCK4_SLP_VSEL_REG,
  83 };
  84 const static int buck_contr_base_addr[] = {
  85         RK818_BUCK1_CONFIG_REG,
  86         RK818_BUCK2_CONFIG_REG,
  87         RK818_BUCK3_CONFIG_REG,
  88         RK818_BUCK4_CONFIG_REG,
  89 };
  90 #define rk818_BUCK_SET_VOL_REG(x) (buck_set_vol_base_addr[x])
  91 #define rk818_BUCK_CONTR_REG(x) (buck_contr_base_addr[x])
  92 #define rk818_BUCK_SET_SLP_VOL_REG(x) (buck_set_slp_vol_base_addr[x])
  93
  94
  95 const static int ldo_set_vol_base_addr[] = {
  96         RK818_LDO1_ON_VSEL_REG,
  97         RK818_LDO2_ON_VSEL_REG,
  98         RK818_LDO3_ON_VSEL_REG,
  99         RK818_LDO4_ON_VSEL_REG,
 100         RK818_LDO5_ON_VSEL_REG,
 101         RK818_LDO6_ON_VSEL_REG,
 102         RK818_LDO7_ON_VSEL_REG,
 103         RK818_LDO8_ON_VSEL_REG,
 104         RK818_BOOST_LDO9_ON_VSEL_REG,
 105 };
 106 const static int ldo_set_slp_vol_base_addr[] = {
 107         RK818_LDO1_SLP_VSEL_REG,
 108         RK818_LDO2_SLP_VSEL_REG,
 109         RK818_LDO3_SLP_VSEL_REG,
 110         RK818_LDO4_SLP_VSEL_REG,
 111         RK818_LDO5_SLP_VSEL_REG,
 112         RK818_LDO6_SLP_VSEL_REG,
 113         RK818_LDO7_SLP_VSEL_REG,
 114         RK818_LDO8_SLP_VSEL_REG,
 115         RK818_BOOST_LDO9_SLP_VSEL_REG,
 116 };
 117
 118 #define rk818_LDO_SET_VOL_REG(x) (ldo_set_vol_base_addr[x])
 119 #define rk818_LDO_SET_SLP_VOL_REG(x) (ldo_set_slp_vol_base_addr[x])
 120
 121 const static int buck_voltage_map[] = {
 122           700,  712,  725,  737,  750, 762,  775,  787,  800,
 123           812,  825,  837,  850,862,  875,  887,  900,  912,
 124           925,  937,  950, 962,  975,  987, 1000, 1012, 1025,
 125           1037, 1050,1062, 1075, 1087, 1100, 1112, 1125, 1137,
 126           1150,1162, 1175, 1187, 1200, 1212, 1225, 1237, 1250,
 127           1262, 1275, 1287, 1300, 1312, 1325, 1337, 1350,1362,
 128           1375, 1387, 1400, 1412, 1425, 1437, 1450,1462, 1475,
 129           1487, 1500,
 130 };
 131
 132 const static int buck4_voltage_map[] = {
 133            1800, 1900, 2000, 2100, 2200,  2300,  2400, 2500, 2600,
 134           2700, 2800, 2900, 3000, 3100, 3200,3300, 3400,3500,3600,
 135 };
 136
 137 const static int ldo_voltage_map[] = {
 138           1800, 1900, 2000, 2100, 2200,  2300,  2400, 2500, 2600,
 139           2700, 2800, 2900, 3000, 3100, 3200,3300, 3400,
 140 };
 141 const static int ldo3_voltage_map[] = {
 142          800, 900, 1000, 1100, 1200,  1300, 1400, 1500, 1600,
 143          1700, 1800, 1900,  2000,2100,  2200,  2500,
 144 };
 145 const static int ldo6_voltage_map[] = {
 146          800, 900, 1000, 1100, 1200,  1300, 1400, 1500, 1600,
 147          1700, 1800, 1900,  2000,2100,  2200,  2300,2400,2500,
 148 };
 149 const static int boost_voltage_map[] = {
 150          4700,4800,4900,5000,5100,5200,5300,5400,
 151 };
 152
 153 static int rk818_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
 154 {
 155         int ldo= rdev_get_id(dev) - RK818_LDO1;
 156         if (ldo == 2){
 157         if (index >= ARRAY_SIZE(ldo3_voltage_map))
 158                 return -EINVAL;
 159         return 1000 * ldo3_voltage_map[index];
 160         }
 161         else if (ldo == 5 || ldo ==6){
 162         if (index >= ARRAY_SIZE(ldo6_voltage_map))
 163                 return -EINVAL;
 164         return 1000 * ldo6_voltage_map[index];
 165         }
 166         else{
 167         if (index >= ARRAY_SIZE(ldo_voltage_map))
 168                 return -EINVAL;
 169         return 1000 * ldo_voltage_map[index];
 170         }
 171 }
 172 static int rk818_ldo_is_enabled(struct regulator_dev *dev)
 173 {
 174         struct rk818 *rk818 = rdev_get_drvdata(dev);
 175         int ldo= rdev_get_id(dev) - RK818_LDO1;
 176         u16 val;
 177
 178         if (ldo == 8){
 179                 val = rk818_reg_read(rk818, RK818_DCDC_EN_REG);  //ldo9
 180                 if (val < 0)
 181                         return val;
 182                 if (val & (1 << 5))
 183                         return 1;
 184                 else
 185                         return 0;
 186         }
 187         val = rk818_reg_read(rk818, RK818_LDO_EN_REG);
 188         if (val < 0)
 189                 return val;
 190         if (val & (1 << ldo))
 191                 return 1;
 192         else
 193                 return 0;
 194 }
 195 static int rk818_ldo_enable(struct regulator_dev *dev)
 196 {
 197         struct rk818 *rk818 = rdev_get_drvdata(dev);
 198         int ldo= rdev_get_id(dev) - RK818_LDO1;
 199
 200         if (ldo == 8)
 201                  rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << 5, 1 << 5); //ldo9
 202         else if (ldo ==9)
 203                 rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << 6, 1 << 6); //ldo10 switch
 204         else
 205                 rk818_set_bits(rk818, RK818_LDO_EN_REG, 1 << ldo, 1 << ldo);
 206
 207          return 0;
 208 }
 209 static int rk818_ldo_disable(struct regulator_dev *dev)
 210 {
 211         struct rk818 *rk818 = rdev_get_drvdata(dev);
 212         int ldo= rdev_get_id(dev) - RK818_LDO1;
 213
 214         if (ldo == 8)
 215                  rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << 5, 1 << 0); //ldo9
 216         else if(ldo ==9)
 217                 rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << 6, 1 << 0); //ldo10 switch
 218         else
 219                 rk818_set_bits(rk818, RK818_LDO_EN_REG, 1 << ldo, 0);
 220
 221          return 0;
 222 }
 223 static int rk818_ldo_get_voltage(struct regulator_dev *dev)
 224 {
 225         struct rk818 *rk818 = rdev_get_drvdata(dev);
 226         int ldo= rdev_get_id(dev) - RK818_LDO1;
 227         u16 reg = 0;
 228         int val;
 229
 230         if  (ldo ==9){
 231                 reg = rk818_reg_read(rk818,rk818_BUCK_SET_VOL_REG(3));
 232                 reg &= BUCK_VOL_MASK;
 233                 val = 1000 * buck4_voltage_map[reg];
 234         }
 235         else{
 236                 reg = rk818_reg_read(rk818,rk818_LDO_SET_VOL_REG(ldo));
 237                 if (ldo == 8){
 238                         reg &= LDO9_VOL_MASK;
 239                 }
 240                 else
 241                         reg &= LDO_VOL_MASK;
 242
 243                 if (ldo ==2){
 244                         val = 1000 * ldo3_voltage_map[reg];
 245                 }
 246                 else if (ldo == 5 || ldo ==6){
 247                         val = 1000 * ldo6_voltage_map[reg];
 248                 }
 249                 else{
 250                         val = 1000 * ldo_voltage_map[reg];
 251                 }
 252         }
 253         return val;
 254 }
 255 static int rk818_ldo_suspend_enable(struct regulator_dev *dev)
 256 {
 257         struct rk818 *rk818 = rdev_get_drvdata(dev);
 258         int ldo= rdev_get_id(dev) - RK818_LDO1;
 259
 260         if (ldo == 8)
 261                 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << 5, 0); //ldo9
 262         else if (ldo ==9)
 263                 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << 6, 0); //ldo10 switch
 264         else
 265                 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG2, 1 << ldo, 0);
 266
 267 }
 268 static int rk818_ldo_suspend_disable(struct regulator_dev *dev)
 269 {
 270         struct rk818 *rk818 = rdev_get_drvdata(dev);
 271         int ldo= rdev_get_id(dev) - RK818_LDO1;
 272
 273         if (ldo == 8)
 274                 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << 5, 1 << 5); //ldo9
 275         else if (ldo ==9)
 276                 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << 6, 1 << 6); //ldo10 switch
 277         else
 278                 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG2, 1 << ldo, 1 << ldo);
 279
 280 }
 281 static int rk818_ldo_set_sleep_voltage(struct regulator_dev *dev,
 282                                             int uV)
 283 {
 284         struct rk818 *rk818 = rdev_get_drvdata(dev);
 285         int ldo= rdev_get_id(dev) - RK818_LDO1;
 286         const int *vol_map = ldo_voltage_map;
 287         int min_vol = uV / 1000;
 288         u16 val;
 289         int ret = 0,num =0;
 290
 291         if (ldo ==2){
 292         vol_map = ldo3_voltage_map;
 293         num = 15;
 294         }
 295         else if (ldo == 5 || ldo ==6){
 296         vol_map = ldo6_voltage_map;
 297         num = 17;
 298         }
 299         else {
 300         num = 16;
 301         }
 302
 303         if (min_vol < vol_map[0] ||
 304             min_vol > vol_map[num])
 305                 return -EINVAL;
 306
 307         for (val = 0; val <= num; val++){
 308                 if (vol_map[val] >= min_vol)
 309                         break;
 310         }
 311
 312         if (ldo == 8){
 313                 ret = rk818_set_bits(rk818, rk818_LDO_SET_SLP_VOL_REG(ldo),LDO9_VOL_MASK, val);
 314         }
 315         else
 316                 ret = rk818_set_bits(rk818, rk818_LDO_SET_SLP_VOL_REG(ldo),LDO_VOL_MASK, val);
 317
 318         return ret;
 319 }
 320
 321 static int rk818_ldo_set_voltage(struct regulator_dev *dev,
 322                                   int min_uV, int max_uV,unsigned *selector)
 323 {
 324         struct rk818 *rk818 = rdev_get_drvdata(dev);
 325         int ldo= rdev_get_id(dev) - RK818_LDO1;
 326         const int *vol_map;
 327         int min_vol = min_uV / 1000;
 328         u16 val;
 329         int ret = 0,num =0;
 330
 331         if (ldo ==2){
 332         vol_map = ldo3_voltage_map;
 333         num = 15;
 334         }
 335         else if (ldo == 5 || ldo ==6){
 336         vol_map = ldo6_voltage_map;
 337         num = 17;
 338         }
 339         else {
 340         vol_map = ldo_voltage_map;
 341         num = 16;
 342         }
 343
 344         if (min_vol < vol_map[0] ||
 345             min_vol > vol_map[num])
 346                 return -EINVAL;
 347
 348         for (val = 0; val <= num; val++){
 349                 if (vol_map[val] >= min_vol)
 350                         break;
 351         }
 352
 353         if (ldo == 8){
 354                 ret = rk818_set_bits(rk818, rk818_LDO_SET_VOL_REG(ldo),LDO9_VOL_MASK, val);
 355         }
 356         else
 357                 ret = rk818_set_bits(rk818, rk818_LDO_SET_VOL_REG(ldo),LDO_VOL_MASK, val);
 358
 359         return ret;
 360
 361 }
 362
 363 static struct regulator_ops rk818_ldo_ops = {
 364         .set_voltage = rk818_ldo_set_voltage,
 365         .get_voltage = rk818_ldo_get_voltage,
 366         .list_voltage = rk818_ldo_list_voltage,
 367         .is_enabled = rk818_ldo_is_enabled,
 368         .enable = rk818_ldo_enable,
 369         .disable = rk818_ldo_disable,
 370         .set_suspend_enable =rk818_ldo_suspend_enable,
 371         .set_suspend_disable =rk818_ldo_suspend_disable,
 372         .set_suspend_voltage = rk818_ldo_set_sleep_voltage,
 373 };
 374
 375 static int rk818_dcdc_list_voltage(struct regulator_dev *dev, unsigned selector)
 376 {
 377         int volt;
 378         int buck = rdev_get_id(dev) - RK818_DCDC1;
 379
 380         if (selector < 0x0 ||selector > BUCK_VOL_MASK )
 381                 return -EINVAL;
 382
 383         switch (buck) {
 384         case 0:
 385         case 1:
 386                 volt = 700000 + selector * 12500;
 387                 break;
 388         case 3:
 389                 volt = 1800000 + selector * 100000;
 390                 break;
 391         case 2:
 392                 volt = 1200000;
 393                 break;
 394         default:
 395                 BUG();
 396                 return -EINVAL;
 397         }
 398
 399         return  volt ;
 400 }
 401 static int rk818_dcdc_is_enabled(struct regulator_dev *dev)
 402 {
 403         struct rk818 *rk818 = rdev_get_drvdata(dev);
 404         int buck = rdev_get_id(dev) - RK818_DCDC1;
 405         u16 val;
 406
 407         val = rk818_reg_read(rk818, RK818_DCDC_EN_REG);
 408         if (val < 0)
 409                 return val;
 410         if (val & (1 << buck))
 411                 return 1;
 412         else
 413                 return 0;
 414 }
 415 static int rk818_dcdc_enable(struct regulator_dev *dev)
 416 {
 417         struct rk818 *rk818 = rdev_get_drvdata(dev);
 418         int buck = rdev_get_id(dev) - RK818_DCDC1;
 419
 420         return rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << buck, 1 << buck);
 421
 422 }
 423 static int rk818_dcdc_disable(struct regulator_dev *dev)
 424 {
 425         struct rk818 *rk818 = rdev_get_drvdata(dev);
 426         int buck = rdev_get_id(dev) - RK818_DCDC1;
 427
 428          return rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << buck , 0);
 429 }
 430 static int rk818_dcdc_get_voltage(struct regulator_dev *dev)
 431 {
 432         struct rk818 *rk818 = rdev_get_drvdata(dev);
 433         int buck = rdev_get_id(dev) - RK818_DCDC1;
 434         u16 reg = 0;
 435         int val;
 436
 437         reg = rk818_reg_read(rk818,rk818_BUCK_SET_VOL_REG(buck));
 438
 439         reg &= BUCK_VOL_MASK;
 440         val = rk818_dcdc_list_voltage(dev,reg);
 441         return val;
 442 }
 443 static int rk818_dcdc_select_min_voltage(struct regulator_dev *dev,
 444                                            int min_uV, int max_uV ,int buck)
 445 {
 446         u16 vsel =0;
 447
 448         if (buck == 0 || buck ==  1){
 449                 if (min_uV < 700000)
 450                 vsel = 0;
 451                 else if (min_uV <= 1500000)
 452                 vsel = ((min_uV - 700000) / 12500) ;
 453                 else
 454                 return -EINVAL;
 455         }
 456         else if (buck ==3){
 457                 if (min_uV < 1800000)
 458                 vsel = 0;
 459                 else if (min_uV <= 3300000)
 460                 vsel = ((min_uV - 1800000) / 100000) ;
 461                 else
 462                 return -EINVAL;
 463         }
 464         if (rk818_dcdc_list_voltage(dev, vsel) > max_uV)
 465                 return -EINVAL;
 466         return vsel;
 467 }
 468
 469 static int rk818_dcdc_set_voltage(struct regulator_dev *dev,
 470                                   int min_uV, int max_uV,unsigned *selector)
 471 {
 472         struct rk818 *rk818 = rdev_get_drvdata(dev);
 473         int buck = rdev_get_id(dev) - RK818_DCDC1;
 474         u16 val;
 475         int ret = 0;
 476
 477         if (buck ==2){
 478                 return 0;
 479         }else if (buck==3){
 480                 val = rk818_dcdc_select_min_voltage(dev,min_uV,max_uV,buck);
 481                 ret = rk818_set_bits(rk818, rk818_BUCK_SET_VOL_REG(buck), BUCK_VOL_MASK, val);
 482         }
 483         val = rk818_dcdc_select_min_voltage(dev,min_uV,max_uV,buck);
 484         ret = rk818_set_bits(rk818, rk818_BUCK_SET_VOL_REG(buck), BUCK_VOL_MASK, val);
 485         return ret;
 486 }
 487 static int rk818_dcdc_set_sleep_voltage(struct regulator_dev *dev,
 488                                             int uV)
 489 {
 490         struct rk818 *rk818 = rdev_get_drvdata(dev);
 491         int buck = rdev_get_id(dev) - RK818_DCDC1;
 492         u16 val;
 493         int ret = 0;
 494
 495         if (buck ==2){
 496         return 0;
 497         }else{
 498         val = rk818_dcdc_select_min_voltage(dev,uV,uV,buck);
 499         ret = rk818_set_bits(rk818, rk818_BUCK_SET_SLP_VOL_REG(buck) , BUCK_VOL_MASK, val);
 500         }
 501         return ret;
 502 }
 503 static unsigned int rk818_dcdc_get_mode(struct regulator_dev *dev)
 504 {
 505         struct rk818 *rk818 = rdev_get_drvdata(dev);
 506         int buck = rdev_get_id(dev) - RK818_DCDC1;
 507         u16 mask = 0x80;
 508         u16 val;
 509         val = rk818_reg_read(rk818, rk818_BUCK_SET_VOL_REG(buck));
 510         if (val < 0) {
 511                 return val;
 512         }
 513         val=val & mask;
 514         if (val== mask)
 515                 return REGULATOR_MODE_FAST;
 516         else
 517                 return REGULATOR_MODE_NORMAL;
 518
 519 }
 520 static int rk818_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
 521 {
 522         struct rk818 *rk818 = rdev_get_drvdata(dev);
 523         int buck = rdev_get_id(dev) - RK818_DCDC1;
 524         u16 mask = 0x80;
 525         switch(mode)
 526         {
 527         case REGULATOR_MODE_FAST:
 528                 return rk818_set_bits(rk818, rk818_BUCK_SET_VOL_REG(buck), mask, mask);
 529         case REGULATOR_MODE_NORMAL:
 530                 return rk818_set_bits(rk818, rk818_BUCK_SET_VOL_REG(buck), mask, 0);
 531         default:
 532                 printk("error:pmu_rk818 only powersave and pwm mode\n");
 533                 return -EINVAL;
 534         }
 535
 536 }
 537 static int rk818_dcdc_set_voltage_time_sel(struct regulator_dev *dev,   unsigned int old_selector,
 538                                      unsigned int new_selector)
 539 {
 540         int old_volt, new_volt;
 541
 542         old_volt = rk818_dcdc_list_voltage(dev, old_selector);
 543         if (old_volt < 0)
 544                 return old_volt;
 545
 546         new_volt = rk818_dcdc_list_voltage(dev, new_selector);
 547         if (new_volt < 0)
 548                 return new_volt;
 549
 550         return DIV_ROUND_UP(abs(old_volt - new_volt)*2, 2500);
 551 }
 552
 553 static int rk818_dcdc_suspend_enable(struct regulator_dev *dev)
 554 {
 555         struct rk818 *rk818 = rdev_get_drvdata(dev);
 556         int buck = rdev_get_id(dev) - RK818_DCDC1;
 557
 558         return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << buck, 0);
 559
 560 }
 561 static int rk818_dcdc_suspend_disable(struct regulator_dev *dev)
 562 {
 563         struct rk818 *rk818 = rdev_get_drvdata(dev);
 564         int buck = rdev_get_id(dev) - RK818_DCDC1;
 565
 566          return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << buck , 1 << buck);
 567 }
 568 static int rk818_dcdc_set_suspend_mode(struct regulator_dev *dev, unsigned int mode)
 569 {
 570         struct rk818 *rk818 = rdev_get_drvdata(dev);
 571         int buck = rdev_get_id(dev) - RK818_DCDC1;
 572         u16 mask = 0x80;
 573
 574         switch(mode)
 575         {
 576         case REGULATOR_MODE_FAST:
 577                 return rk818_set_bits(rk818, (rk818_BUCK_SET_VOL_REG(buck) + 0x01), mask, mask);
 578         case REGULATOR_MODE_NORMAL:
 579                 return rk818_set_bits(rk818, (rk818_BUCK_SET_VOL_REG(buck) + 0x01), mask, 0);
 580         default:
 581                 printk("error:pmu_rk818 only powersave and pwm mode\n");
 582                 return -EINVAL;
 583         }
 584
 585 }
 586 static struct regulator_ops rk818_dcdc_ops = {
 587         .set_voltage = rk818_dcdc_set_voltage,
 588         .get_voltage = rk818_dcdc_get_voltage,
 589         .list_voltage= rk818_dcdc_list_voltage,
 590         .is_enabled = rk818_dcdc_is_enabled,
 591         .enable = rk818_dcdc_enable,
 592         .disable = rk818_dcdc_disable,
 593         .get_mode = rk818_dcdc_get_mode,
 594         .set_mode = rk818_dcdc_set_mode,
 595         .set_suspend_enable =rk818_dcdc_suspend_enable,
 596         .set_suspend_disable =rk818_dcdc_suspend_disable,
 597         .set_suspend_mode = rk818_dcdc_set_suspend_mode,
 598         .set_suspend_voltage = rk818_dcdc_set_sleep_voltage,
 599         .set_voltage_time_sel = rk818_dcdc_set_voltage_time_sel,
 600 };
 601 static struct regulator_desc regulators[] = {
 602
 603         {
 604                 .name = "RK818_DCDC1",
 605                 .id = 0,
 606                 .ops = &rk818_dcdc_ops,
 607                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 608                 .type = REGULATOR_VOLTAGE,
 609                 .owner = THIS_MODULE,
 610         },
 611         {
 612                 .name = "RK818_DCDC2",
 613                 .id = 1,
 614                 .ops = &rk818_dcdc_ops,
 615                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 616                 .type = REGULATOR_VOLTAGE,
 617                 .owner = THIS_MODULE,
 618         },
 619         {
 620                 .name = "RK818_DCDC3",
 621                 .id = 2,
 622                 .ops = &rk818_dcdc_ops,
 623                 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
 624                 .type = REGULATOR_VOLTAGE,
 625                 .owner = THIS_MODULE,
 626         },
 627         {
 628                 .name = "RK818_DCDC4",
 629                 .id = 3,
 630                 .ops = &rk818_dcdc_ops,
 631                 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
 632                 .type = REGULATOR_VOLTAGE,
 633                 .owner = THIS_MODULE,
 634         },
 635
 636         {
 637                 .name = "RK818_LDO1",
 638                 .id =4,
 639                 .ops = &rk818_ldo_ops,
 640                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 641                 .type = REGULATOR_VOLTAGE,
 642                 .owner = THIS_MODULE,
 643         },
 644         {
 645                 .name = "RK818_LDO2",
 646                 .id = 5,
 647                 .ops = &rk818_ldo_ops,
 648                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 649                 .type = REGULATOR_VOLTAGE,
 650                 .owner = THIS_MODULE,
 651         },
 652         {
 653                 .name = "RK818_LDO3",
 654                 .id = 6,
 655                 .ops = &rk818_ldo_ops,
 656                 .n_voltages = ARRAY_SIZE(ldo3_voltage_map),
 657                 .type = REGULATOR_VOLTAGE,
 658                 .owner = THIS_MODULE,
 659         },
 660         {
 661                 .name = "RK818_LDO4",
 662                 .id = 7,
 663                 .ops = &rk818_ldo_ops,
 664                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 665                 .type = REGULATOR_VOLTAGE,
 666                 .owner = THIS_MODULE,
 667         },
 668
 669         {
 670                 .name = "RK818_LDO5",
 671                 .id =8,
 672                 .ops = &rk818_ldo_ops,
 673                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 674                 .type = REGULATOR_VOLTAGE,
 675                 .owner = THIS_MODULE,
 676         },
 677         {
 678                 .name = "RK818_LDO6",
 679                 .id = 9,
 680                 .ops = &rk818_ldo_ops,
 681                 .n_voltages = ARRAY_SIZE(ldo6_voltage_map),
 682                 .type = REGULATOR_VOLTAGE,
 683                 .owner = THIS_MODULE,
 684         },
 685         {
 686                 .name = "RK818_LDO7",
 687                 .id = 10,
 688                 .ops = &rk818_ldo_ops,
 689                 .n_voltages = ARRAY_SIZE(ldo6_voltage_map),
 690                 .type = REGULATOR_VOLTAGE,
 691                 .owner = THIS_MODULE,
 692         },
 693         {
 694                 .name = "RK818_LDO8",
 695                 .id = 11,
 696                 .ops = &rk818_ldo_ops,
 697                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 698                 .type = REGULATOR_VOLTAGE,
 699                 .owner = THIS_MODULE,
 700         },
 701         {
 702                 .name = "RK818_LDO9",
 703                 .id = 12,
 704                 .ops = &rk818_ldo_ops,
 705                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 706                 .type = REGULATOR_VOLTAGE,
 707                 .owner = THIS_MODULE,
 708         },
 709         {
 710                 .name = "RK818_LDO10",
 711                 .id = 13,
 712                 .ops = &rk818_ldo_ops,
 713                 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
 714                 .type = REGULATOR_VOLTAGE,
 715                 .owner = THIS_MODULE,
 716         },
 717
 718 };
 719
 720 /*
 721  *
 722  */
 723  int rk818_i2c_read(struct rk818 *rk818, char reg, int count,u8 *dest)
 724 {
 725         struct i2c_client *i2c = rk818->i2c;
 726
 727       int ret;
 728     struct i2c_adapter *adap;
 729     struct i2c_msg msgs[2];
 730
 731     if(!i2c)
 732                 return ret;
 733
 734         if (count != 1)
 735                 return -EIO;
 736
 737     adap = i2c->adapter;
 738
 739     msgs[0].addr = i2c->addr;
 740     msgs[0].buf = &reg;
 741     msgs[0].flags = 0;
 742     msgs[0].len = 1;
 743     msgs[0].scl_rate = 200*1000;
 744
 745     msgs[1].buf = dest;
 746     msgs[1].addr = i2c->addr;
 747     msgs[1].flags =  I2C_M_RD;
 748     msgs[1].len = count;
 749     msgs[1].scl_rate = RK818_I2C_ADDR_RATE;
 750
 751     ret = i2c_transfer(adap, msgs, 2);
 752
 753         DBG("***run in %s %x  % x\n",__FUNCTION__,i2c->addr,msgs[0].buf);
 754     return 0;
 755 }
 756
 757 int rk818_i2c_write(struct rk818 *rk818, char reg, int count,  const u8 src)
 758 {
 759         int ret=-1;
 760         struct i2c_client *i2c = rk818->i2c;
 761         struct i2c_adapter *adap;
 762         struct i2c_msg msg;
 763         char tx_buf[2];
 764
 765         if(!i2c)
 766                 return ret;
 767         if (count != 1)
 768                 return -EIO;
 769
 770         adap = i2c->adapter;
 771         tx_buf[0] = reg;
 772         tx_buf[1] = src;
 773
 774         msg.addr = i2c->addr;
 775         msg.buf = &tx_buf[0];
 776         msg.len = 1 +1;
 777         msg.flags = i2c->flags;
 778         msg.scl_rate = RK818_I2C_ADDR_RATE;
 779
 780         ret = i2c_transfer(adap, &msg, 1);
 781         return ret;
 782 }
 783
 784 u8 rk818_reg_read(struct rk818 *rk818, u8 reg)
 785 {
 786         u8 val = 0;
 787
 788         mutex_lock(&rk818->io_lock);
 789
 790         rk818_i2c_read(rk818, reg, 1, &val);
 791
 792         DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 793
 794         mutex_unlock(&rk818->io_lock);
 795
 796         return val & 0xff;
 797 }
 798 EXPORT_SYMBOL_GPL(rk818_reg_read);
 799
 800 int rk818_reg_write(struct rk818 *rk818, u8 reg, u8 val)
 801 {
 802         int err =0;
 803
 804         mutex_lock(&rk818->io_lock);
 805
 806         err = rk818_i2c_write(rk818, reg, 1,val);
 807         if (err < 0)
 808                 dev_err(rk818->dev, "Write for reg 0x%x failed\n", reg);
 809
 810         mutex_unlock(&rk818->io_lock);
 811         return err;
 812 }
 813 EXPORT_SYMBOL_GPL(rk818_reg_write);
 814
 815  int rk818_set_bits(struct rk818 *rk818, u8 reg, u8 mask, u8 val)
 816 {
 817         u8 tmp;
 818         int ret;
 819
 820         mutex_lock(&rk818->io_lock);
 821
 822         ret = rk818_i2c_read(rk818, reg, 1, &tmp);
 823         DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
 824         tmp = (tmp & ~mask) | val;
 825         if (ret == 0) {
 826                 ret = rk818_i2c_write(rk818, reg, 1, tmp);
 827                 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 828         }
 829         rk818_i2c_read(rk818, reg, 1, &tmp);
 830         DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
 831         mutex_unlock(&rk818->io_lock);
 832
 833         return 0;//ret;
 834 }
 835 EXPORT_SYMBOL_GPL(rk818_set_bits);
 836
 837 int rk818_clear_bits(struct rk818 *rk818, u8 reg, u8 mask)
 838 {
 839         u8 data;
 840         int err;
 841
 842         mutex_lock(&rk818->io_lock);
 843         err = rk818_i2c_read(rk818, reg, 1, &data);
 844         if (err <0) {
 845                 dev_err(rk818->dev, "read from reg %x failed\n", reg);
 846                 goto out;
 847         }
 848
 849         data &= ~mask;
 850         err = rk818_i2c_write(rk818, reg, 1, data);
 851         if (err <0)
 852                 dev_err(rk818->dev, "write to reg %x failed\n", reg);
 853
 854 out:
 855         mutex_unlock(&rk818->io_lock);
 856         return err;
 857 }
 858 EXPORT_SYMBOL_GPL(rk818_clear_bits);
 859
 860 #if 1
 861 static ssize_t rk818_test_store(struct kobject *kobj, struct kobj_attribute *attr,
 862                                 const char *buf, size_t n)
 863 {
 864     u32 getdata[8];
 865     u8 regAddr;
 866     u8 data;
 867     char cmd;
 868     const char *buftmp = buf;
 869     struct rk818 *rk818 = g_rk818;
 870     /**
 871      * W Addr(8Bit) regAddr(8Bit) data0(8Bit) data1(8Bit) data2(8Bit) data3(8Bit)
 872      *          :data can be less than 4 byte
 873      * R regAddr(8Bit)
 874      * C gpio_name(poweron/powerhold/sleep/boot0/boot1) value(H/L)
 875      */
 876         sscanf(buftmp, "%c ", &cmd);
 877         printk("------zhangqing: get cmd = %c\n", cmd);
 878         switch (cmd) {
 879         case 'w':
 880                 sscanf(buftmp, "%c %x %x ", &cmd, &getdata[0], &getdata[1]);
 881                 regAddr = (u8)(getdata[0] & 0xff);
 882                 data = (u8)(getdata[1] & 0xff);
 883                 printk("get value = %x\n", data);
 884
 885                 rk818_i2c_write(rk818, regAddr, 1, data);
 886                 rk818_i2c_read(rk818, regAddr, 1, &data);
 887                 printk("%x   %x\n", getdata[1], data);
 888                 break;
 889         case 'r':
 890                 sscanf(buftmp, "%c %x ", &cmd, &getdata[0]);
 891                 printk("CMD : %c %x\n", cmd, getdata[0]);
 892
 893                 regAddr = (u8)(getdata[0] & 0xff);
 894                 rk818_i2c_read(rk818, regAddr, 1, &data);
 895                 printk("%x %x\n", getdata[0], data);
 896                 break;
 897         default:
 898                 printk("Unknown command\n");
 899                 break;
 900         }
 901         return n;
 902
 903 }
 904 static ssize_t rk818_test_show(struct kobject *kobj, struct kobj_attribute *attr,
 905                                char *buf)
 906 {
 907    char *s = buf;
 908     buf = "hello";
 909     return sprintf(s, "%s\n", buf);
 910
 911 }
 912
 913 static struct kobject *rk818_kobj;
 914 struct rk818_attribute {
 915         struct attribute        attr;
 916         ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,
 917                         char *buf);
 918         ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,
 919                         const char *buf, size_t n);
 920 };
 921
 922 static struct rk818_attribute rk818_attrs[] = {
 923         /*     node_name        permision               show_func       store_func */
 924         __ATTR(rk818_test,      S_IRUGO | S_IWUSR,      rk818_test_show,        rk818_test_store),
 925 };
 926 #endif
 927
 928 #if 0
 929 extern void rk_send_wakeup_key(void);
 930 static irqreturn_t rk818_vbat_lo_irq(int irq, void *data)
 931 {
 932         printk("rk818 vbat low %s:irq=%d\n",__func__,irq);
 933         rk818_set_bits(g_rk818,0x4c,(0x1 << 1),(0x1 <<1));
 934         rk_send_wakeup_key();
 935         return IRQ_HANDLED;
 936 }
 937 #endif
 938
 939 #ifdef CONFIG_OF
 940 static struct of_device_id rk818_of_match[] = {
 941         { .compatible = "rockchip,rk818"},
 942         { },
 943 };
 944 MODULE_DEVICE_TABLE(of, rk818_of_match);
 945 #endif
 946
 947 #ifdef CONFIG_OF
 948 static struct of_regulator_match rk818_reg_matches[] = {
 949         { .name = "rk818_dcdc1", .driver_data = (void *)0 },
 950         { .name = "rk818_dcdc2", .driver_data = (void *)1 },
 951         { .name = "rk818_dcdc3", .driver_data = (void *)2 },
 952         { .name = "rk818_dcdc4", .driver_data = (void *)3 },
 953         { .name = "rk818_ldo1", .driver_data = (void *)4 },
 954         { .name = "rk818_ldo2", .driver_data = (void *)5 },
 955         { .name = "rk818_ldo3", .driver_data = (void *)6 },
 956         { .name = "rk818_ldo4", .driver_data = (void *)7 },
 957         { .name = "rk818_ldo5", .driver_data = (void *)8 },
 958         { .name = "rk818_ldo6", .driver_data = (void *)9 },
 959         { .name = "rk818_ldo7", .driver_data = (void *)10 },
 960         { .name = "rk818_ldo8", .driver_data = (void *)11 },
 961         { .name = "rk818_ldo9", .driver_data = (void *)12 },
 962         { .name = "rk818_ldo10", .driver_data = (void *)13 },
 963 };
 964
 965 static struct rk818_board *rk818_parse_dt(struct rk818 *rk818)
 966 {
 967         struct rk818_board *pdata;
 968         struct device_node *regs,*rk818_pmic_np;
 969         int i, count;
 970
 971         rk818_pmic_np = of_node_get(rk818->dev->of_node);
 972         if (!rk818_pmic_np) {
 973                 printk("could not find pmic sub-node\n");
 974                 return NULL;
 975         }
 976
 977         regs = of_find_node_by_name(rk818_pmic_np, "regulators");
 978         if (!regs)
 979                 return NULL;
 980
 981         count = of_regulator_match(rk818->dev, regs, rk818_reg_matches,
 982                                    rk818_NUM_REGULATORS);
 983         of_node_put(regs);
 984         if ((count < 0) || (count > rk818_NUM_REGULATORS))
 985                 return NULL;
 986
 987         pdata = devm_kzalloc(rk818->dev, sizeof(*pdata), GFP_KERNEL);
 988         if (!pdata)
 989                 return NULL;
 990
 991         for (i = 0; i < count; i++) {
 992                 if (!rk818_reg_matches[i].init_data || !rk818_reg_matches[i].of_node)
 993                         continue;
 994
 995                 pdata->rk818_init_data[i] = rk818_reg_matches[i].init_data;
 996                 pdata->of_node[i] = rk818_reg_matches[i].of_node;
 997         }
 998         pdata->irq = rk818->chip_irq;
 999         pdata->irq_base = -1;
1000
1001         pdata->irq_gpio = of_get_named_gpio(rk818_pmic_np,"gpios",0);
1002                 if (!gpio_is_valid(pdata->irq_gpio)) {
1003                         printk("invalid gpio: %d\n",  pdata->irq_gpio);
1004                         return NULL;
1005                 }
1006
1007         pdata->pmic_sleep_gpio = of_get_named_gpio(rk818_pmic_np,"gpios",1);
1008                         if (!gpio_is_valid(pdata->pmic_sleep_gpio)) {
1009                                 printk("invalid gpio: %d\n",  pdata->pmic_sleep_gpio);
1010                 }
1011         pdata->pmic_sleep = true;
1012         pdata->pm_off = of_property_read_bool(rk818_pmic_np,"rk818,system-power-controller");
1013
1014         return pdata;
1015 }
1016
1017 #else
1018 static struct rk818_board *rk818_parse_dt(struct i2c_client *i2c)
1019 {
1020         return NULL;
1021 }
1022 #endif
1023
1024 static void rk818_shutdown(void)
1025 {
1026         int ret;
1027         struct rk818 *rk818 = g_rk818;
1028
1029         pr_info("%s\n", __func__);
1030         ret = rk818_set_bits(rk818, RK818_INT_STS_MSK_REG1,(0x3<<5),(0x3<<5)); //close rtc int when power off
1031         ret = rk818_clear_bits(rk818, RK818_RTC_INT_REG,(0x3<<2)); //close rtc int when power off
1032         mutex_lock(&rk818->io_lock);
1033         mdelay(100);
1034 }
1035
1036 static struct syscore_ops rk818_syscore_ops = {
1037         .shutdown = rk818_shutdown,
1038 };
1039
1040 void rk818_device_shutdown(void)
1041 {
1042         int ret, i;
1043         u8 reg = 0;
1044         struct rk818 *rk818 = g_rk818;
1045
1046         for (i = 0; i < 10; i++) {
1047                 pr_info("%s\n", __func__);
1048                 ret = rk818_i2c_read(rk818, RK818_DEVCTRL_REG, 1, &reg);
1049                 if (ret < 0)
1050                         continue;
1051                 ret = rk818_i2c_write(rk818, RK818_DEVCTRL_REG, 1,
1052                                      (reg | (0x1 << 0)));
1053                 if (ret < 0) {
1054                         pr_err("rk818 power off error!\n");
1055                         continue;
1056                 }
1057         }
1058         while(1) wfi();
1059 }
1060 EXPORT_SYMBOL_GPL(rk818_device_shutdown);
1061
1062 __weak void  rk818_device_suspend(void) {}
1063 __weak void  rk818_device_resume(void) {}
1064 #ifdef CONFIG_PM
1065 static int rk818_suspend(struct i2c_client *i2c, pm_message_t mesg)
1066 {
1067         rk818_device_suspend();
1068         return 0;
1069 }
1070
1071 static int rk818_resume(struct i2c_client *i2c)
1072 {
1073         rk818_device_resume();
1074         return 0;
1075 }
1076 #else
1077 static int rk818_suspend(struct i2c_client *i2c, pm_message_t mesg)
1078 {
1079         return 0;
1080 }
1081
1082 static int rk818_resume(struct i2c_client *i2c)
1083 {
1084         return 0;
1085 }
1086 #endif
1087
1088 static int rk818_pre_init(struct rk818 *rk818)
1089 {
1090         int ret,val;
1091          printk("%s,line=%d\n", __func__,__LINE__);
1092
1093         ret = rk818_set_bits(rk818, 0xa1,(0x7<<4),(0x7<<4)); //close charger when usb low then 3.4V
1094         ret = rk818_set_bits(rk818, 0x52,(0x1<<1),(0x1<<1)); //no action when vref
1095
1096         /*******enable switch and boost***********/
1097         val = rk818_reg_read(rk818,RK818_DCDC_EN_REG);
1098         val |= (0x3 << 5);    //enable switch1/2
1099         val |= (0x1 << 4);    //enable boost
1100         ret = rk818_reg_write(rk818,RK818_DCDC_EN_REG,val);
1101          if (ret <0) {
1102                 printk(KERN_ERR "Unable to write RK818_DCDC_EN_REG reg\n");
1103                 return ret;
1104         }
1105         /****************************************/
1106
1107         /****************set vbat low **********/
1108         val = rk818_reg_read(rk818,RK818_VB_MON_REG);
1109        val &=(~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1110        val |= (RK818_VBAT_LOW_3V5 | EN_VBAT_LOW_IRQ);
1111        ret = rk818_reg_write(rk818,RK818_VB_MON_REG,val);
1112          if (ret <0) {
1113                 printk(KERN_ERR "Unable to write RK818_VB_MON_REG reg\n");
1114                 return ret;
1115         }
1116         /**************************************/
1117
1118         /**********mask int****************/
1119          val = rk818_reg_read(rk818,RK818_INT_STS_MSK_REG1);
1120          val |= (0x1<<0); //mask vout_lo_int
1121         ret = rk818_reg_write(rk818,RK818_INT_STS_MSK_REG1,val);
1122          if (ret <0) {
1123                 printk(KERN_ERR "Unable to write RK818_INT_STS_MSK_REG1 reg\n");
1124                 return ret;
1125         }
1126         /**********************************/
1127         /**********enable clkout2****************/
1128         ret = rk818_reg_write(rk818,RK818_CLK32OUT_REG,0x01);
1129          if (ret <0) {
1130                 printk(KERN_ERR "Unable to write RK818_CLK32OUT_REG reg\n");
1131                 return ret;
1132         }
1133         /**********************************/
1134         ret = rk818_clear_bits(rk818, RK818_INT_STS_MSK_REG1,(0x3<<5)); //open rtc int when power on
1135         ret = rk818_set_bits(rk818, RK818_RTC_INT_REG,(0x1<<3),(0x1<<3)); //open rtc int when power on
1136
1137         /*****disable otg and boost when in sleep mode****/
1138         val = rk818_reg_read(rk818, RK818_SLEEP_SET_OFF_REG1);
1139         val |= ((0x1 << 7) | (0x1 << 4));
1140         ret =  rk818_reg_write(rk818, RK818_SLEEP_SET_OFF_REG1, val);
1141         if (ret < 0) {
1142                 pr_err("Unable to write RK818_SLEEP_SET_OFF_REG1 reg\n");
1143                 return ret;
1144         }
1145
1146         return 0;
1147 }
1148
1149 static int  rk818_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
1150 {
1151         struct rk818 *rk818;
1152         struct rk818_board *pdev;
1153         const struct of_device_id *match;
1154         struct regulator_config config = { };
1155         struct regulator_dev *rk818_rdev;
1156         struct regulator_init_data *reg_data;
1157         const char *rail_name = NULL;
1158         int ret, i = 0;
1159
1160         printk("%s,line=%d\n", __func__,__LINE__);
1161
1162         if (i2c->dev.of_node) {
1163                 match = of_match_device(rk818_of_match, &i2c->dev);
1164                 if (!match) {
1165                         dev_err(&i2c->dev,"Failed to find matching dt id\n");
1166                         return -EINVAL;
1167                 }
1168         }
1169
1170         rk818 = devm_kzalloc(&i2c->dev,sizeof(struct rk818), GFP_KERNEL);
1171         if (rk818 == NULL) {
1172                 ret = -ENOMEM;
1173                 goto err;
1174         }
1175         rk818->i2c = i2c;
1176         rk818->dev = &i2c->dev;
1177         i2c_set_clientdata(i2c, rk818);
1178
1179         mutex_init(&rk818->io_lock);
1180
1181         ret = rk818_reg_read(rk818,0x2f);
1182         if ((ret < 0) || (ret == 0xff)){
1183                 printk("The device is not rk818 %d\n",ret);
1184                 goto err;
1185         }
1186
1187         ret = rk818_pre_init(rk818);
1188         if (ret < 0){
1189                 printk("The rk818_pre_init failed %d\n",ret);
1190                 goto err;
1191         }
1192
1193         if (rk818->dev->of_node)
1194                 pdev = rk818_parse_dt(rk818);
1195
1196         /******************************set sleep vol & dcdc mode******************/
1197         #ifdef CONFIG_OF
1198         rk818->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
1199         if (rk818->pmic_sleep_gpio) {
1200                         ret = gpio_request(rk818->pmic_sleep_gpio, "rk818_pmic_sleep");
1201                         if (ret < 0) {
1202                                 dev_err(rk818->dev,"Failed to request gpio %d with ret:""%d\n", rk818->pmic_sleep_gpio, ret);
1203                                 return IRQ_NONE;
1204                         }
1205                         gpio_direction_output(rk818->pmic_sleep_gpio,0);
1206                         ret = gpio_get_value(rk818->pmic_sleep_gpio);
1207                         gpio_free(rk818->pmic_sleep_gpio);
1208                         pr_info("%s: rk818_pmic_sleep=%x\n", __func__, ret);
1209         }
1210         #endif
1211         /**********************************************************/
1212
1213         if (pdev) {
1214                 rk818->num_regulators = rk818_NUM_REGULATORS;
1215                 rk818->rdev = kcalloc(rk818_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
1216                 if (!rk818->rdev) {
1217                         return -ENOMEM;
1218                 }
1219                 /* Instantiate the regulators */
1220                 for (i = 0; i < rk818_NUM_REGULATORS; i++) {
1221                 reg_data = pdev->rk818_init_data[i];
1222                 if (!reg_data)
1223                         continue;
1224                 config.dev = rk818->dev;
1225                 config.driver_data = rk818;
1226                 if (rk818->dev->of_node)
1227                         config.of_node = pdev->of_node[i];
1228                 if (reg_data && reg_data->constraints.name)
1229                                 rail_name = reg_data->constraints.name;
1230                         else
1231                                 rail_name = regulators[i].name;
1232                         reg_data->supply_regulator = rail_name;
1233
1234                 config.init_data =reg_data;
1235
1236                 rk818_rdev = regulator_register(&regulators[i],&config);
1237                 if (IS_ERR(rk818_rdev)) {
1238                         printk("failed to register %d regulator\n",i);
1239                 goto err;
1240                 }
1241                 rk818->rdev[i] = rk818_rdev;
1242                 }
1243         }
1244
1245         rk818->irq_gpio = pdev->irq_gpio;
1246         ret = rk818_irq_init(rk818, rk818->irq_gpio, pdev);
1247         if (ret < 0)
1248                 goto err;
1249
1250         ret = mfd_add_devices(rk818->dev, -1,
1251                               rk818s, ARRAY_SIZE(rk818s),
1252                               NULL, 0,NULL);
1253         #if 0
1254         /********************vbat low int**************/
1255         vlow_irq = irq_create_mapping(rk818->irq_domain, RK818_IRQ_VB_LO);
1256          ret = devm_request_threaded_irq(&i2c->dev,vlow_irq, NULL, rk818_vbat_lo_irq,
1257                                    IRQF_ONESHOT, "rk818_vbatlow",
1258                                    rk818);
1259         if (ret != 0) {
1260                 dev_err(rk818->dev, "Failed to request periodic IRQ %d: %d\n",
1261                         vlow_irq+ RK818_IRQ_VB_LO, ret);
1262
1263         }
1264         #endif
1265         /*********************************************/
1266
1267         g_rk818 = rk818;
1268         if (pdev->pm_off && !pm_power_off) {
1269                 pm_power_off = rk818_device_shutdown;
1270         }
1271
1272         #if 1
1273         rk818_kobj = kobject_create_and_add("rk818", NULL);
1274         if (!rk818_kobj)
1275                 return -ENOMEM;
1276         for (i = 0; i < ARRAY_SIZE(rk818_attrs); i++) {
1277                 ret = sysfs_create_file(rk818_kobj, &rk818_attrs[i].attr);
1278                 if (ret != 0) {
1279                         printk("create index %d error\n", i);
1280                         return ret;
1281                 }
1282         }
1283         #endif
1284
1285         register_syscore_ops(&rk818_syscore_ops);
1286
1287         return 0;
1288
1289 err:
1290         mfd_remove_devices(rk818->dev);
1291         return ret;
1292
1293 }
1294
1295 static int  rk818_i2c_remove(struct i2c_client *i2c)
1296 {
1297         struct rk818 *rk818 = i2c_get_clientdata(i2c);
1298         int i;
1299
1300         unregister_syscore_ops(&rk818_syscore_ops);
1301         for (i = 0; i < rk818->num_regulators; i++)
1302                 if (rk818->rdev[i])
1303                         regulator_unregister(rk818->rdev[i]);
1304         i2c_set_clientdata(i2c, NULL);
1305         kfree(rk818);
1306
1307         return 0;
1308 }
1309
1310 static const struct i2c_device_id rk818_i2c_id[] = {
1311        { "rk818", 0 },
1312        { }
1313 };
1314
1315 MODULE_DEVICE_TABLE(i2c, rk818_i2c_id);
1316
1317 static struct i2c_driver rk818_i2c_driver = {
1318         .driver = {
1319                 .name = "rk818",
1320                 .owner = THIS_MODULE,
1321                 .of_match_table =of_match_ptr(rk818_of_match),
1322         },
1323         .probe    = rk818_i2c_probe,
1324         .remove   = rk818_i2c_remove,
1325         .id_table = rk818_i2c_id,
1326         #ifdef CONFIG_PM
1327         .suspend        = rk818_suspend,
1328         .resume         = rk818_resume,
1329         #endif
1330 };
1331
1332 static int __init rk818_module_init(void)
1333 {
1334         int ret;
1335         ret = i2c_add_driver(&rk818_i2c_driver);
1336         if (ret != 0)
1337                 pr_err("Failed to register I2C driver: %d\n", ret);
1338         return ret;
1339 }
1340
1341 subsys_initcall_sync(rk818_module_init);
1342
1343 static void __exit rk818_module_exit(void)
1344 {
1345         i2c_del_driver(&rk818_i2c_driver);
1346 }
1347 module_exit(rk818_module_exit);
1348
1349 MODULE_LICENSE("GPL");
1350 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1351 MODULE_DESCRIPTION("rk818 PMIC driver");
1352