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 static irqreturn_t rk818_vbat_lo_irq(int irq, void *data)
962 printk("rk818 vbat low %s:irq=%d\n",__func__,irq);
963 rk818_set_bits(g_rk818,0x4c,(0x1 << 1),(0x1 <<1));
964 rk_send_wakeup_key();
970 static struct of_device_id rk818_of_match[] = {
971 { .compatible = "rockchip,rk818"},
974 MODULE_DEVICE_TABLE(of, rk818_of_match);
978 static struct of_regulator_match rk818_reg_matches[] = {
979 { .name = "rk818_dcdc1", .driver_data = (void *)0 },
980 { .name = "rk818_dcdc2", .driver_data = (void *)1 },
981 { .name = "rk818_dcdc3", .driver_data = (void *)2 },
982 { .name = "rk818_dcdc4", .driver_data = (void *)3 },
983 { .name = "rk818_ldo1", .driver_data = (void *)4 },
984 { .name = "rk818_ldo2", .driver_data = (void *)5 },
985 { .name = "rk818_ldo3", .driver_data = (void *)6 },
986 { .name = "rk818_ldo4", .driver_data = (void *)7 },
987 { .name = "rk818_ldo5", .driver_data = (void *)8 },
988 { .name = "rk818_ldo6", .driver_data = (void *)9 },
989 { .name = "rk818_ldo7", .driver_data = (void *)10 },
990 { .name = "rk818_ldo8", .driver_data = (void *)11 },
991 { .name = "rk818_ldo9", .driver_data = (void *)12 },
992 { .name = "rk818_ldo10", .driver_data = (void *)13 },
995 static struct rk818_board *rk818_parse_dt(struct rk818 *rk818)
997 struct rk818_board *pdata;
998 struct device_node *regs,*rk818_pmic_np;
1001 rk818_pmic_np = of_node_get(rk818->dev->of_node);
1002 if (!rk818_pmic_np) {
1003 printk("could not find pmic sub-node\n");
1007 regs = of_find_node_by_name(rk818_pmic_np, "regulators");
1011 count = of_regulator_match(rk818->dev, regs, rk818_reg_matches,
1012 rk818_NUM_REGULATORS);
1014 if ((count < 0) || (count > rk818_NUM_REGULATORS))
1017 pdata = devm_kzalloc(rk818->dev, sizeof(*pdata), GFP_KERNEL);
1021 for (i = 0; i < count; i++) {
1022 if (!rk818_reg_matches[i].init_data || !rk818_reg_matches[i].of_node)
1025 pdata->rk818_init_data[i] = rk818_reg_matches[i].init_data;
1026 pdata->of_node[i] = rk818_reg_matches[i].of_node;
1028 pdata->irq = rk818->chip_irq;
1029 pdata->irq_base = -1;
1031 pdata->irq_gpio = of_get_named_gpio(rk818_pmic_np,"gpios",0);
1032 if (!gpio_is_valid(pdata->irq_gpio)) {
1033 printk("invalid gpio: %d\n", pdata->irq_gpio);
1037 pdata->pmic_sleep_gpio = of_get_named_gpio(rk818_pmic_np,"gpios",1);
1038 if (!gpio_is_valid(pdata->pmic_sleep_gpio)) {
1039 printk("invalid gpio: %d\n", pdata->pmic_sleep_gpio);
1041 pdata->pmic_sleep = true;
1042 pdata->pm_off = of_property_read_bool(rk818_pmic_np,"rk818,system-power-controller");
1048 static struct rk818_board *rk818_parse_dt(struct i2c_client *i2c)
1054 static void rk818_shutdown(void)
1057 struct rk818 *rk818 = g_rk818;
1059 pr_info("%s\n", __func__);
1060 ret = rk818_set_bits(rk818, RK818_INT_STS_MSK_REG1,(0x3<<5),(0x3<<5)); //close rtc int when power off
1061 ret = rk818_clear_bits(rk818, RK818_RTC_INT_REG,(0x3<<2)); //close rtc int when power off
1063 ret = rk818_clear_bits(rk818, RK818_DCDC_EN_REG, (0x1<<7));
1065 mutex_lock(&rk818->io_lock);
1069 static struct syscore_ops rk818_syscore_ops = {
1070 .shutdown = rk818_shutdown,
1073 void rk818_device_shutdown(void)
1077 struct rk818 *rk818 = g_rk818;
1079 for (i = 0; i < 10; i++) {
1080 pr_info("%s\n", __func__);
1081 ret = rk818_i2c_read(rk818, RK818_DEVCTRL_REG, 1, ®);
1084 ret = rk818_i2c_write(rk818, RK818_DEVCTRL_REG, 1,
1085 (reg | (0x1 << 0)));
1087 pr_err("rk818 power off error!\n");
1093 EXPORT_SYMBOL_GPL(rk818_device_shutdown);
1095 __weak void rk818_device_suspend(void) {}
1096 __weak void rk818_device_resume(void) {}
1098 static int rk818_suspend(struct i2c_client *i2c, pm_message_t mesg)
1101 struct rk818 *rk818 = g_rk818;
1103 rk818_device_suspend();
1104 /************set vbat low 3v4 to irq**********/
1105 val = rk818_reg_read(rk818, RK818_VB_MON_REG);
1106 val &= (~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1107 val |= (RK818_VBAT_LOW_3V4 | EN_VBAT_LOW_IRQ);
1108 ret = rk818_reg_write(rk818, RK818_VB_MON_REG, val);
1110 pr_err("Unable to write RK818_VB_MON_REG reg\n");
1114 rk818_set_bits(rk818, 0x4d, (0x1 << 1), (0x0 << 1));
1118 static int rk818_resume(struct i2c_client *i2c)
1121 struct rk818 *rk818 = g_rk818;
1123 rk818_device_resume();
1124 /********set vbat low 3v0 to shutdown**********/
1125 val = rk818_reg_read(rk818, RK818_VB_MON_REG);
1126 val &= (~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1127 val |= (RK818_VBAT_LOW_3V0 | EN_VABT_LOW_SHUT_DOWN);
1128 ret = rk818_reg_write(rk818, RK818_VB_MON_REG, val);
1130 pr_err("Unable to write RK818_VB_MON_REG reg\n");
1134 rk818_set_bits(rk818, 0x4d, (0x1 << 1), (0x1 << 1));
1139 static int rk818_suspend(struct i2c_client *i2c, pm_message_t mesg)
1144 static int rk818_resume(struct i2c_client *i2c)
1150 static int rk818_pre_init(struct rk818 *rk818)
1153 printk("%s,line=%d\n", __func__,__LINE__);
1155 ret = rk818_set_bits(rk818, 0xa1, (0xF<<0),(0x7));
1156 ret = rk818_set_bits(rk818, 0xa1,(0x7<<4),(0x7<<4)); //close charger when usb low then 3.4V
1157 ret = rk818_set_bits(rk818, 0x52,(0x1<<1),(0x1<<1)); //no action when vref
1158 ret = rk818_set_bits(rk818, 0x52,(0x1<<0),(0x1<<0)); //enable HDMI 5V
1160 /*******enable switch and boost***********/
1161 val = rk818_reg_read(rk818,RK818_DCDC_EN_REG);
1162 val |= (0x3 << 5); //enable switch1/2
1163 val |= (0x1 << 4); //enable boost
1164 ret = rk818_reg_write(rk818,RK818_DCDC_EN_REG,val);
1166 printk(KERN_ERR "Unable to write RK818_DCDC_EN_REG reg\n");
1169 /****************************************/
1170 /****************set vbat low **********/
1171 val = rk818_reg_read(rk818,RK818_VB_MON_REG);
1172 val &=(~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1173 val |= (RK818_VBAT_LOW_3V0 | EN_VABT_LOW_SHUT_DOWN);
1174 ret = rk818_reg_write(rk818,RK818_VB_MON_REG,val);
1176 printk(KERN_ERR "Unable to write RK818_VB_MON_REG reg\n");
1179 /**************************************/
1181 /**********mask int****************/
1183 val = rk818_reg_read(rk818,RK818_INT_STS_MSK_REG1);
1184 val |= (0x1<<0); //mask vout_lo_int
1185 ret = rk818_reg_write(rk818,RK818_INT_STS_MSK_REG1,val);
1187 printk(KERN_ERR "Unable to write RK818_INT_STS_MSK_REG1 reg\n");
1191 /**********************************/
1192 /**********enable clkout2****************/
1193 ret = rk818_reg_write(rk818,RK818_CLK32OUT_REG,0x01);
1195 printk(KERN_ERR "Unable to write RK818_CLK32OUT_REG reg\n");
1198 /**********************************/
1199 ret = rk818_clear_bits(rk818, RK818_INT_STS_MSK_REG1,(0x3<<5)); //open rtc int when power on
1200 ret = rk818_set_bits(rk818, RK818_RTC_INT_REG,(0x1<<3),(0x1<<3)); //open rtc int when power on
1202 /*****disable otg when in sleep mode****/
1203 val = rk818_reg_read(rk818, RK818_SLEEP_SET_OFF_REG1);
1205 ret = rk818_reg_write(rk818, RK818_SLEEP_SET_OFF_REG1, val);
1207 pr_err("Unable to write RK818_SLEEP_SET_OFF_REG1 reg\n");
1211 /*************** improve efficiency **********************/
1212 ret = rk818_reg_write(rk818, RK818_BUCK2_CONFIG_REG, 0x1c);
1214 pr_err("Unable to write RK818_BUCK2_CONFIG_REG reg\n");
1218 ret = rk818_reg_write(rk818, RK818_BUCK4_CONFIG_REG, 0x04);
1220 pr_err("Unable to write RK818_BUCK4_CONFIG_REG reg\n");
1227 static int rk818_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
1229 struct rk818 *rk818;
1230 struct rk818_board *pdev;
1231 const struct of_device_id *match;
1232 struct regulator_config config = { };
1233 struct regulator_dev *rk818_rdev;
1234 struct regulator_init_data *reg_data;
1235 const char *rail_name = NULL;
1238 printk("%s,line=%d\n", __func__,__LINE__);
1240 if (i2c->dev.of_node) {
1241 match = of_match_device(rk818_of_match, &i2c->dev);
1243 dev_err(&i2c->dev,"Failed to find matching dt id\n");
1248 rk818 = devm_kzalloc(&i2c->dev,sizeof(struct rk818), GFP_KERNEL);
1249 if (rk818 == NULL) {
1254 rk818->dev = &i2c->dev;
1255 i2c_set_clientdata(i2c, rk818);
1257 mutex_init(&rk818->io_lock);
1259 ret = rk818_reg_read(rk818,0x2f);
1260 if ((ret < 0) || (ret == 0xff)){
1261 printk("The device is not rk818 %d\n",ret);
1265 ret = rk818_pre_init(rk818);
1267 printk("The rk818_pre_init failed %d\n",ret);
1271 if (rk818->dev->of_node)
1272 pdev = rk818_parse_dt(rk818);
1274 /******************************set sleep vol & dcdc mode******************/
1276 rk818->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
1277 if (rk818->pmic_sleep_gpio) {
1278 ret = gpio_request(rk818->pmic_sleep_gpio, "rk818_pmic_sleep");
1280 dev_err(rk818->dev,"Failed to request gpio %d with ret:""%d\n", rk818->pmic_sleep_gpio, ret);
1283 gpio_direction_output(rk818->pmic_sleep_gpio,0);
1284 ret = gpio_get_value(rk818->pmic_sleep_gpio);
1285 gpio_free(rk818->pmic_sleep_gpio);
1286 pr_info("%s: rk818_pmic_sleep=%x\n", __func__, ret);
1289 /**********************************************************/
1292 rk818->num_regulators = rk818_NUM_REGULATORS;
1293 rk818->rdev = kcalloc(rk818_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
1297 /* Instantiate the regulators */
1298 for (i = 0; i < rk818_NUM_REGULATORS; i++) {
1299 reg_data = pdev->rk818_init_data[i];
1302 config.dev = rk818->dev;
1303 config.driver_data = rk818;
1304 if (rk818->dev->of_node)
1305 config.of_node = pdev->of_node[i];
1306 if (reg_data && reg_data->constraints.name)
1307 rail_name = reg_data->constraints.name;
1309 rail_name = regulators[i].name;
1310 reg_data->supply_regulator = rail_name;
1312 config.init_data =reg_data;
1314 rk818_rdev = regulator_register(®ulators[i],&config);
1315 if (IS_ERR(rk818_rdev)) {
1316 printk("failed to register %d regulator\n",i);
1319 rk818->rdev[i] = rk818_rdev;
1323 rk818->irq_gpio = pdev->irq_gpio;
1324 ret = rk818_irq_init(rk818, rk818->irq_gpio, pdev);
1328 ret = mfd_add_devices(rk818->dev, -1,
1329 rk818s, ARRAY_SIZE(rk818s),
1332 /********************vbat low int**************/
1333 vlow_irq = irq_create_mapping(rk818->irq_domain, RK818_IRQ_VB_LO);
1334 ret = devm_request_threaded_irq(&i2c->dev,vlow_irq, NULL, rk818_vbat_lo_irq,
1335 IRQF_ONESHOT, "rk818_vbatlow",
1338 dev_err(rk818->dev, "Failed to request periodic IRQ %d: %d\n",
1339 vlow_irq+ RK818_IRQ_VB_LO, ret);
1343 /*********************************************/
1346 if (pdev->pm_off && !pm_power_off) {
1347 pm_power_off = rk818_device_shutdown;
1351 rk818_kobj = kobject_create_and_add("rk818", NULL);
1354 for (i = 0; i < ARRAY_SIZE(rk818_attrs); i++) {
1355 ret = sysfs_create_file(rk818_kobj, &rk818_attrs[i].attr);
1357 printk("create index %d error\n", i);
1363 register_syscore_ops(&rk818_syscore_ops);
1368 mfd_remove_devices(rk818->dev);
1373 static int rk818_i2c_remove(struct i2c_client *i2c)
1375 struct rk818 *rk818 = i2c_get_clientdata(i2c);
1378 unregister_syscore_ops(&rk818_syscore_ops);
1379 for (i = 0; i < rk818->num_regulators; i++)
1381 regulator_unregister(rk818->rdev[i]);
1382 i2c_set_clientdata(i2c, NULL);
1387 static const struct i2c_device_id rk818_i2c_id[] = {
1392 MODULE_DEVICE_TABLE(i2c, rk818_i2c_id);
1394 static struct i2c_driver rk818_i2c_driver = {
1397 .owner = THIS_MODULE,
1398 .of_match_table =of_match_ptr(rk818_of_match),
1400 .probe = rk818_i2c_probe,
1401 .remove = rk818_i2c_remove,
1402 .id_table = rk818_i2c_id,
1404 .suspend = rk818_suspend,
1405 .resume = rk818_resume,
1409 static int __init rk818_module_init(void)
1412 ret = i2c_add_driver(&rk818_i2c_driver);
1414 pr_err("Failed to register I2C driver: %d\n", ret);
1418 subsys_initcall_sync(rk818_module_init);
1420 static void __exit rk818_module_exit(void)
1422 i2c_del_driver(&rk818_i2c_driver);
1424 module_exit(rk818_module_exit);
1426 MODULE_LICENSE("GPL");
1427 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1428 MODULE_DESCRIPTION("rk818 PMIC driver");