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 // struct early_suspend act8846_suspend;
60 int pmic_sleep_gpio; /* */
61 int pmic_hold_gpio; /* */
62 unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
64 struct regmap *regmap;
67 struct act8846_regulator {
69 struct regulator_desc *desc;
70 struct regulator_dev *rdev;
74 struct act8846 *g_act8846;
76 static u8 act8846_reg_read(struct act8846 *act8846, u8 reg);
77 static int act8846_set_bits(struct act8846 *act8846, u8 reg, u16 mask, u16 val);
80 #define act8846_BUCK1_SET_VOL_BASE 0x10
81 #define act8846_BUCK2_SET_VOL_BASE 0x20
82 #define act8846_BUCK3_SET_VOL_BASE 0x30
83 #define act8846_BUCK4_SET_VOL_BASE 0x40
85 #define act8846_BUCK2_SLP_VOL_BASE 0x21
86 #define act8846_BUCK3_SLP_VOL_BASE 0x31
87 #define act8846_BUCK4_SLP_VOL_BASE 0x41
89 #define act8846_LDO1_SET_VOL_BASE 0x50
90 #define act8846_LDO2_SET_VOL_BASE 0x58
91 #define act8846_LDO3_SET_VOL_BASE 0x60
92 #define act8846_LDO4_SET_VOL_BASE 0x68
93 #define act8846_LDO5_SET_VOL_BASE 0x70
94 #define act8846_LDO6_SET_VOL_BASE 0x80
95 #define act8846_LDO7_SET_VOL_BASE 0x90
96 #define act8846_LDO8_SET_VOL_BASE 0xa0
97 //#define act8846_LDO9_SET_VOL_BASE 0xb1
99 #define act8846_BUCK1_CONTR_BASE 0x12
100 #define act8846_BUCK2_CONTR_BASE 0x22
101 #define act8846_BUCK3_CONTR_BASE 0x32
102 #define act8846_BUCK4_CONTR_BASE 0x42
104 #define act8846_LDO1_CONTR_BASE 0x51
105 #define act8846_LDO2_CONTR_BASE 0x59
106 #define act8846_LDO3_CONTR_BASE 0x61
107 #define act8846_LDO4_CONTR_BASE 0x69
108 #define act8846_LDO5_CONTR_BASE 0x71
109 #define act8846_LDO6_CONTR_BASE 0x81
110 #define act8846_LDO7_CONTR_BASE 0x91
111 #define act8846_LDO8_CONTR_BASE 0xa1
112 //#define act8846_LDO9_CONTR_BASE 0xb1
114 #define BUCK_VOL_MASK 0x3f
115 #define LDO_VOL_MASK 0x3f
117 #define VOL_MIN_IDX 0x00
118 #define VOL_MAX_IDX 0x3f
120 const static int buck_set_vol_base_addr[] = {
121 act8846_BUCK1_SET_VOL_BASE,
122 act8846_BUCK2_SET_VOL_BASE,
123 act8846_BUCK3_SET_VOL_BASE,
124 act8846_BUCK4_SET_VOL_BASE,
126 const static int buck_contr_base_addr[] = {
127 act8846_BUCK1_CONTR_BASE,
128 act8846_BUCK2_CONTR_BASE,
129 act8846_BUCK3_CONTR_BASE,
130 act8846_BUCK4_CONTR_BASE,
132 #define act8846_BUCK_SET_VOL_REG(x) (buck_set_vol_base_addr[x])
133 #define act8846_BUCK_CONTR_REG(x) (buck_contr_base_addr[x])
136 const static int ldo_set_vol_base_addr[] = {
137 act8846_LDO1_SET_VOL_BASE,
138 act8846_LDO2_SET_VOL_BASE,
139 act8846_LDO3_SET_VOL_BASE,
140 act8846_LDO4_SET_VOL_BASE,
141 act8846_LDO5_SET_VOL_BASE,
142 act8846_LDO6_SET_VOL_BASE,
143 act8846_LDO7_SET_VOL_BASE,
144 act8846_LDO8_SET_VOL_BASE,
145 // act8846_LDO9_SET_VOL_BASE,
147 const static int ldo_contr_base_addr[] = {
148 act8846_LDO1_CONTR_BASE,
149 act8846_LDO2_CONTR_BASE,
150 act8846_LDO3_CONTR_BASE,
151 act8846_LDO4_CONTR_BASE,
152 act8846_LDO5_CONTR_BASE,
153 act8846_LDO6_CONTR_BASE,
154 act8846_LDO7_CONTR_BASE,
155 act8846_LDO8_CONTR_BASE,
156 // act8846_LDO9_CONTR_BASE,
158 #define act8846_LDO_SET_VOL_REG(x) (ldo_set_vol_base_addr[x])
159 #define act8846_LDO_CONTR_REG(x) (ldo_contr_base_addr[x])
161 const static int buck_voltage_map[] = {
162 600, 625, 650, 675, 700, 725, 750, 775,
163 800, 825, 850, 875, 900, 925, 950, 975,
164 1000, 1025, 1050, 1075, 1100, 1125, 1150,
165 1175, 1200, 1250, 1300, 1350, 1400, 1450,
166 1500, 1550, 1600, 1650, 1700, 1750, 1800,
167 1850, 1900, 1950, 2000, 2050, 2100, 2150,
168 2200, 2250, 2300, 2350, 2400, 2500, 2600,
169 2700, 2800, 2900, 3000, 3100, 3200,
170 3300, 3400, 3500, 3600, 3700, 3800, 3900,
173 const static int ldo_voltage_map[] = {
174 600, 625, 650, 675, 700, 725, 750, 775,
175 800, 825, 850, 875, 900, 925, 950, 975,
176 1000, 1025, 1050, 1075, 1100, 1125, 1150,
177 1175, 1200, 1250, 1300, 1350, 1400, 1450,
178 1500, 1550, 1600, 1650, 1700, 1750, 1800,
179 1850, 1900, 1950, 2000, 2050, 2100, 2150,
180 2200, 2250, 2300, 2350, 2400, 2500, 2600,
181 2700, 2800, 2900, 3000, 3100, 3200,
182 3300, 3400, 3500, 3600, 3700, 3800, 3900,
185 static int act8846_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
187 if (index >= ARRAY_SIZE(ldo_voltage_map))
189 return 1000 * ldo_voltage_map[index];
191 static int act8846_ldo_is_enabled(struct regulator_dev *dev)
193 struct act8846 *act8846 = rdev_get_drvdata(dev);
194 int ldo = rdev_get_id(dev) - ACT8846_LDO1;
197 val = act8846_reg_read(act8846, act8846_LDO_CONTR_REG(ldo));
206 static int act8846_ldo_enable(struct regulator_dev *dev)
208 struct act8846 *act8846 = rdev_get_drvdata(dev);
209 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
212 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0x80);
215 static int act8846_ldo_disable(struct regulator_dev *dev)
217 struct act8846 *act8846 = rdev_get_drvdata(dev);
218 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
221 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0);
224 static int act8846_ldo_get_voltage(struct regulator_dev *dev)
226 struct act8846 *act8846 = rdev_get_drvdata(dev);
227 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
230 reg = act8846_reg_read(act8846,act8846_LDO_SET_VOL_REG(ldo));
232 val = 1000 * ldo_voltage_map[reg];
235 static int act8846_ldo_set_voltage(struct regulator_dev *dev,
236 int min_uV, int max_uV,unsigned *selector)
238 struct act8846 *act8846 = rdev_get_drvdata(dev);
239 int ldo= rdev_get_id(dev) - ACT8846_LDO1;
240 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
241 const int *vol_map =ldo_voltage_map;
245 if (min_vol < vol_map[VOL_MIN_IDX] ||
246 min_vol > vol_map[VOL_MAX_IDX])
249 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
250 if (vol_map[val] >= min_vol)
254 if (vol_map[val] > max_vol)
257 ret = act8846_set_bits(act8846, act8846_LDO_SET_VOL_REG(ldo),
262 static unsigned int act8846_ldo_get_mode(struct regulator_dev *dev)
264 struct act8846 *act8846 = rdev_get_drvdata(dev);
265 int ldo = rdev_get_id(dev) - ACT8846_LDO1;
268 val = act8846_reg_read(act8846, act8846_LDO_CONTR_REG(ldo));
274 return REGULATOR_MODE_NORMAL;
276 return REGULATOR_MODE_STANDBY;
279 static int act8846_ldo_set_mode(struct regulator_dev *dev, unsigned int mode)
281 struct act8846 *act8846 = rdev_get_drvdata(dev);
282 int ldo = rdev_get_id(dev) - ACT8846_LDO1;
286 case REGULATOR_MODE_NORMAL:
287 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, mask);
288 case REGULATOR_MODE_STANDBY:
289 return act8846_set_bits(act8846, act8846_LDO_CONTR_REG(ldo), mask, 0);
291 printk("error:pmu_act8846 only lowpower and nomal mode\n");
297 static struct regulator_ops act8846_ldo_ops = {
298 .set_voltage = act8846_ldo_set_voltage,
299 .get_voltage = act8846_ldo_get_voltage,
300 .list_voltage = act8846_ldo_list_voltage,
301 .is_enabled = act8846_ldo_is_enabled,
302 .enable = act8846_ldo_enable,
303 .disable = act8846_ldo_disable,
304 .get_mode = act8846_ldo_get_mode,
305 .set_mode = act8846_ldo_set_mode,
309 static int act8846_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
311 if (index >= ARRAY_SIZE(buck_voltage_map))
313 return 1000 * buck_voltage_map[index];
315 static int act8846_dcdc_is_enabled(struct regulator_dev *dev)
317 struct act8846 *act8846 = rdev_get_drvdata(dev);
318 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
321 val = act8846_reg_read(act8846, act8846_BUCK_CONTR_REG(buck));
330 static int act8846_dcdc_enable(struct regulator_dev *dev)
332 struct act8846 *act8846 = rdev_get_drvdata(dev);
333 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
336 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0x80);
339 static int act8846_dcdc_disable(struct regulator_dev *dev)
341 struct act8846 *act8846 = rdev_get_drvdata(dev);
342 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
344 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
346 static int act8846_dcdc_get_voltage(struct regulator_dev *dev)
348 struct act8846 *act8846 = rdev_get_drvdata(dev);
349 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
352 #ifdef CONFIG_ACT8846_SUPPORT_RESET
353 reg = act8846_reg_read(act8846,(act8846_BUCK_SET_VOL_REG(buck)+0x1));
355 reg = act8846_reg_read(act8846,act8846_BUCK_SET_VOL_REG(buck));
357 reg &= BUCK_VOL_MASK;
358 val = 1000 * buck_voltage_map[reg];
361 static int act8846_dcdc_set_voltage(struct regulator_dev *dev,
362 int min_uV, int max_uV,unsigned *selector)
364 struct act8846 *act8846 = rdev_get_drvdata(dev);
365 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
366 int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
367 const int *vol_map = buck_voltage_map;
371 if (min_vol < vol_map[VOL_MIN_IDX] ||
372 min_vol > vol_map[VOL_MAX_IDX])
375 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
376 if (vol_map[val] >= min_vol)
380 if (vol_map[val] > max_vol)
381 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
383 #ifdef CONFIG_ACT8846_SUPPORT_RESET
384 ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) +0x1),BUCK_VOL_MASK, val);
386 ret = act8846_set_bits(act8846, act8846_BUCK_SET_VOL_REG(buck) ,BUCK_VOL_MASK, val);
390 printk("##################:set voltage error!voltage set is %d mv\n",vol_map[val]);
394 static int act8846_dcdc_set_sleep_voltage(struct regulator_dev *dev,
397 struct act8846 *act8846 = rdev_get_drvdata(dev);
398 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
399 int min_vol = uV / 1000,max_vol = uV / 1000;
400 const int *vol_map = buck_voltage_map;
404 if (min_vol < vol_map[VOL_MIN_IDX] ||
405 min_vol > vol_map[VOL_MAX_IDX])
408 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
409 if (vol_map[val] >= min_vol)
413 if (vol_map[val] > max_vol)
414 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
415 #ifdef CONFIG_ACT8846_SUPPORT_RESET
416 ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) ),BUCK_VOL_MASK, val);
418 ret = act8846_set_bits(act8846, (act8846_BUCK_SET_VOL_REG(buck) +0x01),BUCK_VOL_MASK, val);
423 static unsigned int act8846_dcdc_get_mode(struct regulator_dev *dev)
425 struct act8846 *act8846 = rdev_get_drvdata(dev);
426 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
429 val = act8846_reg_read(act8846, act8846_BUCK_CONTR_REG(buck));
435 return REGULATOR_MODE_NORMAL;
437 return REGULATOR_MODE_STANDBY;
440 static int act8846_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
442 struct act8846 *act8846 = rdev_get_drvdata(dev);
443 int buck = rdev_get_id(dev) - ACT8846_DCDC1;
448 case REGULATOR_MODE_STANDBY:
449 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, 0);
450 case REGULATOR_MODE_NORMAL:
451 return act8846_set_bits(act8846, act8846_BUCK_CONTR_REG(buck), mask, mask);
453 printk("error:pmu_act8846 only powersave and pwm mode\n");
459 static int act8846_dcdc_set_voltage_time_sel(struct regulator_dev *dev, unsigned int old_selector,
460 unsigned int new_selector)
462 struct act8846 *act8846 = rdev_get_drvdata(dev);
463 int ret =0,old_volt, new_volt;
465 old_volt = act8846_dcdc_list_voltage(dev, old_selector);
469 new_volt = act8846_dcdc_list_voltage(dev, new_selector);
473 return DIV_ROUND_UP(abs(old_volt - new_volt)*2, 25000);
476 static struct regulator_ops act8846_dcdc_ops = {
477 .set_voltage = act8846_dcdc_set_voltage,
478 .get_voltage = act8846_dcdc_get_voltage,
479 .list_voltage= act8846_dcdc_list_voltage,
480 .is_enabled = act8846_dcdc_is_enabled,
481 .enable = act8846_dcdc_enable,
482 .disable = act8846_dcdc_disable,
483 .get_mode = act8846_dcdc_get_mode,
484 .set_mode = act8846_dcdc_set_mode,
485 .set_suspend_voltage = act8846_dcdc_set_sleep_voltage,
486 .set_voltage_time_sel = act8846_dcdc_set_voltage_time_sel,
488 static struct regulator_desc regulators[] = {
493 .ops = &act8846_dcdc_ops,
494 .n_voltages = ARRAY_SIZE(buck_voltage_map),
495 .type = REGULATOR_VOLTAGE,
496 .owner = THIS_MODULE,
501 .ops = &act8846_dcdc_ops,
502 .n_voltages = ARRAY_SIZE(buck_voltage_map),
503 .type = REGULATOR_VOLTAGE,
504 .owner = THIS_MODULE,
509 .ops = &act8846_dcdc_ops,
510 .n_voltages = ARRAY_SIZE(buck_voltage_map),
511 .type = REGULATOR_VOLTAGE,
512 .owner = THIS_MODULE,
517 .ops = &act8846_dcdc_ops,
518 .n_voltages = ARRAY_SIZE(buck_voltage_map),
519 .type = REGULATOR_VOLTAGE,
520 .owner = THIS_MODULE,
526 .ops = &act8846_ldo_ops,
527 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
528 .type = REGULATOR_VOLTAGE,
529 .owner = THIS_MODULE,
534 .ops = &act8846_ldo_ops,
535 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
536 .type = REGULATOR_VOLTAGE,
537 .owner = THIS_MODULE,
542 .ops = &act8846_ldo_ops,
543 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
544 .type = REGULATOR_VOLTAGE,
545 .owner = THIS_MODULE,
550 .ops = &act8846_ldo_ops,
551 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
552 .type = REGULATOR_VOLTAGE,
553 .owner = THIS_MODULE,
559 .ops = &act8846_ldo_ops,
560 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
561 .type = REGULATOR_VOLTAGE,
562 .owner = THIS_MODULE,
567 .ops = &act8846_ldo_ops,
568 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
569 .type = REGULATOR_VOLTAGE,
570 .owner = THIS_MODULE,
575 .ops = &act8846_ldo_ops,
576 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
577 .type = REGULATOR_VOLTAGE,
578 .owner = THIS_MODULE,
583 .ops = &act8846_ldo_ops,
584 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
585 .type = REGULATOR_VOLTAGE,
586 .owner = THIS_MODULE,
591 .ops = &act8846_ldo_ops,
592 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
593 .type = REGULATOR_VOLTAGE,
594 .owner = THIS_MODULE,
601 static int act8846_i2c_read(struct i2c_client *i2c, char reg, int count, u16 *dest)
604 struct i2c_adapter *adap;
605 struct i2c_msg msgs[2];
615 msgs[0].addr = i2c->addr;
617 msgs[0].flags = i2c->flags;
619 msgs[0].scl_rate = 200*1000;
621 msgs[1].buf = (u8 *)dest;
622 msgs[1].addr = i2c->addr;
623 msgs[1].flags = i2c->flags | I2C_M_RD;
625 msgs[1].scl_rate = 200*1000;
626 ret = i2c_transfer(adap, msgs, 2);
628 DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
633 static int act8846_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
637 struct i2c_adapter *adap;
650 msg.addr = i2c->addr;
651 msg.buf = &tx_buf[0];
653 msg.flags = i2c->flags;
654 msg.scl_rate = 200*1000;
656 ret = i2c_transfer(adap, &msg, 1);
660 static u8 act8846_reg_read(struct act8846 *act8846, u8 reg)
665 mutex_lock(&act8846->io_lock);
667 ret = act8846_i2c_read(act8846->i2c, reg, 1, &val);
669 mutex_unlock(&act8846->io_lock);
673 DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
675 mutex_unlock(&act8846->io_lock);
680 static int act8846_set_bits(struct act8846 *act8846, u8 reg, u16 mask, u16 val)
685 mutex_lock(&act8846->io_lock);
687 ret = act8846_i2c_read(act8846->i2c, reg, 1, &tmp);
689 mutex_unlock(&act8846->io_lock);
692 DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
693 tmp = (tmp & ~mask) | val;
694 ret = act8846_i2c_write(act8846->i2c, reg, 1, tmp);
696 mutex_unlock(&act8846->io_lock);
699 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
701 ret = act8846_i2c_read(act8846->i2c, reg, 1, &tmp);
703 mutex_unlock(&act8846->io_lock);
706 DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
707 mutex_unlock(&act8846->io_lock);
713 static struct of_device_id act8846_of_match[] = {
714 { .compatible = "act,act8846"},
717 MODULE_DEVICE_TABLE(of, act8846_of_match);
720 static struct of_regulator_match act8846_reg_matches[] = {
721 { .name = "act_dcdc1" ,.driver_data = (void *)0},
722 { .name = "act_dcdc2" ,.driver_data = (void *)1},
723 { .name = "act_dcdc3", .driver_data = (void *)2 },
724 { .name = "act_dcdc4", .driver_data = (void *)3 },
725 { .name = "act_ldo1", .driver_data = (void *)4 },
726 { .name = "act_ldo2", .driver_data = (void *)5 },
727 { .name = "act_ldo3", .driver_data = (void *)6 },
728 { .name = "act_ldo4", .driver_data = (void *)7 },
729 { .name = "act_ldo5", .driver_data = (void *)8 },
730 { .name = "act_ldo6", .driver_data = (void *)9 },
731 { .name = "act_ldo7", .driver_data = (void *)10 },
732 { .name = "act_ldo8", .driver_data = (void *)11 },
735 static struct act8846_board *act8846_parse_dt(struct act8846 *act8846)
737 // struct act8846 *act8846 = i2c->dev.parent;
738 struct act8846_board *pdata;
739 struct device_node *regs;
740 struct device_node *act8846_pmic_np;
743 printk("%s,line=%d\n", __func__,__LINE__);
745 act8846_pmic_np = of_node_get(act8846->dev->of_node);
746 if (!act8846_pmic_np) {
747 printk("could not find pmic sub-node\n");
751 regs = of_find_node_by_name(act8846_pmic_np, "regulators");
755 count = of_regulator_match(act8846->dev, regs, act8846_reg_matches,act8846_NUM_REGULATORS);
758 if ((count < 0) || (count > act8846_NUM_REGULATORS))
761 pdata = devm_kzalloc(act8846->dev, sizeof(*pdata), GFP_KERNEL);
764 for (i = 0; i < count; i++) {
765 if (!act8846_reg_matches[i].init_data || !act8846_reg_matches[i].of_node)
767 pdata->act8846_init_data[i] = act8846_reg_matches[i].init_data;
768 pdata->of_node[i] = act8846_reg_matches[i].of_node;
770 pdata->irq = act8846->chip_irq;
771 pdata->irq_base = -1;
773 gpio = of_get_named_gpio(act8846_pmic_np,"gpios", 0);
774 if (!gpio_is_valid(gpio))
775 printk("invalid gpio: %d\n",gpio);
776 pdata->pmic_sleep_gpio = gpio;
777 pdata->pmic_sleep = true;
779 gpio = of_get_named_gpio(act8846_pmic_np,"gpios", 1);
780 if (!gpio_is_valid(gpio))
781 printk("invalid gpio: %d\n",gpio);
782 pdata->pmic_hold_gpio = gpio;
783 pdata->pm_off = of_property_read_bool(act8846_pmic_np,"act8846,system-power-controller");
789 static struct act8846_board *act8846_parse_dt(struct i2c_client *i2c)
796 int act8846_device_shutdown(void)
800 struct act8846 *act8846 = g_act8846;
802 printk("%s\n",__func__);
804 if (act8846->pmic_hold_gpio) {
805 gpio_direction_output(act8846->pmic_hold_gpio,0);
807 arm_pm_restart('h', "charge");
811 ret = act8846_reg_read(act8846,0xc3);
812 ret = act8846_set_bits(act8846, 0xc3,(0x1<<3),(0x1<<3));
813 ret = act8846_set_bits(act8846, 0xc3,(0x1<<4),(0x1<<4));
815 printk("act8846 set 0xc3 error!\n");
821 EXPORT_SYMBOL_GPL(act8846_device_shutdown);
823 __weak void act8846_device_suspend(void) {}
824 __weak void act8846_device_resume(void) {}
826 static int act8846_suspend(struct device *dev)
828 act8846_device_suspend();
832 static int act8846_resume(struct device *dev)
834 act8846_device_resume();
838 static int act8846_suspend(struct device *dev)
843 static int act8846_resume(struct device *dev)
850 #ifdef CONFIG_HAS_EARLYSUSPEND
851 __weak void act8846_early_suspend(struct early_suspend *h) {}
852 __weak void act8846_late_resume(struct early_suspend *h) {}
855 static bool is_volatile_reg(struct device *dev, unsigned int reg)
858 if ((reg >= act8846_BUCK1_SET_VOL_BASE) && (reg <= act8846_LDO8_CONTR_BASE)) {
864 static const struct regmap_config act8846_regmap_config = {
867 .volatile_reg = is_volatile_reg,
868 .max_register = act8846_NUM_REGULATORS - 1,
869 .cache_type = REGCACHE_RBTREE,
871 static int act8846_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
873 struct act8846 *act8846;
874 struct act8846_board *pdev ;
875 const struct of_device_id *match;
876 struct regulator_config config = { };
877 struct regulator_dev *act_rdev;
878 struct regulator_init_data *reg_data;
879 const char *rail_name = NULL;
882 printk("%s,line=%d\n", __func__,__LINE__);
884 if (i2c->dev.of_node) {
885 match = of_match_device(act8846_of_match, &i2c->dev);
887 printk("Failed to find matching dt id\n");
892 act8846 = devm_kzalloc(&i2c->dev,sizeof(struct act8846), GFP_KERNEL);
893 if (act8846 == NULL) {
898 act8846->dev = &i2c->dev;
899 i2c_set_clientdata(i2c, act8846);
902 act8846->regmap = devm_regmap_init_i2c(i2c, &act8846_regmap_config);
903 if (IS_ERR(act8846->regmap)) {
904 ret = PTR_ERR(act8846->regmap);
905 printk("regmap initialization failed: %d\n", ret);
909 mutex_init(&act8846->io_lock);
911 ret = act8846_reg_read(act8846,0x22);
912 if ((ret < 0) || (ret == 0xff)){
913 printk("The device is not act8846 %x \n",ret);
917 ret = act8846_set_bits(act8846, 0xf4,(0x1<<7),(0x0<<7));
919 printk("act8846 set 0xf4 error!\n");
923 if (act8846->dev->of_node)
924 pdev = act8846_parse_dt(act8846);
927 act8846->pmic_hold_gpio = pdev->pmic_hold_gpio;
928 if (act8846->pmic_hold_gpio) {
929 ret = gpio_request(act8846->pmic_hold_gpio, "act8846_pmic_hold");
931 dev_err(act8846->dev,"Failed to request gpio %d with ret:""%d\n", act8846->pmic_hold_gpio, ret);
934 gpio_direction_output(act8846->pmic_hold_gpio,1);
935 ret = gpio_get_value(act8846->pmic_hold_gpio);
936 // gpio_free(act8846->pmic_hold_gpio);
937 printk("%s: act8846_pmic_hold=%x\n", __func__, ret);
941 /******************************set sleep vol & dcdc mode******************/
943 act8846->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
944 if (act8846->pmic_sleep_gpio) {
945 ret = gpio_request(act8846->pmic_sleep_gpio, "act8846_pmic_sleep");
947 dev_err(act8846->dev,"Failed to request gpio %d with ret:""%d\n", act8846->pmic_sleep_gpio, ret);
950 gpio_direction_output(act8846->pmic_sleep_gpio,1);
951 ret = gpio_get_value(act8846->pmic_sleep_gpio);
952 gpio_free(act8846->pmic_sleep_gpio);
953 printk("%s: act8846_pmic_sleep=%x\n", __func__, ret);
958 act8846->num_regulators = act8846_NUM_REGULATORS;
959 act8846->rdev = kcalloc(act8846_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
960 if (!act8846->rdev) {
963 /* Instantiate the regulators */
964 for (i = 0; i < act8846_NUM_REGULATORS; i++) {
965 reg_data = pdev->act8846_init_data[i];
968 config.dev = act8846->dev;
969 config.driver_data = act8846;
970 config.regmap = act8846->regmap;
971 if (act8846->dev->of_node)
972 config.of_node = pdev->of_node[i];
974 if (reg_data && reg_data->constraints.name)
975 rail_name = reg_data->constraints.name;
977 rail_name = regulators[i].name;
978 reg_data->supply_regulator = rail_name;
980 config.init_data =reg_data;
982 act_rdev = regulator_register(®ulators[i],&config);
983 if (IS_ERR(act_rdev)) {
984 printk("failed to register %d regulator\n",i);
987 act8846->rdev[i] = act_rdev;
991 if (pdev->pm_off && !pm_power_off) {
992 pm_power_off = act8846_device_shutdown;
995 #ifdef CONFIG_HAS_EARLYSUSPEND
996 act8846->act8846_suspend.suspend = act8846_early_suspend,
997 act8846->act8846_suspend.resume = act8846_late_resume,
998 act8846->act8846_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 1,
999 register_early_suspend(&act8846->act8846_suspend);
1009 static int act8846_i2c_remove(struct i2c_client *i2c)
1011 struct act8846 *act8846 = i2c_get_clientdata(i2c);
1014 for (i = 0; i < act8846->num_regulators; i++)
1015 if (act8846->rdev[i])
1016 regulator_unregister(act8846->rdev[i]);
1017 kfree(act8846->rdev);
1018 i2c_set_clientdata(i2c, NULL);
1024 static const struct dev_pm_ops act8846_pm_ops = {
1025 .suspend = act8846_suspend,
1026 .resume = act8846_resume,
1029 static const struct i2c_device_id act8846_i2c_id[] = {
1034 MODULE_DEVICE_TABLE(i2c, act8846_i2c_id);
1036 static struct i2c_driver act8846_i2c_driver = {
1039 .owner = THIS_MODULE,
1041 .pm = &act8846_pm_ops,
1043 .of_match_table =of_match_ptr(act8846_of_match),
1045 .probe = act8846_i2c_probe,
1046 .remove = act8846_i2c_remove,
1047 .id_table = act8846_i2c_id,
1050 static int __init act8846_module_init(void)
1053 ret = i2c_add_driver(&act8846_i2c_driver);
1055 pr_err("Failed to register I2C driver: %d\n", ret);
1058 //module_init(act8846_module_init);
1059 //subsys_initcall(act8846_module_init);
1060 //rootfs_initcall(act8846_module_init);
1061 subsys_initcall_sync(act8846_module_init);
1063 static void __exit act8846_module_exit(void)
1065 i2c_del_driver(&act8846_i2c_driver);
1067 module_exit(act8846_module_exit);
1069 MODULE_LICENSE("GPL");
1070 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1071 MODULE_DESCRIPTION("act8846 PMIC driver");