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