drivers/mfd/rk808.c

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