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     u16 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         regAddr = (u16)(getdata[0] & 0xff);
 877          if (strncmp(buf, "start", 5) == 0) {
 878
 879
 880     } else if (strncmp(buf, "stop", 4== 0) ){
 881
 882     } else{
 883         sscanf(buftmp, "%c ", &cmd);
 884         printk("------zhangqing: get cmd = %c\n", cmd);
 885         switch(cmd) {
 886
 887         case 'w':
 888                 sscanf(buftmp, "%c %x %x ", &cmd, &getdata[0],&getdata[1]);
 889                  regAddr = (u16)(getdata[0] & 0xff);
 890                 data = (u8)(getdata[1] & 0xff);
 891                 printk("get value = %x\n", data);
 892
 893              rk818_i2c_write(rk818, regAddr, 1, data);
 894              rk818_i2c_read(rk818, regAddr, 1, &data);
 895              printk("%x   %x\n", getdata[1],data);
 896
 897             break;
 898
 899         case 'r':
 900             sscanf(buftmp, "%c %x ", &cmd, &getdata[0]);
 901             printk("CMD : %c %x\n", cmd, getdata[0]);
 902
 903             regAddr = (u16)(getdata[0] & 0xff);
 904             rk818_i2c_read(rk818, regAddr, 1, &data);
 905                 printk("%x %x\n", getdata[0],data);
 906
 907             break;
 908
 909         default:
 910             printk("Unknown command\n");
 911             break;
 912         }
 913 }
 914     return n;
 915
 916 }
 917 static ssize_t rk818_test_show(struct kobject *kobj, struct kobj_attribute *attr,
 918                                char *buf)
 919 {
 920    char *s = buf;
 921     buf = "hello";
 922     return sprintf(s, "%s\n", buf);
 923
 924 }
 925
 926 static struct kobject *rk818_kobj;
 927 struct rk818_attribute {
 928         struct attribute        attr;
 929         ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,
 930                         char *buf);
 931         ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,
 932                         const char *buf, size_t n);
 933 };
 934
 935 static struct rk818_attribute rk818_attrs[] = {
 936         /*     node_name        permision               show_func       store_func */
 937         __ATTR(rk818_test,      S_IRUGO | S_IWUSR,      rk818_test_show,        rk818_test_store),
 938 };
 939 #endif
 940
 941 #if 0
 942 extern void rk_send_wakeup_key(void);
 943 static irqreturn_t rk818_vbat_lo_irq(int irq, void *data)
 944 {
 945         printk("rk818 vbat low %s:irq=%d\n",__func__,irq);
 946         rk818_set_bits(g_rk818,0x4c,(0x1 << 1),(0x1 <<1));
 947         rk_send_wakeup_key();
 948         return IRQ_HANDLED;
 949 }
 950 #endif
 951
 952 #ifdef CONFIG_OF
 953 static struct of_device_id rk818_of_match[] = {
 954         { .compatible = "rockchip,rk818"},
 955         { },
 956 };
 957 MODULE_DEVICE_TABLE(of, rk818_of_match);
 958 #endif
 959
 960 #ifdef CONFIG_OF
 961 static struct of_regulator_match rk818_reg_matches[] = {
 962         { .name = "rk818_dcdc1", .driver_data = (void *)0 },
 963         { .name = "rk818_dcdc2", .driver_data = (void *)1 },
 964         { .name = "rk818_dcdc3", .driver_data = (void *)2 },
 965         { .name = "rk818_dcdc4", .driver_data = (void *)3 },
 966         { .name = "rk818_ldo1", .driver_data = (void *)4 },
 967         { .name = "rk818_ldo2", .driver_data = (void *)5 },
 968         { .name = "rk818_ldo3", .driver_data = (void *)6 },
 969         { .name = "rk818_ldo4", .driver_data = (void *)7 },
 970         { .name = "rk818_ldo5", .driver_data = (void *)8 },
 971         { .name = "rk818_ldo6", .driver_data = (void *)9 },
 972         { .name = "rk818_ldo7", .driver_data = (void *)10 },
 973         { .name = "rk818_ldo8", .driver_data = (void *)11 },
 974         { .name = "rk818_ldo9", .driver_data = (void *)12 },
 975         { .name = "rk818_ldo10", .driver_data = (void *)13 },
 976 };
 977
 978 static struct rk818_board *rk818_parse_dt(struct rk818 *rk818)
 979 {
 980         struct rk818_board *pdata;
 981         struct device_node *regs,*rk818_pmic_np;
 982         int i, count;
 983
 984         rk818_pmic_np = of_node_get(rk818->dev->of_node);
 985         if (!rk818_pmic_np) {
 986                 printk("could not find pmic sub-node\n");
 987                 return NULL;
 988         }
 989
 990         regs = of_find_node_by_name(rk818_pmic_np, "regulators");
 991         if (!regs)
 992                 return NULL;
 993
 994         count = of_regulator_match(rk818->dev, regs, rk818_reg_matches,
 995                                    rk818_NUM_REGULATORS);
 996         of_node_put(regs);
 997         if ((count < 0) || (count > rk818_NUM_REGULATORS))
 998                 return NULL;
 999
1000         pdata = devm_kzalloc(rk818->dev, sizeof(*pdata), GFP_KERNEL);
1001         if (!pdata)
1002                 return NULL;
1003
1004         for (i = 0; i < count; i++) {
1005                 if (!rk818_reg_matches[i].init_data || !rk818_reg_matches[i].of_node)
1006                         continue;
1007
1008                 pdata->rk818_init_data[i] = rk818_reg_matches[i].init_data;
1009                 pdata->of_node[i] = rk818_reg_matches[i].of_node;
1010         }
1011         pdata->irq = rk818->chip_irq;
1012         pdata->irq_base = -1;
1013
1014         pdata->irq_gpio = of_get_named_gpio(rk818_pmic_np,"gpios",0);
1015                 if (!gpio_is_valid(pdata->irq_gpio)) {
1016                         printk("invalid gpio: %d\n",  pdata->irq_gpio);
1017                         return NULL;
1018                 }
1019
1020         pdata->pmic_sleep_gpio = of_get_named_gpio(rk818_pmic_np,"gpios",1);
1021                         if (!gpio_is_valid(pdata->pmic_sleep_gpio)) {
1022                                 printk("invalid gpio: %d\n",  pdata->pmic_sleep_gpio);
1023                 }
1024         pdata->pmic_sleep = true;
1025         pdata->pm_off = of_property_read_bool(rk818_pmic_np,"rk818,system-power-controller");
1026
1027         return pdata;
1028 }
1029
1030 #else
1031 static struct rk818_board *rk818_parse_dt(struct i2c_client *i2c)
1032 {
1033         return NULL;
1034 }
1035 #endif
1036
1037 static void rk818_shutdown(void)
1038 {
1039         int ret;
1040         struct rk818 *rk818 = g_rk818;
1041
1042         pr_info("%s\n", __func__);
1043         ret = rk818_set_bits(rk818, RK818_INT_STS_MSK_REG1,(0x3<<5),(0x3<<5)); //close rtc int when power off
1044         ret = rk818_clear_bits(rk818, RK818_RTC_INT_REG,(0x3<<2)); //close rtc int when power off
1045         mutex_lock(&rk818->io_lock);
1046         mdelay(100);
1047 }
1048
1049 static struct syscore_ops rk818_syscore_ops = {
1050         .shutdown = rk818_shutdown,
1051 };
1052
1053 void rk818_device_shutdown(void)
1054 {
1055         int ret, i;
1056         u8 reg = 0;
1057         struct rk818 *rk818 = g_rk818;
1058
1059         for (i = 0; i < 10; i++) {
1060                 pr_info("%s\n", __func__);
1061                 ret = rk818_i2c_read(rk818, RK818_DEVCTRL_REG, 1, &reg);
1062                 if (ret < 0)
1063                         continue;
1064                 ret = rk818_i2c_write(rk818, RK818_DEVCTRL_REG, 1,
1065                                      (reg | (0x1 << 0)));
1066                 if (ret < 0) {
1067                         pr_err("rk818 power off error!\n");
1068                         continue;
1069                 }
1070         }
1071         while(1) wfi();
1072 }
1073 EXPORT_SYMBOL_GPL(rk818_device_shutdown);
1074
1075 __weak void  rk818_device_suspend(void) {}
1076 __weak void  rk818_device_resume(void) {}
1077 #ifdef CONFIG_PM
1078 static int rk818_suspend(struct i2c_client *i2c, pm_message_t mesg)
1079 {
1080         rk818_device_suspend();
1081         return 0;
1082 }
1083
1084 static int rk818_resume(struct i2c_client *i2c)
1085 {
1086         rk818_device_resume();
1087         return 0;
1088 }
1089 #else
1090 static int rk818_suspend(struct i2c_client *i2c, pm_message_t mesg)
1091 {
1092         return 0;
1093 }
1094
1095 static int rk818_resume(struct i2c_client *i2c)
1096 {
1097         return 0;
1098 }
1099 #endif
1100
1101 static int rk818_pre_init(struct rk818 *rk818)
1102 {
1103         int ret,val;
1104          printk("%s,line=%d\n", __func__,__LINE__);
1105
1106         ret = rk818_set_bits(rk818, 0xa1,(0x7<<4),(0x7<<4)); //close charger when usb low then 3.4V
1107         ret = rk818_set_bits(rk818, 0x52,(0x1<<1),(0x1<<1)); //no action when vref
1108
1109         /*******enable switch and boost***********/
1110         val = rk818_reg_read(rk818,RK818_DCDC_EN_REG);
1111         val |= (0x3 << 5);    //enable switch1/2
1112         val |= (0x1 << 4);    //enable boost
1113         ret = rk818_reg_write(rk818,RK818_DCDC_EN_REG,val);
1114          if (ret <0) {
1115                 printk(KERN_ERR "Unable to write RK818_DCDC_EN_REG reg\n");
1116                 return ret;
1117         }
1118         /****************************************/
1119
1120         /****************set vbat low **********/
1121         val = rk818_reg_read(rk818,RK818_VB_MON_REG);
1122        val &=(~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1123        val |= (RK818_VBAT_LOW_3V5 | EN_VBAT_LOW_IRQ);
1124        ret = rk818_reg_write(rk818,RK818_VB_MON_REG,val);
1125          if (ret <0) {
1126                 printk(KERN_ERR "Unable to write RK818_VB_MON_REG reg\n");
1127                 return ret;
1128         }
1129         /**************************************/
1130
1131         /**********mask int****************/
1132          val = rk818_reg_read(rk818,RK818_INT_STS_MSK_REG1);
1133          val |= (0x1<<0); //mask vout_lo_int
1134         ret = rk818_reg_write(rk818,RK818_INT_STS_MSK_REG1,val);
1135          if (ret <0) {
1136                 printk(KERN_ERR "Unable to write RK818_INT_STS_MSK_REG1 reg\n");
1137                 return ret;
1138         }
1139         /**********************************/
1140         /**********enable clkout2****************/
1141         ret = rk818_reg_write(rk818,RK818_CLK32OUT_REG,0x01);
1142          if (ret <0) {
1143                 printk(KERN_ERR "Unable to write RK818_CLK32OUT_REG reg\n");
1144                 return ret;
1145         }
1146         /**********************************/
1147         ret = rk818_clear_bits(rk818, RK818_INT_STS_MSK_REG1,(0x3<<5)); //open rtc int when power on
1148         ret = rk818_set_bits(rk818, RK818_RTC_INT_REG,(0x1<<3),(0x1<<3)); //open rtc int when power on
1149         return 0;
1150 }
1151
1152 static int  rk818_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
1153 {
1154         struct rk818 *rk818;
1155         struct rk818_board *pdev;
1156         const struct of_device_id *match;
1157         struct regulator_config config = { };
1158         struct regulator_dev *rk818_rdev;
1159         struct regulator_init_data *reg_data;
1160         const char *rail_name = NULL;
1161         int ret, i = 0;
1162
1163         printk("%s,line=%d\n", __func__,__LINE__);
1164
1165         if (i2c->dev.of_node) {
1166                 match = of_match_device(rk818_of_match, &i2c->dev);
1167                 if (!match) {
1168                         dev_err(&i2c->dev,"Failed to find matching dt id\n");
1169                         return -EINVAL;
1170                 }
1171         }
1172
1173         rk818 = devm_kzalloc(&i2c->dev,sizeof(struct rk818), GFP_KERNEL);
1174         if (rk818 == NULL) {
1175                 ret = -ENOMEM;
1176                 goto err;
1177         }
1178         rk818->i2c = i2c;
1179         rk818->dev = &i2c->dev;
1180         i2c_set_clientdata(i2c, rk818);
1181
1182         mutex_init(&rk818->io_lock);
1183
1184         ret = rk818_reg_read(rk818,0x2f);
1185         if ((ret < 0) || (ret == 0xff)){
1186                 printk("The device is not rk818 %d\n",ret);
1187                 goto err;
1188         }
1189
1190         ret = rk818_pre_init(rk818);
1191         if (ret < 0){
1192                 printk("The rk818_pre_init failed %d\n",ret);
1193                 goto err;
1194         }
1195
1196         if (rk818->dev->of_node)
1197                 pdev = rk818_parse_dt(rk818);
1198
1199         /******************************set sleep vol & dcdc mode******************/
1200         #ifdef CONFIG_OF
1201         rk818->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
1202         if (rk818->pmic_sleep_gpio) {
1203                         ret = gpio_request(rk818->pmic_sleep_gpio, "rk818_pmic_sleep");
1204                         if (ret < 0) {
1205                                 dev_err(rk818->dev,"Failed to request gpio %d with ret:""%d\n", rk818->pmic_sleep_gpio, ret);
1206                                 return IRQ_NONE;
1207                         }
1208                         gpio_direction_output(rk818->pmic_sleep_gpio,0);
1209                         ret = gpio_get_value(rk818->pmic_sleep_gpio);
1210                         gpio_free(rk818->pmic_sleep_gpio);
1211                         pr_info("%s: rk818_pmic_sleep=%x\n", __func__, ret);
1212         }
1213         #endif
1214         /**********************************************************/
1215
1216         if (pdev) {
1217                 rk818->num_regulators = rk818_NUM_REGULATORS;
1218                 rk818->rdev = kcalloc(rk818_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
1219                 if (!rk818->rdev) {
1220                         return -ENOMEM;
1221                 }
1222                 /* Instantiate the regulators */
1223                 for (i = 0; i < rk818_NUM_REGULATORS; i++) {
1224                 reg_data = pdev->rk818_init_data[i];
1225                 if (!reg_data)
1226                         continue;
1227                 config.dev = rk818->dev;
1228                 config.driver_data = rk818;
1229                 if (rk818->dev->of_node)
1230                         config.of_node = pdev->of_node[i];
1231                 if (reg_data && reg_data->constraints.name)
1232                                 rail_name = reg_data->constraints.name;
1233                         else
1234                                 rail_name = regulators[i].name;
1235                         reg_data->supply_regulator = rail_name;
1236
1237                 config.init_data =reg_data;
1238
1239                 rk818_rdev = regulator_register(&regulators[i],&config);
1240                 if (IS_ERR(rk818_rdev)) {
1241                         printk("failed to register %d regulator\n",i);
1242                 goto err;
1243                 }
1244                 rk818->rdev[i] = rk818_rdev;
1245                 }
1246         }
1247
1248         rk818->irq_gpio = pdev->irq_gpio;
1249         ret = rk818_irq_init(rk818, rk818->irq_gpio, pdev);
1250         if (ret < 0)
1251                 goto err;
1252
1253         ret = mfd_add_devices(rk818->dev, -1,
1254                               rk818s, ARRAY_SIZE(rk818s),
1255                               NULL, 0,NULL);
1256         #if 0
1257         /********************vbat low int**************/
1258         vlow_irq = irq_create_mapping(rk818->irq_domain, RK818_IRQ_VB_LO);
1259          ret = devm_request_threaded_irq(&i2c->dev,vlow_irq, NULL, rk818_vbat_lo_irq,
1260                                    IRQF_ONESHOT, "rk818_vbatlow",
1261                                    rk818);
1262         if (ret != 0) {
1263                 dev_err(rk818->dev, "Failed to request periodic IRQ %d: %d\n",
1264                         vlow_irq+ RK818_IRQ_VB_LO, ret);
1265
1266         }
1267         #endif
1268         /*********************************************/
1269
1270         g_rk818 = rk818;
1271         if (pdev->pm_off && !pm_power_off) {
1272                 pm_power_off = rk818_device_shutdown;
1273         }
1274
1275         #if 1
1276         rk818_kobj = kobject_create_and_add("rk818", NULL);
1277         if (!rk818_kobj)
1278                 return -ENOMEM;
1279         for (i = 0; i < ARRAY_SIZE(rk818_attrs); i++) {
1280                 ret = sysfs_create_file(rk818_kobj, &rk818_attrs[i].attr);
1281                 if (ret != 0) {
1282                         printk("create index %d error\n", i);
1283                         return ret;
1284                 }
1285         }
1286         #endif
1287
1288         register_syscore_ops(&rk818_syscore_ops);
1289
1290         return 0;
1291
1292 err:
1293         mfd_remove_devices(rk818->dev);
1294         return ret;
1295
1296 }
1297
1298 static int  rk818_i2c_remove(struct i2c_client *i2c)
1299 {
1300         struct rk818 *rk818 = i2c_get_clientdata(i2c);
1301         int i;
1302
1303         unregister_syscore_ops(&rk818_syscore_ops);
1304         for (i = 0; i < rk818->num_regulators; i++)
1305                 if (rk818->rdev[i])
1306                         regulator_unregister(rk818->rdev[i]);
1307         i2c_set_clientdata(i2c, NULL);
1308         kfree(rk818);
1309
1310         return 0;
1311 }
1312
1313 static const struct i2c_device_id rk818_i2c_id[] = {
1314        { "rk818", 0 },
1315        { }
1316 };
1317
1318 MODULE_DEVICE_TABLE(i2c, rk818_i2c_id);
1319
1320 static struct i2c_driver rk818_i2c_driver = {
1321         .driver = {
1322                 .name = "rk818",
1323                 .owner = THIS_MODULE,
1324                 .of_match_table =of_match_ptr(rk818_of_match),
1325         },
1326         .probe    = rk818_i2c_probe,
1327         .remove   = rk818_i2c_remove,
1328         .id_table = rk818_i2c_id,
1329         #ifdef CONFIG_PM
1330         .suspend        = rk818_suspend,
1331         .resume         = rk818_resume,
1332         #endif
1333 };
1334
1335 static int __init rk818_module_init(void)
1336 {
1337         int ret;
1338         ret = i2c_add_driver(&rk818_i2c_driver);
1339         if (ret != 0)
1340                 pr_err("Failed to register I2C driver: %d\n", ret);
1341         return ret;
1342 }
1343
1344 subsys_initcall_sync(rk818_module_init);
1345
1346 static void __exit rk818_module_exit(void)
1347 {
1348         i2c_del_driver(&rk818_i2c_driver);
1349 }
1350 module_exit(rk818_module_exit);
1351
1352 MODULE_LICENSE("GPL");
1353 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1354 MODULE_DESCRIPTION("rk818 PMIC driver");
1355