drivers/regulator/act8846.c

   1 /*
   2  * Regulator driver for Active-semi act8846 PMIC chip for rk29xx
   3  *
   4  * Copyright (C) 2010, 2011 ROCKCHIP, Inc.
   5
   6  * Based on act8846.c that is work by zhangqing<zhangqing@rock-chips.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  */
  13
  14 #include <linux/bug.h>
  15 #include <linux/err.h>
  16 #include <linux/i2c.h>
  17 #include <linux/kernel.h>
  18 #include <linux/regulator/driver.h>
  19 #include <linux/regulator/act8846.h>
  20 #include <linux/delay.h>
  21 #include <linux/slab.h>
  22 #include <linux/mutex.h>
  23 #ifdef CONFIG_HAS_EARLYSUSPEND
  24 #include <linux/earlysuspend.h>
  25 #endif
  26 #include <linux/interrupt.h>
  27 #include <linux/module.h>
  28 #include <linux/of_irq.h>
  29 #include <linux/of_gpio.h>
  30 #include <linux/of.h>
  31 #include <linux/of_device.h>
  32 #include <linux/regulator/of_regulator.h>
  33 #include <linux/regulator/driver.h>
  34 #include <linux/regulator/machine.h>
  35 #include <linux/regmap.h>
  36
  37 #if 0
  38 #define DBG(x...)       printk(KERN_INFO x)
  39 #else
  40 #define DBG(x...)
  41 #endif
  42 #if 1
  43 #define DBG_INFO(x...)  printk(KERN_INFO x)
  44 #else
  45 #define DBG_INFO(x...)
  46 #endif
  47 #define PM_CONTROL
  48
  49 struct act8846 {
  50         struct device *dev;
  51         struct mutex io_lock;
  52         struct i2c_client *i2c;
  53         int num_regulators;
  54         struct regulator_dev **rdev;
  55 //      struct early_suspend act8846_suspend;
  56         int irq_base;
  57         int chip_irq;
  58         int pmic_sleep_gpio; /* */
  59         unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
  60         bool pmic_sleep;
  61         struct regmap *regmap;
  62 };
  63
  64 struct act8846_regulator {
  65         struct device           *dev;
  66         struct regulator_desc   *desc;
  67         struct regulator_dev    *rdev;
  68 };
  69
  70
  71 struct act8846 *g_act8846;
  72
  73 static u8 act8846_reg_read(struct act8846 *act8846, u8 reg);
  74 static int act8846_set_bits(struct act8846 *act8846, u8 reg, u16 mask, u16 val);
  75
  76
  77 #define act8846_BUCK1_SET_VOL_BASE 0x10
  78 #define act8846_BUCK2_SET_VOL_BASE 0x20
  79 #define act8846_BUCK3_SET_VOL_BASE 0x30
  80 #define act8846_BUCK4_SET_VOL_BASE 0x40
  81
  82 #define act8846_BUCK2_SLP_VOL_BASE 0x21
  83 #define act8846_BUCK3_SLP_VOL_BASE 0x31
  84 #define act8846_BUCK4_SLP_VOL_BASE 0x41
  85
  86 #define act8846_LDO1_SET_VOL_BASE 0x50
  87 #define act8846_LDO2_SET_VOL_BASE 0x58
  88 #define act8846_LDO3_SET_VOL_BASE 0x60
  89 #define act8846_LDO4_SET_VOL_BASE 0x68
  90 #define act8846_LDO5_SET_VOL_BASE 0x70
  91 #define act8846_LDO6_SET_VOL_BASE 0x80
  92 #define act8846_LDO7_SET_VOL_BASE 0x90
  93 #define act8846_LDO8_SET_VOL_BASE 0xa0
  94 //#define act8846_LDO9_SET_VOL_BASE 0xb1
  95
  96 #define act8846_BUCK1_CONTR_BASE 0x12
  97 #define act8846_BUCK2_CONTR_BASE 0x22
  98 #define act8846_BUCK3_CONTR_BASE 0x32
  99 #define act8846_BUCK4_CONTR_BASE 0x42
 100
 101 #define act8846_LDO1_CONTR_BASE 0x51
 102 #define act8846_LDO2_CONTR_BASE 0x59
 103 #define act8846_LDO3_CONTR_BASE 0x61
 104 #define act8846_LDO4_CONTR_BASE 0x69
 105 #define act8846_LDO5_CONTR_BASE 0x71
 106 #define act8846_LDO6_CONTR_BASE 0x81
 107 #define act8846_LDO7_CONTR_BASE 0x91
 108 #define act8846_LDO8_CONTR_BASE 0xa1
 109 //#define act8846_LDO9_CONTR_BASE 0xb1
 110
 111 #define BUCK_VOL_MASK 0x3f
 112 #define LDO_VOL_MASK 0x3f
 113
 114 #define VOL_MIN_IDX 0x00
 115 #define VOL_MAX_IDX 0x3f
 116
 117 const static int buck_set_vol_base_addr[] = {
 118         act8846_BUCK1_SET_VOL_BASE,
 119         act8846_BUCK2_SET_VOL_BASE,
 120         act8846_BUCK3_SET_VOL_BASE,
 121         act8846_BUCK4_SET_VOL_BASE,
 122 };
 123 const static int buck_contr_base_addr[] = {
 124         act8846_BUCK1_CONTR_BASE,
 125         act8846_BUCK2_CONTR_BASE,
 126         act8846_BUCK3_CONTR_BASE,
 127         act8846_BUCK4_CONTR_BASE,
 128 };
 129 #define act8846_BUCK_SET_VOL_REG(x) (buck_set_vol_base_addr[x])
 130 #define act8846_BUCK_CONTR_REG(x) (buck_contr_base_addr[x])
 131
 132
 133 const static int ldo_set_vol_base_addr[] = {
 134         act8846_LDO1_SET_VOL_BASE,
 135         act8846_LDO2_SET_VOL_BASE,
 136         act8846_LDO3_SET_VOL_BASE,
 137         act8846_LDO4_SET_VOL_BASE,
 138         act8846_LDO5_SET_VOL_BASE,
 139         act8846_LDO6_SET_VOL_BASE,
 140         act8846_LDO7_SET_VOL_BASE,
 141         act8846_LDO8_SET_VOL_BASE,
 142 //      act8846_LDO9_SET_VOL_BASE,
 143 };
 144 const static int ldo_contr_base_addr[] = {
 145         act8846_LDO1_CONTR_BASE,
 146         act8846_LDO2_CONTR_BASE,
 147         act8846_LDO3_CONTR_BASE,
 148         act8846_LDO4_CONTR_BASE,
 149         act8846_LDO5_CONTR_BASE,
 150         act8846_LDO6_CONTR_BASE,
 151         act8846_LDO7_CONTR_BASE,
 152         act8846_LDO8_CONTR_BASE,
 153 //      act8846_LDO9_CONTR_BASE,
 154 };
 155 #define act8846_LDO_SET_VOL_REG(x) (ldo_set_vol_base_addr[x])
 156 #define act8846_LDO_CONTR_REG(x) (ldo_contr_base_addr[x])
 157
 158 const static int buck_voltage_map[] = {
 159          600, 625, 650, 675, 700, 725, 750, 775,
 160          800, 825, 850, 875, 900, 925, 950, 975,
 161          1000, 1025, 1050, 1075, 1100, 1125, 1150,
 162          1175, 1200, 1250, 1300, 1350, 1400, 1450,
 163          1500, 1550, 1600, 1650, 1700, 1750, 1800,
 164          1850, 1900, 1950, 2000, 2050, 2100, 2150,
 165          2200, 2250, 2300, 2350, 2400, 2500, 2600,
 166          2700, 2800, 2900, 3000, 3100, 3200,
 167          3300, 3400, 3500, 3600, 3700, 3800, 3900,
 168 };
 169
 170 const static int ldo_voltage_map[] = {
 171          600, 625, 650, 675, 700, 725, 750, 775,
 172          800, 825, 850, 875, 900, 925, 950, 975,
 173          1000, 1025, 1050, 1075, 1100, 1125, 1150,
 174          1175, 1200, 1250, 1300, 1350, 1400, 1450,
 175          1500, 1550, 1600, 1650, 1700, 1750, 1800,
 176          1850, 1900, 1950, 2000, 2050, 2100, 2150,
 177          2200, 2250, 2300, 2350, 2400, 2500, 2600,
 178          2700, 2800, 2900, 3000, 3100, 3200,
 179          3300, 3400, 3500, 3600, 3700, 3800, 3900,
 180 };
 181
 182 static int act8846_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
 183 {
 184         if (index >= ARRAY_SIZE(ldo_voltage_map))
 185                 return -EINVAL;
 186         return 1000 * ldo_voltage_map[index];
 187 }
 188 static int act8846_ldo_is_enabled(struct regulator_dev *dev)
 189 {
 190         struct act8846 *act8846 = rdev_get_drvdata(dev);
 191         int ldo = rdev_get_id(dev) - ACT8846_LDO1;
 192         u16 val;
 193         u16 mask=0x80;
 194         val = act8846_reg_read(act8846, act8846_LDO_CONTR_REG(ldo));
 195         if (val < 0)
 196                 return val;
 197         val=val&~0x7f;
 198         if (val & mask)
 199                 return 1;
 200         else
 201                 return 0;
 202 }
 203 static int act8846_ldo_enable(struct regulator_dev *dev)
 204 {
 205         struct act8846 *act8846 = rdev_get_drvdata(dev);
 206         int ldo= rdev_get_id(dev) - ACT8846_LDO1;
 207         u16 mask=0x80;
 208
 209         return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0x80);
 210
 211 }
 212 static int act8846_ldo_disable(struct regulator_dev *dev)
 213 {
 214         struct act8846 *act8846 = rdev_get_drvdata(dev);
 215         int ldo= rdev_get_id(dev) - ACT8846_LDO1;
 216         u16 mask=0x80;
 217
 218         return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0);
 219
 220 }
 221 static int act8846_ldo_get_voltage(struct regulator_dev *dev)
 222 {
 223         struct act8846 *act8846 = rdev_get_drvdata(dev);
 224         int ldo= rdev_get_id(dev) - ACT8846_LDO1;
 225         u16 reg = 0;
 226         int val;
 227         reg = act8846_reg_read(act8846,act8846_LDO_SET_VOL_REG(ldo));
 228         reg &= LDO_VOL_MASK;
 229         val = 1000 * ldo_voltage_map[reg];
 230         return val;
 231 }
 232 static int act8846_ldo_set_voltage(struct regulator_dev *dev,
 233                                   int min_uV, int max_uV,unsigned *selector)
 234 {
 235         struct act8846 *act8846 = rdev_get_drvdata(dev);
 236         int ldo= rdev_get_id(dev) - ACT8846_LDO1;
 237         int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
 238         const int *vol_map =ldo_voltage_map;
 239         u16 val;
 240         int ret = 0;
 241
 242         if (min_vol < vol_map[VOL_MIN_IDX] ||
 243             min_vol > vol_map[VOL_MAX_IDX])
 244                 return -EINVAL;
 245
 246         for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
 247                 if (vol_map[val] >= min_vol)
 248                         break;
 249         }
 250
 251         if (vol_map[val] > max_vol)
 252                 return -EINVAL;
 253
 254         ret = act8846_set_bits(act8846, act8846_LDO_SET_VOL_REG(ldo),
 255                 LDO_VOL_MASK, val);
 256         return ret;
 257
 258 }
 259 static unsigned int act8846_ldo_get_mode(struct regulator_dev *dev)
 260 {
 261         struct act8846 *act8846 = rdev_get_drvdata(dev);
 262         int ldo = rdev_get_id(dev) - ACT8846_LDO1;
 263         u16 mask = 0x80;
 264         u16 val;
 265         val = act8846_reg_read(act8846, act8846_LDO_CONTR_REG(ldo));
 266         if (val < 0) {
 267                 return val;
 268         }
 269         val=val & mask;
 270         if (val== mask)
 271                 return REGULATOR_MODE_NORMAL;
 272         else
 273                 return REGULATOR_MODE_STANDBY;
 274
 275 }
 276 static int act8846_ldo_set_mode(struct regulator_dev *dev, unsigned int mode)
 277 {
 278         struct act8846 *act8846 = rdev_get_drvdata(dev);
 279         int ldo = rdev_get_id(dev) - ACT8846_LDO1;
 280         u16 mask = 0x80;
 281         switch(mode)
 282         {
 283         case REGULATOR_MODE_NORMAL:
 284                 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, mask);
 285         case REGULATOR_MODE_STANDBY:
 286                 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0);
 287         default:
 288                 printk("error:pmu_act8846 only lowpower and nomal mode\n");
 289                 return -EINVAL;
 290         }
 291
 292
 293 }
 294 static struct regulator_ops act8846_ldo_ops = {
 295         .set_voltage = act8846_ldo_set_voltage,
 296         .get_voltage = act8846_ldo_get_voltage,
 297         .list_voltage = act8846_ldo_list_voltage,
 298         .is_enabled = act8846_ldo_is_enabled,
 299         .enable = act8846_ldo_enable,
 300         .disable = act8846_ldo_disable,
 301         .get_mode = act8846_ldo_get_mode,
 302         .set_mode = act8846_ldo_set_mode,
 303
 304 };
 305
 306 static int act8846_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
 307 {
 308         if (index >= ARRAY_SIZE(buck_voltage_map))
 309                 return -EINVAL;
 310         return 1000 * buck_voltage_map[index];
 311 }
 312 static int act8846_dcdc_is_enabled(struct regulator_dev *dev)
 313 {
 314         struct act8846 *act8846 = rdev_get_drvdata(dev);
 315         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 316         u16 val;
 317         u16 mask=0x80;
 318         val = act8846_reg_read(act8846, act8846_BUCK_CONTR_REG(buck));
 319         if (val < 0)
 320                 return val;
 321          val=val&~0x7f;
 322         if (val & mask)
 323                 return 1;
 324         else
 325                 return 0;
 326 }
 327 static int act8846_dcdc_enable(struct regulator_dev *dev)
 328 {
 329         struct act8846 *act8846 = rdev_get_drvdata(dev);
 330         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 331         u16 mask=0x80;
 332
 333         return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0x80);
 334
 335 }
 336 static int act8846_dcdc_disable(struct regulator_dev *dev)
 337 {
 338         struct act8846 *act8846 = rdev_get_drvdata(dev);
 339         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 340         u16 mask=0x80;
 341          return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
 342 }
 343 static int act8846_dcdc_get_voltage(struct regulator_dev *dev)
 344 {
 345         struct act8846 *act8846 = rdev_get_drvdata(dev);
 346         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 347         u16 reg = 0;
 348         int val;
 349         #ifdef CONFIG_ACT8846_SUPPORT_RESET
 350         reg = act8846_reg_read(act8846,(act8846_BUCK_SET_VOL_REG(buck)+0x1));
 351         #else
 352         reg = act8846_reg_read(act8846,act8846_BUCK_SET_VOL_REG(buck));
 353         #endif
 354         reg &= BUCK_VOL_MASK;
 355         val = 1000 * buck_voltage_map[reg];
 356         return val;
 357 }
 358 static int act8846_dcdc_set_voltage(struct regulator_dev *dev,
 359                                   int min_uV, int max_uV,unsigned *selector)
 360 {
 361         struct act8846 *act8846 = rdev_get_drvdata(dev);
 362         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 363         int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
 364         const int *vol_map = buck_voltage_map;
 365         u16 val;
 366         int ret = 0;
 367
 368         if (min_vol < vol_map[VOL_MIN_IDX] ||
 369             min_vol > vol_map[VOL_MAX_IDX])
 370                 return -EINVAL;
 371
 372         for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
 373                 if (vol_map[val] >= min_vol)
 374                         break;
 375         }
 376
 377         if (vol_map[val] > max_vol)
 378                 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
 379
 380         #ifdef CONFIG_ACT8846_SUPPORT_RESET
 381         ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) +0x1),BUCK_VOL_MASK, val);
 382         #else
 383         ret = act8846_set_bits(act8846, act8846_BUCK_SET_VOL_REG(buck) ,BUCK_VOL_MASK, val);
 384         #endif
 385
 386         return ret;
 387 }
 388 static int act8846_dcdc_set_sleep_voltage(struct regulator_dev *dev,
 389                                             int uV)
 390 {
 391         struct act8846 *act8846 = rdev_get_drvdata(dev);
 392         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 393         int min_vol = uV / 1000,max_vol = uV / 1000;
 394         const int *vol_map = buck_voltage_map;
 395         u16 val;
 396         int ret = 0;
 397
 398         if (min_vol < vol_map[VOL_MIN_IDX] ||
 399             min_vol > vol_map[VOL_MAX_IDX])
 400                 return -EINVAL;
 401
 402         for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
 403                 if (vol_map[val] >= min_vol)
 404                         break;
 405         }
 406
 407         if (vol_map[val] > max_vol)
 408                 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
 409         #ifdef CONFIG_ACT8846_SUPPORT_RESET
 410          ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) ),BUCK_VOL_MASK, val);
 411         #else
 412         ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) +0x01),BUCK_VOL_MASK, val);
 413         #endif
 414
 415         return ret;
 416 }
 417 static unsigned int act8846_dcdc_get_mode(struct regulator_dev *dev)
 418 {
 419         struct act8846 *act8846 = rdev_get_drvdata(dev);
 420         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 421         u16 mask = 0x08;
 422         u16 val;
 423         val = act8846_reg_read(act8846, act8846_BUCK_CONTR_REG(buck));
 424         if (val < 0) {
 425                 return val;
 426         }
 427         val=val & mask;
 428         if (val== mask)
 429                 return REGULATOR_MODE_NORMAL;
 430         else
 431                 return REGULATOR_MODE_STANDBY;
 432
 433 }
 434 static int act8846_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
 435 {
 436         struct act8846 *act8846 = rdev_get_drvdata(dev);
 437         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 438         u16 mask = 0x80;
 439
 440         switch(mode)
 441         {
 442         case REGULATOR_MODE_STANDBY:
 443                 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
 444         case REGULATOR_MODE_NORMAL:
 445                 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, mask);
 446         default:
 447                 printk("error:pmu_act8846 only powersave and pwm mode\n");
 448                 return -EINVAL;
 449         }
 450
 451
 452 }
 453 static int act8846_dcdc_set_voltage_time_sel(struct regulator_dev *dev,   unsigned int old_selector,
 454                                      unsigned int new_selector)
 455 {
 456         struct act8846 *act8846 = rdev_get_drvdata(dev);
 457         int ret =0,old_volt, new_volt;
 458
 459         old_volt = act8846_dcdc_list_voltage(dev, old_selector);
 460         if (old_volt < 0)
 461                 return old_volt;
 462
 463         new_volt = act8846_dcdc_list_voltage(dev, new_selector);
 464         if (new_volt < 0)
 465                 return new_volt;
 466
 467         return DIV_ROUND_UP(abs(old_volt - new_volt)*2, 25000);
 468 }
 469
 470 static struct regulator_ops act8846_dcdc_ops = {
 471         .set_voltage = act8846_dcdc_set_voltage,
 472         .get_voltage = act8846_dcdc_get_voltage,
 473         .list_voltage= act8846_dcdc_list_voltage,
 474         .is_enabled = act8846_dcdc_is_enabled,
 475         .enable = act8846_dcdc_enable,
 476         .disable = act8846_dcdc_disable,
 477         .get_mode = act8846_dcdc_get_mode,
 478         .set_mode = act8846_dcdc_set_mode,
 479         .set_suspend_voltage = act8846_dcdc_set_sleep_voltage,
 480         .set_voltage_time_sel = act8846_dcdc_set_voltage_time_sel,
 481 };
 482 static struct regulator_desc regulators[] = {
 483
 484         {
 485                 .name = "ACT_DCDC1",
 486                 .id = 0,
 487                 .ops = &act8846_dcdc_ops,
 488                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 489                 .type = REGULATOR_VOLTAGE,
 490                 .owner = THIS_MODULE,
 491         },
 492         {
 493                 .name = "ACT_DCDC2",
 494                 .id = 1,
 495                 .ops = &act8846_dcdc_ops,
 496                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 497                 .type = REGULATOR_VOLTAGE,
 498                 .owner = THIS_MODULE,
 499         },
 500         {
 501                 .name = "ACT_DCDC3",
 502                 .id = 2,
 503                 .ops = &act8846_dcdc_ops,
 504                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 505                 .type = REGULATOR_VOLTAGE,
 506                 .owner = THIS_MODULE,
 507         },
 508         {
 509                 .name = "ACT_DCDC4",
 510                 .id = 3,
 511                 .ops = &act8846_dcdc_ops,
 512                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 513                 .type = REGULATOR_VOLTAGE,
 514                 .owner = THIS_MODULE,
 515         },
 516
 517         {
 518                 .name = "ACT_LDO1",
 519                 .id =4,
 520                 .ops = &act8846_ldo_ops,
 521                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 522                 .type = REGULATOR_VOLTAGE,
 523                 .owner = THIS_MODULE,
 524         },
 525         {
 526                 .name = "ACT_LDO2",
 527                 .id = 5,
 528                 .ops = &act8846_ldo_ops,
 529                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 530                 .type = REGULATOR_VOLTAGE,
 531                 .owner = THIS_MODULE,
 532         },
 533         {
 534                 .name = "ACT_LDO3",
 535                 .id = 6,
 536                 .ops = &act8846_ldo_ops,
 537                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 538                 .type = REGULATOR_VOLTAGE,
 539                 .owner = THIS_MODULE,
 540         },
 541         {
 542                 .name = "ACT_LDO4",
 543                 .id = 7,
 544                 .ops = &act8846_ldo_ops,
 545                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 546                 .type = REGULATOR_VOLTAGE,
 547                 .owner = THIS_MODULE,
 548         },
 549
 550         {
 551                 .name = "ACT_LDO5",
 552                 .id =8,
 553                 .ops = &act8846_ldo_ops,
 554                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 555                 .type = REGULATOR_VOLTAGE,
 556                 .owner = THIS_MODULE,
 557         },
 558         {
 559                 .name = "ACT_LDO6",
 560                 .id = 9,
 561                 .ops = &act8846_ldo_ops,
 562                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 563                 .type = REGULATOR_VOLTAGE,
 564                 .owner = THIS_MODULE,
 565         },
 566         {
 567                 .name = "ACT_LDO7",
 568                 .id = 10,
 569                 .ops = &act8846_ldo_ops,
 570                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 571                 .type = REGULATOR_VOLTAGE,
 572                 .owner = THIS_MODULE,
 573         },
 574         {
 575                 .name = "ACT_LDO8",
 576                 .id = 11,
 577                 .ops = &act8846_ldo_ops,
 578                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 579                 .type = REGULATOR_VOLTAGE,
 580                 .owner = THIS_MODULE,
 581         },
 582         {
 583                 .name = "ACT_LDO9",
 584                 .id = 12,
 585                 .ops = &act8846_ldo_ops,
 586                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 587                 .type = REGULATOR_VOLTAGE,
 588                 .owner = THIS_MODULE,
 589         },
 590 };
 591
 592 /*
 593  *
 594  */
 595 static int act8846_i2c_read(struct i2c_client *i2c, char reg, int count,        u16 *dest)
 596 {
 597       int ret;
 598     struct i2c_adapter *adap;
 599     struct i2c_msg msgs[2];
 600
 601     if(!i2c)
 602                 return ret;
 603
 604         if (count != 1)
 605                 return -EIO;
 606
 607     adap = i2c->adapter;
 608
 609     msgs[0].addr = i2c->addr;
 610     msgs[0].buf = &reg;
 611     msgs[0].flags = i2c->flags;
 612     msgs[0].len = 1;
 613     msgs[0].scl_rate = 200*1000;
 614
 615     msgs[1].buf = (u8 *)dest;
 616     msgs[1].addr = i2c->addr;
 617     msgs[1].flags = i2c->flags | I2C_M_RD;
 618     msgs[1].len = 1;
 619     msgs[1].scl_rate = 200*1000;
 620     ret = i2c_transfer(adap, msgs, 2);
 621
 622         DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
 623
 624         return 0;
 625 }
 626
 627 static int act8846_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
 628 {
 629         int ret=-1;
 630
 631         struct i2c_adapter *adap;
 632         struct i2c_msg msg;
 633         char tx_buf[2];
 634
 635         if(!i2c)
 636                 return ret;
 637         if (count != 1)
 638                 return -EIO;
 639
 640         adap = i2c->adapter;
 641         tx_buf[0] = reg;
 642         tx_buf[1] = src;
 643
 644         msg.addr = i2c->addr;
 645         msg.buf = &tx_buf[0];
 646         msg.len = 1 +1;
 647         msg.flags = i2c->flags;
 648         msg.scl_rate = 200*1000;
 649
 650         ret = i2c_transfer(adap, &msg, 1);
 651         return ret;
 652 }
 653
 654 static u8 act8846_reg_read(struct act8846 *act8846, u8 reg)
 655 {
 656         u16 val = 0;
 657
 658         mutex_lock(&act8846->io_lock);
 659
 660         act8846_i2c_read(act8846->i2c, reg, 1, &val);
 661
 662         DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 663
 664         mutex_unlock(&act8846->io_lock);
 665
 666         return val & 0xff;
 667 }
 668
 669 static int act8846_set_bits(struct act8846 *act8846, u8 reg, u16 mask, u16 val)
 670 {
 671         u16 tmp;
 672         int ret;
 673
 674         mutex_lock(&act8846->io_lock);
 675
 676         ret = act8846_i2c_read(act8846->i2c, reg, 1, &tmp);
 677         DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
 678         tmp = (tmp & ~mask) | val;
 679         if (ret == 0) {
 680                 ret = act8846_i2c_write(act8846->i2c, reg, 1, tmp);
 681                 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 682         }
 683         act8846_i2c_read(act8846->i2c, reg, 1, &tmp);
 684         DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
 685         mutex_unlock(&act8846->io_lock);
 686
 687         return 0;//ret;
 688 }
 689
 690 #ifdef CONFIG_OF
 691 static struct of_device_id act8846_of_match[] = {
 692         { .compatible = "act,act8846"},
 693         { },
 694 };
 695 MODULE_DEVICE_TABLE(of, act8846_of_match);
 696 #endif
 697 #ifdef CONFIG_OF
 698 static struct of_regulator_match act8846_reg_matches[] = {
 699         { .name = "act_dcdc1" ,.driver_data = (void *)0},
 700         { .name = "act_dcdc2" ,.driver_data = (void *)1},
 701         { .name = "act_dcdc3", .driver_data = (void *)2 },
 702         { .name = "act_dcdc4", .driver_data = (void *)3 },
 703         { .name = "act_ldo1", .driver_data = (void *)4 },
 704         { .name = "act_ldo2", .driver_data = (void *)5 },
 705         { .name = "act_ldo3", .driver_data = (void *)6 },
 706         { .name = "act_ldo4", .driver_data = (void *)7 },
 707         { .name = "act_ldo5", .driver_data = (void *)8 },
 708         { .name = "act_ldo6", .driver_data = (void *)9 },
 709         { .name = "act_ldo7", .driver_data = (void *)10 },
 710         { .name = "act_ldo8", .driver_data = (void *)11 },
 711 };
 712
 713 static struct act8846_board *act8846_parse_dt(struct act8846 *act8846)
 714 {
 715 //      struct act8846 *act8846 = i2c->dev.parent;
 716         struct act8846_board *pdata;
 717         struct device_node *regs;
 718         struct device_node *act8846_pmic_np;
 719         int i, count,sleep_voltage_nr =1;
 720         int gpio;
 721         printk("%s,line=%d\n", __func__,__LINE__);
 722
 723         act8846_pmic_np = of_node_get(act8846->dev->of_node);
 724         if (!act8846_pmic_np) {
 725                 printk("could not find pmic sub-node\n");
 726                 return NULL;
 727         }
 728
 729         regs = of_find_node_by_name(act8846_pmic_np, "regulators");
 730         if (!regs)
 731                 return NULL;
 732
 733         count = of_regulator_match(act8846->dev, regs, act8846_reg_matches,act8846_NUM_REGULATORS);
 734         of_node_put(regs);
 735
 736         if ((count < 0) || (count > act8846_NUM_REGULATORS))
 737                 return NULL;
 738
 739         pdata = devm_kzalloc(act8846->dev, sizeof(*pdata), GFP_KERNEL);
 740         if (!pdata)
 741                 return NULL;
 742         for (i = 0; i < count; i++) {
 743                 if (!act8846_reg_matches[i].init_data || !act8846_reg_matches[i].of_node)
 744                         continue;
 745                 pdata->act8846_init_data[i] = act8846_reg_matches[i].init_data;
 746                 pdata->of_node[i] = act8846_reg_matches[i].of_node;
 747         }
 748         pdata->irq = act8846->chip_irq;
 749         pdata->irq_base = -1;
 750
 751         if (of_get_property(act8846_pmic_np, "act,pmic-dcdc-sleep-voltage", NULL))
 752                 pdata->pmic_sleep = true;
 753
 754         if (of_get_property(act8846_pmic_np, "act,pmic-ldo-sleep-voltage", NULL))
 755                 pdata->pmic_sleep = true;
 756
 757         gpio = of_get_named_gpio(act8846_pmic_np,"gpios", 0);
 758                 if (!gpio_is_valid(gpio))
 759                         printk("invalid gpio: %d\n",gpio);
 760         pdata->pmic_sleep_gpio = gpio;
 761
 762         if (of_property_read_u32_array(act8846_pmic_np,
 763                                 "act,pmic-dcdc-sleep-voltage",
 764                                 pdata->dcdc_slp_voltage, sleep_voltage_nr)) {
 765                 printk("dcdc sleep voltages not specified\n");
 766         }\r
 767
 768         return pdata;
 769 }
 770 static int act8846_dcdc_sleep_voltage_get_val(int min_uV,int buck)
 771 {
 772         int min_vol = min_uV / 1000, max_vol = min_uV / 1000;
 773         const int *vol_map = buck_voltage_map;
 774         u16 val;
 775
 776         if (min_vol < vol_map[VOL_MIN_IDX] ||
 777             min_vol > vol_map[VOL_MAX_IDX])
 778                 return -EINVAL;
 779
 780         for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
 781                 if (vol_map[val] >= min_vol)
 782                         break;
 783         }
 784
 785         if (vol_map[val] > max_vol)
 786                 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
 787         return val;
 788 }
 789 static int act8846_dts_dcdc_set_mode(unsigned int mode,int buck)
 790 {
 791         struct act8846 *act8846 = g_act8846;
 792         u16 mask = 0x80;
 793         switch(mode)
 794         {
 795         case REGULATOR_MODE_STANDBY:
 796                 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
 797         case REGULATOR_MODE_NORMAL:
 798                 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, mask);
 799         default:
 800                 printk("error:pmu_act8846 only powersave and pwm mode\n");
 801                 return -EINVAL;
 802         }
 803 }
 804 #else
 805 static struct act8846_board *act8846_parse_dt(struct i2c_client *i2c)
 806 {
 807         return NULL;
 808 }
 809 #endif
 810
 811
 812 int act8846_device_shutdown(void)
 813 {
 814         int ret;
 815         int err = -1;
 816         struct act8846 *act8846 = g_act8846;
 817
 818         printk("%s\n",__func__);
 819
 820         ret = act8846_reg_read(act8846,0xc3);
 821         ret = act8846_set_bits(act8846, 0xc3,(0x1<<3),(0x1<<3));
 822         ret = act8846_set_bits(act8846, 0xc3,(0x1<<4),(0x1<<4));
 823         if (ret < 0) {
 824                 printk("act8846 set 0xc3 error!\n");
 825                 return err;
 826         }
 827         return 0;
 828 }
 829 EXPORT_SYMBOL_GPL(act8846_device_shutdown);
 830
 831 __weak void  act8846_device_suspend(void) {}
 832 __weak void  act8846_device_resume(void) {}
 833 #ifdef CONFIG_PM
 834 static int act8846_suspend(struct i2c_client *i2c, pm_message_t mesg)
 835 {
 836         act8846_device_suspend();
 837         return 0;
 838 }
 839
 840 static int act8846_resume(struct i2c_client *i2c)
 841 {
 842         act8846_device_resume();
 843         return 0;
 844 }
 845 #else
 846 static int act8846_suspend(struct i2c_client *i2c, pm_message_t mesg)
 847 {
 848         return 0;
 849 }
 850
 851 static int act8846_resume(struct i2c_client *i2c)
 852 {
 853         return 0;
 854 }
 855 #endif
 856
 857
 858 #ifdef CONFIG_HAS_EARLYSUSPEND
 859 __weak void act8846_early_suspend(struct early_suspend *h) {}
 860 __weak void act8846_late_resume(struct early_suspend *h) {}
 861 #endif
 862
 863 static bool is_volatile_reg(struct device *dev, unsigned int reg)
 864 {
 865
 866         if ((reg >= act8846_BUCK1_SET_VOL_BASE) && (reg <= act8846_LDO8_CONTR_BASE)) {
 867                 return true;
 868         }
 869         return true;
 870 }
 871
 872 static const struct regmap_config act8846_regmap_config = {
 873         .reg_bits = 8,
 874         .val_bits = 8,
 875         .volatile_reg = is_volatile_reg,
 876         .max_register = act8846_NUM_REGULATORS - 1,
 877         .cache_type = REGCACHE_RBTREE,
 878 };
 879 static int act8846_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
 880 {
 881         struct act8846 *act8846;
 882         struct act8846_board *pdev ;
 883         const struct of_device_id *match;
 884         struct regulator_config config = { };
 885         struct regulator_dev *act_rdev;
 886         struct regulator_init_data *reg_data;
 887         const char *rail_name = NULL;
 888         int ret,i=0;
 889
 890         printk("%s,line=%d\n", __func__,__LINE__);
 891
 892         if (i2c->dev.of_node) {
 893                 match = of_match_device(act8846_of_match, &i2c->dev);
 894                 if (!match) {
 895                         printk("Failed to find matching dt id\n");
 896                         return -EINVAL;
 897                 }
 898         }
 899
 900         act8846 = kzalloc(sizeof(struct act8846), GFP_KERNEL);
 901         if (act8846 == NULL) {
 902                 ret = -ENOMEM;
 903                 goto err;
 904         }
 905         act8846->i2c = i2c;
 906         act8846->dev = &i2c->dev;
 907         i2c_set_clientdata(i2c, act8846);
 908         g_act8846 = act8846;
 909
 910         act8846->regmap = devm_regmap_init_i2c(i2c, &act8846_regmap_config);
 911         if (IS_ERR(act8846->regmap)) {
 912                 ret = PTR_ERR(act8846->regmap);
 913                 printk("regmap initialization failed: %d\n", ret);
 914                 return ret;
 915         }
 916
 917         mutex_init(&act8846->io_lock);
 918
 919         ret = act8846_reg_read(act8846,0x22);
 920         if ((ret < 0) || (ret == 0xff)){
 921                 printk("The device is not act8846 %x \n",ret);
 922                 return 0;
 923         }
 924
 925         ret = act8846_set_bits(act8846, 0xf4,(0x1<<7),(0x0<<7));
 926         if (ret < 0) {
 927                 printk("act8846 set 0xf4 error!\n");
 928                 goto err;
 929         }
 930
 931         if (act8846->dev->of_node)
 932                 pdev = act8846_parse_dt(act8846);
 933
 934         /******************************set sleep vol & dcdc mode******************/
 935         #ifdef CONFIG_OF
 936         act8846->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
 937         if (act8846->pmic_sleep_gpio) {
 938                         ret = gpio_request(act8846->pmic_sleep_gpio, "act8846_pmic_sleep");
 939                         if (ret < 0) {
 940                                 dev_err(act8846->dev,"Failed to request gpio %d with ret:""%d\n",       act8846->pmic_sleep_gpio, ret);
 941                                 return IRQ_NONE;
 942                         }
 943                         gpio_direction_input(act8846->pmic_sleep_gpio);
 944                         ret = gpio_get_value(act8846->pmic_sleep_gpio);
 945                         gpio_free(act8846->pmic_sleep_gpio);
 946                         printk("%s: act8846_pmic_sleep=%x\n", __func__, ret);
 947         }
 948         for (i = 0;i <4 ; i ++){
 949         act8846->dcdc_slp_voltage[i] = pdev->dcdc_slp_voltage[i];
 950                 if (act8846->dcdc_slp_voltage[i]){
 951                         if (i ==0)
 952                                 continue;
 953
 954                         #ifdef CONFIG_ACT8846_SUPPORT_RESET
 955                         ret = act8846_set_bits(act8846, act8846_BUCK_SET_VOL_REG(i) ,BUCK_VOL_MASK, act8846_dcdc_sleep_voltage_get_val(act8846->dcdc_slp_voltage[i],i));
 956                         #else
 957                         ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(i) +0x01),BUCK_VOL_MASK, act8846_dcdc_sleep_voltage_get_val(act8846->dcdc_slp_voltage[i],i));
 958                         #endif
 959                 }
 960         }
 961         #endif
 962
 963         if (pdev) {
 964                 act8846->num_regulators = act8846_NUM_REGULATORS;
 965                 act8846->rdev = kcalloc(act8846_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
 966                 if (!act8846->rdev) {
 967                         return -ENOMEM;
 968                 }
 969                 /* Instantiate the regulators */
 970                 for (i = 0; i < act8846_NUM_REGULATORS; i++) {
 971                 reg_data = pdev->act8846_init_data[i];
 972                 if (!reg_data)
 973                         continue;
 974                 config.dev = act8846->dev;
 975                 config.driver_data = act8846;
 976                 config.regmap = act8846->regmap;
 977                 if (act8846->dev->of_node)
 978                         config.of_node = pdev->of_node[i];
 979
 980                         if (reg_data && reg_data->constraints.name)
 981                                 rail_name = reg_data->constraints.name;
 982                         else
 983                                 rail_name = regulators[i].name;
 984                         reg_data->supply_regulator = rail_name;
 985
 986                 config.init_data =reg_data;
 987
 988                 act_rdev = regulator_register(&regulators[i],&config);
 989                 if (IS_ERR(act_rdev)) {
 990                         printk("failed to register %d regulator\n",i);
 991                 goto err;
 992                 }
 993                 act8846->rdev[i] = act_rdev;
 994                 }
 995         }
 996
 997         #ifdef CONFIG_HAS_EARLYSUSPEND
 998         act8846->act8846_suspend.suspend = act8846_early_suspend,
 999         act8846->act8846_suspend.resume = act8846_late_resume,
1000         act8846->act8846_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 1,
1001         register_early_suspend(&act8846->act8846_suspend);
1002         #endif
1003
1004         return 0;
1005
1006 err:
1007         return ret;
1008
1009 }
1010
1011 static int  act8846_i2c_remove(struct i2c_client *i2c)
1012 {
1013         struct act8846 *act8846 = i2c_get_clientdata(i2c);
1014         int i;
1015
1016         for (i = 0; i < act8846->num_regulators; i++)
1017                 if (act8846->rdev[i])
1018                         regulator_unregister(act8846->rdev[i]);
1019         kfree(act8846->rdev);
1020         i2c_set_clientdata(i2c, NULL);
1021         kfree(act8846);
1022
1023         return 0;
1024 }
1025
1026 static const struct i2c_device_id act8846_i2c_id[] = {
1027        { "act8846", 0 },
1028        { }
1029 };
1030
1031 MODULE_DEVICE_TABLE(i2c, act8846_i2c_id);
1032
1033 static struct i2c_driver act8846_i2c_driver = {
1034         .driver = {
1035                 .name = "act8846",
1036                 .owner = THIS_MODULE,
1037                 .of_match_table =of_match_ptr(act8846_of_match),
1038         },
1039         .probe    = act8846_i2c_probe,
1040         .remove   = act8846_i2c_remove,
1041         .id_table = act8846_i2c_id,
1042         #ifdef CONFIG_PM
1043         .suspend        = act8846_suspend,
1044         .resume         = act8846_resume,
1045         #endif
1046 };
1047
1048 static int __init act8846_module_init(void)
1049 {
1050         int ret;
1051         ret = i2c_add_driver(&act8846_i2c_driver);
1052         if (ret != 0)
1053                 pr_err("Failed to register I2C driver: %d\n", ret);
1054         return ret;
1055 }
1056 //module_init(act8846_module_init);
1057 //subsys_initcall(act8846_module_init);
1058 //rootfs_initcall(act8846_module_init);
1059 subsys_initcall_sync(act8846_module_init);
1060
1061 static void __exit act8846_module_exit(void)
1062 {
1063         i2c_del_driver(&act8846_i2c_driver);
1064 }
1065 module_exit(act8846_module_exit);
1066
1067 MODULE_LICENSE("GPL");
1068 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1069 MODULE_DESCRIPTION("act8846 PMIC driver");
1070