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>
35 #define DBG(x...) printk(KERN_INFO x)
40 #define DBG_INFO(x...) printk(KERN_INFO x)
42 #define DBG_INFO(x...)
46 struct rk818 *g_rk818;
48 static struct mfd_cell rk818s[] = {
54 .name = "rk818-battery",
57 .name = "rk818-power",
62 #define BUCK_VOL_MASK 0x3f
63 #define LDO_VOL_MASK 0x3f
64 #define LDO9_VOL_MASK 0x1f
65 #define BOOST_VOL_MASK 0xe0
67 #define VOL_MIN_IDX 0x00
68 #define VOL_MAX_IDX 0x3f
69 #define RK818_I2C_ADDR_RATE 200*1000
71 const static int buck_set_vol_base_addr[] = {
74 RK818_BUCK3_CONFIG_REG,
77 const static int buck_set_slp_vol_base_addr[] = {
80 RK818_BUCK3_CONFIG_REG,
81 RK818_BUCK4_SLP_VSEL_REG,
83 const static int buck_contr_base_addr[] = {
84 RK818_BUCK1_CONFIG_REG,
85 RK818_BUCK2_CONFIG_REG,
86 RK818_BUCK3_CONFIG_REG,
87 RK818_BUCK4_CONFIG_REG,
89 #define rk818_BUCK_SET_VOL_REG(x) (buck_set_vol_base_addr[x])
90 #define rk818_BUCK_CONTR_REG(x) (buck_contr_base_addr[x])
91 #define rk818_BUCK_SET_SLP_VOL_REG(x) (buck_set_slp_vol_base_addr[x])
94 const static int ldo_set_vol_base_addr[] = {
95 RK818_LDO1_ON_VSEL_REG,
96 RK818_LDO2_ON_VSEL_REG,
97 RK818_LDO3_ON_VSEL_REG,
98 RK818_LDO4_ON_VSEL_REG,
99 RK818_LDO5_ON_VSEL_REG,
100 RK818_LDO6_ON_VSEL_REG,
101 RK818_LDO7_ON_VSEL_REG,
102 RK818_LDO8_ON_VSEL_REG,
103 RK818_BOOST_LDO9_ON_VSEL_REG,
105 const static int ldo_set_slp_vol_base_addr[] = {
106 RK818_LDO1_SLP_VSEL_REG,
107 RK818_LDO2_SLP_VSEL_REG,
108 RK818_LDO3_SLP_VSEL_REG,
109 RK818_LDO4_SLP_VSEL_REG,
110 RK818_LDO5_SLP_VSEL_REG,
111 RK818_LDO6_SLP_VSEL_REG,
112 RK818_LDO7_SLP_VSEL_REG,
113 RK818_LDO8_SLP_VSEL_REG,
114 RK818_BOOST_LDO9_SLP_VSEL_REG,
117 #define rk818_LDO_SET_VOL_REG(x) (ldo_set_vol_base_addr[x])
118 #define rk818_LDO_SET_SLP_VOL_REG(x) (ldo_set_slp_vol_base_addr[x])
120 const static int buck_voltage_map[] = {
121 700, 712, 725, 737, 750, 762, 775, 787, 800,
122 812, 825, 837, 850,862, 875, 887, 900, 912,
123 925, 937, 950, 962, 975, 987, 1000, 1012, 1025,
124 1037, 1050,1062, 1075, 1087, 1100, 1112, 1125, 1137,
125 1150,1162, 1175, 1187, 1200, 1212, 1225, 1237, 1250,
126 1262, 1275, 1287, 1300, 1312, 1325, 1337, 1350,1362,
127 1375, 1387, 1400, 1412, 1425, 1437, 1450,1462, 1475,
131 const static int buck4_voltage_map[] = {
132 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500, 2600,
133 2700, 2800, 2900, 3000, 3100, 3200,3300, 3400,3500,3600,
136 const static int ldo_voltage_map[] = {
137 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500, 2600,
138 2700, 2800, 2900, 3000, 3100, 3200,3300, 3400,
140 const static int ldo3_voltage_map[] = {
141 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600,
142 1700, 1800, 1900, 2000,2100, 2200, 2500,
144 const static int ldo6_voltage_map[] = {
145 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600,
146 1700, 1800, 1900, 2000,2100, 2200, 2300,2400,2500,
148 const static int boost_voltage_map[] = {
149 4700,4800,4900,5000,5100,5200,5300,5400,
152 static int rk818_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
154 int ldo= rdev_get_id(dev) - RK818_LDO1;
156 if (index >= ARRAY_SIZE(ldo3_voltage_map))
158 return 1000 * ldo3_voltage_map[index];
160 else if (ldo == 5 || ldo ==6){
161 if (index >= ARRAY_SIZE(ldo6_voltage_map))
163 return 1000 * ldo6_voltage_map[index];
166 if (index >= ARRAY_SIZE(ldo_voltage_map))
168 return 1000 * ldo_voltage_map[index];
171 static int rk818_ldo_is_enabled(struct regulator_dev *dev)
173 struct rk818 *rk818 = rdev_get_drvdata(dev);
174 int ldo= rdev_get_id(dev) - RK818_LDO1;
178 val = rk818_reg_read(rk818, RK818_DCDC_EN_REG); //ldo9
186 val = rk818_reg_read(rk818, RK818_LDO_EN_REG);
189 if (val & (1 << ldo))
194 static int rk818_ldo_enable(struct regulator_dev *dev)
196 struct rk818 *rk818 = rdev_get_drvdata(dev);
197 int ldo= rdev_get_id(dev) - RK818_LDO1;
200 rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << 5, 1 << 5); //ldo9
202 rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << 6, 1 << 6); //ldo10 switch
204 rk818_set_bits(rk818, RK818_LDO_EN_REG, 1 << ldo, 1 << ldo);
208 static int rk818_ldo_disable(struct regulator_dev *dev)
210 struct rk818 *rk818 = rdev_get_drvdata(dev);
211 int ldo= rdev_get_id(dev) - RK818_LDO1;
214 rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << 5, 1 << 0); //ldo9
216 rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << 6, 1 << 0); //ldo10 switch
218 rk818_set_bits(rk818, RK818_LDO_EN_REG, 1 << ldo, 0);
222 static int rk818_ldo_get_voltage(struct regulator_dev *dev)
224 struct rk818 *rk818 = rdev_get_drvdata(dev);
225 int ldo= rdev_get_id(dev) - RK818_LDO1;
230 reg = rk818_reg_read(rk818,rk818_BUCK_SET_VOL_REG(3));
231 reg &= BUCK_VOL_MASK;
232 val = 1000 * buck4_voltage_map[reg];
235 reg = rk818_reg_read(rk818,rk818_LDO_SET_VOL_REG(ldo));
237 reg &= LDO9_VOL_MASK;
243 val = 1000 * ldo3_voltage_map[reg];
245 else if (ldo == 5 || ldo ==6){
246 val = 1000 * ldo6_voltage_map[reg];
249 val = 1000 * ldo_voltage_map[reg];
254 static int rk818_ldo_suspend_enable(struct regulator_dev *dev)
256 struct rk818 *rk818 = rdev_get_drvdata(dev);
257 int ldo= rdev_get_id(dev) - RK818_LDO1;
260 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << 5, 0); //ldo9
262 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << 6, 0); //ldo10 switch
264 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG2, 1 << ldo, 0);
267 static int rk818_ldo_suspend_disable(struct regulator_dev *dev)
269 struct rk818 *rk818 = rdev_get_drvdata(dev);
270 int ldo= rdev_get_id(dev) - RK818_LDO1;
273 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << 5, 1 << 5); //ldo9
275 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << 6, 1 << 6); //ldo10 switch
277 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG2, 1 << ldo, 1 << ldo);
280 static int rk818_ldo_set_sleep_voltage(struct regulator_dev *dev,
283 struct rk818 *rk818 = rdev_get_drvdata(dev);
284 int ldo= rdev_get_id(dev) - RK818_LDO1;
285 const int *vol_map = ldo_voltage_map;
286 int min_vol = uV / 1000;
291 vol_map = ldo3_voltage_map;
294 else if (ldo == 5 || ldo ==6){
295 vol_map = ldo6_voltage_map;
302 if (min_vol < vol_map[0] ||
303 min_vol > vol_map[num])
306 for (val = 0; val <= num; val++){
307 if (vol_map[val] >= min_vol)
312 ret = rk818_set_bits(rk818, rk818_LDO_SET_SLP_VOL_REG(ldo),LDO9_VOL_MASK, val);
315 ret = rk818_set_bits(rk818, rk818_LDO_SET_SLP_VOL_REG(ldo),LDO_VOL_MASK, val);
320 static int rk818_ldo_set_voltage(struct regulator_dev *dev,
321 int min_uV, int max_uV,unsigned *selector)
323 struct rk818 *rk818 = rdev_get_drvdata(dev);
324 int ldo= rdev_get_id(dev) - RK818_LDO1;
326 int min_vol = min_uV / 1000;
331 vol_map = ldo3_voltage_map;
334 else if (ldo == 5 || ldo ==6){
335 vol_map = ldo6_voltage_map;
339 vol_map = ldo_voltage_map;
343 if (min_vol < vol_map[0] ||
344 min_vol > vol_map[num])
347 for (val = 0; val <= num; val++){
348 if (vol_map[val] >= min_vol)
353 ret = rk818_set_bits(rk818, rk818_LDO_SET_VOL_REG(ldo),LDO9_VOL_MASK, val);
356 ret = rk818_set_bits(rk818, rk818_LDO_SET_VOL_REG(ldo),LDO_VOL_MASK, val);
362 static struct regulator_ops rk818_ldo_ops = {
363 .set_voltage = rk818_ldo_set_voltage,
364 .get_voltage = rk818_ldo_get_voltage,
365 .list_voltage = rk818_ldo_list_voltage,
366 .is_enabled = rk818_ldo_is_enabled,
367 .enable = rk818_ldo_enable,
368 .disable = rk818_ldo_disable,
369 .set_suspend_enable =rk818_ldo_suspend_enable,
370 .set_suspend_disable =rk818_ldo_suspend_disable,
371 .set_suspend_voltage = rk818_ldo_set_sleep_voltage,
374 static int rk818_dcdc_list_voltage(struct regulator_dev *dev, unsigned selector)
377 int buck = rdev_get_id(dev) - RK818_DCDC1;
379 if (selector < 0x0 ||selector > BUCK_VOL_MASK )
385 volt = 700000 + selector * 12500;
388 volt = 1800000 + selector * 100000;
400 static int rk818_dcdc_is_enabled(struct regulator_dev *dev)
402 struct rk818 *rk818 = rdev_get_drvdata(dev);
403 int buck = rdev_get_id(dev) - RK818_DCDC1;
406 val = rk818_reg_read(rk818, RK818_DCDC_EN_REG);
409 if (val & (1 << buck))
414 static int rk818_dcdc_enable(struct regulator_dev *dev)
416 struct rk818 *rk818 = rdev_get_drvdata(dev);
417 int buck = rdev_get_id(dev) - RK818_DCDC1;
419 return rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << buck, 1 << buck);
422 static int rk818_dcdc_disable(struct regulator_dev *dev)
424 struct rk818 *rk818 = rdev_get_drvdata(dev);
425 int buck = rdev_get_id(dev) - RK818_DCDC1;
427 return rk818_set_bits(rk818, RK818_DCDC_EN_REG, 1 << buck , 0);
429 static int rk818_dcdc_get_voltage(struct regulator_dev *dev)
431 struct rk818 *rk818 = rdev_get_drvdata(dev);
432 int buck = rdev_get_id(dev) - RK818_DCDC1;
436 reg = rk818_reg_read(rk818,rk818_BUCK_SET_VOL_REG(buck));
438 reg &= BUCK_VOL_MASK;
439 val = rk818_dcdc_list_voltage(dev,reg);
442 static int rk818_dcdc_select_min_voltage(struct regulator_dev *dev,
443 int min_uV, int max_uV ,int buck)
447 if (buck == 0 || buck == 1){
450 else if (min_uV <= 1500000)
451 vsel = ((min_uV - 700000) / 12500) ;
456 if (min_uV < 1800000)
458 else if (min_uV <= 3300000)
459 vsel = ((min_uV - 1800000) / 100000) ;
463 if (rk818_dcdc_list_voltage(dev, vsel) > max_uV)
468 static int rk818_dcdc_set_voltage(struct regulator_dev *dev,
469 int min_uV, int max_uV,unsigned *selector)
471 struct rk818 *rk818 = rdev_get_drvdata(dev);
472 int buck = rdev_get_id(dev) - RK818_DCDC1;
474 int ret = 0,old_voltage =0,vol_temp =0;
479 val = rk818_dcdc_select_min_voltage(dev,min_uV,max_uV,buck);
480 ret = rk818_set_bits(rk818, rk818_BUCK_SET_VOL_REG(buck), BUCK_VOL_MASK, val);
482 val = rk818_dcdc_select_min_voltage(dev,min_uV,max_uV,buck);
483 ret = rk818_set_bits(rk818, rk818_BUCK_SET_VOL_REG(buck), BUCK_VOL_MASK, val);
486 static int rk818_dcdc_set_sleep_voltage(struct regulator_dev *dev,
489 struct rk818 *rk818 = rdev_get_drvdata(dev);
490 int buck = rdev_get_id(dev) - RK818_DCDC1;
497 val = rk818_dcdc_select_min_voltage(dev,uV,uV,buck);
498 ret = rk818_set_bits(rk818, rk818_BUCK_SET_SLP_VOL_REG(buck) , BUCK_VOL_MASK, val);
502 static unsigned int rk818_dcdc_get_mode(struct regulator_dev *dev)
504 struct rk818 *rk818 = rdev_get_drvdata(dev);
505 int buck = rdev_get_id(dev) - RK818_DCDC1;
508 val = rk818_reg_read(rk818, rk818_BUCK_SET_VOL_REG(buck));
514 return REGULATOR_MODE_FAST;
516 return REGULATOR_MODE_NORMAL;
519 static int rk818_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
521 struct rk818 *rk818 = rdev_get_drvdata(dev);
522 int buck = rdev_get_id(dev) - RK818_DCDC1;
526 case REGULATOR_MODE_FAST:
527 return rk818_set_bits(rk818, rk818_BUCK_SET_VOL_REG(buck), mask, mask);
528 case REGULATOR_MODE_NORMAL:
529 return rk818_set_bits(rk818, rk818_BUCK_SET_VOL_REG(buck), mask, 0);
531 printk("error:pmu_rk818 only powersave and pwm mode\n");
536 static int rk818_dcdc_set_voltage_time_sel(struct regulator_dev *dev, unsigned int old_selector,
537 unsigned int new_selector)
539 int old_volt, new_volt;
541 old_volt = rk818_dcdc_list_voltage(dev, old_selector);
545 new_volt = rk818_dcdc_list_voltage(dev, new_selector);
549 return DIV_ROUND_UP(abs(old_volt - new_volt)*2, 2500);
552 static int rk818_dcdc_suspend_enable(struct regulator_dev *dev)
554 struct rk818 *rk818 = rdev_get_drvdata(dev);
555 int buck = rdev_get_id(dev) - RK818_DCDC1;
557 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << buck, 0);
560 static int rk818_dcdc_suspend_disable(struct regulator_dev *dev)
562 struct rk818 *rk818 = rdev_get_drvdata(dev);
563 int buck = rdev_get_id(dev) - RK818_DCDC1;
565 return rk818_set_bits(rk818, RK818_SLEEP_SET_OFF_REG1, 1 << buck , 1 << buck);
567 static int rk818_dcdc_set_suspend_mode(struct regulator_dev *dev, unsigned int mode)
569 struct rk818 *rk818 = rdev_get_drvdata(dev);
570 int buck = rdev_get_id(dev) - RK818_DCDC1;
575 case REGULATOR_MODE_FAST:
576 return rk818_set_bits(rk818, (rk818_BUCK_SET_VOL_REG(buck) + 0x01), mask, mask);
577 case REGULATOR_MODE_NORMAL:
578 return rk818_set_bits(rk818, (rk818_BUCK_SET_VOL_REG(buck) + 0x01), mask, 0);
580 printk("error:pmu_rk818 only powersave and pwm mode\n");
585 static struct regulator_ops rk818_dcdc_ops = {
586 .set_voltage = rk818_dcdc_set_voltage,
587 .get_voltage = rk818_dcdc_get_voltage,
588 .list_voltage= rk818_dcdc_list_voltage,
589 .is_enabled = rk818_dcdc_is_enabled,
590 .enable = rk818_dcdc_enable,
591 .disable = rk818_dcdc_disable,
592 .get_mode = rk818_dcdc_get_mode,
593 .set_mode = rk818_dcdc_set_mode,
594 .set_suspend_enable =rk818_dcdc_suspend_enable,
595 .set_suspend_disable =rk818_dcdc_suspend_disable,
596 .set_suspend_mode = rk818_dcdc_set_suspend_mode,
597 .set_suspend_voltage = rk818_dcdc_set_sleep_voltage,
598 .set_voltage_time_sel = rk818_dcdc_set_voltage_time_sel,
600 static struct regulator_desc regulators[] = {
603 .name = "RK818_DCDC1",
605 .ops = &rk818_dcdc_ops,
606 .n_voltages = ARRAY_SIZE(buck_voltage_map),
607 .type = REGULATOR_VOLTAGE,
608 .owner = THIS_MODULE,
611 .name = "RK818_DCDC2",
613 .ops = &rk818_dcdc_ops,
614 .n_voltages = ARRAY_SIZE(buck_voltage_map),
615 .type = REGULATOR_VOLTAGE,
616 .owner = THIS_MODULE,
619 .name = "RK818_DCDC3",
621 .ops = &rk818_dcdc_ops,
622 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
623 .type = REGULATOR_VOLTAGE,
624 .owner = THIS_MODULE,
627 .name = "RK818_DCDC4",
629 .ops = &rk818_dcdc_ops,
630 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
631 .type = REGULATOR_VOLTAGE,
632 .owner = THIS_MODULE,
636 .name = "RK818_LDO1",
638 .ops = &rk818_ldo_ops,
639 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
640 .type = REGULATOR_VOLTAGE,
641 .owner = THIS_MODULE,
644 .name = "RK818_LDO2",
646 .ops = &rk818_ldo_ops,
647 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
648 .type = REGULATOR_VOLTAGE,
649 .owner = THIS_MODULE,
652 .name = "RK818_LDO3",
654 .ops = &rk818_ldo_ops,
655 .n_voltages = ARRAY_SIZE(ldo3_voltage_map),
656 .type = REGULATOR_VOLTAGE,
657 .owner = THIS_MODULE,
660 .name = "RK818_LDO4",
662 .ops = &rk818_ldo_ops,
663 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
664 .type = REGULATOR_VOLTAGE,
665 .owner = THIS_MODULE,
669 .name = "RK818_LDO5",
671 .ops = &rk818_ldo_ops,
672 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
673 .type = REGULATOR_VOLTAGE,
674 .owner = THIS_MODULE,
677 .name = "RK818_LDO6",
679 .ops = &rk818_ldo_ops,
680 .n_voltages = ARRAY_SIZE(ldo6_voltage_map),
681 .type = REGULATOR_VOLTAGE,
682 .owner = THIS_MODULE,
685 .name = "RK818_LDO7",
687 .ops = &rk818_ldo_ops,
688 .n_voltages = ARRAY_SIZE(ldo6_voltage_map),
689 .type = REGULATOR_VOLTAGE,
690 .owner = THIS_MODULE,
693 .name = "RK818_LDO8",
695 .ops = &rk818_ldo_ops,
696 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
697 .type = REGULATOR_VOLTAGE,
698 .owner = THIS_MODULE,
701 .name = "RK818_LDO9",
703 .ops = &rk818_ldo_ops,
704 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
705 .type = REGULATOR_VOLTAGE,
706 .owner = THIS_MODULE,
709 .name = "RK818_LDO10",
711 .ops = &rk818_ldo_ops,
712 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
713 .type = REGULATOR_VOLTAGE,
714 .owner = THIS_MODULE,
722 int rk818_i2c_read(struct rk818 *rk818, char reg, int count,u8 *dest)
724 struct i2c_client *i2c = rk818->i2c;
727 struct i2c_adapter *adap;
728 struct i2c_msg msgs[2];
738 msgs[0].addr = i2c->addr;
742 msgs[0].scl_rate = 200*1000;
745 msgs[1].addr = i2c->addr;
746 msgs[1].flags = I2C_M_RD;
748 msgs[1].scl_rate = RK818_I2C_ADDR_RATE;
750 ret = i2c_transfer(adap, msgs, 2);
752 DBG("***run in %s %x % x\n",__FUNCTION__,i2c->addr,msgs[0].buf);
756 int rk818_i2c_write(struct rk818 *rk818, char reg, int count, const u8 src)
759 struct i2c_client *i2c = rk818->i2c;
760 struct i2c_adapter *adap;
773 msg.addr = i2c->addr;
774 msg.buf = &tx_buf[0];
776 msg.flags = i2c->flags;
777 msg.scl_rate = RK818_I2C_ADDR_RATE;
779 ret = i2c_transfer(adap, &msg, 1);
783 u8 rk818_reg_read(struct rk818 *rk818, u8 reg)
787 mutex_lock(&rk818->io_lock);
789 rk818_i2c_read(rk818, reg, 1, &val);
791 DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
793 mutex_unlock(&rk818->io_lock);
797 EXPORT_SYMBOL_GPL(rk818_reg_read);
799 int rk818_reg_write(struct rk818 *rk818, u8 reg, u8 val)
803 mutex_lock(&rk818->io_lock);
805 err = rk818_i2c_write(rk818, reg, 1,val);
807 dev_err(rk818->dev, "Write for reg 0x%x failed\n", reg);
809 mutex_unlock(&rk818->io_lock);
812 EXPORT_SYMBOL_GPL(rk818_reg_write);
814 int rk818_set_bits(struct rk818 *rk818, u8 reg, u8 mask, u8 val)
819 mutex_lock(&rk818->io_lock);
821 ret = rk818_i2c_read(rk818, reg, 1, &tmp);
822 DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
823 tmp = (tmp & ~mask) | val;
825 ret = rk818_i2c_write(rk818, reg, 1, tmp);
826 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
828 rk818_i2c_read(rk818, reg, 1, &tmp);
829 DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
830 mutex_unlock(&rk818->io_lock);
834 EXPORT_SYMBOL_GPL(rk818_set_bits);
836 int rk818_clear_bits(struct rk818 *rk818, u8 reg, u8 mask)
841 mutex_lock(&rk818->io_lock);
842 err = rk818_i2c_read(rk818, reg, 1, &data);
844 dev_err(rk818->dev, "read from reg %x failed\n", reg);
849 err = rk818_i2c_write(rk818, reg, 1, data);
851 dev_err(rk818->dev, "write to reg %x failed\n", reg);
854 mutex_unlock(&rk818->io_lock);
857 EXPORT_SYMBOL_GPL(rk818_clear_bits);
860 static ssize_t rk818_test_store(struct kobject *kobj, struct kobj_attribute *attr,
861 const char *buf, size_t n)
867 const char *buftmp = buf;
868 struct rk818 *rk818 = g_rk818;
870 * W Addr(8Bit) regAddr(8Bit) data0(8Bit) data1(8Bit) data2(8Bit) data3(8Bit)
871 * :data can be less than 4 byte
873 * C gpio_name(poweron/powerhold/sleep/boot0/boot1) value(H/L)
875 regAddr = (u16)(getdata[0] & 0xff);
876 if (strncmp(buf, "start", 5) == 0) {
879 } else if (strncmp(buf, "stop", 4== 0) ){
882 sscanf(buftmp, "%c ", &cmd);
883 printk("------zhangqing: get cmd = %c\n", cmd);
887 sscanf(buftmp, "%c %x %x ", &cmd, &getdata[0],&getdata[1]);
888 regAddr = (u16)(getdata[0] & 0xff);
889 data = (u8)(getdata[1] & 0xff);
890 printk("get value = %x\n", data);
892 rk818_i2c_write(rk818, regAddr, 1, data);
893 rk818_i2c_read(rk818, regAddr, 1, &data);
894 printk("%x %x\n", getdata[1],data);
899 sscanf(buftmp, "%c %x ", &cmd, &getdata[0]);
900 printk("CMD : %c %x\n", cmd, getdata[0]);
902 regAddr = (u16)(getdata[0] & 0xff);
903 rk818_i2c_read(rk818, regAddr, 1, &data);
904 printk("%x %x\n", getdata[0],data);
909 printk("Unknown command\n");
916 static ssize_t rk818_test_show(struct kobject *kobj, struct kobj_attribute *attr,
921 return sprintf(s, "%s\n", buf);
925 static struct kobject *rk818_kobj;
926 struct rk818_attribute {
927 struct attribute attr;
928 ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,
930 ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,
931 const char *buf, size_t n);
934 static struct rk818_attribute rk818_attrs[] = {
935 /* node_name permision show_func store_func */
936 __ATTR(rk818_test, S_IRUGO | S_IWUSR, rk818_test_show, rk818_test_store),
940 extern void rk_send_wakeup_key(void);
941 static irqreturn_t rk818_vbat_lo_irq(int irq, void *data)
943 printk("rk818 vbat low %s:irq=%d\n",__func__,irq);
944 rk818_set_bits(g_rk818,0x4c,(0x1 << 1),(0x1 <<1));
945 rk_send_wakeup_key();
950 static struct of_device_id rk818_of_match[] = {
951 { .compatible = "rockchip,rk818"},
954 MODULE_DEVICE_TABLE(of, rk818_of_match);
958 static struct of_regulator_match rk818_reg_matches[] = {
959 { .name = "rk818_dcdc1", .driver_data = (void *)0 },
960 { .name = "rk818_dcdc2", .driver_data = (void *)1 },
961 { .name = "rk818_dcdc3", .driver_data = (void *)2 },
962 { .name = "rk818_dcdc4", .driver_data = (void *)3 },
963 { .name = "rk818_ldo1", .driver_data = (void *)4 },
964 { .name = "rk818_ldo2", .driver_data = (void *)5 },
965 { .name = "rk818_ldo3", .driver_data = (void *)6 },
966 { .name = "rk818_ldo4", .driver_data = (void *)7 },
967 { .name = "rk818_ldo5", .driver_data = (void *)8 },
968 { .name = "rk818_ldo6", .driver_data = (void *)9 },
969 { .name = "rk818_ldo7", .driver_data = (void *)10 },
970 { .name = "rk818_ldo8", .driver_data = (void *)11 },
971 { .name = "rk818_ldo9", .driver_data = (void *)12 },
972 { .name = "rk818_ldo10", .driver_data = (void *)13 },
975 static struct rk818_board *rk818_parse_dt(struct rk818 *rk818)
977 struct rk818_board *pdata;
978 struct device_node *regs,*rk818_pmic_np;
981 rk818_pmic_np = of_node_get(rk818->dev->of_node);
982 if (!rk818_pmic_np) {
983 printk("could not find pmic sub-node\n");
987 regs = of_find_node_by_name(rk818_pmic_np, "regulators");
991 count = of_regulator_match(rk818->dev, regs, rk818_reg_matches,
992 rk818_NUM_REGULATORS);
994 if ((count < 0) || (count > rk818_NUM_REGULATORS))
997 pdata = devm_kzalloc(rk818->dev, sizeof(*pdata), GFP_KERNEL);
1001 for (i = 0; i < count; i++) {
1002 if (!rk818_reg_matches[i].init_data || !rk818_reg_matches[i].of_node)
1005 pdata->rk818_init_data[i] = rk818_reg_matches[i].init_data;
1006 pdata->of_node[i] = rk818_reg_matches[i].of_node;
1008 pdata->irq = rk818->chip_irq;
1009 pdata->irq_base = -1;
1011 pdata->irq_gpio = of_get_named_gpio(rk818_pmic_np,"gpios",0);
1012 if (!gpio_is_valid(pdata->irq_gpio)) {
1013 printk("invalid gpio: %d\n", pdata->irq_gpio);
1017 pdata->pmic_sleep_gpio = of_get_named_gpio(rk818_pmic_np,"gpios",1);
1018 if (!gpio_is_valid(pdata->pmic_sleep_gpio)) {
1019 printk("invalid gpio: %d\n", pdata->pmic_sleep_gpio);
1021 pdata->pmic_sleep = true;
1022 pdata->pm_off = of_property_read_bool(rk818_pmic_np,"rk818,system-power-controller");
1028 static struct rk818_board *rk818_parse_dt(struct i2c_client *i2c)
1034 int rk818_device_shutdown(void)
1038 struct rk818 *rk818 = g_rk818;
1040 printk("%s\n",__func__);
1041 ret = rk818_set_bits(rk818, RK818_INT_STS_MSK_REG1,(0x3<<5),(0x3<<5)); //close rtc int when power off
1042 ret = rk818_clear_bits(rk818, RK818_RTC_INT_REG,(0x3<<2)); //close rtc int when power off
1043 ret = rk818_reg_read(rk818,RK818_DEVCTRL_REG);
1044 ret = rk818_set_bits(rk818, RK818_DEVCTRL_REG,(0x1<<0),(0x1<<0));
1045 // ret = rk818_set_bits(rk818, RK818_DEVCTRL_REG,(0x1<<4),(0x1<<4));
1047 printk("rk818 power off error!\n");
1052 EXPORT_SYMBOL_GPL(rk818_device_shutdown);
1054 __weak void rk818_device_suspend(void) {}
1055 __weak void rk818_device_resume(void) {}
1057 static int rk818_suspend(struct i2c_client *i2c, pm_message_t mesg)
1059 rk818_device_suspend();
1063 static int rk818_resume(struct i2c_client *i2c)
1065 rk818_device_resume();
1069 static int rk818_suspend(struct i2c_client *i2c, pm_message_t mesg)
1074 static int rk818_resume(struct i2c_client *i2c)
1080 static int rk818_pre_init(struct rk818 *rk818)
1083 printk("%s,line=%d\n", __func__,__LINE__);
1085 ret = rk818_set_bits(rk818, 0xa1,(0x7<<4),(0x7<<4)); //close charger when usb low then 3.4V
1086 ret = rk818_set_bits(rk818, 0x52,(0x1<<1),(0x1<<1)); //no action when vref
1088 /*******enable switch and boost***********/
1089 val = rk818_reg_read(rk818,RK818_DCDC_EN_REG);
1090 val |= (0x3 << 5); //enable switch1/2
1091 val |= (0x1 << 4); //enable boost
1092 ret = rk818_reg_write(rk818,RK818_DCDC_EN_REG,val);
1094 printk(KERN_ERR "Unable to write RK818_DCDC_EN_REG reg\n");
1097 /****************************************/
1099 /****************set vbat low **********/
1100 val = rk818_reg_read(rk818,RK818_VB_MON_REG);
1101 val &=(~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1102 val |= (RK818_VBAT_LOW_3V5 | EN_VBAT_LOW_IRQ);
1103 ret = rk818_reg_write(rk818,RK818_VB_MON_REG,val);
1105 printk(KERN_ERR "Unable to write RK818_VB_MON_REG reg\n");
1108 /**************************************/
1110 /**********mask int****************/
1111 val = rk818_reg_read(rk818,RK818_INT_STS_MSK_REG1);
1112 val |= (0x1<<0); //mask vout_lo_int
1113 ret = rk818_reg_write(rk818,RK818_INT_STS_MSK_REG1,val);
1115 printk(KERN_ERR "Unable to write RK818_INT_STS_MSK_REG1 reg\n");
1118 /**********************************/
1119 /**********enable clkout2****************/
1120 ret = rk818_reg_write(rk818,RK818_CLK32OUT_REG,0x01);
1122 printk(KERN_ERR "Unable to write RK818_CLK32OUT_REG reg\n");
1125 /**********************************/
1126 ret = rk818_clear_bits(rk818, RK818_INT_STS_MSK_REG1,(0x3<<5)); //open rtc int when power on
1127 ret = rk818_set_bits(rk818, RK818_RTC_INT_REG,(0x1<<3),(0x1<<3)); //open rtc int when power on
1131 static int rk818_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
1133 struct rk818 *rk818;
1134 struct rk818_board *pdev;
1135 const struct of_device_id *match;
1136 struct regulator_config config = { };
1137 struct regulator_dev *rk818_rdev;
1138 struct regulator_init_data *reg_data;
1139 const char *rail_name = NULL;
1140 int ret,vlow_irq,i=0;
1142 printk("%s,line=%d\n", __func__,__LINE__);
1144 if (i2c->dev.of_node) {
1145 match = of_match_device(rk818_of_match, &i2c->dev);
1147 dev_err(&i2c->dev,"Failed to find matching dt id\n");
1152 rk818 = devm_kzalloc(&i2c->dev,sizeof(struct rk818), GFP_KERNEL);
1153 if (rk818 == NULL) {
1158 rk818->dev = &i2c->dev;
1159 i2c_set_clientdata(i2c, rk818);
1161 mutex_init(&rk818->io_lock);
1163 ret = rk818_reg_read(rk818,0x2f);
1164 if ((ret < 0) || (ret == 0xff)){
1165 printk("The device is not rk818 %d\n",ret);
1169 ret = rk818_pre_init(rk818);
1171 printk("The rk818_pre_init failed %d\n",ret);
1175 if (rk818->dev->of_node)
1176 pdev = rk818_parse_dt(rk818);
1178 /******************************set sleep vol & dcdc mode******************/
1180 rk818->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
1181 if (rk818->pmic_sleep_gpio) {
1182 ret = gpio_request(rk818->pmic_sleep_gpio, "rk818_pmic_sleep");
1184 dev_err(rk818->dev,"Failed to request gpio %d with ret:""%d\n", rk818->pmic_sleep_gpio, ret);
1187 gpio_direction_output(rk818->pmic_sleep_gpio,0);
1188 ret = gpio_get_value(rk818->pmic_sleep_gpio);
1189 gpio_free(rk818->pmic_sleep_gpio);
1190 pr_info("%s: rk818_pmic_sleep=%x\n", __func__, ret);
1193 /**********************************************************/
1196 rk818->num_regulators = rk818_NUM_REGULATORS;
1197 rk818->rdev = kcalloc(rk818_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
1201 /* Instantiate the regulators */
1202 for (i = 0; i < rk818_NUM_REGULATORS; i++) {
1203 reg_data = pdev->rk818_init_data[i];
1206 config.dev = rk818->dev;
1207 config.driver_data = rk818;
1208 if (rk818->dev->of_node)
1209 config.of_node = pdev->of_node[i];
1210 if (reg_data && reg_data->constraints.name)
1211 rail_name = reg_data->constraints.name;
1213 rail_name = regulators[i].name;
1214 reg_data->supply_regulator = rail_name;
1216 config.init_data =reg_data;
1218 rk818_rdev = regulator_register(®ulators[i],&config);
1219 if (IS_ERR(rk818_rdev)) {
1220 printk("failed to register %d regulator\n",i);
1223 rk818->rdev[i] = rk818_rdev;
1227 rk818->irq_gpio = pdev->irq_gpio;
1228 ret = rk818_irq_init(rk818, rk818->irq_gpio, pdev);
1232 ret = mfd_add_devices(rk818->dev, -1,
1233 rk818s, ARRAY_SIZE(rk818s),
1236 /********************vbat low int**************/
1237 vlow_irq = irq_create_mapping(rk818->irq_domain, RK818_IRQ_VB_LO);
1238 ret = devm_request_threaded_irq(&i2c->dev,vlow_irq, NULL, rk818_vbat_lo_irq,
1239 IRQF_ONESHOT, "rk818_vbatlow",
1242 dev_err(rk818->dev, "Failed to request periodic IRQ %d: %d\n",
1243 vlow_irq+ RK818_IRQ_VB_LO, ret);
1247 /*********************************************/
1250 if (pdev->pm_off && !pm_power_off) {
1251 pm_power_off = rk818_device_shutdown;
1255 rk818_kobj = kobject_create_and_add("rk818", NULL);
1258 for (i = 0; i < ARRAY_SIZE(rk818_attrs); i++) {
1259 ret = sysfs_create_file(rk818_kobj, &rk818_attrs[i].attr);
1261 printk("create index %d error\n", i);
1270 mfd_remove_devices(rk818->dev);
1275 static int rk818_i2c_remove(struct i2c_client *i2c)
1277 struct rk818 *rk818 = i2c_get_clientdata(i2c);
1280 for (i = 0; i < rk818->num_regulators; i++)
1282 regulator_unregister(rk818->rdev[i]);
1283 i2c_set_clientdata(i2c, NULL);
1289 static const struct i2c_device_id rk818_i2c_id[] = {
1294 MODULE_DEVICE_TABLE(i2c, rk818_i2c_id);
1296 static struct i2c_driver rk818_i2c_driver = {
1299 .owner = THIS_MODULE,
1300 .of_match_table =of_match_ptr(rk818_of_match),
1302 .probe = rk818_i2c_probe,
1303 .remove = rk818_i2c_remove,
1304 .id_table = rk818_i2c_id,
1306 .suspend = rk818_suspend,
1307 .resume = rk818_resume,
1311 static int __init rk818_module_init(void)
1314 ret = i2c_add_driver(&rk818_i2c_driver);
1316 pr_err("Failed to register I2C driver: %d\n", ret);
1320 subsys_initcall_sync(rk818_module_init);
1322 static void __exit rk818_module_exit(void)
1324 i2c_del_driver(&rk818_i2c_driver);
1326 module_exit(rk818_module_exit);
1328 MODULE_LICENSE("GPL");
1329 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1330 MODULE_DESCRIPTION("rk818 PMIC driver");