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         reg = act8846_reg_read(act8846,act8846_BUCK_SET_VOL_REG(buck));
 327         reg &= BUCK_VOL_MASK;
 328         DBG("%d\n", reg);
 329         val = 1000 * buck_voltage_map[reg];
 330         DBG("%d\n", val);
 331         return val;
 332 }
 333 static int act8846_dcdc_set_voltage(struct regulator_dev *dev,
 334                                   int min_uV, int max_uV,unsigned *selector)
 335 {
 336         struct act8846 *act8846 = rdev_get_drvdata(dev);
 337         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 338         int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
 339         const int *vol_map = buck_voltage_map;
 340         u16 val;
 341         int ret = 0;
 342
 343         DBG("%s, min_uV = %d, max_uV = %d!\n", __func__, min_uV, max_uV);
 344         if (min_vol < vol_map[VOL_MIN_IDX] ||
 345             min_vol > vol_map[VOL_MAX_IDX])
 346                 return -EINVAL;
 347
 348         for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
 349                 if (vol_map[val] >= min_vol)
 350                         break;
 351         }
 352
 353         if (vol_map[val] > max_vol)
 354                 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
 355         ret = act8846_set_bits(act8846, act8846_BUCK_SET_VOL_REG(buck),
 356                 BUCK_VOL_MASK, val);
 357         return ret;
 358 }
 359 static int act8846_dcdc_set_sleep_voltage(struct regulator_dev *dev,
 360                                             int uV)
 361 {
 362         struct act8846 *act8846 = rdev_get_drvdata(dev);
 363         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 364         int min_vol = uV / 1000,max_vol = uV / 1000;
 365         const int *vol_map = buck_voltage_map;
 366         u16 val;
 367         int ret = 0;
 368
 369         DBG("%s, min_uV = %d, max_uV = %d!\n", __func__, min_uV, max_uV);
 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            ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) + 0x01),
 382                                 BUCK_VOL_MASK, val);
 383         return ret;
 384 }
 385 static unsigned int act8846_dcdc_get_mode(struct regulator_dev *dev)
 386 {
 387         struct act8846 *act8846 = rdev_get_drvdata(dev);
 388         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 389         u16 mask = 0x08;
 390         u16 val;
 391         val = act8846_reg_read(act8846, act8846_BUCK_CONTR_REG(buck));
 392         if (val < 0) {
 393                 return val;
 394         }
 395         val=val & mask;
 396         if (val== mask)
 397                 return REGULATOR_MODE_NORMAL;
 398         else
 399                 return REGULATOR_MODE_STANDBY;
 400
 401 }
 402 static int act8846_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
 403 {
 404         struct act8846 *act8846 = rdev_get_drvdata(dev);
 405         int buck = rdev_get_id(dev) - ACT8846_DCDC1;
 406         u16 mask = 0x80;
 407         switch(mode)
 408         {
 409         case REGULATOR_MODE_STANDBY:
 410                 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
 411         case REGULATOR_MODE_NORMAL:
 412                 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, mask);
 413         default:
 414                 printk("error:pmu_act8846 only powersave and pwm mode\n");
 415                 return -EINVAL;
 416         }
 417
 418
 419 }
 420 static struct regulator_ops act8846_dcdc_ops = {
 421         .set_voltage = act8846_dcdc_set_voltage,
 422         .get_voltage = act8846_dcdc_get_voltage,
 423         .list_voltage= act8846_dcdc_list_voltage,
 424         .is_enabled = act8846_dcdc_is_enabled,
 425         .enable = act8846_dcdc_enable,
 426         .disable = act8846_dcdc_disable,
 427         .get_mode = act8846_dcdc_get_mode,
 428         .set_mode = act8846_dcdc_set_mode,
 429         .set_suspend_voltage = act8846_dcdc_set_sleep_voltage,
 430 };
 431 static struct regulator_desc regulators[] = {
 432
 433         {
 434                 .name = "DCDC1",
 435                 .id = 0,
 436                 .ops = &act8846_dcdc_ops,
 437                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 438                 .type = REGULATOR_VOLTAGE,
 439                 .owner = THIS_MODULE,
 440         },
 441         {
 442                 .name = "DCDC2",
 443                 .id = 1,
 444                 .ops = &act8846_dcdc_ops,
 445                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 446                 .type = REGULATOR_VOLTAGE,
 447                 .owner = THIS_MODULE,
 448         },
 449         {
 450                 .name = "DCDC3",
 451                 .id = 2,
 452                 .ops = &act8846_dcdc_ops,
 453                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 454                 .type = REGULATOR_VOLTAGE,
 455                 .owner = THIS_MODULE,
 456         },
 457         {
 458                 .name = "DCDC4",
 459                 .id = 3,
 460                 .ops = &act8846_dcdc_ops,
 461                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 462                 .type = REGULATOR_VOLTAGE,
 463                 .owner = THIS_MODULE,
 464         },
 465
 466         {
 467                 .name = "LDO1",
 468                 .id =4,
 469                 .ops = &act8846_ldo_ops,
 470                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 471                 .type = REGULATOR_VOLTAGE,
 472                 .owner = THIS_MODULE,
 473         },
 474         {
 475                 .name = "LDO2",
 476                 .id = 5,
 477                 .ops = &act8846_ldo_ops,
 478                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 479                 .type = REGULATOR_VOLTAGE,
 480                 .owner = THIS_MODULE,
 481         },
 482         {
 483                 .name = "LDO3",
 484                 .id = 6,
 485                 .ops = &act8846_ldo_ops,
 486                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 487                 .type = REGULATOR_VOLTAGE,
 488                 .owner = THIS_MODULE,
 489         },
 490         {
 491                 .name = "LDO4",
 492                 .id = 7,
 493                 .ops = &act8846_ldo_ops,
 494                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 495                 .type = REGULATOR_VOLTAGE,
 496                 .owner = THIS_MODULE,
 497         },
 498
 499         {
 500                 .name = "LDO5",
 501                 .id =8,
 502                 .ops = &act8846_ldo_ops,
 503                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 504                 .type = REGULATOR_VOLTAGE,
 505                 .owner = THIS_MODULE,
 506         },
 507         {
 508                 .name = "LDO6",
 509                 .id = 9,
 510                 .ops = &act8846_ldo_ops,
 511                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 512                 .type = REGULATOR_VOLTAGE,
 513                 .owner = THIS_MODULE,
 514         },
 515         {
 516                 .name = "LDO7",
 517                 .id = 10,
 518                 .ops = &act8846_ldo_ops,
 519                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 520                 .type = REGULATOR_VOLTAGE,
 521                 .owner = THIS_MODULE,
 522         },
 523         {
 524                 .name = "LDO8",
 525                 .id = 11,
 526                 .ops = &act8846_ldo_ops,
 527                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 528                 .type = REGULATOR_VOLTAGE,
 529                 .owner = THIS_MODULE,
 530         },
 531         {
 532                 .name = "LDO9",
 533                 .id = 12,
 534                 .ops = &act8846_ldo_ops,
 535                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 536                 .type = REGULATOR_VOLTAGE,
 537                 .owner = THIS_MODULE,
 538         },
 539 };
 540
 541 /*
 542  *
 543  */
 544 static int act8846_i2c_read(struct i2c_client *i2c, char reg, int count,        u16 *dest)
 545 {
 546       int ret;
 547     struct i2c_adapter *adap;
 548     struct i2c_msg msgs[2];
 549
 550     if(!i2c)
 551                 return ret;
 552
 553         if (count != 1)
 554                 return -EIO;
 555
 556     adap = i2c->adapter;
 557
 558     msgs[0].addr = i2c->addr;
 559     msgs[0].buf = &reg;
 560     msgs[0].flags = i2c->flags;
 561     msgs[0].len = 1;
 562     msgs[0].scl_rate = 200*1000;
 563
 564     msgs[1].buf = (u8 *)dest;
 565     msgs[1].addr = i2c->addr;
 566     msgs[1].flags = i2c->flags | I2C_M_RD;
 567     msgs[1].len = 1;
 568     msgs[1].scl_rate = 200*1000;
 569     ret = i2c_transfer(adap, msgs, 2);
 570
 571         DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
 572
 573         return 0;
 574 }
 575
 576 static int act8846_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
 577 {
 578         int ret=-1;
 579
 580         struct i2c_adapter *adap;
 581         struct i2c_msg msg;
 582         char tx_buf[2];
 583
 584         if(!i2c)
 585                 return ret;
 586         if (count != 1)
 587                 return -EIO;
 588
 589         adap = i2c->adapter;
 590         tx_buf[0] = reg;
 591         tx_buf[1] = src;
 592
 593         msg.addr = i2c->addr;
 594         msg.buf = &tx_buf[0];
 595         msg.len = 1 +1;
 596         msg.flags = i2c->flags;
 597         msg.scl_rate = 200*1000;
 598
 599         ret = i2c_transfer(adap, &msg, 1);
 600         return ret;
 601 }
 602
 603 static u8 act8846_reg_read(struct act8846 *act8846, u8 reg)
 604 {
 605         u16 val = 0;
 606
 607         mutex_lock(&act8846->io_lock);
 608
 609         act8846_i2c_read(act8846->i2c, reg, 1, &val);
 610
 611         DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 612
 613         mutex_unlock(&act8846->io_lock);
 614
 615         return val & 0xff;
 616 }
 617
 618 static int act8846_set_bits(struct act8846 *act8846, u8 reg, u16 mask, u16 val)
 619 {
 620         u16 tmp;
 621         int ret;
 622
 623         mutex_lock(&act8846->io_lock);
 624
 625         ret = act8846_i2c_read(act8846->i2c, reg, 1, &tmp);
 626         DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
 627         tmp = (tmp & ~mask) | val;
 628         if (ret == 0) {
 629                 ret = act8846_i2c_write(act8846->i2c, reg, 1, tmp);
 630                 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 631         }
 632         act8846_i2c_read(act8846->i2c, reg, 1, &tmp);
 633         DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
 634         mutex_unlock(&act8846->io_lock);
 635
 636         return 0;//ret;
 637 }
 638 static int __devinit setup_regulators(struct act8846 *act8846, struct act8846_platform_data *pdata)
 639 {
 640         int i, err;
 641
 642         act8846->num_regulators = pdata->num_regulators;
 643         act8846->rdev = kcalloc(pdata->num_regulators,
 644                                sizeof(struct regulator_dev *), GFP_KERNEL);
 645         if (!act8846->rdev) {
 646                 return -ENOMEM;
 647         }
 648         /* Instantiate the regulators */
 649         for (i = 0; i < pdata->num_regulators; i++) {
 650                 int id = pdata->regulators[i].id;
 651                 act8846->rdev[i] = regulator_register(&regulators[id],
 652                         act8846->dev, pdata->regulators[i].initdata, act8846);
 653 /*
 654                 if (IS_ERR(act8846->rdev[i])) {
 655                         err = PTR_ERR(act8846->rdev[i]);
 656                         dev_err(act8846->dev, "regulator init failed: %d\n",
 657                                 err);
 658                         goto error;
 659                 }*/
 660         }
 661
 662         return 0;
 663 error:
 664         while (--i >= 0)
 665                 regulator_unregister(act8846->rdev[i]);
 666         kfree(act8846->rdev);
 667         act8846->rdev = NULL;
 668         return err;
 669 }
 670
 671
 672 int act8846_device_shutdown(void)
 673 {
 674         int ret;
 675         int err = -1;
 676         struct act8846 *act8846 = g_act8846;
 677
 678         printk("%s\n",__func__);
 679
 680         ret = act8846_reg_read(act8846,0xc3);
 681         ret = act8846_set_bits(act8846, 0xc3,(0x1<<3),(0x1<<3));
 682         ret = act8846_set_bits(act8846, 0xc3,(0x1<<4),(0x1<<4));
 683         if (ret < 0) {
 684                 printk("act8846 set 0xc3 error!\n");
 685                 return err;
 686         }
 687         return 0;
 688 }
 689 EXPORT_SYMBOL_GPL(act8846_device_shutdown);
 690
 691 #ifdef CONFIG_HAS_EARLYSUSPEND
 692 __weak void act8846_early_suspend(struct early_suspend *h) {}
 693 __weak void act8846_late_resume(struct early_suspend *h) {}
 694 #endif
 695
 696 static int __devinit act8846_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
 697 {
 698         struct act8846 *act8846;
 699         struct act8846_platform_data *pdata = i2c->dev.platform_data;
 700         int ret;
 701         act8846 = kzalloc(sizeof(struct act8846), GFP_KERNEL);
 702         if (act8846 == NULL) {
 703                 ret = -ENOMEM;
 704                 goto err;
 705         }
 706         act8846->i2c = i2c;
 707         act8846->dev = &i2c->dev;
 708         i2c_set_clientdata(i2c, act8846);
 709         mutex_init(&act8846->io_lock);
 710
 711         ret = act8846_reg_read(act8846,0x22);
 712         if ((ret < 0) || (ret == 0xff)){
 713                 printk("The device is not act8846 \n");
 714                 return 0;
 715         }
 716
 717         if (pdata) {
 718                 ret = setup_regulators(act8846, pdata);
 719                 if (ret < 0)
 720                         goto err;
 721         } else
 722                 dev_warn(act8846->dev, "No platform init data supplied\n");
 723
 724         g_act8846 = act8846;
 725         pdata->set_init(act8846);
 726
 727         #ifdef CONFIG_HAS_EARLYSUSPEND
 728         act8846->act8846_suspend.suspend = act8846_early_suspend,
 729         act8846->act8846_suspend.resume = act8846_late_resume,
 730         act8846->act8846_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 1,
 731         register_early_suspend(&act8846->act8846_suspend);
 732         #endif
 733
 734         return 0;
 735
 736 err:
 737         return ret;
 738
 739 }
 740
 741 static int __devexit act8846_i2c_remove(struct i2c_client *i2c)
 742 {
 743         struct act8846 *act8846 = i2c_get_clientdata(i2c);
 744         int i;
 745
 746         for (i = 0; i < act8846->num_regulators; i++)
 747                 if (act8846->rdev[i])
 748                         regulator_unregister(act8846->rdev[i]);
 749         kfree(act8846->rdev);
 750         i2c_set_clientdata(i2c, NULL);
 751         kfree(act8846);
 752
 753         return 0;
 754 }
 755
 756 static const struct i2c_device_id act8846_i2c_id[] = {
 757        { "act8846", 0 },
 758        { }
 759 };
 760
 761 MODULE_DEVICE_TABLE(i2c, act8846_i2c_id);
 762
 763 static struct i2c_driver act8846_i2c_driver = {
 764         .driver = {
 765                 .name = "act8846",
 766                 .owner = THIS_MODULE,
 767         },
 768         .probe    = act8846_i2c_probe,
 769         .remove   = __devexit_p(act8846_i2c_remove),
 770         .id_table = act8846_i2c_id,
 771 };
 772
 773 static int __init act8846_module_init(void)
 774 {
 775         int ret;
 776         ret = i2c_add_driver(&act8846_i2c_driver);
 777         if (ret != 0)
 778                 pr_err("Failed to register I2C driver: %d\n", ret);
 779         return ret;
 780 }
 781 //module_init(act8846_module_init);
 782 //subsys_initcall(act8846_module_init);
 783 //rootfs_initcall(act8846_module_init);
 784 subsys_initcall_sync(act8846_module_init);
 785
 786 static void __exit act8846_module_exit(void)
 787 {
 788         i2c_del_driver(&act8846_i2c_driver);
 789 }
 790 module_exit(act8846_module_exit);
 791
 792 MODULE_LICENSE("GPL");
 793 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
 794 MODULE_DESCRIPTION("act8846 PMIC driver");
 795