2 * Regulator driver for Active-semi act8931 PMIC chip for rk29xx
4 * Copyright (C) 2010, 2011 ROCKCHIP, Inc.
6 * Based on act8891.c that is work by zhangqing<zhangqing@rock-chips.com>
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.
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>
30 #define DBG(x...) printk(KERN_INFO x)
35 #define DBG_INFO(x...) printk(KERN_INFO x)
37 #define DBG_INFO(x...)
41 struct act8931 *g_act8931;
47 struct i2c_client *i2c;
49 struct regulator_dev **rdev;
50 struct early_suspend act8931_suspend;
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);
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
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
73 #define BUCK_VOL_MASK 0x3f
74 #define LDO_VOL_MASK 0x3f
76 #define VOL_MIN_IDX 0x00
77 #define VOL_MAX_IDX 0x3f
79 #define INSTAT_MASK (1<<5)
80 #define CHGSTAT_MASK (1<<4)
81 #define INDAT_MASK (1<<1)
82 #define CHGDAT_MASK (1<<0)
84 #define INCON_MASK (1<<5)
85 #define CHGEOCIN_MASK (1<<4)
86 #define INDIS_MASK (1<<1)
87 #define CHGEOCOUT_MASK (1<<0)
89 int act8931_charge_det, act8931_charge_ok;
90 EXPORT_SYMBOL(act8931_charge_det);
91 EXPORT_SYMBOL(act8931_charge_ok);
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,
98 const static int buck_contr_base_addr[] = {
99 act8931_BUCK1_CONTR_BASE,
100 act8931_BUCK2_CONTR_BASE,
101 act8931_BUCK3_CONTR_BASE,
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])
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,
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,
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])
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,
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,
146 static int act8931_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
148 if (index >= ARRAY_SIZE(ldo_voltage_map))
150 return 1000 * ldo_voltage_map[index];
152 static int act8931_ldo_is_enabled(struct regulator_dev *dev)
154 struct act8931 *act8931 = rdev_get_drvdata(dev);
155 int ldo = rdev_get_id(dev) -ACT8931_LDO1;
158 val = act8931_reg_read(act8931, act8931_LDO_CONTR_REG(ldo));
167 static int act8931_ldo_enable(struct regulator_dev *dev)
169 struct act8931 *act8931 = rdev_get_drvdata(dev);
170 int ldo= rdev_get_id(dev) -ACT8931_LDO1;
173 return act8931_set_bits(act8931, act8931_LDO_CONTR_REG(ldo), mask, 0x80);
176 static int act8931_ldo_disable(struct regulator_dev *dev)
178 struct act8931 *act8931 = rdev_get_drvdata(dev);
179 int ldo= rdev_get_id(dev) -ACT8931_LDO1;
182 return act8931_set_bits(act8931, act8931_LDO_CONTR_REG(ldo), mask, 0);
185 static int act8931_ldo_get_voltage(struct regulator_dev *dev)
187 struct act8931 *act8931 = rdev_get_drvdata(dev);
188 int ldo= rdev_get_id(dev) -ACT8931_LDO1;
191 reg = act8931_reg_read(act8931,act8931_LDO_SET_VOL_REG(ldo));
193 val = 1000 * ldo_voltage_map[reg];
196 static int act8931_ldo_set_voltage(struct regulator_dev *dev,
197 int min_uV, int max_uV, unsigned *selector)
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;
205 if (min_vol < vol_map[VOL_MIN_IDX] ||
206 min_vol > vol_map[VOL_MAX_IDX])
209 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX;
211 if (vol_map[val] >= min_vol)
214 if (vol_map[val] > max_vol)
217 ret = act8931_set_bits(act8931, act8931_LDO_SET_VOL_REG(ldo),
222 static unsigned int act8931_ldo_get_mode(struct regulator_dev *dev)
224 struct act8931 *act8931 = rdev_get_drvdata(dev);
225 int ldo = rdev_get_id(dev) -ACT8931_LDO1 ;
228 val = act8931_reg_read(act8931, act8931_LDO_CONTR_REG(ldo));
231 return REGULATOR_MODE_NORMAL;
233 return REGULATOR_MODE_STANDBY;
236 static int act8931_ldo_set_mode(struct regulator_dev *dev, unsigned int mode)
238 struct act8931 *act8931 = rdev_get_drvdata(dev);
239 int ldo = rdev_get_id(dev) -ACT8931_LDO1 ;
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);
248 printk("error:pmu_act8931 only lowpower and nomal mode\n");
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,
266 static int act8931_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
268 if (index >= ARRAY_SIZE(buck_voltage_map))
270 return 1000 * buck_voltage_map[index];
272 static int act8931_dcdc_is_enabled(struct regulator_dev *dev)
274 struct act8931 *act8931 = rdev_get_drvdata(dev);
275 int buck = rdev_get_id(dev) -ACT8931_DCDC1;
278 val = act8931_reg_read(act8931, act8931_BUCK_CONTR_REG(buck));
287 static int act8931_dcdc_enable(struct regulator_dev *dev)
289 struct act8931 *act8931 = rdev_get_drvdata(dev);
290 int buck = rdev_get_id(dev) -ACT8931_DCDC1 ;
292 return act8931_set_bits(act8931, act8931_BUCK_CONTR_REG(buck), mask, 0x80);
295 static int act8931_dcdc_disable(struct regulator_dev *dev)
297 struct act8931 *act8931 = rdev_get_drvdata(dev);
298 int buck = rdev_get_id(dev) -ACT8931_DCDC1 ;
300 return act8931_set_bits(act8931, act8931_BUCK_CONTR_REG(buck), mask, 0);
302 static int act8931_dcdc_get_voltage(struct regulator_dev *dev)
304 struct act8931 *act8931 = rdev_get_drvdata(dev);
305 int buck = rdev_get_id(dev) -ACT8931_DCDC1 ;
308 reg = act8931_reg_read(act8931,act8931_BUCK_SET_VOL_REG(buck));
309 reg &= BUCK_VOL_MASK;
311 val = 1000 * buck_voltage_map[reg];
315 static int act8931_dcdc_set_voltage(struct regulator_dev *dev,
316 int min_uV, int max_uV, unsigned *selector)
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;
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])
330 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX;
332 if (vol_map[val] >= min_vol)
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),
339 ret = act8931_set_bits(act8931, act8931_BUCK_SET_VOL_REG(buck) + 0x01,
344 static unsigned int act8931_dcdc_get_mode(struct regulator_dev *dev)
346 struct act8931 *act8931 = rdev_get_drvdata(dev);
347 int buck = rdev_get_id(dev) -ACT8931_DCDC1 ;
350 val = act8931_reg_read(act8931, act8931_BUCK_CONTR_REG(buck));
353 return REGULATOR_MODE_STANDBY;
355 return REGULATOR_MODE_NORMAL;
358 static int act8931_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
360 struct act8931 *act8931 = rdev_get_drvdata(dev);
361 int buck = rdev_get_id(dev) -ACT8931_DCDC1 ;
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);
370 printk("error:pmu_act8931 only powersave and pwm mode\n");
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,
386 static struct regulator_desc regulators[] = {
390 .ops = &act8931_ldo_ops,
391 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
392 .type = REGULATOR_VOLTAGE,
393 .owner = THIS_MODULE,
398 .ops = &act8931_ldo_ops,
399 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
400 .type = REGULATOR_VOLTAGE,
401 .owner = THIS_MODULE,
406 .ops = &act8931_ldo_ops,
407 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
408 .type = REGULATOR_VOLTAGE,
409 .owner = THIS_MODULE,
414 .ops = &act8931_ldo_ops,
415 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
416 .type = REGULATOR_VOLTAGE,
417 .owner = THIS_MODULE,
423 .ops = &act8931_dcdc_ops,
424 .n_voltages = ARRAY_SIZE(buck_voltage_map),
425 .type = REGULATOR_VOLTAGE,
426 .owner = THIS_MODULE,
431 .ops = &act8931_dcdc_ops,
432 .n_voltages = ARRAY_SIZE(buck_voltage_map),
433 .type = REGULATOR_VOLTAGE,
434 .owner = THIS_MODULE,
439 .ops = &act8931_dcdc_ops,
440 .n_voltages = ARRAY_SIZE(buck_voltage_map),
441 .type = REGULATOR_VOLTAGE,
442 .owner = THIS_MODULE,
450 static int act8931_i2c_read(struct i2c_client *i2c, char reg, int count, u16 *dest)
453 struct i2c_adapter *adap;
454 struct i2c_msg msgs[2];
464 msgs[0].addr = i2c->addr;
466 msgs[0].flags = i2c->flags;
468 msgs[0].scl_rate = 200*1000;
470 msgs[1].buf = (u8 *)dest;
471 msgs[1].addr = i2c->addr;
472 msgs[1].flags = i2c->flags | I2C_M_RD;
474 msgs[1].scl_rate = 200*1000;
475 ret = i2c_transfer(adap, msgs, 2);
477 DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
482 static int act8931_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
486 struct i2c_adapter *adap;
499 msg.addr = i2c->addr;
500 msg.buf = &tx_buf[0];
502 msg.flags = i2c->flags;
503 msg.scl_rate = 200*1000;
505 ret = i2c_transfer(adap, &msg, 1);
509 static u8 act8931_reg_read(struct act8931 *act8931, u8 reg)
513 mutex_lock(&act8931->io_lock);
515 act8931_i2c_read(act8931->i2c, reg, 1, &val);
517 DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
519 mutex_unlock(&act8931->io_lock);
524 static int act8931_set_bits(struct act8931 *act8931, u8 reg, u16 mask, u16 val)
529 mutex_lock(&act8931->io_lock);
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;
535 ret = act8931_i2c_write(act8931->i2c, reg, 1, tmp);
536 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
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);
544 static int __devinit setup_regulators(struct act8931 *act8931, struct act8931_platform_data *pdata)
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) {
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(®ulators[id],
558 act8931->dev, pdata->regulators[i].initdata, act8931);
560 if (IS_ERR(act8931->rdev[i])) {
561 err = PTR_ERR(act8931->rdev[i]);
562 dev_err(act8931->dev, "regulator init failed: %d\n",
571 regulator_unregister(act8931->rdev[i]);
572 kfree(act8931->rdev);
573 act8931->rdev = NULL;
577 int act8931_device_shutdown(void)
581 struct act8931 *act8931 = g_act8931;
583 printk("%s\n",__func__);
585 ret = act8931_reg_read(act8931,0x01);
586 ret = act8931_set_bits(act8931, 0x01,(0x1<<5) |(0x3<<0),(0x1<<5) | (0x3<<0));
588 printk("act8931 set 0x00 error!\n");
593 EXPORT_SYMBOL_GPL(act8931_device_shutdown);
596 static irqreturn_t act8931_irq_thread(unsigned int irq, void *dev_id)
598 struct act8931 *act8931 = (struct act8931 *)dev_id;
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");
607 /* reset related regs according to spec */
608 ret = act8931_set_bits(act8931, 0x78, INSTAT_MASK | CHGSTAT_MASK,
609 INSTAT_MASK | CHGSTAT_MASK);
611 printk("act8931 set 0x78 error!\n");
614 /* FIXME: it's better that waking up screen in battery driver */
615 rk28_send_wakeup_key();
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) {}
624 static int __devinit act8931_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
626 struct act8931 *act8931;
627 struct act8931_platform_data *pdata = i2c->dev.platform_data;
630 act8931 = kzalloc(sizeof(struct act8931), GFP_KERNEL);
631 if (act8931 == NULL) {
636 act8931->dev = &i2c->dev;
637 i2c_set_clientdata(i2c, act8931);
638 mutex_init(&act8931->io_lock);
640 ret = act8931_reg_read(act8931,0x22);
641 if ((ret < 0) || (ret == 0xff)){
642 printk("The device is not act8931 \n");
647 ret = setup_regulators(act8931, pdata);
651 dev_warn(act8931->dev, "No platform init data supplied\n");
653 ret = act8931_reg_read(act8931,0x01);
656 ret = act8931_set_bits(act8931, 0x01,(0x1<<5) | (0x1<<0),(0x1<<0));
658 printk("act8931 set 0x01 error!\n");
664 pdata->set_init(act8931);
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");
673 ret = act8931_set_bits(act8931, 0x78, INSTAT_MASK | CHGSTAT_MASK,
674 INSTAT_MASK | CHGSTAT_MASK);
676 printk("act8931 set 0x78 error!\n");
680 ret = act8931_set_bits(act8931, 0x79, INCON_MASK | CHGEOCIN_MASK | INDIS_MASK | CHGEOCOUT_MASK,
681 INCON_MASK | CHGEOCIN_MASK | INDIS_MASK | CHGEOCOUT_MASK);
683 printk("act8931 set 0x79 error!\n");
687 ret = gpio_request(i2c->irq, "act8931 gpio");
690 printk("act8931 gpio request fail\n");
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);
701 printk("request act8931 irq fail\n");
705 enable_irq_wake(act8931->irq);
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);
721 static int __devexit act8931_i2c_remove(struct i2c_client *i2c)
723 struct act8931 *act8931 = i2c_get_clientdata(i2c);
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);
736 static const struct i2c_device_id act8931_i2c_id[] = {
741 MODULE_DEVICE_TABLE(i2c, act8931_i2c_id);
743 static struct i2c_driver act8931_i2c_driver = {
746 .owner = THIS_MODULE,
748 .probe = act8931_i2c_probe,
749 .remove = __devexit_p(act8931_i2c_remove),
750 .id_table = act8931_i2c_id,
753 static int __init act8931_module_init(void)
756 ret = i2c_add_driver(&act8931_i2c_driver);
758 pr_err("Failed to register I2C driver: %d\n", ret);
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);
766 static void __exit act8931_module_exit(void)
768 i2c_del_driver(&act8931_i2c_driver);
770 module_exit(act8931_module_exit);
772 MODULE_LICENSE("GPL");
773 MODULE_AUTHOR("xhc <xhc@rock-chips.com>");
774 MODULE_DESCRIPTION("act8931 PMIC driver");