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 sscanf(buftmp, "%c ", &cmd);
877 printk("------zhangqing: get cmd = %c\n", cmd);
880 sscanf(buftmp, "%c %x %x ", &cmd, &getdata[0], &getdata[1]);
881 regAddr = (u8)(getdata[0] & 0xff);
882 data = (u8)(getdata[1] & 0xff);
883 printk("get value = %x\n", data);
885 rk818_i2c_write(rk818, regAddr, 1, data);
886 rk818_i2c_read(rk818, regAddr, 1, &data);
887 printk("%x %x\n", getdata[1], data);
890 sscanf(buftmp, "%c %x ", &cmd, &getdata[0]);
891 printk("CMD : %c %x\n", cmd, getdata[0]);
893 regAddr = (u8)(getdata[0] & 0xff);
894 rk818_i2c_read(rk818, regAddr, 1, &data);
895 printk("%x %x\n", getdata[0], data);
898 printk("Unknown command\n");
904 static ssize_t rk818_test_show(struct kobject *kobj, struct kobj_attribute *attr,
909 return sprintf(s, "%s\n", buf);
913 static struct kobject *rk818_kobj;
914 struct rk818_attribute {
915 struct attribute attr;
916 ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,
918 ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,
919 const char *buf, size_t n);
922 static struct rk818_attribute rk818_attrs[] = {
923 /* node_name permision show_func store_func */
924 __ATTR(rk818_test, S_IRUGO | S_IWUSR, rk818_test_show, rk818_test_store),
929 extern void rk_send_wakeup_key(void);
930 static irqreturn_t rk818_vbat_lo_irq(int irq, void *data)
932 printk("rk818 vbat low %s:irq=%d\n",__func__,irq);
933 rk818_set_bits(g_rk818,0x4c,(0x1 << 1),(0x1 <<1));
934 rk_send_wakeup_key();
940 static struct of_device_id rk818_of_match[] = {
941 { .compatible = "rockchip,rk818"},
944 MODULE_DEVICE_TABLE(of, rk818_of_match);
948 static struct of_regulator_match rk818_reg_matches[] = {
949 { .name = "rk818_dcdc1", .driver_data = (void *)0 },
950 { .name = "rk818_dcdc2", .driver_data = (void *)1 },
951 { .name = "rk818_dcdc3", .driver_data = (void *)2 },
952 { .name = "rk818_dcdc4", .driver_data = (void *)3 },
953 { .name = "rk818_ldo1", .driver_data = (void *)4 },
954 { .name = "rk818_ldo2", .driver_data = (void *)5 },
955 { .name = "rk818_ldo3", .driver_data = (void *)6 },
956 { .name = "rk818_ldo4", .driver_data = (void *)7 },
957 { .name = "rk818_ldo5", .driver_data = (void *)8 },
958 { .name = "rk818_ldo6", .driver_data = (void *)9 },
959 { .name = "rk818_ldo7", .driver_data = (void *)10 },
960 { .name = "rk818_ldo8", .driver_data = (void *)11 },
961 { .name = "rk818_ldo9", .driver_data = (void *)12 },
962 { .name = "rk818_ldo10", .driver_data = (void *)13 },
965 static struct rk818_board *rk818_parse_dt(struct rk818 *rk818)
967 struct rk818_board *pdata;
968 struct device_node *regs,*rk818_pmic_np;
971 rk818_pmic_np = of_node_get(rk818->dev->of_node);
972 if (!rk818_pmic_np) {
973 printk("could not find pmic sub-node\n");
977 regs = of_find_node_by_name(rk818_pmic_np, "regulators");
981 count = of_regulator_match(rk818->dev, regs, rk818_reg_matches,
982 rk818_NUM_REGULATORS);
984 if ((count < 0) || (count > rk818_NUM_REGULATORS))
987 pdata = devm_kzalloc(rk818->dev, sizeof(*pdata), GFP_KERNEL);
991 for (i = 0; i < count; i++) {
992 if (!rk818_reg_matches[i].init_data || !rk818_reg_matches[i].of_node)
995 pdata->rk818_init_data[i] = rk818_reg_matches[i].init_data;
996 pdata->of_node[i] = rk818_reg_matches[i].of_node;
998 pdata->irq = rk818->chip_irq;
999 pdata->irq_base = -1;
1001 pdata->irq_gpio = of_get_named_gpio(rk818_pmic_np,"gpios",0);
1002 if (!gpio_is_valid(pdata->irq_gpio)) {
1003 printk("invalid gpio: %d\n", pdata->irq_gpio);
1007 pdata->pmic_sleep_gpio = of_get_named_gpio(rk818_pmic_np,"gpios",1);
1008 if (!gpio_is_valid(pdata->pmic_sleep_gpio)) {
1009 printk("invalid gpio: %d\n", pdata->pmic_sleep_gpio);
1011 pdata->pmic_sleep = true;
1012 pdata->pm_off = of_property_read_bool(rk818_pmic_np,"rk818,system-power-controller");
1018 static struct rk818_board *rk818_parse_dt(struct i2c_client *i2c)
1024 static void rk818_shutdown(void)
1027 struct rk818 *rk818 = g_rk818;
1029 pr_info("%s\n", __func__);
1030 ret = rk818_set_bits(rk818, RK818_INT_STS_MSK_REG1,(0x3<<5),(0x3<<5)); //close rtc int when power off
1031 ret = rk818_clear_bits(rk818, RK818_RTC_INT_REG,(0x3<<2)); //close rtc int when power off
1032 mutex_lock(&rk818->io_lock);
1036 static struct syscore_ops rk818_syscore_ops = {
1037 .shutdown = rk818_shutdown,
1040 void rk818_device_shutdown(void)
1044 struct rk818 *rk818 = g_rk818;
1046 for (i = 0; i < 10; i++) {
1047 pr_info("%s\n", __func__);
1048 ret = rk818_i2c_read(rk818, RK818_DEVCTRL_REG, 1, ®);
1051 ret = rk818_i2c_write(rk818, RK818_DEVCTRL_REG, 1,
1052 (reg | (0x1 << 0)));
1054 pr_err("rk818 power off error!\n");
1060 EXPORT_SYMBOL_GPL(rk818_device_shutdown);
1062 __weak void rk818_device_suspend(void) {}
1063 __weak void rk818_device_resume(void) {}
1065 static int rk818_suspend(struct i2c_client *i2c, pm_message_t mesg)
1067 rk818_device_suspend();
1071 static int rk818_resume(struct i2c_client *i2c)
1073 rk818_device_resume();
1077 static int rk818_suspend(struct i2c_client *i2c, pm_message_t mesg)
1082 static int rk818_resume(struct i2c_client *i2c)
1088 static int rk818_pre_init(struct rk818 *rk818)
1091 printk("%s,line=%d\n", __func__,__LINE__);
1093 ret = rk818_set_bits(rk818, 0xa1,(0x7<<4),(0x7<<4)); //close charger when usb low then 3.4V
1094 ret = rk818_set_bits(rk818, 0x52,(0x1<<1),(0x1<<1)); //no action when vref
1095 ret = rk818_set_bits(rk818, 0x52,(0x1<<0),(0x1<<0)); //enable HDMI 5V
1097 /*******enable switch and boost***********/
1098 val = rk818_reg_read(rk818,RK818_DCDC_EN_REG);
1099 val |= (0x3 << 5); //enable switch1/2
1100 val |= (0x1 << 4); //enable boost
1101 ret = rk818_reg_write(rk818,RK818_DCDC_EN_REG,val);
1103 printk(KERN_ERR "Unable to write RK818_DCDC_EN_REG reg\n");
1106 /****************************************/
1108 /****************set vbat low **********/
1109 val = rk818_reg_read(rk818,RK818_VB_MON_REG);
1110 val &=(~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1111 val |= (RK818_VBAT_LOW_3V5 | EN_VBAT_LOW_IRQ);
1112 ret = rk818_reg_write(rk818,RK818_VB_MON_REG,val);
1114 printk(KERN_ERR "Unable to write RK818_VB_MON_REG reg\n");
1117 /**************************************/
1119 /**********mask int****************/
1120 val = rk818_reg_read(rk818,RK818_INT_STS_MSK_REG1);
1121 val |= (0x1<<0); //mask vout_lo_int
1122 ret = rk818_reg_write(rk818,RK818_INT_STS_MSK_REG1,val);
1124 printk(KERN_ERR "Unable to write RK818_INT_STS_MSK_REG1 reg\n");
1127 /**********************************/
1128 /**********enable clkout2****************/
1129 ret = rk818_reg_write(rk818,RK818_CLK32OUT_REG,0x01);
1131 printk(KERN_ERR "Unable to write RK818_CLK32OUT_REG reg\n");
1134 /**********************************/
1135 ret = rk818_clear_bits(rk818, RK818_INT_STS_MSK_REG1,(0x3<<5)); //open rtc int when power on
1136 ret = rk818_set_bits(rk818, RK818_RTC_INT_REG,(0x1<<3),(0x1<<3)); //open rtc int when power on
1138 /*****disable otg and boost when in sleep mode****/
1139 val = rk818_reg_read(rk818, RK818_SLEEP_SET_OFF_REG1);
1140 val |= ((0x1 << 7) | (0x1 << 4));
1141 ret = rk818_reg_write(rk818, RK818_SLEEP_SET_OFF_REG1, val);
1143 pr_err("Unable to write RK818_SLEEP_SET_OFF_REG1 reg\n");
1150 static int rk818_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
1152 struct rk818 *rk818;
1153 struct rk818_board *pdev;
1154 const struct of_device_id *match;
1155 struct regulator_config config = { };
1156 struct regulator_dev *rk818_rdev;
1157 struct regulator_init_data *reg_data;
1158 const char *rail_name = NULL;
1161 printk("%s,line=%d\n", __func__,__LINE__);
1163 if (i2c->dev.of_node) {
1164 match = of_match_device(rk818_of_match, &i2c->dev);
1166 dev_err(&i2c->dev,"Failed to find matching dt id\n");
1171 rk818 = devm_kzalloc(&i2c->dev,sizeof(struct rk818), GFP_KERNEL);
1172 if (rk818 == NULL) {
1177 rk818->dev = &i2c->dev;
1178 i2c_set_clientdata(i2c, rk818);
1180 mutex_init(&rk818->io_lock);
1182 ret = rk818_reg_read(rk818,0x2f);
1183 if ((ret < 0) || (ret == 0xff)){
1184 printk("The device is not rk818 %d\n",ret);
1188 ret = rk818_pre_init(rk818);
1190 printk("The rk818_pre_init failed %d\n",ret);
1194 if (rk818->dev->of_node)
1195 pdev = rk818_parse_dt(rk818);
1197 /******************************set sleep vol & dcdc mode******************/
1199 rk818->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
1200 if (rk818->pmic_sleep_gpio) {
1201 ret = gpio_request(rk818->pmic_sleep_gpio, "rk818_pmic_sleep");
1203 dev_err(rk818->dev,"Failed to request gpio %d with ret:""%d\n", rk818->pmic_sleep_gpio, ret);
1206 gpio_direction_output(rk818->pmic_sleep_gpio,0);
1207 ret = gpio_get_value(rk818->pmic_sleep_gpio);
1208 gpio_free(rk818->pmic_sleep_gpio);
1209 pr_info("%s: rk818_pmic_sleep=%x\n", __func__, ret);
1212 /**********************************************************/
1215 rk818->num_regulators = rk818_NUM_REGULATORS;
1216 rk818->rdev = kcalloc(rk818_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
1220 /* Instantiate the regulators */
1221 for (i = 0; i < rk818_NUM_REGULATORS; i++) {
1222 reg_data = pdev->rk818_init_data[i];
1225 config.dev = rk818->dev;
1226 config.driver_data = rk818;
1227 if (rk818->dev->of_node)
1228 config.of_node = pdev->of_node[i];
1229 if (reg_data && reg_data->constraints.name)
1230 rail_name = reg_data->constraints.name;
1232 rail_name = regulators[i].name;
1233 reg_data->supply_regulator = rail_name;
1235 config.init_data =reg_data;
1237 rk818_rdev = regulator_register(®ulators[i],&config);
1238 if (IS_ERR(rk818_rdev)) {
1239 printk("failed to register %d regulator\n",i);
1242 rk818->rdev[i] = rk818_rdev;
1246 rk818->irq_gpio = pdev->irq_gpio;
1247 ret = rk818_irq_init(rk818, rk818->irq_gpio, pdev);
1251 ret = mfd_add_devices(rk818->dev, -1,
1252 rk818s, ARRAY_SIZE(rk818s),
1255 /********************vbat low int**************/
1256 vlow_irq = irq_create_mapping(rk818->irq_domain, RK818_IRQ_VB_LO);
1257 ret = devm_request_threaded_irq(&i2c->dev,vlow_irq, NULL, rk818_vbat_lo_irq,
1258 IRQF_ONESHOT, "rk818_vbatlow",
1261 dev_err(rk818->dev, "Failed to request periodic IRQ %d: %d\n",
1262 vlow_irq+ RK818_IRQ_VB_LO, ret);
1266 /*********************************************/
1269 if (pdev->pm_off && !pm_power_off) {
1270 pm_power_off = rk818_device_shutdown;
1274 rk818_kobj = kobject_create_and_add("rk818", NULL);
1277 for (i = 0; i < ARRAY_SIZE(rk818_attrs); i++) {
1278 ret = sysfs_create_file(rk818_kobj, &rk818_attrs[i].attr);
1280 printk("create index %d error\n", i);
1286 register_syscore_ops(&rk818_syscore_ops);
1291 mfd_remove_devices(rk818->dev);
1296 static int rk818_i2c_remove(struct i2c_client *i2c)
1298 struct rk818 *rk818 = i2c_get_clientdata(i2c);
1301 unregister_syscore_ops(&rk818_syscore_ops);
1302 for (i = 0; i < rk818->num_regulators; i++)
1304 regulator_unregister(rk818->rdev[i]);
1305 i2c_set_clientdata(i2c, NULL);
1311 static const struct i2c_device_id rk818_i2c_id[] = {
1316 MODULE_DEVICE_TABLE(i2c, rk818_i2c_id);
1318 static struct i2c_driver rk818_i2c_driver = {
1321 .owner = THIS_MODULE,
1322 .of_match_table =of_match_ptr(rk818_of_match),
1324 .probe = rk818_i2c_probe,
1325 .remove = rk818_i2c_remove,
1326 .id_table = rk818_i2c_id,
1328 .suspend = rk818_suspend,
1329 .resume = rk818_resume,
1333 static int __init rk818_module_init(void)
1336 ret = i2c_add_driver(&rk818_i2c_driver);
1338 pr_err("Failed to register I2C driver: %d\n", ret);
1342 subsys_initcall_sync(rk818_module_init);
1344 static void __exit rk818_module_exit(void)
1346 i2c_del_driver(&rk818_i2c_driver);
1348 module_exit(rk818_module_exit);
1350 MODULE_LICENSE("GPL");
1351 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1352 MODULE_DESCRIPTION("rk818 PMIC driver");