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