drivers/regulator/act8931.c

   1 /*
   2  * Regulator driver for Active-semi act8931 PMIC chip for rk29xx
   3  *
   4  * Copyright (C) 2010, 2011 ROCKCHIP, Inc.
   5
   6  * Based on act8891.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 #include <linux/bug.h>
  14 #include <linux/err.h>
  15 #include <linux/i2c.h>
  16 #include <linux/kernel.h>
  17 #include <linux/regulator/driver.h>
  18 #include <linux/regulator/act8931.h>
  19 #include <mach/gpio.h>
  20 #include <linux/delay.h>
  21 #include <mach/iomux.h>
  22 #include <linux/slab.h>
  23
  24 #if 0
  25 #define DBG(x...)       printk(KERN_INFO x)
  26 #else
  27 #define DBG(x...)
  28 #endif
  29 #if 1
  30 #define DBG_INFO(x...)  printk(KERN_INFO x)
  31 #else
  32 #define DBG_INFO(x...)
  33 #endif
  34 #define PM_CONTROL
  35
  36 struct act8931 {
  37         struct device *dev;
  38         struct mutex io_lock;
  39         struct i2c_client *i2c;
  40         int num_regulators;
  41         struct regulator_dev **rdev;
  42 };
  43
  44 static u8 act8931_reg_read(struct act8931 *act8931, u8 reg);
  45 static int act8931_set_bits(struct act8931 *act8931, u8 reg, u16 mask, u16 val);
  46
  47
  48 #define act8931_BUCK1_SET_VOL_BASE 0x20
  49 #define act8931_BUCK2_SET_VOL_BASE 0x30
  50 #define act8931_BUCK3_SET_VOL_BASE 0x40
  51 #define act8931_LDO1_SET_VOL_BASE 0x50
  52 #define act8931_LDO2_SET_VOL_BASE 0x54
  53 #define act8931_LDO3_SET_VOL_BASE 0x60
  54 #define act8931_LDO4_SET_VOL_BASE 0x64
  55
  56 #define act8931_BUCK1_CONTR_BASE 0x22
  57 #define act8931_BUCK2_CONTR_BASE 0x32
  58 #define act8931_BUCK3_CONTR_BASE 0x42
  59 #define act8931_LDO1_CONTR_BASE 0x51
  60 #define act8931_LDO2_CONTR_BASE 0x55
  61 #define act8931_LDO3_CONTR_BASE 0x61
  62 #define act8931_LDO4_CONTR_BASE 0x65
  63
  64 #define BUCK_VOL_MASK 0x3f
  65 #define LDO_VOL_MASK 0x3f
  66
  67 #define VOL_MIN_IDX 0x00
  68 #define VOL_MAX_IDX 0x3f
  69
  70 const static int buck_set_vol_base_addr[] = {
  71         act8931_BUCK1_SET_VOL_BASE,
  72         act8931_BUCK2_SET_VOL_BASE,
  73         act8931_BUCK3_SET_VOL_BASE,
  74 };
  75 const static int buck_contr_base_addr[] = {
  76         act8931_BUCK1_CONTR_BASE,
  77         act8931_BUCK2_CONTR_BASE,
  78         act8931_BUCK3_CONTR_BASE,
  79 };
  80 #define act8931_BUCK_SET_VOL_REG(x) (buck_set_vol_base_addr[x])
  81 #define act8931_BUCK_CONTR_REG(x) (buck_contr_base_addr[x])
  82
  83
  84 const static int ldo_set_vol_base_addr[] = {
  85         act8931_LDO1_SET_VOL_BASE,
  86         act8931_LDO2_SET_VOL_BASE,
  87         act8931_LDO3_SET_VOL_BASE,
  88         act8931_LDO4_SET_VOL_BASE,
  89 };
  90 const static int ldo_contr_base_addr[] = {
  91         act8931_LDO1_CONTR_BASE,
  92         act8931_LDO2_CONTR_BASE,
  93         act8931_LDO3_CONTR_BASE,
  94         act8931_LDO4_CONTR_BASE,
  95 };
  96 #define act8931_LDO_SET_VOL_REG(x) (ldo_set_vol_base_addr[x])
  97 #define act8931_LDO_CONTR_REG(x) (ldo_contr_base_addr[x])
  98
  99 const static int buck_voltage_map[] = {
 100          600, 625, 650, 675, 700, 725, 750, 775,
 101          800, 825, 850, 875, 900, 925, 950, 975,
 102          1000, 1025, 1050, 1075, 1100, 1125, 1150,
 103          1175, 1200, 1250, 1300, 1350, 1400, 1450,
 104          1500, 1550, 1600, 1650, 1700, 1750, 1800,
 105          1850, 1900, 1950, 2000, 2050, 2100, 2150,
 106          2200, 2250, 2300, 2350, 2400, 2500, 2600,
 107          2700, 2800, 2850, 2900, 3000, 3100, 3200,
 108          3300, 3400, 3500, 3600, 3700, 3800, 3900,
 109 };
 110
 111 const static int ldo_voltage_map[] = {
 112          600, 625, 650, 675, 700, 725, 750, 775,
 113          800, 825, 850, 875, 900, 925, 950, 975,
 114          1000, 1025, 1050, 1075, 1100, 1125, 1150,
 115          1175, 1200, 1250, 1300, 1350, 1400, 1450,
 116          1500, 1550, 1600, 1650, 1700, 1750, 1800,
 117          1850, 1900, 1950, 2000, 2050, 2100, 2150,
 118          2200, 2250, 2300, 2350, 2400, 2500, 2600,
 119          2700, 2800, 2850, 2900, 3000, 3100, 3200,
 120          3300, 3400, 3500, 3600, 3700, 3800, 3900,
 121 };
 122
 123 static int act8931_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
 124 {
 125         return 1000 * ldo_voltage_map[index];
 126 }
 127 static int act8931_ldo_is_enabled(struct regulator_dev *dev)
 128 {
 129         struct act8931 *act8931 = rdev_get_drvdata(dev);
 130         int ldo = rdev_get_id(dev) -ACT8931_LDO1;
 131         u16 val;
 132         u16 mask=0x80;
 133         val = act8931_reg_read(act8931, act8931_LDO_CONTR_REG(ldo));
 134         if (val < 0)
 135                 return val;
 136         val=val&~0x7f;
 137         if (val & mask)
 138                 return 1;
 139         else
 140                 return 0;
 141 }
 142 static int act8931_ldo_enable(struct regulator_dev *dev)
 143 {
 144         struct act8931 *act8931 = rdev_get_drvdata(dev);
 145         int ldo= rdev_get_id(dev) -ACT8931_LDO1;
 146         u16 mask=0x80;
 147         int ret;
 148         return act8931_set_bits(act8931, act8931_LDO_CONTR_REG(ldo), mask, 0x80);
 149
 150 }
 151 static int act8931_ldo_disable(struct regulator_dev *dev)
 152 {
 153         struct act8931 *act8931 = rdev_get_drvdata(dev);
 154         int ldo= rdev_get_id(dev) -ACT8931_LDO1;
 155         u16 mask=0x80;
 156         int ret;
 157         return act8931_set_bits(act8931, act8931_LDO_CONTR_REG(ldo), mask, 0);
 158
 159 }
 160 static int act8931_ldo_get_voltage(struct regulator_dev *dev)
 161 {
 162         struct act8931 *act8931 = rdev_get_drvdata(dev);
 163         int ldo= rdev_get_id(dev) -ACT8931_LDO1;
 164         u16 reg = 0;
 165         int val;
 166         reg = act8931_reg_read(act8931,act8931_LDO_SET_VOL_REG(ldo));
 167         reg &= LDO_VOL_MASK;
 168         val = 1000 * ldo_voltage_map[reg];
 169         return val;
 170 }
 171 static int act8931_ldo_set_voltage(struct regulator_dev *dev,
 172                                   int min_uV, int max_uV)
 173 {
 174         struct act8931 *act8931 = rdev_get_drvdata(dev);
 175         int ldo= rdev_get_id(dev) -ACT8931_LDO1;
 176         int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
 177         const int *vol_map =ldo_voltage_map;
 178         u16 val;
 179         int ret = 0;
 180         if (min_vol < vol_map[VOL_MIN_IDX] ||
 181             min_vol > vol_map[VOL_MAX_IDX])
 182                 return -EINVAL;
 183
 184         for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX;
 185              val++){
 186                 if (vol_map[val] >= min_vol)
 187                         break;  }
 188
 189         if (vol_map[val] > max_vol)
 190                 return -EINVAL;
 191
 192         ret = act8931_set_bits(act8931, act8931_LDO_SET_VOL_REG(ldo),
 193                 LDO_VOL_MASK, val);
 194         if (ret)
 195                 return ret;
 196
 197 }
 198 static int act8931_ldo_get_mode(struct regulator_dev *dev, unsigned index)
 199 {
 200         struct act8931 *act8931 = rdev_get_drvdata(dev);
 201         int ldo = rdev_get_id(dev) -ACT8931_LDO1 ;
 202         u16 mask = 0xcf;
 203         u16 val;
 204         val = act8931_reg_read(act8931, act8931_LDO_CONTR_REG(ldo));
 205         val=val|mask;
 206         if (val== mask)
 207                 return REGULATOR_MODE_NORMAL;
 208         else
 209                 return REGULATOR_MODE_STANDBY;
 210
 211 }
 212 static int act8931_ldo_set_mode(struct regulator_dev *dev, unsigned int mode)
 213 {
 214         struct act8931 *act8931 = rdev_get_drvdata(dev);
 215         int ldo = rdev_get_id(dev) -ACT8931_LDO1 ;
 216         u16 mask = 0x20;
 217         switch(mode)
 218         {
 219         case REGULATOR_MODE_NORMAL:
 220                 return act8931_set_bits(act8931, act8931_LDO_CONTR_REG(ldo), mask, 0);
 221         case REGULATOR_MODE_STANDBY:
 222                 return act8931_set_bits(act8931, act8931_LDO_CONTR_REG(ldo), mask, mask);
 223         default:
 224                 printk("error:pmu_act8931 only lowpower and nomal mode\n");
 225                 return -EINVAL;
 226         }
 227
 228
 229 }
 230 static struct regulator_ops act8931_ldo_ops = {
 231         .set_voltage = act8931_ldo_set_voltage,
 232         .get_voltage = act8931_ldo_get_voltage,
 233         .list_voltage = act8931_ldo_list_voltage,
 234         .is_enabled = act8931_ldo_is_enabled,
 235         .enable = act8931_ldo_enable,
 236         .disable = act8931_ldo_disable,
 237         .get_mode = act8931_ldo_get_mode,
 238         .set_mode = act8931_ldo_set_mode,
 239
 240 };
 241
 242 static int act8931_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
 243 {
 244         return 1000 * buck_voltage_map[index];
 245 }
 246 static int act8931_dcdc_is_enabled(struct regulator_dev *dev)
 247 {
 248         struct act8931 *act8931 = rdev_get_drvdata(dev);
 249         int buck = rdev_get_id(dev) -ACT8931_DCDC1;
 250         u16 val;
 251         u16 mask=0x80;
 252         val = act8931_reg_read(act8931, act8931_BUCK_CONTR_REG(buck));
 253         if (val < 0)
 254                 return val;
 255          val=val&~0x7f;
 256         if (val & mask)
 257                 return 1;
 258         else
 259                 return 0;
 260 }
 261 static int act8931_dcdc_enable(struct regulator_dev *dev)
 262 {
 263         struct act8931 *act8931 = rdev_get_drvdata(dev);
 264         int buck = rdev_get_id(dev) -ACT8931_DCDC1 ;
 265         u16 mask=0x80;
 266         return act8931_set_bits(act8931, act8931_BUCK_CONTR_REG(buck), mask, 0x80);
 267
 268 }
 269 static int act8931_dcdc_disable(struct regulator_dev *dev)
 270 {
 271         struct act8931 *act8931 = rdev_get_drvdata(dev);
 272         int buck = rdev_get_id(dev) -ACT8931_DCDC1 ;
 273         u16 mask=0x80;
 274          return act8931_set_bits(act8931, act8931_BUCK_CONTR_REG(buck), mask, 0);
 275 }
 276 static int act8931_dcdc_get_voltage(struct regulator_dev *dev)
 277 {
 278         struct act8931 *act8931 = rdev_get_drvdata(dev);
 279         int buck = rdev_get_id(dev) -ACT8931_DCDC1 ;
 280         u16 reg = 0;
 281         int val;
 282         reg = act8931_reg_read(act8931,act8931_BUCK_SET_VOL_REG(buck));
 283         reg &= BUCK_VOL_MASK;
 284         DBG("%d\n", reg);
 285         val = 1000 * buck_voltage_map[reg];
 286         DBG("%d\n", val);
 287         return val;
 288 }
 289 static int act8931_dcdc_set_voltage(struct regulator_dev *dev,
 290                                   int min_uV, int max_uV)
 291 {
 292         struct act8931 *act8931 = rdev_get_drvdata(dev);
 293         int buck = rdev_get_id(dev) -ACT8931_DCDC1 ;
 294         int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
 295         const int *vol_map = buck_voltage_map;
 296         u16 val;
 297         int ret = 0;
 298
 299         DBG("%s, min_uV = %d, max_uV = %d!\n", __func__, min_uV, max_uV);
 300         if (min_vol < vol_map[VOL_MIN_IDX] ||
 301             min_vol > vol_map[VOL_MAX_IDX])
 302                 return -EINVAL;
 303
 304         for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX;
 305              val++){
 306                 if (vol_map[val] >= min_vol)
 307                         break;}
 308
 309         if (vol_map[val] > max_vol)
 310                 return -EINVAL;
 311         ret = act8931_set_bits(act8931, act8931_BUCK_SET_VOL_REG(buck),
 312                 BUCK_VOL_MASK, val);
 313         ret = act8931_set_bits(act8931, act8931_BUCK_SET_VOL_REG(buck) + 0x01,
 314                 BUCK_VOL_MASK, val);
 315         //if (ret)
 316                 return ret;
 317 }
 318 static int act8931_dcdc_get_mode(struct regulator_dev *dev, unsigned index)
 319 {
 320         struct act8931 *act8931 = rdev_get_drvdata(dev);
 321         int buck = rdev_get_id(dev) -ACT8931_DCDC1 ;
 322         u16 mask = 0xcf;
 323         u16 val;
 324         val = act8931_reg_read(act8931, act8931_BUCK_CONTR_REG(buck));
 325         val=val|mask;
 326         if (val== mask)
 327                 return REGULATOR_MODE_STANDBY;
 328         else
 329                 return REGULATOR_MODE_NORMAL;
 330
 331 }
 332 static int act8931_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
 333 {
 334         struct act8931 *act8931 = rdev_get_drvdata(dev);
 335         int buck = rdev_get_id(dev) -ACT8931_DCDC1 ;
 336         u16 mask = 0x20;
 337         switch(mode)
 338         {
 339         case REGULATOR_MODE_STANDBY:
 340                 return act8931_set_bits(act8931, act8931_BUCK_CONTR_REG(buck), mask, 0);
 341         case REGULATOR_MODE_NORMAL:
 342                 return act8931_set_bits(act8931, act8931_BUCK_CONTR_REG(buck), mask, mask);
 343         default:
 344                 printk("error:pmu_act8931 only powersave and pwm mode\n");
 345                 return -EINVAL;
 346         }
 347
 348
 349 }
 350 static struct regulator_ops act8931_dcdc_ops = {
 351         .set_voltage = act8931_dcdc_set_voltage,
 352         .get_voltage = act8931_dcdc_get_voltage,
 353         .list_voltage= act8931_dcdc_list_voltage,
 354         .is_enabled = act8931_dcdc_is_enabled,
 355         .enable = act8931_dcdc_enable,
 356         .disable = act8931_dcdc_disable,
 357         .get_mode = act8931_dcdc_get_mode,
 358         .set_mode = act8931_dcdc_set_mode,
 359 };
 360 static struct regulator_desc regulators[] = {
 361         {
 362                 .name = "ACT_LDO1",
 363                 .id =0,
 364                 .ops = &act8931_ldo_ops,
 365                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 366                 .type = REGULATOR_VOLTAGE,
 367                 .owner = THIS_MODULE,
 368         },
 369         {
 370                 .name = "ACT_LDO2",
 371                 .id = 1,
 372                 .ops = &act8931_ldo_ops,
 373                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 374                 .type = REGULATOR_VOLTAGE,
 375                 .owner = THIS_MODULE,
 376         },
 377         {
 378                 .name = "ACT_LDO3",
 379                 .id = 2,
 380                 .ops = &act8931_ldo_ops,
 381                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 382                 .type = REGULATOR_VOLTAGE,
 383                 .owner = THIS_MODULE,
 384         },
 385         {
 386                 .name = "ACT_LDO4",
 387                 .id = 3,
 388                 .ops = &act8931_ldo_ops,
 389                 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
 390                 .type = REGULATOR_VOLTAGE,
 391                 .owner = THIS_MODULE,
 392         },
 393
 394         {
 395                 .name = "ACT_DCDC1",
 396                 .id = 4,
 397                 .ops = &act8931_dcdc_ops,
 398                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 399                 .type = REGULATOR_VOLTAGE,
 400                 .owner = THIS_MODULE,
 401         },
 402         {
 403                 .name = "ACT_DCDC2",
 404                 .id = 5,
 405                 .ops = &act8931_dcdc_ops,
 406                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 407                 .type = REGULATOR_VOLTAGE,
 408                 .owner = THIS_MODULE,
 409         },
 410         {
 411                 .name = "ACT_DCDC3",
 412                 .id = 6,
 413                 .ops = &act8931_dcdc_ops,
 414                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 415                 .type = REGULATOR_VOLTAGE,
 416                 .owner = THIS_MODULE,
 417         },
 418
 419 };
 420
 421 /*
 422  *
 423  */
 424 static int act8931_i2c_read(struct i2c_client *i2c, char reg, int count,        u16 *dest)
 425 {
 426       int ret;
 427     struct i2c_adapter *adap;
 428     struct i2c_msg msgs[2];
 429
 430     if(!i2c)
 431                 return ret;
 432
 433         if (count != 1)
 434                 return -EIO;
 435
 436     adap = i2c->adapter;
 437
 438     msgs[0].addr = i2c->addr;
 439     msgs[0].buf = &reg;
 440     msgs[0].flags = i2c->flags;
 441     msgs[0].len = 1;
 442     msgs[0].scl_rate = 200*1000;
 443
 444     msgs[1].buf = dest;
 445     msgs[1].addr = i2c->addr;
 446     msgs[1].flags = i2c->flags | I2C_M_RD;
 447     msgs[1].len = 1;
 448     msgs[1].scl_rate = 200*1000;
 449     ret = i2c_transfer(adap, msgs, 2);
 450
 451         DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
 452
 453         return 0;
 454 }
 455
 456 static int act8931_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
 457 {
 458         int ret=-1;
 459
 460         struct i2c_adapter *adap;
 461         struct i2c_msg msg;
 462         char tx_buf[2];
 463
 464         if(!i2c)
 465                 return ret;
 466         if (count != 1)
 467                 return -EIO;
 468
 469         adap = i2c->adapter;
 470         tx_buf[0] = reg;
 471         tx_buf[1] = src;
 472
 473         msg.addr = i2c->addr;
 474         msg.buf = &tx_buf[0];
 475         msg.len = 1 +1;
 476         msg.flags = i2c->flags;
 477         msg.scl_rate = 200*1000;
 478
 479         ret = i2c_transfer(adap, &msg, 1);
 480         return 0;
 481 }
 482
 483 static u8 act8931_reg_read(struct act8931 *act8931, u8 reg)
 484 {
 485         u16 val = 0;
 486
 487         mutex_lock(&act8931->io_lock);
 488
 489         act8931_i2c_read(act8931->i2c, reg, 1, &val);
 490
 491         DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 492
 493         mutex_unlock(&act8931->io_lock);
 494
 495         return val & 0xff;
 496 }
 497
 498 static int act8931_set_bits(struct act8931 *act8931, u8 reg, u16 mask, u16 val)
 499 {
 500         u16 tmp;
 501         int ret;
 502
 503         mutex_lock(&act8931->io_lock);
 504
 505         ret = act8931_i2c_read(act8931->i2c, reg, 1, &tmp);
 506         DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
 507         tmp = (tmp & ~mask) | val;
 508         if (ret == 0) {
 509                 ret = act8931_i2c_write(act8931->i2c, reg, 1, tmp);
 510                 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 511         }
 512         act8931_i2c_read(act8931->i2c, reg, 1, &tmp);
 513         DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
 514         mutex_unlock(&act8931->io_lock);
 515
 516         return ret;
 517 }
 518 static int __devinit setup_regulators(struct act8931 *act8931, struct act8931_platform_data *pdata)
 519 {
 520         int i, err;
 521
 522         act8931->num_regulators = pdata->num_regulators;
 523         act8931->rdev = kcalloc(pdata->num_regulators,
 524                                sizeof(struct regulator_dev *), GFP_KERNEL);
 525         if (!act8931->rdev) {
 526                 return -ENOMEM;
 527         }
 528         /* Instantiate the regulators */
 529         for (i = 0; i < pdata->num_regulators; i++) {
 530                 int id = pdata->regulators[i].id;
 531                 act8931->rdev[i] = regulator_register(&regulators[id],
 532                         act8931->dev, pdata->regulators[i].initdata, act8931);
 533 /*
 534                 if (IS_ERR(act8931->rdev[i])) {
 535                         err = PTR_ERR(act8931->rdev[i]);
 536                         dev_err(act8931->dev, "regulator init failed: %d\n",
 537                                 err);
 538                         goto error;
 539                 }*/
 540         }
 541
 542         return 0;
 543 error:
 544         while (--i >= 0)
 545                 regulator_unregister(act8931->rdev[i]);
 546         kfree(act8931->rdev);
 547         act8931->rdev = NULL;
 548         return err;
 549 }
 550
 551 static int __devinit act8931_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
 552 {
 553         struct act8931 *act8931;
 554         struct act8931_platform_data *pdata = i2c->dev.platform_data;
 555         int ret;
 556         act8931 = kzalloc(sizeof(struct act8931), GFP_KERNEL);
 557         if (act8931 == NULL) {
 558                 ret = -ENOMEM;
 559                 goto err;
 560         }
 561         act8931->i2c = i2c;
 562         act8931->dev = &i2c->dev;
 563         i2c_set_clientdata(i2c, act8931);
 564         mutex_init(&act8931->io_lock);
 565
 566         ret = act8931_reg_read(act8931,0x22);
 567         if ((ret < 0) || (ret == 0xff)){
 568                 printk("The device is not act8931 \n");
 569                 return 0;
 570         }
 571
 572         if (pdata) {
 573                 ret = setup_regulators(act8931, pdata);
 574                 if (ret < 0)
 575                         goto err;
 576         } else
 577                 dev_warn(act8931->dev, "No platform init data supplied\n");
 578
 579         pdata->set_init(act8931);
 580
 581         return 0;
 582
 583 err:
 584         return ret;
 585
 586 }
 587
 588 static int __devexit act8931_i2c_remove(struct i2c_client *i2c)
 589 {
 590         struct act8931 *act8931 = i2c_get_clientdata(i2c);
 591         int i;
 592
 593         for (i = 0; i < act8931->num_regulators; i++)
 594                 if (act8931->rdev[i])
 595                         regulator_unregister(act8931->rdev[i]);
 596         kfree(act8931->rdev);
 597         i2c_set_clientdata(i2c, NULL);
 598         kfree(act8931);
 599
 600         return 0;
 601 }
 602
 603 static const struct i2c_device_id act8931_i2c_id[] = {
 604        { "act8931", 0 },
 605        { }
 606 };
 607
 608 MODULE_DEVICE_TABLE(i2c, act8931_i2c_id);
 609
 610 static struct i2c_driver act8931_i2c_driver = {
 611         .driver = {
 612                 .name = "act8931",
 613                 .owner = THIS_MODULE,
 614         },
 615         .probe    = act8931_i2c_probe,
 616         .remove   = __devexit_p(act8931_i2c_remove),
 617         .id_table = act8931_i2c_id,
 618 };
 619
 620 static int __init act8931_module_init(void)
 621 {
 622         int ret;
 623         ret = i2c_add_driver(&act8931_i2c_driver);
 624         if (ret != 0)
 625                 pr_err("Failed to register I2C driver: %d\n", ret);
 626         return ret;
 627 }
 628 //module_init(act8931_module_init);
 629 //subsys_initcall(act8931_module_init);
 630 //rootfs_initcall(act8931_module_init);
 631 subsys_initcall_sync(act8931_module_init);
 632
 633 static void __exit act8931_module_exit(void)
 634 {
 635         i2c_del_driver(&act8931_i2c_driver);
 636 }
 637 module_exit(act8931_module_exit);
 638
 639 MODULE_LICENSE("GPL");
 640 MODULE_AUTHOR("xhc <xhc@rock-chips.com>");
 641 MODULE_DESCRIPTION("act8931 PMIC driver");
 642
 643