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