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 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);
282 int rk818_ldo_slp_enable(int ldo_id)
284 int ldo = ldo_id - 1;
287 return rk818_set_bits(g_rk818, RK818_SLEEP_SET_OFF_REG1,
290 return rk818_set_bits(g_rk818, RK818_SLEEP_SET_OFF_REG1,
291 1 << 6, 0); /*ldo10 switch*/
293 return rk818_set_bits(g_rk818, RK818_SLEEP_SET_OFF_REG2,
297 int rk818_ldo_slp_disable(int ldo_id)
299 int ldo = ldo_id - 1;
302 return rk818_set_bits(g_rk818, RK818_SLEEP_SET_OFF_REG1,
303 1 << 5, 1 << 5); /*ldo9*/
305 return rk818_set_bits(g_rk818, RK818_SLEEP_SET_OFF_REG1,
306 1 << 6, 1 << 6); /*ldo10 switch*/
308 return rk818_set_bits(g_rk818, RK818_SLEEP_SET_OFF_REG2,
312 static int rk818_ldo_set_sleep_voltage(struct regulator_dev *dev,
315 struct rk818 *rk818 = rdev_get_drvdata(dev);
316 int ldo= rdev_get_id(dev) - RK818_LDO1;
317 const int *vol_map = ldo_voltage_map;
318 int min_vol = uV / 1000;
323 vol_map = ldo3_voltage_map;
326 else if (ldo == 5 || ldo ==6){
327 vol_map = ldo6_voltage_map;
334 if (min_vol < vol_map[0] ||
335 min_vol > vol_map[num])
338 for (val = 0; val <= num; val++){
339 if (vol_map[val] >= min_vol)
344 ret = rk818_set_bits(rk818, rk818_LDO_SET_SLP_VOL_REG(ldo),LDO9_VOL_MASK, val);
347 ret = rk818_set_bits(rk818, rk818_LDO_SET_SLP_VOL_REG(ldo),LDO_VOL_MASK, val);
352 static int rk818_ldo_set_voltage(struct regulator_dev *dev,
353 int min_uV, int max_uV,unsigned *selector)
355 struct rk818 *rk818 = rdev_get_drvdata(dev);
356 int ldo= rdev_get_id(dev) - RK818_LDO1;
358 int min_vol = min_uV / 1000;
363 vol_map = ldo3_voltage_map;
366 else if (ldo == 5 || ldo ==6){
367 vol_map = ldo6_voltage_map;
371 vol_map = ldo_voltage_map;
375 if (min_vol < vol_map[0] ||
376 min_vol > vol_map[num])
379 for (val = 0; val <= num; val++){
380 if (vol_map[val] >= min_vol)
385 ret = rk818_set_bits(rk818, rk818_LDO_SET_VOL_REG(ldo),LDO9_VOL_MASK, val);
388 ret = rk818_set_bits(rk818, rk818_LDO_SET_VOL_REG(ldo),LDO_VOL_MASK, val);
394 static struct regulator_ops rk818_ldo_ops = {
395 .set_voltage = rk818_ldo_set_voltage,
396 .get_voltage = rk818_ldo_get_voltage,
397 .list_voltage = rk818_ldo_list_voltage,
398 .is_enabled = rk818_ldo_is_enabled,
399 .enable = rk818_ldo_enable,
400 .disable = rk818_ldo_disable,
401 .set_suspend_enable =rk818_ldo_suspend_enable,
402 .set_suspend_disable =rk818_ldo_suspend_disable,
403 .set_suspend_voltage = rk818_ldo_set_sleep_voltage,
406 static int rk818_dcdc_list_voltage(struct regulator_dev *dev, unsigned selector)
409 int buck = rdev_get_id(dev) - RK818_DCDC1;
411 if (selector < 0x0 ||selector > BUCK_VOL_MASK )
417 volt = 712500 + selector * 12500;
420 volt = 1800000 + selector * 100000;
432 static int rk818_dcdc_is_enabled(struct regulator_dev *dev)
434 struct rk818 *rk818 = rdev_get_drvdata(dev);
435 int buck = rdev_get_id(dev) - RK818_DCDC1;
438 val = rk818_reg_read(rk818, RK818_DCDC_EN_REG);
441 if (val & (1 << buck))
446 static int rk818_dcdc_enable(struct regulator_dev *dev)
448 struct rk818 *rk818 = rdev_get_drvdata(dev);
449 int buck = rdev_get_id(dev) - RK818_DCDC1;
451 return rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << buck, 1 << buck);
454 static int rk818_dcdc_disable(struct regulator_dev *dev)
456 struct rk818 *rk818 = rdev_get_drvdata(dev);
457 int buck = rdev_get_id(dev) - RK818_DCDC1;
459 return rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << buck , 0);
461 static int rk818_dcdc_get_voltage(struct regulator_dev *dev)
463 struct rk818 *rk818 = rdev_get_drvdata(dev);
464 int buck = rdev_get_id(dev) - RK818_DCDC1;
468 reg = rk818_reg_read(rk818,rk818_BUCK_SET_VOL_REG(buck));
470 reg &= BUCK_VOL_MASK;
471 val = rk818_dcdc_list_voltage(dev,reg);
474 static int rk818_dcdc_select_min_voltage(struct regulator_dev *dev,
475 int min_uV, int max_uV ,int buck)
479 if (buck == 0 || buck == 1){
482 else if (min_uV <= 1500000)
483 vsel = ((min_uV - 712500) / 12500) ;
488 if (min_uV < 1800000)
490 else if (min_uV <= 3300000)
491 vsel = ((min_uV - 1800000) / 100000) ;
495 if (rk818_dcdc_list_voltage(dev, vsel) > max_uV)
500 static int rk818_dcdc_set_voltage(struct regulator_dev *dev,
501 int min_uV, int max_uV,unsigned *selector)
503 struct rk818 *rk818 = rdev_get_drvdata(dev);
504 int buck = rdev_get_id(dev) - RK818_DCDC1;
511 val = rk818_dcdc_select_min_voltage(dev,min_uV,max_uV,buck);
512 ret = rk818_set_bits(rk818, rk818_BUCK_SET_VOL_REG(buck), BUCK_VOL_MASK, val);
514 val = rk818_dcdc_select_min_voltage(dev,min_uV,max_uV,buck);
515 ret = rk818_set_bits(rk818, rk818_BUCK_SET_VOL_REG(buck), BUCK_VOL_MASK, val);
518 static int rk818_dcdc_set_sleep_voltage(struct regulator_dev *dev,
521 struct rk818 *rk818 = rdev_get_drvdata(dev);
522 int buck = rdev_get_id(dev) - RK818_DCDC1;
529 val = rk818_dcdc_select_min_voltage(dev,uV,uV,buck);
530 ret = rk818_set_bits(rk818, rk818_BUCK_SET_SLP_VOL_REG(buck) , BUCK_VOL_MASK, val);
534 static unsigned int rk818_dcdc_get_mode(struct regulator_dev *dev)
536 struct rk818 *rk818 = rdev_get_drvdata(dev);
537 int buck = rdev_get_id(dev) - RK818_DCDC1;
540 val = rk818_reg_read(rk818, rk818_BUCK_SET_VOL_REG(buck));
546 return REGULATOR_MODE_FAST;
548 return REGULATOR_MODE_NORMAL;
551 static int rk818_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
553 struct rk818 *rk818 = rdev_get_drvdata(dev);
554 int buck = rdev_get_id(dev) - RK818_DCDC1;
558 case REGULATOR_MODE_FAST:
559 return rk818_set_bits(rk818, rk818_BUCK_SET_VOL_REG(buck), mask, mask);
560 case REGULATOR_MODE_NORMAL:
561 return rk818_set_bits(rk818, rk818_BUCK_SET_VOL_REG(buck), mask, 0);
563 printk("error:pmu_rk818 only powersave and pwm mode\n");
568 static int rk818_dcdc_set_voltage_time_sel(struct regulator_dev *dev, unsigned int old_selector,
569 unsigned int new_selector)
571 int old_volt, new_volt;
573 old_volt = rk818_dcdc_list_voltage(dev, old_selector);
577 new_volt = rk818_dcdc_list_voltage(dev, new_selector);
581 return DIV_ROUND_UP(abs(old_volt - new_volt)*2, 2500);
584 static int rk818_dcdc_suspend_enable(struct regulator_dev *dev)
586 struct rk818 *rk818 = rdev_get_drvdata(dev);
587 int buck = rdev_get_id(dev) - RK818_DCDC1;
589 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << buck, 0);
592 static int rk818_dcdc_suspend_disable(struct regulator_dev *dev)
594 struct rk818 *rk818 = rdev_get_drvdata(dev);
595 int buck = rdev_get_id(dev) - RK818_DCDC1;
597 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << buck , 1 << buck);
599 static int rk818_dcdc_set_suspend_mode(struct regulator_dev *dev, unsigned int mode)
601 struct rk818 *rk818 = rdev_get_drvdata(dev);
602 int buck = rdev_get_id(dev) - RK818_DCDC1;
607 case REGULATOR_MODE_FAST:
608 return rk818_set_bits(rk818, (rk818_BUCK_SET_VOL_REG(buck) + 0x01), mask, mask);
609 case REGULATOR_MODE_NORMAL:
610 return rk818_set_bits(rk818, (rk818_BUCK_SET_VOL_REG(buck) + 0x01), mask, 0);
612 printk("error:pmu_rk818 only powersave and pwm mode\n");
617 static struct regulator_ops rk818_dcdc_ops = {
618 .set_voltage = rk818_dcdc_set_voltage,
619 .get_voltage = rk818_dcdc_get_voltage,
620 .list_voltage= rk818_dcdc_list_voltage,
621 .is_enabled = rk818_dcdc_is_enabled,
622 .enable = rk818_dcdc_enable,
623 .disable = rk818_dcdc_disable,
624 .get_mode = rk818_dcdc_get_mode,
625 .set_mode = rk818_dcdc_set_mode,
626 .set_suspend_enable =rk818_dcdc_suspend_enable,
627 .set_suspend_disable =rk818_dcdc_suspend_disable,
628 .set_suspend_mode = rk818_dcdc_set_suspend_mode,
629 .set_suspend_voltage = rk818_dcdc_set_sleep_voltage,
630 .set_voltage_time_sel = rk818_dcdc_set_voltage_time_sel,
632 static struct regulator_desc regulators[] = {
635 .name = "RK818_DCDC1",
637 .ops = &rk818_dcdc_ops,
638 .n_voltages = ARRAY_SIZE(buck_voltage_map),
639 .type = REGULATOR_VOLTAGE,
640 .owner = THIS_MODULE,
643 .name = "RK818_DCDC2",
645 .ops = &rk818_dcdc_ops,
646 .n_voltages = ARRAY_SIZE(buck_voltage_map),
647 .type = REGULATOR_VOLTAGE,
648 .owner = THIS_MODULE,
651 .name = "RK818_DCDC3",
653 .ops = &rk818_dcdc_ops,
654 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
655 .type = REGULATOR_VOLTAGE,
656 .owner = THIS_MODULE,
659 .name = "RK818_DCDC4",
661 .ops = &rk818_dcdc_ops,
662 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
663 .type = REGULATOR_VOLTAGE,
664 .owner = THIS_MODULE,
668 .name = "RK818_LDO1",
670 .ops = &rk818_ldo_ops,
671 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
672 .type = REGULATOR_VOLTAGE,
673 .owner = THIS_MODULE,
676 .name = "RK818_LDO2",
678 .ops = &rk818_ldo_ops,
679 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
680 .type = REGULATOR_VOLTAGE,
681 .owner = THIS_MODULE,
684 .name = "RK818_LDO3",
686 .ops = &rk818_ldo_ops,
687 .n_voltages = ARRAY_SIZE(ldo3_voltage_map),
688 .type = REGULATOR_VOLTAGE,
689 .owner = THIS_MODULE,
692 .name = "RK818_LDO4",
694 .ops = &rk818_ldo_ops,
695 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
696 .type = REGULATOR_VOLTAGE,
697 .owner = THIS_MODULE,
701 .name = "RK818_LDO5",
703 .ops = &rk818_ldo_ops,
704 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
705 .type = REGULATOR_VOLTAGE,
706 .owner = THIS_MODULE,
709 .name = "RK818_LDO6",
711 .ops = &rk818_ldo_ops,
712 .n_voltages = ARRAY_SIZE(ldo6_voltage_map),
713 .type = REGULATOR_VOLTAGE,
714 .owner = THIS_MODULE,
717 .name = "RK818_LDO7",
719 .ops = &rk818_ldo_ops,
720 .n_voltages = ARRAY_SIZE(ldo6_voltage_map),
721 .type = REGULATOR_VOLTAGE,
722 .owner = THIS_MODULE,
725 .name = "RK818_LDO8",
727 .ops = &rk818_ldo_ops,
728 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
729 .type = REGULATOR_VOLTAGE,
730 .owner = THIS_MODULE,
733 .name = "RK818_LDO9",
735 .ops = &rk818_ldo_ops,
736 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
737 .type = REGULATOR_VOLTAGE,
738 .owner = THIS_MODULE,
741 .name = "RK818_LDO10",
743 .ops = &rk818_ldo_ops,
744 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
745 .type = REGULATOR_VOLTAGE,
746 .owner = THIS_MODULE,
754 int rk818_i2c_read(struct rk818 *rk818, char reg, int count,u8 *dest)
756 struct i2c_client *i2c = rk818->i2c;
759 struct i2c_adapter *adap;
760 struct i2c_msg msgs[2];
770 msgs[0].addr = i2c->addr;
774 msgs[0].scl_rate = 200*1000;
777 msgs[1].addr = i2c->addr;
778 msgs[1].flags = I2C_M_RD;
780 msgs[1].scl_rate = RK818_I2C_ADDR_RATE;
782 ret = i2c_transfer(adap, msgs, 2);
784 DBG("***run in %s %x % x\n",__FUNCTION__,i2c->addr,msgs[0].buf);
788 int rk818_i2c_write(struct rk818 *rk818, char reg, int count, const u8 src)
791 struct i2c_client *i2c = rk818->i2c;
792 struct i2c_adapter *adap;
805 msg.addr = i2c->addr;
806 msg.buf = &tx_buf[0];
808 msg.flags = i2c->flags;
809 msg.scl_rate = RK818_I2C_ADDR_RATE;
811 ret = i2c_transfer(adap, &msg, 1);
815 u8 rk818_reg_read(struct rk818 *rk818, u8 reg)
819 mutex_lock(&rk818->io_lock);
821 rk818_i2c_read(rk818, reg, 1, &val);
823 DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
825 mutex_unlock(&rk818->io_lock);
829 EXPORT_SYMBOL_GPL(rk818_reg_read);
831 int rk818_reg_write(struct rk818 *rk818, u8 reg, u8 val)
835 mutex_lock(&rk818->io_lock);
837 err = rk818_i2c_write(rk818, reg, 1,val);
839 dev_err(rk818->dev, "Write for reg 0x%x failed\n", reg);
841 mutex_unlock(&rk818->io_lock);
844 EXPORT_SYMBOL_GPL(rk818_reg_write);
846 int rk818_set_bits(struct rk818 *rk818, u8 reg, u8 mask, u8 val)
851 mutex_lock(&rk818->io_lock);
853 ret = rk818_i2c_read(rk818, reg, 1, &tmp);
854 DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
855 tmp = (tmp & ~mask) | val;
857 ret = rk818_i2c_write(rk818, reg, 1, tmp);
858 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
860 rk818_i2c_read(rk818, reg, 1, &tmp);
861 DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
862 mutex_unlock(&rk818->io_lock);
866 EXPORT_SYMBOL_GPL(rk818_set_bits);
868 int rk818_clear_bits(struct rk818 *rk818, u8 reg, u8 mask)
873 mutex_lock(&rk818->io_lock);
874 err = rk818_i2c_read(rk818, reg, 1, &data);
876 dev_err(rk818->dev, "read from reg %x failed\n", reg);
881 err = rk818_i2c_write(rk818, reg, 1, data);
883 dev_err(rk818->dev, "write to reg %x failed\n", reg);
886 mutex_unlock(&rk818->io_lock);
889 EXPORT_SYMBOL_GPL(rk818_clear_bits);
892 static ssize_t rk818_test_store(struct kobject *kobj, struct kobj_attribute *attr,
893 const char *buf, size_t n)
899 const char *buftmp = buf;
900 struct rk818 *rk818 = g_rk818;
902 * W Addr(8Bit) regAddr(8Bit) data0(8Bit) data1(8Bit) data2(8Bit) data3(8Bit)
903 * :data can be less than 4 byte
905 * C gpio_name(poweron/powerhold/sleep/boot0/boot1) value(H/L)
907 sscanf(buftmp, "%c ", &cmd);
908 printk("------zhangqing: get cmd = %c\n", cmd);
911 sscanf(buftmp, "%c %x %x ", &cmd, &getdata[0], &getdata[1]);
912 regAddr = (u8)(getdata[0] & 0xff);
913 data = (u8)(getdata[1] & 0xff);
914 printk("get value = %x\n", data);
916 rk818_i2c_write(rk818, regAddr, 1, data);
917 rk818_i2c_read(rk818, regAddr, 1, &data);
918 printk("%x %x\n", getdata[1], data);
921 sscanf(buftmp, "%c %x ", &cmd, &getdata[0]);
922 printk("CMD : %c %x\n", cmd, getdata[0]);
924 regAddr = (u8)(getdata[0] & 0xff);
925 rk818_i2c_read(rk818, regAddr, 1, &data);
926 printk("%x %x\n", getdata[0], data);
929 printk("Unknown command\n");
935 static ssize_t rk818_test_show(struct kobject *kobj, struct kobj_attribute *attr,
940 return sprintf(s, "%s\n", buf);
944 static struct kobject *rk818_kobj;
945 struct rk818_attribute {
946 struct attribute attr;
947 ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,
949 ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,
950 const char *buf, size_t n);
953 static struct rk818_attribute rk818_attrs[] = {
954 /* node_name permision show_func store_func */
955 __ATTR(rk818_test, S_IRUGO | S_IWUSR, rk818_test_show, rk818_test_store),
960 extern void rk_send_wakeup_key(void);
961 static irqreturn_t rk818_vbat_lo_irq(int irq, void *data)
963 printk("rk818 vbat low %s:irq=%d\n",__func__,irq);
964 rk818_set_bits(g_rk818,0x4c,(0x1 << 1),(0x1 <<1));
965 rk_send_wakeup_key();
971 static struct of_device_id rk818_of_match[] = {
972 { .compatible = "rockchip,rk818"},
975 MODULE_DEVICE_TABLE(of, rk818_of_match);
979 static struct of_regulator_match rk818_reg_matches[] = {
980 { .name = "rk818_dcdc1", .driver_data = (void *)0 },
981 { .name = "rk818_dcdc2", .driver_data = (void *)1 },
982 { .name = "rk818_dcdc3", .driver_data = (void *)2 },
983 { .name = "rk818_dcdc4", .driver_data = (void *)3 },
984 { .name = "rk818_ldo1", .driver_data = (void *)4 },
985 { .name = "rk818_ldo2", .driver_data = (void *)5 },
986 { .name = "rk818_ldo3", .driver_data = (void *)6 },
987 { .name = "rk818_ldo4", .driver_data = (void *)7 },
988 { .name = "rk818_ldo5", .driver_data = (void *)8 },
989 { .name = "rk818_ldo6", .driver_data = (void *)9 },
990 { .name = "rk818_ldo7", .driver_data = (void *)10 },
991 { .name = "rk818_ldo8", .driver_data = (void *)11 },
992 { .name = "rk818_ldo9", .driver_data = (void *)12 },
993 { .name = "rk818_ldo10", .driver_data = (void *)13 },
996 static struct rk818_board *rk818_parse_dt(struct rk818 *rk818)
998 struct rk818_board *pdata;
999 struct device_node *regs,*rk818_pmic_np;
1002 rk818_pmic_np = of_node_get(rk818->dev->of_node);
1003 if (!rk818_pmic_np) {
1004 printk("could not find pmic sub-node\n");
1008 regs = of_find_node_by_name(rk818_pmic_np, "regulators");
1012 count = of_regulator_match(rk818->dev, regs, rk818_reg_matches,
1013 rk818_NUM_REGULATORS);
1015 if ((count < 0) || (count > rk818_NUM_REGULATORS))
1018 pdata = devm_kzalloc(rk818->dev, sizeof(*pdata), GFP_KERNEL);
1022 for (i = 0; i < count; i++) {
1023 if (!rk818_reg_matches[i].init_data || !rk818_reg_matches[i].of_node)
1026 pdata->rk818_init_data[i] = rk818_reg_matches[i].init_data;
1027 pdata->of_node[i] = rk818_reg_matches[i].of_node;
1029 pdata->irq = rk818->chip_irq;
1030 pdata->irq_base = -1;
1032 pdata->irq_gpio = of_get_named_gpio(rk818_pmic_np,"gpios",0);
1033 if (!gpio_is_valid(pdata->irq_gpio)) {
1034 printk("invalid gpio: %d\n", pdata->irq_gpio);
1038 pdata->pmic_sleep_gpio = of_get_named_gpio(rk818_pmic_np,"gpios",1);
1039 if (!gpio_is_valid(pdata->pmic_sleep_gpio)) {
1040 printk("invalid gpio: %d\n", pdata->pmic_sleep_gpio);
1042 pdata->pmic_sleep = true;
1043 pdata->pm_off = of_property_read_bool(rk818_pmic_np,"rk818,system-power-controller");
1049 static struct rk818_board *rk818_parse_dt(struct i2c_client *i2c)
1055 static void rk818_shutdown(void)
1058 struct rk818 *rk818 = g_rk818;
1060 pr_info("%s\n", __func__);
1061 ret = rk818_set_bits(rk818, RK818_INT_STS_MSK_REG1,(0x3<<5),(0x3<<5)); //close rtc int when power off
1062 ret = rk818_clear_bits(rk818, RK818_RTC_INT_REG,(0x3<<2)); //close rtc int when power off
1064 ret = rk818_clear_bits(rk818, RK818_DCDC_EN_REG, (0x1<<7));
1066 mutex_lock(&rk818->io_lock);
1070 static struct syscore_ops rk818_syscore_ops = {
1071 .shutdown = rk818_shutdown,
1074 void rk818_device_shutdown(void)
1078 struct rk818 *rk818 = g_rk818;
1080 for (i = 0; i < 10; i++) {
1081 pr_info("%s\n", __func__);
1082 ret = rk818_i2c_read(rk818, RK818_DEVCTRL_REG, 1, ®);
1085 ret = rk818_i2c_write(rk818, RK818_DEVCTRL_REG, 1,
1086 (reg | (0x1 << 0)));
1088 pr_err("rk818 power off error!\n");
1094 EXPORT_SYMBOL_GPL(rk818_device_shutdown);
1096 __weak void rk818_device_suspend(void) {}
1097 __weak void rk818_device_resume(void) {}
1099 static int rk818_suspend(struct i2c_client *i2c, pm_message_t mesg)
1102 struct rk818 *rk818 = g_rk818;
1104 rk818_device_suspend();
1105 /************set vbat low 3v4 to irq**********/
1106 val = rk818_reg_read(rk818, RK818_VB_MON_REG);
1107 val &= (~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1108 val |= (RK818_VBAT_LOW_3V4 | EN_VBAT_LOW_IRQ);
1109 ret = rk818_reg_write(rk818, RK818_VB_MON_REG, val);
1111 pr_err("Unable to write RK818_VB_MON_REG reg\n");
1115 rk818_set_bits(rk818, 0x4d, (0x1 << 1), (0x0 << 1));
1119 static int rk818_resume(struct i2c_client *i2c)
1122 struct rk818 *rk818 = g_rk818;
1124 rk818_device_resume();
1125 /********set vbat low 3v0 to shutdown**********/
1126 val = rk818_reg_read(rk818, RK818_VB_MON_REG);
1127 val &= (~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1128 val |= (RK818_VBAT_LOW_3V0 | EN_VABT_LOW_SHUT_DOWN);
1129 ret = rk818_reg_write(rk818, RK818_VB_MON_REG, val);
1131 pr_err("Unable to write RK818_VB_MON_REG reg\n");
1135 rk818_set_bits(rk818, 0x4d, (0x1 << 1), (0x1 << 1));
1140 static int rk818_suspend(struct i2c_client *i2c, pm_message_t mesg)
1145 static int rk818_resume(struct i2c_client *i2c)
1151 static int rk818_pre_init(struct rk818 *rk818)
1154 printk("%s,line=%d\n", __func__,__LINE__);
1156 ret = rk818_set_bits(rk818, 0xa1, (0xF<<0),(0x7));
1157 ret = rk818_set_bits(rk818, 0xa1,(0x7<<4),(0x7<<4)); //close charger when usb low then 3.4V
1158 ret = rk818_set_bits(rk818, 0x52,(0x1<<1),(0x1<<1)); //no action when vref
1159 ret = rk818_set_bits(rk818, 0x52,(0x1<<0),(0x1<<0)); //enable HDMI 5V
1161 /*******enable switch and boost***********/
1162 val = rk818_reg_read(rk818,RK818_DCDC_EN_REG);
1163 val |= (0x3 << 5); //enable switch1/2
1164 val |= (0x1 << 4); //enable boost
1165 ret = rk818_reg_write(rk818,RK818_DCDC_EN_REG,val);
1167 printk(KERN_ERR "Unable to write RK818_DCDC_EN_REG reg\n");
1170 /****************************************/
1171 /****************set vbat low **********/
1172 val = rk818_reg_read(rk818,RK818_VB_MON_REG);
1173 val &=(~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1174 val |= (RK818_VBAT_LOW_3V0 | EN_VABT_LOW_SHUT_DOWN);
1175 ret = rk818_reg_write(rk818,RK818_VB_MON_REG,val);
1177 printk(KERN_ERR "Unable to write RK818_VB_MON_REG reg\n");
1180 /**************************************/
1182 /**********mask int****************/
1184 val = rk818_reg_read(rk818,RK818_INT_STS_MSK_REG1);
1185 val |= (0x1<<0); //mask vout_lo_int
1186 ret = rk818_reg_write(rk818,RK818_INT_STS_MSK_REG1,val);
1188 printk(KERN_ERR "Unable to write RK818_INT_STS_MSK_REG1 reg\n");
1192 /**********************************/
1193 /**********enable clkout2****************/
1194 ret = rk818_reg_write(rk818,RK818_CLK32OUT_REG,0x01);
1196 printk(KERN_ERR "Unable to write RK818_CLK32OUT_REG reg\n");
1199 /**********************************/
1200 ret = rk818_clear_bits(rk818, RK818_INT_STS_MSK_REG1,(0x3<<5)); //open rtc int when power on
1201 ret = rk818_set_bits(rk818, RK818_RTC_INT_REG,(0x1<<3),(0x1<<3)); //open rtc int when power on
1203 /*****disable otg when in sleep mode****/
1204 val = rk818_reg_read(rk818, RK818_SLEEP_SET_OFF_REG1);
1206 ret = rk818_reg_write(rk818, RK818_SLEEP_SET_OFF_REG1, val);
1208 pr_err("Unable to write RK818_SLEEP_SET_OFF_REG1 reg\n");
1212 /*************** improve efficiency **********************/
1213 ret = rk818_reg_write(rk818, RK818_BUCK2_CONFIG_REG, 0x1c);
1215 pr_err("Unable to write RK818_BUCK2_CONFIG_REG reg\n");
1219 ret = rk818_reg_write(rk818, RK818_BUCK4_CONFIG_REG, 0x04);
1221 pr_err("Unable to write RK818_BUCK4_CONFIG_REG reg\n");
1228 static int rk818_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
1230 struct rk818 *rk818;
1231 struct rk818_board *pdev;
1232 const struct of_device_id *match;
1233 struct regulator_config config = { };
1234 struct regulator_dev *rk818_rdev;
1235 struct regulator_init_data *reg_data;
1236 const char *rail_name = NULL;
1239 printk("%s,line=%d\n", __func__,__LINE__);
1241 if (i2c->dev.of_node) {
1242 match = of_match_device(rk818_of_match, &i2c->dev);
1244 dev_err(&i2c->dev,"Failed to find matching dt id\n");
1249 rk818 = devm_kzalloc(&i2c->dev,sizeof(struct rk818), GFP_KERNEL);
1250 if (rk818 == NULL) {
1255 rk818->dev = &i2c->dev;
1256 i2c_set_clientdata(i2c, rk818);
1258 mutex_init(&rk818->io_lock);
1260 ret = rk818_reg_read(rk818,0x2f);
1261 if ((ret < 0) || (ret == 0xff)){
1262 printk("The device is not rk818 %d\n",ret);
1266 ret = rk818_pre_init(rk818);
1268 printk("The rk818_pre_init failed %d\n",ret);
1272 if (rk818->dev->of_node)
1273 pdev = rk818_parse_dt(rk818);
1275 /******************************set sleep vol & dcdc mode******************/
1277 rk818->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
1278 if (rk818->pmic_sleep_gpio) {
1279 ret = gpio_request(rk818->pmic_sleep_gpio, "rk818_pmic_sleep");
1281 dev_err(rk818->dev,"Failed to request gpio %d with ret:""%d\n", rk818->pmic_sleep_gpio, ret);
1284 gpio_direction_output(rk818->pmic_sleep_gpio,0);
1285 ret = gpio_get_value(rk818->pmic_sleep_gpio);
1286 gpio_free(rk818->pmic_sleep_gpio);
1287 pr_info("%s: rk818_pmic_sleep=%x\n", __func__, ret);
1290 /**********************************************************/
1293 rk818->num_regulators = rk818_NUM_REGULATORS;
1294 rk818->rdev = kcalloc(rk818_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
1298 /* Instantiate the regulators */
1299 for (i = 0; i < rk818_NUM_REGULATORS; i++) {
1300 reg_data = pdev->rk818_init_data[i];
1303 config.dev = rk818->dev;
1304 config.driver_data = rk818;
1305 if (rk818->dev->of_node)
1306 config.of_node = pdev->of_node[i];
1307 if (reg_data && reg_data->constraints.name)
1308 rail_name = reg_data->constraints.name;
1310 rail_name = regulators[i].name;
1311 reg_data->supply_regulator = rail_name;
1313 config.init_data =reg_data;
1315 rk818_rdev = regulator_register(®ulators[i],&config);
1316 if (IS_ERR(rk818_rdev)) {
1317 printk("failed to register %d regulator\n",i);
1320 rk818->rdev[i] = rk818_rdev;
1324 rk818->irq_gpio = pdev->irq_gpio;
1325 ret = rk818_irq_init(rk818, rk818->irq_gpio, pdev);
1329 ret = mfd_add_devices(rk818->dev, -1,
1330 rk818s, ARRAY_SIZE(rk818s),
1333 /********************vbat low int**************/
1334 vlow_irq = irq_create_mapping(rk818->irq_domain, RK818_IRQ_VB_LO);
1335 ret = devm_request_threaded_irq(&i2c->dev,vlow_irq, NULL, rk818_vbat_lo_irq,
1336 IRQF_ONESHOT, "rk818_vbatlow",
1339 dev_err(rk818->dev, "Failed to request periodic IRQ %d: %d\n",
1340 vlow_irq+ RK818_IRQ_VB_LO, ret);
1344 /*********************************************/
1347 if (pdev->pm_off && !pm_power_off) {
1348 pm_power_off = rk818_device_shutdown;
1352 rk818_kobj = kobject_create_and_add("rk818", NULL);
1355 for (i = 0; i < ARRAY_SIZE(rk818_attrs); i++) {
1356 ret = sysfs_create_file(rk818_kobj, &rk818_attrs[i].attr);
1358 printk("create index %d error\n", i);
1364 register_syscore_ops(&rk818_syscore_ops);
1369 mfd_remove_devices(rk818->dev);
1374 static int rk818_i2c_remove(struct i2c_client *i2c)
1376 struct rk818 *rk818 = i2c_get_clientdata(i2c);
1379 unregister_syscore_ops(&rk818_syscore_ops);
1380 for (i = 0; i < rk818->num_regulators; i++)
1382 regulator_unregister(rk818->rdev[i]);
1383 i2c_set_clientdata(i2c, NULL);
1388 static const struct i2c_device_id rk818_i2c_id[] = {
1393 MODULE_DEVICE_TABLE(i2c, rk818_i2c_id);
1395 static struct i2c_driver rk818_i2c_driver = {
1398 .owner = THIS_MODULE,
1399 .of_match_table =of_match_ptr(rk818_of_match),
1401 .probe = rk818_i2c_probe,
1402 .remove = rk818_i2c_remove,
1403 .id_table = rk818_i2c_id,
1405 .suspend = rk818_suspend,
1406 .resume = rk818_resume,
1410 static int __init rk818_module_init(void)
1413 ret = i2c_add_driver(&rk818_i2c_driver);
1415 pr_err("Failed to register I2C driver: %d\n", ret);
1419 subsys_initcall_sync(rk818_module_init);
1421 static void __exit rk818_module_exit(void)
1423 i2c_del_driver(&rk818_i2c_driver);
1425 module_exit(rk818_module_exit);
1427 MODULE_LICENSE("GPL");
1428 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1429 MODULE_DESCRIPTION("rk818 PMIC driver");