Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branches 'ib-mfd-clk-gpio-power-regulator-rtc-6.20', 'ib-mfd-regulator-6.20' and 'ib-mfd-rtc-6.20' into ibs-for-mfd-merged
+745
-66
+197
Documentation/devicetree/bindings/mfd/rockchip,rk801.yaml
+197
Documentation/devicetree/bindings/mfd/rockchip,rk801.yaml
···
1
+
# SPDX-License-Identifier: GPL-2.0-only OR BSD-2-Clause
2
+
%YAML 1.2
3
+
---
4
+
$id: http://devicetree.org/schemas/mfd/rockchip,rk801.yaml#
5
+
$schema: http://devicetree.org/meta-schemas/core.yaml#
6
+
7
+
title: RK801 Power Management Integrated Circuit
8
+
9
+
maintainers:
10
+
- Joseph Chen <chenjh@rock-chips.com>
11
+
12
+
description: |
13
+
Rockchip RK801 series PMIC. This device consists of an i2c controlled MFD
14
+
that includes multiple switchable regulators.
15
+
16
+
properties:
17
+
compatible:
18
+
enum:
19
+
- rockchip,rk801
20
+
21
+
reg:
22
+
maxItems: 1
23
+
24
+
interrupts:
25
+
maxItems: 1
26
+
27
+
system-power-controller:
28
+
type: boolean
29
+
description:
30
+
Telling whether or not this PMIC is controlling the system power.
31
+
32
+
wakeup-source:
33
+
type: boolean
34
+
description:
35
+
Device can be used as a wakeup source.
36
+
37
+
vcc1-supply:
38
+
description:
39
+
The input supply for dcdc1.
40
+
41
+
vcc2-supply:
42
+
description:
43
+
The input supply for dcdc2.
44
+
45
+
vcc3-supply:
46
+
description:
47
+
The input supply for dcdc3.
48
+
49
+
vcc4-supply:
50
+
description:
51
+
The input supply for dcdc4.
52
+
53
+
vcc5-supply:
54
+
description:
55
+
The input supply for ldo1.
56
+
57
+
vcc6-supply:
58
+
description:
59
+
The input supply for ldo2.
60
+
61
+
vcc7-supply:
62
+
description:
63
+
The input supply for switch.
64
+
65
+
regulators:
66
+
type: object
67
+
patternProperties:
68
+
"^(dcdc[1-4]|ldo[1-2]|switch)$":
69
+
type: object
70
+
$ref: /schemas/regulator/regulator.yaml#
71
+
unevaluatedProperties: false
72
+
additionalProperties: false
73
+
74
+
required:
75
+
- compatible
76
+
- reg
77
+
- interrupts
78
+
79
+
additionalProperties: false
80
+
81
+
examples:
82
+
- |
83
+
#include <dt-bindings/pinctrl/rockchip.h>
84
+
#include <dt-bindings/interrupt-controller/irq.h>
85
+
#include <dt-bindings/gpio/gpio.h>
86
+
87
+
i2c {
88
+
#address-cells = <1>;
89
+
#size-cells = <0>;
90
+
91
+
rk801: pmic@27 {
92
+
compatible = "rockchip,rk801";
93
+
reg = <0x27>;
94
+
interrupt-parent = <&gpio0>;
95
+
interrupts = <RK_PC0 IRQ_TYPE_LEVEL_LOW>;
96
+
pinctrl-names = "default";
97
+
pinctrl-0 = <&pmic_int_l>;
98
+
system-power-controller;
99
+
wakeup-source;
100
+
101
+
vcc1-supply = <&vcc_sys>;
102
+
vcc2-supply = <&vcc_sys>;
103
+
vcc3-supply = <&vcc_sys>;
104
+
vcc4-supply = <&vcc_sys>;
105
+
vcc5-supply = <&vcc3v3_sys>;
106
+
vcc6-supply = <&vcc3v3_sys>;
107
+
vcc7-supply = <&vcc3v3_sys>;
108
+
109
+
regulators {
110
+
vdd_cpu: dcdc1 {
111
+
regulator-name = "vdd_cpu";
112
+
regulator-min-microvolt = <500000>;
113
+
regulator-max-microvolt = <1500000>;
114
+
regulator-initial-mode = <0x1>;
115
+
regulator-boot-on;
116
+
regulator-always-on;
117
+
regulator-state-mem {
118
+
regulator-mode = <0x2>;
119
+
regulator-off-in-suspend;
120
+
regulator-suspend-microvolt = <950000>;
121
+
};
122
+
};
123
+
124
+
vcc3v3_sys: dcdc2 {
125
+
regulator-name = "vcc3v3_sys";
126
+
regulator-min-microvolt = <3300000>;
127
+
regulator-max-microvolt = <3300000>;
128
+
regulator-initial-mode = <0x1>;
129
+
regulator-boot-on;
130
+
regulator-always-on;
131
+
regulator-state-mem {
132
+
regulator-mode = <0x2>;
133
+
regulator-on-in-suspend;
134
+
regulator-suspend-microvolt = <3300000>;
135
+
};
136
+
};
137
+
138
+
vcc_ddr: dcdc3 {
139
+
regulator-name = "vcc_ddr";
140
+
regulator-boot-on;
141
+
regulator-always-on;
142
+
regulator-state-mem {
143
+
regulator-mode = <0x2>;
144
+
regulator-on-in-suspend;
145
+
};
146
+
};
147
+
148
+
vdd_logic: dcdc4 {
149
+
regulator-name = "vdd_logic";
150
+
regulator-min-microvolt = <500000>;
151
+
regulator-max-microvolt = <1500000>;
152
+
regulator-initial-mode = <0x1>;
153
+
regulator-boot-on;
154
+
regulator-always-on;
155
+
regulator-state-mem {
156
+
regulator-mode = <0x2>;
157
+
regulator-off-in-suspend;
158
+
regulator-suspend-microvolt = <900000>;
159
+
};
160
+
};
161
+
162
+
vdd0v9_sys: ldo1 {
163
+
regulator-name = "vdd0v9_sys";
164
+
regulator-min-microvolt = <900000>;
165
+
regulator-max-microvolt = <900000>;
166
+
regulator-boot-on;
167
+
regulator-always-on;
168
+
regulator-state-mem {
169
+
regulator-off-in-suspend;
170
+
regulator-suspend-microvolt = <900000>;
171
+
};
172
+
};
173
+
174
+
vcc_1v8: ldo2 {
175
+
regulator-name = "vcc_1v8";
176
+
regulator-min-microvolt = <1800000>;
177
+
regulator-max-microvolt = <1800000>;
178
+
regulator-boot-on;
179
+
regulator-always-on;
180
+
regulator-state-mem {
181
+
regulator-off-in-suspend;
182
+
regulator-suspend-microvolt = <1800000>;
183
+
};
184
+
};
185
+
186
+
vcc_3v3: switch {
187
+
regulator-name = "vcc_3v3";
188
+
regulator-boot-on;
189
+
regulator-always-on;
190
+
regulator-state-mem {
191
+
regulator-off-in-suspend;
192
+
regulator-suspend-microvolt = <3300000>;
193
+
};
194
+
};
195
+
};
196
+
};
197
+
};
+3
-3
drivers/mfd/Kconfig
+3
-3
drivers/mfd/Kconfig
···
1371
1371
select MFD_CORE
1372
1372
1373
1373
config MFD_RK8XX_I2C
1374
-
tristate "Rockchip RK805/RK808/RK809/RK816/RK817/RK818 Power Management Chip"
1374
+
tristate "Rockchip RK8xx Power Management Chips"
1375
1375
depends on I2C && OF
1376
1376
select MFD_CORE
1377
1377
select REGMAP_I2C
1378
1378
select REGMAP_IRQ
1379
1379
select MFD_RK8XX
1380
1380
help
1381
-
If you say yes here you get support for the RK805, RK808, RK809,
1382
-
RK816, RK817 and RK818 Power Management chips.
1381
+
If you say yes here you get support for the RK801, RK805, RK808,
1382
+
RK809, RK816, RK817 and RK818 Power Management chips.
1383
1383
This driver provides common support for accessing the device
1384
1384
through I2C interface. The device supports multiple sub-devices
1385
1385
including interrupts, RTC, LDO & DCDC regulators, and onkey.
+81
drivers/mfd/rk8xx-core.c
+81
drivers/mfd/rk8xx-core.c
···
37
37
DEFINE_RES_IRQ(RK817_IRQ_RTC_ALARM),
38
38
};
39
39
40
+
static const struct resource rk801_key_resources[] = {
41
+
DEFINE_RES_IRQ(RK801_IRQ_PWRON_FALL),
42
+
DEFINE_RES_IRQ(RK801_IRQ_PWRON_RISE),
43
+
};
44
+
40
45
static const struct resource rk805_key_resources[] = {
41
46
DEFINE_RES_IRQ(RK805_IRQ_PWRON_RISE),
42
47
DEFINE_RES_IRQ(RK805_IRQ_PWRON_FALL),
···
60
55
static const struct resource rk817_charger_resources[] = {
61
56
DEFINE_RES_IRQ(RK817_IRQ_PLUG_IN),
62
57
DEFINE_RES_IRQ(RK817_IRQ_PLUG_OUT),
58
+
};
59
+
60
+
static const struct mfd_cell rk801s[] = {
61
+
{ .name = "rk808-regulator", },
62
+
{ .name = "rk805-pwrkey",
63
+
.num_resources = ARRAY_SIZE(rk801_key_resources),
64
+
.resources = &rk801_key_resources[0],
65
+
},
63
66
};
64
67
65
68
static const struct mfd_cell rk805s[] = {
···
150
137
.num_resources = ARRAY_SIZE(rtc_resources),
151
138
.resources = rtc_resources,
152
139
},
140
+
};
141
+
142
+
static const struct rk808_reg_data rk801_pre_init_reg[] = {
143
+
{ RK801_SLEEP_CFG_REG, RK801_SLEEP_FUN_MSK, RK801_NONE_FUN },
144
+
{ RK801_SYS_CFG2_REG, RK801_RST_MSK, RK801_RST_RESTART_REG_RESETB },
145
+
{ RK801_INT_CONFIG_REG, RK801_INT_POL_MSK, RK801_INT_ACT_L },
146
+
{ RK801_POWER_FPWM_EN_REG, RK801_PLDO_HRDEC_EN, RK801_PLDO_HRDEC_EN },
147
+
{ RK801_BUCK_DEBUG5_REG, MASK_ALL, 0x54 },
148
+
{ RK801_CON_BACK1_REG, MASK_ALL, 0x18 },
153
149
};
154
150
155
151
static const struct rk808_reg_data rk805_pre_init_reg[] = {
···
304
282
{ RK818_H5V_EN_REG, BIT(0), RK818_H5V_EN },
305
283
{ RK808_VB_MON_REG, MASK_ALL, VB_LO_ACT |
306
284
VB_LO_SEL_3500MV },
285
+
};
286
+
287
+
static const struct regmap_irq rk801_irqs[] = {
288
+
[RK801_IRQ_PWRON_FALL] = {
289
+
.mask = RK801_IRQ_PWRON_FALL_MSK,
290
+
.reg_offset = 0,
291
+
},
292
+
[RK801_IRQ_PWRON_RISE] = {
293
+
.mask = RK801_IRQ_PWRON_RISE_MSK,
294
+
.reg_offset = 0,
295
+
},
296
+
[RK801_IRQ_PWRON] = {
297
+
.mask = RK801_IRQ_PWRON_MSK,
298
+
.reg_offset = 0,
299
+
},
300
+
[RK801_IRQ_PWRON_LP] = {
301
+
.mask = RK801_IRQ_PWRON_LP_MSK,
302
+
.reg_offset = 0,
303
+
},
304
+
[RK801_IRQ_HOTDIE] = {
305
+
.mask = RK801_IRQ_HOTDIE_MSK,
306
+
.reg_offset = 0,
307
+
},
308
+
[RK801_IRQ_VDC_RISE] = {
309
+
.mask = RK801_IRQ_VDC_RISE_MSK,
310
+
.reg_offset = 0,
311
+
},
312
+
[RK801_IRQ_VDC_FALL] = {
313
+
.mask = RK801_IRQ_VDC_FALL_MSK,
314
+
.reg_offset = 0,
315
+
},
307
316
};
308
317
309
318
static const struct regmap_irq rk805_irqs[] = {
···
585
532
REGMAP_IRQ_REG_LINE(23, 8)
586
533
};
587
534
535
+
static const struct regmap_irq_chip rk801_irq_chip = {
536
+
.name = "rk801",
537
+
.irqs = rk801_irqs,
538
+
.num_irqs = ARRAY_SIZE(rk801_irqs),
539
+
.num_regs = 1,
540
+
.status_base = RK801_INT_STS0_REG,
541
+
.mask_base = RK801_INT_MASK0_REG,
542
+
.ack_base = RK801_INT_STS0_REG,
543
+
.init_ack_masked = true,
544
+
};
545
+
588
546
static const struct regmap_irq_chip rk805_irq_chip = {
589
547
.name = "rk805",
590
548
.irqs = rk805_irqs,
···
674
610
unsigned int reg, bit;
675
611
676
612
switch (rk808->variant) {
613
+
case RK801_ID:
614
+
reg = RK801_SYS_CFG2_REG;
615
+
bit = DEV_OFF;
616
+
break;
677
617
case RK805_ID:
678
618
reg = RK805_DEV_CTRL_REG;
679
619
bit = DEV_OFF;
···
782
714
dev_set_drvdata(dev, rk808);
783
715
784
716
switch (rk808->variant) {
717
+
case RK801_ID:
718
+
rk808->regmap_irq_chip = &rk801_irq_chip;
719
+
pre_init_reg = rk801_pre_init_reg;
720
+
nr_pre_init_regs = ARRAY_SIZE(rk801_pre_init_reg);
721
+
cells = rk801s;
722
+
nr_cells = ARRAY_SIZE(rk801s);
723
+
break;
785
724
case RK805_ID:
786
725
rk808->regmap_irq_chip = &rk805_irq_chip;
787
726
pre_init_reg = rk805_pre_init_reg;
···
906
831
int ret = 0;
907
832
908
833
switch (rk808->variant) {
834
+
case RK801_ID:
835
+
ret = regmap_update_bits(rk808->regmap,
836
+
RK801_SLEEP_CFG_REG,
837
+
RK801_SLEEP_FUN_MSK,
838
+
RK801_SLEEP_FUN);
839
+
break;
909
840
case RK805_ID:
910
841
ret = regmap_update_bits(rk808->regmap,
911
842
RK805_GPIO_IO_POL_REG,
+32
-1
drivers/mfd/rk8xx-i2c.c
+32
-1
drivers/mfd/rk8xx-i2c.c
···
1
1
// SPDX-License-Identifier: GPL-2.0-only
2
2
/*
3
-
* Rockchip RK805/RK808/RK816/RK817/RK818 Core (I2C) driver
3
+
* Rockchip RK801/RK805/RK808/RK816/RK817/RK818 Core (I2C) driver
4
4
*
5
5
* Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd
6
6
* Copyright (C) 2016 PHYTEC Messtechnik GmbH
···
20
20
const struct regmap_config *regmap_cfg;
21
21
int variant;
22
22
};
23
+
24
+
static bool rk801_is_volatile_reg(struct device *dev, unsigned int reg)
25
+
{
26
+
switch (reg) {
27
+
case RK801_SYS_STS_REG:
28
+
case RK801_INT_STS0_REG:
29
+
case RK801_SYS_CFG0_REG:
30
+
case RK801_SYS_CFG1_REG:
31
+
case RK801_SYS_CFG2_REG:
32
+
case RK801_SYS_CFG3_REG:
33
+
case RK801_SYS_CFG4_REG:
34
+
case RK801_SLEEP_CFG_REG:
35
+
return true;
36
+
}
37
+
38
+
return false;
39
+
}
23
40
24
41
static bool rk806_is_volatile_reg(struct device *dev, unsigned int reg)
25
42
{
···
141
124
.volatile_reg = rk808_is_volatile_reg,
142
125
};
143
126
127
+
static const struct regmap_config rk801_regmap_config = {
128
+
.reg_bits = 8,
129
+
.val_bits = 8,
130
+
.max_register = RK801_SYS_CFG3_OTP_REG,
131
+
.cache_type = REGCACHE_RBTREE,
132
+
.volatile_reg = rk801_is_volatile_reg,
133
+
};
134
+
144
135
static const struct regmap_config rk805_regmap_config = {
145
136
.reg_bits = 8,
146
137
.val_bits = 8,
···
187
162
.max_register = RK817_GPIO_INT_CFG,
188
163
.cache_type = REGCACHE_NONE,
189
164
.volatile_reg = rk817_is_volatile_reg,
165
+
};
166
+
167
+
static const struct rk8xx_i2c_platform_data rk801_data = {
168
+
.regmap_cfg = &rk801_regmap_config,
169
+
.variant = RK801_ID,
190
170
};
191
171
192
172
static const struct rk8xx_i2c_platform_data rk805_data = {
···
254
224
static SIMPLE_DEV_PM_OPS(rk8xx_i2c_pm_ops, rk8xx_suspend, rk8xx_resume);
255
225
256
226
static const struct of_device_id rk8xx_i2c_of_match[] = {
227
+
{ .compatible = "rockchip,rk801", .data = &rk801_data },
257
228
{ .compatible = "rockchip,rk805", .data = &rk805_data },
258
229
{ .compatible = "rockchip,rk806", .data = &rk806_data },
259
230
{ .compatible = "rockchip,rk808", .data = &rk808_data },
+33
-12
drivers/mfd/sec-common.c
+33
-12
drivers/mfd/sec-common.c
···
23
23
#include <linux/regmap.h>
24
24
#include "sec-core.h"
25
25
26
+
static const struct resource s5m8767_rtc_resources[] = {
27
+
DEFINE_RES_IRQ_NAMED(S5M8767_IRQ_RTCA1, "alarm"),
28
+
};
29
+
26
30
static const struct mfd_cell s5m8767_devs[] = {
27
31
MFD_CELL_NAME("s5m8767-pmic"),
28
-
MFD_CELL_NAME("s5m-rtc"),
32
+
MFD_CELL_RES("s5m-rtc", s5m8767_rtc_resources),
29
33
MFD_CELL_OF("s5m8767-clk", NULL, NULL, 0, 0, "samsung,s5m8767-clk"),
30
34
};
31
35
···
37
33
MFD_CELL_NAME("s2dos05-regulator"),
38
34
};
39
35
36
+
static const struct resource s2mpg10_rtc_resources[] = {
37
+
DEFINE_RES_IRQ_NAMED(S2MPG10_IRQ_RTCA0, "alarm"),
38
+
};
39
+
40
40
static const struct mfd_cell s2mpg10_devs[] = {
41
41
MFD_CELL_NAME("s2mpg10-meter"),
42
42
MFD_CELL_NAME("s2mpg10-regulator"),
43
-
MFD_CELL_NAME("s2mpg10-rtc"),
43
+
MFD_CELL_RES("s2mpg10-rtc", s2mpg10_rtc_resources),
44
44
MFD_CELL_OF("s2mpg10-clk", NULL, NULL, 0, 0, "samsung,s2mpg10-clk"),
45
45
MFD_CELL_OF("s2mpg10-gpio", NULL, NULL, 0, 0, "samsung,s2mpg10-gpio"),
46
46
};
47
47
48
+
static const struct resource s2mps11_rtc_resources[] = {
49
+
DEFINE_RES_IRQ_NAMED(S2MPS11_IRQ_RTCA0, "alarm"),
50
+
};
51
+
48
52
static const struct mfd_cell s2mps11_devs[] = {
49
53
MFD_CELL_NAME("s2mps11-regulator"),
50
-
MFD_CELL_NAME("s2mps14-rtc"),
54
+
MFD_CELL_RES("s2mps14-rtc", s2mps11_rtc_resources),
51
55
MFD_CELL_OF("s2mps11-clk", NULL, NULL, 0, 0, "samsung,s2mps11-clk"),
56
+
};
57
+
58
+
static const struct resource s2mps14_rtc_resources[] = {
59
+
DEFINE_RES_IRQ_NAMED(S2MPS14_IRQ_RTCA0, "alarm"),
52
60
};
53
61
54
62
static const struct mfd_cell s2mps13_devs[] = {
55
63
MFD_CELL_NAME("s2mps13-regulator"),
56
-
MFD_CELL_NAME("s2mps13-rtc"),
64
+
MFD_CELL_RES("s2mps13-rtc", s2mps14_rtc_resources),
57
65
MFD_CELL_OF("s2mps13-clk", NULL, NULL, 0, 0, "samsung,s2mps13-clk"),
58
66
};
59
67
60
68
static const struct mfd_cell s2mps14_devs[] = {
61
69
MFD_CELL_NAME("s2mps14-regulator"),
62
-
MFD_CELL_NAME("s2mps14-rtc"),
70
+
MFD_CELL_RES("s2mps14-rtc", s2mps14_rtc_resources),
63
71
MFD_CELL_OF("s2mps14-clk", NULL, NULL, 0, 0, "samsung,s2mps14-clk"),
64
72
};
65
73
66
74
static const struct mfd_cell s2mps15_devs[] = {
67
75
MFD_CELL_NAME("s2mps15-regulator"),
68
-
MFD_CELL_NAME("s2mps15-rtc"),
76
+
MFD_CELL_RES("s2mps15-rtc", s2mps14_rtc_resources),
69
77
MFD_CELL_OF("s2mps13-clk", NULL, NULL, 0, 0, "samsung,s2mps13-clk"),
70
78
};
71
79
72
80
static const struct mfd_cell s2mpa01_devs[] = {
73
81
MFD_CELL_NAME("s2mpa01-pmic"),
74
-
MFD_CELL_NAME("s2mps14-rtc"),
82
+
MFD_CELL_RES("s2mps14-rtc", s2mps14_rtc_resources),
75
83
};
76
84
77
85
static const struct mfd_cell s2mpu02_devs[] = {
78
86
MFD_CELL_NAME("s2mpu02-regulator"),
79
87
};
80
88
89
+
static const struct resource s2mpu05_rtc_resources[] = {
90
+
DEFINE_RES_IRQ_NAMED(S2MPU05_IRQ_RTCA0, "alarm"),
91
+
};
92
+
81
93
static const struct mfd_cell s2mpu05_devs[] = {
82
94
MFD_CELL_NAME("s2mpu05-regulator"),
83
-
MFD_CELL_NAME("s2mps15-rtc"),
95
+
MFD_CELL_RES("s2mps15-rtc", s2mpu05_rtc_resources),
84
96
};
85
97
86
98
static void sec_pmic_dump_rev(struct sec_pmic_dev *sec_pmic)
···
163
143
int sec_pmic_probe(struct device *dev, int device_type, unsigned int irq,
164
144
struct regmap *regmap, struct i2c_client *client)
165
145
{
146
+
struct regmap_irq_chip_data *irq_data;
166
147
struct sec_platform_data *pdata;
167
148
const struct mfd_cell *sec_devs;
168
149
struct sec_pmic_dev *sec_pmic;
···
188
167
189
168
sec_pmic->pdata = pdata;
190
169
191
-
ret = sec_irq_init(sec_pmic);
192
-
if (ret)
193
-
return ret;
170
+
irq_data = sec_irq_init(sec_pmic);
171
+
if (IS_ERR(irq_data))
172
+
return PTR_ERR(irq_data);
194
173
195
174
pm_runtime_set_active(sec_pmic->dev);
196
175
···
241
220
sec_pmic->device_type);
242
221
}
243
222
ret = devm_mfd_add_devices(sec_pmic->dev, -1, sec_devs, num_sec_devs,
244
-
NULL, 0, NULL);
223
+
NULL, 0, regmap_irq_get_domain(irq_data));
245
224
if (ret)
246
225
return ret;
247
226
+1
-1
drivers/mfd/sec-core.h
+1
-1
drivers/mfd/sec-core.h
+29
-35
drivers/mfd/sec-irq.c
+29
-35
drivers/mfd/sec-irq.c
···
268
268
.ack_base = S5M8767_REG_INT1,
269
269
};
270
270
271
-
static int s2mpg1x_add_chained_irq_chip(struct device *dev, struct regmap *regmap, int pirq,
272
-
struct regmap_irq_chip_data *parent,
273
-
const struct regmap_irq_chip *chip,
274
-
struct regmap_irq_chip_data **data)
271
+
static struct regmap_irq_chip_data *
272
+
s2mpg1x_add_chained_pmic(struct sec_pmic_dev *sec_pmic, int pirq,
273
+
struct regmap_irq_chip_data *parent, const struct regmap_irq_chip *chip)
275
274
{
275
+
struct device *dev = sec_pmic->dev;
276
+
struct regmap_irq_chip_data *data;
276
277
int irq, ret;
277
278
278
279
irq = regmap_irq_get_virq(parent, pirq);
279
280
if (irq < 0)
280
-
return dev_err_probe(dev, irq, "Failed to get parent vIRQ(%d) for chip %s\n", pirq,
281
-
chip->name);
281
+
return dev_err_ptr_probe(dev, irq, "Failed to get parent vIRQ(%d) for chip %s\n",
282
+
pirq, chip->name);
282
283
283
-
ret = devm_regmap_add_irq_chip(dev, regmap, irq, IRQF_ONESHOT | IRQF_SHARED, 0, chip, data);
284
+
ret = devm_regmap_add_irq_chip(dev, sec_pmic->regmap_pmic, irq,
285
+
IRQF_ONESHOT | IRQF_SHARED, 0, chip, &data);
284
286
if (ret)
285
-
return dev_err_probe(dev, ret, "Failed to add %s IRQ chip\n", chip->name);
287
+
return dev_err_ptr_probe(dev, ret, "Failed to add %s IRQ chip\n", chip->name);
286
288
287
-
return 0;
289
+
return data;
288
290
}
289
291
290
-
static int sec_irq_init_s2mpg1x(struct sec_pmic_dev *sec_pmic)
292
+
static struct regmap_irq_chip_data *sec_irq_init_s2mpg1x(struct sec_pmic_dev *sec_pmic)
291
293
{
292
294
const struct regmap_irq_chip *irq_chip, *chained_irq_chip;
293
295
struct regmap_irq_chip_data *irq_data;
···
304
302
chained_pirq = S2MPG10_COMMON_IRQ_PMIC;
305
303
break;
306
304
default:
307
-
return dev_err_probe(sec_pmic->dev, -EINVAL, "Unsupported device type %d\n",
308
-
sec_pmic->device_type);
305
+
return dev_err_ptr_probe(sec_pmic->dev, -EINVAL, "Unsupported device type %d\n",
306
+
sec_pmic->device_type);
309
307
}
310
308
311
309
regmap_common = dev_get_regmap(sec_pmic->dev, "common");
312
310
if (!regmap_common)
313
-
return dev_err_probe(sec_pmic->dev, -EINVAL, "No 'common' regmap %d\n",
314
-
sec_pmic->device_type);
311
+
return dev_err_ptr_probe(sec_pmic->dev, -EINVAL, "No 'common' regmap %d\n",
312
+
sec_pmic->device_type);
315
313
316
314
ret = devm_regmap_add_irq_chip(sec_pmic->dev, regmap_common, sec_pmic->irq, IRQF_ONESHOT, 0,
317
315
irq_chip, &irq_data);
318
316
if (ret)
319
-
return dev_err_probe(sec_pmic->dev, ret, "Failed to add %s IRQ chip\n",
320
-
irq_chip->name);
317
+
return dev_err_ptr_probe(sec_pmic->dev, ret, "Failed to add %s IRQ chip\n",
318
+
irq_chip->name);
321
319
322
-
return s2mpg1x_add_chained_irq_chip(sec_pmic->dev, sec_pmic->regmap_pmic, chained_pirq,
323
-
irq_data, chained_irq_chip, &sec_pmic->irq_data);
320
+
return s2mpg1x_add_chained_pmic(sec_pmic, chained_pirq, irq_data, chained_irq_chip);
324
321
}
325
322
326
-
int sec_irq_init(struct sec_pmic_dev *sec_pmic)
323
+
struct regmap_irq_chip_data *sec_irq_init(struct sec_pmic_dev *sec_pmic)
327
324
{
325
+
struct regmap_irq_chip_data *sec_irq_chip_data;
328
326
const struct regmap_irq_chip *sec_irq_chip;
329
327
int ret;
330
328
···
333
331
sec_irq_chip = &s5m8767_irq_chip;
334
332
break;
335
333
case S2DOS05:
336
-
return 0;
334
+
return NULL;
337
335
case S2MPA01:
338
336
sec_irq_chip = &s2mps14_irq_chip;
339
337
break;
···
358
356
sec_irq_chip = &s2mpu05_irq_chip;
359
357
break;
360
358
default:
361
-
return dev_err_probe(sec_pmic->dev, -EINVAL,
362
-
"Unsupported device type %d\n",
363
-
sec_pmic->device_type);
359
+
return dev_err_ptr_probe(sec_pmic->dev, -EINVAL, "Unsupported device type %d\n",
360
+
sec_pmic->device_type);
364
361
}
365
362
366
363
if (!sec_pmic->irq) {
367
364
dev_warn(sec_pmic->dev,
368
365
"No interrupt specified, no interrupts\n");
369
-
return 0;
366
+
return NULL;
370
367
}
371
368
372
369
ret = devm_regmap_add_irq_chip(sec_pmic->dev, sec_pmic->regmap_pmic,
373
370
sec_pmic->irq, IRQF_ONESHOT,
374
-
0, sec_irq_chip, &sec_pmic->irq_data);
371
+
0, sec_irq_chip, &sec_irq_chip_data);
375
372
if (ret)
376
-
return dev_err_probe(sec_pmic->dev, ret,
377
-
"Failed to add %s IRQ chip\n",
378
-
sec_irq_chip->name);
373
+
return dev_err_ptr_probe(sec_pmic->dev, ret, "Failed to add %s IRQ chip\n",
374
+
sec_irq_chip->name);
379
375
380
-
/*
381
-
* The rtc-s5m driver requests S2MPS14_IRQ_RTCA0 also for S2MPS11
382
-
* so the interrupt number must be consistent.
383
-
*/
384
-
BUILD_BUG_ON(((enum s2mps14_irq)S2MPS11_IRQ_RTCA0) != S2MPS14_IRQ_RTCA0);
385
-
386
-
return 0;
376
+
return sec_irq_chip_data;
387
377
}
+243
drivers/regulator/rk808-regulator.c
+243
drivers/regulator/rk808-regulator.c
···
24
24
#include <linux/gpio/consumer.h>
25
25
26
26
/* Field definitions */
27
+
#define RK801_BUCK_VSEL_MASK 0x7f
28
+
#define RK801_LDO_VSEL_MASK 0x3f
29
+
27
30
#define RK808_BUCK_VSEL_MASK 0x3f
28
31
#define RK808_BUCK4_VSEL_MASK 0xf
29
32
#define RK808_LDO_VSEL_MASK 0x1f
···
161
158
RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \
162
159
_vmask, _ereg, _emask, 0, 0, _etime, &rk808_reg_ops)
163
160
161
+
#define RK801_DESC(_id, _match, _supply, _min, _max, _step, _vreg, \
162
+
_vmask, _ereg, _emask, _disval, _etime) \
163
+
RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \
164
+
_vmask, _ereg, _emask, _emask, _disval, _etime, &rk801_reg_ops)
165
+
164
166
#define RK816_DESC(_id, _match, _supply, _min, _max, _step, _vreg, \
165
167
_vmask, _ereg, _emask, _disval, _etime) \
166
168
RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \
···
192
184
.owner = THIS_MODULE, \
193
185
.ops = _ops \
194
186
}
187
+
188
+
#define RK801_DESC_SWITCH(_id, _match, _supply, _ereg, _emask, \
189
+
_disval) \
190
+
RKXX_DESC_SWITCH_COM(_id, _match, _supply, _ereg, _emask, \
191
+
_emask, _disval, &rk801_switch_ops)
195
192
196
193
#define RK817_DESC_SWITCH(_id, _match, _supply, _ereg, _emask, \
197
194
_disval) \
···
815
802
}
816
803
}
817
804
805
+
static unsigned int rk801_get_mode(struct regulator_dev *rdev)
806
+
{
807
+
unsigned int val;
808
+
int err;
809
+
810
+
err = regmap_read(rdev->regmap, RK801_POWER_FPWM_EN_REG, &val);
811
+
if (err)
812
+
return err;
813
+
814
+
if (val & BIT(rdev->desc->id))
815
+
return REGULATOR_MODE_FAST;
816
+
else
817
+
return REGULATOR_MODE_NORMAL;
818
+
}
819
+
820
+
static int rk801_set_mode(struct regulator_dev *rdev, unsigned int mode)
821
+
{
822
+
unsigned int offset = rdev->desc->id;
823
+
824
+
switch (mode) {
825
+
case REGULATOR_MODE_FAST:
826
+
return regmap_update_bits(rdev->regmap, RK801_POWER_FPWM_EN_REG,
827
+
BIT(offset), RK801_FPWM_MODE << offset);
828
+
case REGULATOR_MODE_NORMAL:
829
+
return regmap_update_bits(rdev->regmap, RK801_POWER_FPWM_EN_REG,
830
+
BIT(offset), RK801_AUTO_PWM_MODE << offset);
831
+
default:
832
+
dev_err(&rdev->dev, "do not support this mode\n");
833
+
return -EINVAL;
834
+
}
835
+
836
+
return 0;
837
+
}
838
+
839
+
static int rk801_set_suspend_voltage(struct regulator_dev *rdev, int uv)
840
+
{
841
+
unsigned int reg;
842
+
int sel;
843
+
844
+
if (rdev->desc->id < RK801_ID_LDO1)
845
+
sel = regulator_map_voltage_linear_range(rdev, uv, uv);
846
+
else
847
+
sel = regulator_map_voltage_linear(rdev, uv, uv);
848
+
if (sel < 0)
849
+
return -EINVAL;
850
+
851
+
reg = rdev->desc->vsel_reg + RK801_SLP_REG_OFFSET;
852
+
853
+
return regmap_update_bits(rdev->regmap, reg,
854
+
rdev->desc->vsel_mask, sel);
855
+
}
856
+
857
+
static int rk801_set_suspend_enable(struct regulator_dev *rdev)
858
+
{
859
+
return regmap_update_bits(rdev->regmap, RK801_POWER_SLP_EN_REG,
860
+
BIT(rdev->desc->id), BIT(rdev->desc->id));
861
+
}
862
+
863
+
static int rk801_set_suspend_disable(struct regulator_dev *rdev)
864
+
{
865
+
return regmap_update_bits(rdev->regmap, RK801_POWER_SLP_EN_REG,
866
+
BIT(rdev->desc->id), 0);
867
+
}
868
+
869
+
static int rk801_set_voltage_time_sel(struct regulator_dev *rdev,
870
+
unsigned int old_selector,
871
+
unsigned int new_selector)
872
+
{
873
+
return regulator_set_voltage_time_sel(rdev, old_selector,
874
+
new_selector) + RK801_HW_SYNC_US;
875
+
}
876
+
877
+
static const struct regulator_ops rk801_buck_ops = {
878
+
.list_voltage = regulator_list_voltage_linear_range,
879
+
.map_voltage = regulator_map_voltage_linear_range,
880
+
.get_voltage_sel = regulator_get_voltage_sel_regmap,
881
+
.set_voltage_sel = regulator_set_voltage_sel_regmap,
882
+
.set_voltage_time_sel = rk801_set_voltage_time_sel,
883
+
.enable = regulator_enable_regmap,
884
+
.disable = regulator_disable_regmap,
885
+
.is_enabled = regulator_is_enabled_regmap,
886
+
.set_mode = rk801_set_mode,
887
+
.get_mode = rk801_get_mode,
888
+
.set_suspend_voltage = rk801_set_suspend_voltage,
889
+
.set_suspend_enable = rk801_set_suspend_enable,
890
+
.set_suspend_disable = rk801_set_suspend_disable,
891
+
};
892
+
893
+
static const struct regulator_ops rk801_reg_ops = {
894
+
.list_voltage = regulator_list_voltage_linear,
895
+
.map_voltage = regulator_map_voltage_linear,
896
+
.get_voltage_sel = regulator_get_voltage_sel_regmap,
897
+
.set_voltage_sel = regulator_set_voltage_sel_regmap,
898
+
.enable = regulator_enable_regmap,
899
+
.disable = regulator_disable_regmap,
900
+
.is_enabled = regulator_is_enabled_regmap,
901
+
.set_suspend_voltage = rk801_set_suspend_voltage,
902
+
.set_suspend_enable = rk801_set_suspend_enable,
903
+
.set_suspend_disable = rk801_set_suspend_disable,
904
+
};
905
+
906
+
static const struct regulator_ops rk801_switch_ops = {
907
+
.enable = regulator_enable_regmap,
908
+
.disable = regulator_disable_regmap,
909
+
.is_enabled = regulator_is_enabled_regmap,
910
+
.set_suspend_enable = rk801_set_suspend_enable,
911
+
.set_suspend_disable = rk801_set_suspend_disable,
912
+
};
913
+
818
914
static const struct regulator_ops rk805_reg_ops = {
819
915
.list_voltage = regulator_list_voltage_linear,
820
916
.map_voltage = regulator_map_voltage_linear,
···
1169
1047
.is_enabled = rk8xx_is_enabled_wmsk_regmap,
1170
1048
.set_suspend_enable = rk817_set_suspend_enable,
1171
1049
.set_suspend_disable = rk817_set_suspend_disable,
1050
+
};
1051
+
1052
+
static const struct linear_range rk801_buck1_voltage_ranges[] = {
1053
+
REGULATOR_LINEAR_RANGE(500000, 0, 80, 12500), /* 0.5v - 1.5v */
1054
+
REGULATOR_LINEAR_RANGE(1800000, 81, 82, 400000),/* 1.8v - 2.2v */
1055
+
REGULATOR_LINEAR_RANGE(3300000, 83, 83, 0), /* 3.3v */
1056
+
REGULATOR_LINEAR_RANGE(5000000, 84, 84, 0), /* 5.0v */
1057
+
REGULATOR_LINEAR_RANGE(5250000, 85, 85, 0), /* 5.25v */
1058
+
};
1059
+
1060
+
static const struct linear_range rk801_buck2_voltage_ranges[] = {
1061
+
REGULATOR_LINEAR_RANGE(800000, 0, 2, 50000), /* 0.8v - 0.9v */
1062
+
REGULATOR_LINEAR_RANGE(1800000, 3, 4, 400000), /* 1.8v - 2.2v */
1063
+
REGULATOR_LINEAR_RANGE(3300000, 5, 5, 0), /* 3.3v */
1064
+
REGULATOR_LINEAR_RANGE(5000000, 6, 6, 0), /* 5.0v */
1065
+
REGULATOR_LINEAR_RANGE(5250000, 7, 7, 0), /* 5.25v */
1066
+
};
1067
+
1068
+
static const struct linear_range rk801_buck4_voltage_ranges[] = {
1069
+
REGULATOR_LINEAR_RANGE(500000, 0, 80, 12500), /* 0.5v - 1.5v */
1070
+
REGULATOR_LINEAR_RANGE(1800000, 81, 82, 400000),/* 1.8v - 2.2v */
1071
+
REGULATOR_LINEAR_RANGE(2500000, 83, 83, 0), /* 2.5v */
1072
+
REGULATOR_LINEAR_RANGE(2800000, 84, 84, 0), /* 2.8v */
1073
+
REGULATOR_LINEAR_RANGE(3000000, 85, 85, 0), /* 3.0v */
1074
+
REGULATOR_LINEAR_RANGE(3300000, 86, 86, 0), /* 3.3v */
1075
+
};
1076
+
1077
+
static const struct regulator_desc rk801_reg[] = {
1078
+
{
1079
+
.name = "dcdc1",
1080
+
.supply_name = "vcc1",
1081
+
.of_match = of_match_ptr("dcdc1"),
1082
+
.regulators_node = of_match_ptr("regulators"),
1083
+
.id = RK801_ID_DCDC1,
1084
+
.ops = &rk801_buck_ops,
1085
+
.type = REGULATOR_VOLTAGE,
1086
+
.n_voltages = 86,
1087
+
.linear_ranges = rk801_buck1_voltage_ranges,
1088
+
.n_linear_ranges = ARRAY_SIZE(rk801_buck1_voltage_ranges),
1089
+
.vsel_reg = RK801_BUCK1_ON_VSEL_REG,
1090
+
.vsel_mask = RK801_BUCK_VSEL_MASK,
1091
+
.enable_reg = RK801_POWER_EN0_REG,
1092
+
.enable_mask = ENABLE_MASK(RK801_ID_DCDC1),
1093
+
.enable_val = ENABLE_MASK(RK801_ID_DCDC1),
1094
+
.disable_val = DISABLE_VAL(RK801_ID_DCDC1),
1095
+
.ramp_delay = 1000,
1096
+
.of_map_mode = rk8xx_regulator_of_map_mode,
1097
+
.enable_time = 400,
1098
+
.owner = THIS_MODULE,
1099
+
}, {
1100
+
.name = "dcdc2",
1101
+
.supply_name = "vcc2",
1102
+
.of_match = of_match_ptr("dcdc2"),
1103
+
.regulators_node = of_match_ptr("regulators"),
1104
+
.id = RK801_ID_DCDC2,
1105
+
.ops = &rk801_buck_ops,
1106
+
.type = REGULATOR_VOLTAGE,
1107
+
.n_voltages = 8,
1108
+
.linear_ranges = rk801_buck2_voltage_ranges,
1109
+
.n_linear_ranges = ARRAY_SIZE(rk801_buck2_voltage_ranges),
1110
+
.vsel_reg = RK801_BUCK2_ON_VSEL_REG,
1111
+
.vsel_mask = RK801_BUCK_VSEL_MASK,
1112
+
.enable_reg = RK801_POWER_EN0_REG,
1113
+
.enable_mask = ENABLE_MASK(RK801_ID_DCDC2),
1114
+
.enable_val = ENABLE_MASK(RK801_ID_DCDC2),
1115
+
.disable_val = DISABLE_VAL(RK801_ID_DCDC2),
1116
+
.ramp_delay = 1000,
1117
+
.of_map_mode = rk8xx_regulator_of_map_mode,
1118
+
.enable_time = 400,
1119
+
.owner = THIS_MODULE,
1120
+
}, {
1121
+
.name = "dcdc3",
1122
+
.supply_name = "vcc3",
1123
+
.of_match = of_match_ptr("dcdc3"),
1124
+
.regulators_node = of_match_ptr("regulators"),
1125
+
.id = RK801_ID_DCDC3,
1126
+
.ops = &rk801_switch_ops,
1127
+
.type = REGULATOR_VOLTAGE,
1128
+
.n_voltages = 1,
1129
+
.enable_reg = RK801_POWER_EN0_REG,
1130
+
.enable_mask = ENABLE_MASK(RK801_ID_DCDC3),
1131
+
.enable_val = ENABLE_MASK(RK801_ID_DCDC3),
1132
+
.disable_val = DISABLE_VAL(RK801_ID_DCDC3),
1133
+
.of_map_mode = rk8xx_regulator_of_map_mode,
1134
+
.enable_time = 400,
1135
+
.owner = THIS_MODULE,
1136
+
}, {
1137
+
.name = "dcdc4",
1138
+
.supply_name = "vcc4",
1139
+
.of_match = of_match_ptr("dcdc4"),
1140
+
.regulators_node = of_match_ptr("regulators"),
1141
+
.id = RK801_ID_DCDC4,
1142
+
.ops = &rk801_buck_ops,
1143
+
.type = REGULATOR_VOLTAGE,
1144
+
.n_voltages = 87,
1145
+
.linear_ranges = rk801_buck4_voltage_ranges,
1146
+
.n_linear_ranges = ARRAY_SIZE(rk801_buck4_voltage_ranges),
1147
+
.vsel_reg = RK801_BUCK4_ON_VSEL_REG,
1148
+
.vsel_mask = RK801_BUCK_VSEL_MASK,
1149
+
.enable_reg = RK801_POWER_EN0_REG,
1150
+
.enable_mask = ENABLE_MASK(RK801_ID_DCDC4),
1151
+
.enable_val = ENABLE_MASK(RK801_ID_DCDC4),
1152
+
.disable_val = DISABLE_VAL(RK801_ID_DCDC4),
1153
+
.ramp_delay = 1000,
1154
+
.of_map_mode = rk8xx_regulator_of_map_mode,
1155
+
.enable_time = 400,
1156
+
.owner = THIS_MODULE,
1157
+
},
1158
+
1159
+
RK801_DESC(RK801_ID_LDO1, "ldo1", "vcc5", 500, 3400, 50,
1160
+
RK801_LDO1_ON_VSEL_REG, RK801_LDO_VSEL_MASK, RK801_POWER_EN1_REG,
1161
+
ENABLE_MASK(0), DISABLE_VAL(0), 400),
1162
+
RK801_DESC(RK801_ID_LDO2, "ldo2", "vcc6", 500, 3400, 50,
1163
+
RK801_LDO2_ON_VSEL_REG, RK801_LDO_VSEL_MASK, RK801_POWER_EN1_REG,
1164
+
ENABLE_MASK(1), DISABLE_VAL(1), 400),
1165
+
RK801_DESC_SWITCH(RK801_ID_SWITCH, "switch", "vcc7", RK801_POWER_EN1_REG,
1166
+
ENABLE_MASK(2), DISABLE_VAL(2)),
1172
1167
};
1173
1168
1174
1169
static const struct regulator_desc rk805_reg[] = {
···
2126
1887
return -ENOMEM;
2127
1888
2128
1889
switch (rk808->variant) {
1890
+
case RK801_ID:
1891
+
regulators = rk801_reg;
1892
+
nregulators = RK801_NUM_REGULATORS;
1893
+
break;
2129
1894
case RK805_ID:
2130
1895
regulators = rk805_reg;
2131
1896
nregulators = RK805_NUM_REGULATORS;
+8
-13
drivers/rtc/rtc-s5m.c
+8
-13
drivers/rtc/rtc-s5m.c
···
15
15
#include <linux/rtc.h>
16
16
#include <linux/platform_device.h>
17
17
#include <linux/mfd/samsung/core.h>
18
-
#include <linux/mfd/samsung/irq.h>
19
18
#include <linux/mfd/samsung/rtc.h>
20
19
#include <linux/mfd/samsung/s2mps14.h>
21
20
···
682
683
case S2MPS15X:
683
684
regmap_cfg = &s2mps14_rtc_regmap_config;
684
685
info->regs = &s2mps15_rtc_regs;
685
-
alarm_irq = S2MPS14_IRQ_RTCA0;
686
686
break;
687
687
case S2MPS14X:
688
688
regmap_cfg = &s2mps14_rtc_regmap_config;
689
689
info->regs = &s2mps14_rtc_regs;
690
-
alarm_irq = S2MPS14_IRQ_RTCA0;
691
690
break;
692
691
case S2MPS13X:
693
692
regmap_cfg = &s2mps14_rtc_regmap_config;
694
693
info->regs = &s2mps13_rtc_regs;
695
-
alarm_irq = S2MPS14_IRQ_RTCA0;
696
694
break;
697
695
case S5M8767X:
698
696
regmap_cfg = &s5m_rtc_regmap_config;
699
697
info->regs = &s5m_rtc_regs;
700
-
alarm_irq = S5M8767_IRQ_RTCA1;
701
698
break;
702
699
default:
703
700
return dev_err_probe(&pdev->dev, -ENODEV,
···
714
719
"Failed to allocate regmap\n");
715
720
} else if (device_type == S2MPG10) {
716
721
info->regs = &s2mpg10_rtc_regs;
717
-
alarm_irq = S2MPG10_IRQ_RTCA0;
718
722
} else {
719
723
return dev_err_probe(&pdev->dev, -ENODEV,
720
724
"Unsupported device type %d\n",
···
724
730
info->s5m87xx = s5m87xx;
725
731
info->device_type = device_type;
726
732
727
-
if (s5m87xx->irq_data) {
728
-
info->irq = regmap_irq_get_virq(s5m87xx->irq_data, alarm_irq);
729
-
if (info->irq <= 0)
730
-
return dev_err_probe(&pdev->dev, -EINVAL,
731
-
"Failed to get virtual IRQ %d\n",
732
-
alarm_irq);
733
-
}
733
+
alarm_irq = platform_get_irq_byname_optional(pdev, "alarm");
734
+
if (alarm_irq > 0)
735
+
info->irq = alarm_irq;
736
+
else if (alarm_irq == -ENXIO)
737
+
info->irq = 0;
738
+
else
739
+
return dev_err_probe(&pdev->dev, alarm_irq ? : -EINVAL,
740
+
"IRQ 'alarm' not found\n");
734
741
735
742
platform_set_drvdata(pdev, info);
736
743
+118
include/linux/mfd/rk808.h
+118
include/linux/mfd/rk808.h
···
340
340
#define RK818_USB_ILMIN_2000MA 0x7
341
341
#define RK818_USB_CHG_SD_VSEL_MASK 0x70
342
342
343
+
/* RK801 */
344
+
enum rk801_reg {
345
+
RK801_ID_DCDC1,
346
+
RK801_ID_DCDC2,
347
+
RK801_ID_DCDC4,
348
+
RK801_ID_DCDC3,
349
+
RK801_ID_LDO1,
350
+
RK801_ID_LDO2,
351
+
RK801_ID_SWITCH,
352
+
RK801_ID_MAX,
353
+
};
354
+
355
+
#define RK801_SLP_REG_OFFSET 5
356
+
#define RK801_NUM_REGULATORS 7
357
+
358
+
#define RK801_HW_SYNC_US 32
359
+
360
+
/* RK801 Register Definitions */
361
+
#define RK801_ID_MSB 0x00
362
+
#define RK801_ID_LSB 0x01
363
+
#define RK801_OTP_VER_REG 0x02
364
+
#define RK801_POWER_EN0_REG 0x03
365
+
#define RK801_POWER_EN1_REG 0x04
366
+
#define RK801_POWER_SLP_EN_REG 0x05
367
+
#define RK801_POWER_FPWM_EN_REG 0x06
368
+
#define RK801_SLP_LP_CONFIG_REG 0x07
369
+
#define RK801_BUCK_CONFIG_REG 0x08
370
+
#define RK801_BUCK1_ON_VSEL_REG 0x09
371
+
#define RK801_BUCK2_ON_VSEL_REG 0x0a
372
+
#define RK801_BUCK4_ON_VSEL_REG 0x0b
373
+
#define RK801_LDO1_ON_VSEL_REG 0x0c
374
+
#define RK801_LDO2_ON_VSEL_REG 0x0d
375
+
#define RK801_BUCK1_SLP_VSEL_REG 0x0e
376
+
#define RK801_BUCK2_SLP_VSEL_REG 0x0f
377
+
#define RK801_BUCK4_SLP_VSEL_REG 0x10
378
+
#define RK801_LDO1_SLP_VSEL_REG 0x11
379
+
#define RK801_LDO2_SLP_VSEL_REG 0x12
380
+
#define RK801_LDO_SW_IMAX_REG 0x13
381
+
#define RK801_SYS_STS_REG 0x14
382
+
#define RK801_SYS_CFG0_REG 0x15
383
+
#define RK801_SYS_CFG1_REG 0x16
384
+
#define RK801_SYS_CFG2_REG 0x17
385
+
#define RK801_SYS_CFG3_REG 0x18
386
+
#define RK801_SYS_CFG4_REG 0x19
387
+
#define RK801_SLEEP_CFG_REG 0x1a
388
+
#define RK801_ON_SOURCE_REG 0x1b
389
+
#define RK801_OFF_SOURCE_REG 0x1c
390
+
#define RK801_PWRON_KEY_REG 0x1d
391
+
#define RK801_INT_STS0_REG 0x1e
392
+
#define RK801_INT_MASK0_REG 0x1f
393
+
#define RK801_INT_CONFIG_REG 0x20
394
+
#define RK801_CON_BACK1_REG 0x21
395
+
#define RK801_CON_BACK2_REG 0x22
396
+
#define RK801_DATA_CON0_REG 0x23
397
+
#define RK801_DATA_CON1_REG 0x24
398
+
#define RK801_DATA_CON2_REG 0x25
399
+
#define RK801_DATA_CON3_REG 0x26
400
+
#define RK801_POWER_EXIT_SLP_SEQ0_REG 0x27
401
+
#define RK801_POWER_EXIT_SLP_SEQ1_REG 0x28
402
+
#define RK801_POWER_EXIT_SLP_SEQ2_REG 0x29
403
+
#define RK801_POWER_EXIT_SLP_SEQ3_REG 0x2a
404
+
#define RK801_POWER_ENTER_SLP_OR_SHTD_SEQ0_REG 0x2b
405
+
#define RK801_POWER_ENTER_SLP_OR_SHTD_SEQ1_REG 0x2c
406
+
#define RK801_POWER_ENTER_SLP_OR_SHTD_SEQ2_REG 0x2d
407
+
#define RK801_POWER_ENTER_SLP_OR_SHTD_SEQ3_REG 0x2e
408
+
#define RK801_BUCK_DEBUG1_REG 0x2f
409
+
#define RK801_BUCK_DEBUG2_REG 0x30
410
+
#define RK801_BUCK_DEBUG3_REG 0x31
411
+
#define RK801_BUCK_DEBUG4_REG 0x32
412
+
#define RK801_BUCK_DEBUG5_REG 0x33
413
+
#define RK801_BUCK_DEBUG7_REG 0x34
414
+
#define RK801_OTP_EN_CON_REG 0x35
415
+
#define RK801_TEST_CON_REG 0x36
416
+
#define RK801_EFUSE_CONTROL_REG 0x37
417
+
#define RK801_SYS_CFG3_OTP_REG 0x38
418
+
419
+
/* RK801 IRQ Definitions */
420
+
#define RK801_IRQ_PWRON_FALL 0
421
+
#define RK801_IRQ_PWRON_RISE 1
422
+
#define RK801_IRQ_PWRON 2
423
+
#define RK801_IRQ_PWRON_LP 3
424
+
#define RK801_IRQ_HOTDIE 4
425
+
#define RK801_IRQ_VDC_RISE 5
426
+
#define RK801_IRQ_VDC_FALL 6
427
+
#define RK801_IRQ_PWRON_FALL_MSK BIT(0)
428
+
#define RK801_IRQ_PWRON_RISE_MSK BIT(1)
429
+
#define RK801_IRQ_PWRON_MSK BIT(2)
430
+
#define RK801_IRQ_PWRON_LP_MSK BIT(3)
431
+
#define RK801_IRQ_HOTDIE_MSK BIT(4)
432
+
#define RK801_IRQ_VDC_RISE_MSK BIT(5)
433
+
#define RK801_IRQ_VDC_FALL_MSK BIT(6)
434
+
/* RK801_SLP_LP_CONFIG_REG */
435
+
#define RK801_BUCK_SLP_LP_EN BIT(3)
436
+
#define RK801_PLDO_SLP_LP_EN BIT(1)
437
+
#define RK801_SLP_LP_MASK (RK801_PLDO_SLP_LP_EN | RK801_BUCK_SLP_LP_EN)
438
+
/* RK801_SLEEP_CFG_REG */
439
+
#define RK801_SLEEP_FUN_MSK 0x3
440
+
#define RK801_NONE_FUN 0x0
441
+
#define RK801_SLEEP_FUN 0x1
442
+
#define RK801_SHUTDOWN_FUN 0x2
443
+
#define RK801_RESET_FUN 0x3
444
+
/* RK801_SYS_CFG2_REG */
445
+
#define RK801_SLEEP_POL_MSK BIT(1)
446
+
#define RK801_SLEEP_ACT_H BIT(1)
447
+
#define RK801_SLEEP_ACT_L 0
448
+
#define RK801_RST_MSK (0x3 << 4)
449
+
#define RK801_RST_RESTART_PMU (0x0 << 4)
450
+
#define RK801_RST_RESTART_REG (0x1 << 4)
451
+
#define RK801_RST_RESTART_REG_RESETB (0x2 << 4)
452
+
/* RK801_INT_CONFIG_REG */
453
+
#define RK801_INT_POL_MSK BIT(1)
454
+
#define RK801_INT_ACT_H BIT(1)
455
+
#define RK801_INT_ACT_L 0
456
+
#define RK801_FPWM_MODE 1
457
+
#define RK801_AUTO_PWM_MODE 0
458
+
#define RK801_PLDO_HRDEC_EN BIT(6)
459
+
343
460
/* RK805 */
344
461
enum rk805_reg {
345
462
RK805_ID_DCDC1,
···
1449
1332
};
1450
1333
1451
1334
enum {
1335
+
RK801_ID = 0x8010,
1452
1336
RK805_ID = 0x8050,
1453
1337
RK806_ID = 0x8060,
1454
1338
RK808_ID = 0x0000,