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