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 return 1000 * ldo_voltage_map[index];
150 static int act8931_ldo_is_enabled(struct regulator_dev *dev)
152 struct act8931 *act8931 = rdev_get_drvdata(dev);
153 int ldo = rdev_get_id(dev) -ACT8931_LDO1;
156 val = act8931_reg_read(act8931, act8931_LDO_CONTR_REG(ldo));
165 static int act8931_ldo_enable(struct regulator_dev *dev)
167 struct act8931 *act8931 = rdev_get_drvdata(dev);
168 int ldo= rdev_get_id(dev) -ACT8931_LDO1;
171 return act8931_set_bits(act8931, act8931_LDO_CONTR_REG(ldo), mask, 0x80);
174 static int act8931_ldo_disable(struct regulator_dev *dev)
176 struct act8931 *act8931 = rdev_get_drvdata(dev);
177 int ldo= rdev_get_id(dev) -ACT8931_LDO1;
180 return act8931_set_bits(act8931, act8931_LDO_CONTR_REG(ldo), mask, 0);
183 static int act8931_ldo_get_voltage(struct regulator_dev *dev)
185 struct act8931 *act8931 = rdev_get_drvdata(dev);
186 int ldo= rdev_get_id(dev) -ACT8931_LDO1;
189 reg = act8931_reg_read(act8931,act8931_LDO_SET_VOL_REG(ldo));
191 val = 1000 * ldo_voltage_map[reg];
194 static int act8931_ldo_set_voltage(struct regulator_dev *dev,
195 int min_uV, int max_uV, unsigned *selector)
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;
203 if (min_vol < vol_map[VOL_MIN_IDX] ||
204 min_vol > vol_map[VOL_MAX_IDX])
207 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX;
209 if (vol_map[val] >= min_vol)
212 if (vol_map[val] > max_vol)
215 ret = act8931_set_bits(act8931, act8931_LDO_SET_VOL_REG(ldo),
220 static unsigned int act8931_ldo_get_mode(struct regulator_dev *dev)
222 struct act8931 *act8931 = rdev_get_drvdata(dev);
223 int ldo = rdev_get_id(dev) -ACT8931_LDO1 ;
226 val = act8931_reg_read(act8931, act8931_LDO_CONTR_REG(ldo));
229 return REGULATOR_MODE_NORMAL;
231 return REGULATOR_MODE_STANDBY;
234 static int act8931_ldo_set_mode(struct regulator_dev *dev, unsigned int mode)
236 struct act8931 *act8931 = rdev_get_drvdata(dev);
237 int ldo = rdev_get_id(dev) -ACT8931_LDO1 ;
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);
246 printk("error:pmu_act8931 only lowpower and nomal mode\n");
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,
264 static int act8931_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
266 return 1000 * buck_voltage_map[index];
268 static int act8931_dcdc_is_enabled(struct regulator_dev *dev)
270 struct act8931 *act8931 = rdev_get_drvdata(dev);
271 int buck = rdev_get_id(dev) -ACT8931_DCDC1;
274 val = act8931_reg_read(act8931, act8931_BUCK_CONTR_REG(buck));
283 static int act8931_dcdc_enable(struct regulator_dev *dev)
285 struct act8931 *act8931 = rdev_get_drvdata(dev);
286 int buck = rdev_get_id(dev) -ACT8931_DCDC1 ;
288 return act8931_set_bits(act8931, act8931_BUCK_CONTR_REG(buck), mask, 0x80);
291 static int act8931_dcdc_disable(struct regulator_dev *dev)
293 struct act8931 *act8931 = rdev_get_drvdata(dev);
294 int buck = rdev_get_id(dev) -ACT8931_DCDC1 ;
296 return act8931_set_bits(act8931, act8931_BUCK_CONTR_REG(buck), mask, 0);
298 static int act8931_dcdc_get_voltage(struct regulator_dev *dev)
300 struct act8931 *act8931 = rdev_get_drvdata(dev);
301 int buck = rdev_get_id(dev) -ACT8931_DCDC1 ;
304 reg = act8931_reg_read(act8931,act8931_BUCK_SET_VOL_REG(buck));
305 reg &= BUCK_VOL_MASK;
307 val = 1000 * buck_voltage_map[reg];
311 static int act8931_dcdc_set_voltage(struct regulator_dev *dev,
312 int min_uV, int max_uV, unsigned *selector)
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;
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])
326 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX;
328 if (vol_map[val] >= min_vol)
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),
335 ret = act8931_set_bits(act8931, act8931_BUCK_SET_VOL_REG(buck) + 0x01,
340 static unsigned int act8931_dcdc_get_mode(struct regulator_dev *dev)
342 struct act8931 *act8931 = rdev_get_drvdata(dev);
343 int buck = rdev_get_id(dev) -ACT8931_DCDC1 ;
346 val = act8931_reg_read(act8931, act8931_BUCK_CONTR_REG(buck));
349 return REGULATOR_MODE_STANDBY;
351 return REGULATOR_MODE_NORMAL;
354 static int act8931_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
356 struct act8931 *act8931 = rdev_get_drvdata(dev);
357 int buck = rdev_get_id(dev) -ACT8931_DCDC1 ;
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);
366 printk("error:pmu_act8931 only powersave and pwm mode\n");
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,
382 static struct regulator_desc regulators[] = {
386 .ops = &act8931_ldo_ops,
387 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
388 .type = REGULATOR_VOLTAGE,
389 .owner = THIS_MODULE,
394 .ops = &act8931_ldo_ops,
395 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
396 .type = REGULATOR_VOLTAGE,
397 .owner = THIS_MODULE,
402 .ops = &act8931_ldo_ops,
403 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
404 .type = REGULATOR_VOLTAGE,
405 .owner = THIS_MODULE,
410 .ops = &act8931_ldo_ops,
411 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
412 .type = REGULATOR_VOLTAGE,
413 .owner = THIS_MODULE,
419 .ops = &act8931_dcdc_ops,
420 .n_voltages = ARRAY_SIZE(buck_voltage_map),
421 .type = REGULATOR_VOLTAGE,
422 .owner = THIS_MODULE,
427 .ops = &act8931_dcdc_ops,
428 .n_voltages = ARRAY_SIZE(buck_voltage_map),
429 .type = REGULATOR_VOLTAGE,
430 .owner = THIS_MODULE,
435 .ops = &act8931_dcdc_ops,
436 .n_voltages = ARRAY_SIZE(buck_voltage_map),
437 .type = REGULATOR_VOLTAGE,
438 .owner = THIS_MODULE,
446 static int act8931_i2c_read(struct i2c_client *i2c, char reg, int count, u16 *dest)
449 struct i2c_adapter *adap;
450 struct i2c_msg msgs[2];
460 msgs[0].addr = i2c->addr;
462 msgs[0].flags = i2c->flags;
464 msgs[0].scl_rate = 200*1000;
466 msgs[1].buf = (u8 *)dest;
467 msgs[1].addr = i2c->addr;
468 msgs[1].flags = i2c->flags | I2C_M_RD;
470 msgs[1].scl_rate = 200*1000;
471 ret = i2c_transfer(adap, msgs, 2);
473 DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
478 static int act8931_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
482 struct i2c_adapter *adap;
495 msg.addr = i2c->addr;
496 msg.buf = &tx_buf[0];
498 msg.flags = i2c->flags;
499 msg.scl_rate = 200*1000;
501 ret = i2c_transfer(adap, &msg, 1);
505 static u8 act8931_reg_read(struct act8931 *act8931, u8 reg)
509 mutex_lock(&act8931->io_lock);
511 act8931_i2c_read(act8931->i2c, reg, 1, &val);
513 DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
515 mutex_unlock(&act8931->io_lock);
520 static int act8931_set_bits(struct act8931 *act8931, u8 reg, u16 mask, u16 val)
525 mutex_lock(&act8931->io_lock);
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;
531 ret = act8931_i2c_write(act8931->i2c, reg, 1, tmp);
532 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
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);
540 static int __devinit setup_regulators(struct act8931 *act8931, struct act8931_platform_data *pdata)
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) {
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(®ulators[id],
554 act8931->dev, pdata->regulators[i].initdata, act8931);
556 if (IS_ERR(act8931->rdev[i])) {
557 err = PTR_ERR(act8931->rdev[i]);
558 dev_err(act8931->dev, "regulator init failed: %d\n",
567 regulator_unregister(act8931->rdev[i]);
568 kfree(act8931->rdev);
569 act8931->rdev = NULL;
573 int act8931_device_shutdown(void)
577 struct act8931 *act8931 = g_act8931;
579 printk("%s\n",__func__);
581 ret = act8931_reg_read(act8931,0x01);
582 ret = act8931_set_bits(act8931, 0x01,(0x1<<5) |(0x3<<0),(0x1<<5) | (0x3<<0));
584 printk("act8931 set 0x00 error!\n");
589 EXPORT_SYMBOL_GPL(act8931_device_shutdown);
592 static irqreturn_t act8931_irq_thread(unsigned int irq, void *dev_id)
594 struct act8931 *act8931 = (struct act8931 *)dev_id;
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");
603 /* reset related regs according to spec */
604 ret = act8931_set_bits(act8931, 0x78, INSTAT_MASK | CHGSTAT_MASK,
605 INSTAT_MASK | CHGSTAT_MASK);
607 printk("act8931 set 0x78 error!\n");
610 /* FIXME: it's better that waking up screen in battery driver */
611 rk28_send_wakeup_key();
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) {}
620 static int __devinit act8931_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
622 struct act8931 *act8931;
623 struct act8931_platform_data *pdata = i2c->dev.platform_data;
626 act8931 = kzalloc(sizeof(struct act8931), GFP_KERNEL);
627 if (act8931 == NULL) {
632 act8931->dev = &i2c->dev;
633 i2c_set_clientdata(i2c, act8931);
634 mutex_init(&act8931->io_lock);
636 ret = act8931_reg_read(act8931,0x22);
637 if ((ret < 0) || (ret == 0xff)){
638 printk("The device is not act8931 \n");
643 ret = setup_regulators(act8931, pdata);
647 dev_warn(act8931->dev, "No platform init data supplied\n");
649 ret = act8931_reg_read(act8931,0x01);
652 ret = act8931_set_bits(act8931, 0x01,(0x1<<0),(0x1<<0));
654 printk("act8931 set 0x01 error!\n");
660 pdata->set_init(act8931);
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");
669 ret = act8931_set_bits(act8931, 0x78, INSTAT_MASK | CHGSTAT_MASK,
670 INSTAT_MASK | CHGSTAT_MASK);
672 printk("act8931 set 0x78 error!\n");
676 ret = act8931_set_bits(act8931, 0x79, INCON_MASK | CHGEOCIN_MASK | INDIS_MASK | CHGEOCOUT_MASK,
677 INCON_MASK | CHGEOCIN_MASK | INDIS_MASK | CHGEOCOUT_MASK);
679 printk("act8931 set 0x79 error!\n");
683 ret = gpio_request(i2c->irq, "act8931 gpio");
686 printk("act8931 gpio request fail\n");
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);
697 printk("request act8931 irq fail\n");
701 enable_irq_wake(act8931->irq);
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);
717 static int __devexit act8931_i2c_remove(struct i2c_client *i2c)
719 struct act8931 *act8931 = i2c_get_clientdata(i2c);
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);
732 static const struct i2c_device_id act8931_i2c_id[] = {
737 MODULE_DEVICE_TABLE(i2c, act8931_i2c_id);
739 static struct i2c_driver act8931_i2c_driver = {
742 .owner = THIS_MODULE,
744 .probe = act8931_i2c_probe,
745 .remove = __devexit_p(act8931_i2c_remove),
746 .id_table = act8931_i2c_id,
749 static int __init act8931_module_init(void)
752 ret = i2c_add_driver(&act8931_i2c_driver);
754 pr_err("Failed to register I2C driver: %d\n", ret);
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);
762 static void __exit act8931_module_exit(void)
764 i2c_del_driver(&act8931_i2c_driver);
766 module_exit(act8931_module_exit);
768 MODULE_LICENSE("GPL");
769 MODULE_AUTHOR("xhc <xhc@rock-chips.com>");
770 MODULE_DESCRIPTION("act8931 PMIC driver");