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