drivers/regulator/act8891.c

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