drivers/mfd/rk-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 static irqreturn_t rk808_vbat_lo_irq(int irq, void *data)
1036 {
1037         printk("rk808 vbat low %s:irq=%d\n",__func__,irq);
1038         rk808_set_bits(g_rk808,0x4c,(0x1 << 1),(0x1 <<1));
1039 //      rk_send_wakeup_key();
1040         return IRQ_HANDLED;
1041 }
1042 #endif
1043 #ifdef CONFIG_OF
1044 static struct of_device_id rk808_of_match[] = {
1045         { .compatible = "rockchip,rk808"},
1046         { },
1047 };
1048 MODULE_DEVICE_TABLE(of, rk808_of_match);
1049 #endif
1050
1051 #ifdef CONFIG_OF
1052 static struct of_regulator_match rk808_reg_matches[] = {
1053         { .name = "rk_dcdc1", .driver_data = (void *)0 },
1054         { .name = "rk_dcdc2", .driver_data = (void *)1 },
1055         { .name = "rk_dcdc3", .driver_data = (void *)2 },
1056         { .name = "rk_dcdc4", .driver_data = (void *)3 },
1057         { .name = "rk_ldo1", .driver_data = (void *)4 },
1058         { .name = "rk_ldo2", .driver_data = (void *)5 },
1059         { .name = "rk_ldo3", .driver_data = (void *)6 },
1060         { .name = "rk_ldo4", .driver_data = (void *)7 },
1061         { .name = "rk_ldo5", .driver_data = (void *)8 },
1062         { .name = "rk_ldo6", .driver_data = (void *)9 },
1063         { .name = "rk_ldo7", .driver_data = (void *)10 },
1064         { .name = "rk_ldo8", .driver_data = (void *)11 },
1065         { .name = "rk_ldo9", .driver_data = (void *)12 },
1066         { .name = "rk_ldo10", .driver_data = (void *)13 },
1067 };
1068
1069 static struct rk808_board *rk808_parse_dt(struct rk808 *rk808)
1070 {
1071         struct rk808_board *pdata;
1072         struct device_node *regs,*rk808_pmic_np;
1073         int i, count;
1074
1075         rk808_pmic_np = of_node_get(rk808->dev->of_node);
1076         if (!rk808_pmic_np) {
1077                 printk("could not find pmic sub-node\n");
1078                 return NULL;
1079         }
1080
1081         regs = of_find_node_by_name(rk808_pmic_np, "regulators");
1082         if (!regs)
1083                 return NULL;
1084
1085         count = of_regulator_match(rk808->dev, regs, rk808_reg_matches,
1086                                    rk808_NUM_REGULATORS);
1087         of_node_put(regs);
1088         if ((count < 0) || (count > rk808_NUM_REGULATORS))
1089                 return NULL;
1090
1091         pdata = devm_kzalloc(rk808->dev, sizeof(*pdata), GFP_KERNEL);
1092         if (!pdata)
1093                 return NULL;
1094
1095         for (i = 0; i < count; i++) {
1096                 if (!rk808_reg_matches[i].init_data || !rk808_reg_matches[i].of_node)
1097                         continue;
1098
1099                 pdata->rk808_init_data[i] = rk808_reg_matches[i].init_data;
1100                 pdata->of_node[i] = rk808_reg_matches[i].of_node;
1101         }
1102         pdata->irq = rk808->chip_irq;
1103         pdata->irq_base = -1;
1104
1105         pdata->irq_gpio = of_get_named_gpio(rk808_pmic_np,"gpios",0);
1106                 if (!gpio_is_valid(pdata->irq_gpio)) {
1107                         printk("invalid gpio: %d\n",  pdata->irq_gpio);
1108                         return NULL;
1109                 }
1110
1111         pdata->pmic_sleep_gpio = of_get_named_gpio(rk808_pmic_np,"gpios",1);
1112                         if (!gpio_is_valid(pdata->pmic_sleep_gpio)) {
1113                                 printk("invalid gpio: %d\n",  pdata->pmic_sleep_gpio);
1114                 }
1115         pdata->pmic_sleep = true;
1116
1117         pdata->pm_off = of_property_read_bool(rk808_pmic_np,"rk808,system-power-controller");
1118
1119         return pdata;
1120 }
1121
1122 #else
1123 static struct rk808_board *rk808_parse_dt(struct i2c_client *i2c)
1124 {
1125         return NULL;
1126 }
1127 #endif
1128 static void rk808_shutdown(void)
1129 {
1130         int ret,i,val;
1131         u16 reg = 0;
1132         struct rk808 *rk808 = g_rk808;
1133
1134         printk("%s\n",__func__);
1135         /***************get dc1\dc2 voltage *********************/
1136         for(i=0;i<2;i++){
1137         reg = rk808_reg_read(rk808,rk808_BUCK_SET_VOL_REG(i));
1138         reg &= BUCK_VOL_MASK;
1139         val = 712500 + reg * 12500;
1140         printk("%s,line=%d dc[%d]= %d\n", __func__,__LINE__,(i+1),val);
1141         }
1142         /*****************************************************/
1143         ret = rk808_set_bits(rk808, RK808_INT_STS_MSK_REG1,(0x3<<5),(0x3<<5)); //close rtc int when power off
1144         ret = rk808_clear_bits(rk808, RK808_RTC_INT_REG,(0x3<<2)); //close rtc int when power off
1145         mutex_lock(&rk808->io_lock);
1146         mdelay(100);
1147 }
1148
1149 static struct syscore_ops rk808_syscore_ops = {
1150         .shutdown = rk808_shutdown,
1151 };
1152
1153 static void rk808_device_shutdown(void)
1154 {
1155         int ret,i;
1156         u8 reg = 0;
1157         struct rk808 *rk808 = g_rk808;
1158         for(i=0;i < 10;i++){
1159                 printk("%s\n",__func__);
1160                 ret = rk808_i2c_read(rk808,RK808_DEVCTRL_REG,1,&reg);
1161                 if(ret < 0)
1162                         continue;
1163                 ret = rk808_i2c_write(rk808, RK808_DEVCTRL_REG, 1,(reg |(0x1 <<3)));
1164                 if (ret < 0) {
1165                         printk("rk808 power off error!\n");
1166                         continue;
1167                 }
1168         }
1169         while(1)wfi();
1170 }
1171 EXPORT_SYMBOL_GPL(rk808_device_shutdown);
1172
1173 __weak void  rk808_device_suspend(void) {}
1174 __weak void  rk808_device_resume(void) {}
1175 #ifdef CONFIG_PM
1176 static int rk808_suspend(struct device *dev)
1177 {
1178         rk808_device_suspend();
1179         return 0;
1180 }
1181
1182 static int rk808_resume(struct device *dev)
1183 {
1184         rk808_device_resume();
1185         return 0;
1186 }
1187 #else
1188 static int rk808_suspend(struct device *dev)
1189 {
1190         return 0;
1191 }
1192
1193 static int rk808_resume(struct device *dev)
1194 {
1195         return 0;
1196 }
1197 #endif
1198
1199 static bool is_volatile_reg(struct device *dev, unsigned int reg)
1200 {
1201         if ((reg >= RK808_DCDC_EN_REG) && (reg <= RK808_LDO8_SLP_VSEL_REG)) {
1202                 return true;
1203         }
1204         return true;
1205 }
1206
1207 static const struct regmap_config rk808_regmap_config = {
1208         .reg_bits = 8,
1209         .val_bits = 8,
1210         .volatile_reg = is_volatile_reg,
1211         .max_register = rk808_NUM_REGULATORS - 1,
1212         .cache_type = REGCACHE_RBTREE,
1213 };
1214
1215 #ifdef CONFIG_HAS_EARLYSUSPEND
1216 __weak void rk808_early_suspend(struct early_suspend *h) {}
1217 __weak void rk808_late_resume(struct early_suspend *h) {}
1218 #endif
1219
1220 static int rk808_pre_init(struct rk808 *rk808)
1221 {
1222         int ret,val;
1223          printk("%s,line=%d\n", __func__,__LINE__);
1224          /**********disable dcdc uv func****************/
1225         ret = rk808_reg_write(rk808,RK808_DCDC_UV_ACT_REG,0x10);
1226          if (ret <0) {
1227                 printk(KERN_ERR "Unable to write RK808_DCDC_UV_ACT_REG reg\n");
1228                 return ret;
1229         }
1230         /**********************************/
1231          /***********set ILIM ************/
1232         val = rk808_reg_read(rk808,RK808_BUCK3_CONFIG_REG);
1233         val &= (~(0x7 <<0));
1234         val |= (0x2 <<0);
1235         ret = rk808_reg_write(rk808,RK808_BUCK3_CONFIG_REG,val);
1236         if (ret < 0) {
1237                 printk(KERN_ERR "Unable to write RK808_BUCK3_CONFIG_REG reg\n");
1238                 return ret;
1239         }
1240
1241         val = rk808_reg_read(rk808,RK808_BUCK4_CONFIG_REG);
1242         val &= (~(0x7 <<0));
1243         val |= (0x3 <<0);
1244         ret = rk808_reg_write(rk808,RK808_BUCK4_CONFIG_REG,val);
1245         if (ret < 0) {
1246                 printk(KERN_ERR "Unable to write RK808_BUCK4_CONFIG_REG reg\n");
1247                 return ret;
1248         }
1249
1250         val = rk808_reg_read(rk808,RK808_BOOST_CONFIG_REG);
1251         val &= (~(0x7 <<0));
1252         val |= (0x1 <<0);
1253         ret = rk808_reg_write(rk808,RK808_BOOST_CONFIG_REG,val);
1254         if (ret < 0) {
1255                 printk(KERN_ERR "Unable to write RK808_BOOST_CONFIG_REG reg\n");
1256                 return ret;
1257         }
1258         /*****************************************/
1259         /***********set buck OTP function************/
1260         ret = rk808_reg_write(rk808,0x6f,0x5a);
1261         if (ret < 0) {
1262                 printk(KERN_ERR "Unable to write 0x6f reg\n");
1263                 return ret;
1264         }
1265
1266         ret = rk808_reg_write(rk808,0x91,0x80);
1267         if (ret < 0) {
1268                 printk(KERN_ERR "Unable to write 0x91 reg\n");
1269                 return ret;
1270         }
1271
1272         ret = rk808_reg_write(rk808,0x92,0x55);
1273          if (ret <0) {
1274                 printk(KERN_ERR "Unable to write 0x92 reg\n");
1275                 return ret;
1276         }
1277         /*****************************************/
1278         /***********set buck 12.5mv/us ************/
1279         val = rk808_reg_read(rk808,RK808_BUCK1_CONFIG_REG);
1280         val &= (~(0x3 <<3));
1281         val |= (0x3 <<0);
1282         ret = rk808_reg_write(rk808,RK808_BUCK1_CONFIG_REG,val);
1283         if (ret < 0) {
1284                 printk(KERN_ERR "Unable to write RK808_BUCK1_CONFIG_REG reg\n");
1285                 return ret;
1286         }
1287
1288         val = rk808_reg_read(rk808,RK808_BUCK2_CONFIG_REG);
1289         val &= (~(0x3 <<3));
1290         val |= (0x3 <<0);
1291         ret = rk808_reg_write(rk808,RK808_BUCK2_CONFIG_REG,val);
1292          if (ret <0) {
1293                 printk(KERN_ERR "Unable to write RK808_BUCK2_CONFIG_REG reg\n");
1294                 return ret;
1295         }
1296         /*****************************************/
1297
1298         /*******enable switch and boost***********/
1299         val = rk808_reg_read(rk808,RK808_DCDC_EN_REG);
1300         val |= (0x3 << 5);    //enable switch1/2
1301         val |= (0x1 << 4);    //enable boost
1302         ret = rk808_reg_write(rk808,RK808_DCDC_EN_REG,val);
1303          if (ret <0) {
1304                 printk(KERN_ERR "Unable to write RK808_DCDC_EN_REG reg\n");
1305                 return ret;
1306         }
1307         /****************************************/
1308
1309         /****************set vbat low **********/
1310         val = rk808_reg_read(rk808,RK808_VB_MON_REG);
1311        val &=(~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1312        val |= (RK808_VBAT_LOW_3V5 | EN_VBAT_LOW_IRQ);
1313        ret = rk808_reg_write(rk808,RK808_VB_MON_REG,val);
1314          if (ret <0) {
1315                 printk(KERN_ERR "Unable to write RK818_VB_MON_REG reg\n");
1316                 return ret;
1317         }
1318         /**************************************/
1319
1320         /**********mask int****************/
1321          val = rk808_reg_read(rk808,RK808_INT_STS_MSK_REG1);
1322          val |= (0x1<<0); //mask vout_lo_int
1323         ret = rk808_reg_write(rk808,RK808_INT_STS_MSK_REG1,val);
1324          if (ret <0) {
1325                 printk(KERN_ERR "Unable to write RK808_INT_STS_MSK_REG1 reg\n");
1326                 return ret;
1327         }
1328         /**********************************/
1329         /**********enable clkout2****************/
1330         ret = rk808_reg_write(rk808,RK808_CLK32OUT_REG,0x01);
1331          if (ret <0) {
1332                 printk(KERN_ERR "Unable to write RK808_CLK32OUT_REG reg\n");
1333                 return ret;
1334         }
1335         /**********************************/
1336         ret = rk808_clear_bits(rk808, RK808_INT_STS_MSK_REG1,(0x3<<5)); //open rtc int when power on
1337         ret = rk808_set_bits(rk808, RK808_RTC_INT_REG,(0x1<<3),(0x1<<3)); //open rtc int when power on
1338
1339         return 0;
1340 }
1341
1342 static int rk808_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
1343 {
1344         struct rk808 *rk808;
1345         struct rk808_board *pdev;
1346         const struct of_device_id *match;
1347         struct regulator_config config = { };
1348         struct regulator_dev *rk808_rdev;
1349         struct regulator_init_data *reg_data;
1350         const char *rail_name = NULL;
1351         int ret,i=0;
1352 //      int vlow_irq;
1353
1354         printk("%s,line=%d\n", __func__,__LINE__);
1355
1356         if (i2c->dev.of_node) {
1357                 match = of_match_device(rk808_of_match, &i2c->dev);
1358                 if (!match) {
1359                         dev_err(&i2c->dev,"Failed to find matching dt id\n");
1360                         return -EINVAL;
1361                 }
1362         }
1363
1364         rk808 = devm_kzalloc(&i2c->dev,sizeof(struct rk808), GFP_KERNEL);
1365         if (rk808 == NULL) {
1366                 ret = -ENOMEM;
1367                 goto err;
1368         }
1369         rk808->i2c = i2c;
1370         rk808->dev = &i2c->dev;
1371         i2c_set_clientdata(i2c, rk808);
1372 //      rk808->read = rk808_i2c_read;
1373 //      rk808->write = rk808_i2c_write;
1374
1375         rk808->regmap = devm_regmap_init_i2c(i2c, &rk808_regmap_config);
1376         if (IS_ERR(rk808->regmap)) {
1377                 printk("regmap initialization failed\n");
1378                 return ret;
1379         }
1380
1381         mutex_init(&rk808->io_lock);
1382
1383         ret = rk808_reg_read(rk808,0x2f);
1384         if ((ret < 0) || (ret == 0xff)){
1385                 printk("The device is not rk808 %d\n",ret);
1386                 goto err;
1387         }
1388
1389         ret = rk808_pre_init(rk808);
1390         if (ret < 0){
1391                 printk("The rk808_pre_init failed %d\n",ret);
1392                 goto err;
1393         }
1394
1395         if (rk808->dev->of_node)
1396                 pdev = rk808_parse_dt(rk808);
1397
1398         /******************************set sleep vol & dcdc mode******************/
1399         #ifdef CONFIG_OF
1400         rk808->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
1401         if (gpio_is_valid(rk808->pmic_sleep_gpio)) {
1402                         ret = gpio_request(rk808->pmic_sleep_gpio, "rk808_pmic_sleep");
1403                         if (ret < 0) {
1404                                 dev_err(rk808->dev,"Failed to request gpio %d with ret:""%d\n", rk808->pmic_sleep_gpio, ret);
1405                                 return IRQ_NONE;
1406                         }
1407                         gpio_direction_output(rk808->pmic_sleep_gpio,0);
1408                         ret = gpio_get_value(rk808->pmic_sleep_gpio);
1409                         gpio_free(rk808->pmic_sleep_gpio);
1410                         pr_info("%s: rk808_pmic_sleep=%x\n", __func__, ret);
1411         }
1412         #endif
1413         /**********************************************************/
1414
1415         if (pdev) {
1416                 rk808->num_regulators = rk808_NUM_REGULATORS;
1417                 rk808->rdev = kcalloc(rk808_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
1418                 if (!rk808->rdev) {
1419                         return -ENOMEM;
1420                 }
1421                 /* Instantiate the regulators */
1422                 for (i = 0; i < rk808_NUM_REGULATORS; i++) {
1423                 reg_data = pdev->rk808_init_data[i];
1424                 if (!reg_data)
1425                         continue;
1426                 config.dev = rk808->dev;
1427                 config.driver_data = rk808;
1428                 config.regmap = rk808->regmap;
1429                 if (rk808->dev->of_node)
1430                         config.of_node = pdev->of_node[i];
1431                 if (reg_data && reg_data->constraints.name)
1432                                 rail_name = reg_data->constraints.name;
1433                         else
1434                                 rail_name = regulators[i].name;
1435                         reg_data->supply_regulator = rail_name;
1436
1437                 config.init_data =reg_data;
1438
1439                 rk808_rdev = regulator_register(&regulators[i],&config);
1440                 if (IS_ERR(rk808_rdev)) {
1441                         printk("failed to register %d regulator\n",i);
1442                 goto err;
1443                 }
1444                 rk808->rdev[i] = rk808_rdev;
1445                 }
1446         }
1447
1448 //      rk808->wakeup = pdev->wakeup;
1449         rk808->irq_gpio = pdev->irq_gpio;
1450         ret = rk808_irq_init(rk808, rk808->irq_gpio, pdev);
1451         if (ret < 0)
1452                 goto err;
1453
1454         ret = mfd_add_devices(rk808->dev, -1,
1455                               rk808s, ARRAY_SIZE(rk808s),
1456                               NULL, 0,NULL);
1457         #if 0
1458         /********************vbat low int**************/
1459         vlow_irq = irq_create_mapping(rk808->irq_domain, RK808_IRQ_VB_LO);
1460          ret = request_threaded_irq(vlow_irq, NULL, rk808_vbat_lo_irq,
1461                                    IRQF_TRIGGER_RISING, "rk808_vbatlow",
1462                                    rk808);
1463         if (ret != 0) {
1464                 dev_err(rk808->dev, "Failed to request periodic IRQ %d: %d\n",
1465                         vlow_irq+ RK808_IRQ_VB_LO, ret);
1466
1467         }
1468         #endif
1469         /*********************************************/
1470
1471         g_rk808 = rk808;
1472         if (pdev->pm_off && !pm_power_off) {
1473                 pm_power_off = rk808_device_shutdown;
1474         }
1475
1476         #ifdef CONFIG_HAS_EARLYSUSPEND
1477         rk808->rk808_suspend.suspend = rk808_early_suspend,
1478         rk808->rk808_suspend.resume = rk808_late_resume,
1479         rk808->rk808_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 1,
1480         register_early_suspend(&rk808->rk808_suspend);
1481         #endif
1482
1483         #if 1
1484         rk808_kobj = kobject_create_and_add("rk808", NULL);
1485         if (!rk808_kobj)
1486                 return -ENOMEM;
1487         for (i = 0; i < ARRAY_SIZE(rk808_attrs); i++) {
1488                 ret = sysfs_create_file(rk808_kobj, &rk808_attrs[i].attr);
1489                 if (ret != 0) {
1490                         printk("create index %d error\n", i);
1491                         return ret;
1492                 }
1493         }
1494         #endif
1495
1496         register_syscore_ops(&rk808_syscore_ops);
1497
1498         return 0;
1499
1500 err:
1501         mfd_remove_devices(rk808->dev);
1502         return ret;
1503
1504 }
1505
1506 static int rk808_i2c_remove(struct i2c_client *i2c)
1507 {
1508         struct rk808 *rk808 = i2c_get_clientdata(i2c);
1509         int i;
1510
1511         unregister_syscore_ops(&rk808_syscore_ops);
1512         for (i = 0; i < rk808->num_regulators; i++)
1513                 if (rk808->rdev[i])
1514                         regulator_unregister(rk808->rdev[i]);
1515         kfree(rk808->rdev);
1516         i2c_set_clientdata(i2c, NULL);
1517
1518         return 0;
1519 }
1520
1521 static const struct dev_pm_ops rk808_pm_ops = {
1522         .suspend = rk808_suspend,
1523         .resume =  rk808_resume,
1524 };
1525
1526 static const struct i2c_device_id rk808_i2c_id[] = {
1527        { "rk808", 0 },
1528        { }
1529 };
1530
1531 MODULE_DEVICE_TABLE(i2c, rk808_i2c_id);
1532
1533 static struct i2c_driver rk808_i2c_driver = {
1534         .driver = {
1535                 .name = "rk808",
1536                 .owner = THIS_MODULE,
1537                 #ifdef CONFIG_PM
1538                 .pm = &rk808_pm_ops,
1539                 #endif
1540                 .of_match_table =of_match_ptr(rk808_of_match),
1541         },
1542         .probe    = rk808_i2c_probe,
1543         .remove   = rk808_i2c_remove,
1544         .id_table = rk808_i2c_id,
1545 };
1546
1547 static int __init rk808_module_init(void)
1548 {
1549         int ret;
1550         ret = i2c_add_driver(&rk808_i2c_driver);
1551         if (ret != 0)
1552                 pr_err("Failed to register I2C driver: %d\n", ret);
1553         return ret;
1554 }
1555 //module_init(rk808_module_init);
1556 //subsys_initcall(rk808_module_init);
1557 //rootfs_initcall(rk808_module_init);
1558 subsys_initcall_sync(rk808_module_init);
1559
1560 static void __exit rk808_module_exit(void)
1561 {
1562         i2c_del_driver(&rk808_i2c_driver);
1563 }
1564 module_exit(rk808_module_exit);
1565
1566 MODULE_LICENSE("GPL");
1567 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1568 MODULE_DESCRIPTION("rk808 PMIC driver");
1569