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 <linux/delay.h>
21 #include <linux/slab.h>
22 #include <linux/mutex.h>
23 #ifdef CONFIG_HAS_EARLYSUSPEND
24 #include <linux/earlysuspend.h>
26 #include <linux/interrupt.h>
27 #include <linux/module.h>
28 #include <linux/of_irq.h>
29 #include <linux/of_gpio.h>
31 #include <linux/of_device.h>
32 #include <linux/regulator/of_regulator.h>
33 #include <linux/regulator/driver.h>
34 #include <linux/regulator/machine.h>
35 #include <linux/regmap.h>
38 #define DBG(x...) printk(KERN_INFO x)
43 #define DBG_INFO(x...) printk(KERN_INFO x)
45 #define DBG_INFO(x...)
52 struct i2c_client *i2c;
54 struct regulator_dev **rdev;
55 // struct early_suspend act8846_suspend;
58 int pmic_sleep_gpio; /* */
59 unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
61 struct regmap *regmap;
64 struct act8846_regulator {
66 struct regulator_desc *desc;
67 struct regulator_dev *rdev;
71 struct act8846 *g_act8846;
73 static u8 act8846_reg_read(struct act8846 *act8846, u8 reg);
74 static int act8846_set_bits(struct act8846 *act8846, u8 reg, u16 mask, u16 val);
77 #define act8846_BUCK1_SET_VOL_BASE 0x10
78 #define act8846_BUCK2_SET_VOL_BASE 0x20
79 #define act8846_BUCK3_SET_VOL_BASE 0x30
80 #define act8846_BUCK4_SET_VOL_BASE 0x40
82 #define act8846_BUCK2_SLP_VOL_BASE 0x21
83 #define act8846_BUCK3_SLP_VOL_BASE 0x31
84 #define act8846_BUCK4_SLP_VOL_BASE 0x41
86 #define act8846_LDO1_SET_VOL_BASE 0x50
87 #define act8846_LDO2_SET_VOL_BASE 0x58
88 #define act8846_LDO3_SET_VOL_BASE 0x60
89 #define act8846_LDO4_SET_VOL_BASE 0x68
90 #define act8846_LDO5_SET_VOL_BASE 0x70
91 #define act8846_LDO6_SET_VOL_BASE 0x80
92 #define act8846_LDO7_SET_VOL_BASE 0x90
93 #define act8846_LDO8_SET_VOL_BASE 0xa0
94 //#define act8846_LDO9_SET_VOL_BASE 0xb1
96 #define act8846_BUCK1_CONTR_BASE 0x12
97 #define act8846_BUCK2_CONTR_BASE 0x22
98 #define act8846_BUCK3_CONTR_BASE 0x32
99 #define act8846_BUCK4_CONTR_BASE 0x42
101 #define act8846_LDO1_CONTR_BASE 0x51
102 #define act8846_LDO2_CONTR_BASE 0x59
103 #define act8846_LDO3_CONTR_BASE 0x61
104 #define act8846_LDO4_CONTR_BASE 0x69
105 #define act8846_LDO5_CONTR_BASE 0x71
106 #define act8846_LDO6_CONTR_BASE 0x81
107 #define act8846_LDO7_CONTR_BASE 0x91
108 #define act8846_LDO8_CONTR_BASE 0xa1
109 //#define act8846_LDO9_CONTR_BASE 0xb1
111 #define BUCK_VOL_MASK 0x3f
112 #define LDO_VOL_MASK 0x3f
114 #define VOL_MIN_IDX 0x00
115 #define VOL_MAX_IDX 0x3f
117 const static int buck_set_vol_base_addr[] = {
118 act8846_BUCK1_SET_VOL_BASE,
119 act8846_BUCK2_SET_VOL_BASE,
120 act8846_BUCK3_SET_VOL_BASE,
121 act8846_BUCK4_SET_VOL_BASE,
123 const static int buck_contr_base_addr[] = {
124 act8846_BUCK1_CONTR_BASE,
125 act8846_BUCK2_CONTR_BASE,
126 act8846_BUCK3_CONTR_BASE,
127 act8846_BUCK4_CONTR_BASE,
129 #define act8846_BUCK_SET_VOL_REG(x) (buck_set_vol_base_addr[x])
130 #define act8846_BUCK_CONTR_REG(x) (buck_contr_base_addr[x])
133 const static int ldo_set_vol_base_addr[] = {
134 act8846_LDO1_SET_VOL_BASE,
135 act8846_LDO2_SET_VOL_BASE,
136 act8846_LDO3_SET_VOL_BASE,
137 act8846_LDO4_SET_VOL_BASE,
138 act8846_LDO5_SET_VOL_BASE,
139 act8846_LDO6_SET_VOL_BASE,
140 act8846_LDO7_SET_VOL_BASE,
141 act8846_LDO8_SET_VOL_BASE,
142 // act8846_LDO9_SET_VOL_BASE,
144 const static int ldo_contr_base_addr[] = {
145 act8846_LDO1_CONTR_BASE,
146 act8846_LDO2_CONTR_BASE,
147 act8846_LDO3_CONTR_BASE,
148 act8846_LDO4_CONTR_BASE,
149 act8846_LDO5_CONTR_BASE,
150 act8846_LDO6_CONTR_BASE,
151 act8846_LDO7_CONTR_BASE,
152 act8846_LDO8_CONTR_BASE,
153 // act8846_LDO9_CONTR_BASE,
155 #define act8846_LDO_SET_VOL_REG(x) (ldo_set_vol_base_addr[x])
156 #define act8846_LDO_CONTR_REG(x) (ldo_contr_base_addr[x])
158 const static int buck_voltage_map[] = {
159 600, 625, 650, 675, 700, 725, 750, 775,
160 800, 825, 850, 875, 900, 925, 950, 975,
161 1000, 1025, 1050, 1075, 1100, 1125, 1150,
162 1175, 1200, 1250, 1300, 1350, 1400, 1450,
163 1500, 1550, 1600, 1650, 1700, 1750, 1800,
164 1850, 1900, 1950, 2000, 2050, 2100, 2150,
165 2200, 2250, 2300, 2350, 2400, 2500, 2600,
166 2700, 2800, 2900, 3000, 3100, 3200,
167 3300, 3400, 3500, 3600, 3700, 3800, 3900,
170 const static int ldo_voltage_map[] = {
171 600, 625, 650, 675, 700, 725, 750, 775,
172 800, 825, 850, 875, 900, 925, 950, 975,
173 1000, 1025, 1050, 1075, 1100, 1125, 1150,
174 1175, 1200, 1250, 1300, 1350, 1400, 1450,
175 1500, 1550, 1600, 1650, 1700, 1750, 1800,
176 1850, 1900, 1950, 2000, 2050, 2100, 2150,
177 2200, 2250, 2300, 2350, 2400, 2500, 2600,
178 2700, 2800, 2900, 3000, 3100, 3200,
179 3300, 3400, 3500, 3600, 3700, 3800, 3900,
182 static int act8846_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
184 if (index >= ARRAY_SIZE(ldo_voltage_map))
186 return 1000 * ldo_voltage_map[index];
188 static int act8846_ldo_is_enabled(struct regulator_dev *dev)
190 struct act8846 *act8846 = rdev_get_drvdata(dev);
191 int ldo = rdev_get_id(dev) - ACT8846_LDO1;
194 val = act8846_reg_read(act8846, act8846_LDO_CONTR_REG(ldo));
203 static int act8846_ldo_enable(struct regulator_dev *dev)
205 struct act8846 *act8846 = rdev_get_drvdata(dev);
206 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
209 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0x80);
212 static int act8846_ldo_disable(struct regulator_dev *dev)
214 struct act8846 *act8846 = rdev_get_drvdata(dev);
215 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
218 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0);
221 static int act8846_ldo_get_voltage(struct regulator_dev *dev)
223 struct act8846 *act8846 = rdev_get_drvdata(dev);
224 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
227 reg = act8846_reg_read(act8846,act8846_LDO_SET_VOL_REG(ldo));
229 val = 1000 * ldo_voltage_map[reg];
232 static int act8846_ldo_set_voltage(struct regulator_dev *dev,
233 int min_uV, int max_uV,unsigned *selector)
235 struct act8846 *act8846 = rdev_get_drvdata(dev);
236 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
237 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
238 const int *vol_map =ldo_voltage_map;
242 if (min_vol < vol_map[VOL_MIN_IDX] ||
243 min_vol > vol_map[VOL_MAX_IDX])
246 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
247 if (vol_map[val] >= min_vol)
251 if (vol_map[val] > max_vol)
254 ret = act8846_set_bits(act8846, act8846_LDO_SET_VOL_REG(ldo),
259 static unsigned int act8846_ldo_get_mode(struct regulator_dev *dev)
261 struct act8846 *act8846 = rdev_get_drvdata(dev);
262 int ldo = rdev_get_id(dev) - ACT8846_LDO1;
265 val = act8846_reg_read(act8846, act8846_LDO_CONTR_REG(ldo));
271 return REGULATOR_MODE_NORMAL;
273 return REGULATOR_MODE_STANDBY;
276 static int act8846_ldo_set_mode(struct regulator_dev *dev, unsigned int mode)
278 struct act8846 *act8846 = rdev_get_drvdata(dev);
279 int ldo = rdev_get_id(dev) - ACT8846_LDO1;
283 case REGULATOR_MODE_NORMAL:
284 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, mask);
285 case REGULATOR_MODE_STANDBY:
286 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0);
288 printk("error:pmu_act8846 only lowpower and nomal mode\n");
294 static struct regulator_ops act8846_ldo_ops = {
295 .set_voltage = act8846_ldo_set_voltage,
296 .get_voltage = act8846_ldo_get_voltage,
297 .list_voltage = act8846_ldo_list_voltage,
298 .is_enabled = act8846_ldo_is_enabled,
299 .enable = act8846_ldo_enable,
300 .disable = act8846_ldo_disable,
301 .get_mode = act8846_ldo_get_mode,
302 .set_mode = act8846_ldo_set_mode,
306 static int act8846_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
308 if (index >= ARRAY_SIZE(buck_voltage_map))
310 return 1000 * buck_voltage_map[index];
312 static int act8846_dcdc_is_enabled(struct regulator_dev *dev)
314 struct act8846 *act8846 = rdev_get_drvdata(dev);
315 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
318 val = act8846_reg_read(act8846, act8846_BUCK_CONTR_REG(buck));
327 static int act8846_dcdc_enable(struct regulator_dev *dev)
329 struct act8846 *act8846 = rdev_get_drvdata(dev);
330 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
333 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0x80);
336 static int act8846_dcdc_disable(struct regulator_dev *dev)
338 struct act8846 *act8846 = rdev_get_drvdata(dev);
339 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
341 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
343 static int act8846_dcdc_get_voltage(struct regulator_dev *dev)
345 struct act8846 *act8846 = rdev_get_drvdata(dev);
346 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
349 #ifdef CONFIG_ACT8846_SUPPORT_RESET
350 reg = act8846_reg_read(act8846,(act8846_BUCK_SET_VOL_REG(buck)+0x1));
352 reg = act8846_reg_read(act8846,act8846_BUCK_SET_VOL_REG(buck));
354 reg &= BUCK_VOL_MASK;
355 val = 1000 * buck_voltage_map[reg];
358 static int act8846_dcdc_set_voltage(struct regulator_dev *dev,
359 int min_uV, int max_uV,unsigned *selector)
361 struct act8846 *act8846 = rdev_get_drvdata(dev);
362 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
363 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
364 const int *vol_map = buck_voltage_map;
368 if (min_vol < vol_map[VOL_MIN_IDX] ||
369 min_vol > vol_map[VOL_MAX_IDX])
372 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
373 if (vol_map[val] >= min_vol)
377 if (vol_map[val] > max_vol)
378 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
380 #ifdef CONFIG_ACT8846_SUPPORT_RESET
381 ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) +0x1),BUCK_VOL_MASK, val);
383 ret = act8846_set_bits(act8846, act8846_BUCK_SET_VOL_REG(buck) ,BUCK_VOL_MASK, val);
388 static int act8846_dcdc_set_sleep_voltage(struct regulator_dev *dev,
391 struct act8846 *act8846 = rdev_get_drvdata(dev);
392 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
393 int min_vol = uV / 1000,max_vol = uV / 1000;
394 const int *vol_map = buck_voltage_map;
398 if (min_vol < vol_map[VOL_MIN_IDX] ||
399 min_vol > vol_map[VOL_MAX_IDX])
402 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
403 if (vol_map[val] >= min_vol)
407 if (vol_map[val] > max_vol)
408 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
409 #ifdef CONFIG_ACT8846_SUPPORT_RESET
410 ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) ),BUCK_VOL_MASK, val);
412 ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) +0x01),BUCK_VOL_MASK, val);
417 static unsigned int act8846_dcdc_get_mode(struct regulator_dev *dev)
419 struct act8846 *act8846 = rdev_get_drvdata(dev);
420 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
423 val = act8846_reg_read(act8846, act8846_BUCK_CONTR_REG(buck));
429 return REGULATOR_MODE_NORMAL;
431 return REGULATOR_MODE_STANDBY;
434 static int act8846_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
436 struct act8846 *act8846 = rdev_get_drvdata(dev);
437 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
442 case REGULATOR_MODE_STANDBY:
443 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
444 case REGULATOR_MODE_NORMAL:
445 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, mask);
447 printk("error:pmu_act8846 only powersave and pwm mode\n");
453 static int act8846_dcdc_set_voltage_time_sel(struct regulator_dev *dev, unsigned int old_selector,
454 unsigned int new_selector)
456 struct act8846 *act8846 = rdev_get_drvdata(dev);
457 int ret =0,old_volt, new_volt;
459 old_volt = act8846_dcdc_list_voltage(dev, old_selector);
463 new_volt = act8846_dcdc_list_voltage(dev, new_selector);
467 return DIV_ROUND_UP(abs(old_volt - new_volt)*2, 25000);
470 static struct regulator_ops act8846_dcdc_ops = {
471 .set_voltage = act8846_dcdc_set_voltage,
472 .get_voltage = act8846_dcdc_get_voltage,
473 .list_voltage= act8846_dcdc_list_voltage,
474 .is_enabled = act8846_dcdc_is_enabled,
475 .enable = act8846_dcdc_enable,
476 .disable = act8846_dcdc_disable,
477 .get_mode = act8846_dcdc_get_mode,
478 .set_mode = act8846_dcdc_set_mode,
479 .set_suspend_voltage = act8846_dcdc_set_sleep_voltage,
480 .set_voltage_time_sel = act8846_dcdc_set_voltage_time_sel,
482 static struct regulator_desc regulators[] = {
487 .ops = &act8846_dcdc_ops,
488 .n_voltages = ARRAY_SIZE(buck_voltage_map),
489 .type = REGULATOR_VOLTAGE,
490 .owner = THIS_MODULE,
495 .ops = &act8846_dcdc_ops,
496 .n_voltages = ARRAY_SIZE(buck_voltage_map),
497 .type = REGULATOR_VOLTAGE,
498 .owner = THIS_MODULE,
503 .ops = &act8846_dcdc_ops,
504 .n_voltages = ARRAY_SIZE(buck_voltage_map),
505 .type = REGULATOR_VOLTAGE,
506 .owner = THIS_MODULE,
511 .ops = &act8846_dcdc_ops,
512 .n_voltages = ARRAY_SIZE(buck_voltage_map),
513 .type = REGULATOR_VOLTAGE,
514 .owner = THIS_MODULE,
520 .ops = &act8846_ldo_ops,
521 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
522 .type = REGULATOR_VOLTAGE,
523 .owner = THIS_MODULE,
528 .ops = &act8846_ldo_ops,
529 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
530 .type = REGULATOR_VOLTAGE,
531 .owner = THIS_MODULE,
536 .ops = &act8846_ldo_ops,
537 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
538 .type = REGULATOR_VOLTAGE,
539 .owner = THIS_MODULE,
544 .ops = &act8846_ldo_ops,
545 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
546 .type = REGULATOR_VOLTAGE,
547 .owner = THIS_MODULE,
553 .ops = &act8846_ldo_ops,
554 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
555 .type = REGULATOR_VOLTAGE,
556 .owner = THIS_MODULE,
561 .ops = &act8846_ldo_ops,
562 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
563 .type = REGULATOR_VOLTAGE,
564 .owner = THIS_MODULE,
569 .ops = &act8846_ldo_ops,
570 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
571 .type = REGULATOR_VOLTAGE,
572 .owner = THIS_MODULE,
577 .ops = &act8846_ldo_ops,
578 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
579 .type = REGULATOR_VOLTAGE,
580 .owner = THIS_MODULE,
585 .ops = &act8846_ldo_ops,
586 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
587 .type = REGULATOR_VOLTAGE,
588 .owner = THIS_MODULE,
595 static int act8846_i2c_read(struct i2c_client *i2c, char reg, int count, u16 *dest)
598 struct i2c_adapter *adap;
599 struct i2c_msg msgs[2];
609 msgs[0].addr = i2c->addr;
611 msgs[0].flags = i2c->flags;
613 msgs[0].scl_rate = 200*1000;
615 msgs[1].buf = (u8 *)dest;
616 msgs[1].addr = i2c->addr;
617 msgs[1].flags = i2c->flags | I2C_M_RD;
619 msgs[1].scl_rate = 200*1000;
620 ret = i2c_transfer(adap, msgs, 2);
622 DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
627 static int act8846_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
631 struct i2c_adapter *adap;
644 msg.addr = i2c->addr;
645 msg.buf = &tx_buf[0];
647 msg.flags = i2c->flags;
648 msg.scl_rate = 200*1000;
650 ret = i2c_transfer(adap, &msg, 1);
654 static u8 act8846_reg_read(struct act8846 *act8846, u8 reg)
658 mutex_lock(&act8846->io_lock);
660 act8846_i2c_read(act8846->i2c, reg, 1, &val);
662 DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
664 mutex_unlock(&act8846->io_lock);
669 static int act8846_set_bits(struct act8846 *act8846, u8 reg, u16 mask, u16 val)
674 mutex_lock(&act8846->io_lock);
676 ret = act8846_i2c_read(act8846->i2c, reg, 1, &tmp);
677 DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
678 tmp = (tmp & ~mask) | val;
680 ret = act8846_i2c_write(act8846->i2c, reg, 1, tmp);
681 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
683 act8846_i2c_read(act8846->i2c, reg, 1, &tmp);
684 DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
685 mutex_unlock(&act8846->io_lock);
691 static struct of_device_id act8846_of_match[] = {
692 { .compatible = "act,act8846"},
695 MODULE_DEVICE_TABLE(of, act8846_of_match);
698 static struct of_regulator_match act8846_reg_matches[] = {
699 { .name = "act_dcdc1" ,.driver_data = (void *)0},
700 { .name = "act_dcdc2" ,.driver_data = (void *)1},
701 { .name = "act_dcdc3", .driver_data = (void *)2 },
702 { .name = "act_dcdc4", .driver_data = (void *)3 },
703 { .name = "act_ldo1", .driver_data = (void *)4 },
704 { .name = "act_ldo2", .driver_data = (void *)5 },
705 { .name = "act_ldo3", .driver_data = (void *)6 },
706 { .name = "act_ldo4", .driver_data = (void *)7 },
707 { .name = "act_ldo5", .driver_data = (void *)8 },
708 { .name = "act_ldo6", .driver_data = (void *)9 },
709 { .name = "act_ldo7", .driver_data = (void *)10 },
710 { .name = "act_ldo8", .driver_data = (void *)11 },
713 static struct act8846_board *act8846_parse_dt(struct act8846 *act8846)
715 // struct act8846 *act8846 = i2c->dev.parent;
716 struct act8846_board *pdata;
717 struct device_node *regs;
718 struct device_node *act8846_pmic_np;
719 int i, count,sleep_voltage_nr =1;
721 printk("%s,line=%d\n", __func__,__LINE__);
723 act8846_pmic_np = of_node_get(act8846->dev->of_node);
724 if (!act8846_pmic_np) {
725 printk("could not find pmic sub-node\n");
729 regs = of_find_node_by_name(act8846_pmic_np, "regulators");
733 count = of_regulator_match(act8846->dev, regs, act8846_reg_matches,act8846_NUM_REGULATORS);
736 if ((count < 0) || (count > act8846_NUM_REGULATORS))
739 pdata = devm_kzalloc(act8846->dev, sizeof(*pdata), GFP_KERNEL);
742 for (i = 0; i < count; i++) {
743 if (!act8846_reg_matches[i].init_data || !act8846_reg_matches[i].of_node)
745 pdata->act8846_init_data[i] = act8846_reg_matches[i].init_data;
746 pdata->of_node[i] = act8846_reg_matches[i].of_node;
748 pdata->irq = act8846->chip_irq;
749 pdata->irq_base = -1;
751 if (of_get_property(act8846_pmic_np, "act,pmic-dcdc-sleep-voltage", NULL))
752 pdata->pmic_sleep = true;
754 if (of_get_property(act8846_pmic_np, "act,pmic-ldo-sleep-voltage", NULL))
755 pdata->pmic_sleep = true;
757 gpio = of_get_named_gpio(act8846_pmic_np,"gpios", 0);
758 if (!gpio_is_valid(gpio))
759 printk("invalid gpio: %d\n",gpio);
760 pdata->pmic_sleep_gpio = gpio;
762 if (of_property_read_u32_array(act8846_pmic_np,
763 "act,pmic-dcdc-sleep-voltage",
764 pdata->dcdc_slp_voltage, sleep_voltage_nr)) {
765 printk("dcdc sleep voltages not specified\n");
770 static int act8846_dcdc_sleep_voltage_get_val(int min_uV,int buck)
772 int min_vol = min_uV / 1000, max_vol = min_uV / 1000;
773 const int *vol_map = buck_voltage_map;
776 if (min_vol < vol_map[VOL_MIN_IDX] ||
777 min_vol > vol_map[VOL_MAX_IDX])
780 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
781 if (vol_map[val] >= min_vol)
785 if (vol_map[val] > max_vol)
786 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
789 static int act8846_dts_dcdc_set_mode(unsigned int mode,int buck)
791 struct act8846 *act8846 = g_act8846;
795 case REGULATOR_MODE_STANDBY:
796 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
797 case REGULATOR_MODE_NORMAL:
798 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, mask);
800 printk("error:pmu_act8846 only powersave and pwm mode\n");
805 static struct act8846_board *act8846_parse_dt(struct i2c_client *i2c)
812 int act8846_device_shutdown(void)
816 struct act8846 *act8846 = g_act8846;
818 printk("%s\n",__func__);
820 ret = act8846_reg_read(act8846,0xc3);
821 ret = act8846_set_bits(act8846, 0xc3,(0x1<<3),(0x1<<3));
822 ret = act8846_set_bits(act8846, 0xc3,(0x1<<4),(0x1<<4));
824 printk("act8846 set 0xc3 error!\n");
829 EXPORT_SYMBOL_GPL(act8846_device_shutdown);
831 __weak void act8846_device_suspend(void) {}
832 __weak void act8846_device_resume(void) {}
834 static int act8846_suspend(struct i2c_client *i2c, pm_message_t mesg)
836 act8846_device_suspend();
840 static int act8846_resume(struct i2c_client *i2c)
842 act8846_device_resume();
846 static int act8846_suspend(struct i2c_client *i2c, pm_message_t mesg)
851 static int act8846_resume(struct i2c_client *i2c)
858 #ifdef CONFIG_HAS_EARLYSUSPEND
859 __weak void act8846_early_suspend(struct early_suspend *h) {}
860 __weak void act8846_late_resume(struct early_suspend *h) {}
863 static bool is_volatile_reg(struct device *dev, unsigned int reg)
866 if ((reg >= act8846_BUCK1_SET_VOL_BASE) && (reg <= act8846_LDO8_CONTR_BASE)) {
872 static const struct regmap_config act8846_regmap_config = {
875 .volatile_reg = is_volatile_reg,
876 .max_register = act8846_NUM_REGULATORS - 1,
877 .cache_type = REGCACHE_RBTREE,
879 static int act8846_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
881 struct act8846 *act8846;
882 struct act8846_board *pdev ;
883 const struct of_device_id *match;
884 struct regulator_config config = { };
885 struct regulator_dev *act_rdev;
886 struct regulator_init_data *reg_data;
887 const char *rail_name = NULL;
890 printk("%s,line=%d\n", __func__,__LINE__);
892 if (i2c->dev.of_node) {
893 match = of_match_device(act8846_of_match, &i2c->dev);
895 printk("Failed to find matching dt id\n");
900 act8846 = kzalloc(sizeof(struct act8846), GFP_KERNEL);
901 if (act8846 == NULL) {
906 act8846->dev = &i2c->dev;
907 i2c_set_clientdata(i2c, act8846);
910 act8846->regmap = devm_regmap_init_i2c(i2c, &act8846_regmap_config);
911 if (IS_ERR(act8846->regmap)) {
912 ret = PTR_ERR(act8846->regmap);
913 printk("regmap initialization failed: %d\n", ret);
917 mutex_init(&act8846->io_lock);
919 ret = act8846_reg_read(act8846,0x22);
920 if ((ret < 0) || (ret == 0xff)){
921 printk("The device is not act8846 %x \n",ret);
925 ret = act8846_set_bits(act8846, 0xf4,(0x1<<7),(0x0<<7));
927 printk("act8846 set 0xf4 error!\n");
931 if (act8846->dev->of_node)
932 pdev = act8846_parse_dt(act8846);
934 /******************************set sleep vol & dcdc mode******************/
936 act8846->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
937 if (act8846->pmic_sleep_gpio) {
938 ret = gpio_request(act8846->pmic_sleep_gpio, "act8846_pmic_sleep");
940 dev_err(act8846->dev,"Failed to request gpio %d with ret:""%d\n", act8846->pmic_sleep_gpio, ret);
943 gpio_direction_input(act8846->pmic_sleep_gpio);
944 ret = gpio_get_value(act8846->pmic_sleep_gpio);
945 gpio_free(act8846->pmic_sleep_gpio);
946 printk("%s: act8846_pmic_sleep=%x\n", __func__, ret);
948 for (i = 0;i <4 ; i ++){
949 act8846->dcdc_slp_voltage[i] = pdev->dcdc_slp_voltage[i];
950 if (act8846->dcdc_slp_voltage[i]){
954 #ifdef CONFIG_ACT8846_SUPPORT_RESET
955 ret = act8846_set_bits(act8846, act8846_BUCK_SET_VOL_REG(i) ,BUCK_VOL_MASK, act8846_dcdc_sleep_voltage_get_val(act8846->dcdc_slp_voltage[i],i));
957 ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(i) +0x01),BUCK_VOL_MASK, act8846_dcdc_sleep_voltage_get_val(act8846->dcdc_slp_voltage[i],i));
964 act8846->num_regulators = act8846_NUM_REGULATORS;
965 act8846->rdev = kcalloc(act8846_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
966 if (!act8846->rdev) {
969 /* Instantiate the regulators */
970 for (i = 0; i < act8846_NUM_REGULATORS; i++) {
971 reg_data = pdev->act8846_init_data[i];
974 config.dev = act8846->dev;
975 config.driver_data = act8846;
976 config.regmap = act8846->regmap;
977 if (act8846->dev->of_node)
978 config.of_node = pdev->of_node[i];
980 if (reg_data && reg_data->constraints.name)
981 rail_name = reg_data->constraints.name;
983 rail_name = regulators[i].name;
984 reg_data->supply_regulator = rail_name;
986 config.init_data =reg_data;
988 act_rdev = regulator_register(®ulators[i],&config);
989 if (IS_ERR(act_rdev)) {
990 printk("failed to register %d regulator\n",i);
993 act8846->rdev[i] = act_rdev;
997 #ifdef CONFIG_HAS_EARLYSUSPEND
998 act8846->act8846_suspend.suspend = act8846_early_suspend,
999 act8846->act8846_suspend.resume = act8846_late_resume,
1000 act8846->act8846_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 1,
1001 register_early_suspend(&act8846->act8846_suspend);
1011 static int act8846_i2c_remove(struct i2c_client *i2c)
1013 struct act8846 *act8846 = i2c_get_clientdata(i2c);
1016 for (i = 0; i < act8846->num_regulators; i++)
1017 if (act8846->rdev[i])
1018 regulator_unregister(act8846->rdev[i]);
1019 kfree(act8846->rdev);
1020 i2c_set_clientdata(i2c, NULL);
1026 static const struct i2c_device_id act8846_i2c_id[] = {
1031 MODULE_DEVICE_TABLE(i2c, act8846_i2c_id);
1033 static struct i2c_driver act8846_i2c_driver = {
1036 .owner = THIS_MODULE,
1037 .of_match_table =of_match_ptr(act8846_of_match),
1039 .probe = act8846_i2c_probe,
1040 .remove = act8846_i2c_remove,
1041 .id_table = act8846_i2c_id,
1043 .suspend = act8846_suspend,
1044 .resume = act8846_resume,
1048 static int __init act8846_module_init(void)
1051 ret = i2c_add_driver(&act8846_i2c_driver);
1053 pr_err("Failed to register I2C driver: %d\n", ret);
1056 //module_init(act8846_module_init);
1057 //subsys_initcall(act8846_module_init);
1058 //rootfs_initcall(act8846_module_init);
1059 subsys_initcall_sync(act8846_module_init);
1061 static void __exit act8846_module_exit(void)
1063 i2c_del_driver(&act8846_i2c_driver);
1065 module_exit(act8846_module_exit);
1067 MODULE_LICENSE("GPL");
1068 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1069 MODULE_DESCRIPTION("act8846 PMIC driver");