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