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 extern void rk_send_wakeup_key(void);
 961 static irqreturn_t rk818_vbat_lo_irq(int irq, void *data)
 962 {
 963         printk("rk818 vbat low %s:irq=%d\n",__func__,irq);
 964         rk818_set_bits(g_rk818,0x4c,(0x1 << 1),(0x1 <<1));
 965         rk_send_wakeup_key();
 966         return IRQ_HANDLED;
 967 }
 968 #endif
 969
 970 #ifdef CONFIG_OF
 971 static struct of_device_id rk818_of_match[] = {
 972         { .compatible = "rockchip,rk818"},
 973         { },
 974 };
 975 MODULE_DEVICE_TABLE(of, rk818_of_match);
 976 #endif
 977
 978 #ifdef CONFIG_OF
 979 static struct of_regulator_match rk818_reg_matches[] = {
 980         { .name = "rk818_dcdc1", .driver_data = (void *)0 },
 981         { .name = "rk818_dcdc2", .driver_data = (void *)1 },
 982         { .name = "rk818_dcdc3", .driver_data = (void *)2 },
 983         { .name = "rk818_dcdc4", .driver_data = (void *)3 },
 984         { .name = "rk818_ldo1", .driver_data = (void *)4 },
 985         { .name = "rk818_ldo2", .driver_data = (void *)5 },
 986         { .name = "rk818_ldo3", .driver_data = (void *)6 },
 987         { .name = "rk818_ldo4", .driver_data = (void *)7 },
 988         { .name = "rk818_ldo5", .driver_data = (void *)8 },
 989         { .name = "rk818_ldo6", .driver_data = (void *)9 },
 990         { .name = "rk818_ldo7", .driver_data = (void *)10 },
 991         { .name = "rk818_ldo8", .driver_data = (void *)11 },
 992         { .name = "rk818_ldo9", .driver_data = (void *)12 },
 993         { .name = "rk818_ldo10", .driver_data = (void *)13 },
 994 };
 995
 996 static struct rk818_board *rk818_parse_dt(struct rk818 *rk818)
 997 {
 998         struct rk818_board *pdata;
 999         struct device_node *regs,*rk818_pmic_np;
1000         int i, count;
1001
1002         rk818_pmic_np = of_node_get(rk818->dev->of_node);
1003         if (!rk818_pmic_np) {
1004                 printk("could not find pmic sub-node\n");
1005                 return NULL;
1006         }
1007
1008         regs = of_find_node_by_name(rk818_pmic_np, "regulators");
1009         if (!regs)
1010                 return NULL;
1011
1012         count = of_regulator_match(rk818->dev, regs, rk818_reg_matches,
1013                                    rk818_NUM_REGULATORS);
1014         of_node_put(regs);
1015         if ((count < 0) || (count > rk818_NUM_REGULATORS))
1016                 return NULL;
1017
1018         pdata = devm_kzalloc(rk818->dev, sizeof(*pdata), GFP_KERNEL);
1019         if (!pdata)
1020                 return NULL;
1021
1022         for (i = 0; i < count; i++) {
1023                 if (!rk818_reg_matches[i].init_data || !rk818_reg_matches[i].of_node)
1024                         continue;
1025
1026                 pdata->rk818_init_data[i] = rk818_reg_matches[i].init_data;
1027                 pdata->of_node[i] = rk818_reg_matches[i].of_node;
1028         }
1029         pdata->irq = rk818->chip_irq;
1030         pdata->irq_base = -1;
1031
1032         pdata->irq_gpio = of_get_named_gpio(rk818_pmic_np,"gpios",0);
1033                 if (!gpio_is_valid(pdata->irq_gpio)) {
1034                         printk("invalid gpio: %d\n",  pdata->irq_gpio);
1035                         return NULL;
1036                 }
1037
1038         pdata->pmic_sleep_gpio = of_get_named_gpio(rk818_pmic_np,"gpios",1);
1039                         if (!gpio_is_valid(pdata->pmic_sleep_gpio)) {
1040                                 printk("invalid gpio: %d\n",  pdata->pmic_sleep_gpio);
1041                 }
1042         pdata->pmic_sleep = true;
1043         pdata->pm_off = of_property_read_bool(rk818_pmic_np,"rk818,system-power-controller");
1044
1045         return pdata;
1046 }
1047
1048 #else
1049 static struct rk818_board *rk818_parse_dt(struct i2c_client *i2c)
1050 {
1051         return NULL;
1052 }
1053 #endif
1054
1055 static void rk818_shutdown(void)
1056 {
1057         int ret;
1058         struct rk818 *rk818 = g_rk818;
1059
1060         pr_info("%s\n", __func__);
1061         ret = rk818_set_bits(rk818, RK818_INT_STS_MSK_REG1,(0x3<<5),(0x3<<5)); //close rtc int when power off
1062         ret = rk818_clear_bits(rk818, RK818_RTC_INT_REG,(0x3<<2)); //close rtc int when power off
1063         /*disable otg_en*/
1064         ret = rk818_clear_bits(rk818, RK818_DCDC_EN_REG, (0x1<<7));
1065
1066         mutex_lock(&rk818->io_lock);
1067         mdelay(100);
1068 }
1069
1070 static struct syscore_ops rk818_syscore_ops = {
1071         .shutdown = rk818_shutdown,
1072 };
1073
1074 void rk818_device_shutdown(void)
1075 {
1076         int ret, i;
1077         u8 reg = 0;
1078         struct rk818 *rk818 = g_rk818;
1079
1080         for (i = 0; i < 10; i++) {
1081                 pr_info("%s\n", __func__);
1082                 ret = rk818_i2c_read(rk818, RK818_DEVCTRL_REG, 1, &reg);
1083                 if (ret < 0)
1084                         continue;
1085                 ret = rk818_i2c_write(rk818, RK818_DEVCTRL_REG, 1,
1086                                      (reg | (0x1 << 0)));
1087                 if (ret < 0) {
1088                         pr_err("rk818 power off error!\n");
1089                         continue;
1090                 }
1091         }
1092         while(1) wfi();
1093 }
1094 EXPORT_SYMBOL_GPL(rk818_device_shutdown);
1095
1096 __weak void  rk818_device_suspend(void) {}
1097 __weak void  rk818_device_resume(void) {}
1098 #ifdef CONFIG_PM
1099 static int rk818_suspend(struct i2c_client *i2c, pm_message_t mesg)
1100 {
1101         int ret, val;
1102         struct rk818 *rk818 = g_rk818;
1103
1104         rk818_device_suspend();
1105         /************set vbat low 3v4 to irq**********/
1106         val = rk818_reg_read(rk818, RK818_VB_MON_REG);
1107         val &= (~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1108         val |= (RK818_VBAT_LOW_3V4 | EN_VBAT_LOW_IRQ);
1109         ret = rk818_reg_write(rk818, RK818_VB_MON_REG, val);
1110         if (ret < 0) {
1111                 pr_err("Unable to write RK818_VB_MON_REG reg\n");
1112                 return ret;
1113         }
1114         /*enable low irq*/
1115         rk818_set_bits(rk818, 0x4d, (0x1 << 1), (0x0 << 1));
1116         return 0;
1117 }
1118
1119 static int rk818_resume(struct i2c_client *i2c)
1120 {
1121         int ret, val;
1122         struct rk818 *rk818 = g_rk818;
1123
1124         rk818_device_resume();
1125         /********set vbat low 3v0 to shutdown**********/
1126         val = rk818_reg_read(rk818, RK818_VB_MON_REG);
1127         val &= (~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1128         val |= (RK818_VBAT_LOW_3V0 | EN_VABT_LOW_SHUT_DOWN);
1129         ret = rk818_reg_write(rk818, RK818_VB_MON_REG, val);
1130         if (ret < 0) {
1131                 pr_err("Unable to write RK818_VB_MON_REG reg\n");
1132                 return ret;
1133         }
1134         /*disable low irq*/
1135         rk818_set_bits(rk818, 0x4d, (0x1 << 1), (0x1 << 1));
1136
1137         return 0;
1138 }
1139 #else
1140 static int rk818_suspend(struct i2c_client *i2c, pm_message_t mesg)
1141 {
1142         return 0;
1143 }
1144
1145 static int rk818_resume(struct i2c_client *i2c)
1146 {
1147         return 0;
1148 }
1149 #endif
1150
1151 static int rk818_pre_init(struct rk818 *rk818)
1152 {
1153         int ret,val;
1154         printk("%s,line=%d\n", __func__,__LINE__);
1155
1156         ret = rk818_set_bits(rk818, 0xa1, (0xF<<0),(0x7));
1157         ret = rk818_set_bits(rk818, 0xa1,(0x7<<4),(0x7<<4)); //close charger when usb low then 3.4V
1158         ret = rk818_set_bits(rk818, 0x52,(0x1<<1),(0x1<<1)); //no action when vref
1159         ret = rk818_set_bits(rk818, 0x52,(0x1<<0),(0x1<<0)); //enable HDMI 5V
1160
1161         /*******enable switch and boost***********/
1162         val = rk818_reg_read(rk818,RK818_DCDC_EN_REG);
1163         val |= (0x3 << 5);    //enable switch1/2
1164         val |= (0x1 << 4);    //enable boost
1165         ret = rk818_reg_write(rk818,RK818_DCDC_EN_REG,val);
1166         if (ret <0) {
1167                 printk(KERN_ERR "Unable to write RK818_DCDC_EN_REG reg\n");
1168                 return ret;
1169         }
1170         /****************************************/
1171         /****************set vbat low **********/
1172         val = rk818_reg_read(rk818,RK818_VB_MON_REG);
1173         val &=(~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1174         val |= (RK818_VBAT_LOW_3V0 | EN_VABT_LOW_SHUT_DOWN);
1175         ret = rk818_reg_write(rk818,RK818_VB_MON_REG,val);
1176         if (ret <0) {
1177                 printk(KERN_ERR "Unable to write RK818_VB_MON_REG reg\n");
1178                 return ret;
1179         }
1180         /**************************************/
1181
1182         /**********mask int****************/
1183
1184         val = rk818_reg_read(rk818,RK818_INT_STS_MSK_REG1);
1185         val |= (0x1<<0); //mask vout_lo_int
1186         ret = rk818_reg_write(rk818,RK818_INT_STS_MSK_REG1,val);
1187         if (ret <0) {
1188                 printk(KERN_ERR "Unable to write RK818_INT_STS_MSK_REG1 reg\n");
1189                 return ret;
1190         }
1191
1192         /**********************************/
1193         /**********enable clkout2****************/
1194         ret = rk818_reg_write(rk818,RK818_CLK32OUT_REG,0x01);
1195         if (ret <0) {
1196                 printk(KERN_ERR "Unable to write RK818_CLK32OUT_REG reg\n");
1197                 return ret;
1198         }
1199         /**********************************/
1200         ret = rk818_clear_bits(rk818, RK818_INT_STS_MSK_REG1,(0x3<<5)); //open rtc int when power on
1201         ret = rk818_set_bits(rk818, RK818_RTC_INT_REG,(0x1<<3),(0x1<<3)); //open rtc int when power on
1202
1203         /*****disable otg when in sleep mode****/
1204         val = rk818_reg_read(rk818, RK818_SLEEP_SET_OFF_REG1);
1205         val |= (0x1 << 7);
1206         ret =  rk818_reg_write(rk818, RK818_SLEEP_SET_OFF_REG1, val);
1207         if (ret < 0) {
1208                 pr_err("Unable to write RK818_SLEEP_SET_OFF_REG1 reg\n");
1209                 return ret;
1210         }
1211
1212         /*************** improve efficiency **********************/
1213         ret =  rk818_reg_write(rk818, RK818_BUCK2_CONFIG_REG, 0x1c);
1214         if (ret < 0) {
1215                 pr_err("Unable to write RK818_BUCK2_CONFIG_REG reg\n");
1216                 return ret;
1217         }
1218
1219         ret =  rk818_reg_write(rk818, RK818_BUCK4_CONFIG_REG, 0x04);
1220         if (ret < 0) {
1221                 pr_err("Unable to write RK818_BUCK4_CONFIG_REG reg\n");
1222                 return ret;
1223         }
1224
1225         return 0;
1226 }
1227
1228 static int  rk818_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
1229 {
1230         struct rk818 *rk818;
1231         struct rk818_board *pdev;
1232         const struct of_device_id *match;
1233         struct regulator_config config = { };
1234         struct regulator_dev *rk818_rdev;
1235         struct regulator_init_data *reg_data;
1236         const char *rail_name = NULL;
1237         int ret, i = 0;
1238
1239         printk("%s,line=%d\n", __func__,__LINE__);
1240
1241         if (i2c->dev.of_node) {
1242                 match = of_match_device(rk818_of_match, &i2c->dev);
1243                 if (!match) {
1244                         dev_err(&i2c->dev,"Failed to find matching dt id\n");
1245                         return -EINVAL;
1246                 }
1247         }
1248
1249         rk818 = devm_kzalloc(&i2c->dev,sizeof(struct rk818), GFP_KERNEL);
1250         if (rk818 == NULL) {
1251                 ret = -ENOMEM;
1252                 goto err;
1253         }
1254         rk818->i2c = i2c;
1255         rk818->dev = &i2c->dev;
1256         i2c_set_clientdata(i2c, rk818);
1257
1258         mutex_init(&rk818->io_lock);
1259
1260         ret = rk818_reg_read(rk818,0x2f);
1261         if ((ret < 0) || (ret == 0xff)){
1262                 printk("The device is not rk818 %d\n",ret);
1263                 goto err;
1264         }
1265
1266         ret = rk818_pre_init(rk818);
1267         if (ret < 0){
1268                 printk("The rk818_pre_init failed %d\n",ret);
1269                 goto err;
1270         }
1271
1272         if (rk818->dev->of_node)
1273                 pdev = rk818_parse_dt(rk818);
1274
1275         /******************************set sleep vol & dcdc mode******************/
1276         #ifdef CONFIG_OF
1277         rk818->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
1278         if (rk818->pmic_sleep_gpio) {
1279                         ret = gpio_request(rk818->pmic_sleep_gpio, "rk818_pmic_sleep");
1280                         if (ret < 0) {
1281                                 dev_err(rk818->dev,"Failed to request gpio %d with ret:""%d\n", rk818->pmic_sleep_gpio, ret);
1282                                 return IRQ_NONE;
1283                         }
1284                         gpio_direction_output(rk818->pmic_sleep_gpio,0);
1285                         ret = gpio_get_value(rk818->pmic_sleep_gpio);
1286                         gpio_free(rk818->pmic_sleep_gpio);
1287                         pr_info("%s: rk818_pmic_sleep=%x\n", __func__, ret);
1288         }
1289         #endif
1290         /**********************************************************/
1291
1292         if (pdev) {
1293                 rk818->num_regulators = rk818_NUM_REGULATORS;
1294                 rk818->rdev = kcalloc(rk818_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
1295                 if (!rk818->rdev) {
1296                         return -ENOMEM;
1297                 }
1298                 /* Instantiate the regulators */
1299                 for (i = 0; i < rk818_NUM_REGULATORS; i++) {
1300                 reg_data = pdev->rk818_init_data[i];
1301                 if (!reg_data)
1302                         continue;
1303                 config.dev = rk818->dev;
1304                 config.driver_data = rk818;
1305                 if (rk818->dev->of_node)
1306                         config.of_node = pdev->of_node[i];
1307                 if (reg_data && reg_data->constraints.name)
1308                                 rail_name = reg_data->constraints.name;
1309                         else
1310                                 rail_name = regulators[i].name;
1311                         reg_data->supply_regulator = rail_name;
1312
1313                 config.init_data =reg_data;
1314
1315                 rk818_rdev = regulator_register(&regulators[i],&config);
1316                 if (IS_ERR(rk818_rdev)) {
1317                         printk("failed to register %d regulator\n",i);
1318                 goto err;
1319                 }
1320                 rk818->rdev[i] = rk818_rdev;
1321                 }
1322         }
1323
1324         rk818->irq_gpio = pdev->irq_gpio;
1325         ret = rk818_irq_init(rk818, rk818->irq_gpio, pdev);
1326         if (ret < 0)
1327                 goto err;
1328
1329         ret = mfd_add_devices(rk818->dev, -1,
1330                               rk818s, ARRAY_SIZE(rk818s),
1331                               NULL, 0,NULL);
1332         #if 0
1333         /********************vbat low int**************/
1334         vlow_irq = irq_create_mapping(rk818->irq_domain, RK818_IRQ_VB_LO);
1335          ret = devm_request_threaded_irq(&i2c->dev,vlow_irq, NULL, rk818_vbat_lo_irq,
1336                                    IRQF_ONESHOT, "rk818_vbatlow",
1337                                    rk818);
1338         if (ret != 0) {
1339                 dev_err(rk818->dev, "Failed to request periodic IRQ %d: %d\n",
1340                         vlow_irq+ RK818_IRQ_VB_LO, ret);
1341
1342         }
1343         #endif
1344         /*********************************************/
1345
1346         g_rk818 = rk818;
1347         if (pdev->pm_off && !pm_power_off) {
1348                 pm_power_off = rk818_device_shutdown;
1349         }
1350
1351         #if 1
1352         rk818_kobj = kobject_create_and_add("rk818", NULL);
1353         if (!rk818_kobj)
1354                 return -ENOMEM;
1355         for (i = 0; i < ARRAY_SIZE(rk818_attrs); i++) {
1356                 ret = sysfs_create_file(rk818_kobj, &rk818_attrs[i].attr);
1357                 if (ret != 0) {
1358                         printk("create index %d error\n", i);
1359                         return ret;
1360                 }
1361         }
1362         #endif
1363
1364         register_syscore_ops(&rk818_syscore_ops);
1365
1366         return 0;
1367
1368 err:
1369         mfd_remove_devices(rk818->dev);
1370         return ret;
1371
1372 }
1373
1374 static int  rk818_i2c_remove(struct i2c_client *i2c)
1375 {
1376         struct rk818 *rk818 = i2c_get_clientdata(i2c);
1377         int i;
1378
1379         unregister_syscore_ops(&rk818_syscore_ops);
1380         for (i = 0; i < rk818->num_regulators; i++)
1381                 if (rk818->rdev[i])
1382                         regulator_unregister(rk818->rdev[i]);
1383         i2c_set_clientdata(i2c, NULL);
1384
1385         return 0;
1386 }
1387
1388 static const struct i2c_device_id rk818_i2c_id[] = {
1389        { "rk818", 0 },
1390        { }
1391 };
1392
1393 MODULE_DEVICE_TABLE(i2c, rk818_i2c_id);
1394
1395 static struct i2c_driver rk818_i2c_driver = {
1396         .driver = {
1397                 .name = "rk818",
1398                 .owner = THIS_MODULE,
1399                 .of_match_table =of_match_ptr(rk818_of_match),
1400         },
1401         .probe    = rk818_i2c_probe,
1402         .remove   = rk818_i2c_remove,
1403         .id_table = rk818_i2c_id,
1404         #ifdef CONFIG_PM
1405         .suspend        = rk818_suspend,
1406         .resume         = rk818_resume,
1407         #endif
1408 };
1409
1410 static int __init rk818_module_init(void)
1411 {
1412         int ret;
1413         ret = i2c_add_driver(&rk818_i2c_driver);
1414         if (ret != 0)
1415                 pr_err("Failed to register I2C driver: %d\n", ret);
1416         return ret;
1417 }
1418
1419 subsys_initcall_sync(rk818_module_init);
1420
1421 static void __exit rk818_module_exit(void)
1422 {
1423         i2c_del_driver(&rk818_i2c_driver);
1424 }
1425 module_exit(rk818_module_exit);
1426
1427 MODULE_LICENSE("GPL");
1428 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1429 MODULE_DESCRIPTION("rk818 PMIC driver");
1430