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