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