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