drivers/mfd/rk808.c

   1 /*
   2  * Regulator driver for rk808 PMIC chip for rk31xx
   3  *
   4  * Based on rk808.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/rk808.h>
  18 #include <linux/mfd/core.h>
  19 #include <linux/delay.h>
  20 #include <linux/slab.h>
  21 #include <linux/mutex.h>
  22 #ifdef CONFIG_HAS_EARLYSUSPEND
  23 #include <linux/earlysuspend.h>
  24 #endif
  25 #include <linux/interrupt.h>
  26 #include <linux/module.h>
  27 #include <linux/of_irq.h>
  28 #include <linux/of_gpio.h>
  29 #include <linux/of.h>
  30 #include <linux/of_device.h>
  31 #include <linux/regulator/of_regulator.h>
  32 #include <linux/regulator/driver.h>
  33 #include <linux/regulator/machine.h>
  34 #include <linux/regmap.h>
  35
  36 #if 0
  37 #define DBG(x...)       printk(KERN_INFO x)
  38 #else
  39 #define DBG(x...)
  40 #endif
  41 #if 1
  42 #define DBG_INFO(x...)  printk(KERN_INFO x)
  43 #else
  44 #define DBG_INFO(x...)
  45 #endif
  46 #define PM_CONTROL
  47
  48 struct rk808 *g_rk808;
  49 #define DCDC_RAISE_VOL_BYSTEP 1
  50 #define DCDC_VOL_STEP 25000  //25mv
  51
  52 static struct mfd_cell rk808s[] = {
  53         {
  54                 .name = "rk808-rtc",
  55         },
  56 };
  57
  58 #define BUCK_VOL_MASK 0x3f
  59 #define LDO_VOL_MASK 0x3f
  60
  61 #define VOL_MIN_IDX 0x00
  62 #define VOL_MAX_IDX 0x3f
  63
  64 const static int buck_set_vol_base_addr[] = {
  65         RK808_BUCK1_ON_REG,
  66         RK808_BUCK2_ON_REG,
  67         RK808_BUCK3_CONFIG_REG,
  68         RK808_BUCK4_ON_REG,
  69 };
  70 const static int buck_contr_base_addr[] = {
  71         RK808_BUCK1_CONFIG_REG,
  72         RK808_BUCK2_CONFIG_REG,
  73         RK808_BUCK3_CONFIG_REG,
  74         RK808_BUCK4_CONFIG_REG,
  75 };
  76 #define rk808_BUCK_SET_VOL_REG(x) (buck_set_vol_base_addr[x])
  77 #define rk808_BUCK_CONTR_REG(x) (buck_contr_base_addr[x])
  78
  79
  80 const static int ldo_set_vol_base_addr[] = {
  81         RK808_LDO1_ON_VSEL_REG,
  82         RK808_LDO2_ON_VSEL_REG,
  83         RK808_LDO3_ON_VSEL_REG,
  84         RK808_LDO4_ON_VSEL_REG,
  85         RK808_LDO5_ON_VSEL_REG,
  86         RK808_LDO6_ON_VSEL_REG,
  87         RK808_LDO7_ON_VSEL_REG,
  88         RK808_LDO8_ON_VSEL_REG,
  89 //      RK808_LDO1_ON_VSEL_REG,
  90 };
  91 /*
  92 const static int ldo_contr_base_addr[] = {
  93         rk808_LDO1_CONTR_BASE,
  94         rk808_LDO2_CONTR_BASE,
  95         rk808_LDO3_CONTR_BASE,
  96         rk808_LDO4_CONTR_BASE,
  97         rk808_LDO5_CONTR_BASE,
  98         rk808_LDO6_CONTR_BASE,
  99         rk808_LDO7_CONTR_BASE,
 100         rk808_LDO8_CONTR_BASE,
 101 //      rk808_LDO9_CONTR_BASE,
 102 };
 103 */
 104 #define rk808_LDO_SET_VOL_REG(x) (ldo_set_vol_base_addr[x])
 105 //#define rk808_LDO_CONTR_REG(x) (ldo_contr_base_addr[x])
 106
 107 const static int buck_voltage_map[] = {
 108           700,  712,  725,  737,  750, 762,  775,  787,  800,
 109           812,  825,  837,  850,862,  875,  887,  900,  912,
 110           925,  937,  950, 962,  975,  987, 1000, 1012, 1025,
 111           1037, 1050,1062, 1075, 1087, 1100, 1112, 1125, 1137,
 112           1150,1162, 1175, 1187, 1200, 1212, 1225, 1237, 1250,
 113           1262, 1275, 1287, 1300, 1312, 1325, 1337, 1350,1362,
 114           1375, 1387, 1400, 1412, 1425, 1437, 1450,1462, 1475,
 115           1487, 1500,
 116 };
 117
 118 const static int buck4_voltage_map[] = {
 119            1800, 1900, 2000, 2100, 2200,  2300,  2400, 2500, 2600,
 120           2700, 2800, 2900, 3000, 3100, 3200,3300,
 121 };
 122
 123 const static int ldo_voltage_map[] = {
 124           1800, 1900, 2000, 2100, 2200,  2300,  2400, 2500, 2600,
 125           2700, 2800, 2900, 3000, 3100, 3200,3300, 3400,
 126 };
 127 const static int ldo3_voltage_map[] = {
 128          800, 900, 1000, 1100, 1200,  1300, 1400, 1500, 1600,
 129          1700, 1800, 1900,  2000,2100,  2200,  2500,
 130 };
 131 const static int ldo6_voltage_map[] = {
 132          800, 900, 1000, 1100, 1200,  1300, 1400, 1500, 1600,
 133          1700, 1800, 1900,  2000,2100,  2200,  2300,2400,2500,
 134 };
 135
 136 static int rk808_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
 137 {
 138         int ldo= rdev_get_id(dev) - RK808_LDO1;
 139         if (ldo == 2){
 140         if (index >= ARRAY_SIZE(ldo3_voltage_map))
 141                 return -EINVAL;
 142         return 1000 * ldo3_voltage_map[index];
 143         }
 144         else if (ldo == 5 || ldo ==6){
 145         if (index >= ARRAY_SIZE(ldo6_voltage_map))
 146                 return -EINVAL;
 147         return 1000 * ldo6_voltage_map[index];
 148         }
 149         else{
 150         if (index >= ARRAY_SIZE(ldo_voltage_map))
 151                 return -EINVAL;
 152         return 1000 * ldo_voltage_map[index];
 153         }
 154 }
 155 static int rk808_ldo_is_enabled(struct regulator_dev *dev)
 156 {
 157         struct rk808 *rk808 = rdev_get_drvdata(dev);
 158         int ldo= rdev_get_id(dev) - RK808_LDO1;
 159         u16 val;
 160
 161         val = rk808_reg_read(rk808, RK808_LDO_EN_REG);
 162         if (val < 0)
 163                 return val;
 164         if (val & (1 << ldo))
 165                 return 1;
 166         else
 167                 return 0;
 168 }
 169 static int rk808_ldo_enable(struct regulator_dev *dev)
 170 {
 171         struct rk808 *rk808 = rdev_get_drvdata(dev);
 172         int ldo= rdev_get_id(dev) - RK808_LDO1;
 173
 174         return rk808_set_bits(rk808, RK808_LDO_EN_REG, 1 << ldo, 1 << ldo);
 175
 176 }
 177 static int rk808_ldo_disable(struct regulator_dev *dev)
 178 {
 179         struct rk808 *rk808 = rdev_get_drvdata(dev);
 180         int ldo= rdev_get_id(dev) - RK808_LDO1;
 181
 182         return rk808_set_bits(rk808, RK808_LDO_EN_REG, 1 << ldo, 0);
 183
 184 }
 185 static int rk808_ldo_suspend_enable(struct regulator_dev *dev)
 186 {
 187         struct rk808 *rk808 = rdev_get_drvdata(dev);
 188         int ldo= rdev_get_id(dev) - RK808_LDO1;
 189
 190         return rk808_set_bits(rk808, RK808_SLEEP_SET_OFF_REG2, 1 << ldo, 0);
 191
 192 }
 193 static int rk808_ldo_suspend_disable(struct regulator_dev *dev)
 194 {
 195         struct rk808 *rk808 = rdev_get_drvdata(dev);
 196         int ldo= rdev_get_id(dev) - RK808_LDO1;
 197
 198         return rk808_set_bits(rk808, RK808_SLEEP_SET_OFF_REG2, 1 << ldo, 1 << ldo);
 199
 200 }
 201 static int rk808_ldo_get_voltage(struct regulator_dev *dev)
 202 {
 203         struct rk808 *rk808 = rdev_get_drvdata(dev);
 204         int ldo= rdev_get_id(dev) - RK808_LDO1;
 205         u16 reg = 0;
 206         int val;
 207         reg = rk808_reg_read(rk808,rk808_LDO_SET_VOL_REG(ldo));
 208         reg &= LDO_VOL_MASK;
 209         if (ldo ==2){
 210         val = 1000 * ldo3_voltage_map[reg];
 211         }
 212         else if (ldo == 5 || ldo ==6){
 213         val = 1000 * ldo6_voltage_map[reg];
 214         }
 215         else{
 216         val = 1000 * ldo_voltage_map[reg];
 217         }
 218         return val;
 219 }
 220 static int rk808_ldo_set_sleep_voltage(struct regulator_dev *dev,
 221                                             int uV)
 222 {
 223         struct rk808 *rk808 = rdev_get_drvdata(dev);
 224         int ldo= rdev_get_id(dev) - RK808_LDO1;
 225         const int *vol_map = ldo_voltage_map;
 226         int min_vol = uV / 1000;
 227         u16 val;
 228         int ret = 0,num =0;
 229
 230         if (ldo ==2){
 231         vol_map = ldo3_voltage_map;
 232         num = 15;
 233         }
 234         else if (ldo == 5 || ldo ==6){
 235         vol_map = ldo6_voltage_map;
 236         num = 17;
 237         }
 238         else {
 239         num = 16;
 240         }
 241
 242         if (min_vol < vol_map[0] ||
 243             min_vol > vol_map[num])
 244                 return -EINVAL;
 245
 246         for (val = 0; val <= num; val++){
 247                 if (vol_map[val] >= min_vol)
 248                         break;
 249         }
 250
 251         ret = rk808_set_bits(rk808, rk808_LDO_SET_VOL_REG(ldo) +0x01,
 252                 LDO_VOL_MASK, val);
 253         return ret;
 254 }
 255
 256 static int rk808_ldo_set_voltage(struct regulator_dev *dev,
 257                                   int min_uV, int max_uV,unsigned *selector)
 258 {
 259         struct rk808 *rk808 = rdev_get_drvdata(dev);
 260         int ldo= rdev_get_id(dev) - RK808_LDO1;
 261         const int *vol_map;
 262         int min_vol = min_uV / 1000;
 263         u16 val;
 264         int ret = 0,num =0;
 265
 266         if (ldo ==2){
 267         vol_map = ldo3_voltage_map;
 268         num = 15;
 269         }
 270         else if (ldo == 5 || ldo ==6){
 271         vol_map = ldo6_voltage_map;
 272         num = 17;
 273         }
 274         else {
 275         vol_map = ldo_voltage_map;
 276         num = 16;
 277         }
 278
 279         if (min_vol < vol_map[0] ||
 280             min_vol > vol_map[num])
 281                 return -EINVAL;
 282
 283         for (val = 0; val <= num; val++){
 284                 if (vol_map[val] >= min_vol)
 285                         break;
 286         }
 287
 288         ret = rk808_set_bits(rk808, rk808_LDO_SET_VOL_REG(ldo),
 289                 LDO_VOL_MASK, val);
 290         return ret;
 291
 292 }
 293 static unsigned int rk808_ldo_get_mode(struct regulator_dev *dev)
 294 {
 295         struct rk808 *rk808 = rdev_get_drvdata(dev);
 296         int ldo = rdev_get_id(dev) - RK808_LDO1;
 297         u16 mask = 0x80;
 298         u16 val;
 299         val = rk808_reg_read(rk808, rk808_LDO_SET_VOL_REG(ldo));
 300         if (val < 0) {
 301                 return val;
 302         }
 303         val=val & mask;
 304         if (val== mask)
 305                 return REGULATOR_MODE_NORMAL;
 306         else
 307                 return REGULATOR_MODE_STANDBY;
 308
 309 }
 310 static int rk808_ldo_set_mode(struct regulator_dev *dev, unsigned int mode)
 311 {
 312         struct rk808 *rk808 = rdev_get_drvdata(dev);
 313         int ldo = rdev_get_id(dev) - RK808_LDO1;
 314         u16 mask = 0x80;
 315         switch(mode)
 316         {
 317         case REGULATOR_MODE_FAST:
 318                 return rk808_set_bits(rk808, rk808_LDO_SET_VOL_REG(ldo), mask, mask);
 319         case REGULATOR_MODE_NORMAL:
 320                 return rk808_set_bits(rk808, rk808_LDO_SET_VOL_REG(ldo), mask, 0);
 321         default:
 322                 printk("error:pmu_rk808 only lowpower and nomal mode\n");
 323                 return -EINVAL;
 324         }
 325
 326
 327 }
 328 static struct regulator_ops rk808_ldo_ops = {
 329         .set_voltage = rk808_ldo_set_voltage,
 330         .get_voltage = rk808_ldo_get_voltage,
 331         .list_voltage = rk808_ldo_list_voltage,
 332         .is_enabled = rk808_ldo_is_enabled,
 333         .enable = rk808_ldo_enable,
 334         .disable = rk808_ldo_disable,
 335         .set_suspend_enable =rk808_ldo_suspend_enable,
 336         .set_suspend_disable =rk808_ldo_suspend_disable,
 337         .get_mode = rk808_ldo_get_mode,
 338         .set_mode = rk808_ldo_set_mode,
 339         .set_suspend_voltage = rk808_ldo_set_sleep_voltage,
 340
 341 };
 342
 343 static int rk808_dcdc_list_voltage(struct regulator_dev *dev, unsigned selector)
 344 {
 345         int volt;
 346         int buck = rdev_get_id(dev) - RK808_DCDC1;
 347
 348         if (selector < 0x0 ||selector > BUCK_VOL_MASK )
 349                 return -EINVAL;
 350
 351         switch (buck) {
 352         case 0:
 353         case 1:
 354                 volt = 700000 + selector * 12500;
 355                 break;
 356         case 3:
 357                 volt = 1800000 + selector * 100000;
 358                 break;
 359         case 2:
 360                 volt = 1200000;
 361                 break;
 362         default:
 363                 BUG();
 364                 return -EINVAL;
 365         }
 366
 367         return  volt ;
 368 }
 369 static int rk808_dcdc_is_enabled(struct regulator_dev *dev)
 370 {
 371         struct rk808 *rk808 = rdev_get_drvdata(dev);
 372         int buck = rdev_get_id(dev) - RK808_DCDC1;
 373         u16 val;
 374
 375         val = rk808_reg_read(rk808, RK808_DCDC_EN_REG);
 376         if (val < 0)
 377                 return val;
 378         if (val & (1 << buck))
 379                 return 1;
 380         else
 381                 return 0;
 382 }
 383 static int rk808_dcdc_enable(struct regulator_dev *dev)
 384 {
 385         struct rk808 *rk808 = rdev_get_drvdata(dev);
 386         int buck = rdev_get_id(dev) - RK808_DCDC1;
 387
 388         return rk808_set_bits(rk808, RK808_DCDC_EN_REG, 1 << buck, 1 << buck);
 389
 390 }
 391 static int rk808_dcdc_disable(struct regulator_dev *dev)
 392 {
 393         struct rk808 *rk808 = rdev_get_drvdata(dev);
 394         int buck = rdev_get_id(dev) - RK808_DCDC1;
 395
 396          return rk808_set_bits(rk808, RK808_DCDC_EN_REG, 1 << buck , 0);
 397 }
 398
 399 static int rk808_dcdc_suspend_enable(struct regulator_dev *dev)
 400 {
 401         struct rk808 *rk808 = rdev_get_drvdata(dev);
 402         int buck = rdev_get_id(dev) - RK808_DCDC1;
 403
 404         return rk808_set_bits(rk808, RK808_SLEEP_SET_OFF_REG1, 1 << buck, 0);
 405
 406 }
 407 static int rk808_dcdc_suspend_disable(struct regulator_dev *dev)
 408 {
 409         struct rk808 *rk808 = rdev_get_drvdata(dev);
 410         int buck = rdev_get_id(dev) - RK808_DCDC1;
 411
 412          return rk808_set_bits(rk808, RK808_SLEEP_SET_OFF_REG1, 1 << buck , 1 << buck);
 413 }
 414 static int rk808_dcdc_get_voltage(struct regulator_dev *dev)
 415 {
 416         struct rk808 *rk808 = rdev_get_drvdata(dev);
 417         int buck = rdev_get_id(dev) - RK808_DCDC1;
 418         u16 reg = 0;
 419         int val;
 420
 421         reg = rk808_reg_read(rk808,rk808_BUCK_SET_VOL_REG(buck));
 422
 423         reg &= BUCK_VOL_MASK;
 424         val = rk808_dcdc_list_voltage(dev,reg);
 425         return val;
 426 }
 427 static int rk808_dcdc_select_min_voltage(struct regulator_dev *dev,
 428                                            int min_uV, int max_uV ,int buck)
 429 {
 430         u16 vsel =0;
 431
 432         if (buck == 0 || buck ==  1){
 433                 if (min_uV < 700000)
 434                 vsel = 0;
 435                 else if (min_uV <= 1500000)
 436                 vsel = ((min_uV - 700000) / 12500) ;
 437                 else
 438                 return -EINVAL;
 439         }
 440         else if (buck ==3){
 441                 if (min_uV < 1800000)
 442                 vsel = 0;
 443                 else if (min_uV <= 3300000)
 444                 vsel = ((min_uV - 1800000) / 100000) ;
 445                 else
 446                 return -EINVAL;
 447         }
 448         if (rk808_dcdc_list_voltage(dev, vsel) > max_uV)
 449                 return -EINVAL;
 450         return vsel;
 451 }
 452
 453 static int rk808_dcdc_set_voltage(struct regulator_dev *dev,
 454                                   int min_uV, int max_uV,unsigned *selector)
 455 {
 456         struct rk808 *rk808 = rdev_get_drvdata(dev);
 457         int buck = rdev_get_id(dev) - RK808_DCDC1;
 458         u16 val;
 459         int ret = 0,old_voltage =0,vol_temp =0;
 460
 461         if (buck ==2){
 462                 return 0;
 463         }else if (buck==3){
 464                 val = rk808_dcdc_select_min_voltage(dev,min_uV,max_uV,buck);
 465                 ret = rk808_set_bits(rk808, rk808_BUCK_SET_VOL_REG(buck), BUCK_VOL_MASK, val);
 466         }
 467         else {
 468 #if defined(DCDC_RAISE_VOL_BYSTEP)
 469                 old_voltage = rk808_dcdc_get_voltage(dev);
 470                         if (max_uV >old_voltage){
 471                                 vol_temp = old_voltage;
 472                                do{
 473                                         vol_temp +=   DCDC_VOL_STEP;
 474                                         val = rk808_dcdc_select_min_voltage(dev,vol_temp,vol_temp,buck);
 475                                 //      printk("rk808_dcdc_set_voltage buck = %d vol_temp= %d old_voltage= %d min_uV =%d \n",buck,vol_temp,old_voltage,min_uV);
 476                                         ret = rk808_set_bits(rk808, rk808_BUCK_SET_VOL_REG(buck), BUCK_VOL_MASK, val);
 477                                 }while(vol_temp != max_uV);
 478                         }
 479                         else{
 480                                 val = rk808_dcdc_select_min_voltage(dev,min_uV,max_uV,buck);
 481                                 ret = rk808_set_bits(rk808, rk808_BUCK_SET_VOL_REG(buck), BUCK_VOL_MASK, val);
 482                         }
 483 #else
 484                 val = rk808_dcdc_select_min_voltage(dev,min_uV,max_uV,buck);
 485                 ret = rk808_set_bits(rk808, rk808_BUCK_SET_VOL_REG(buck), BUCK_VOL_MASK, val);
 486 #endif
 487         }
 488         return ret;
 489 }
 490 static int rk808_dcdc_set_sleep_voltage(struct regulator_dev *dev,
 491                                             int uV)
 492 {
 493         struct rk808 *rk808 = rdev_get_drvdata(dev);
 494         int buck = rdev_get_id(dev) - RK808_DCDC1;
 495         u16 val;
 496         int ret = 0;
 497
 498         if (buck ==2){
 499         return 0;
 500         }else{
 501         val = rk808_dcdc_select_min_voltage(dev,uV,uV,buck);
 502         ret = rk808_set_bits(rk808, (rk808_BUCK_SET_VOL_REG(buck) + 0x01), BUCK_VOL_MASK, val);
 503         }
 504         return ret;
 505 }
 506 static unsigned int rk808_dcdc_get_mode(struct regulator_dev *dev)
 507 {
 508         struct rk808 *rk808 = rdev_get_drvdata(dev);
 509         int buck = rdev_get_id(dev) - RK808_DCDC1;
 510         u16 mask = 0x80;
 511         u16 val;
 512         val = rk808_reg_read(rk808, rk808_BUCK_SET_VOL_REG(buck));
 513         if (val < 0) {
 514                 return val;
 515         }
 516         val=val & mask;
 517         if (val== mask)
 518                 return REGULATOR_MODE_FAST;
 519         else
 520                 return REGULATOR_MODE_NORMAL;
 521
 522 }
 523 static int rk808_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
 524 {
 525         struct rk808 *rk808 = rdev_get_drvdata(dev);
 526         int buck = rdev_get_id(dev) - RK808_DCDC1;
 527         u16 mask = 0x80;
 528
 529         switch(mode)
 530         {
 531         case REGULATOR_MODE_FAST:
 532                 return rk808_set_bits(rk808, rk808_BUCK_SET_VOL_REG(buck), mask, mask);
 533         case REGULATOR_MODE_NORMAL:
 534                 return rk808_set_bits(rk808, rk808_BUCK_SET_VOL_REG(buck), mask, 0);
 535         default:
 536                 printk("error:pmu_rk808 only powersave and pwm mode\n");
 537                 return -EINVAL;
 538         }
 539
 540 }
 541 static int rk808_dcdc_set_suspend_mode(struct regulator_dev *dev, unsigned int mode)
 542 {
 543         struct rk808 *rk808 = rdev_get_drvdata(dev);
 544         int buck = rdev_get_id(dev) - RK808_DCDC1;
 545         u16 mask = 0x80;
 546
 547         switch(mode)
 548         {
 549         case REGULATOR_MODE_FAST:
 550                 return rk808_set_bits(rk808, (rk808_BUCK_SET_VOL_REG(buck) + 0x01), mask, mask);
 551         case REGULATOR_MODE_NORMAL:
 552                 return rk808_set_bits(rk808, (rk808_BUCK_SET_VOL_REG(buck) + 0x01), mask, 0);
 553         default:
 554                 printk("error:pmu_rk808 only powersave and pwm mode\n");
 555                 return -EINVAL;
 556         }
 557
 558 }
 559 static int rk808_dcdc_set_voltage_time_sel(struct regulator_dev *dev,   unsigned int old_selector,
 560                                      unsigned int new_selector)
 561 {
 562         int old_volt, new_volt;
 563
 564         old_volt = rk808_dcdc_list_voltage(dev, old_selector);
 565         if (old_volt < 0)
 566                 return old_volt;
 567
 568         new_volt = rk808_dcdc_list_voltage(dev, new_selector);
 569         if (new_volt < 0)
 570                 return new_volt;
 571
 572         return DIV_ROUND_UP(abs(old_volt - new_volt)*2, 2500);
 573 }
 574
 575 static struct regulator_ops rk808_dcdc_ops = {
 576         .set_voltage = rk808_dcdc_set_voltage,
 577         .get_voltage = rk808_dcdc_get_voltage,
 578         .list_voltage= rk808_dcdc_list_voltage,
 579         .is_enabled = rk808_dcdc_is_enabled,
 580         .enable = rk808_dcdc_enable,
 581         .disable = rk808_dcdc_disable,
 582         .set_suspend_enable =rk808_dcdc_suspend_enable,
 583         .set_suspend_disable =rk808_dcdc_suspend_disable,
 584         .get_mode = rk808_dcdc_get_mode,
 585         .set_mode = rk808_dcdc_set_mode,
 586         .set_suspend_mode = rk808_dcdc_set_suspend_mode,
 587         .set_suspend_voltage = rk808_dcdc_set_sleep_voltage,
 588         .set_voltage_time_sel = rk808_dcdc_set_voltage_time_sel,
 589 };
 590 static struct regulator_desc regulators[] = {
 591
 592         {
 593                 .name = "RK_DCDC1",
 594                 .id = 0,
 595                 .ops = &rk808_dcdc_ops,
 596                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 597                 .type = REGULATOR_VOLTAGE,
 598                 .owner = THIS_MODULE,
 599         },
 600         {
 601                 .name = "RK_DCDC2",
 602                 .id = 1,
 603                 .ops = &rk808_dcdc_ops,
 604                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 605                 .type = REGULATOR_VOLTAGE,
 606                 .owner = THIS_MODULE,
 607         },
 608         {
 609                 .name = "RK_DCDC3",
 610                 .id = 2,
 611                 .ops = &rk808_dcdc_ops,
 612                 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
 613                 .type = REGULATOR_VOLTAGE,
 614                 .owner = THIS_MODULE,
 615         },
 616         {
 617                 .name = "RK_DCDC4",
 618                 .id = 3,
 619                 .ops = &rk808_dcdc_ops,
 620                 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
 621                 .type = REGULATOR_VOLTAGE,
 622                 .owner = THIS_MODULE,
 623         },
 624
 625         {
 626                 .name = "RK_LDO1",
 627                 .id =4,
 628                 .ops = &rk808_ldo_ops,
 629                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 630                 .type = REGULATOR_VOLTAGE,
 631                 .owner = THIS_MODULE,
 632         },
 633         {
 634                 .name = "RK_LDO2",
 635                 .id = 5,
 636                 .ops = &rk808_ldo_ops,
 637                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 638                 .type = REGULATOR_VOLTAGE,
 639                 .owner = THIS_MODULE,
 640         },
 641         {
 642                 .name = "RK_LDO3",
 643                 .id = 6,
 644                 .ops = &rk808_ldo_ops,
 645                 .n_voltages = ARRAY_SIZE(ldo3_voltage_map),
 646                 .type = REGULATOR_VOLTAGE,
 647                 .owner = THIS_MODULE,
 648         },
 649         {
 650                 .name = "RK_LDO4",
 651                 .id = 7,
 652                 .ops = &rk808_ldo_ops,
 653                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 654                 .type = REGULATOR_VOLTAGE,
 655                 .owner = THIS_MODULE,
 656         },
 657
 658         {
 659                 .name = "RK_LDO5",
 660                 .id =8,
 661                 .ops = &rk808_ldo_ops,
 662                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 663                 .type = REGULATOR_VOLTAGE,
 664                 .owner = THIS_MODULE,
 665         },
 666         {
 667                 .name = "RK_LDO6",
 668                 .id = 9,
 669                 .ops = &rk808_ldo_ops,
 670                 .n_voltages = ARRAY_SIZE(ldo6_voltage_map),
 671                 .type = REGULATOR_VOLTAGE,
 672                 .owner = THIS_MODULE,
 673         },
 674         {
 675                 .name = "RK_LDO7",
 676                 .id = 10,
 677                 .ops = &rk808_ldo_ops,
 678                 .n_voltages = ARRAY_SIZE(ldo6_voltage_map),
 679                 .type = REGULATOR_VOLTAGE,
 680                 .owner = THIS_MODULE,
 681         },
 682         {
 683                 .name = "RK_LDO8",
 684                 .id = 11,
 685                 .ops = &rk808_ldo_ops,
 686                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 687                 .type = REGULATOR_VOLTAGE,
 688                 .owner = THIS_MODULE,
 689         },
 690
 691 };
 692
 693 /*
 694  *
 695  */
 696  int rk808_i2c_read(struct rk808 *rk808, char reg, int count,u8 *dest)
 697 {
 698         struct i2c_client *i2c = rk808->i2c;
 699         int ret;
 700     struct i2c_adapter *adap;
 701     struct i2c_msg msgs[2];
 702
 703     if(!i2c)
 704                 return ret;
 705
 706         if (count != 1)
 707                 return -EIO;
 708
 709     adap = i2c->adapter;
 710
 711     msgs[0].addr = i2c->addr;
 712     msgs[0].buf = &reg;
 713     msgs[0].flags = i2c->flags;
 714     msgs[0].len = 1;
 715     msgs[0].scl_rate = 100*1000;
 716
 717     msgs[1].buf = (u8 *)dest;
 718     msgs[1].addr = i2c->addr;
 719     msgs[1].flags =  i2c->flags |I2C_M_RD;
 720     msgs[1].len = 1;
 721     msgs[1].scl_rate = 100*1000;
 722
 723     ret = i2c_transfer(adap, msgs, 2);
 724
 725         DBG("***run in %s %x  % x\n",__FUNCTION__,i2c->addr,*(msgs[1].buf));
 726     return 0;
 727 }
 728
 729 int rk808_i2c_write(struct rk808 *rk808, char reg, int count,  const u8 src)
 730 {
 731         int ret=-1;
 732         struct i2c_client *i2c = rk808->i2c;
 733         struct i2c_adapter *adap;
 734         struct i2c_msg msg;
 735         char tx_buf[2];
 736
 737         if(!i2c)
 738                 return ret;
 739         if (count != 1)
 740                 return -EIO;
 741
 742         adap = i2c->adapter;
 743         tx_buf[0] = reg;
 744         tx_buf[1] = src;
 745
 746         msg.addr = i2c->addr;
 747         msg.buf = &tx_buf[0];
 748         msg.len = 1 +1;
 749         msg.flags = i2c->flags;
 750         msg.scl_rate = 100*1000;
 751
 752         ret = i2c_transfer(adap, &msg, 1);
 753         return ret;
 754 }
 755
 756 u8 rk808_reg_read(struct rk808 *rk808, u8 reg)
 757 {
 758         u8 val = 0;
 759
 760         mutex_lock(&rk808->io_lock);
 761
 762         rk808_i2c_read(rk808, reg, 1, &val);
 763
 764         DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 765
 766         mutex_unlock(&rk808->io_lock);
 767
 768         return val & 0xff;
 769 }
 770 EXPORT_SYMBOL_GPL(rk808_reg_read);
 771
 772 int rk808_reg_write(struct rk808 *rk808, u8 reg, u8 val)
 773 {
 774         int err =0;
 775
 776         mutex_lock(&rk808->io_lock);
 777
 778         err = rk808_i2c_write(rk808, reg, 1,val);
 779         if (err < 0)
 780                 dev_err(rk808->dev, "Write for reg 0x%x failed\n", reg);
 781
 782         mutex_unlock(&rk808->io_lock);
 783         return err;
 784 }
 785 EXPORT_SYMBOL_GPL(rk808_reg_write);
 786
 787  int rk808_set_bits(struct rk808 *rk808, u8 reg, u8 mask, u8 val)
 788 {
 789         u8 tmp;
 790         int ret;
 791
 792         mutex_lock(&rk808->io_lock);
 793
 794         ret = rk808_i2c_read(rk808, reg, 1, &tmp);
 795         DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
 796         tmp = (tmp & ~mask) | val;
 797         if (ret == 0) {
 798                 ret = rk808_i2c_write(rk808, reg, 1, tmp);
 799                 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 800         }
 801         rk808_i2c_read(rk808, reg, 1, &tmp);
 802         DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
 803         mutex_unlock(&rk808->io_lock);
 804
 805         return 0;//ret;
 806 }
 807 EXPORT_SYMBOL_GPL(rk808_set_bits);
 808
 809 int rk808_clear_bits(struct rk808 *rk808, u8 reg, u8 mask)
 810 {
 811         u8 data;
 812         int err;
 813
 814         mutex_lock(&rk808->io_lock);
 815         err = rk808_i2c_read(rk808, reg, 1, &data);
 816         if (err <0) {
 817                 dev_err(rk808->dev, "read from reg %x failed\n", reg);
 818                 goto out;
 819         }
 820
 821         data &= ~mask;
 822         err = rk808_i2c_write(rk808, reg, 1, data);
 823         if (err <0)
 824                 dev_err(rk808->dev, "write to reg %x failed\n", reg);
 825
 826 out:
 827         mutex_unlock(&rk808->io_lock);
 828         return err;
 829 }
 830 EXPORT_SYMBOL_GPL(rk808_clear_bits);
 831 #if 0
 832 int rk808_bulk_read(struct rk808 *rk808, u8 reg,
 833                      int count, u8 *buf)
 834 {
 835         int ret;
 836
 837 #if defined(CONFIG_MFD_RK610)
 838         int i;             //Solve communication conflict when rk610 and rk808 on the same i2c
 839
 840         mutex_lock(&rk808->io_lock);
 841         for(i=0; i<count; i++){
 842                 ret = rk808_reg_read(rk808, reg+i);
 843                 if(ret < 0){
 844                         printk("%s: failed read reg 0x%0x, ret = %d\n", __FUNCTION__, reg+i, ret);
 845                         mutex_unlock(&rk808->io_lock);
 846                         return ret;
 847                 }else{
 848                         buf[i] = ret & 0x000000FF;
 849                 }
 850         }
 851         mutex_unlock(&rk808->io_lock);
 852 #else
 853         mutex_lock(&rk808->io_lock);
 854
 855         ret = rk808->read(rk808, reg, count, buf);
 856
 857         mutex_unlock(&rk808->io_lock);
 858 #endif
 859         return 0;
 860
 861 }
 862 EXPORT_SYMBOL_GPL(rk808_bulk_read);
 863
 864 int rk808_bulk_write(struct rk808 *rk808, u8 reg,
 865                      int count, u8 *buf)
 866 {
 867         int ret;
 868
 869 #if defined(CONFIG_MFD_RK610)
 870         int i;       // //Solve communication conflict when rk610 and 808 on the same i2c
 871
 872         mutex_lock(&rk808->io_lock);
 873         for(i=0; i<count; i++){
 874                 ret = rk808_reg_write(rk808, reg+i, buf[i]);
 875                 if(ret < 0){
 876                         printk("%s: failed write reg=0x%0x, val=0x%0x, ret = %d\n", __FUNCTION__, reg+i, buf[i], ret);
 877                         mutex_unlock(&rk808->io_lock);
 878                         return ret;
 879                 }
 880         }
 881         mutex_unlock(&rk808->io_lock);
 882 #else
 883         mutex_lock(&rk808->io_lock);
 884
 885         ret = rk808->write(rk808, reg, count, buf);
 886
 887         mutex_unlock(&rk808->io_lock);
 888 #endif
 889         return 0;
 890
 891 }
 892 EXPORT_SYMBOL_GPL(rk808_bulk_write);
 893 #endif
 894
 895 #if 1
 896 static ssize_t rk808_test_store(struct kobject *kobj, struct kobj_attribute *attr,
 897                                 const char *buf, size_t n)
 898 {
 899     u32 getdata[8];
 900     u16 regAddr;
 901     u8 data;
 902     char cmd;
 903     const char *buftmp = buf;
 904     struct rk808 *rk808 = g_rk808;
 905     /**
 906      * W Addr(8Bit) regAddr(8Bit) data0(8Bit) data1(8Bit) data2(8Bit) data3(8Bit)
 907      *          :data can be less than 4 byte
 908      * R regAddr(8Bit)
 909      * C gpio_name(poweron/powerhold/sleep/boot0/boot1) value(H/L)
 910      */
 911         regAddr = (u16)(getdata[0] & 0xff);
 912          if (strncmp(buf, "start", 5) == 0) {
 913
 914
 915     } else if (strncmp(buf, "stop", 4== 0) ){
 916
 917     } else{
 918         sscanf(buftmp, "%c ", &cmd);
 919         printk("------zhangqing: get cmd = %c\n", cmd);
 920         switch(cmd) {
 921
 922         case 'w':
 923                 sscanf(buftmp, "%c %x %x ", &cmd, &getdata[0],&getdata[1]);
 924                  regAddr = (u16)(getdata[0] & 0xff);
 925                 data = (u8)(getdata[1] & 0xff);
 926                 printk("get value = %x\n", data);
 927
 928              rk808_i2c_write(rk808, regAddr, 1, data);
 929              rk808_i2c_read(rk808, regAddr, 1, &data);
 930              printk("%x   %x\n", getdata[1],data);
 931
 932             break;
 933
 934         case 'r':
 935             sscanf(buftmp, "%c %x ", &cmd, &getdata[0]);
 936             printk("CMD : %c %x\n", cmd, getdata[0]);
 937
 938             regAddr = (u16)(getdata[0] & 0xff);
 939             rk808_i2c_read(rk808, regAddr, 1, &data);
 940                 printk("%x %x\n", getdata[0],data);
 941
 942             break;
 943
 944         default:
 945             printk("Unknown command\n");
 946             break;
 947         }
 948 }
 949     return n;
 950
 951 }
 952 static ssize_t rk808_test_show(struct kobject *kobj, struct kobj_attribute *attr,
 953                                char *buf)
 954 {
 955    char *s = buf;
 956     buf = "hello";
 957     return sprintf(s, "%s\n", buf);
 958
 959 }
 960
 961 static struct kobject *rk808_kobj;
 962 struct rk808_attribute {
 963         struct attribute        attr;
 964         ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,
 965                         char *buf);
 966         ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,
 967                         const char *buf, size_t n);
 968 };
 969
 970 static struct rk808_attribute rk808_attrs[] = {
 971         /*     node_name        permision               show_func       store_func */
 972         __ATTR(rk808_test,      S_IRUGO | S_IWUSR,      rk808_test_show,        rk808_test_store),
 973 };
 974 #endif
 975
 976 extern void rk28_send_wakeup_key(void);
 977 static irqreturn_t rk808_vbat_lo_irq(int irq, void *data)
 978 {
 979         printk("rk808 vbat low %s:irq=%d\n",__func__,irq);
 980         rk808_set_bits(g_rk808,0x4c,(0x1 << 1),(0x1 <<1));
 981 //      rk28_send_wakeup_key();
 982         return IRQ_HANDLED;
 983 }
 984
 985 #ifdef CONFIG_OF
 986 static struct of_device_id rk808_of_match[] = {
 987         { .compatible = "rockchip,rk808"},
 988         { },
 989 };
 990 MODULE_DEVICE_TABLE(of, rk808_of_match);
 991 #endif
 992
 993 #ifdef CONFIG_OF
 994 static struct of_regulator_match rk808_reg_matches[] = {
 995         { .name = "rk_dcdc1", .driver_data = (void *)0 },
 996         { .name = "rk_dcdc2", .driver_data = (void *)1 },
 997         { .name = "rk_dcdc3", .driver_data = (void *)2 },
 998         { .name = "rk_dcdc4", .driver_data = (void *)3 },
 999         { .name = "rk_ldo1", .driver_data = (void *)4 },
1000         { .name = "rk_ldo2", .driver_data = (void *)5 },
1001         { .name = "rk_ldo3", .driver_data = (void *)6 },
1002         { .name = "rk_ldo4", .driver_data = (void *)7 },
1003         { .name = "rk_ldo5", .driver_data = (void *)8 },
1004         { .name = "rk_ldo6", .driver_data = (void *)9 },
1005         { .name = "rk_ldo7", .driver_data = (void *)10 },
1006         { .name = "rk_ldo8", .driver_data = (void *)11 },
1007 };
1008
1009 static struct rk808_board *rk808_parse_dt(struct rk808 *rk808)
1010 {
1011         struct rk808_board *pdata;
1012         struct device_node *regs,*rk808_pmic_np;
1013         int i, count;
1014
1015         rk808_pmic_np = of_node_get(rk808->dev->of_node);
1016         if (!rk808_pmic_np) {
1017                 printk("could not find pmic sub-node\n");
1018                 return NULL;
1019         }
1020
1021         regs = of_find_node_by_name(rk808_pmic_np, "regulators");
1022         if (!regs)
1023                 return NULL;
1024
1025         count = of_regulator_match(rk808->dev, regs, rk808_reg_matches,
1026                                    rk808_NUM_REGULATORS);
1027         of_node_put(regs);
1028         if ((count < 0) || (count > rk808_NUM_REGULATORS))
1029                 return NULL;
1030
1031         pdata = devm_kzalloc(rk808->dev, sizeof(*pdata), GFP_KERNEL);
1032         if (!pdata)
1033                 return NULL;
1034
1035         for (i = 0; i < count; i++) {
1036                 if (!rk808_reg_matches[i].init_data || !rk808_reg_matches[i].of_node)
1037                         continue;
1038
1039                 pdata->rk808_init_data[i] = rk808_reg_matches[i].init_data;
1040                 pdata->of_node[i] = rk808_reg_matches[i].of_node;
1041         }
1042         pdata->irq = rk808->chip_irq;
1043         pdata->irq_base = -1;
1044
1045         pdata->irq_gpio = of_get_named_gpio(rk808_pmic_np,"gpios",0);
1046                 if (!gpio_is_valid(pdata->irq_gpio)) {
1047                         printk("invalid gpio: %d\n",  pdata->irq_gpio);
1048                         return NULL;
1049                 }
1050
1051         pdata->pmic_sleep_gpio = of_get_named_gpio(rk808_pmic_np,"gpios",1);
1052                         if (!gpio_is_valid(pdata->pmic_sleep_gpio)) {
1053                                 printk("invalid gpio: %d\n",  pdata->pmic_sleep_gpio);
1054                 }
1055         pdata->pmic_sleep = true;
1056
1057         return pdata;
1058 }
1059
1060 #else
1061 static struct rk808_board *rk808_parse_dt(struct i2c_client *i2c)
1062 {
1063         return NULL;
1064 }
1065 #endif
1066
1067
1068 int rk808_device_shutdown(void)
1069 {
1070         int ret;
1071         int err = -1;
1072         struct rk808 *rk808 = g_rk808;
1073
1074         printk("%s\n",__func__);
1075
1076         ret = rk808_reg_read(rk808,RK808_DEVCTRL_REG);
1077         ret = rk808_set_bits(rk808, RK808_DEVCTRL_REG,(0x1<<3),(0x1<<3));
1078 //      ret = rk808_set_bits(rk808, RK808_DEVCTRL_REG,(0x1<<4),(0x1<<4));
1079         if (ret < 0) {
1080                 printk("rk808 power off error!\n");
1081                 return err;
1082         }
1083         return 0;
1084 }
1085 EXPORT_SYMBOL_GPL(rk808_device_shutdown);
1086
1087 __weak void  rk808_device_suspend(void) {}
1088 __weak void  rk808_device_resume(void) {}
1089 #ifdef CONFIG_PM
1090 static int rk808_suspend(struct i2c_client *i2c, pm_message_t mesg)
1091 {
1092         rk808_device_suspend();
1093         return 0;
1094 }
1095
1096 static int rk808_resume(struct i2c_client *i2c)
1097 {
1098         rk808_device_resume();
1099         return 0;
1100 }
1101 #else
1102 static int rk808_suspend(struct i2c_client *i2c, pm_message_t mesg)
1103 {
1104         return 0;
1105 }
1106
1107 static int rk808_resume(struct i2c_client *i2c)
1108 {
1109         return 0;
1110 }
1111 #endif
1112
1113 static bool is_volatile_reg(struct device *dev, unsigned int reg)
1114 {
1115         if ((reg >= RK808_DCDC_EN_REG) && (reg <= RK808_LDO8_SLP_VSEL_REG)) {
1116                 return true;
1117         }
1118         return true;
1119 }
1120
1121 static const struct regmap_config rk808_regmap_config = {
1122         .reg_bits = 8,
1123         .val_bits = 8,
1124         .volatile_reg = is_volatile_reg,
1125         .max_register = rk808_NUM_REGULATORS - 1,
1126         .cache_type = REGCACHE_RBTREE,
1127 };
1128
1129 #ifdef CONFIG_HAS_EARLYSUSPEND
1130 __weak void rk808_early_suspend(struct early_suspend *h) {}
1131 __weak void rk808_late_resume(struct early_suspend *h) {}
1132 #endif
1133
1134 static int rk808_pre_init(struct rk808 *rk808)
1135 {
1136         int ret,val;
1137          printk("%s,line=%d\n", __func__,__LINE__);
1138          /***********set ILIM ************/
1139         val = rk808_reg_read(rk808,RK808_BUCK3_CONFIG_REG);
1140         val &= (~(0x7 <<0));
1141         val |= (0x2 <<0);
1142         ret = rk808_reg_write(rk808,RK808_BUCK3_CONFIG_REG,val);
1143         if (ret < 0) {
1144                 printk(KERN_ERR "Unable to write RK808_BUCK3_CONFIG_REG reg\n");
1145                 return ret;
1146         }
1147
1148         val = rk808_reg_read(rk808,RK808_BUCK4_CONFIG_REG);
1149         val &= (~(0x7 <<0));
1150         val |= (0x3 <<0);
1151         ret = rk808_reg_write(rk808,RK808_BUCK4_CONFIG_REG,val);
1152         if (ret < 0) {
1153                 printk(KERN_ERR "Unable to write RK808_BUCK4_CONFIG_REG reg\n");
1154                 return ret;
1155         }
1156
1157         val = rk808_reg_read(rk808,RK808_BOOST_CONFIG_REG);
1158         val &= (~(0x7 <<0));
1159         val |= (0x1 <<0);
1160         ret = rk808_reg_write(rk808,RK808_BOOST_CONFIG_REG,val);
1161         if (ret < 0) {
1162                 printk(KERN_ERR "Unable to write RK808_BOOST_CONFIG_REG reg\n");
1163                 return ret;
1164         }
1165         /*****************************************/
1166         /***********set buck OTP function************/
1167         ret = rk808_reg_write(rk808,0x6f,0x5a);
1168         if (ret < 0) {
1169                 printk(KERN_ERR "Unable to write 0x6f reg\n");
1170                 return ret;
1171         }
1172
1173         ret = rk808_reg_write(rk808,0x91,0x80);
1174         if (ret < 0) {
1175                 printk(KERN_ERR "Unable to write 0x91 reg\n");
1176                 return ret;
1177         }
1178
1179         ret = rk808_reg_write(rk808,0x92,0x55);
1180          if (ret <0) {
1181                 printk(KERN_ERR "Unable to write 0x92 reg\n");
1182                 return ret;
1183         }
1184         /*****************************************/
1185         /***********set buck 12.5mv/us ************/
1186         val = rk808_reg_read(rk808,RK808_BUCK1_CONFIG_REG);
1187         val &= (~(0x3 <<3));
1188         val |= (0x3 <<0);
1189         ret = rk808_reg_write(rk808,RK808_BUCK1_CONFIG_REG,val);
1190         if (ret < 0) {
1191                 printk(KERN_ERR "Unable to write RK808_BUCK1_CONFIG_REG reg\n");
1192                 return ret;
1193         }
1194
1195         val = rk808_reg_read(rk808,RK808_BUCK2_CONFIG_REG);
1196         val &= (~(0x3 <<3));
1197         val |= (0x3 <<0);
1198         ret = rk808_reg_write(rk808,RK808_BUCK2_CONFIG_REG,val);
1199          if (ret <0) {
1200                 printk(KERN_ERR "Unable to write RK808_BUCK2_CONFIG_REG reg\n");
1201                 return ret;
1202         }
1203         /*****************************************/
1204
1205         /*******enable switch and boost***********/
1206         val = rk808_reg_read(rk808,RK808_DCDC_EN_REG);
1207         val |= (0x3 << 5);    //enable switch1/2
1208         val |= (0x1 << 4);    //enable boost
1209         ret = rk808_reg_write(rk808,RK808_DCDC_EN_REG,val);
1210          if (ret <0) {
1211                 printk(KERN_ERR "Unable to write RK808_DCDC_EN_REG reg\n");
1212                 return ret;
1213         }
1214         /****************************************/
1215
1216         /****************set vbat low **********/
1217         val = rk808_reg_read(rk808,RK808_VB_MON_REG);
1218        val &=(~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1219        val |= (RK808_VBAT_LOW_3V5 | EN_VBAT_LOW_IRQ);
1220        ret = rk808_reg_write(rk808,RK808_VB_MON_REG,val);
1221          if (ret <0) {
1222                 printk(KERN_ERR "Unable to write RK818_VB_MON_REG reg\n");
1223                 return ret;
1224         }
1225         /**************************************/
1226
1227         /**********mask int****************/
1228          val = rk808_reg_read(rk808,RK808_INT_STS_MSK_REG1);
1229          val |= (0x1<<0); //mask vout_lo_int
1230         ret = rk808_reg_write(rk808,RK808_INT_STS_MSK_REG1,val);
1231          if (ret <0) {
1232                 printk(KERN_ERR "Unable to write RK808_INT_STS_MSK_REG1 reg\n");
1233                 return ret;
1234         }
1235         /**********************************/
1236         /**********enable clkout2****************/
1237         ret = rk808_reg_write(rk808,RK808_CLK32OUT_REG,0x01);
1238          if (ret <0) {
1239                 printk(KERN_ERR "Unable to write RK808_CLK32OUT_REG reg\n");
1240                 return ret;
1241         }
1242         /**********************************/
1243         return 0;
1244 }
1245
1246 static int rk808_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
1247 {
1248         struct rk808 *rk808;
1249         struct rk808_board *pdev;
1250         const struct of_device_id *match;
1251         struct regulator_config config = { };
1252         struct regulator_dev *rk808_rdev;
1253         struct regulator_init_data *reg_data;
1254         const char *rail_name = NULL;
1255         int ret,vlow_irq,i=0;
1256
1257         printk("%s,line=%d\n", __func__,__LINE__);
1258
1259         if (i2c->dev.of_node) {
1260                 match = of_match_device(rk808_of_match, &i2c->dev);
1261                 if (!match) {
1262                         dev_err(&i2c->dev,"Failed to find matching dt id\n");
1263                         return -EINVAL;
1264                 }
1265         }
1266
1267         rk808 = devm_kzalloc(&i2c->dev,sizeof(struct rk808), GFP_KERNEL);
1268         if (rk808 == NULL) {
1269                 ret = -ENOMEM;
1270                 goto err;
1271         }
1272         rk808->i2c = i2c;
1273         rk808->dev = &i2c->dev;
1274         i2c_set_clientdata(i2c, rk808);
1275 //      rk808->read = rk808_i2c_read;
1276 //      rk808->write = rk808_i2c_write;
1277
1278         rk808->regmap = devm_regmap_init_i2c(i2c, &rk808_regmap_config);
1279         if (IS_ERR(rk808->regmap)) {
1280                 printk("regmap initialization failed\n");
1281                 return ret;
1282         }
1283
1284         mutex_init(&rk808->io_lock);
1285
1286         ret = rk808_reg_read(rk808,0x2f);
1287         if ((ret < 0) || (ret == 0xff)){
1288                 printk("The device is not rk808 %d\n",ret);
1289                 goto err;
1290         }
1291
1292         ret = rk808_pre_init(rk808);
1293         if (ret < 0){
1294                 printk("The rk808_pre_init failed %d\n",ret);
1295                 goto err;
1296         }
1297
1298         if (rk808->dev->of_node)
1299                 pdev = rk808_parse_dt(rk808);
1300
1301         /******************************set sleep vol & dcdc mode******************/
1302         #ifdef CONFIG_OF
1303         rk808->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
1304         if (rk808->pmic_sleep_gpio) {
1305                         ret = gpio_request(rk808->pmic_sleep_gpio, "rk808_pmic_sleep");
1306                         if (ret < 0) {
1307                                 dev_err(rk808->dev,"Failed to request gpio %d with ret:""%d\n", rk808->pmic_sleep_gpio, ret);
1308                                 return IRQ_NONE;
1309                         }
1310                         gpio_direction_output(rk808->pmic_sleep_gpio,0);
1311                         ret = gpio_get_value(rk808->pmic_sleep_gpio);
1312                         gpio_free(rk808->pmic_sleep_gpio);
1313                         pr_info("%s: rk808_pmic_sleep=%x\n", __func__, ret);
1314         }
1315         #endif
1316         /**********************************************************/
1317
1318         if (pdev) {
1319                 rk808->num_regulators = rk808_NUM_REGULATORS;
1320                 rk808->rdev = kcalloc(rk808_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
1321                 if (!rk808->rdev) {
1322                         return -ENOMEM;
1323                 }
1324                 /* Instantiate the regulators */
1325                 for (i = 0; i < rk808_NUM_REGULATORS; i++) {
1326                 reg_data = pdev->rk808_init_data[i];
1327                 if (!reg_data)
1328                         continue;
1329                 config.dev = rk808->dev;
1330                 config.driver_data = rk808;
1331                 config.regmap = rk808->regmap;
1332                 if (rk808->dev->of_node)
1333                         config.of_node = pdev->of_node[i];
1334                 if (reg_data && reg_data->constraints.name)
1335                                 rail_name = reg_data->constraints.name;
1336                         else
1337                                 rail_name = regulators[i].name;
1338                         reg_data->supply_regulator = rail_name;
1339
1340                 config.init_data =reg_data;
1341
1342                 rk808_rdev = regulator_register(&regulators[i],&config);
1343                 if (IS_ERR(rk808_rdev)) {
1344                         printk("failed to register %d regulator\n",i);
1345                 goto err;
1346                 }
1347                 rk808->rdev[i] = rk808_rdev;
1348                 }
1349         }
1350
1351 //      rk808->wakeup = pdev->wakeup;
1352         rk808->irq_gpio = pdev->irq_gpio;
1353         ret = rk808_irq_init(rk808, rk808->irq_gpio, pdev);
1354         if (ret < 0)
1355                 goto err;
1356
1357         ret = mfd_add_devices(rk808->dev, -1,
1358                               rk808s, ARRAY_SIZE(rk808s),
1359                               NULL, 0,NULL);
1360         #if 0
1361         /********************vbat low int**************/
1362         vlow_irq = irq_create_mapping(rk808->irq_domain, RK808_IRQ_VB_LO);
1363          ret = request_threaded_irq(vlow_irq, NULL, rk808_vbat_lo_irq,
1364                                    IRQF_TRIGGER_RISING, "rk808_vbatlow",
1365                                    rk808);
1366         if (ret != 0) {
1367                 dev_err(rk808->dev, "Failed to request periodic IRQ %d: %d\n",
1368                         vlow_irq+ RK808_IRQ_VB_LO, ret);
1369
1370         }
1371         #endif
1372         /*********************************************/
1373
1374         g_rk808 = rk808;
1375
1376         #ifdef CONFIG_HAS_EARLYSUSPEND
1377         rk808->rk808_suspend.suspend = rk808_early_suspend,
1378         rk808->rk808_suspend.resume = rk808_late_resume,
1379         rk808->rk808_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 1,
1380         register_early_suspend(&rk808->rk808_suspend);
1381         #endif
1382
1383         #if 1
1384         rk808_kobj = kobject_create_and_add("rk808", NULL);
1385         if (!rk808_kobj)
1386                 return -ENOMEM;
1387         for (i = 0; i < ARRAY_SIZE(rk808_attrs); i++) {
1388                 ret = sysfs_create_file(rk808_kobj, &rk808_attrs[i].attr);
1389                 if (ret != 0) {
1390                         printk("create index %d error\n", i);
1391                         return ret;
1392                 }
1393         }
1394         #endif
1395
1396         return 0;
1397
1398 err:
1399         mfd_remove_devices(rk808->dev);
1400         return ret;
1401
1402 }
1403
1404 static int rk808_i2c_remove(struct i2c_client *i2c)
1405 {
1406         struct rk808 *rk808 = i2c_get_clientdata(i2c);
1407         int i;
1408
1409         for (i = 0; i < rk808->num_regulators; i++)
1410                 if (rk808->rdev[i])
1411                         regulator_unregister(rk808->rdev[i]);
1412         kfree(rk808->rdev);
1413         i2c_set_clientdata(i2c, NULL);
1414         kfree(rk808);
1415
1416         return 0;
1417 }
1418
1419 static const struct i2c_device_id rk808_i2c_id[] = {
1420        { "rk808", 0 },
1421        { }
1422 };
1423
1424 MODULE_DEVICE_TABLE(i2c, rk808_i2c_id);
1425
1426 static struct i2c_driver rk808_i2c_driver = {
1427         .driver = {
1428                 .name = "rk808",
1429                 .owner = THIS_MODULE,
1430                 .of_match_table =of_match_ptr(rk808_of_match),
1431         },
1432         .probe    = rk808_i2c_probe,
1433         .remove   = rk808_i2c_remove,
1434         .id_table = rk808_i2c_id,
1435         #ifdef CONFIG_PM
1436         .suspend        = rk808_suspend,
1437         .resume         = rk808_resume,
1438         #endif
1439 };
1440
1441 static int __init rk808_module_init(void)
1442 {
1443         int ret;
1444         ret = i2c_add_driver(&rk808_i2c_driver);
1445         if (ret != 0)
1446                 pr_err("Failed to register I2C driver: %d\n", ret);
1447         return ret;
1448 }
1449 //module_init(rk808_module_init);
1450 //subsys_initcall(rk808_module_init);
1451 //rootfs_initcall(rk808_module_init);
1452 subsys_initcall_sync(rk808_module_init);
1453
1454 static void __exit rk808_module_exit(void)
1455 {
1456         i2c_del_driver(&rk808_i2c_driver);
1457 }
1458 module_exit(rk808_module_exit);
1459
1460 MODULE_LICENSE("GPL");
1461 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1462 MODULE_DESCRIPTION("rk808 PMIC driver");
1463