2 * Regulator driver for rk808 PMIC chip for rk31xx
4 * Based on rk808.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/rk808.h>
18 #include <linux/mfd/core.h>
19 #include <linux/delay.h>
20 #include <linux/slab.h>
21 #include <linux/mutex.h>
22 #ifdef CONFIG_HAS_EARLYSUSPEND
23 #include <linux/earlysuspend.h>
25 #include <linux/interrupt.h>
26 #include <linux/module.h>
27 #include <linux/of_irq.h>
28 #include <linux/of_gpio.h>
30 #include <linux/of_device.h>
31 #include <linux/regulator/of_regulator.h>
32 #include <linux/regulator/driver.h>
33 #include <linux/regulator/machine.h>
34 #include <linux/regmap.h>
35 #include <linux/syscore_ops.h>
38 #define DBG(x...) printk(KERN_INFO x)
43 #define DBG_INFO(x...) printk(KERN_INFO x)
45 #define DBG_INFO(x...)
49 struct rk808 *g_rk808;
50 #define DCDC_RAISE_VOL_BYSTEP 1
51 #define DCDC_VOL_STEP 12500 /*12.5mv*/
53 static struct mfd_cell rk808s[] = {
59 #define BUCK_VOL_MASK 0x3f
60 #define LDO_VOL_MASK 0x3f
62 #define VOL_MIN_IDX 0x00
63 #define VOL_MAX_IDX 0x3f
65 const static int buck_set_vol_base_addr[] = {
68 RK808_BUCK3_CONFIG_REG,
71 const static int buck_contr_base_addr[] = {
72 RK808_BUCK1_CONFIG_REG,
73 RK808_BUCK2_CONFIG_REG,
74 RK808_BUCK3_CONFIG_REG,
75 RK808_BUCK4_CONFIG_REG,
77 #define rk808_BUCK_SET_VOL_REG(x) (buck_set_vol_base_addr[x])
78 #define rk808_BUCK_CONTR_REG(x) (buck_contr_base_addr[x])
81 const static int ldo_set_vol_base_addr[] = {
82 RK808_LDO1_ON_VSEL_REG,
83 RK808_LDO2_ON_VSEL_REG,
84 RK808_LDO3_ON_VSEL_REG,
85 RK808_LDO4_ON_VSEL_REG,
86 RK808_LDO5_ON_VSEL_REG,
87 RK808_LDO6_ON_VSEL_REG,
88 RK808_LDO7_ON_VSEL_REG,
89 RK808_LDO8_ON_VSEL_REG,
90 // RK808_LDO1_ON_VSEL_REG,
93 const static int ldo_contr_base_addr[] = {
94 rk808_LDO1_CONTR_BASE,
95 rk808_LDO2_CONTR_BASE,
96 rk808_LDO3_CONTR_BASE,
97 rk808_LDO4_CONTR_BASE,
98 rk808_LDO5_CONTR_BASE,
99 rk808_LDO6_CONTR_BASE,
100 rk808_LDO7_CONTR_BASE,
101 rk808_LDO8_CONTR_BASE,
102 // rk808_LDO9_CONTR_BASE,
105 #define rk808_LDO_SET_VOL_REG(x) (ldo_set_vol_base_addr[x])
106 //#define rk808_LDO_CONTR_REG(x) (ldo_contr_base_addr[x])
108 const static int buck_voltage_map[] = {
109 712, 725, 737, 750, 762, 775, 787, 800,
110 812, 825, 837, 850,862, 875, 887, 900, 912,
111 925, 937, 950, 962, 975, 987, 1000, 1012, 1025,
112 1037, 1050,1062, 1075, 1087, 1100, 1112, 1125, 1137,
113 1150,1162, 1175, 1187, 1200, 1212, 1225, 1237, 1250,
114 1262, 1275, 1287, 1300, 1312, 1325, 1337, 1350,1362,
115 1375, 1387, 1400, 1412, 1425, 1437, 1450,1462, 1475,
119 const static int buck4_voltage_map[] = {
120 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500, 2600,
121 2700, 2800, 2900, 3000, 3100, 3200,3300,
124 const static int ldo_voltage_map[] = {
125 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500, 2600,
126 2700, 2800, 2900, 3000, 3100, 3200,3300, 3400,
128 const static int ldo3_voltage_map[] = {
129 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600,
130 1700, 1800, 1900, 2000,2100, 2200, 2500,
132 const static int ldo6_voltage_map[] = {
133 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600,
134 1700, 1800, 1900, 2000,2100, 2200, 2300,2400,2500,
137 static int rk808_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
139 int ldo= rdev_get_id(dev) - RK808_LDO1;
141 if (index >= ARRAY_SIZE(ldo3_voltage_map))
143 return 1000 * ldo3_voltage_map[index];
145 else if (ldo == 5 || ldo ==6){
146 if (index >= ARRAY_SIZE(ldo6_voltage_map))
148 return 1000 * ldo6_voltage_map[index];
151 if (index >= ARRAY_SIZE(ldo_voltage_map))
153 return 1000 * ldo_voltage_map[index];
156 static int rk808_ldo_is_enabled(struct regulator_dev *dev)
158 struct rk808 *rk808 = rdev_get_drvdata(dev);
159 int ldo= rdev_get_id(dev) - RK808_LDO1;
162 if ((ldo ==8) ||(ldo ==9)){
163 val = rk808_reg_read(rk808, RK808_DCDC_EN_REG);
166 if (val & (1 <<( ldo -3)))
172 val = rk808_reg_read(rk808, RK808_LDO_EN_REG);
175 if (val & (1 << ldo))
181 static int rk808_ldo_enable(struct regulator_dev *dev)
183 struct rk808 *rk808 = rdev_get_drvdata(dev);
184 int ldo= rdev_get_id(dev) - RK808_LDO1;
187 return rk808_set_bits(rk808, RK808_DCDC_EN_REG, 1 << 5, 1 << 5);
189 return rk808_set_bits(rk808, RK808_DCDC_EN_REG, 1 << 6, 1 << 6);
191 return rk808_set_bits(rk808, RK808_LDO_EN_REG, 1 << ldo, 1 << ldo);
194 static int rk808_ldo_disable(struct regulator_dev *dev)
196 struct rk808 *rk808 = rdev_get_drvdata(dev);
197 int ldo= rdev_get_id(dev) - RK808_LDO1;
200 return rk808_set_bits(rk808, RK808_DCDC_EN_REG, 1 << 5, 0);
202 return rk808_set_bits(rk808, RK808_DCDC_EN_REG, 1 << 6, 0);
204 return rk808_set_bits(rk808, RK808_LDO_EN_REG, 1 << ldo, 0);
207 static int rk808_ldo_suspend_enable(struct regulator_dev *dev)
209 struct rk808 *rk808 = rdev_get_drvdata(dev);
210 int ldo= rdev_get_id(dev) - RK808_LDO1;
213 return rk808_set_bits(rk808, RK808_SLEEP_SET_OFF_REG1, 1 << 5, 0);
215 return rk808_set_bits(rk808, RK808_SLEEP_SET_OFF_REG1, 1 << 6, 0);
217 return rk808_set_bits(rk808, RK808_SLEEP_SET_OFF_REG2, 1 << ldo, 0);
220 static int rk808_ldo_suspend_disable(struct regulator_dev *dev)
222 struct rk808 *rk808 = rdev_get_drvdata(dev);
223 int ldo= rdev_get_id(dev) - RK808_LDO1;
226 return rk808_set_bits(rk808, RK808_SLEEP_SET_OFF_REG1, 1 << 5, 1 << 5);
228 return rk808_set_bits(rk808, RK808_SLEEP_SET_OFF_REG1, 1 << 6, 1 << 6);
230 return rk808_set_bits(rk808, RK808_SLEEP_SET_OFF_REG2, 1 << ldo, 1 << ldo);
233 static int rk808_ldo_get_voltage(struct regulator_dev *dev)
235 struct rk808 *rk808 = rdev_get_drvdata(dev);
236 int ldo= rdev_get_id(dev) - RK808_LDO1;
240 if ((ldo ==8 ) || (ldo ==9)){
241 reg = rk808_reg_read(rk808,rk808_BUCK_SET_VOL_REG(3));
242 reg &= BUCK_VOL_MASK;
243 val = 1000 * buck4_voltage_map[reg];
246 reg = rk808_reg_read(rk808,rk808_LDO_SET_VOL_REG(ldo));
249 val = 1000 * ldo3_voltage_map[reg];
251 else if (ldo == 5 || ldo ==6){
252 val = 1000 * ldo6_voltage_map[reg];
255 val = 1000 * ldo_voltage_map[reg];
260 static int rk808_ldo_set_sleep_voltage(struct regulator_dev *dev,
263 struct rk808 *rk808 = rdev_get_drvdata(dev);
264 int ldo= rdev_get_id(dev) - RK808_LDO1;
265 const int *vol_map = ldo_voltage_map;
266 int min_vol = uV / 1000;
271 vol_map = ldo3_voltage_map;
274 else if (ldo == 5 || ldo ==6){
275 vol_map = ldo6_voltage_map;
282 if (min_vol < vol_map[0] ||
283 min_vol > vol_map[num])
286 for (val = 0; val <= num; val++){
287 if (vol_map[val] >= min_vol)
291 ret = rk808_set_bits(rk808, rk808_LDO_SET_VOL_REG(ldo) +0x01,
296 static int rk808_ldo_set_voltage(struct regulator_dev *dev,
297 int min_uV, int max_uV,unsigned *selector)
299 struct rk808 *rk808 = rdev_get_drvdata(dev);
300 int ldo= rdev_get_id(dev) - RK808_LDO1;
302 int min_vol = min_uV / 1000;
307 vol_map = ldo3_voltage_map;
310 else if (ldo == 5 || ldo ==6){
311 vol_map = ldo6_voltage_map;
315 vol_map = ldo_voltage_map;
319 if (min_vol < vol_map[0] ||
320 min_vol > vol_map[num])
323 for (val = 0; val <= num; val++){
324 if (vol_map[val] >= min_vol)
328 ret = rk808_set_bits(rk808, rk808_LDO_SET_VOL_REG(ldo),
333 static unsigned int rk808_ldo_get_mode(struct regulator_dev *dev)
335 struct rk808 *rk808 = rdev_get_drvdata(dev);
336 int ldo = rdev_get_id(dev) - RK808_LDO1;
339 val = rk808_reg_read(rk808, rk808_LDO_SET_VOL_REG(ldo));
345 return REGULATOR_MODE_NORMAL;
347 return REGULATOR_MODE_STANDBY;
350 static int rk808_ldo_set_mode(struct regulator_dev *dev, unsigned int mode)
352 struct rk808 *rk808 = rdev_get_drvdata(dev);
353 int ldo = rdev_get_id(dev) - RK808_LDO1;
357 case REGULATOR_MODE_FAST:
358 return rk808_set_bits(rk808, rk808_LDO_SET_VOL_REG(ldo), mask, mask);
359 case REGULATOR_MODE_NORMAL:
360 return rk808_set_bits(rk808, rk808_LDO_SET_VOL_REG(ldo), mask, 0);
362 printk("error:pmu_rk808 only lowpower and nomal mode\n");
368 static struct regulator_ops rk808_ldo_ops = {
369 .set_voltage = rk808_ldo_set_voltage,
370 .get_voltage = rk808_ldo_get_voltage,
371 .list_voltage = rk808_ldo_list_voltage,
372 .is_enabled = rk808_ldo_is_enabled,
373 .enable = rk808_ldo_enable,
374 .disable = rk808_ldo_disable,
375 .set_suspend_enable =rk808_ldo_suspend_enable,
376 .set_suspend_disable =rk808_ldo_suspend_disable,
377 .get_mode = rk808_ldo_get_mode,
378 .set_mode = rk808_ldo_set_mode,
379 .set_suspend_voltage = rk808_ldo_set_sleep_voltage,
383 static int rk808_dcdc_list_voltage(struct regulator_dev *dev, unsigned selector)
386 int buck = rdev_get_id(dev) - RK808_DCDC1;
388 if (selector < 0x0 ||selector > BUCK_VOL_MASK )
394 volt = 712500 + selector * 12500;
397 volt = 1800000 + selector * 100000;
409 static int rk808_dcdc_is_enabled(struct regulator_dev *dev)
411 struct rk808 *rk808 = rdev_get_drvdata(dev);
412 int buck = rdev_get_id(dev) - RK808_DCDC1;
415 val = rk808_reg_read(rk808, RK808_DCDC_EN_REG);
418 if (val & (1 << buck))
423 static int rk808_dcdc_enable(struct regulator_dev *dev)
425 struct rk808 *rk808 = rdev_get_drvdata(dev);
426 int buck = rdev_get_id(dev) - RK808_DCDC1;
428 return rk808_set_bits(rk808, RK808_DCDC_EN_REG, 1 << buck, 1 << buck);
431 static int rk808_dcdc_disable(struct regulator_dev *dev)
433 struct rk808 *rk808 = rdev_get_drvdata(dev);
434 int buck = rdev_get_id(dev) - RK808_DCDC1;
436 return rk808_set_bits(rk808, RK808_DCDC_EN_REG, 1 << buck , 0);
439 static int rk808_dcdc_suspend_enable(struct regulator_dev *dev)
441 struct rk808 *rk808 = rdev_get_drvdata(dev);
442 int buck = rdev_get_id(dev) - RK808_DCDC1;
444 return rk808_set_bits(rk808, RK808_SLEEP_SET_OFF_REG1, 1 << buck, 0);
447 static int rk808_dcdc_suspend_disable(struct regulator_dev *dev)
449 struct rk808 *rk808 = rdev_get_drvdata(dev);
450 int buck = rdev_get_id(dev) - RK808_DCDC1;
452 return rk808_set_bits(rk808, RK808_SLEEP_SET_OFF_REG1, 1 << buck , 1 << buck);
454 static int rk808_dcdc_get_voltage(struct regulator_dev *dev)
456 struct rk808 *rk808 = rdev_get_drvdata(dev);
457 int buck = rdev_get_id(dev) - RK808_DCDC1;
461 reg = rk808_reg_read(rk808,rk808_BUCK_SET_VOL_REG(buck));
463 reg &= BUCK_VOL_MASK;
464 val = rk808_dcdc_list_voltage(dev,reg);
467 static int rk808_dcdc_select_min_voltage(struct regulator_dev *dev,
468 int min_uV, int max_uV ,int buck)
472 if (buck == 0 || buck == 1){
475 else if (min_uV <= 1500000)
476 vsel = ((min_uV - 712500) / 12500) ;
481 if (min_uV < 1800000)
483 else if (min_uV <= 3300000)
484 vsel = ((min_uV - 1800000) / 100000) ;
488 if (rk808_dcdc_list_voltage(dev, vsel) > max_uV)
493 static int rk808_dcdc_set_voltage(struct regulator_dev *dev,
494 int min_uV, int max_uV,unsigned *selector)
496 struct rk808 *rk808 = rdev_get_drvdata(dev);
497 int buck = rdev_get_id(dev) - RK808_DCDC1;
499 int ret = 0,old_voltage =0,vol_temp =0;
504 val = rk808_dcdc_select_min_voltage(dev,min_uV,max_uV,buck);
505 ret = rk808_set_bits(rk808, rk808_BUCK_SET_VOL_REG(buck), BUCK_VOL_MASK, val);
508 #if defined(DCDC_RAISE_VOL_BYSTEP)
509 old_voltage = rk808_dcdc_get_voltage(dev);
510 if (max_uV >old_voltage){
511 vol_temp = old_voltage;
513 vol_temp += DCDC_VOL_STEP;
514 val = rk808_dcdc_select_min_voltage(dev,vol_temp,vol_temp,buck);
515 // printk("rk808_dcdc_set_voltage buck = %d vol_temp= %d old_voltage= %d min_uV =%d \n",buck,vol_temp,old_voltage,min_uV);
516 ret = rk808_set_bits(rk808, rk808_BUCK_SET_VOL_REG(buck), BUCK_VOL_MASK, val);
517 } while (vol_temp < max_uV);
520 val = rk808_dcdc_select_min_voltage(dev,min_uV,max_uV,buck);
521 ret = rk808_set_bits(rk808, rk808_BUCK_SET_VOL_REG(buck), BUCK_VOL_MASK, val);
524 val = rk808_dcdc_select_min_voltage(dev,min_uV,max_uV,buck);
525 ret = rk808_set_bits(rk808, rk808_BUCK_SET_VOL_REG(buck), BUCK_VOL_MASK, val);
529 printk("################WARNING:set voltage is error!voltage set is %d mv %d\n",min_uV,ret);
533 static int rk808_dcdc_set_sleep_voltage(struct regulator_dev *dev,
536 struct rk808 *rk808 = rdev_get_drvdata(dev);
537 int buck = rdev_get_id(dev) - RK808_DCDC1;
544 val = rk808_dcdc_select_min_voltage(dev,uV,uV,buck);
545 ret = rk808_set_bits(rk808, (rk808_BUCK_SET_VOL_REG(buck) + 0x01), BUCK_VOL_MASK, val);
549 static unsigned int rk808_dcdc_get_mode(struct regulator_dev *dev)
551 struct rk808 *rk808 = rdev_get_drvdata(dev);
552 int buck = rdev_get_id(dev) - RK808_DCDC1;
555 val = rk808_reg_read(rk808, rk808_BUCK_SET_VOL_REG(buck));
561 return REGULATOR_MODE_FAST;
563 return REGULATOR_MODE_NORMAL;
566 static int rk808_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
568 struct rk808 *rk808 = rdev_get_drvdata(dev);
569 int buck = rdev_get_id(dev) - RK808_DCDC1;
574 case REGULATOR_MODE_FAST:
575 return rk808_set_bits(rk808, rk808_BUCK_SET_VOL_REG(buck), mask, mask);
576 case REGULATOR_MODE_NORMAL:
577 return rk808_set_bits(rk808, rk808_BUCK_SET_VOL_REG(buck), mask, 0);
579 printk("error:pmu_rk808 only powersave and pwm mode\n");
584 static int rk808_dcdc_set_suspend_mode(struct regulator_dev *dev, unsigned int mode)
586 struct rk808 *rk808 = rdev_get_drvdata(dev);
587 int buck = rdev_get_id(dev) - RK808_DCDC1;
592 case REGULATOR_MODE_FAST:
593 return rk808_set_bits(rk808, (rk808_BUCK_SET_VOL_REG(buck) + 0x01), mask, mask);
594 case REGULATOR_MODE_NORMAL:
595 return rk808_set_bits(rk808, (rk808_BUCK_SET_VOL_REG(buck) + 0x01), mask, 0);
597 printk("error:pmu_rk808 only powersave and pwm mode\n");
602 static int rk808_dcdc_set_voltage_time_sel(struct regulator_dev *dev, unsigned int old_selector,
603 unsigned int new_selector)
605 int old_volt, new_volt;
607 old_volt = rk808_dcdc_list_voltage(dev, old_selector);
611 new_volt = rk808_dcdc_list_voltage(dev, new_selector);
615 return DIV_ROUND_UP(abs(old_volt - new_volt)*2, 2500);
618 static struct regulator_ops rk808_dcdc_ops = {
619 .set_voltage = rk808_dcdc_set_voltage,
620 .get_voltage = rk808_dcdc_get_voltage,
621 .list_voltage= rk808_dcdc_list_voltage,
622 .is_enabled = rk808_dcdc_is_enabled,
623 .enable = rk808_dcdc_enable,
624 .disable = rk808_dcdc_disable,
625 .set_suspend_enable =rk808_dcdc_suspend_enable,
626 .set_suspend_disable =rk808_dcdc_suspend_disable,
627 .get_mode = rk808_dcdc_get_mode,
628 .set_mode = rk808_dcdc_set_mode,
629 .set_suspend_mode = rk808_dcdc_set_suspend_mode,
630 .set_suspend_voltage = rk808_dcdc_set_sleep_voltage,
631 .set_voltage_time_sel = rk808_dcdc_set_voltage_time_sel,
633 static struct regulator_desc regulators[] = {
638 .ops = &rk808_dcdc_ops,
639 .n_voltages = ARRAY_SIZE(buck_voltage_map),
640 .type = REGULATOR_VOLTAGE,
641 .owner = THIS_MODULE,
646 .ops = &rk808_dcdc_ops,
647 .n_voltages = ARRAY_SIZE(buck_voltage_map),
648 .type = REGULATOR_VOLTAGE,
649 .owner = THIS_MODULE,
654 .ops = &rk808_dcdc_ops,
655 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
656 .type = REGULATOR_VOLTAGE,
657 .owner = THIS_MODULE,
662 .ops = &rk808_dcdc_ops,
663 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
664 .type = REGULATOR_VOLTAGE,
665 .owner = THIS_MODULE,
671 .ops = &rk808_ldo_ops,
672 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
673 .type = REGULATOR_VOLTAGE,
674 .owner = THIS_MODULE,
679 .ops = &rk808_ldo_ops,
680 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
681 .type = REGULATOR_VOLTAGE,
682 .owner = THIS_MODULE,
687 .ops = &rk808_ldo_ops,
688 .n_voltages = ARRAY_SIZE(ldo3_voltage_map),
689 .type = REGULATOR_VOLTAGE,
690 .owner = THIS_MODULE,
695 .ops = &rk808_ldo_ops,
696 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
697 .type = REGULATOR_VOLTAGE,
698 .owner = THIS_MODULE,
704 .ops = &rk808_ldo_ops,
705 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
706 .type = REGULATOR_VOLTAGE,
707 .owner = THIS_MODULE,
712 .ops = &rk808_ldo_ops,
713 .n_voltages = ARRAY_SIZE(ldo6_voltage_map),
714 .type = REGULATOR_VOLTAGE,
715 .owner = THIS_MODULE,
720 .ops = &rk808_ldo_ops,
721 .n_voltages = ARRAY_SIZE(ldo6_voltage_map),
722 .type = REGULATOR_VOLTAGE,
723 .owner = THIS_MODULE,
728 .ops = &rk808_ldo_ops,
729 .n_voltages = ARRAY_SIZE(ldo_voltage_map),
730 .type = REGULATOR_VOLTAGE,
731 .owner = THIS_MODULE,
736 .ops = &rk808_ldo_ops,
737 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
738 .type = REGULATOR_VOLTAGE,
739 .owner = THIS_MODULE,
744 .ops = &rk808_ldo_ops,
745 .n_voltages = ARRAY_SIZE(buck4_voltage_map),
746 .type = REGULATOR_VOLTAGE,
747 .owner = THIS_MODULE,
755 int rk808_i2c_read(struct rk808 *rk808, char reg, int count,u8 *dest)
757 struct i2c_client *i2c = rk808->i2c;
759 struct i2c_adapter *adap;
760 struct i2c_msg msgs[2];
770 msgs[0].addr = i2c->addr;
772 msgs[0].flags = i2c->flags;
774 msgs[0].scl_rate = 100*1000;
776 msgs[1].buf = (u8 *)dest;
777 msgs[1].addr = i2c->addr;
778 msgs[1].flags = i2c->flags |I2C_M_RD;
780 msgs[1].scl_rate = 100*1000;
782 ret = i2c_transfer(adap, msgs, 2);
784 DBG("***run in %s %x % x\n",__FUNCTION__,i2c->addr,*(msgs[1].buf));
788 int rk808_i2c_write(struct rk808 *rk808, char reg, int count, const u8 src)
791 struct i2c_client *i2c = rk808->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 = 100*1000;
811 ret = i2c_transfer(adap, &msg, 1);
815 int rk808_reg_read(struct rk808 *rk808, u8 reg)
820 mutex_lock(&rk808->io_lock);
822 ret = rk808_i2c_read(rk808, reg, 1, &val);
823 DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
825 mutex_unlock(&rk808->io_lock);
828 mutex_unlock(&rk808->io_lock);
832 EXPORT_SYMBOL_GPL(rk808_reg_read);
834 int rk808_reg_write(struct rk808 *rk808, u8 reg, u8 val)
838 mutex_lock(&rk808->io_lock);
840 err = rk808_i2c_write(rk808, reg, 1,val);
842 dev_err(rk808->dev, "Write for reg 0x%x failed\n", reg);
844 mutex_unlock(&rk808->io_lock);
847 EXPORT_SYMBOL_GPL(rk808_reg_write);
849 int rk808_set_bits(struct rk808 *rk808, u8 reg, u8 mask, u8 val)
854 mutex_lock(&rk808->io_lock);
856 ret = rk808_i2c_read(rk808, reg, 1, &tmp);
857 DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
859 mutex_unlock(&rk808->io_lock);
862 tmp = (tmp & ~mask) | val;
863 ret = rk808_i2c_write(rk808, reg, 1, tmp);
864 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
866 mutex_unlock(&rk808->io_lock);
869 ret = rk808_i2c_read(rk808, reg, 1, &tmp);
871 mutex_unlock(&rk808->io_lock);
874 DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
875 mutex_unlock(&rk808->io_lock);
879 EXPORT_SYMBOL_GPL(rk808_set_bits);
881 int rk808_clear_bits(struct rk808 *rk808, u8 reg, u8 mask)
886 mutex_lock(&rk808->io_lock);
887 err = rk808_i2c_read(rk808, reg, 1, &data);
889 dev_err(rk808->dev, "read from reg %x failed\n", reg);
894 err = rk808_i2c_write(rk808, reg, 1, data);
896 dev_err(rk808->dev, "write to reg %x failed\n", reg);
899 mutex_unlock(&rk808->io_lock);
902 EXPORT_SYMBOL_GPL(rk808_clear_bits);
904 int rk808_bulk_read(struct rk808 *rk808, u8 reg,
909 #if defined(CONFIG_MFD_RK610)
910 int i; //Solve communication conflict when rk610 and rk808 on the same i2c
912 mutex_lock(&rk808->io_lock);
913 for(i=0; i<count; i++){
914 ret = rk808_reg_read(rk808, reg+i);
916 printk("%s: failed read reg 0x%0x, ret = %d\n", __FUNCTION__, reg+i, ret);
917 mutex_unlock(&rk808->io_lock);
920 buf[i] = ret & 0x000000FF;
923 mutex_unlock(&rk808->io_lock);
925 mutex_lock(&rk808->io_lock);
927 ret = rk808->read(rk808, reg, count, buf);
929 mutex_unlock(&rk808->io_lock);
934 EXPORT_SYMBOL_GPL(rk808_bulk_read);
936 int rk808_bulk_write(struct rk808 *rk808, u8 reg,
941 #if defined(CONFIG_MFD_RK610)
942 int i; // //Solve communication conflict when rk610 and 808 on the same i2c
944 mutex_lock(&rk808->io_lock);
945 for(i=0; i<count; i++){
946 ret = rk808_reg_write(rk808, reg+i, buf[i]);
948 printk("%s: failed write reg=0x%0x, val=0x%0x, ret = %d\n", __FUNCTION__, reg+i, buf[i], ret);
949 mutex_unlock(&rk808->io_lock);
953 mutex_unlock(&rk808->io_lock);
955 mutex_lock(&rk808->io_lock);
957 ret = rk808->write(rk808, reg, count, buf);
959 mutex_unlock(&rk808->io_lock);
964 EXPORT_SYMBOL_GPL(rk808_bulk_write);
968 static ssize_t rk808_test_store(struct kobject *kobj, struct kobj_attribute *attr,
969 const char *buf, size_t n)
975 const char *buftmp = buf;
976 struct rk808 *rk808 = g_rk808;
978 * W Addr(8Bit) regAddr(8Bit) data0(8Bit) data1(8Bit) data2(8Bit) data3(8Bit)
979 * :data can be less than 4 byte
981 * C gpio_name(poweron/powerhold/sleep/boot0/boot1) value(H/L)
983 sscanf(buftmp, "%c ", &cmd);
984 printk("------zhangqing: get cmd = %c\n", cmd);
987 sscanf(buftmp, "%c %x %x ", &cmd, &getdata[0], &getdata[1]);
988 regAddr = (u8)(getdata[0] & 0xff);
989 data = (u8)(getdata[1] & 0xff);
990 printk("get value = %x\n", data);
992 rk808_i2c_write(rk808, regAddr, 1, data);
993 rk808_i2c_read(rk808, regAddr, 1, &data);
994 printk("%x %x\n", getdata[1], data);
997 sscanf(buftmp, "%c %x ", &cmd, &getdata[0]);
998 printk("CMD : %c %x\n", cmd, getdata[0]);
1000 regAddr = (u8)(getdata[0] & 0xff);
1001 rk808_i2c_read(rk808, regAddr, 1, &data);
1002 printk("%x %x\n", getdata[0], data);
1005 printk("Unknown command\n");
1011 static ssize_t rk808_test_show(struct kobject *kobj, struct kobj_attribute *attr,
1016 return sprintf(s, "%s\n", buf);
1020 static struct kobject *rk808_kobj;
1021 struct rk808_attribute {
1022 struct attribute attr;
1023 ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,
1025 ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,
1026 const char *buf, size_t n);
1029 static struct rk808_attribute rk808_attrs[] = {
1030 /* node_name permision show_func store_func */
1031 __ATTR(rk808_test, S_IRUGO | S_IWUSR, rk808_test_show, rk808_test_store),
1035 static irqreturn_t rk808_vbat_lo_irq(int irq, void *data)
1037 printk("rk808 vbat low %s:irq=%d\n",__func__,irq);
1038 rk808_set_bits(g_rk808,0x4c,(0x1 << 1),(0x1 <<1));
1039 // rk_send_wakeup_key();
1044 static struct of_device_id rk808_of_match[] = {
1045 { .compatible = "rockchip,rk808"},
1048 MODULE_DEVICE_TABLE(of, rk808_of_match);
1052 static struct of_regulator_match rk808_reg_matches[] = {
1053 { .name = "rk_dcdc1", .driver_data = (void *)0 },
1054 { .name = "rk_dcdc2", .driver_data = (void *)1 },
1055 { .name = "rk_dcdc3", .driver_data = (void *)2 },
1056 { .name = "rk_dcdc4", .driver_data = (void *)3 },
1057 { .name = "rk_ldo1", .driver_data = (void *)4 },
1058 { .name = "rk_ldo2", .driver_data = (void *)5 },
1059 { .name = "rk_ldo3", .driver_data = (void *)6 },
1060 { .name = "rk_ldo4", .driver_data = (void *)7 },
1061 { .name = "rk_ldo5", .driver_data = (void *)8 },
1062 { .name = "rk_ldo6", .driver_data = (void *)9 },
1063 { .name = "rk_ldo7", .driver_data = (void *)10 },
1064 { .name = "rk_ldo8", .driver_data = (void *)11 },
1065 { .name = "rk_ldo9", .driver_data = (void *)12 },
1066 { .name = "rk_ldo10", .driver_data = (void *)13 },
1069 static struct rk808_board *rk808_parse_dt(struct rk808 *rk808)
1071 struct rk808_board *pdata;
1072 struct device_node *regs,*rk808_pmic_np;
1075 rk808_pmic_np = of_node_get(rk808->dev->of_node);
1076 if (!rk808_pmic_np) {
1077 printk("could not find pmic sub-node\n");
1081 regs = of_find_node_by_name(rk808_pmic_np, "regulators");
1085 count = of_regulator_match(rk808->dev, regs, rk808_reg_matches,
1086 rk808_NUM_REGULATORS);
1088 if ((count < 0) || (count > rk808_NUM_REGULATORS))
1091 pdata = devm_kzalloc(rk808->dev, sizeof(*pdata), GFP_KERNEL);
1095 for (i = 0; i < count; i++) {
1096 if (!rk808_reg_matches[i].init_data || !rk808_reg_matches[i].of_node)
1099 pdata->rk808_init_data[i] = rk808_reg_matches[i].init_data;
1100 pdata->of_node[i] = rk808_reg_matches[i].of_node;
1102 pdata->irq = rk808->chip_irq;
1103 pdata->irq_base = -1;
1105 pdata->irq_gpio = of_get_named_gpio(rk808_pmic_np,"gpios",0);
1106 if (!gpio_is_valid(pdata->irq_gpio)) {
1107 printk("invalid gpio: %d\n", pdata->irq_gpio);
1111 pdata->pmic_sleep_gpio = of_get_named_gpio(rk808_pmic_np,"gpios",1);
1112 if (!gpio_is_valid(pdata->pmic_sleep_gpio)) {
1113 printk("invalid gpio: %d\n", pdata->pmic_sleep_gpio);
1115 pdata->pmic_sleep = true;
1117 pdata->pm_off = of_property_read_bool(rk808_pmic_np,"rk808,system-power-controller");
1123 static struct rk808_board *rk808_parse_dt(struct i2c_client *i2c)
1128 static void rk808_shutdown(void)
1132 struct rk808 *rk808 = g_rk808;
1134 printk("%s\n",__func__);
1135 /***************get dc1\dc2 voltage *********************/
1137 reg = rk808_reg_read(rk808,rk808_BUCK_SET_VOL_REG(i));
1138 reg &= BUCK_VOL_MASK;
1139 val = 712500 + reg * 12500;
1140 printk("%s,line=%d dc[%d]= %d\n", __func__,__LINE__,(i+1),val);
1142 /*****************************************************/
1143 ret = rk808_set_bits(rk808, RK808_INT_STS_MSK_REG1,(0x3<<5),(0x3<<5)); //close rtc int when power off
1144 ret = rk808_clear_bits(rk808, RK808_RTC_INT_REG,(0x3<<2)); //close rtc int when power off
1145 mutex_lock(&rk808->io_lock);
1149 static struct syscore_ops rk808_syscore_ops = {
1150 .shutdown = rk808_shutdown,
1153 static void rk808_device_shutdown(void)
1157 struct rk808 *rk808 = g_rk808;
1158 for(i=0;i < 10;i++){
1159 printk("%s\n",__func__);
1160 ret = rk808_i2c_read(rk808,RK808_DEVCTRL_REG,1,®);
1163 ret = rk808_i2c_write(rk808, RK808_DEVCTRL_REG, 1,(reg |(0x1 <<3)));
1165 printk("rk808 power off error!\n");
1171 EXPORT_SYMBOL_GPL(rk808_device_shutdown);
1173 __weak void rk808_device_suspend(void) {}
1174 __weak void rk808_device_resume(void) {}
1176 static int rk808_suspend(struct device *dev)
1178 rk808_device_suspend();
1182 static int rk808_resume(struct device *dev)
1184 rk808_device_resume();
1188 static int rk808_suspend(struct device *dev)
1193 static int rk808_resume(struct device *dev)
1199 static bool is_volatile_reg(struct device *dev, unsigned int reg)
1201 if ((reg >= RK808_DCDC_EN_REG) && (reg <= RK808_LDO8_SLP_VSEL_REG)) {
1207 static const struct regmap_config rk808_regmap_config = {
1210 .volatile_reg = is_volatile_reg,
1211 .max_register = rk808_NUM_REGULATORS - 1,
1212 .cache_type = REGCACHE_RBTREE,
1215 #ifdef CONFIG_HAS_EARLYSUSPEND
1216 __weak void rk808_early_suspend(struct early_suspend *h) {}
1217 __weak void rk808_late_resume(struct early_suspend *h) {}
1220 static int rk808_pre_init(struct rk808 *rk808)
1223 printk("%s,line=%d\n", __func__,__LINE__);
1224 /**********disable dcdc uv func****************/
1225 ret = rk808_reg_write(rk808,RK808_DCDC_UV_ACT_REG,0x10);
1227 printk(KERN_ERR "Unable to write RK808_DCDC_UV_ACT_REG reg\n");
1230 /**********************************/
1231 /***********set ILIM ************/
1232 val = rk808_reg_read(rk808,RK808_BUCK3_CONFIG_REG);
1233 val &= (~(0x7 <<0));
1235 ret = rk808_reg_write(rk808,RK808_BUCK3_CONFIG_REG,val);
1237 printk(KERN_ERR "Unable to write RK808_BUCK3_CONFIG_REG reg\n");
1241 val = rk808_reg_read(rk808,RK808_BUCK4_CONFIG_REG);
1242 val &= (~(0x7 <<0));
1244 ret = rk808_reg_write(rk808,RK808_BUCK4_CONFIG_REG,val);
1246 printk(KERN_ERR "Unable to write RK808_BUCK4_CONFIG_REG reg\n");
1250 val = rk808_reg_read(rk808,RK808_BOOST_CONFIG_REG);
1251 val &= (~(0x7 <<0));
1253 ret = rk808_reg_write(rk808,RK808_BOOST_CONFIG_REG,val);
1255 printk(KERN_ERR "Unable to write RK808_BOOST_CONFIG_REG reg\n");
1258 /*****************************************/
1259 /***********set buck OTP function************/
1260 ret = rk808_reg_write(rk808,0x6f,0x5a);
1262 printk(KERN_ERR "Unable to write 0x6f reg\n");
1266 ret = rk808_reg_write(rk808,0x91,0x80);
1268 printk(KERN_ERR "Unable to write 0x91 reg\n");
1272 ret = rk808_reg_write(rk808,0x92,0x55);
1274 printk(KERN_ERR "Unable to write 0x92 reg\n");
1277 /*****************************************/
1278 /***********set buck 12.5mv/us ************/
1279 val = rk808_reg_read(rk808,RK808_BUCK1_CONFIG_REG);
1280 val &= (~(0x3 <<3));
1282 ret = rk808_reg_write(rk808,RK808_BUCK1_CONFIG_REG,val);
1284 printk(KERN_ERR "Unable to write RK808_BUCK1_CONFIG_REG reg\n");
1288 val = rk808_reg_read(rk808,RK808_BUCK2_CONFIG_REG);
1289 val &= (~(0x3 <<3));
1291 ret = rk808_reg_write(rk808,RK808_BUCK2_CONFIG_REG,val);
1293 printk(KERN_ERR "Unable to write RK808_BUCK2_CONFIG_REG reg\n");
1296 /*****************************************/
1298 /*******enable switch and boost***********/
1299 val = rk808_reg_read(rk808,RK808_DCDC_EN_REG);
1300 val |= (0x3 << 5); //enable switch1/2
1301 val |= (0x1 << 4); //enable boost
1302 ret = rk808_reg_write(rk808,RK808_DCDC_EN_REG,val);
1304 printk(KERN_ERR "Unable to write RK808_DCDC_EN_REG reg\n");
1307 /****************************************/
1309 /****************set vbat low **********/
1310 val = rk808_reg_read(rk808,RK808_VB_MON_REG);
1311 val &=(~(VBAT_LOW_VOL_MASK | VBAT_LOW_ACT_MASK));
1312 val |= (RK808_VBAT_LOW_3V5 | EN_VBAT_LOW_IRQ);
1313 ret = rk808_reg_write(rk808,RK808_VB_MON_REG,val);
1315 printk(KERN_ERR "Unable to write RK818_VB_MON_REG reg\n");
1318 /**************************************/
1320 /**********mask int****************/
1321 val = rk808_reg_read(rk808,RK808_INT_STS_MSK_REG1);
1322 val |= (0x1<<0); //mask vout_lo_int
1323 ret = rk808_reg_write(rk808,RK808_INT_STS_MSK_REG1,val);
1325 printk(KERN_ERR "Unable to write RK808_INT_STS_MSK_REG1 reg\n");
1328 /**********************************/
1329 /**********enable clkout2****************/
1330 ret = rk808_reg_write(rk808,RK808_CLK32OUT_REG,0x01);
1332 printk(KERN_ERR "Unable to write RK808_CLK32OUT_REG reg\n");
1335 /**********************************/
1336 ret = rk808_clear_bits(rk808, RK808_INT_STS_MSK_REG1,(0x3<<5)); //open rtc int when power on
1337 ret = rk808_set_bits(rk808, RK808_RTC_INT_REG,(0x1<<3),(0x1<<3)); //open rtc int when power on
1342 static int rk808_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
1344 struct rk808 *rk808;
1345 struct rk808_board *pdev;
1346 const struct of_device_id *match;
1347 struct regulator_config config = { };
1348 struct regulator_dev *rk808_rdev;
1349 struct regulator_init_data *reg_data;
1350 const char *rail_name = NULL;
1354 printk("%s,line=%d\n", __func__,__LINE__);
1356 if (i2c->dev.of_node) {
1357 match = of_match_device(rk808_of_match, &i2c->dev);
1359 dev_err(&i2c->dev,"Failed to find matching dt id\n");
1364 rk808 = devm_kzalloc(&i2c->dev,sizeof(struct rk808), GFP_KERNEL);
1365 if (rk808 == NULL) {
1370 rk808->dev = &i2c->dev;
1371 i2c_set_clientdata(i2c, rk808);
1372 // rk808->read = rk808_i2c_read;
1373 // rk808->write = rk808_i2c_write;
1375 rk808->regmap = devm_regmap_init_i2c(i2c, &rk808_regmap_config);
1376 if (IS_ERR(rk808->regmap)) {
1377 printk("regmap initialization failed\n");
1381 mutex_init(&rk808->io_lock);
1383 ret = rk808_reg_read(rk808,0x2f);
1384 if ((ret < 0) || (ret == 0xff)){
1385 printk("The device is not rk808 %d\n",ret);
1389 ret = rk808_pre_init(rk808);
1391 printk("The rk808_pre_init failed %d\n",ret);
1395 if (rk808->dev->of_node)
1396 pdev = rk808_parse_dt(rk808);
1398 /******************************set sleep vol & dcdc mode******************/
1400 rk808->pmic_sleep_gpio = pdev->pmic_sleep_gpio;
1401 if (gpio_is_valid(rk808->pmic_sleep_gpio)) {
1402 ret = gpio_request(rk808->pmic_sleep_gpio, "rk808_pmic_sleep");
1404 dev_err(rk808->dev,"Failed to request gpio %d with ret:""%d\n", rk808->pmic_sleep_gpio, ret);
1407 gpio_direction_output(rk808->pmic_sleep_gpio,0);
1408 ret = gpio_get_value(rk808->pmic_sleep_gpio);
1409 gpio_free(rk808->pmic_sleep_gpio);
1410 pr_info("%s: rk808_pmic_sleep=%x\n", __func__, ret);
1413 /**********************************************************/
1416 rk808->num_regulators = rk808_NUM_REGULATORS;
1417 rk808->rdev = kcalloc(rk808_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
1421 /* Instantiate the regulators */
1422 for (i = 0; i < rk808_NUM_REGULATORS; i++) {
1423 reg_data = pdev->rk808_init_data[i];
1426 config.dev = rk808->dev;
1427 config.driver_data = rk808;
1428 config.regmap = rk808->regmap;
1429 if (rk808->dev->of_node)
1430 config.of_node = pdev->of_node[i];
1431 if (reg_data && reg_data->constraints.name)
1432 rail_name = reg_data->constraints.name;
1434 rail_name = regulators[i].name;
1435 reg_data->supply_regulator = rail_name;
1437 config.init_data =reg_data;
1439 rk808_rdev = regulator_register(®ulators[i],&config);
1440 if (IS_ERR(rk808_rdev)) {
1441 printk("failed to register %d regulator\n",i);
1444 rk808->rdev[i] = rk808_rdev;
1448 // rk808->wakeup = pdev->wakeup;
1449 rk808->irq_gpio = pdev->irq_gpio;
1450 ret = rk808_irq_init(rk808, rk808->irq_gpio, pdev);
1454 ret = mfd_add_devices(rk808->dev, -1,
1455 rk808s, ARRAY_SIZE(rk808s),
1458 /********************vbat low int**************/
1459 vlow_irq = irq_create_mapping(rk808->irq_domain, RK808_IRQ_VB_LO);
1460 ret = request_threaded_irq(vlow_irq, NULL, rk808_vbat_lo_irq,
1461 IRQF_TRIGGER_RISING, "rk808_vbatlow",
1464 dev_err(rk808->dev, "Failed to request periodic IRQ %d: %d\n",
1465 vlow_irq+ RK808_IRQ_VB_LO, ret);
1469 /*********************************************/
1472 if (pdev->pm_off && !pm_power_off) {
1473 pm_power_off = rk808_device_shutdown;
1476 #ifdef CONFIG_HAS_EARLYSUSPEND
1477 rk808->rk808_suspend.suspend = rk808_early_suspend,
1478 rk808->rk808_suspend.resume = rk808_late_resume,
1479 rk808->rk808_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 1,
1480 register_early_suspend(&rk808->rk808_suspend);
1484 rk808_kobj = kobject_create_and_add("rk808", NULL);
1487 for (i = 0; i < ARRAY_SIZE(rk808_attrs); i++) {
1488 ret = sysfs_create_file(rk808_kobj, &rk808_attrs[i].attr);
1490 printk("create index %d error\n", i);
1496 register_syscore_ops(&rk808_syscore_ops);
1501 mfd_remove_devices(rk808->dev);
1506 static int rk808_i2c_remove(struct i2c_client *i2c)
1508 struct rk808 *rk808 = i2c_get_clientdata(i2c);
1511 unregister_syscore_ops(&rk808_syscore_ops);
1512 for (i = 0; i < rk808->num_regulators; i++)
1514 regulator_unregister(rk808->rdev[i]);
1516 i2c_set_clientdata(i2c, NULL);
1521 static const struct dev_pm_ops rk808_pm_ops = {
1522 .suspend = rk808_suspend,
1523 .resume = rk808_resume,
1526 static const struct i2c_device_id rk808_i2c_id[] = {
1531 MODULE_DEVICE_TABLE(i2c, rk808_i2c_id);
1533 static struct i2c_driver rk808_i2c_driver = {
1536 .owner = THIS_MODULE,
1538 .pm = &rk808_pm_ops,
1540 .of_match_table =of_match_ptr(rk808_of_match),
1542 .probe = rk808_i2c_probe,
1543 .remove = rk808_i2c_remove,
1544 .id_table = rk808_i2c_id,
1547 static int __init rk808_module_init(void)
1550 ret = i2c_add_driver(&rk808_i2c_driver);
1552 pr_err("Failed to register I2C driver: %d\n", ret);
1555 //module_init(rk808_module_init);
1556 //subsys_initcall(rk808_module_init);
1557 //rootfs_initcall(rk808_module_init);
1558 subsys_initcall_sync(rk808_module_init);
1560 static void __exit rk808_module_exit(void)
1562 i2c_del_driver(&rk808_i2c_driver);
1564 module_exit(rk808_module_exit);
1566 MODULE_LICENSE("GPL");
1567 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
1568 MODULE_DESCRIPTION("rk808 PMIC driver");