Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
mfd: rk808: Split into core and i2c
Split rk808 into a core and an i2c part in preparation for
SPI support.
Acked-by: Alexandre Belloni <alexandre.belloni@bootlin.com> # for RTC
Tested-by: Diederik de Haas <didi.debian@cknow.org> # Rock64, Quartz64 Model A + B
Tested-by: Vincent Legoll <vincent.legoll@gmail.com> # Pine64 QuartzPro64
Signed-off-by: Sebastian Reichel <sebastian.reichel@collabora.com>
Link: https://lore.kernel.org/r/20230504173618.142075-6-sebastian.reichel@collabora.com
Signed-off-by: Lee Jones <lee@kernel.org>
authored by
Sebastian Reichel
and committed by
Lee Jones
c20e8c5b
04944997
+256
-183
+1
-1
drivers/clk/Kconfig
+1
-1
drivers/clk/Kconfig
···
82
82
83
83
config COMMON_CLK_RK808
84
84
tristate "Clock driver for RK805/RK808/RK809/RK817/RK818"
85
-
depends on MFD_RK808
85
+
depends on MFD_RK8XX
86
86
help
87
87
This driver supports RK805, RK809 and RK817, RK808 and RK818 crystal oscillator clock.
88
88
These multi-function devices have two fixed-rate oscillators, clocked at 32KHz each.
+1
-1
drivers/input/misc/Kconfig
+1
-1
drivers/input/misc/Kconfig
+6
-1
drivers/mfd/Kconfig
+6
-1
drivers/mfd/Kconfig
···
1183
1183
Additional drivers must be enabled in order to use the
1184
1184
different functionality of the device.
1185
1185
1186
-
config MFD_RK808
1186
+
config MFD_RK8XX
1187
+
bool
1188
+
select MFD_CORE
1189
+
1190
+
config MFD_RK8XX_I2C
1187
1191
tristate "Rockchip RK805/RK808/RK809/RK817/RK818 Power Management Chip"
1188
1192
depends on I2C && OF
1189
1193
select MFD_CORE
1190
1194
select REGMAP_I2C
1191
1195
select REGMAP_IRQ
1196
+
select MFD_RK8XX
1192
1197
help
1193
1198
If you say yes here you get support for the RK805, RK808, RK809,
1194
1199
RK817 and RK818 Power Management chips.
+2
-1
drivers/mfd/Makefile
+2
-1
drivers/mfd/Makefile
···
214
214
obj-$(CONFIG_MFD_VIPERBOARD) += viperboard.o
215
215
obj-$(CONFIG_MFD_NTXEC) += ntxec.o
216
216
obj-$(CONFIG_MFD_RC5T583) += rc5t583.o rc5t583-irq.o
217
-
obj-$(CONFIG_MFD_RK808) += rk808.o
217
+
obj-$(CONFIG_MFD_RK8XX) += rk8xx-core.o
218
+
obj-$(CONFIG_MFD_RK8XX_I2C) += rk8xx-i2c.o
218
219
obj-$(CONFIG_MFD_RN5T618) += rn5t618.o
219
220
obj-$(CONFIG_MFD_SEC_CORE) += sec-core.o sec-irq.o
220
221
obj-$(CONFIG_MFD_SYSCON) += syscon.o
+35
-174
drivers/mfd/rk808.c
drivers/mfd/rk8xx-core.c
+35
-174
drivers/mfd/rk808.c
drivers/mfd/rk8xx-core.c
···
1
1
// SPDX-License-Identifier: GPL-2.0-only
2
2
/*
3
-
* MFD core driver for Rockchip RK808/RK818
3
+
* MFD core driver for Rockchip RK8XX
4
4
*
5
5
* Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd
6
+
* Copyright (C) 2016 PHYTEC Messtechnik GmbH
6
7
*
7
8
* Author: Chris Zhong <zyw@rock-chips.com>
8
9
* Author: Zhang Qing <zhangqing@rock-chips.com>
9
-
*
10
-
* Copyright (C) 2016 PHYTEC Messtechnik GmbH
11
-
*
12
10
* Author: Wadim Egorov <w.egorov@phytec.de>
13
11
*/
14
12
15
-
#include <linux/i2c.h>
16
13
#include <linux/interrupt.h>
17
14
#include <linux/mfd/rk808.h>
18
15
#include <linux/mfd/core.h>
···
22
25
int addr;
23
26
int mask;
24
27
int value;
25
-
};
26
-
27
-
static bool rk808_is_volatile_reg(struct device *dev, unsigned int reg)
28
-
{
29
-
/*
30
-
* Notes:
31
-
* - Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but
32
-
* we don't use that feature. It's better to cache.
33
-
* - It's unlikely we care that RK808_DEVCTRL_REG is volatile since
34
-
* bits are cleared in case when we shutoff anyway, but better safe.
35
-
*/
36
-
37
-
switch (reg) {
38
-
case RK808_SECONDS_REG ... RK808_WEEKS_REG:
39
-
case RK808_RTC_STATUS_REG:
40
-
case RK808_VB_MON_REG:
41
-
case RK808_THERMAL_REG:
42
-
case RK808_DCDC_UV_STS_REG:
43
-
case RK808_LDO_UV_STS_REG:
44
-
case RK808_DCDC_PG_REG:
45
-
case RK808_LDO_PG_REG:
46
-
case RK808_DEVCTRL_REG:
47
-
case RK808_INT_STS_REG1:
48
-
case RK808_INT_STS_REG2:
49
-
return true;
50
-
}
51
-
52
-
return false;
53
-
}
54
-
55
-
static bool rk817_is_volatile_reg(struct device *dev, unsigned int reg)
56
-
{
57
-
/*
58
-
* Notes:
59
-
* - Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but
60
-
* we don't use that feature. It's better to cache.
61
-
*/
62
-
63
-
switch (reg) {
64
-
case RK817_SECONDS_REG ... RK817_WEEKS_REG:
65
-
case RK817_RTC_STATUS_REG:
66
-
case RK817_CODEC_DTOP_LPT_SRST:
67
-
case RK817_GAS_GAUGE_ADC_CONFIG0 ... RK817_GAS_GAUGE_CUR_ADC_K0:
68
-
case RK817_PMIC_CHRG_STS:
69
-
case RK817_PMIC_CHRG_OUT:
70
-
case RK817_PMIC_CHRG_IN:
71
-
case RK817_INT_STS_REG0:
72
-
case RK817_INT_STS_REG1:
73
-
case RK817_INT_STS_REG2:
74
-
case RK817_SYS_STS:
75
-
return true;
76
-
}
77
-
78
-
return false;
79
-
}
80
-
81
-
static const struct regmap_config rk818_regmap_config = {
82
-
.reg_bits = 8,
83
-
.val_bits = 8,
84
-
.max_register = RK818_USB_CTRL_REG,
85
-
.cache_type = REGCACHE_RBTREE,
86
-
.volatile_reg = rk808_is_volatile_reg,
87
-
};
88
-
89
-
static const struct regmap_config rk805_regmap_config = {
90
-
.reg_bits = 8,
91
-
.val_bits = 8,
92
-
.max_register = RK805_OFF_SOURCE_REG,
93
-
.cache_type = REGCACHE_RBTREE,
94
-
.volatile_reg = rk808_is_volatile_reg,
95
-
};
96
-
97
-
static const struct regmap_config rk808_regmap_config = {
98
-
.reg_bits = 8,
99
-
.val_bits = 8,
100
-
.max_register = RK808_IO_POL_REG,
101
-
.cache_type = REGCACHE_RBTREE,
102
-
.volatile_reg = rk808_is_volatile_reg,
103
-
};
104
-
105
-
static const struct regmap_config rk817_regmap_config = {
106
-
.reg_bits = 8,
107
-
.val_bits = 8,
108
-
.max_register = RK817_GPIO_INT_CFG,
109
-
.cache_type = REGCACHE_NONE,
110
-
.volatile_reg = rk817_is_volatile_reg,
111
28
};
112
29
113
30
static const struct resource rtc_resources[] = {
···
516
605
return NOTIFY_DONE;
517
606
}
518
607
519
-
static void rk8xx_shutdown(struct i2c_client *client)
608
+
void rk8xx_shutdown(struct device *dev)
520
609
{
521
-
struct rk808 *rk808 = i2c_get_clientdata(client);
610
+
struct rk808 *rk808 = dev_get_drvdata(dev);
522
611
int ret;
523
612
524
613
switch (rk808->variant) {
···
539
628
return;
540
629
}
541
630
if (ret)
542
-
dev_warn(&client->dev,
631
+
dev_warn(dev,
543
632
"Cannot switch to power down function\n");
544
633
}
634
+
EXPORT_SYMBOL_GPL(rk8xx_shutdown);
545
635
546
-
static const struct of_device_id rk808_of_match[] = {
547
-
{ .compatible = "rockchip,rk805" },
548
-
{ .compatible = "rockchip,rk808" },
549
-
{ .compatible = "rockchip,rk809" },
550
-
{ .compatible = "rockchip,rk817" },
551
-
{ .compatible = "rockchip,rk818" },
552
-
{ },
553
-
};
554
-
MODULE_DEVICE_TABLE(of, rk808_of_match);
555
-
556
-
static int rk808_probe(struct i2c_client *client)
636
+
int rk8xx_probe(struct device *dev, int variant, unsigned int irq, struct regmap *regmap)
557
637
{
558
-
struct device_node *np = client->dev.of_node;
559
638
struct rk808 *rk808;
560
639
const struct rk808_reg_data *pre_init_reg;
561
640
const struct mfd_cell *cells;
562
641
int nr_pre_init_regs;
563
642
int nr_cells;
564
-
int msb, lsb;
565
-
unsigned char pmic_id_msb, pmic_id_lsb;
566
643
int ret;
567
644
int i;
568
645
569
-
rk808 = devm_kzalloc(&client->dev, sizeof(*rk808), GFP_KERNEL);
646
+
rk808 = devm_kzalloc(dev, sizeof(*rk808), GFP_KERNEL);
570
647
if (!rk808)
571
648
return -ENOMEM;
572
-
573
-
if (of_device_is_compatible(np, "rockchip,rk817") ||
574
-
of_device_is_compatible(np, "rockchip,rk809")) {
575
-
pmic_id_msb = RK817_ID_MSB;
576
-
pmic_id_lsb = RK817_ID_LSB;
577
-
} else {
578
-
pmic_id_msb = RK808_ID_MSB;
579
-
pmic_id_lsb = RK808_ID_LSB;
580
-
}
581
-
582
-
/* Read chip variant */
583
-
msb = i2c_smbus_read_byte_data(client, pmic_id_msb);
584
-
if (msb < 0)
585
-
return dev_err_probe(&client->dev, msb, "failed to read the chip id MSB\n");
586
-
587
-
lsb = i2c_smbus_read_byte_data(client, pmic_id_lsb);
588
-
if (lsb < 0)
589
-
return dev_err_probe(&client->dev, lsb, "failed to read the chip id LSB\n");
590
-
591
-
rk808->variant = ((msb << 8) | lsb) & RK8XX_ID_MSK;
592
-
dev_info(&client->dev, "chip id: 0x%x\n", (unsigned int)rk808->variant);
649
+
rk808->dev = dev;
650
+
rk808->variant = variant;
651
+
rk808->regmap = regmap;
652
+
dev_set_drvdata(dev, rk808);
593
653
594
654
switch (rk808->variant) {
595
655
case RK805_ID:
596
-
rk808->regmap_cfg = &rk805_regmap_config;
597
656
rk808->regmap_irq_chip = &rk805_irq_chip;
598
657
pre_init_reg = rk805_pre_init_reg;
599
658
nr_pre_init_regs = ARRAY_SIZE(rk805_pre_init_reg);
···
571
690
nr_cells = ARRAY_SIZE(rk805s);
572
691
break;
573
692
case RK808_ID:
574
-
rk808->regmap_cfg = &rk808_regmap_config;
575
693
rk808->regmap_irq_chip = &rk808_irq_chip;
576
694
pre_init_reg = rk808_pre_init_reg;
577
695
nr_pre_init_regs = ARRAY_SIZE(rk808_pre_init_reg);
···
578
698
nr_cells = ARRAY_SIZE(rk808s);
579
699
break;
580
700
case RK818_ID:
581
-
rk808->regmap_cfg = &rk818_regmap_config;
582
701
rk808->regmap_irq_chip = &rk818_irq_chip;
583
702
pre_init_reg = rk818_pre_init_reg;
584
703
nr_pre_init_regs = ARRAY_SIZE(rk818_pre_init_reg);
···
586
707
break;
587
708
case RK809_ID:
588
709
case RK817_ID:
589
-
rk808->regmap_cfg = &rk817_regmap_config;
590
710
rk808->regmap_irq_chip = &rk817_irq_chip;
591
711
pre_init_reg = rk817_pre_init_reg;
592
712
nr_pre_init_regs = ARRAY_SIZE(rk817_pre_init_reg);
···
593
715
nr_cells = ARRAY_SIZE(rk817s);
594
716
break;
595
717
default:
596
-
dev_err(&client->dev, "Unsupported RK8XX ID %lu\n",
597
-
rk808->variant);
718
+
dev_err(dev, "Unsupported RK8XX ID %lu\n", rk808->variant);
598
719
return -EINVAL;
599
720
}
600
721
601
-
rk808->dev = &client->dev;
602
-
i2c_set_clientdata(client, rk808);
722
+
dev_info(dev, "chip id: 0x%x\n", (unsigned int)rk808->variant);
603
723
604
-
rk808->regmap = devm_regmap_init_i2c(client, rk808->regmap_cfg);
605
-
if (IS_ERR(rk808->regmap))
606
-
return dev_err_probe(&client->dev, PTR_ERR(rk808->regmap),
607
-
"regmap initialization failed\n");
724
+
if (!irq)
725
+
return dev_err_probe(dev, -EINVAL, "No interrupt support, no core IRQ\n");
608
726
609
-
if (!client->irq)
610
-
return dev_err_probe(&client->dev, -EINVAL, "No interrupt support, no core IRQ\n");
611
-
612
-
ret = devm_regmap_add_irq_chip(&client->dev, rk808->regmap, client->irq,
727
+
ret = devm_regmap_add_irq_chip(dev, rk808->regmap, irq,
613
728
IRQF_ONESHOT, -1,
614
729
rk808->regmap_irq_chip, &rk808->irq_data);
615
730
if (ret)
616
-
return dev_err_probe(&client->dev, ret, "Failed to add irq_chip\n");
731
+
return dev_err_probe(dev, ret, "Failed to add irq_chip\n");
617
732
618
733
for (i = 0; i < nr_pre_init_regs; i++) {
619
734
ret = regmap_update_bits(rk808->regmap,
···
614
743
pre_init_reg[i].mask,
615
744
pre_init_reg[i].value);
616
745
if (ret)
617
-
return dev_err_probe(&client->dev, ret, "0x%x write err\n",
746
+
return dev_err_probe(dev, ret, "0x%x write err\n",
618
747
pre_init_reg[i].addr);
619
748
}
620
749
621
-
ret = devm_mfd_add_devices(&client->dev, PLATFORM_DEVID_NONE,
750
+
ret = devm_mfd_add_devices(dev, PLATFORM_DEVID_NONE,
622
751
cells, nr_cells, NULL, 0,
623
752
regmap_irq_get_domain(rk808->irq_data));
624
753
if (ret)
625
-
return dev_err_probe(&client->dev, ret, "failed to add MFD devices\n");
754
+
return dev_err_probe(dev, ret, "failed to add MFD devices\n");
626
755
627
-
if (of_property_read_bool(np, "rockchip,system-power-controller")) {
628
-
ret = devm_register_sys_off_handler(&client->dev,
756
+
if (device_property_read_bool(dev, "rockchip,system-power-controller")) {
757
+
ret = devm_register_sys_off_handler(dev,
629
758
SYS_OFF_MODE_POWER_OFF_PREPARE, SYS_OFF_PRIO_HIGH,
630
759
&rk808_power_off, rk808);
631
760
if (ret)
632
-
return dev_err_probe(&client->dev, ret,
761
+
return dev_err_probe(dev, ret,
633
762
"failed to register poweroff handler\n");
634
763
635
764
switch (rk808->variant) {
636
765
case RK809_ID:
637
766
case RK817_ID:
638
-
ret = devm_register_sys_off_handler(&client->dev,
767
+
ret = devm_register_sys_off_handler(dev,
639
768
SYS_OFF_MODE_RESTART, SYS_OFF_PRIO_HIGH,
640
769
&rk808_restart, rk808);
641
770
if (ret)
642
-
dev_warn(&client->dev, "failed to register rst handler, %d\n", ret);
771
+
dev_warn(dev, "failed to register rst handler, %d\n", ret);
643
772
break;
644
773
default:
645
-
dev_dbg(&client->dev, "pmic controlled board reset not supported\n");
774
+
dev_dbg(dev, "pmic controlled board reset not supported\n");
646
775
break;
647
776
}
648
777
}
649
778
650
779
return 0;
651
780
}
781
+
EXPORT_SYMBOL_GPL(rk8xx_probe);
652
782
653
-
static int __maybe_unused rk8xx_suspend(struct device *dev)
783
+
int rk8xx_suspend(struct device *dev)
654
784
{
655
-
struct rk808 *rk808 = i2c_get_clientdata(to_i2c_client(dev));
785
+
struct rk808 *rk808 = dev_get_drvdata(dev);
656
786
int ret = 0;
657
787
658
788
switch (rk808->variant) {
···
676
804
677
805
return ret;
678
806
}
807
+
EXPORT_SYMBOL_GPL(rk8xx_suspend);
679
808
680
-
static int __maybe_unused rk8xx_resume(struct device *dev)
809
+
int rk8xx_resume(struct device *dev)
681
810
{
682
-
struct rk808 *rk808 = i2c_get_clientdata(to_i2c_client(dev));
811
+
struct rk808 *rk808 = dev_get_drvdata(dev);
683
812
int ret = 0;
684
813
685
814
switch (rk808->variant) {
···
697
824
698
825
return ret;
699
826
}
700
-
static SIMPLE_DEV_PM_OPS(rk8xx_pm_ops, rk8xx_suspend, rk8xx_resume);
701
-
702
-
static struct i2c_driver rk808_i2c_driver = {
703
-
.driver = {
704
-
.name = "rk808",
705
-
.of_match_table = rk808_of_match,
706
-
.pm = &rk8xx_pm_ops,
707
-
},
708
-
.probe_new = rk808_probe,
709
-
.shutdown = rk8xx_shutdown,
710
-
};
711
-
712
-
module_i2c_driver(rk808_i2c_driver);
827
+
EXPORT_SYMBOL_GPL(rk8xx_resume);
713
828
714
829
MODULE_LICENSE("GPL");
715
830
MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>");
716
831
MODULE_AUTHOR("Zhang Qing <zhangqing@rock-chips.com>");
717
832
MODULE_AUTHOR("Wadim Egorov <w.egorov@phytec.de>");
718
-
MODULE_DESCRIPTION("RK808/RK818 PMIC driver");
833
+
MODULE_DESCRIPTION("RK8xx PMIC core");
+200
drivers/mfd/rk8xx-i2c.c
+200
drivers/mfd/rk8xx-i2c.c
···
1
+
// SPDX-License-Identifier: GPL-2.0-only
2
+
/*
3
+
* Rockchip RK808/RK818 Core (I2C) driver
4
+
*
5
+
* Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd
6
+
* Copyright (C) 2016 PHYTEC Messtechnik GmbH
7
+
*
8
+
* Author: Chris Zhong <zyw@rock-chips.com>
9
+
* Author: Zhang Qing <zhangqing@rock-chips.com>
10
+
* Author: Wadim Egorov <w.egorov@phytec.de>
11
+
*/
12
+
13
+
#include <linux/i2c.h>
14
+
#include <linux/mfd/rk808.h>
15
+
#include <linux/module.h>
16
+
#include <linux/of.h>
17
+
#include <linux/regmap.h>
18
+
19
+
static bool rk808_is_volatile_reg(struct device *dev, unsigned int reg)
20
+
{
21
+
/*
22
+
* Notes:
23
+
* - Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but
24
+
* we don't use that feature. It's better to cache.
25
+
* - It's unlikely we care that RK808_DEVCTRL_REG is volatile since
26
+
* bits are cleared in case when we shutoff anyway, but better safe.
27
+
*/
28
+
29
+
switch (reg) {
30
+
case RK808_SECONDS_REG ... RK808_WEEKS_REG:
31
+
case RK808_RTC_STATUS_REG:
32
+
case RK808_VB_MON_REG:
33
+
case RK808_THERMAL_REG:
34
+
case RK808_DCDC_UV_STS_REG:
35
+
case RK808_LDO_UV_STS_REG:
36
+
case RK808_DCDC_PG_REG:
37
+
case RK808_LDO_PG_REG:
38
+
case RK808_DEVCTRL_REG:
39
+
case RK808_INT_STS_REG1:
40
+
case RK808_INT_STS_REG2:
41
+
return true;
42
+
}
43
+
44
+
return false;
45
+
}
46
+
47
+
static bool rk817_is_volatile_reg(struct device *dev, unsigned int reg)
48
+
{
49
+
/*
50
+
* Notes:
51
+
* - Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but
52
+
* we don't use that feature. It's better to cache.
53
+
*/
54
+
55
+
switch (reg) {
56
+
case RK817_SECONDS_REG ... RK817_WEEKS_REG:
57
+
case RK817_RTC_STATUS_REG:
58
+
case RK817_CODEC_DTOP_LPT_SRST:
59
+
case RK817_GAS_GAUGE_ADC_CONFIG0 ... RK817_GAS_GAUGE_CUR_ADC_K0:
60
+
case RK817_PMIC_CHRG_STS:
61
+
case RK817_PMIC_CHRG_OUT:
62
+
case RK817_PMIC_CHRG_IN:
63
+
case RK817_INT_STS_REG0:
64
+
case RK817_INT_STS_REG1:
65
+
case RK817_INT_STS_REG2:
66
+
case RK817_SYS_STS:
67
+
return true;
68
+
}
69
+
70
+
return false;
71
+
}
72
+
73
+
74
+
static const struct regmap_config rk818_regmap_config = {
75
+
.reg_bits = 8,
76
+
.val_bits = 8,
77
+
.max_register = RK818_USB_CTRL_REG,
78
+
.cache_type = REGCACHE_RBTREE,
79
+
.volatile_reg = rk808_is_volatile_reg,
80
+
};
81
+
82
+
static const struct regmap_config rk805_regmap_config = {
83
+
.reg_bits = 8,
84
+
.val_bits = 8,
85
+
.max_register = RK805_OFF_SOURCE_REG,
86
+
.cache_type = REGCACHE_RBTREE,
87
+
.volatile_reg = rk808_is_volatile_reg,
88
+
};
89
+
90
+
static const struct regmap_config rk808_regmap_config = {
91
+
.reg_bits = 8,
92
+
.val_bits = 8,
93
+
.max_register = RK808_IO_POL_REG,
94
+
.cache_type = REGCACHE_RBTREE,
95
+
.volatile_reg = rk808_is_volatile_reg,
96
+
};
97
+
98
+
static const struct regmap_config rk817_regmap_config = {
99
+
.reg_bits = 8,
100
+
.val_bits = 8,
101
+
.max_register = RK817_GPIO_INT_CFG,
102
+
.cache_type = REGCACHE_NONE,
103
+
.volatile_reg = rk817_is_volatile_reg,
104
+
};
105
+
106
+
static int rk8xx_i2c_get_variant(struct i2c_client *client)
107
+
{
108
+
u8 pmic_id_msb, pmic_id_lsb;
109
+
int msb, lsb;
110
+
111
+
if (of_device_is_compatible(client->dev.of_node, "rockchip,rk817") ||
112
+
of_device_is_compatible(client->dev.of_node, "rockchip,rk809")) {
113
+
pmic_id_msb = RK817_ID_MSB;
114
+
pmic_id_lsb = RK817_ID_LSB;
115
+
} else {
116
+
pmic_id_msb = RK808_ID_MSB;
117
+
pmic_id_lsb = RK808_ID_LSB;
118
+
}
119
+
120
+
/* Read chip variant */
121
+
msb = i2c_smbus_read_byte_data(client, pmic_id_msb);
122
+
if (msb < 0)
123
+
return dev_err_probe(&client->dev, msb, "failed to read the chip id MSB\n");
124
+
125
+
lsb = i2c_smbus_read_byte_data(client, pmic_id_lsb);
126
+
if (lsb < 0)
127
+
return dev_err_probe(&client->dev, lsb, "failed to read the chip id LSB\n");
128
+
129
+
return ((msb << 8) | lsb) & RK8XX_ID_MSK;
130
+
}
131
+
132
+
static int rk8xx_i2c_probe(struct i2c_client *client)
133
+
{
134
+
const struct regmap_config *regmap_cfg;
135
+
struct regmap *regmap;
136
+
int variant;
137
+
138
+
variant = rk8xx_i2c_get_variant(client);
139
+
if (variant < 0)
140
+
return variant;
141
+
142
+
switch (variant) {
143
+
case RK805_ID:
144
+
regmap_cfg = &rk805_regmap_config;
145
+
break;
146
+
case RK808_ID:
147
+
regmap_cfg = &rk808_regmap_config;
148
+
break;
149
+
case RK818_ID:
150
+
regmap_cfg = &rk818_regmap_config;
151
+
break;
152
+
case RK809_ID:
153
+
case RK817_ID:
154
+
regmap_cfg = &rk817_regmap_config;
155
+
break;
156
+
default:
157
+
return dev_err_probe(&client->dev, -EINVAL, "Unsupported RK8XX ID %x\n", variant);
158
+
}
159
+
160
+
regmap = devm_regmap_init_i2c(client, regmap_cfg);
161
+
if (IS_ERR(regmap))
162
+
return dev_err_probe(&client->dev, PTR_ERR(regmap),
163
+
"regmap initialization failed\n");
164
+
165
+
return rk8xx_probe(&client->dev, variant, client->irq, regmap);
166
+
}
167
+
168
+
static void rk8xx_i2c_shutdown(struct i2c_client *client)
169
+
{
170
+
rk8xx_shutdown(&client->dev);
171
+
}
172
+
173
+
static SIMPLE_DEV_PM_OPS(rk8xx_i2c_pm_ops, rk8xx_suspend, rk8xx_resume);
174
+
175
+
static const struct of_device_id rk8xx_i2c_of_match[] = {
176
+
{ .compatible = "rockchip,rk805" },
177
+
{ .compatible = "rockchip,rk808" },
178
+
{ .compatible = "rockchip,rk809" },
179
+
{ .compatible = "rockchip,rk817" },
180
+
{ .compatible = "rockchip,rk818" },
181
+
{ },
182
+
};
183
+
MODULE_DEVICE_TABLE(of, rk8xx_i2c_of_match);
184
+
185
+
static struct i2c_driver rk8xx_i2c_driver = {
186
+
.driver = {
187
+
.name = "rk8xx-i2c",
188
+
.of_match_table = rk8xx_i2c_of_match,
189
+
.pm = &rk8xx_i2c_pm_ops,
190
+
},
191
+
.probe_new = rk8xx_i2c_probe,
192
+
.shutdown = rk8xx_i2c_shutdown,
193
+
};
194
+
module_i2c_driver(rk8xx_i2c_driver);
195
+
196
+
MODULE_LICENSE("GPL");
197
+
MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>");
198
+
MODULE_AUTHOR("Zhang Qing <zhangqing@rock-chips.com>");
199
+
MODULE_AUTHOR("Wadim Egorov <w.egorov@phytec.de>");
200
+
MODULE_DESCRIPTION("RK8xx I2C PMIC driver");
+1
-1
drivers/pinctrl/Kconfig
+1
-1
drivers/pinctrl/Kconfig
+1
-1
drivers/power/supply/Kconfig
+1
-1
drivers/power/supply/Kconfig
+1
-1
drivers/regulator/Kconfig
+1
-1
drivers/regulator/Kconfig
···
1056
1056
1057
1057
config REGULATOR_RK808
1058
1058
tristate "Rockchip RK805/RK808/RK809/RK817/RK818 Power regulators"
1059
-
depends on MFD_RK808
1059
+
depends on MFD_RK8XX
1060
1060
help
1061
1061
Select this option to enable the power regulator of ROCKCHIP
1062
1062
PMIC RK805,RK809&RK817,RK808 and RK818.
+1
-1
drivers/rtc/Kconfig
+1
-1
drivers/rtc/Kconfig
+6
include/linux/mfd/rk808.h
+6
include/linux/mfd/rk808.h
···
794
794
const struct regmap_config *regmap_cfg;
795
795
const struct regmap_irq_chip *regmap_irq_chip;
796
796
};
797
+
798
+
void rk8xx_shutdown(struct device *dev);
799
+
int rk8xx_probe(struct device *dev, int variant, unsigned int irq, struct regmap *regmap);
800
+
int rk8xx_suspend(struct device *dev);
801
+
int rk8xx_resume(struct device *dev);
802
+
797
803
#endif /* __LINUX_REGULATOR_RK808_H */