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
1150 /*****disable otg and boost when in sleep mode****/
1151 val = rk818_reg_read(rk818, RK818_SLEEP_SET_OFF_REG1);
1152 val |= ((0x1 << 7) | (0x1 << 4));
1153 ret = rk818_reg_write(rk818, RK818_SLEEP_SET_OFF_REG1, val);
1155 pr_err("Unable to write RK818_SLEEP_SET_OFF_REG1 reg\n");
1162 static int rk818_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
1164 struct rk818 *rk818;
1165 struct rk818_board *pdev;
1166 const struct of_device_id *match;
1167 struct regulator_config config = { };
1168 struct regulator_dev *rk818_rdev;
1169 struct regulator_init_data *reg_data;
1170 const char *rail_name = NULL;
1173 printk("%s,line=%d\n", __func__,__LINE__);
1175 if (i2c->dev.of_node) {
1176 match = of_match_device(rk818_of_match, &i2c->dev);
1178 dev_err(&i2c->dev,"Failed to find matching dt id\n");
1183 rk818 = devm_kzalloc(&i2c->dev,sizeof(struct rk818), GFP_KERNEL);
1184 if (rk818 == NULL) {
1189 rk818->dev = &i2c->dev;
1190 i2c_set_clientdata(i2c, rk818);
1192 mutex_init(&rk818->io_lock);
1194 ret = rk818_reg_read(rk818,0x2f);
1195 if ((ret < 0) || (ret == 0xff)){
1196 printk("The device is not rk818 %d\n",ret);
1200 ret = rk818_pre_init(rk818);
1202 printk("The rk818_pre_init failed %d\n",ret);
1206 if (rk818->dev->of_node)
1207 pdev = rk818_parse_dt(rk818);
1209 /******************************set sleep vol & dcdc mode******************/
1211 rk818->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
1212 if (rk818->pmic_sleep_gpio) {
1213 ret = gpio_request(rk818->pmic_sleep_gpio, "rk818_pmic_sleep");
1215 dev_err(rk818->dev,"Failed to request gpio %d with ret:""%d\n", rk818->pmic_sleep_gpio, ret);
1218 gpio_direction_output(rk818->pmic_sleep_gpio,0);
1219 ret = gpio_get_value(rk818->pmic_sleep_gpio);
1220 gpio_free(rk818->pmic_sleep_gpio);
1221 pr_info("%s: rk818_pmic_sleep=%x\n", __func__, ret);
1224 /**********************************************************/
1227 rk818->num_regulators = rk818_NUM_REGULATORS;
1228 rk818->rdev = kcalloc(rk818_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
1232 /* Instantiate the regulators */
1233 for (i = 0; i < rk818_NUM_REGULATORS; i++) {
1234 reg_data = pdev->rk818_init_data[i];
1237 config.dev = rk818->dev;
1238 config.driver_data = rk818;
1239 if (rk818->dev->of_node)
1240 config.of_node = pdev->of_node[i];
1241 if (reg_data && reg_data->constraints.name)
1242 rail_name = reg_data->constraints.name;
1244 rail_name = regulators[i].name;
1245 reg_data->supply_regulator = rail_name;
1247 config.init_data =reg_data;
1249 rk818_rdev = regulator_register(®ulators[i],&config);
1250 if (IS_ERR(rk818_rdev)) {
1251 printk("failed to register %d regulator\n",i);
1254 rk818->rdev[i] = rk818_rdev;
1258 rk818->irq_gpio = pdev->irq_gpio;
1259 ret = rk818_irq_init(rk818, rk818->irq_gpio, pdev);
1263 ret = mfd_add_devices(rk818->dev, -1,
1264 rk818s, ARRAY_SIZE(rk818s),
1267 /********************vbat low int**************/
1268 vlow_irq = irq_create_mapping(rk818->irq_domain, RK818_IRQ_VB_LO);
1269 ret = devm_request_threaded_irq(&i2c->dev,vlow_irq, NULL, rk818_vbat_lo_irq,
1270 IRQF_ONESHOT, "rk818_vbatlow",
1273 dev_err(rk818->dev, "Failed to request periodic IRQ %d: %d\n",
1274 vlow_irq+ RK818_IRQ_VB_LO, ret);
1278 /*********************************************/
1281 if (pdev->pm_off && !pm_power_off) {
1282 pm_power_off = rk818_device_shutdown;
1286 rk818_kobj = kobject_create_and_add("rk818", NULL);
1289 for (i = 0; i < ARRAY_SIZE(rk818_attrs); i++) {
1290 ret = sysfs_create_file(rk818_kobj, &rk818_attrs[i].attr);
1292 printk("create index %d error\n", i);
1298 register_syscore_ops(&rk818_syscore_ops);
1303 mfd_remove_devices(rk818->dev);
1308 static int rk818_i2c_remove(struct i2c_client *i2c)
1310 struct rk818 *rk818 = i2c_get_clientdata(i2c);
1313 unregister_syscore_ops(&rk818_syscore_ops);
1314 for (i = 0; i < rk818->num_regulators; i++)
1316 regulator_unregister(rk818->rdev[i]);
1317 i2c_set_clientdata(i2c, NULL);
1323 static const struct i2c_device_id rk818_i2c_id[] = {
1328 MODULE_DEVICE_TABLE(i2c, rk818_i2c_id);
1330 static struct i2c_driver rk818_i2c_driver = {
1333 .owner = THIS_MODULE,
1334 .of_match_table =of_match_ptr(rk818_of_match),
1336 .probe = rk818_i2c_probe,
1337 .remove = rk818_i2c_remove,
1338 .id_table = rk818_i2c_id,
1340 .suspend = rk818_suspend,
1341 .resume = rk818_resume,
1345 static int __init rk818_module_init(void)
1348 ret = i2c_add_driver(&rk818_i2c_driver);
1350 pr_err("Failed to register I2C driver: %d\n", ret);
1354 subsys_initcall_sync(rk818_module_init);
1356 static void __exit rk818_module_exit(void)
1358 i2c_del_driver(&rk818_i2c_driver);
1360 module_exit(rk818_module_exit);
1362 MODULE_LICENSE("GPL");
1363 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1364 MODULE_DESCRIPTION("rk818 PMIC driver");