drivers/mfd/rk818.c

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