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 #include <linux/mfd/core.h>
24 #ifdef CONFIG_HAS_EARLYSUSPEND
25 #include <linux/earlysuspend.h>
27 #include <linux/interrupt.h>
28 #include <linux/module.h>
29 #include <linux/of_irq.h>
30 #include <linux/of_gpio.h>
32 #include <linux/of_device.h>
33 #include <linux/regulator/of_regulator.h>
34 #include <linux/regulator/driver.h>
35 #include <linux/regulator/machine.h>
36 #include <linux/regmap.h>
39 #define DBG(x...) printk(KERN_INFO x)
44 #define DBG_INFO(x...) printk(KERN_INFO x)
46 #define DBG_INFO(x...)
53 struct i2c_client *i2c;
55 struct regulator_dev **rdev;
56 // struct early_suspend act8846_suspend;
59 int pmic_sleep_gpio; /* */
60 int pmic_hold_gpio; /* */
61 unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
63 struct regmap *regmap;
66 struct act8846_regulator {
68 struct regulator_desc *desc;
69 struct regulator_dev *rdev;
73 struct act8846 *g_act8846;
75 static u8 act8846_reg_read(struct act8846 *act8846, u8 reg);
76 static int act8846_set_bits(struct act8846 *act8846, u8 reg, u16 mask, u16 val);
79 #define act8846_BUCK1_SET_VOL_BASE 0x10
80 #define act8846_BUCK2_SET_VOL_BASE 0x20
81 #define act8846_BUCK3_SET_VOL_BASE 0x30
82 #define act8846_BUCK4_SET_VOL_BASE 0x40
84 #define act8846_BUCK2_SLP_VOL_BASE 0x21
85 #define act8846_BUCK3_SLP_VOL_BASE 0x31
86 #define act8846_BUCK4_SLP_VOL_BASE 0x41
88 #define act8846_LDO1_SET_VOL_BASE 0x50
89 #define act8846_LDO2_SET_VOL_BASE 0x58
90 #define act8846_LDO3_SET_VOL_BASE 0x60
91 #define act8846_LDO4_SET_VOL_BASE 0x68
92 #define act8846_LDO5_SET_VOL_BASE 0x70
93 #define act8846_LDO6_SET_VOL_BASE 0x80
94 #define act8846_LDO7_SET_VOL_BASE 0x90
95 #define act8846_LDO8_SET_VOL_BASE 0xa0
96 //#define act8846_LDO9_SET_VOL_BASE 0xb1
98 #define act8846_BUCK1_CONTR_BASE 0x12
99 #define act8846_BUCK2_CONTR_BASE 0x22
100 #define act8846_BUCK3_CONTR_BASE 0x32
101 #define act8846_BUCK4_CONTR_BASE 0x42
103 #define act8846_LDO1_CONTR_BASE 0x51
104 #define act8846_LDO2_CONTR_BASE 0x59
105 #define act8846_LDO3_CONTR_BASE 0x61
106 #define act8846_LDO4_CONTR_BASE 0x69
107 #define act8846_LDO5_CONTR_BASE 0x71
108 #define act8846_LDO6_CONTR_BASE 0x81
109 #define act8846_LDO7_CONTR_BASE 0x91
110 #define act8846_LDO8_CONTR_BASE 0xa1
111 //#define act8846_LDO9_CONTR_BASE 0xb1
113 #define BUCK_VOL_MASK 0x3f
114 #define LDO_VOL_MASK 0x3f
116 #define VOL_MIN_IDX 0x00
117 #define VOL_MAX_IDX 0x3f
119 const static int buck_set_vol_base_addr[] = {
120 act8846_BUCK1_SET_VOL_BASE,
121 act8846_BUCK2_SET_VOL_BASE,
122 act8846_BUCK3_SET_VOL_BASE,
123 act8846_BUCK4_SET_VOL_BASE,
125 const static int buck_contr_base_addr[] = {
126 act8846_BUCK1_CONTR_BASE,
127 act8846_BUCK2_CONTR_BASE,
128 act8846_BUCK3_CONTR_BASE,
129 act8846_BUCK4_CONTR_BASE,
131 #define act8846_BUCK_SET_VOL_REG(x) (buck_set_vol_base_addr[x])
132 #define act8846_BUCK_CONTR_REG(x) (buck_contr_base_addr[x])
135 const static int ldo_set_vol_base_addr[] = {
136 act8846_LDO1_SET_VOL_BASE,
137 act8846_LDO2_SET_VOL_BASE,
138 act8846_LDO3_SET_VOL_BASE,
139 act8846_LDO4_SET_VOL_BASE,
140 act8846_LDO5_SET_VOL_BASE,
141 act8846_LDO6_SET_VOL_BASE,
142 act8846_LDO7_SET_VOL_BASE,
143 act8846_LDO8_SET_VOL_BASE,
144 // act8846_LDO9_SET_VOL_BASE,
146 const static int ldo_contr_base_addr[] = {
147 act8846_LDO1_CONTR_BASE,
148 act8846_LDO2_CONTR_BASE,
149 act8846_LDO3_CONTR_BASE,
150 act8846_LDO4_CONTR_BASE,
151 act8846_LDO5_CONTR_BASE,
152 act8846_LDO6_CONTR_BASE,
153 act8846_LDO7_CONTR_BASE,
154 act8846_LDO8_CONTR_BASE,
155 // act8846_LDO9_CONTR_BASE,
157 #define act8846_LDO_SET_VOL_REG(x) (ldo_set_vol_base_addr[x])
158 #define act8846_LDO_CONTR_REG(x) (ldo_contr_base_addr[x])
160 const static int buck_voltage_map[] = {
161 600, 625, 650, 675, 700, 725, 750, 775,
162 800, 825, 850, 875, 900, 925, 950, 975,
163 1000, 1025, 1050, 1075, 1100, 1125, 1150,
164 1175, 1200, 1250, 1300, 1350, 1400, 1450,
165 1500, 1550, 1600, 1650, 1700, 1750, 1800,
166 1850, 1900, 1950, 2000, 2050, 2100, 2150,
167 2200, 2250, 2300, 2350, 2400, 2500, 2600,
168 2700, 2800, 2900, 3000, 3100, 3200,
169 3300, 3400, 3500, 3600, 3700, 3800, 3900,
172 const static int ldo_voltage_map[] = {
173 600, 625, 650, 675, 700, 725, 750, 775,
174 800, 825, 850, 875, 900, 925, 950, 975,
175 1000, 1025, 1050, 1075, 1100, 1125, 1150,
176 1175, 1200, 1250, 1300, 1350, 1400, 1450,
177 1500, 1550, 1600, 1650, 1700, 1750, 1800,
178 1850, 1900, 1950, 2000, 2050, 2100, 2150,
179 2200, 2250, 2300, 2350, 2400, 2500, 2600,
180 2700, 2800, 2900, 3000, 3100, 3200,
181 3300, 3400, 3500, 3600, 3700, 3800, 3900,
184 static int act8846_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
186 if (index >= ARRAY_SIZE(ldo_voltage_map))
188 return 1000 * ldo_voltage_map[index];
190 static int act8846_ldo_is_enabled(struct regulator_dev *dev)
192 struct act8846 *act8846 = rdev_get_drvdata(dev);
193 int ldo = rdev_get_id(dev) - ACT8846_LDO1;
196 val = act8846_reg_read(act8846, act8846_LDO_CONTR_REG(ldo));
205 static int act8846_ldo_enable(struct regulator_dev *dev)
207 struct act8846 *act8846 = rdev_get_drvdata(dev);
208 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
211 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0x80);
214 static int act8846_ldo_disable(struct regulator_dev *dev)
216 struct act8846 *act8846 = rdev_get_drvdata(dev);
217 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
220 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0);
223 static int act8846_ldo_get_voltage(struct regulator_dev *dev)
225 struct act8846 *act8846 = rdev_get_drvdata(dev);
226 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
229 reg = act8846_reg_read(act8846,act8846_LDO_SET_VOL_REG(ldo));
231 val = 1000 * ldo_voltage_map[reg];
234 static int act8846_ldo_set_voltage(struct regulator_dev *dev,
235 int min_uV, int max_uV,unsigned *selector)
237 struct act8846 *act8846 = rdev_get_drvdata(dev);
238 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
239 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
240 const int *vol_map =ldo_voltage_map;
244 if (min_vol < vol_map[VOL_MIN_IDX] ||
245 min_vol > vol_map[VOL_MAX_IDX])
248 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
249 if (vol_map[val] >= min_vol)
253 if (vol_map[val] > max_vol)
256 ret = act8846_set_bits(act8846, act8846_LDO_SET_VOL_REG(ldo),
261 static unsigned int act8846_ldo_get_mode(struct regulator_dev *dev)
263 struct act8846 *act8846 = rdev_get_drvdata(dev);
264 int ldo = rdev_get_id(dev) - ACT8846_LDO1;
267 val = act8846_reg_read(act8846, act8846_LDO_CONTR_REG(ldo));
273 return REGULATOR_MODE_NORMAL;
275 return REGULATOR_MODE_STANDBY;
278 static int act8846_ldo_set_mode(struct regulator_dev *dev, unsigned int mode)
280 struct act8846 *act8846 = rdev_get_drvdata(dev);
281 int ldo = rdev_get_id(dev) - ACT8846_LDO1;
285 case REGULATOR_MODE_NORMAL:
286 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, mask);
287 case REGULATOR_MODE_STANDBY:
288 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0);
290 printk("error:pmu_act8846 only lowpower and nomal mode\n");
296 static struct regulator_ops act8846_ldo_ops = {
297 .set_voltage = act8846_ldo_set_voltage,
298 .get_voltage = act8846_ldo_get_voltage,
299 .list_voltage = act8846_ldo_list_voltage,
300 .is_enabled = act8846_ldo_is_enabled,
301 .enable = act8846_ldo_enable,
302 .disable = act8846_ldo_disable,
303 .get_mode = act8846_ldo_get_mode,
304 .set_mode = act8846_ldo_set_mode,
308 static int act8846_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
310 if (index >= ARRAY_SIZE(buck_voltage_map))
312 return 1000 * buck_voltage_map[index];
314 static int act8846_dcdc_is_enabled(struct regulator_dev *dev)
316 struct act8846 *act8846 = rdev_get_drvdata(dev);
317 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
320 val = act8846_reg_read(act8846, act8846_BUCK_CONTR_REG(buck));
329 static int act8846_dcdc_enable(struct regulator_dev *dev)
331 struct act8846 *act8846 = rdev_get_drvdata(dev);
332 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
335 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0x80);
338 static int act8846_dcdc_disable(struct regulator_dev *dev)
340 struct act8846 *act8846 = rdev_get_drvdata(dev);
341 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
343 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
345 static int act8846_dcdc_get_voltage(struct regulator_dev *dev)
347 struct act8846 *act8846 = rdev_get_drvdata(dev);
348 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
351 #ifdef CONFIG_ACT8846_SUPPORT_RESET
352 reg = act8846_reg_read(act8846,(act8846_BUCK_SET_VOL_REG(buck)+0x1));
354 reg = act8846_reg_read(act8846,act8846_BUCK_SET_VOL_REG(buck));
356 reg &= BUCK_VOL_MASK;
357 val = 1000 * buck_voltage_map[reg];
360 static int act8846_dcdc_set_voltage(struct regulator_dev *dev,
361 int min_uV, int max_uV,unsigned *selector)
363 struct act8846 *act8846 = rdev_get_drvdata(dev);
364 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
365 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
366 const int *vol_map = buck_voltage_map;
370 if (min_vol < vol_map[VOL_MIN_IDX] ||
371 min_vol > vol_map[VOL_MAX_IDX])
374 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
375 if (vol_map[val] >= min_vol)
379 if (vol_map[val] > max_vol)
380 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
382 #ifdef CONFIG_ACT8846_SUPPORT_RESET
383 ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) +0x1),BUCK_VOL_MASK, val);
385 ret = act8846_set_bits(act8846, act8846_BUCK_SET_VOL_REG(buck) ,BUCK_VOL_MASK, val);
389 printk("##################:set voltage error!voltage set is %d mv\n",vol_map[val]);
393 static int act8846_dcdc_set_sleep_voltage(struct regulator_dev *dev,
396 struct act8846 *act8846 = rdev_get_drvdata(dev);
397 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
398 int min_vol = uV / 1000,max_vol = uV / 1000;
399 const int *vol_map = buck_voltage_map;
403 if (min_vol < vol_map[VOL_MIN_IDX] ||
404 min_vol > vol_map[VOL_MAX_IDX])
407 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
408 if (vol_map[val] >= min_vol)
412 if (vol_map[val] > max_vol)
413 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
414 #ifdef CONFIG_ACT8846_SUPPORT_RESET
415 ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) ),BUCK_VOL_MASK, val);
417 ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) +0x01),BUCK_VOL_MASK, val);
422 static unsigned int act8846_dcdc_get_mode(struct regulator_dev *dev)
424 struct act8846 *act8846 = rdev_get_drvdata(dev);
425 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
428 val = act8846_reg_read(act8846, act8846_BUCK_CONTR_REG(buck));
434 return REGULATOR_MODE_NORMAL;
436 return REGULATOR_MODE_STANDBY;
439 static int act8846_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
441 struct act8846 *act8846 = rdev_get_drvdata(dev);
442 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
447 case REGULATOR_MODE_STANDBY:
448 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
449 case REGULATOR_MODE_NORMAL:
450 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, mask);
452 printk("error:pmu_act8846 only powersave and pwm mode\n");
458 static int act8846_dcdc_set_voltage_time_sel(struct regulator_dev *dev, unsigned int old_selector,
459 unsigned int new_selector)
461 struct act8846 *act8846 = rdev_get_drvdata(dev);
462 int ret =0,old_volt, new_volt;
464 old_volt = act8846_dcdc_list_voltage(dev, old_selector);
468 new_volt = act8846_dcdc_list_voltage(dev, new_selector);
472 return DIV_ROUND_UP(abs(old_volt - new_volt)*2, 25000);
475 static struct regulator_ops act8846_dcdc_ops = {
476 .set_voltage = act8846_dcdc_set_voltage,
477 .get_voltage = act8846_dcdc_get_voltage,
478 .list_voltage= act8846_dcdc_list_voltage,
479 .is_enabled = act8846_dcdc_is_enabled,
480 .enable = act8846_dcdc_enable,
481 .disable = act8846_dcdc_disable,
482 .get_mode = act8846_dcdc_get_mode,
483 .set_mode = act8846_dcdc_set_mode,
484 .set_suspend_voltage = act8846_dcdc_set_sleep_voltage,
485 .set_voltage_time_sel = act8846_dcdc_set_voltage_time_sel,
487 static struct regulator_desc regulators[] = {
492 .ops = &act8846_dcdc_ops,
493 .n_voltages = ARRAY_SIZE(buck_voltage_map),
494 .type = REGULATOR_VOLTAGE,
495 .owner = THIS_MODULE,
500 .ops = &act8846_dcdc_ops,
501 .n_voltages = ARRAY_SIZE(buck_voltage_map),
502 .type = REGULATOR_VOLTAGE,
503 .owner = THIS_MODULE,
508 .ops = &act8846_dcdc_ops,
509 .n_voltages = ARRAY_SIZE(buck_voltage_map),
510 .type = REGULATOR_VOLTAGE,
511 .owner = THIS_MODULE,
516 .ops = &act8846_dcdc_ops,
517 .n_voltages = ARRAY_SIZE(buck_voltage_map),
518 .type = REGULATOR_VOLTAGE,
519 .owner = THIS_MODULE,
525 .ops = &act8846_ldo_ops,
526 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
527 .type = REGULATOR_VOLTAGE,
528 .owner = THIS_MODULE,
533 .ops = &act8846_ldo_ops,
534 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
535 .type = REGULATOR_VOLTAGE,
536 .owner = THIS_MODULE,
541 .ops = &act8846_ldo_ops,
542 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
543 .type = REGULATOR_VOLTAGE,
544 .owner = THIS_MODULE,
549 .ops = &act8846_ldo_ops,
550 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
551 .type = REGULATOR_VOLTAGE,
552 .owner = THIS_MODULE,
558 .ops = &act8846_ldo_ops,
559 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
560 .type = REGULATOR_VOLTAGE,
561 .owner = THIS_MODULE,
566 .ops = &act8846_ldo_ops,
567 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
568 .type = REGULATOR_VOLTAGE,
569 .owner = THIS_MODULE,
574 .ops = &act8846_ldo_ops,
575 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
576 .type = REGULATOR_VOLTAGE,
577 .owner = THIS_MODULE,
582 .ops = &act8846_ldo_ops,
583 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
584 .type = REGULATOR_VOLTAGE,
585 .owner = THIS_MODULE,
590 .ops = &act8846_ldo_ops,
591 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
592 .type = REGULATOR_VOLTAGE,
593 .owner = THIS_MODULE,
600 static int act8846_i2c_read(struct i2c_client *i2c, char reg, int count, u16 *dest)
603 struct i2c_adapter *adap;
604 struct i2c_msg msgs[2];
614 msgs[0].addr = i2c->addr;
616 msgs[0].flags = i2c->flags;
618 msgs[0].scl_rate = 200*1000;
620 msgs[1].buf = (u8 *)dest;
621 msgs[1].addr = i2c->addr;
622 msgs[1].flags = i2c->flags | I2C_M_RD;
624 msgs[1].scl_rate = 200*1000;
625 ret = i2c_transfer(adap, msgs, 2);
627 DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
632 static int act8846_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
636 struct i2c_adapter *adap;
649 msg.addr = i2c->addr;
650 msg.buf = &tx_buf[0];
652 msg.flags = i2c->flags;
653 msg.scl_rate = 200*1000;
655 ret = i2c_transfer(adap, &msg, 1);
659 static u8 act8846_reg_read(struct act8846 *act8846, u8 reg)
664 mutex_lock(&act8846->io_lock);
666 ret = act8846_i2c_read(act8846->i2c, reg, 1, &val);
668 mutex_unlock(&act8846->io_lock);
672 DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
674 mutex_unlock(&act8846->io_lock);
679 static int act8846_set_bits(struct act8846 *act8846, u8 reg, u16 mask, u16 val)
684 mutex_lock(&act8846->io_lock);
686 ret = act8846_i2c_read(act8846->i2c, reg, 1, &tmp);
688 mutex_unlock(&act8846->io_lock);
691 DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
692 tmp = (tmp & ~mask) | val;
693 ret = act8846_i2c_write(act8846->i2c, reg, 1, tmp);
695 mutex_unlock(&act8846->io_lock);
698 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
700 ret = act8846_i2c_read(act8846->i2c, reg, 1, &tmp);
702 mutex_unlock(&act8846->io_lock);
705 DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
706 mutex_unlock(&act8846->io_lock);
712 static struct of_device_id act8846_of_match[] = {
713 { .compatible = "act,act8846"},
716 MODULE_DEVICE_TABLE(of, act8846_of_match);
719 static struct of_regulator_match act8846_reg_matches[] = {
720 { .name = "act_dcdc1" ,.driver_data = (void *)0},
721 { .name = "act_dcdc2" ,.driver_data = (void *)1},
722 { .name = "act_dcdc3", .driver_data = (void *)2 },
723 { .name = "act_dcdc4", .driver_data = (void *)3 },
724 { .name = "act_ldo1", .driver_data = (void *)4 },
725 { .name = "act_ldo2", .driver_data = (void *)5 },
726 { .name = "act_ldo3", .driver_data = (void *)6 },
727 { .name = "act_ldo4", .driver_data = (void *)7 },
728 { .name = "act_ldo5", .driver_data = (void *)8 },
729 { .name = "act_ldo6", .driver_data = (void *)9 },
730 { .name = "act_ldo7", .driver_data = (void *)10 },
731 { .name = "act_ldo8", .driver_data = (void *)11 },
734 static struct act8846_board *act8846_parse_dt(struct act8846 *act8846)
736 // struct act8846 *act8846 = i2c->dev.parent;
737 struct act8846_board *pdata;
738 struct device_node *regs;
739 struct device_node *act8846_pmic_np;
742 printk("%s,line=%d\n", __func__,__LINE__);
744 act8846_pmic_np = of_node_get(act8846->dev->of_node);
745 if (!act8846_pmic_np) {
746 printk("could not find pmic sub-node\n");
750 regs = of_find_node_by_name(act8846_pmic_np, "regulators");
754 count = of_regulator_match(act8846->dev, regs, act8846_reg_matches,act8846_NUM_REGULATORS);
757 if ((count < 0) || (count > act8846_NUM_REGULATORS))
760 pdata = devm_kzalloc(act8846->dev, sizeof(*pdata), GFP_KERNEL);
763 for (i = 0; i < count; i++) {
764 if (!act8846_reg_matches[i].init_data || !act8846_reg_matches[i].of_node)
766 pdata->act8846_init_data[i] = act8846_reg_matches[i].init_data;
767 pdata->of_node[i] = act8846_reg_matches[i].of_node;
769 pdata->irq = act8846->chip_irq;
770 pdata->irq_base = -1;
772 gpio = of_get_named_gpio(act8846_pmic_np,"gpios", 0);
773 if (!gpio_is_valid(gpio))
774 printk("invalid gpio: %d\n",gpio);
775 pdata->pmic_sleep_gpio = gpio;
776 pdata->pmic_sleep = true;
778 gpio = of_get_named_gpio(act8846_pmic_np,"gpios", 1);
779 if (!gpio_is_valid(gpio))
780 printk("invalid gpio: %d\n",gpio);
781 pdata->pmic_hold_gpio = gpio;
782 pdata->pm_off = of_property_read_bool(act8846_pmic_np,"act8846,system-power-controller");
788 static struct act8846_board *act8846_parse_dt(struct i2c_client *i2c)
795 int act8846_device_shutdown(void)
799 struct act8846 *act8846 = g_act8846;
801 printk("%s\n",__func__);
803 if (act8846->pmic_hold_gpio) {
804 gpio_direction_output(act8846->pmic_hold_gpio,0);
807 ret = act8846_reg_read(act8846,0xc3);
808 ret = act8846_set_bits(act8846, 0xc3,(0x1<<3),(0x1<<3));
809 ret = act8846_set_bits(act8846, 0xc3,(0x1<<4),(0x1<<4));
811 printk("act8846 set 0xc3 error!\n");
817 EXPORT_SYMBOL_GPL(act8846_device_shutdown);
819 __weak void act8846_device_suspend(void) {}
820 __weak void act8846_device_resume(void) {}
822 static int act8846_suspend(struct device *dev)
824 act8846_device_suspend();
828 static int act8846_resume(struct device *dev)
830 act8846_device_resume();
834 static int act8846_suspend(struct device *dev)
839 static int act8846_resume(struct device *dev)
846 #ifdef CONFIG_HAS_EARLYSUSPEND
847 __weak void act8846_early_suspend(struct early_suspend *h) {}
848 __weak void act8846_late_resume(struct early_suspend *h) {}
851 static bool is_volatile_reg(struct device *dev, unsigned int reg)
854 if ((reg >= act8846_BUCK1_SET_VOL_BASE) && (reg <= act8846_LDO8_CONTR_BASE)) {
860 static const struct regmap_config act8846_regmap_config = {
863 .volatile_reg = is_volatile_reg,
864 .max_register = act8846_NUM_REGULATORS - 1,
865 .cache_type = REGCACHE_RBTREE,
867 static int act8846_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
869 struct act8846 *act8846;
870 struct act8846_board *pdev ;
871 const struct of_device_id *match;
872 struct regulator_config config = { };
873 struct regulator_dev *act_rdev;
874 struct regulator_init_data *reg_data;
875 const char *rail_name = NULL;
878 printk("%s,line=%d\n", __func__,__LINE__);
880 if (i2c->dev.of_node) {
881 match = of_match_device(act8846_of_match, &i2c->dev);
883 printk("Failed to find matching dt id\n");
888 act8846 = devm_kzalloc(&i2c->dev,sizeof(struct act8846), GFP_KERNEL);
889 if (act8846 == NULL) {
894 act8846->dev = &i2c->dev;
895 i2c_set_clientdata(i2c, act8846);
898 act8846->regmap = devm_regmap_init_i2c(i2c, &act8846_regmap_config);
899 if (IS_ERR(act8846->regmap)) {
900 ret = PTR_ERR(act8846->regmap);
901 printk("regmap initialization failed: %d\n", ret);
905 mutex_init(&act8846->io_lock);
907 ret = act8846_reg_read(act8846,0x22);
908 if ((ret < 0) || (ret == 0xff)){
909 printk("The device is not act8846 %x \n",ret);
913 ret = act8846_set_bits(act8846, 0xf4,(0x1<<7),(0x0<<7));
915 printk("act8846 set 0xf4 error!\n");
919 if (act8846->dev->of_node)
920 pdev = act8846_parse_dt(act8846);
923 act8846->pmic_hold_gpio = pdev->pmic_hold_gpio;
924 if (act8846->pmic_hold_gpio) {
925 ret = gpio_request(act8846->pmic_hold_gpio, "act8846_pmic_hold");
927 dev_err(act8846->dev,"Failed to request gpio %d with ret:""%d\n", act8846->pmic_hold_gpio, ret);
930 gpio_direction_output(act8846->pmic_hold_gpio,1);
931 ret = gpio_get_value(act8846->pmic_hold_gpio);
932 // gpio_free(act8846->pmic_hold_gpio);
933 printk("%s: act8846_pmic_hold=%x\n", __func__, ret);
937 /******************************set sleep vol & dcdc mode******************/
939 act8846->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
940 if (act8846->pmic_sleep_gpio) {
941 ret = gpio_request(act8846->pmic_sleep_gpio, "act8846_pmic_sleep");
943 dev_err(act8846->dev,"Failed to request gpio %d with ret:""%d\n", act8846->pmic_sleep_gpio, ret);
946 gpio_direction_output(act8846->pmic_sleep_gpio,1);
947 ret = gpio_get_value(act8846->pmic_sleep_gpio);
948 gpio_free(act8846->pmic_sleep_gpio);
949 printk("%s: act8846_pmic_sleep=%x\n", __func__, ret);
954 act8846->num_regulators = act8846_NUM_REGULATORS;
955 act8846->rdev = kcalloc(act8846_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
956 if (!act8846->rdev) {
959 /* Instantiate the regulators */
960 for (i = 0; i < act8846_NUM_REGULATORS; i++) {
961 reg_data = pdev->act8846_init_data[i];
964 config.dev = act8846->dev;
965 config.driver_data = act8846;
966 config.regmap = act8846->regmap;
967 if (act8846->dev->of_node)
968 config.of_node = pdev->of_node[i];
970 if (reg_data && reg_data->constraints.name)
971 rail_name = reg_data->constraints.name;
973 rail_name = regulators[i].name;
974 reg_data->supply_regulator = rail_name;
976 config.init_data =reg_data;
978 act_rdev = regulator_register(®ulators[i],&config);
979 if (IS_ERR(act_rdev)) {
980 printk("failed to register %d regulator\n",i);
983 act8846->rdev[i] = act_rdev;
987 if (pdev->pm_off && !pm_power_off) {
988 pm_power_off = act8846_device_shutdown;
991 #ifdef CONFIG_HAS_EARLYSUSPEND
992 act8846->act8846_suspend.suspend = act8846_early_suspend,
993 act8846->act8846_suspend.resume = act8846_late_resume,
994 act8846->act8846_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 1,
995 register_early_suspend(&act8846->act8846_suspend);
1005 static int act8846_i2c_remove(struct i2c_client *i2c)
1007 struct act8846 *act8846 = i2c_get_clientdata(i2c);
1010 for (i = 0; i < act8846->num_regulators; i++)
1011 if (act8846->rdev[i])
1012 regulator_unregister(act8846->rdev[i]);
1013 kfree(act8846->rdev);
1014 i2c_set_clientdata(i2c, NULL);
1020 static const struct dev_pm_ops act8846_pm_ops = {
1021 .suspend = act8846_suspend,
1022 .resume = act8846_resume,
1025 static const struct i2c_device_id act8846_i2c_id[] = {
1030 MODULE_DEVICE_TABLE(i2c, act8846_i2c_id);
1032 static struct i2c_driver act8846_i2c_driver = {
1035 .owner = THIS_MODULE,
1037 .pm = &act8846_pm_ops,
1039 .of_match_table =of_match_ptr(act8846_of_match),
1041 .probe = act8846_i2c_probe,
1042 .remove = act8846_i2c_remove,
1043 .id_table = act8846_i2c_id,
1046 static int __init act8846_module_init(void)
1049 ret = i2c_add_driver(&act8846_i2c_driver);
1051 pr_err("Failed to register I2C driver: %d\n", ret);
1054 //module_init(act8846_module_init);
1055 //subsys_initcall(act8846_module_init);
1056 //rootfs_initcall(act8846_module_init);
1057 subsys_initcall_sync(act8846_module_init);
1059 static void __exit act8846_module_exit(void)
1061 i2c_del_driver(&act8846_i2c_driver);
1063 module_exit(act8846_module_exit);
1065 MODULE_LICENSE("GPL");
1066 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1067 MODULE_DESCRIPTION("act8846 PMIC driver");