2 * Regulator driver for rk818 PMIC chip for rk31xx
4 * Based on rk818.c that is work by zhangqing<zhangqing@rock-chips.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
12 #include <linux/bug.h>
13 #include <linux/err.h>
14 #include <linux/i2c.h>
15 #include <linux/kernel.h>
16 #include <linux/regulator/driver.h>
17 #include <linux/mfd/rk818.h>
18 #include <linux/mfd/core.h>
19 #include <linux/delay.h>
20 #include <linux/slab.h>
21 #include <linux/mutex.h>
22 #include <linux/interrupt.h>
23 #include <linux/module.h>
24 #include <linux/of_irq.h>
25 #include <linux/of_gpio.h>
27 #include <linux/of_device.h>
28 #include <linux/regulator/of_regulator.h>
29 #include <linux/regulator/driver.h>
30 #include <linux/regulator/machine.h>
31 #include <linux/regmap.h>
32 #include <linux/syscore_ops.h>
36 #define DBG(x...) printk(KERN_INFO x)
41 #define DBG_INFO(x...) printk(KERN_INFO x)
43 #define DBG_INFO(x...)
47 struct rk818 *g_rk818;
49 static struct mfd_cell rk818s[] = {
55 .name = "rk818-battery",
58 .name = "rk818-power",
63 #define BUCK_VOL_MASK 0x3f
64 #define LDO_VOL_MASK 0x3f
65 #define LDO9_VOL_MASK 0x1f
66 #define BOOST_VOL_MASK 0xe0
68 #define VOL_MIN_IDX 0x00
69 #define VOL_MAX_IDX 0x3f
70 #define RK818_I2C_ADDR_RATE 200*1000
72 const static int buck_set_vol_base_addr[] = {
75 RK818_BUCK3_CONFIG_REG,
78 const static int buck_set_slp_vol_base_addr[] = {
81 RK818_BUCK3_CONFIG_REG,
82 RK818_BUCK4_SLP_VSEL_REG,
84 const static int buck_contr_base_addr[] = {
85 RK818_BUCK1_CONFIG_REG,
86 RK818_BUCK2_CONFIG_REG,
87 RK818_BUCK3_CONFIG_REG,
88 RK818_BUCK4_CONFIG_REG,
90 #define rk818_BUCK_SET_VOL_REG(x) (buck_set_vol_base_addr[x])
91 #define rk818_BUCK_CONTR_REG(x) (buck_contr_base_addr[x])
92 #define rk818_BUCK_SET_SLP_VOL_REG(x) (buck_set_slp_vol_base_addr[x])
95 const static int ldo_set_vol_base_addr[] = {
96 RK818_LDO1_ON_VSEL_REG,
97 RK818_LDO2_ON_VSEL_REG,
98 RK818_LDO3_ON_VSEL_REG,
99 RK818_LDO4_ON_VSEL_REG,
100 RK818_LDO5_ON_VSEL_REG,
101 RK818_LDO6_ON_VSEL_REG,
102 RK818_LDO7_ON_VSEL_REG,
103 RK818_LDO8_ON_VSEL_REG,
104 RK818_BOOST_LDO9_ON_VSEL_REG,
106 const static int ldo_set_slp_vol_base_addr[] = {
107 RK818_LDO1_SLP_VSEL_REG,
108 RK818_LDO2_SLP_VSEL_REG,
109 RK818_LDO3_SLP_VSEL_REG,
110 RK818_LDO4_SLP_VSEL_REG,
111 RK818_LDO5_SLP_VSEL_REG,
112 RK818_LDO6_SLP_VSEL_REG,
113 RK818_LDO7_SLP_VSEL_REG,
114 RK818_LDO8_SLP_VSEL_REG,
115 RK818_BOOST_LDO9_SLP_VSEL_REG,
118 #define rk818_LDO_SET_VOL_REG(x) (ldo_set_vol_base_addr[x])
119 #define rk818_LDO_SET_SLP_VOL_REG(x) (ldo_set_slp_vol_base_addr[x])
121 const static int buck_voltage_map[] = {
122 700, 712, 725, 737, 750, 762, 775, 787, 800,
123 812, 825, 837, 850,862, 875, 887, 900, 912,
124 925, 937, 950, 962, 975, 987, 1000, 1012, 1025,
125 1037, 1050,1062, 1075, 1087, 1100, 1112, 1125, 1137,
126 1150,1162, 1175, 1187, 1200, 1212, 1225, 1237, 1250,
127 1262, 1275, 1287, 1300, 1312, 1325, 1337, 1350,1362,
128 1375, 1387, 1400, 1412, 1425, 1437, 1450,1462, 1475,
132 const static int buck4_voltage_map[] = {
133 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500, 2600,
134 2700, 2800, 2900, 3000, 3100, 3200,3300, 3400,3500,3600,
137 const static int ldo_voltage_map[] = {
138 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500, 2600,
139 2700, 2800, 2900, 3000, 3100, 3200,3300, 3400,
141 const static int ldo3_voltage_map[] = {
142 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600,
143 1700, 1800, 1900, 2000,2100, 2200, 2500,
145 const static int ldo6_voltage_map[] = {
146 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600,
147 1700, 1800, 1900, 2000,2100, 2200, 2300,2400,2500,
149 const static int boost_voltage_map[] = {
150 4700,4800,4900,5000,5100,5200,5300,5400,
153 static int rk818_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
155 int ldo= rdev_get_id(dev) - RK818_LDO1;
157 if (index >= ARRAY_SIZE(ldo3_voltage_map))
159 return 1000 * ldo3_voltage_map[index];
161 else if (ldo == 5 || ldo ==6){
162 if (index >= ARRAY_SIZE(ldo6_voltage_map))
164 return 1000 * ldo6_voltage_map[index];
167 if (index >= ARRAY_SIZE(ldo_voltage_map))
169 return 1000 * ldo_voltage_map[index];
172 static int rk818_ldo_is_enabled(struct regulator_dev *dev)
174 struct rk818 *rk818 = rdev_get_drvdata(dev);
175 int ldo= rdev_get_id(dev) - RK818_LDO1;
179 val = rk818_reg_read(rk818, RK818_DCDC_EN_REG); //ldo9
187 val = rk818_reg_read(rk818, RK818_LDO_EN_REG);
190 if (val & (1 << ldo))
195 static int rk818_ldo_enable(struct regulator_dev *dev)
197 struct rk818 *rk818 = rdev_get_drvdata(dev);
198 int ldo= rdev_get_id(dev) - RK818_LDO1;
201 rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << 5, 1 << 5); //ldo9
203 rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << 6, 1 << 6); //ldo10 switch
205 rk818_set_bits(rk818, RK818_LDO_EN_REG, 1 << ldo, 1 << ldo);
209 static int rk818_ldo_disable(struct regulator_dev *dev)
211 struct rk818 *rk818 = rdev_get_drvdata(dev);
212 int ldo= rdev_get_id(dev) - RK818_LDO1;
215 rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << 5, 1 << 0); //ldo9
217 rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << 6, 1 << 0); //ldo10 switch
219 rk818_set_bits(rk818, RK818_LDO_EN_REG, 1 << ldo, 0);
223 static int rk818_ldo_get_voltage(struct regulator_dev *dev)
225 struct rk818 *rk818 = rdev_get_drvdata(dev);
226 int ldo= rdev_get_id(dev) - RK818_LDO1;
231 reg = rk818_reg_read(rk818,rk818_BUCK_SET_VOL_REG(3));
232 reg &= BUCK_VOL_MASK;
233 val = 1000 * buck4_voltage_map[reg];
236 reg = rk818_reg_read(rk818,rk818_LDO_SET_VOL_REG(ldo));
238 reg &= LDO9_VOL_MASK;
244 val = 1000 * ldo3_voltage_map[reg];
246 else if (ldo == 5 || ldo ==6){
247 val = 1000 * ldo6_voltage_map[reg];
250 val = 1000 * ldo_voltage_map[reg];
255 static int rk818_ldo_suspend_enable(struct regulator_dev *dev)
257 struct rk818 *rk818 = rdev_get_drvdata(dev);
258 int ldo= rdev_get_id(dev) - RK818_LDO1;
261 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << 5, 0); //ldo9
263 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << 6, 0); //ldo10 switch
265 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG2, 1 << ldo, 0);
268 static int rk818_ldo_suspend_disable(struct regulator_dev *dev)
270 struct rk818 *rk818 = rdev_get_drvdata(dev);
271 int ldo= rdev_get_id(dev) - RK818_LDO1;
274 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << 5, 1 << 5); //ldo9
276 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << 6, 1 << 6); //ldo10 switch
278 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG2, 1 << ldo, 1 << ldo);
281 static int rk818_ldo_set_sleep_voltage(struct regulator_dev *dev,
284 struct rk818 *rk818 = rdev_get_drvdata(dev);
285 int ldo= rdev_get_id(dev) - RK818_LDO1;
286 const int *vol_map = ldo_voltage_map;
287 int min_vol = uV / 1000;
292 vol_map = ldo3_voltage_map;
295 else if (ldo == 5 || ldo ==6){
296 vol_map = ldo6_voltage_map;
303 if (min_vol < vol_map[0] ||
304 min_vol > vol_map[num])
307 for (val = 0; val <= num; val++){
308 if (vol_map[val] >= min_vol)
313 ret = rk818_set_bits(rk818, rk818_LDO_SET_SLP_VOL_REG(ldo),LDO9_VOL_MASK, val);
316 ret = rk818_set_bits(rk818, rk818_LDO_SET_SLP_VOL_REG(ldo),LDO_VOL_MASK, val);
321 static int rk818_ldo_set_voltage(struct regulator_dev *dev,
322 int min_uV, int max_uV,unsigned *selector)
324 struct rk818 *rk818 = rdev_get_drvdata(dev);
325 int ldo= rdev_get_id(dev) - RK818_LDO1;
327 int min_vol = min_uV / 1000;
332 vol_map = ldo3_voltage_map;
335 else if (ldo == 5 || ldo ==6){
336 vol_map = ldo6_voltage_map;
340 vol_map = ldo_voltage_map;
344 if (min_vol < vol_map[0] ||
345 min_vol > vol_map[num])
348 for (val = 0; val <= num; val++){
349 if (vol_map[val] >= min_vol)
354 ret = rk818_set_bits(rk818, rk818_LDO_SET_VOL_REG(ldo),LDO9_VOL_MASK, val);
357 ret = rk818_set_bits(rk818, rk818_LDO_SET_VOL_REG(ldo),LDO_VOL_MASK, val);
363 static struct regulator_ops rk818_ldo_ops = {
364 .set_voltage = rk818_ldo_set_voltage,
365 .get_voltage = rk818_ldo_get_voltage,
366 .list_voltage = rk818_ldo_list_voltage,
367 .is_enabled = rk818_ldo_is_enabled,
368 .enable = rk818_ldo_enable,
369 .disable = rk818_ldo_disable,
370 .set_suspend_enable =rk818_ldo_suspend_enable,
371 .set_suspend_disable =rk818_ldo_suspend_disable,
372 .set_suspend_voltage = rk818_ldo_set_sleep_voltage,
375 static int rk818_dcdc_list_voltage(struct regulator_dev *dev, unsigned selector)
378 int buck = rdev_get_id(dev) - RK818_DCDC1;
380 if (selector < 0x0 ||selector > BUCK_VOL_MASK )
386 volt = 700000 + selector * 12500;
389 volt = 1800000 + selector * 100000;
401 static int rk818_dcdc_is_enabled(struct regulator_dev *dev)
403 struct rk818 *rk818 = rdev_get_drvdata(dev);
404 int buck = rdev_get_id(dev) - RK818_DCDC1;
407 val = rk818_reg_read(rk818, RK818_DCDC_EN_REG);
410 if (val & (1 << buck))
415 static int rk818_dcdc_enable(struct regulator_dev *dev)
417 struct rk818 *rk818 = rdev_get_drvdata(dev);
418 int buck = rdev_get_id(dev) - RK818_DCDC1;
420 return rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << buck, 1 << buck);
423 static int rk818_dcdc_disable(struct regulator_dev *dev)
425 struct rk818 *rk818 = rdev_get_drvdata(dev);
426 int buck = rdev_get_id(dev) - RK818_DCDC1;
428 return rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << buck , 0);
430 static int rk818_dcdc_get_voltage(struct regulator_dev *dev)
432 struct rk818 *rk818 = rdev_get_drvdata(dev);
433 int buck = rdev_get_id(dev) - RK818_DCDC1;
437 reg = rk818_reg_read(rk818,rk818_BUCK_SET_VOL_REG(buck));
439 reg &= BUCK_VOL_MASK;
440 val = rk818_dcdc_list_voltage(dev,reg);
443 static int rk818_dcdc_select_min_voltage(struct regulator_dev *dev,
444 int min_uV, int max_uV ,int buck)
448 if (buck == 0 || buck == 1){
451 else if (min_uV <= 1500000)
452 vsel = ((min_uV - 700000) / 12500) ;
457 if (min_uV < 1800000)
459 else if (min_uV <= 3300000)
460 vsel = ((min_uV - 1800000) / 100000) ;
464 if (rk818_dcdc_list_voltage(dev, vsel) > max_uV)
469 static int rk818_dcdc_set_voltage(struct regulator_dev *dev,
470 int min_uV, int max_uV,unsigned *selector)
472 struct rk818 *rk818 = rdev_get_drvdata(dev);
473 int buck = rdev_get_id(dev) - RK818_DCDC1;
480 val = rk818_dcdc_select_min_voltage(dev,min_uV,max_uV,buck);
481 ret = rk818_set_bits(rk818, rk818_BUCK_SET_VOL_REG(buck), BUCK_VOL_MASK, val);
483 val = rk818_dcdc_select_min_voltage(dev,min_uV,max_uV,buck);
484 ret = rk818_set_bits(rk818, rk818_BUCK_SET_VOL_REG(buck), BUCK_VOL_MASK, val);
487 static int rk818_dcdc_set_sleep_voltage(struct regulator_dev *dev,
490 struct rk818 *rk818 = rdev_get_drvdata(dev);
491 int buck = rdev_get_id(dev) - RK818_DCDC1;
498 val = rk818_dcdc_select_min_voltage(dev,uV,uV,buck);
499 ret = rk818_set_bits(rk818, rk818_BUCK_SET_SLP_VOL_REG(buck) , BUCK_VOL_MASK, val);
503 static unsigned int rk818_dcdc_get_mode(struct regulator_dev *dev)
505 struct rk818 *rk818 = rdev_get_drvdata(dev);
506 int buck = rdev_get_id(dev) - RK818_DCDC1;
509 val = rk818_reg_read(rk818, rk818_BUCK_SET_VOL_REG(buck));
515 return REGULATOR_MODE_FAST;
517 return REGULATOR_MODE_NORMAL;
520 static int rk818_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
522 struct rk818 *rk818 = rdev_get_drvdata(dev);
523 int buck = rdev_get_id(dev) - RK818_DCDC1;
527 case REGULATOR_MODE_FAST:
528 return rk818_set_bits(rk818, rk818_BUCK_SET_VOL_REG(buck), mask, mask);
529 case REGULATOR_MODE_NORMAL:
530 return rk818_set_bits(rk818, rk818_BUCK_SET_VOL_REG(buck), mask, 0);
532 printk("error:pmu_rk818 only powersave and pwm mode\n");
537 static int rk818_dcdc_set_voltage_time_sel(struct regulator_dev *dev, unsigned int old_selector,
538 unsigned int new_selector)
540 int old_volt, new_volt;
542 old_volt = rk818_dcdc_list_voltage(dev, old_selector);
546 new_volt = rk818_dcdc_list_voltage(dev, new_selector);
550 return DIV_ROUND_UP(abs(old_volt - new_volt)*2, 2500);
553 static int rk818_dcdc_suspend_enable(struct regulator_dev *dev)
555 struct rk818 *rk818 = rdev_get_drvdata(dev);
556 int buck = rdev_get_id(dev) - RK818_DCDC1;
558 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << buck, 0);
561 static int rk818_dcdc_suspend_disable(struct regulator_dev *dev)
563 struct rk818 *rk818 = rdev_get_drvdata(dev);
564 int buck = rdev_get_id(dev) - RK818_DCDC1;
566 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << buck , 1 << buck);
568 static int rk818_dcdc_set_suspend_mode(struct regulator_dev *dev, unsigned int mode)
570 struct rk818 *rk818 = rdev_get_drvdata(dev);
571 int buck = rdev_get_id(dev) - RK818_DCDC1;
576 case REGULATOR_MODE_FAST:
577 return rk818_set_bits(rk818, (rk818_BUCK_SET_VOL_REG(buck) + 0x01), mask, mask);
578 case REGULATOR_MODE_NORMAL:
579 return rk818_set_bits(rk818, (rk818_BUCK_SET_VOL_REG(buck) + 0x01), mask, 0);
581 printk("error:pmu_rk818 only powersave and pwm mode\n");
586 static struct regulator_ops rk818_dcdc_ops = {
587 .set_voltage = rk818_dcdc_set_voltage,
588 .get_voltage = rk818_dcdc_get_voltage,
589 .list_voltage= rk818_dcdc_list_voltage,
590 .is_enabled = rk818_dcdc_is_enabled,
591 .enable = rk818_dcdc_enable,
592 .disable = rk818_dcdc_disable,
593 .get_mode = rk818_dcdc_get_mode,
594 .set_mode = rk818_dcdc_set_mode,
595 .set_suspend_enable =rk818_dcdc_suspend_enable,
596 .set_suspend_disable =rk818_dcdc_suspend_disable,
597 .set_suspend_mode = rk818_dcdc_set_suspend_mode,
598 .set_suspend_voltage = rk818_dcdc_set_sleep_voltage,
599 .set_voltage_time_sel = rk818_dcdc_set_voltage_time_sel,
601 static struct regulator_desc regulators[] = {
604 .name = "RK818_DCDC1",
606 .ops = &rk818_dcdc_ops,
607 .n_voltages = ARRAY_SIZE(buck_voltage_map),
608 .type = REGULATOR_VOLTAGE,
609 .owner = THIS_MODULE,
612 .name = "RK818_DCDC2",
614 .ops = &rk818_dcdc_ops,
615 .n_voltages = ARRAY_SIZE(buck_voltage_map),
616 .type = REGULATOR_VOLTAGE,
617 .owner = THIS_MODULE,
620 .name = "RK818_DCDC3",
622 .ops = &rk818_dcdc_ops,
623 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
624 .type = REGULATOR_VOLTAGE,
625 .owner = THIS_MODULE,
628 .name = "RK818_DCDC4",
630 .ops = &rk818_dcdc_ops,
631 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
632 .type = REGULATOR_VOLTAGE,
633 .owner = THIS_MODULE,
637 .name = "RK818_LDO1",
639 .ops = &rk818_ldo_ops,
640 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
641 .type = REGULATOR_VOLTAGE,
642 .owner = THIS_MODULE,
645 .name = "RK818_LDO2",
647 .ops = &rk818_ldo_ops,
648 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
649 .type = REGULATOR_VOLTAGE,
650 .owner = THIS_MODULE,
653 .name = "RK818_LDO3",
655 .ops = &rk818_ldo_ops,
656 .n_voltages = ARRAY_SIZE(ldo3_voltage_map),
657 .type = REGULATOR_VOLTAGE,
658 .owner = THIS_MODULE,
661 .name = "RK818_LDO4",
663 .ops = &rk818_ldo_ops,
664 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
665 .type = REGULATOR_VOLTAGE,
666 .owner = THIS_MODULE,
670 .name = "RK818_LDO5",
672 .ops = &rk818_ldo_ops,
673 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
674 .type = REGULATOR_VOLTAGE,
675 .owner = THIS_MODULE,
678 .name = "RK818_LDO6",
680 .ops = &rk818_ldo_ops,
681 .n_voltages = ARRAY_SIZE(ldo6_voltage_map),
682 .type = REGULATOR_VOLTAGE,
683 .owner = THIS_MODULE,
686 .name = "RK818_LDO7",
688 .ops = &rk818_ldo_ops,
689 .n_voltages = ARRAY_SIZE(ldo6_voltage_map),
690 .type = REGULATOR_VOLTAGE,
691 .owner = THIS_MODULE,
694 .name = "RK818_LDO8",
696 .ops = &rk818_ldo_ops,
697 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
698 .type = REGULATOR_VOLTAGE,
699 .owner = THIS_MODULE,
702 .name = "RK818_LDO9",
704 .ops = &rk818_ldo_ops,
705 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
706 .type = REGULATOR_VOLTAGE,
707 .owner = THIS_MODULE,
710 .name = "RK818_LDO10",
712 .ops = &rk818_ldo_ops,
713 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
714 .type = REGULATOR_VOLTAGE,
715 .owner = THIS_MODULE,
723 int rk818_i2c_read(struct rk818 *rk818, char reg, int count,u8 *dest)
725 struct i2c_client *i2c = rk818->i2c;
728 struct i2c_adapter *adap;
729 struct i2c_msg msgs[2];
739 msgs[0].addr = i2c->addr;
743 msgs[0].scl_rate = 200*1000;
746 msgs[1].addr = i2c->addr;
747 msgs[1].flags = I2C_M_RD;
749 msgs[1].scl_rate = RK818_I2C_ADDR_RATE;
751 ret = i2c_transfer(adap, msgs, 2);
753 DBG("***run in %s %x % x\n",__FUNCTION__,i2c->addr,msgs[0].buf);
757 int rk818_i2c_write(struct rk818 *rk818, char reg, int count, const u8 src)
760 struct i2c_client *i2c = rk818->i2c;
761 struct i2c_adapter *adap;
774 msg.addr = i2c->addr;
775 msg.buf = &tx_buf[0];
777 msg.flags = i2c->flags;
778 msg.scl_rate = RK818_I2C_ADDR_RATE;
780 ret = i2c_transfer(adap, &msg, 1);
784 u8 rk818_reg_read(struct rk818 *rk818, u8 reg)
788 mutex_lock(&rk818->io_lock);
790 rk818_i2c_read(rk818, reg, 1, &val);
792 DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
794 mutex_unlock(&rk818->io_lock);
798 EXPORT_SYMBOL_GPL(rk818_reg_read);
800 int rk818_reg_write(struct rk818 *rk818, u8 reg, u8 val)
804 mutex_lock(&rk818->io_lock);
806 err = rk818_i2c_write(rk818, reg, 1,val);
808 dev_err(rk818->dev, "Write for reg 0x%x failed\n", reg);
810 mutex_unlock(&rk818->io_lock);
813 EXPORT_SYMBOL_GPL(rk818_reg_write);
815 int rk818_set_bits(struct rk818 *rk818, u8 reg, u8 mask, u8 val)
820 mutex_lock(&rk818->io_lock);
822 ret = rk818_i2c_read(rk818, reg, 1, &tmp);
823 DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
824 tmp = (tmp & ~mask) | val;
826 ret = rk818_i2c_write(rk818, reg, 1, tmp);
827 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
829 rk818_i2c_read(rk818, reg, 1, &tmp);
830 DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
831 mutex_unlock(&rk818->io_lock);
835 EXPORT_SYMBOL_GPL(rk818_set_bits);
837 int rk818_clear_bits(struct rk818 *rk818, u8 reg, u8 mask)
842 mutex_lock(&rk818->io_lock);
843 err = rk818_i2c_read(rk818, reg, 1, &data);
845 dev_err(rk818->dev, "read from reg %x failed\n", reg);
850 err = rk818_i2c_write(rk818, reg, 1, data);
852 dev_err(rk818->dev, "write to reg %x failed\n", reg);
855 mutex_unlock(&rk818->io_lock);
858 EXPORT_SYMBOL_GPL(rk818_clear_bits);
861 static ssize_t rk818_test_store(struct kobject *kobj, struct kobj_attribute *attr,
862 const char *buf, size_t n)
868 const char *buftmp = buf;
869 struct rk818 *rk818 = g_rk818;
871 * W Addr(8Bit) regAddr(8Bit) data0(8Bit) data1(8Bit) data2(8Bit) data3(8Bit)
872 * :data can be less than 4 byte
874 * C gpio_name(poweron/powerhold/sleep/boot0/boot1) value(H/L)
876 regAddr = (u16)(getdata[0] & 0xff);
877 if (strncmp(buf, "start", 5) == 0) {
880 } else if (strncmp(buf, "stop", 4== 0) ){
883 sscanf(buftmp, "%c ", &cmd);
884 printk("------zhangqing: get cmd = %c\n", cmd);
888 sscanf(buftmp, "%c %x %x ", &cmd, &getdata[0],&getdata[1]);
889 regAddr = (u16)(getdata[0] & 0xff);
890 data = (u8)(getdata[1] & 0xff);
891 printk("get value = %x\n", data);
893 rk818_i2c_write(rk818, regAddr, 1, data);
894 rk818_i2c_read(rk818, regAddr, 1, &data);
895 printk("%x %x\n", getdata[1],data);
900 sscanf(buftmp, "%c %x ", &cmd, &getdata[0]);
901 printk("CMD : %c %x\n", cmd, getdata[0]);
903 regAddr = (u16)(getdata[0] & 0xff);
904 rk818_i2c_read(rk818, regAddr, 1, &data);
905 printk("%x %x\n", getdata[0],data);
910 printk("Unknown command\n");
917 static ssize_t rk818_test_show(struct kobject *kobj, struct kobj_attribute *attr,
922 return sprintf(s, "%s\n", buf);
926 static struct kobject *rk818_kobj;
927 struct rk818_attribute {
928 struct attribute attr;
929 ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,
931 ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,
932 const char *buf, size_t n);
935 static struct rk818_attribute rk818_attrs[] = {
936 /* node_name permision show_func store_func */
937 __ATTR(rk818_test, S_IRUGO | S_IWUSR, rk818_test_show, rk818_test_store),
942 extern void rk_send_wakeup_key(void);
943 static irqreturn_t rk818_vbat_lo_irq(int irq, void *data)
945 printk("rk818 vbat low %s:irq=%d\n",__func__,irq);
946 rk818_set_bits(g_rk818,0x4c,(0x1 << 1),(0x1 <<1));
947 rk_send_wakeup_key();
953 static struct of_device_id rk818_of_match[] = {
954 { .compatible = "rockchip,rk818"},
957 MODULE_DEVICE_TABLE(of, rk818_of_match);
961 static struct of_regulator_match rk818_reg_matches[] = {
962 { .name = "rk818_dcdc1", .driver_data = (void *)0 },
963 { .name = "rk818_dcdc2", .driver_data = (void *)1 },
964 { .name = "rk818_dcdc3", .driver_data = (void *)2 },
965 { .name = "rk818_dcdc4", .driver_data = (void *)3 },
966 { .name = "rk818_ldo1", .driver_data = (void *)4 },
967 { .name = "rk818_ldo2", .driver_data = (void *)5 },
968 { .name = "rk818_ldo3", .driver_data = (void *)6 },
969 { .name = "rk818_ldo4", .driver_data = (void *)7 },
970 { .name = "rk818_ldo5", .driver_data = (void *)8 },
971 { .name = "rk818_ldo6", .driver_data = (void *)9 },
972 { .name = "rk818_ldo7", .driver_data = (void *)10 },
973 { .name = "rk818_ldo8", .driver_data = (void *)11 },
974 { .name = "rk818_ldo9", .driver_data = (void *)12 },
975 { .name = "rk818_ldo10", .driver_data = (void *)13 },
978 static struct rk818_board *rk818_parse_dt(struct rk818 *rk818)
980 struct rk818_board *pdata;
981 struct device_node *regs,*rk818_pmic_np;
984 rk818_pmic_np = of_node_get(rk818->dev->of_node);
985 if (!rk818_pmic_np) {
986 printk("could not find pmic sub-node\n");
990 regs = of_find_node_by_name(rk818_pmic_np, "regulators");
994 count = of_regulator_match(rk818->dev, regs, rk818_reg_matches,
995 rk818_NUM_REGULATORS);
997 if ((count < 0) || (count > rk818_NUM_REGULATORS))
1000 pdata = devm_kzalloc(rk818->dev, sizeof(*pdata), GFP_KERNEL);
1004 for (i = 0; i < count; i++) {
1005 if (!rk818_reg_matches[i].init_data || !rk818_reg_matches[i].of_node)
1008 pdata->rk818_init_data[i] = rk818_reg_matches[i].init_data;
1009 pdata->of_node[i] = rk818_reg_matches[i].of_node;
1011 pdata->irq = rk818->chip_irq;
1012 pdata->irq_base = -1;
1014 pdata->irq_gpio = of_get_named_gpio(rk818_pmic_np,"gpios",0);
1015 if (!gpio_is_valid(pdata->irq_gpio)) {
1016 printk("invalid gpio: %d\n", pdata->irq_gpio);
1020 pdata->pmic_sleep_gpio = of_get_named_gpio(rk818_pmic_np,"gpios",1);
1021 if (!gpio_is_valid(pdata->pmic_sleep_gpio)) {
1022 printk("invalid gpio: %d\n", pdata->pmic_sleep_gpio);
1024 pdata->pmic_sleep = true;
1025 pdata->pm_off = of_property_read_bool(rk818_pmic_np,"rk818,system-power-controller");
1031 static struct rk818_board *rk818_parse_dt(struct i2c_client *i2c)
1037 static void rk818_shutdown(void)
1040 struct rk818 *rk818 = g_rk818;
1042 pr_info("%s\n", __func__);
1043 ret = rk818_set_bits(rk818, RK818_INT_STS_MSK_REG1,(0x3<<5),(0x3<<5)); //close rtc int when power off
1044 ret = rk818_clear_bits(rk818, RK818_RTC_INT_REG,(0x3<<2)); //close rtc int when power off
1045 mutex_lock(&rk818->io_lock);
1049 static struct syscore_ops rk818_syscore_ops = {
1050 .shutdown = rk818_shutdown,
1053 void rk818_device_shutdown(void)
1057 struct rk818 *rk818 = g_rk818;
1059 for (i = 0; i < 10; i++) {
1060 pr_info("%s\n", __func__);
1061 ret = rk818_i2c_read(rk818, RK818_DEVCTRL_REG, 1, ®);
1064 ret = rk818_i2c_write(rk818, RK818_DEVCTRL_REG, 1,
1065 (reg | (0x1 << 0)));
1067 pr_err("rk818 power off error!\n");
1073 EXPORT_SYMBOL_GPL(rk818_device_shutdown);
1075 __weak void rk818_device_suspend(void) {}
1076 __weak void rk818_device_resume(void) {}
1078 static int rk818_suspend(struct i2c_client *i2c, pm_message_t mesg)
1080 rk818_device_suspend();
1084 static int rk818_resume(struct i2c_client *i2c)
1086 rk818_device_resume();
1090 static int rk818_suspend(struct i2c_client *i2c, pm_message_t mesg)
1095 static int rk818_resume(struct i2c_client *i2c)
1101 static int rk818_pre_init(struct rk818 *rk818)
1104 printk("%s,line=%d\n", __func__,__LINE__);
1106 ret = rk818_set_bits(rk818, 0xa1,(0x7<<4),(0x7<<4)); //close charger when usb low then 3.4V
1107 ret = rk818_set_bits(rk818, 0x52,(0x1<<1),(0x1<<1)); //no action when vref
1109 /*******enable switch and boost***********/
1110 val = rk818_reg_read(rk818,RK818_DCDC_EN_REG);
1111 val |= (0x3 << 5); //enable switch1/2
1112 val |= (0x1 << 4); //enable boost
1113 ret = rk818_reg_write(rk818,RK818_DCDC_EN_REG,val);
1115 printk(KERN_ERR "Unable to write RK818_DCDC_EN_REG reg\n");
1118 /****************************************/
1120 /****************set vbat low **********/
1121 val = rk818_reg_read(rk818,RK818_VB_MON_REG);
1122 val &=(~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1123 val |= (RK818_VBAT_LOW_3V5 | EN_VBAT_LOW_IRQ);
1124 ret = rk818_reg_write(rk818,RK818_VB_MON_REG,val);
1126 printk(KERN_ERR "Unable to write RK818_VB_MON_REG reg\n");
1129 /**************************************/
1131 /**********mask int****************/
1132 val = rk818_reg_read(rk818,RK818_INT_STS_MSK_REG1);
1133 val |= (0x1<<0); //mask vout_lo_int
1134 ret = rk818_reg_write(rk818,RK818_INT_STS_MSK_REG1,val);
1136 printk(KERN_ERR "Unable to write RK818_INT_STS_MSK_REG1 reg\n");
1139 /**********************************/
1140 /**********enable clkout2****************/
1141 ret = rk818_reg_write(rk818,RK818_CLK32OUT_REG,0x01);
1143 printk(KERN_ERR "Unable to write RK818_CLK32OUT_REG reg\n");
1146 /**********************************/
1147 ret = rk818_clear_bits(rk818, RK818_INT_STS_MSK_REG1,(0x3<<5)); //open rtc int when power on
1148 ret = rk818_set_bits(rk818, RK818_RTC_INT_REG,(0x1<<3),(0x1<<3)); //open rtc int when power on
1152 static int rk818_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
1154 struct rk818 *rk818;
1155 struct rk818_board *pdev;
1156 const struct of_device_id *match;
1157 struct regulator_config config = { };
1158 struct regulator_dev *rk818_rdev;
1159 struct regulator_init_data *reg_data;
1160 const char *rail_name = NULL;
1163 printk("%s,line=%d\n", __func__,__LINE__);
1165 if (i2c->dev.of_node) {
1166 match = of_match_device(rk818_of_match, &i2c->dev);
1168 dev_err(&i2c->dev,"Failed to find matching dt id\n");
1173 rk818 = devm_kzalloc(&i2c->dev,sizeof(struct rk818), GFP_KERNEL);
1174 if (rk818 == NULL) {
1179 rk818->dev = &i2c->dev;
1180 i2c_set_clientdata(i2c, rk818);
1182 mutex_init(&rk818->io_lock);
1184 ret = rk818_reg_read(rk818,0x2f);
1185 if ((ret < 0) || (ret == 0xff)){
1186 printk("The device is not rk818 %d\n",ret);
1190 ret = rk818_pre_init(rk818);
1192 printk("The rk818_pre_init failed %d\n",ret);
1196 if (rk818->dev->of_node)
1197 pdev = rk818_parse_dt(rk818);
1199 /******************************set sleep vol & dcdc mode******************/
1201 rk818->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
1202 if (rk818->pmic_sleep_gpio) {
1203 ret = gpio_request(rk818->pmic_sleep_gpio, "rk818_pmic_sleep");
1205 dev_err(rk818->dev,"Failed to request gpio %d with ret:""%d\n", rk818->pmic_sleep_gpio, ret);
1208 gpio_direction_output(rk818->pmic_sleep_gpio,0);
1209 ret = gpio_get_value(rk818->pmic_sleep_gpio);
1210 gpio_free(rk818->pmic_sleep_gpio);
1211 pr_info("%s: rk818_pmic_sleep=%x\n", __func__, ret);
1214 /**********************************************************/
1217 rk818->num_regulators = rk818_NUM_REGULATORS;
1218 rk818->rdev = kcalloc(rk818_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
1222 /* Instantiate the regulators */
1223 for (i = 0; i < rk818_NUM_REGULATORS; i++) {
1224 reg_data = pdev->rk818_init_data[i];
1227 config.dev = rk818->dev;
1228 config.driver_data = rk818;
1229 if (rk818->dev->of_node)
1230 config.of_node = pdev->of_node[i];
1231 if (reg_data && reg_data->constraints.name)
1232 rail_name = reg_data->constraints.name;
1234 rail_name = regulators[i].name;
1235 reg_data->supply_regulator = rail_name;
1237 config.init_data =reg_data;
1239 rk818_rdev = regulator_register(®ulators[i],&config);
1240 if (IS_ERR(rk818_rdev)) {
1241 printk("failed to register %d regulator\n",i);
1244 rk818->rdev[i] = rk818_rdev;
1248 rk818->irq_gpio = pdev->irq_gpio;
1249 ret = rk818_irq_init(rk818, rk818->irq_gpio, pdev);
1253 ret = mfd_add_devices(rk818->dev, -1,
1254 rk818s, ARRAY_SIZE(rk818s),
1257 /********************vbat low int**************/
1258 vlow_irq = irq_create_mapping(rk818->irq_domain, RK818_IRQ_VB_LO);
1259 ret = devm_request_threaded_irq(&i2c->dev,vlow_irq, NULL, rk818_vbat_lo_irq,
1260 IRQF_ONESHOT, "rk818_vbatlow",
1263 dev_err(rk818->dev, "Failed to request periodic IRQ %d: %d\n",
1264 vlow_irq+ RK818_IRQ_VB_LO, ret);
1268 /*********************************************/
1271 if (pdev->pm_off && !pm_power_off) {
1272 pm_power_off = rk818_device_shutdown;
1276 rk818_kobj = kobject_create_and_add("rk818", NULL);
1279 for (i = 0; i < ARRAY_SIZE(rk818_attrs); i++) {
1280 ret = sysfs_create_file(rk818_kobj, &rk818_attrs[i].attr);
1282 printk("create index %d error\n", i);
1288 register_syscore_ops(&rk818_syscore_ops);
1293 mfd_remove_devices(rk818->dev);
1298 static int rk818_i2c_remove(struct i2c_client *i2c)
1300 struct rk818 *rk818 = i2c_get_clientdata(i2c);
1303 unregister_syscore_ops(&rk818_syscore_ops);
1304 for (i = 0; i < rk818->num_regulators; i++)
1306 regulator_unregister(rk818->rdev[i]);
1307 i2c_set_clientdata(i2c, NULL);
1313 static const struct i2c_device_id rk818_i2c_id[] = {
1318 MODULE_DEVICE_TABLE(i2c, rk818_i2c_id);
1320 static struct i2c_driver rk818_i2c_driver = {
1323 .owner = THIS_MODULE,
1324 .of_match_table =of_match_ptr(rk818_of_match),
1326 .probe = rk818_i2c_probe,
1327 .remove = rk818_i2c_remove,
1328 .id_table = rk818_i2c_id,
1330 .suspend = rk818_suspend,
1331 .resume = rk818_resume,
1335 static int __init rk818_module_init(void)
1338 ret = i2c_add_driver(&rk818_i2c_driver);
1340 pr_err("Failed to register I2C driver: %d\n", ret);
1344 subsys_initcall_sync(rk818_module_init);
1346 static void __exit rk818_module_exit(void)
1348 i2c_del_driver(&rk818_i2c_driver);
1350 module_exit(rk818_module_exit);
1352 MODULE_LICENSE("GPL");
1353 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1354 MODULE_DESCRIPTION("rk818 PMIC driver");