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>
37 #include <asm/system_misc.h>
40 #define DBG(x...) printk(KERN_INFO x)
45 #define DBG_INFO(x...) printk(KERN_INFO x)
47 #define DBG_INFO(x...)
54 struct i2c_client *i2c;
56 struct regulator_dev **rdev;
57 #ifdef CONFIG_HAS_EARLYSUSPEND
58 struct early_suspend act8846_suspend;
62 int pmic_sleep_gpio; /* */
63 int pmic_hold_gpio; /* */
64 unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
66 struct regmap *regmap;
69 struct act8846_regulator {
71 struct regulator_desc *desc;
72 struct regulator_dev *rdev;
76 struct act8846 *g_act8846;
78 static u8 act8846_reg_read(struct act8846 *act8846, u8 reg);
79 static int act8846_set_bits(struct act8846 *act8846, u8 reg, u16 mask, u16 val);
82 #define act8846_BUCK1_SET_VOL_BASE 0x10
83 #define act8846_BUCK2_SET_VOL_BASE 0x20
84 #define act8846_BUCK3_SET_VOL_BASE 0x30
85 #define act8846_BUCK4_SET_VOL_BASE 0x40
87 #define act8846_BUCK2_SLP_VOL_BASE 0x21
88 #define act8846_BUCK3_SLP_VOL_BASE 0x31
89 #define act8846_BUCK4_SLP_VOL_BASE 0x41
91 #define act8846_LDO1_SET_VOL_BASE 0x50
92 #define act8846_LDO2_SET_VOL_BASE 0x58
93 #define act8846_LDO3_SET_VOL_BASE 0x60
94 #define act8846_LDO4_SET_VOL_BASE 0x68
95 #define act8846_LDO5_SET_VOL_BASE 0x70
96 #define act8846_LDO6_SET_VOL_BASE 0x80
97 #define act8846_LDO7_SET_VOL_BASE 0x90
98 #define act8846_LDO8_SET_VOL_BASE 0xa0
99 //#define act8846_LDO9_SET_VOL_BASE 0xb1
101 #define act8846_BUCK1_CONTR_BASE 0x12
102 #define act8846_BUCK2_CONTR_BASE 0x22
103 #define act8846_BUCK3_CONTR_BASE 0x32
104 #define act8846_BUCK4_CONTR_BASE 0x42
106 #define act8846_LDO1_CONTR_BASE 0x51
107 #define act8846_LDO2_CONTR_BASE 0x59
108 #define act8846_LDO3_CONTR_BASE 0x61
109 #define act8846_LDO4_CONTR_BASE 0x69
110 #define act8846_LDO5_CONTR_BASE 0x71
111 #define act8846_LDO6_CONTR_BASE 0x81
112 #define act8846_LDO7_CONTR_BASE 0x91
113 #define act8846_LDO8_CONTR_BASE 0xa1
114 //#define act8846_LDO9_CONTR_BASE 0xb1
116 #define BUCK_VOL_MASK 0x3f
117 #define LDO_VOL_MASK 0x3f
119 #define VOL_MIN_IDX 0x00
120 #define VOL_MAX_IDX 0x3f
122 const static int buck_set_vol_base_addr[] = {
123 act8846_BUCK1_SET_VOL_BASE,
124 act8846_BUCK2_SET_VOL_BASE,
125 act8846_BUCK3_SET_VOL_BASE,
126 act8846_BUCK4_SET_VOL_BASE,
128 const static int buck_contr_base_addr[] = {
129 act8846_BUCK1_CONTR_BASE,
130 act8846_BUCK2_CONTR_BASE,
131 act8846_BUCK3_CONTR_BASE,
132 act8846_BUCK4_CONTR_BASE,
134 #define act8846_BUCK_SET_VOL_REG(x) (buck_set_vol_base_addr[x])
135 #define act8846_BUCK_CONTR_REG(x) (buck_contr_base_addr[x])
138 const static int ldo_set_vol_base_addr[] = {
139 act8846_LDO1_SET_VOL_BASE,
140 act8846_LDO2_SET_VOL_BASE,
141 act8846_LDO3_SET_VOL_BASE,
142 act8846_LDO4_SET_VOL_BASE,
143 act8846_LDO5_SET_VOL_BASE,
144 act8846_LDO6_SET_VOL_BASE,
145 act8846_LDO7_SET_VOL_BASE,
146 act8846_LDO8_SET_VOL_BASE,
147 // act8846_LDO9_SET_VOL_BASE,
149 const static int ldo_contr_base_addr[] = {
150 act8846_LDO1_CONTR_BASE,
151 act8846_LDO2_CONTR_BASE,
152 act8846_LDO3_CONTR_BASE,
153 act8846_LDO4_CONTR_BASE,
154 act8846_LDO5_CONTR_BASE,
155 act8846_LDO6_CONTR_BASE,
156 act8846_LDO7_CONTR_BASE,
157 act8846_LDO8_CONTR_BASE,
158 // act8846_LDO9_CONTR_BASE,
160 #define act8846_LDO_SET_VOL_REG(x) (ldo_set_vol_base_addr[x])
161 #define act8846_LDO_CONTR_REG(x) (ldo_contr_base_addr[x])
163 const static int buck_voltage_map[] = {
164 600, 625, 650, 675, 700, 725, 750, 775,
165 800, 825, 850, 875, 900, 925, 950, 975,
166 1000, 1025, 1050, 1075, 1100, 1125, 1150,
167 1175, 1200, 1250, 1300, 1350, 1400, 1450,
168 1500, 1550, 1600, 1650, 1700, 1750, 1800,
169 1850, 1900, 1950, 2000, 2050, 2100, 2150,
170 2200, 2250, 2300, 2350, 2400, 2500, 2600,
171 2700, 2800, 2900, 3000, 3100, 3200,
172 3300, 3400, 3500, 3600, 3700, 3800, 3900,
175 const static int ldo_voltage_map[] = {
176 600, 625, 650, 675, 700, 725, 750, 775,
177 800, 825, 850, 875, 900, 925, 950, 975,
178 1000, 1025, 1050, 1075, 1100, 1125, 1150,
179 1175, 1200, 1250, 1300, 1350, 1400, 1450,
180 1500, 1550, 1600, 1650, 1700, 1750, 1800,
181 1850, 1900, 1950, 2000, 2050, 2100, 2150,
182 2200, 2250, 2300, 2350, 2400, 2500, 2600,
183 2700, 2800, 2900, 3000, 3100, 3200,
184 3300, 3400, 3500, 3600, 3700, 3800, 3900,
187 static int act8846_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
189 if (index >= ARRAY_SIZE(ldo_voltage_map))
191 return 1000 * ldo_voltage_map[index];
193 static int act8846_ldo_is_enabled(struct regulator_dev *dev)
195 struct act8846 *act8846 = rdev_get_drvdata(dev);
196 int ldo = rdev_get_id(dev) - ACT8846_LDO1;
199 val = act8846_reg_read(act8846, act8846_LDO_CONTR_REG(ldo));
208 static int act8846_ldo_enable(struct regulator_dev *dev)
210 struct act8846 *act8846 = rdev_get_drvdata(dev);
211 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
214 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0x80);
217 static int act8846_ldo_disable(struct regulator_dev *dev)
219 struct act8846 *act8846 = rdev_get_drvdata(dev);
220 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
223 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0);
226 static int act8846_ldo_get_voltage(struct regulator_dev *dev)
228 struct act8846 *act8846 = rdev_get_drvdata(dev);
229 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
232 reg = act8846_reg_read(act8846,act8846_LDO_SET_VOL_REG(ldo));
234 val = 1000 * ldo_voltage_map[reg];
237 static int act8846_ldo_set_voltage(struct regulator_dev *dev,
238 int min_uV, int max_uV,unsigned *selector)
240 struct act8846 *act8846 = rdev_get_drvdata(dev);
241 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
242 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
243 const int *vol_map =ldo_voltage_map;
247 if (min_vol < vol_map[VOL_MIN_IDX] ||
248 min_vol > vol_map[VOL_MAX_IDX])
251 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
252 if (vol_map[val] >= min_vol)
256 if (vol_map[val] > max_vol)
259 ret = act8846_set_bits(act8846, act8846_LDO_SET_VOL_REG(ldo),
264 static unsigned int act8846_ldo_get_mode(struct regulator_dev *dev)
266 struct act8846 *act8846 = rdev_get_drvdata(dev);
267 int ldo = rdev_get_id(dev) - ACT8846_LDO1;
270 val = act8846_reg_read(act8846, act8846_LDO_CONTR_REG(ldo));
276 return REGULATOR_MODE_NORMAL;
278 return REGULATOR_MODE_STANDBY;
281 static int act8846_ldo_set_mode(struct regulator_dev *dev, unsigned int mode)
283 struct act8846 *act8846 = rdev_get_drvdata(dev);
284 int ldo = rdev_get_id(dev) - ACT8846_LDO1;
288 case REGULATOR_MODE_NORMAL:
289 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, mask);
290 case REGULATOR_MODE_STANDBY:
291 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0);
293 printk("error:pmu_act8846 only lowpower and nomal mode\n");
299 static struct regulator_ops act8846_ldo_ops = {
300 .set_voltage = act8846_ldo_set_voltage,
301 .get_voltage = act8846_ldo_get_voltage,
302 .list_voltage = act8846_ldo_list_voltage,
303 .is_enabled = act8846_ldo_is_enabled,
304 .enable = act8846_ldo_enable,
305 .disable = act8846_ldo_disable,
306 .get_mode = act8846_ldo_get_mode,
307 .set_mode = act8846_ldo_set_mode,
311 static int act8846_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
313 if (index >= ARRAY_SIZE(buck_voltage_map))
315 return 1000 * buck_voltage_map[index];
317 static int act8846_dcdc_is_enabled(struct regulator_dev *dev)
319 struct act8846 *act8846 = rdev_get_drvdata(dev);
320 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
323 val = act8846_reg_read(act8846, act8846_BUCK_CONTR_REG(buck));
332 static int act8846_dcdc_enable(struct regulator_dev *dev)
334 struct act8846 *act8846 = rdev_get_drvdata(dev);
335 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
338 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0x80);
341 static int act8846_dcdc_disable(struct regulator_dev *dev)
343 struct act8846 *act8846 = rdev_get_drvdata(dev);
344 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
346 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
348 static int act8846_dcdc_get_voltage(struct regulator_dev *dev)
350 struct act8846 *act8846 = rdev_get_drvdata(dev);
351 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
354 #ifdef CONFIG_ACT8846_SUPPORT_RESET
355 reg = act8846_reg_read(act8846,(act8846_BUCK_SET_VOL_REG(buck)+0x1));
357 reg = act8846_reg_read(act8846,act8846_BUCK_SET_VOL_REG(buck));
359 reg &= BUCK_VOL_MASK;
360 val = 1000 * buck_voltage_map[reg];
363 static int act8846_dcdc_set_voltage(struct regulator_dev *dev,
364 int min_uV, int max_uV,unsigned *selector)
366 struct act8846 *act8846 = rdev_get_drvdata(dev);
367 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
368 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
369 const int *vol_map = buck_voltage_map;
373 if (min_vol < vol_map[VOL_MIN_IDX] ||
374 min_vol > vol_map[VOL_MAX_IDX])
377 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
378 if (vol_map[val] >= min_vol)
382 if (vol_map[val] > max_vol)
383 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
385 #ifdef CONFIG_ACT8846_SUPPORT_RESET
386 ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) +0x1),BUCK_VOL_MASK, val);
388 ret = act8846_set_bits(act8846, act8846_BUCK_SET_VOL_REG(buck) ,BUCK_VOL_MASK, val);
392 printk("##################:set voltage error!voltage set is %d mv\n",vol_map[val]);
396 static int act8846_dcdc_set_sleep_voltage(struct regulator_dev *dev,
399 struct act8846 *act8846 = rdev_get_drvdata(dev);
400 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
401 int min_vol = uV / 1000,max_vol = uV / 1000;
402 const int *vol_map = buck_voltage_map;
406 if (min_vol < vol_map[VOL_MIN_IDX] ||
407 min_vol > vol_map[VOL_MAX_IDX])
410 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
411 if (vol_map[val] >= min_vol)
415 if (vol_map[val] > max_vol)
416 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
417 #ifdef CONFIG_ACT8846_SUPPORT_RESET
418 ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) ),BUCK_VOL_MASK, val);
420 ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) +0x01),BUCK_VOL_MASK, val);
425 static unsigned int act8846_dcdc_get_mode(struct regulator_dev *dev)
427 struct act8846 *act8846 = rdev_get_drvdata(dev);
428 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
431 val = act8846_reg_read(act8846, act8846_BUCK_CONTR_REG(buck));
437 return REGULATOR_MODE_NORMAL;
439 return REGULATOR_MODE_STANDBY;
442 static int act8846_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
444 struct act8846 *act8846 = rdev_get_drvdata(dev);
445 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
450 case REGULATOR_MODE_STANDBY:
451 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
452 case REGULATOR_MODE_NORMAL:
453 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, mask);
455 printk("error:pmu_act8846 only powersave and pwm mode\n");
461 static int act8846_dcdc_set_voltage_time_sel(struct regulator_dev *dev, unsigned int old_selector,
462 unsigned int new_selector)
464 int old_volt, new_volt;
466 old_volt = act8846_dcdc_list_voltage(dev, old_selector);
470 new_volt = act8846_dcdc_list_voltage(dev, new_selector);
474 return DIV_ROUND_UP(abs(old_volt - new_volt)*2, 25000);
477 static struct regulator_ops act8846_dcdc_ops = {
478 .set_voltage = act8846_dcdc_set_voltage,
479 .get_voltage = act8846_dcdc_get_voltage,
480 .list_voltage= act8846_dcdc_list_voltage,
481 .is_enabled = act8846_dcdc_is_enabled,
482 .enable = act8846_dcdc_enable,
483 .disable = act8846_dcdc_disable,
484 .get_mode = act8846_dcdc_get_mode,
485 .set_mode = act8846_dcdc_set_mode,
486 .set_suspend_voltage = act8846_dcdc_set_sleep_voltage,
487 .set_voltage_time_sel = act8846_dcdc_set_voltage_time_sel,
489 static struct regulator_desc regulators[] = {
494 .ops = &act8846_dcdc_ops,
495 .n_voltages = ARRAY_SIZE(buck_voltage_map),
496 .type = REGULATOR_VOLTAGE,
497 .owner = THIS_MODULE,
502 .ops = &act8846_dcdc_ops,
503 .n_voltages = ARRAY_SIZE(buck_voltage_map),
504 .type = REGULATOR_VOLTAGE,
505 .owner = THIS_MODULE,
510 .ops = &act8846_dcdc_ops,
511 .n_voltages = ARRAY_SIZE(buck_voltage_map),
512 .type = REGULATOR_VOLTAGE,
513 .owner = THIS_MODULE,
518 .ops = &act8846_dcdc_ops,
519 .n_voltages = ARRAY_SIZE(buck_voltage_map),
520 .type = REGULATOR_VOLTAGE,
521 .owner = THIS_MODULE,
527 .ops = &act8846_ldo_ops,
528 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
529 .type = REGULATOR_VOLTAGE,
530 .owner = THIS_MODULE,
535 .ops = &act8846_ldo_ops,
536 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
537 .type = REGULATOR_VOLTAGE,
538 .owner = THIS_MODULE,
543 .ops = &act8846_ldo_ops,
544 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
545 .type = REGULATOR_VOLTAGE,
546 .owner = THIS_MODULE,
551 .ops = &act8846_ldo_ops,
552 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
553 .type = REGULATOR_VOLTAGE,
554 .owner = THIS_MODULE,
560 .ops = &act8846_ldo_ops,
561 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
562 .type = REGULATOR_VOLTAGE,
563 .owner = THIS_MODULE,
568 .ops = &act8846_ldo_ops,
569 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
570 .type = REGULATOR_VOLTAGE,
571 .owner = THIS_MODULE,
576 .ops = &act8846_ldo_ops,
577 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
578 .type = REGULATOR_VOLTAGE,
579 .owner = THIS_MODULE,
584 .ops = &act8846_ldo_ops,
585 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
586 .type = REGULATOR_VOLTAGE,
587 .owner = THIS_MODULE,
592 .ops = &act8846_ldo_ops,
593 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
594 .type = REGULATOR_VOLTAGE,
595 .owner = THIS_MODULE,
602 static int act8846_i2c_read(struct i2c_client *i2c, char reg, int count, u16 *dest)
605 struct i2c_adapter *adap;
606 struct i2c_msg msgs[2];
616 msgs[0].addr = i2c->addr;
618 msgs[0].flags = i2c->flags;
620 msgs[0].scl_rate = 200*1000;
622 msgs[1].buf = (u8 *)dest;
623 msgs[1].addr = i2c->addr;
624 msgs[1].flags = i2c->flags | I2C_M_RD;
626 msgs[1].scl_rate = 200*1000;
627 ret = i2c_transfer(adap, msgs, 2);
629 DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
634 static int act8846_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
638 struct i2c_adapter *adap;
651 msg.addr = i2c->addr;
652 msg.buf = &tx_buf[0];
654 msg.flags = i2c->flags;
655 msg.scl_rate = 200*1000;
657 ret = i2c_transfer(adap, &msg, 1);
661 static u8 act8846_reg_read(struct act8846 *act8846, u8 reg)
666 mutex_lock(&act8846->io_lock);
668 ret = act8846_i2c_read(act8846->i2c, reg, 1, &val);
670 mutex_unlock(&act8846->io_lock);
674 DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
676 mutex_unlock(&act8846->io_lock);
681 static int act8846_set_bits(struct act8846 *act8846, u8 reg, u16 mask, u16 val)
686 mutex_lock(&act8846->io_lock);
688 ret = act8846_i2c_read(act8846->i2c, reg, 1, &tmp);
690 mutex_unlock(&act8846->io_lock);
693 DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
694 tmp = (tmp & ~mask) | val;
695 ret = act8846_i2c_write(act8846->i2c, reg, 1, tmp);
697 mutex_unlock(&act8846->io_lock);
700 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
702 ret = act8846_i2c_read(act8846->i2c, reg, 1, &tmp);
704 mutex_unlock(&act8846->io_lock);
707 DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
708 mutex_unlock(&act8846->io_lock);
714 static struct of_device_id act8846_of_match[] = {
715 { .compatible = "act,act8846"},
718 MODULE_DEVICE_TABLE(of, act8846_of_match);
721 static struct of_regulator_match act8846_reg_matches[] = {
722 { .name = "act_dcdc1" ,.driver_data = (void *)0},
723 { .name = "act_dcdc2" ,.driver_data = (void *)1},
724 { .name = "act_dcdc3", .driver_data = (void *)2 },
725 { .name = "act_dcdc4", .driver_data = (void *)3 },
726 { .name = "act_ldo1", .driver_data = (void *)4 },
727 { .name = "act_ldo2", .driver_data = (void *)5 },
728 { .name = "act_ldo3", .driver_data = (void *)6 },
729 { .name = "act_ldo4", .driver_data = (void *)7 },
730 { .name = "act_ldo5", .driver_data = (void *)8 },
731 { .name = "act_ldo6", .driver_data = (void *)9 },
732 { .name = "act_ldo7", .driver_data = (void *)10 },
733 { .name = "act_ldo8", .driver_data = (void *)11 },
736 static struct act8846_board *act8846_parse_dt(struct act8846 *act8846)
738 // struct act8846 *act8846 = i2c->dev.parent;
739 struct act8846_board *pdata;
740 struct device_node *regs;
741 struct device_node *act8846_pmic_np;
744 printk("%s,line=%d\n", __func__,__LINE__);
746 act8846_pmic_np = of_node_get(act8846->dev->of_node);
747 if (!act8846_pmic_np) {
748 printk("could not find pmic sub-node\n");
752 regs = of_find_node_by_name(act8846_pmic_np, "regulators");
756 count = of_regulator_match(act8846->dev, regs, act8846_reg_matches,act8846_NUM_REGULATORS);
759 if ((count < 0) || (count > act8846_NUM_REGULATORS))
762 pdata = devm_kzalloc(act8846->dev, sizeof(*pdata), GFP_KERNEL);
765 for (i = 0; i < count; i++) {
766 if (!act8846_reg_matches[i].init_data || !act8846_reg_matches[i].of_node)
768 pdata->act8846_init_data[i] = act8846_reg_matches[i].init_data;
769 pdata->of_node[i] = act8846_reg_matches[i].of_node;
771 pdata->irq = act8846->chip_irq;
772 pdata->irq_base = -1;
774 gpio = of_get_named_gpio(act8846_pmic_np,"gpios", 0);
775 if (!gpio_is_valid(gpio))
776 printk("invalid gpio: %d\n",gpio);
777 pdata->pmic_sleep_gpio = gpio;
778 pdata->pmic_sleep = true;
780 gpio = of_get_named_gpio(act8846_pmic_np,"gpios", 1);
781 if (!gpio_is_valid(gpio))
782 printk("invalid gpio: %d\n",gpio);
783 pdata->pmic_hold_gpio = gpio;
784 pdata->pm_off = of_property_read_bool(act8846_pmic_np,"act8846,system-power-controller");
790 static struct act8846_board *act8846_parse_dt(struct i2c_client *i2c)
797 void 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);
806 arm_pm_restart('h', "charge");
810 ret = act8846_reg_read(act8846,0xc3);
811 ret = act8846_set_bits(act8846, 0xc3,(0x1<<3),(0x1<<3));
812 ret = act8846_set_bits(act8846, 0xc3,(0x1<<4),(0x1<<4));
814 printk("act8846 set 0xc3 error!\n");
819 EXPORT_SYMBOL_GPL(act8846_device_shutdown);
821 __weak void act8846_device_suspend(void) {}
822 __weak void act8846_device_resume(void) {}
824 static int act8846_suspend(struct device *dev)
826 act8846_device_suspend();
830 static int act8846_resume(struct device *dev)
832 act8846_device_resume();
836 static int act8846_suspend(struct device *dev)
841 static int act8846_resume(struct device *dev)
848 #ifdef CONFIG_HAS_EARLYSUSPEND
849 __weak void act8846_early_suspend(struct early_suspend *h) {}
850 __weak void act8846_late_resume(struct early_suspend *h) {}
853 static bool is_volatile_reg(struct device *dev, unsigned int reg)
856 if ((reg >= act8846_BUCK1_SET_VOL_BASE) && (reg <= act8846_LDO8_CONTR_BASE)) {
862 static const struct regmap_config act8846_regmap_config = {
865 .volatile_reg = is_volatile_reg,
866 .max_register = act8846_NUM_REGULATORS - 1,
867 .cache_type = REGCACHE_RBTREE,
869 static int act8846_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
871 struct act8846 *act8846;
872 struct act8846_board *pdev ;
873 const struct of_device_id *match;
874 struct regulator_config config = { };
875 struct regulator_dev *act_rdev;
876 struct regulator_init_data *reg_data;
877 const char *rail_name = NULL;
880 printk("%s,line=%d\n", __func__,__LINE__);
882 if (i2c->dev.of_node) {
883 match = of_match_device(act8846_of_match, &i2c->dev);
885 printk("Failed to find matching dt id\n");
890 act8846 = devm_kzalloc(&i2c->dev,sizeof(struct act8846), GFP_KERNEL);
891 if (act8846 == NULL) {
896 act8846->dev = &i2c->dev;
897 i2c_set_clientdata(i2c, act8846);
900 act8846->regmap = devm_regmap_init_i2c(i2c, &act8846_regmap_config);
901 if (IS_ERR(act8846->regmap)) {
902 ret = PTR_ERR(act8846->regmap);
903 printk("regmap initialization failed: %d\n", ret);
907 mutex_init(&act8846->io_lock);
909 ret = act8846_reg_read(act8846,0x22);
910 if ((ret < 0) || (ret == 0xff)){
911 printk("The device is not act8846 %x \n",ret);
915 ret = act8846_set_bits(act8846, 0xf4,(0x1<<7),(0x0<<7));
917 printk("act8846 set 0xf4 error!\n");
921 if (act8846->dev->of_node)
922 pdev = act8846_parse_dt(act8846);
925 act8846->pmic_hold_gpio = pdev->pmic_hold_gpio;
926 if (act8846->pmic_hold_gpio) {
927 ret = gpio_request(act8846->pmic_hold_gpio, "act8846_pmic_hold");
929 dev_err(act8846->dev,"Failed to request gpio %d with ret:""%d\n", act8846->pmic_hold_gpio, ret);
932 gpio_direction_output(act8846->pmic_hold_gpio,1);
933 ret = gpio_get_value(act8846->pmic_hold_gpio);
934 // gpio_free(act8846->pmic_hold_gpio);
935 printk("%s: act8846_pmic_hold=%x\n", __func__, ret);
939 /******************************set sleep vol & dcdc mode******************/
941 act8846->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
942 if (act8846->pmic_sleep_gpio) {
943 ret = gpio_request(act8846->pmic_sleep_gpio, "act8846_pmic_sleep");
945 dev_err(act8846->dev,"Failed to request gpio %d with ret:""%d\n", act8846->pmic_sleep_gpio, ret);
948 gpio_direction_output(act8846->pmic_sleep_gpio,1);
949 ret = gpio_get_value(act8846->pmic_sleep_gpio);
950 gpio_free(act8846->pmic_sleep_gpio);
951 printk("%s: act8846_pmic_sleep=%x\n", __func__, ret);
956 act8846->num_regulators = act8846_NUM_REGULATORS;
957 act8846->rdev = devm_kcalloc(act8846->dev,
958 act8846_NUM_REGULATORS,
959 sizeof(struct regulator_dev *),
961 if (!act8846->rdev) {
964 /* Instantiate the regulators */
965 for (i = 0; i < act8846_NUM_REGULATORS; i++) {
966 reg_data = pdev->act8846_init_data[i];
969 config.dev = act8846->dev;
970 config.driver_data = act8846;
971 config.regmap = act8846->regmap;
972 if (act8846->dev->of_node)
973 config.of_node = pdev->of_node[i];
975 if (reg_data && reg_data->constraints.name)
976 rail_name = reg_data->constraints.name;
978 rail_name = regulators[i].name;
979 reg_data->supply_regulator = rail_name;
981 config.init_data =reg_data;
983 act_rdev = regulator_register(®ulators[i],&config);
984 if (IS_ERR(act_rdev)) {
985 printk("failed to register %d regulator\n",i);
988 act8846->rdev[i] = act_rdev;
992 if (pdev->pm_off && !pm_power_off) {
993 pm_power_off = act8846_device_shutdown;
996 #ifdef CONFIG_HAS_EARLYSUSPEND
997 act8846->act8846_suspend.suspend = act8846_early_suspend,
998 act8846->act8846_suspend.resume = act8846_late_resume,
999 act8846->act8846_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 1,
1000 register_early_suspend(&act8846->act8846_suspend);
1010 static int act8846_i2c_remove(struct i2c_client *i2c)
1012 struct act8846 *act8846 = i2c_get_clientdata(i2c);
1015 for (i = 0; i < act8846->num_regulators; i++)
1016 if (act8846->rdev[i])
1017 regulator_unregister(act8846->rdev[i]);
1018 i2c_set_clientdata(i2c, NULL);
1023 static const struct dev_pm_ops act8846_pm_ops = {
1024 .suspend = act8846_suspend,
1025 .resume = act8846_resume,
1028 static const struct i2c_device_id act8846_i2c_id[] = {
1033 MODULE_DEVICE_TABLE(i2c, act8846_i2c_id);
1035 static struct i2c_driver act8846_i2c_driver = {
1038 .owner = THIS_MODULE,
1040 .pm = &act8846_pm_ops,
1042 .of_match_table =of_match_ptr(act8846_of_match),
1044 .probe = act8846_i2c_probe,
1045 .remove = act8846_i2c_remove,
1046 .id_table = act8846_i2c_id,
1049 static int __init act8846_module_init(void)
1052 ret = i2c_add_driver(&act8846_i2c_driver);
1054 pr_err("Failed to register I2C driver: %d\n", ret);
1057 //module_init(act8846_module_init);
1058 //subsys_initcall(act8846_module_init);
1059 //rootfs_initcall(act8846_module_init);
1060 subsys_initcall_sync(act8846_module_init);
1062 static void __exit act8846_module_exit(void)
1064 i2c_del_driver(&act8846_i2c_driver);
1066 module_exit(act8846_module_exit);
1068 MODULE_LICENSE("GPL");
1069 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1070 MODULE_DESCRIPTION("act8846 PMIC driver");