2 * Regulator driver for Active-semi act8846 PMIC chip for rk29xx
4 * Copyright (C) 2010, 2011 ROCKCHIP, Inc.
6 * Based on act8846.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.
14 #include <linux/bug.h>
15 #include <linux/err.h>
16 #include <linux/i2c.h>
17 #include <linux/kernel.h>
18 #include <linux/regulator/driver.h>
19 #include <linux/regulator/act8846.h>
20 #include <mach/gpio.h>
21 #include <linux/delay.h>
22 #include <mach/iomux.h>
23 #include <linux/slab.h>
26 #define DBG(x...) printk(KERN_INFO x)
31 #define DBG_INFO(x...) printk(KERN_INFO x)
33 #define DBG_INFO(x...)
40 struct i2c_client *i2c;
42 struct regulator_dev **rdev;
45 static u8 act8846_reg_read(struct act8846 *act8846, u8 reg);
46 static int act8846_set_bits(struct act8846 *act8846, u8 reg, u16 mask, u16 val);
49 #define act8846_BUCK1_SET_VOL_BASE 0x10
50 #define act8846_BUCK2_SET_VOL_BASE 0x20
51 #define act8846_BUCK3_SET_VOL_BASE 0x30
52 #define act8846_BUCK4_SET_VOL_BASE 0x40
54 #define act8846_BUCK2_SLP_VOL_BASE 0x21
55 #define act8846_BUCK3_SLP_VOL_BASE 0x31
56 #define act8846_BUCK4_SLP_VOL_BASE 0x41
58 #define act8846_LDO1_SET_VOL_BASE 0x50
59 #define act8846_LDO2_SET_VOL_BASE 0x58
60 #define act8846_LDO3_SET_VOL_BASE 0x60
61 #define act8846_LDO4_SET_VOL_BASE 0x68
62 #define act8846_LDO5_SET_VOL_BASE 0x70
63 #define act8846_LDO6_SET_VOL_BASE 0x80
64 #define act8846_LDO7_SET_VOL_BASE 0x90
65 #define act8846_LDO8_SET_VOL_BASE 0xa0
66 //#define act8846_LDO9_SET_VOL_BASE 0xb1
68 #define act8846_BUCK1_CONTR_BASE 0x12
69 #define act8846_BUCK2_CONTR_BASE 0x22
70 #define act8846_BUCK3_CONTR_BASE 0x32
71 #define act8846_BUCK4_CONTR_BASE 0x42
73 #define act8846_LDO1_CONTR_BASE 0x51
74 #define act8846_LDO2_CONTR_BASE 0x59
75 #define act8846_LDO3_CONTR_BASE 0x61
76 #define act8846_LDO4_CONTR_BASE 0x69
77 #define act8846_LDO5_CONTR_BASE 0x71
78 #define act8846_LDO6_CONTR_BASE 0x81
79 #define act8846_LDO7_CONTR_BASE 0x91
80 #define act8846_LDO8_CONTR_BASE 0xa1
81 //#define act8846_LDO9_CONTR_BASE 0xb1
83 #define BUCK_VOL_MASK 0x3f
84 #define LDO_VOL_MASK 0x3f
86 #define VOL_MIN_IDX 0x00
87 #define VOL_MAX_IDX 0x3f
89 const static int buck_set_vol_base_addr[] = {
90 act8846_BUCK1_SET_VOL_BASE,
91 act8846_BUCK2_SET_VOL_BASE,
92 act8846_BUCK3_SET_VOL_BASE,
93 act8846_BUCK4_SET_VOL_BASE,
95 const static int buck_contr_base_addr[] = {
96 act8846_BUCK1_CONTR_BASE,
97 act8846_BUCK2_CONTR_BASE,
98 act8846_BUCK3_CONTR_BASE,
99 act8846_BUCK4_CONTR_BASE,
101 #define act8846_BUCK_SET_VOL_REG(x) (buck_set_vol_base_addr[x])
102 #define act8846_BUCK_CONTR_REG(x) (buck_contr_base_addr[x])
105 const static int ldo_set_vol_base_addr[] = {
106 act8846_LDO1_SET_VOL_BASE,
107 act8846_LDO2_SET_VOL_BASE,
108 act8846_LDO3_SET_VOL_BASE,
109 act8846_LDO4_SET_VOL_BASE,
110 act8846_LDO5_SET_VOL_BASE,
111 act8846_LDO6_SET_VOL_BASE,
112 act8846_LDO7_SET_VOL_BASE,
113 act8846_LDO8_SET_VOL_BASE,
114 // act8846_LDO9_SET_VOL_BASE,
116 const static int ldo_contr_base_addr[] = {
117 act8846_LDO1_CONTR_BASE,
118 act8846_LDO2_CONTR_BASE,
119 act8846_LDO3_CONTR_BASE,
120 act8846_LDO4_CONTR_BASE,
121 act8846_LDO5_CONTR_BASE,
122 act8846_LDO6_CONTR_BASE,
123 act8846_LDO7_CONTR_BASE,
124 act8846_LDO8_CONTR_BASE,
125 // act8846_LDO9_CONTR_BASE,
127 #define act8846_LDO_SET_VOL_REG(x) (ldo_set_vol_base_addr[x])
128 #define act8846_LDO_CONTR_REG(x) (ldo_contr_base_addr[x])
130 const static int buck_voltage_map[] = {
131 600, 625, 650, 675, 700, 725, 750, 775,
132 800, 825, 850, 875, 900, 925, 950, 975,
133 1000, 1025, 1050, 1075, 1100, 1125, 1150,
134 1175, 1200, 1250, 1300, 1350, 1400, 1450,
135 1500, 1550, 1600, 1650, 1700, 1750, 1800,
136 1850, 1900, 1950, 2000, 2050, 2100, 2150,
137 2200, 2250, 2300, 2350, 2400, 2500, 2600,
138 2700, 2800, 2850, 2900, 3000, 3100, 3200,
139 3300, 3400, 3500, 3600, 3700, 3800, 3900,
142 const static int ldo_voltage_map[] = {
143 600, 625, 650, 675, 700, 725, 750, 775,
144 800, 825, 850, 875, 900, 925, 950, 975,
145 1000, 1025, 1050, 1075, 1100, 1125, 1150,
146 1175, 1200, 1250, 1300, 1350, 1400, 1450,
147 1500, 1550, 1600, 1650, 1700, 1750, 1800,
148 1850, 1900, 1950, 2000, 2050, 2100, 2150,
149 2200, 2250, 2300, 2350, 2400, 2500, 2600,
150 2700, 2800, 2850, 2900, 3000, 3100, 3200,
151 3300, 3400, 3500, 3600, 3700, 3800, 3900,
154 static int act8846_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
156 return 1000 * ldo_voltage_map[index];
158 static int act8846_ldo_is_enabled(struct regulator_dev *dev)
160 struct act8846 *act8846 = rdev_get_drvdata(dev);
161 int ldo = rdev_get_id(dev) - ACT8846_LDO1;
164 val = act8846_reg_read(act8846, act8846_LDO_CONTR_REG(ldo));
173 static int act8846_ldo_enable(struct regulator_dev *dev)
175 struct act8846 *act8846 = rdev_get_drvdata(dev);
176 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
179 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0x80);
182 static int act8846_ldo_disable(struct regulator_dev *dev)
184 struct act8846 *act8846 = rdev_get_drvdata(dev);
185 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
188 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0);
191 static int act8846_ldo_get_voltage(struct regulator_dev *dev)
193 struct act8846 *act8846 = rdev_get_drvdata(dev);
194 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
197 reg = act8846_reg_read(act8846,act8846_LDO_SET_VOL_REG(ldo));
199 val = 1000 * ldo_voltage_map[reg];
202 static int act8846_ldo_set_voltage(struct regulator_dev *dev,
203 int min_uV, int max_uV)
205 struct act8846 *act8846 = rdev_get_drvdata(dev);
206 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
207 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
208 const int *vol_map =ldo_voltage_map;
211 if (min_vol < vol_map[VOL_MIN_IDX] ||
212 min_vol > vol_map[VOL_MAX_IDX])
215 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
216 if (vol_map[val] >= min_vol)
220 if (vol_map[val] > max_vol)
223 ret = act8846_set_bits(act8846, act8846_LDO_SET_VOL_REG(ldo),
229 static int act8846_ldo_get_mode(struct regulator_dev *dev, unsigned index)
231 struct act8846 *act8846 = rdev_get_drvdata(dev);
232 int ldo = rdev_get_id(dev) - ACT8846_LDO1;
235 val = act8846_reg_read(act8846, act8846_LDO_CONTR_REG(ldo));
241 return REGULATOR_MODE_NORMAL;
243 return REGULATOR_MODE_STANDBY;
246 static int act8846_ldo_set_mode(struct regulator_dev *dev, unsigned int mode)
248 struct act8846 *act8846 = rdev_get_drvdata(dev);
249 int ldo = rdev_get_id(dev) - ACT8846_LDO1;
253 case REGULATOR_MODE_NORMAL:
254 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, mask);
255 case REGULATOR_MODE_STANDBY:
256 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0);
258 printk("error:pmu_act8846 only lowpower and nomal mode\n");
264 static struct regulator_ops act8846_ldo_ops = {
265 .set_voltage = act8846_ldo_set_voltage,
266 .get_voltage = act8846_ldo_get_voltage,
267 .list_voltage = act8846_ldo_list_voltage,
268 .is_enabled = act8846_ldo_is_enabled,
269 .enable = act8846_ldo_enable,
270 .disable = act8846_ldo_disable,
271 .get_mode = act8846_ldo_get_mode,
272 .set_mode = act8846_ldo_set_mode,
276 static int act8846_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
278 return 1000 * buck_voltage_map[index];
280 static int act8846_dcdc_is_enabled(struct regulator_dev *dev)
282 struct act8846 *act8846 = rdev_get_drvdata(dev);
283 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
286 val = act8846_reg_read(act8846, act8846_BUCK_CONTR_REG(buck));
295 static int act8846_dcdc_enable(struct regulator_dev *dev)
297 struct act8846 *act8846 = rdev_get_drvdata(dev);
298 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
300 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0x80);
303 static int act8846_dcdc_disable(struct regulator_dev *dev)
305 struct act8846 *act8846 = rdev_get_drvdata(dev);
306 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
308 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
310 static int act8846_dcdc_get_voltage(struct regulator_dev *dev)
312 struct act8846 *act8846 = rdev_get_drvdata(dev);
313 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
316 reg = act8846_reg_read(act8846,act8846_BUCK_SET_VOL_REG(buck));
317 reg &= BUCK_VOL_MASK;
319 val = 1000 * buck_voltage_map[reg];
323 static int act8846_dcdc_set_voltage(struct regulator_dev *dev,
324 int min_uV, int max_uV)
326 struct act8846 *act8846 = rdev_get_drvdata(dev);
327 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
328 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
329 const int *vol_map = buck_voltage_map;
333 DBG("%s, min_uV = %d, max_uV = %d!\n", __func__, min_uV, max_uV);
334 if (min_vol < vol_map[VOL_MIN_IDX] ||
335 min_vol > vol_map[VOL_MAX_IDX])
338 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
339 if (vol_map[val] >= min_vol)
343 if (vol_map[val] > max_vol)
344 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
345 ret = act8846_set_bits(act8846, act8846_BUCK_SET_VOL_REG(buck),
349 static int act8846_dcdc_set_sleep_voltage(struct regulator_dev *dev,
350 int min_uV, int max_uV)
352 struct act8846 *act8846 = rdev_get_drvdata(dev);
353 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
354 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
355 const int *vol_map = buck_voltage_map;
359 DBG("%s, min_uV = %d, max_uV = %d!\n", __func__, min_uV, max_uV);
360 if (min_vol < vol_map[VOL_MIN_IDX] ||
361 min_vol > vol_map[VOL_MAX_IDX])
364 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
365 if (vol_map[val] >= min_vol)
369 if (vol_map[val] > max_vol)
370 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
371 ret = act8846_set_bits(act8846, act8846_BUCK_SET_VOL_REG(buck) + 0x01,
375 static int act8846_dcdc_get_mode(struct regulator_dev *dev, unsigned index)
377 struct act8846 *act8846 = rdev_get_drvdata(dev);
378 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
381 val = act8846_reg_read(act8846, act8846_BUCK_CONTR_REG(buck));
387 return REGULATOR_MODE_NORMAL;
389 return REGULATOR_MODE_STANDBY;
392 static int act8846_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
394 struct act8846 *act8846 = rdev_get_drvdata(dev);
395 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
399 case REGULATOR_MODE_STANDBY:
400 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
401 case REGULATOR_MODE_NORMAL:
402 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, mask);
404 printk("error:pmu_act8846 only powersave and pwm mode\n");
410 static struct regulator_ops act8846_dcdc_ops = {
411 .set_voltage = act8846_dcdc_set_voltage,
412 .get_voltage = act8846_dcdc_get_voltage,
413 .list_voltage= act8846_dcdc_list_voltage,
414 .is_enabled = act8846_dcdc_is_enabled,
415 .enable = act8846_dcdc_enable,
416 .disable = act8846_dcdc_disable,
417 .get_mode = act8846_dcdc_get_mode,
418 .set_mode = act8846_dcdc_set_mode,
419 .set_suspend_voltage = act8846_dcdc_set_sleep_voltage,
421 static struct regulator_desc regulators[] = {
426 .ops = &act8846_dcdc_ops,
427 .n_voltages = ARRAY_SIZE(buck_voltage_map),
428 .type = REGULATOR_VOLTAGE,
429 .owner = THIS_MODULE,
434 .ops = &act8846_dcdc_ops,
435 .n_voltages = ARRAY_SIZE(buck_voltage_map),
436 .type = REGULATOR_VOLTAGE,
437 .owner = THIS_MODULE,
442 .ops = &act8846_dcdc_ops,
443 .n_voltages = ARRAY_SIZE(buck_voltage_map),
444 .type = REGULATOR_VOLTAGE,
445 .owner = THIS_MODULE,
450 .ops = &act8846_dcdc_ops,
451 .n_voltages = ARRAY_SIZE(buck_voltage_map),
452 .type = REGULATOR_VOLTAGE,
453 .owner = THIS_MODULE,
459 .ops = &act8846_ldo_ops,
460 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
461 .type = REGULATOR_VOLTAGE,
462 .owner = THIS_MODULE,
467 .ops = &act8846_ldo_ops,
468 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
469 .type = REGULATOR_VOLTAGE,
470 .owner = THIS_MODULE,
475 .ops = &act8846_ldo_ops,
476 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
477 .type = REGULATOR_VOLTAGE,
478 .owner = THIS_MODULE,
483 .ops = &act8846_ldo_ops,
484 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
485 .type = REGULATOR_VOLTAGE,
486 .owner = THIS_MODULE,
492 .ops = &act8846_ldo_ops,
493 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
494 .type = REGULATOR_VOLTAGE,
495 .owner = THIS_MODULE,
500 .ops = &act8846_ldo_ops,
501 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
502 .type = REGULATOR_VOLTAGE,
503 .owner = THIS_MODULE,
508 .ops = &act8846_ldo_ops,
509 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
510 .type = REGULATOR_VOLTAGE,
511 .owner = THIS_MODULE,
516 .ops = &act8846_ldo_ops,
517 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
518 .type = REGULATOR_VOLTAGE,
519 .owner = THIS_MODULE,
524 .ops = &act8846_ldo_ops,
525 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
526 .type = REGULATOR_VOLTAGE,
527 .owner = THIS_MODULE,
534 static int act8846_i2c_read(struct i2c_client *i2c, char reg, int count, u16 *dest)
537 struct i2c_adapter *adap;
538 struct i2c_msg msgs[2];
548 msgs[0].addr = i2c->addr;
550 msgs[0].flags = i2c->flags;
552 msgs[0].scl_rate = 200*1000;
555 msgs[1].addr = i2c->addr;
556 msgs[1].flags = i2c->flags | I2C_M_RD;
558 msgs[1].scl_rate = 200*1000;
559 ret = i2c_transfer(adap, msgs, 2);
561 DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
566 static int act8846_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
570 struct i2c_adapter *adap;
583 msg.addr = i2c->addr;
584 msg.buf = &tx_buf[0];
586 msg.flags = i2c->flags;
587 msg.scl_rate = 200*1000;
589 ret = i2c_transfer(adap, &msg, 1);
593 static u8 act8846_reg_read(struct act8846 *act8846, u8 reg)
597 mutex_lock(&act8846->io_lock);
599 act8846_i2c_read(act8846->i2c, reg, 1, &val);
601 DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
603 mutex_unlock(&act8846->io_lock);
608 static int act8846_set_bits(struct act8846 *act8846, u8 reg, u16 mask, u16 val)
613 mutex_lock(&act8846->io_lock);
615 ret = act8846_i2c_read(act8846->i2c, reg, 1, &tmp);
616 DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
617 tmp = (tmp & ~mask) | val;
619 ret = act8846_i2c_write(act8846->i2c, reg, 1, tmp);
620 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
622 act8846_i2c_read(act8846->i2c, reg, 1, &tmp);
623 DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
624 mutex_unlock(&act8846->io_lock);
628 static int __devinit setup_regulators(struct act8846 *act8846, struct act8846_platform_data *pdata)
632 act8846->num_regulators = pdata->num_regulators;
633 act8846->rdev = kcalloc(pdata->num_regulators,
634 sizeof(struct regulator_dev *), GFP_KERNEL);
635 if (!act8846->rdev) {
638 /* Instantiate the regulators */
639 for (i = 0; i < pdata->num_regulators; i++) {
640 int id = pdata->regulators[i].id;
641 act8846->rdev[i] = regulator_register(®ulators[id],
642 act8846->dev, pdata->regulators[i].initdata, act8846);
644 if (IS_ERR(act8846->rdev[i])) {
645 err = PTR_ERR(act8846->rdev[i]);
646 dev_err(act8846->dev, "regulator init failed: %d\n",
655 regulator_unregister(act8846->rdev[i]);
656 kfree(act8846->rdev);
657 act8846->rdev = NULL;
661 static int __devinit act8846_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
663 struct act8846 *act8846;
664 struct act8846_platform_data *pdata = i2c->dev.platform_data;
667 act8846 = kzalloc(sizeof(struct act8846), GFP_KERNEL);
668 if (act8846 == NULL) {
673 act8846->dev = &i2c->dev;
674 i2c_set_clientdata(i2c, act8846);
675 mutex_init(&act8846->io_lock);
677 ret = act8846_reg_read(act8846,0x22);
678 if ((ret < 0) || (ret == 0xff)){
679 printk("The device is not act8846 \n");
684 ret = setup_regulators(act8846, pdata);
688 dev_warn(act8846->dev, "No platform init data supplied\n");
690 pdata->set_init(act8846);
699 static int __devexit act8846_i2c_remove(struct i2c_client *i2c)
701 struct act8846 *act8846 = i2c_get_clientdata(i2c);
704 for (i = 0; i < act8846->num_regulators; i++)
705 if (act8846->rdev[i])
706 regulator_unregister(act8846->rdev[i]);
707 kfree(act8846->rdev);
708 i2c_set_clientdata(i2c, NULL);
714 static const struct i2c_device_id act8846_i2c_id[] = {
719 MODULE_DEVICE_TABLE(i2c, act8846_i2c_id);
721 static struct i2c_driver act8846_i2c_driver = {
724 .owner = THIS_MODULE,
726 .probe = act8846_i2c_probe,
727 .remove = __devexit_p(act8846_i2c_remove),
728 .id_table = act8846_i2c_id,
731 static int __init act8846_module_init(void)
734 ret = i2c_add_driver(&act8846_i2c_driver);
736 pr_err("Failed to register I2C driver: %d\n", ret);
739 //module_init(act8846_module_init);
740 //subsys_initcall(act8846_module_init);
741 //rootfs_initcall(act8846_module_init);
742 subsys_initcall_sync(act8846_module_init);
744 static void __exit act8846_module_exit(void)
746 i2c_del_driver(&act8846_i2c_driver);
748 module_exit(act8846_module_exit);
750 MODULE_LICENSE("GPL");
751 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
752 MODULE_DESCRIPTION("act8846 PMIC driver");