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
 783         return pdata;
 784 }
 785
 786 #else
 787 static struct act8846_board *act8846_parse_dt(struct i2c_client *i2c)
 788 {
 789         return NULL;
 790 }
 791 #endif
 792
 793
 794 int act8846_device_shutdown(void)
 795 {
 796         int ret;
 797         int err = -1;
 798         struct act8846 *act8846 = g_act8846;
 799
 800         printk("%s\n",__func__);
 801
 802         ret = act8846_reg_read(act8846,0xc3);
 803         ret = act8846_set_bits(act8846, 0xc3,(0x1<<3),(0x1<<3));
 804         ret = act8846_set_bits(act8846, 0xc3,(0x1<<4),(0x1<<4));
 805         if (ret < 0) {
 806                 printk("act8846 set 0xc3 error!\n");
 807                 return err;
 808         }
 809         return 0;
 810 }
 811 EXPORT_SYMBOL_GPL(act8846_device_shutdown);
 812
 813 __weak void  act8846_device_suspend(void) {}
 814 __weak void  act8846_device_resume(void) {}
 815 #ifdef CONFIG_PM
 816 static int act8846_suspend(struct i2c_client *i2c, pm_message_t mesg)
 817 {
 818         act8846_device_suspend();
 819         return 0;
 820 }
 821
 822 static int act8846_resume(struct i2c_client *i2c)
 823 {
 824         act8846_device_resume();
 825         return 0;
 826 }
 827 #else
 828 static int act8846_suspend(struct i2c_client *i2c, pm_message_t mesg)
 829 {
 830         return 0;
 831 }
 832
 833 static int act8846_resume(struct i2c_client *i2c)
 834 {
 835         return 0;
 836 }
 837 #endif
 838
 839
 840 #ifdef CONFIG_HAS_EARLYSUSPEND
 841 __weak void act8846_early_suspend(struct early_suspend *h) {}
 842 __weak void act8846_late_resume(struct early_suspend *h) {}
 843 #endif
 844
 845 static bool is_volatile_reg(struct device *dev, unsigned int reg)
 846 {
 847
 848         if ((reg >= act8846_BUCK1_SET_VOL_BASE) && (reg <= act8846_LDO8_CONTR_BASE)) {
 849                 return true;
 850         }
 851         return true;
 852 }
 853
 854 static const struct regmap_config act8846_regmap_config = {
 855         .reg_bits = 8,
 856         .val_bits = 8,
 857         .volatile_reg = is_volatile_reg,
 858         .max_register = act8846_NUM_REGULATORS - 1,
 859         .cache_type = REGCACHE_RBTREE,
 860 };
 861 static int act8846_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
 862 {
 863         struct act8846 *act8846;
 864         struct act8846_board *pdev ;
 865         const struct of_device_id *match;
 866         struct regulator_config config = { };
 867         struct regulator_dev *act_rdev;
 868         struct regulator_init_data *reg_data;
 869         const char *rail_name = NULL;
 870         int ret,i=0;
 871
 872         printk("%s,line=%d\n", __func__,__LINE__);
 873
 874         if (i2c->dev.of_node) {
 875                 match = of_match_device(act8846_of_match, &i2c->dev);
 876                 if (!match) {
 877                         printk("Failed to find matching dt id\n");
 878                         return -EINVAL;
 879                 }
 880         }
 881
 882         act8846 = devm_kzalloc(&i2c->dev,sizeof(struct act8846), GFP_KERNEL);
 883         if (act8846 == NULL) {
 884                 ret = -ENOMEM;
 885                 goto err;
 886         }
 887         act8846->i2c = i2c;
 888         act8846->dev = &i2c->dev;
 889         i2c_set_clientdata(i2c, act8846);
 890         g_act8846 = act8846;
 891
 892         act8846->regmap = devm_regmap_init_i2c(i2c, &act8846_regmap_config);
 893         if (IS_ERR(act8846->regmap)) {
 894                 ret = PTR_ERR(act8846->regmap);
 895                 printk("regmap initialization failed: %d\n", ret);
 896                 return ret;
 897         }
 898
 899         mutex_init(&act8846->io_lock);
 900
 901         ret = act8846_reg_read(act8846,0x22);
 902         if ((ret < 0) || (ret == 0xff)){
 903                 printk("The device is not act8846 %x \n",ret);
 904                 goto err;
 905         }
 906
 907         ret = act8846_set_bits(act8846, 0xf4,(0x1<<7),(0x0<<7));
 908         if (ret < 0) {
 909                 printk("act8846 set 0xf4 error!\n");
 910                 goto err;
 911         }
 912
 913         if (act8846->dev->of_node)
 914                 pdev = act8846_parse_dt(act8846);
 915
 916         #ifdef CONFIG_OF
 917         act8846->pmic_hold_gpio = pdev->pmic_hold_gpio;
 918         if (act8846->pmic_hold_gpio) {
 919                         ret = gpio_request(act8846->pmic_hold_gpio, "act8846_pmic_hold");
 920                         if (ret < 0) {
 921                                 dev_err(act8846->dev,"Failed to request gpio %d with ret:""%d\n",       act8846->pmic_hold_gpio, ret);
 922                                 return IRQ_NONE;
 923                         }
 924                         gpio_direction_output(act8846->pmic_hold_gpio,1);
 925                         ret = gpio_get_value(act8846->pmic_hold_gpio);
 926                         gpio_free(act8846->pmic_hold_gpio);
 927                         printk("%s: act8846_pmic_hold=%x\n", __func__, ret);
 928         }
 929         #endif
 930
 931         /******************************set sleep vol & dcdc mode******************/
 932         #ifdef CONFIG_OF
 933         act8846->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
 934         if (act8846->pmic_sleep_gpio) {
 935                         ret = gpio_request(act8846->pmic_sleep_gpio, "act8846_pmic_sleep");
 936                         if (ret < 0) {
 937                                 dev_err(act8846->dev,"Failed to request gpio %d with ret:""%d\n",       act8846->pmic_sleep_gpio, ret);
 938                                 return IRQ_NONE;
 939                         }
 940                         gpio_direction_output(act8846->pmic_sleep_gpio,1);
 941                         ret = gpio_get_value(act8846->pmic_sleep_gpio);
 942                         gpio_free(act8846->pmic_sleep_gpio);
 943                         printk("%s: act8846_pmic_sleep=%x\n", __func__, ret);
 944         }
 945         #endif
 946
 947         if (pdev) {
 948                 act8846->num_regulators = act8846_NUM_REGULATORS;
 949                 act8846->rdev = kcalloc(act8846_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
 950                 if (!act8846->rdev) {
 951                         return -ENOMEM;
 952                 }
 953                 /* Instantiate the regulators */
 954                 for (i = 0; i < act8846_NUM_REGULATORS; i++) {
 955                 reg_data = pdev->act8846_init_data[i];
 956                 if (!reg_data)
 957                         continue;
 958                 config.dev = act8846->dev;
 959                 config.driver_data = act8846;
 960                 config.regmap = act8846->regmap;
 961                 if (act8846->dev->of_node)
 962                         config.of_node = pdev->of_node[i];
 963
 964                         if (reg_data && reg_data->constraints.name)
 965                                 rail_name = reg_data->constraints.name;
 966                         else
 967                                 rail_name = regulators[i].name;
 968                         reg_data->supply_regulator = rail_name;
 969
 970                 config.init_data =reg_data;
 971
 972                 act_rdev = regulator_register(&regulators[i],&config);
 973                 if (IS_ERR(act_rdev)) {
 974                         printk("failed to register %d regulator\n",i);
 975                 goto err;
 976                 }
 977                 act8846->rdev[i] = act_rdev;
 978                 }
 979         }
 980
 981         #ifdef CONFIG_HAS_EARLYSUSPEND
 982         act8846->act8846_suspend.suspend = act8846_early_suspend,
 983         act8846->act8846_suspend.resume = act8846_late_resume,
 984         act8846->act8846_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 1,
 985         register_early_suspend(&act8846->act8846_suspend);
 986         #endif
 987
 988         return 0;
 989
 990 err:
 991         return ret;
 992
 993 }
 994
 995 static int  act8846_i2c_remove(struct i2c_client *i2c)
 996 {
 997         struct act8846 *act8846 = i2c_get_clientdata(i2c);
 998         int i;
 999
1000         for (i = 0; i < act8846->num_regulators; i++)
1001                 if (act8846->rdev[i])
1002                         regulator_unregister(act8846->rdev[i]);
1003         kfree(act8846->rdev);
1004         i2c_set_clientdata(i2c, NULL);
1005         kfree(act8846);
1006
1007         return 0;
1008 }
1009
1010 static const struct i2c_device_id act8846_i2c_id[] = {
1011        { "act8846", 0 },
1012        { }
1013 };
1014
1015 MODULE_DEVICE_TABLE(i2c, act8846_i2c_id);
1016
1017 static struct i2c_driver act8846_i2c_driver = {
1018         .driver = {
1019                 .name = "act8846",
1020                 .owner = THIS_MODULE,
1021                 .of_match_table =of_match_ptr(act8846_of_match),
1022         },
1023         .probe    = act8846_i2c_probe,
1024         .remove   = act8846_i2c_remove,
1025         .id_table = act8846_i2c_id,
1026         #ifdef CONFIG_PM
1027         .suspend        = act8846_suspend,
1028         .resume         = act8846_resume,
1029         #endif
1030 };
1031
1032 static int __init act8846_module_init(void)
1033 {
1034         int ret;
1035         ret = i2c_add_driver(&act8846_i2c_driver);
1036         if (ret != 0)
1037                 pr_err("Failed to register I2C driver: %d\n", ret);
1038         return ret;
1039 }
1040 //module_init(act8846_module_init);
1041 //subsys_initcall(act8846_module_init);
1042 //rootfs_initcall(act8846_module_init);
1043 subsys_initcall_sync(act8846_module_init);
1044
1045 static void __exit act8846_module_exit(void)
1046 {
1047         i2c_del_driver(&act8846_i2c_driver);
1048 }
1049 module_exit(act8846_module_exit);
1050
1051 MODULE_LICENSE("GPL");
1052 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1053 MODULE_DESCRIPTION("act8846 PMIC driver");
1054