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