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 <mach/gpio.h>
  21 #include <linux/delay.h>
  22 #include <mach/iomux.h>
  23 #include <linux/slab.h>
  24 #ifdef CONFIG_HAS_EARLYSUSPEND
  25 #include <linux/earlysuspend.h>
  26 #endif
  27
  28
  29 #if 0
  30 #define DBG(x...)       printk(KERN_INFO x)
  31 #else
  32 #define DBG(x...)
  33 #endif
  34 #if 1
  35 #define DBG_INFO(x...)  printk(KERN_INFO x)
  36 #else
  37 #define DBG_INFO(x...)
  38 #endif
  39 #define PM_CONTROL
  40
  41 struct act8846 {
  42         struct device *dev;
  43         struct mutex io_lock;
  44         struct i2c_client *i2c;
  45         int num_regulators;
  46         struct regulator_dev **rdev;
  47         struct early_suspend act8846_suspend;
  48 };
  49
  50 struct act8846 *g_act8846;
  51
  52 static u8 act8846_reg_read(struct act8846 *act8846, u8 reg);
  53 static int act8846_set_bits(struct act8846 *act8846, u8 reg, u16 mask, u16 val);
  54
  55
  56 #define act8846_BUCK1_SET_VOL_BASE 0x10
  57 #define act8846_BUCK2_SET_VOL_BASE 0x20
  58 #define act8846_BUCK3_SET_VOL_BASE 0x30
  59 #define act8846_BUCK4_SET_VOL_BASE 0x40
  60
  61 #define act8846_BUCK2_SLP_VOL_BASE 0x21
  62 #define act8846_BUCK3_SLP_VOL_BASE 0x31
  63 #define act8846_BUCK4_SLP_VOL_BASE 0x41
  64
  65 #define act8846_LDO1_SET_VOL_BASE 0x50
  66 #define act8846_LDO2_SET_VOL_BASE 0x58
  67 #define act8846_LDO3_SET_VOL_BASE 0x60
  68 #define act8846_LDO4_SET_VOL_BASE 0x68
  69 #define act8846_LDO5_SET_VOL_BASE 0x70
  70 #define act8846_LDO6_SET_VOL_BASE 0x80
  71 #define act8846_LDO7_SET_VOL_BASE 0x90
  72 #define act8846_LDO8_SET_VOL_BASE 0xa0
  73 //#define act8846_LDO9_SET_VOL_BASE 0xb1
  74
  75 #define act8846_BUCK1_CONTR_BASE 0x12
  76 #define act8846_BUCK2_CONTR_BASE 0x22
  77 #define act8846_BUCK3_CONTR_BASE 0x32
  78 #define act8846_BUCK4_CONTR_BASE 0x42
  79
  80 #define act8846_LDO1_CONTR_BASE 0x51
  81 #define act8846_LDO2_CONTR_BASE 0x59
  82 #define act8846_LDO3_CONTR_BASE 0x61
  83 #define act8846_LDO4_CONTR_BASE 0x69
  84 #define act8846_LDO5_CONTR_BASE 0x71
  85 #define act8846_LDO6_CONTR_BASE 0x81
  86 #define act8846_LDO7_CONTR_BASE 0x91
  87 #define act8846_LDO8_CONTR_BASE 0xa1
  88 //#define act8846_LDO9_CONTR_BASE 0xb1
  89
  90 #define BUCK_VOL_MASK 0x3f
  91 #define LDO_VOL_MASK 0x3f
  92
  93 #define VOL_MIN_IDX 0x00
  94 #define VOL_MAX_IDX 0x3f
  95
  96 const static int buck_set_vol_base_addr[] = {
  97         act8846_BUCK1_SET_VOL_BASE,
  98         act8846_BUCK2_SET_VOL_BASE,
  99         act8846_BUCK3_SET_VOL_BASE,
 100         act8846_BUCK4_SET_VOL_BASE,
 101 };
 102 const static int buck_contr_base_addr[] = {
 103         act8846_BUCK1_CONTR_BASE,
 104         act8846_BUCK2_CONTR_BASE,
 105         act8846_BUCK3_CONTR_BASE,
 106         act8846_BUCK4_CONTR_BASE,
 107 };
 108 #define act8846_BUCK_SET_VOL_REG(x) (buck_set_vol_base_addr[x])
 109 #define act8846_BUCK_CONTR_REG(x) (buck_contr_base_addr[x])
 110
 111
 112 const static int ldo_set_vol_base_addr[] = {
 113         act8846_LDO1_SET_VOL_BASE,
 114         act8846_LDO2_SET_VOL_BASE,
 115         act8846_LDO3_SET_VOL_BASE,
 116         act8846_LDO4_SET_VOL_BASE,
 117         act8846_LDO5_SET_VOL_BASE,
 118         act8846_LDO6_SET_VOL_BASE,
 119         act8846_LDO7_SET_VOL_BASE,
 120         act8846_LDO8_SET_VOL_BASE,
 121 //      act8846_LDO9_SET_VOL_BASE,
 122 };
 123 const static int ldo_contr_base_addr[] = {
 124         act8846_LDO1_CONTR_BASE,
 125         act8846_LDO2_CONTR_BASE,
 126         act8846_LDO3_CONTR_BASE,
 127         act8846_LDO4_CONTR_BASE,
 128         act8846_LDO5_CONTR_BASE,
 129         act8846_LDO6_CONTR_BASE,
 130         act8846_LDO7_CONTR_BASE,
 131         act8846_LDO8_CONTR_BASE,
 132 //      act8846_LDO9_CONTR_BASE,
 133 };
 134 #define act8846_LDO_SET_VOL_REG(x) (ldo_set_vol_base_addr[x])
 135 #define act8846_LDO_CONTR_REG(x) (ldo_contr_base_addr[x])
 136
 137 const static int buck_voltage_map[] = {
 138          600, 625, 650, 675, 700, 725, 750, 775,
 139          800, 825, 850, 875, 900, 925, 950, 975,
 140          1000, 1025, 1050, 1075, 1100, 1125, 1150,
 141          1175, 1200, 1250, 1300, 1350, 1400, 1450,
 142          1500, 1550, 1600, 1650, 1700, 1750, 1800,
 143          1850, 1900, 1950, 2000, 2050, 2100, 2150,
 144          2200, 2250, 2300, 2350, 2400, 2500, 2600,
 145          2700, 2800, 2850, 2900, 3000, 3100, 3200,
 146          3300, 3400, 3500, 3600, 3700, 3800, 3900,
 147 };
 148
 149 const static int ldo_voltage_map[] = {
 150          600, 625, 650, 675, 700, 725, 750, 775,
 151          800, 825, 850, 875, 900, 925, 950, 975,
 152          1000, 1025, 1050, 1075, 1100, 1125, 1150,
 153          1175, 1200, 1250, 1300, 1350, 1400, 1450,
 154          1500, 1550, 1600, 1650, 1700, 1750, 1800,
 155          1850, 1900, 1950, 2000, 2050, 2100, 2150,
 156          2200, 2250, 2300, 2350, 2400, 2500, 2600,
 157          2700, 2800, 2850, 2900, 3000, 3100, 3200,
 158          3300, 3400, 3500, 3600, 3700, 3800, 3900,
 159 };
 160
 161 static int act8846_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
 162 {
 163         if (index >= ARRAY_SIZE(ldo_voltage_map))
 164                 return -EINVAL;
 165         return 1000 * ldo_voltage_map[index];
 166 }
 167 static int act8846_ldo_is_enabled(struct regulator_dev *dev)
 168 {
 169         struct act8846 *act8846 = rdev_get_drvdata(dev);
 170         int ldo = rdev_get_id(dev) - ACT8846_LDO1;
 171         u16 val;
 172         u16 mask=0x80;
 173         val = act8846_reg_read(act8846, act8846_LDO_CONTR_REG(ldo));
 174         if (val < 0)
 175                 return val;
 176         val=val&~0x7f;
 177         if (val & mask)
 178                 return 1;
 179         else
 180                 return 0;
 181 }
 182 static int act8846_ldo_enable(struct regulator_dev *dev)
 183 {
 184         struct act8846 *act8846 = rdev_get_drvdata(dev);
 185         int ldo= rdev_get_id(dev) - ACT8846_LDO1;
 186         u16 mask=0x80;
 187
 188         return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0x80);
 189
 190 }
 191 static int act8846_ldo_disable(struct regulator_dev *dev)
 192 {
 193         struct act8846 *act8846 = rdev_get_drvdata(dev);
 194         int ldo= rdev_get_id(dev) - ACT8846_LDO1;
 195         u16 mask=0x80;
 196
 197         return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0);
 198
 199 }
 200 static int act8846_ldo_get_voltage(struct regulator_dev *dev)
 201 {
 202         struct act8846 *act8846 = rdev_get_drvdata(dev);
 203         int ldo= rdev_get_id(dev) - ACT8846_LDO1;
 204         u16 reg = 0;
 205         int val;
 206         reg = act8846_reg_read(act8846,act8846_LDO_SET_VOL_REG(ldo));
 207         reg &= LDO_VOL_MASK;
 208         val = 1000 * ldo_voltage_map[reg];
 209         return val;
 210 }
 211 static int act8846_ldo_set_voltage(struct regulator_dev *dev,
 212                                   int min_uV, int max_uV,unsigned *selector)
 213 {
 214         struct act8846 *act8846 = rdev_get_drvdata(dev);
 215         int ldo= rdev_get_id(dev) - ACT8846_LDO1;
 216         int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
 217         const int *vol_map =ldo_voltage_map;
 218         u16 val;
 219         int ret = 0;
 220         if (min_vol < vol_map[VOL_MIN_IDX] ||
 221             min_vol > vol_map[VOL_MAX_IDX])
 222                 return -EINVAL;
 223
 224         for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
 225                 if (vol_map[val] >= min_vol)
 226                         break;
 227         }
 228
 229         if (vol_map[val] > max_vol)
 230                 return -EINVAL;
 231
 232         ret = act8846_set_bits(act8846, act8846_LDO_SET_VOL_REG(ldo),
 233                 LDO_VOL_MASK, val);
 234         return ret;
 235
 236 }
 237 static unsigned int act8846_ldo_get_mode(struct regulator_dev *dev)
 238 {
 239         struct act8846 *act8846 = rdev_get_drvdata(dev);
 240         int ldo = rdev_get_id(dev) - ACT8846_LDO1;
 241         u16 mask = 0x80;
 242         u16 val;
 243         val = act8846_reg_read(act8846, act8846_LDO_CONTR_REG(ldo));
 244         if (val < 0) {
 245                 return val;
 246         }
 247         val=val & mask;
 248         if (val== mask)
 249                 return REGULATOR_MODE_NORMAL;
 250         else
 251                 return REGULATOR_MODE_STANDBY;
 252
 253 }
 254 static int act8846_ldo_set_mode(struct regulator_dev *dev, unsigned int mode)
 255 {
 256         struct act8846 *act8846 = rdev_get_drvdata(dev);
 257         int ldo = rdev_get_id(dev) - ACT8846_LDO1;
 258         u16 mask = 0x80;
 259         switch(mode)
 260         {
 261         case REGULATOR_MODE_NORMAL:
 262                 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, mask);
 263         case REGULATOR_MODE_STANDBY:
 264                 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0);
 265         default:
 266                 printk("error:pmu_act8846 only lowpower and nomal mode\n");
 267                 return -EINVAL;
 268         }
 269
 270
 271 }
 272 static struct regulator_ops act8846_ldo_ops = {
 273         .set_voltage = act8846_ldo_set_voltage,
 274         .get_voltage = act8846_ldo_get_voltage,
 275         .list_voltage = act8846_ldo_list_voltage,
 276         .is_enabled = act8846_ldo_is_enabled,
 277         .enable = act8846_ldo_enable,
 278         .disable = act8846_ldo_disable,
 279         .get_mode = act8846_ldo_get_mode,
 280         .set_mode = act8846_ldo_set_mode,
 281
 282 };
 283
 284 static int act8846_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
 285 {
 286         if (index >= ARRAY_SIZE(buck_voltage_map))
 287                 return -EINVAL;
 288         return 1000 * buck_voltage_map[index];
 289 }
 290 static int act8846_dcdc_is_enabled(struct regulator_dev *dev)
 291 {
 292         struct act8846 *act8846 = rdev_get_drvdata(dev);
 293         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 294         u16 val;
 295         u16 mask=0x80;
 296         val = act8846_reg_read(act8846, act8846_BUCK_CONTR_REG(buck));
 297         if (val < 0)
 298                 return val;
 299          val=val&~0x7f;
 300         if (val & mask)
 301                 return 1;
 302         else
 303                 return 0;
 304 }
 305 static int act8846_dcdc_enable(struct regulator_dev *dev)
 306 {
 307         struct act8846 *act8846 = rdev_get_drvdata(dev);
 308         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 309         u16 mask=0x80;
 310         return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0x80);
 311
 312 }
 313 static int act8846_dcdc_disable(struct regulator_dev *dev)
 314 {
 315         struct act8846 *act8846 = rdev_get_drvdata(dev);
 316         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 317         u16 mask=0x80;
 318          return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
 319 }
 320 static int act8846_dcdc_get_voltage(struct regulator_dev *dev)
 321 {
 322         struct act8846 *act8846 = rdev_get_drvdata(dev);
 323         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 324         u16 reg = 0;
 325         int val;
 326         #ifdef CONFIG_ACT8846_SUPPORT_RESET
 327         reg = act8846_reg_read(act8846,(act8846_BUCK_SET_VOL_REG(buck)+0x1));
 328         #else
 329         reg = act8846_reg_read(act8846,act8846_BUCK_SET_VOL_REG(buck));
 330         #endif
 331         reg &= BUCK_VOL_MASK;
 332         DBG("%d\n", reg);
 333         val = 1000 * buck_voltage_map[reg];
 334         DBG("%d\n", val);
 335         return val;
 336 }
 337 static int act8846_dcdc_set_voltage(struct regulator_dev *dev,
 338                                   int min_uV, int max_uV,unsigned *selector)
 339 {
 340         struct act8846 *act8846 = rdev_get_drvdata(dev);
 341         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 342         int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
 343         const int *vol_map = buck_voltage_map;
 344         u16 val;
 345         int ret = 0;
 346
 347         DBG("%s, min_uV = %d, max_uV = %d!\n", __func__, min_uV, max_uV);
 348         if (min_vol < vol_map[VOL_MIN_IDX] ||
 349             min_vol > vol_map[VOL_MAX_IDX])
 350                 return -EINVAL;
 351
 352         for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
 353                 if (vol_map[val] >= min_vol)
 354                         break;
 355         }
 356
 357         if (vol_map[val] > max_vol)
 358                 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
 359
 360         #ifdef CONFIG_ACT8846_SUPPORT_RESET
 361         ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) +0x1),BUCK_VOL_MASK, val);
 362         #else
 363         ret = act8846_set_bits(act8846, act8846_BUCK_SET_VOL_REG(buck) ,BUCK_VOL_MASK, val);
 364         #endif
 365
 366         return ret;
 367 }
 368 static int act8846_dcdc_set_sleep_voltage(struct regulator_dev *dev,
 369                                             int uV)
 370 {
 371         struct act8846 *act8846 = rdev_get_drvdata(dev);
 372         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 373         int min_vol = uV / 1000,max_vol = uV / 1000;
 374         const int *vol_map = buck_voltage_map;
 375         u16 val;
 376         int ret = 0;
 377
 378         DBG("%s, min_uV = %d, max_uV = %d!\n", __func__, min_uV, max_uV);
 379         if (min_vol < vol_map[VOL_MIN_IDX] ||
 380             min_vol > vol_map[VOL_MAX_IDX])
 381                 return -EINVAL;
 382
 383         for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
 384                 if (vol_map[val] >= min_vol)
 385                         break;
 386         }
 387
 388         if (vol_map[val] > max_vol)
 389                 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
 390         #ifdef CONFIG_ACT8846_SUPPORT_RESET
 391          ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) ),BUCK_VOL_MASK, val);
 392         #else
 393         ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) +0x01),BUCK_VOL_MASK, val);
 394         #endif
 395
 396         return ret;
 397 }
 398 static unsigned int act8846_dcdc_get_mode(struct regulator_dev *dev)
 399 {
 400         struct act8846 *act8846 = rdev_get_drvdata(dev);
 401         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 402         u16 mask = 0x08;
 403         u16 val;
 404         val = act8846_reg_read(act8846, act8846_BUCK_CONTR_REG(buck));
 405         if (val < 0) {
 406                 return val;
 407         }
 408         val=val & mask;
 409         if (val== mask)
 410                 return REGULATOR_MODE_NORMAL;
 411         else
 412                 return REGULATOR_MODE_STANDBY;
 413
 414 }
 415 static int act8846_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
 416 {
 417         struct act8846 *act8846 = rdev_get_drvdata(dev);
 418         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 419         u16 mask = 0x80;
 420         switch(mode)
 421         {
 422         case REGULATOR_MODE_STANDBY:
 423                 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
 424         case REGULATOR_MODE_NORMAL:
 425                 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, mask);
 426         default:
 427                 printk("error:pmu_act8846 only powersave and pwm mode\n");
 428                 return -EINVAL;
 429         }
 430
 431
 432 }
 433 static struct regulator_ops act8846_dcdc_ops = {
 434         .set_voltage = act8846_dcdc_set_voltage,
 435         .get_voltage = act8846_dcdc_get_voltage,
 436         .list_voltage= act8846_dcdc_list_voltage,
 437         .is_enabled = act8846_dcdc_is_enabled,
 438         .enable = act8846_dcdc_enable,
 439         .disable = act8846_dcdc_disable,
 440         .get_mode = act8846_dcdc_get_mode,
 441         .set_mode = act8846_dcdc_set_mode,
 442         .set_suspend_voltage = act8846_dcdc_set_sleep_voltage,
 443 };
 444 static struct regulator_desc regulators[] = {
 445
 446         {
 447                 .name = "DCDC1",
 448                 .id = 0,
 449                 .ops = &act8846_dcdc_ops,
 450                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 451                 .type = REGULATOR_VOLTAGE,
 452                 .owner = THIS_MODULE,
 453         },
 454         {
 455                 .name = "DCDC2",
 456                 .id = 1,
 457                 .ops = &act8846_dcdc_ops,
 458                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 459                 .type = REGULATOR_VOLTAGE,
 460                 .owner = THIS_MODULE,
 461         },
 462         {
 463                 .name = "DCDC3",
 464                 .id = 2,
 465                 .ops = &act8846_dcdc_ops,
 466                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 467                 .type = REGULATOR_VOLTAGE,
 468                 .owner = THIS_MODULE,
 469         },
 470         {
 471                 .name = "DCDC4",
 472                 .id = 3,
 473                 .ops = &act8846_dcdc_ops,
 474                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 475                 .type = REGULATOR_VOLTAGE,
 476                 .owner = THIS_MODULE,
 477         },
 478
 479         {
 480                 .name = "LDO1",
 481                 .id =4,
 482                 .ops = &act8846_ldo_ops,
 483                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 484                 .type = REGULATOR_VOLTAGE,
 485                 .owner = THIS_MODULE,
 486         },
 487         {
 488                 .name = "LDO2",
 489                 .id = 5,
 490                 .ops = &act8846_ldo_ops,
 491                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 492                 .type = REGULATOR_VOLTAGE,
 493                 .owner = THIS_MODULE,
 494         },
 495         {
 496                 .name = "LDO3",
 497                 .id = 6,
 498                 .ops = &act8846_ldo_ops,
 499                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 500                 .type = REGULATOR_VOLTAGE,
 501                 .owner = THIS_MODULE,
 502         },
 503         {
 504                 .name = "LDO4",
 505                 .id = 7,
 506                 .ops = &act8846_ldo_ops,
 507                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 508                 .type = REGULATOR_VOLTAGE,
 509                 .owner = THIS_MODULE,
 510         },
 511
 512         {
 513                 .name = "LDO5",
 514                 .id =8,
 515                 .ops = &act8846_ldo_ops,
 516                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 517                 .type = REGULATOR_VOLTAGE,
 518                 .owner = THIS_MODULE,
 519         },
 520         {
 521                 .name = "LDO6",
 522                 .id = 9,
 523                 .ops = &act8846_ldo_ops,
 524                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 525                 .type = REGULATOR_VOLTAGE,
 526                 .owner = THIS_MODULE,
 527         },
 528         {
 529                 .name = "LDO7",
 530                 .id = 10,
 531                 .ops = &act8846_ldo_ops,
 532                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 533                 .type = REGULATOR_VOLTAGE,
 534                 .owner = THIS_MODULE,
 535         },
 536         {
 537                 .name = "LDO8",
 538                 .id = 11,
 539                 .ops = &act8846_ldo_ops,
 540                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 541                 .type = REGULATOR_VOLTAGE,
 542                 .owner = THIS_MODULE,
 543         },
 544         {
 545                 .name = "LDO9",
 546                 .id = 12,
 547                 .ops = &act8846_ldo_ops,
 548                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 549                 .type = REGULATOR_VOLTAGE,
 550                 .owner = THIS_MODULE,
 551         },
 552 };
 553
 554 /*
 555  *
 556  */
 557 static int act8846_i2c_read(struct i2c_client *i2c, char reg, int count,        u16 *dest)
 558 {
 559       int ret;
 560     struct i2c_adapter *adap;
 561     struct i2c_msg msgs[2];
 562
 563     if(!i2c)
 564                 return ret;
 565
 566         if (count != 1)
 567                 return -EIO;
 568
 569     adap = i2c->adapter;
 570
 571     msgs[0].addr = i2c->addr;
 572     msgs[0].buf = &reg;
 573     msgs[0].flags = i2c->flags;
 574     msgs[0].len = 1;
 575     msgs[0].scl_rate = 200*1000;
 576
 577     msgs[1].buf = (u8 *)dest;
 578     msgs[1].addr = i2c->addr;
 579     msgs[1].flags = i2c->flags | I2C_M_RD;
 580     msgs[1].len = 1;
 581     msgs[1].scl_rate = 200*1000;
 582     ret = i2c_transfer(adap, msgs, 2);
 583
 584         DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
 585
 586         return 0;
 587 }
 588
 589 static int act8846_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
 590 {
 591         int ret=-1;
 592
 593         struct i2c_adapter *adap;
 594         struct i2c_msg msg;
 595         char tx_buf[2];
 596
 597         if(!i2c)
 598                 return ret;
 599         if (count != 1)
 600                 return -EIO;
 601
 602         adap = i2c->adapter;
 603         tx_buf[0] = reg;
 604         tx_buf[1] = src;
 605
 606         msg.addr = i2c->addr;
 607         msg.buf = &tx_buf[0];
 608         msg.len = 1 +1;
 609         msg.flags = i2c->flags;
 610         msg.scl_rate = 200*1000;
 611
 612         ret = i2c_transfer(adap, &msg, 1);
 613         return ret;
 614 }
 615
 616 static u8 act8846_reg_read(struct act8846 *act8846, u8 reg)
 617 {
 618         u16 val = 0;
 619
 620         mutex_lock(&act8846->io_lock);
 621
 622         act8846_i2c_read(act8846->i2c, reg, 1, &val);
 623
 624         DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 625
 626         mutex_unlock(&act8846->io_lock);
 627
 628         return val & 0xff;
 629 }
 630
 631 static int act8846_set_bits(struct act8846 *act8846, u8 reg, u16 mask, u16 val)
 632 {
 633         u16 tmp;
 634         int ret;
 635
 636         mutex_lock(&act8846->io_lock);
 637
 638         ret = act8846_i2c_read(act8846->i2c, reg, 1, &tmp);
 639         DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
 640         tmp = (tmp & ~mask) | val;
 641         if (ret == 0) {
 642                 ret = act8846_i2c_write(act8846->i2c, reg, 1, tmp);
 643                 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 644         }
 645         act8846_i2c_read(act8846->i2c, reg, 1, &tmp);
 646         DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
 647         mutex_unlock(&act8846->io_lock);
 648
 649         return 0;//ret;
 650 }
 651 static int __devinit setup_regulators(struct act8846 *act8846, struct act8846_platform_data *pdata)
 652 {
 653         int i, err;
 654
 655         act8846->num_regulators = pdata->num_regulators;
 656         act8846->rdev = kcalloc(pdata->num_regulators,
 657                                sizeof(struct regulator_dev *), GFP_KERNEL);
 658         if (!act8846->rdev) {
 659                 return -ENOMEM;
 660         }
 661         /* Instantiate the regulators */
 662         for (i = 0; i < pdata->num_regulators; i++) {
 663                 int id = pdata->regulators[i].id;
 664                 act8846->rdev[i] = regulator_register(&regulators[id],
 665                         act8846->dev, pdata->regulators[i].initdata, act8846);
 666 /*
 667                 if (IS_ERR(act8846->rdev[i])) {
 668                         err = PTR_ERR(act8846->rdev[i]);
 669                         dev_err(act8846->dev, "regulator init failed: %d\n",
 670                                 err);
 671                         goto error;
 672                 }*/
 673         }
 674
 675         return 0;
 676 error:
 677         while (--i >= 0)
 678                 regulator_unregister(act8846->rdev[i]);
 679         kfree(act8846->rdev);
 680         act8846->rdev = NULL;
 681         return err;
 682 }
 683
 684
 685 int act8846_device_shutdown(void)
 686 {
 687         int ret;
 688         int err = -1;
 689         struct act8846 *act8846 = g_act8846;
 690
 691         printk("%s\n",__func__);
 692
 693         ret = act8846_reg_read(act8846,0xc3);
 694         ret = act8846_set_bits(act8846, 0xc3,(0x1<<3),(0x1<<3));
 695         ret = act8846_set_bits(act8846, 0xc3,(0x1<<4),(0x1<<4));
 696         if (ret < 0) {
 697                 printk("act8846 set 0xc3 error!\n");
 698                 return err;
 699         }
 700         return 0;
 701 }
 702 EXPORT_SYMBOL_GPL(act8846_device_shutdown);
 703
 704 #ifdef CONFIG_HAS_EARLYSUSPEND
 705 __weak void act8846_early_suspend(struct early_suspend *h) {}
 706 __weak void act8846_late_resume(struct early_suspend *h) {}
 707 #endif
 708
 709 static int __devinit act8846_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
 710 {
 711         struct act8846 *act8846;
 712         struct act8846_platform_data *pdata = i2c->dev.platform_data;
 713         int ret;
 714         act8846 = kzalloc(sizeof(struct act8846), GFP_KERNEL);
 715         if (act8846 == NULL) {
 716                 ret = -ENOMEM;
 717                 goto err;
 718         }
 719         act8846->i2c = i2c;
 720         act8846->dev = &i2c->dev;
 721         i2c_set_clientdata(i2c, act8846);
 722         mutex_init(&act8846->io_lock);
 723
 724         ret = act8846_reg_read(act8846,0x22);
 725         if ((ret < 0) || (ret == 0xff)){
 726                 printk("The device is not act8846 \n");
 727                 return 0;
 728         }
 729
 730         if (pdata) {
 731                 ret = setup_regulators(act8846, pdata);
 732                 if (ret < 0)
 733                         goto err;
 734         } else
 735                 dev_warn(act8846->dev, "No platform init data supplied\n");
 736
 737         g_act8846 = act8846;
 738         pdata->set_init(act8846);
 739
 740         #ifdef CONFIG_HAS_EARLYSUSPEND
 741         act8846->act8846_suspend.suspend = act8846_early_suspend,
 742         act8846->act8846_suspend.resume = act8846_late_resume,
 743         act8846->act8846_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 1,
 744         register_early_suspend(&act8846->act8846_suspend);
 745         #endif
 746
 747         return 0;
 748
 749 err:
 750         return ret;
 751
 752 }
 753
 754 static int __devexit act8846_i2c_remove(struct i2c_client *i2c)
 755 {
 756         struct act8846 *act8846 = i2c_get_clientdata(i2c);
 757         int i;
 758
 759         for (i = 0; i < act8846->num_regulators; i++)
 760                 if (act8846->rdev[i])
 761                         regulator_unregister(act8846->rdev[i]);
 762         kfree(act8846->rdev);
 763         i2c_set_clientdata(i2c, NULL);
 764         kfree(act8846);
 765
 766         return 0;
 767 }
 768
 769 static const struct i2c_device_id act8846_i2c_id[] = {
 770        { "act8846", 0 },
 771        { }
 772 };
 773
 774 MODULE_DEVICE_TABLE(i2c, act8846_i2c_id);
 775
 776 static struct i2c_driver act8846_i2c_driver = {
 777         .driver = {
 778                 .name = "act8846",
 779                 .owner = THIS_MODULE,
 780         },
 781         .probe    = act8846_i2c_probe,
 782         .remove   = __devexit_p(act8846_i2c_remove),
 783         .id_table = act8846_i2c_id,
 784 };
 785
 786 static int __init act8846_module_init(void)
 787 {
 788         int ret;
 789         ret = i2c_add_driver(&act8846_i2c_driver);
 790         if (ret != 0)
 791                 pr_err("Failed to register I2C driver: %d\n", ret);
 792         return ret;
 793 }
 794 //module_init(act8846_module_init);
 795 //subsys_initcall(act8846_module_init);
 796 //rootfs_initcall(act8846_module_init);
 797 subsys_initcall_sync(act8846_module_init);
 798
 799 static void __exit act8846_module_exit(void)
 800 {
 801         i2c_del_driver(&act8846_i2c_driver);
 802 }
 803 module_exit(act8846_module_exit);
 804
 805 MODULE_LICENSE("GPL");
 806 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
 807 MODULE_DESCRIPTION("act8846 PMIC driver");
 808