Commit | Line | Data |
---|---|---|
2025cf9e | 1 | // SPDX-License-Identifier: GPL-2.0-only |
2cd64ae3 | 2 | /* |
a7567663 | 3 | * Regulator driver for Rockchip RK805/RK808/RK818 |
2cd64ae3 CZ |
4 | * |
5 | * Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd | |
6 | * | |
7 | * Author: Chris Zhong <zyw@rock-chips.com> | |
8 | * Author: Zhang Qing <zhangqing@rock-chips.com> | |
9 | * | |
11375293 WE |
10 | * Copyright (C) 2016 PHYTEC Messtechnik GmbH |
11 | * | |
12 | * Author: Wadim Egorov <w.egorov@phytec.de> | |
2cd64ae3 CZ |
13 | */ |
14 | ||
bad47ad2 CZ |
15 | #include <linux/delay.h> |
16 | #include <linux/gpio.h> | |
bad47ad2 | 17 | #include <linux/module.h> |
2cd64ae3 | 18 | #include <linux/of_device.h> |
bad47ad2 CZ |
19 | #include <linux/of_gpio.h> |
20 | #include <linux/mfd/rk808.h> | |
2cd64ae3 CZ |
21 | #include <linux/regulator/driver.h> |
22 | #include <linux/regulator/of_regulator.h> | |
604d4994 | 23 | #include <linux/gpio/consumer.h> |
571a4010 CZ |
24 | |
25 | /* Field Definitions */ | |
2cd64ae3 CZ |
26 | #define RK808_BUCK_VSEL_MASK 0x3f |
27 | #define RK808_BUCK4_VSEL_MASK 0xf | |
28 | #define RK808_LDO_VSEL_MASK 0x1f | |
29 | ||
e444f6d6 HS |
30 | #define RK809_BUCK5_VSEL_MASK 0x7 |
31 | ||
32 | #define RK817_LDO_VSEL_MASK 0x7f | |
33 | #define RK817_BOOST_VSEL_MASK 0x7 | |
34 | #define RK817_BUCK_VSEL_MASK 0x7f | |
35 | ||
11375293 WE |
36 | #define RK818_BUCK_VSEL_MASK 0x3f |
37 | #define RK818_BUCK4_VSEL_MASK 0x1f | |
38 | #define RK818_LDO_VSEL_MASK 0x1f | |
39 | #define RK818_LDO3_ON_VSEL_MASK 0xf | |
40 | #define RK818_BOOST_ON_VSEL_MASK 0xe0 | |
41 | ||
8af25227 DA |
42 | /* Ramp rate definitions for buck1 / buck2 only */ |
43 | #define RK808_RAMP_RATE_OFFSET 3 | |
44 | #define RK808_RAMP_RATE_MASK (3 << RK808_RAMP_RATE_OFFSET) | |
45 | #define RK808_RAMP_RATE_2MV_PER_US (0 << RK808_RAMP_RATE_OFFSET) | |
46 | #define RK808_RAMP_RATE_4MV_PER_US (1 << RK808_RAMP_RATE_OFFSET) | |
47 | #define RK808_RAMP_RATE_6MV_PER_US (2 << RK808_RAMP_RATE_OFFSET) | |
48 | #define RK808_RAMP_RATE_10MV_PER_US (3 << RK808_RAMP_RATE_OFFSET) | |
49 | ||
bad47ad2 CZ |
50 | #define RK808_DVS2_POL BIT(2) |
51 | #define RK808_DVS1_POL BIT(1) | |
52 | ||
251ce318 CZ |
53 | /* Offset from XXX_ON_VSEL to XXX_SLP_VSEL */ |
54 | #define RK808_SLP_REG_OFFSET 1 | |
55 | ||
bad47ad2 CZ |
56 | /* Offset from XXX_ON_VSEL to XXX_DVS_VSEL */ |
57 | #define RK808_DVS_REG_OFFSET 2 | |
58 | ||
251ce318 CZ |
59 | /* Offset from XXX_EN_REG to SLEEP_SET_OFF_XXX */ |
60 | #define RK808_SLP_SET_OFF_REG_OFFSET 2 | |
61 | ||
bad47ad2 CZ |
62 | /* max steps for increase voltage of Buck1/2, equal 100mv*/ |
63 | #define MAX_STEPS_ONE_TIME 8 | |
64 | ||
e444f6d6 HS |
65 | #define ENABLE_MASK(id) (BIT(id) | BIT(4 + (id))) |
66 | #define DISABLE_VAL(id) (BIT(4 + (id))) | |
67 | ||
68 | #define RK817_BOOST_DESC(_id, _match, _supply, _min, _max, _step, _vreg,\ | |
69 | _vmask, _ereg, _emask, _enval, _disval, _etime, m_drop) \ | |
70 | { \ | |
71 | .name = (_match), \ | |
72 | .supply_name = (_supply), \ | |
73 | .of_match = of_match_ptr(_match), \ | |
74 | .regulators_node = of_match_ptr("regulators"), \ | |
75 | .type = REGULATOR_VOLTAGE, \ | |
76 | .id = (_id), \ | |
77 | .n_voltages = (((_max) - (_min)) / (_step) + 1), \ | |
78 | .owner = THIS_MODULE, \ | |
79 | .min_uV = (_min) * 1000, \ | |
80 | .uV_step = (_step) * 1000, \ | |
81 | .vsel_reg = (_vreg), \ | |
82 | .vsel_mask = (_vmask), \ | |
83 | .enable_reg = (_ereg), \ | |
84 | .enable_mask = (_emask), \ | |
85 | .enable_val = (_enval), \ | |
86 | .disable_val = (_disval), \ | |
87 | .enable_time = (_etime), \ | |
88 | .min_dropout_uV = (m_drop) * 1000, \ | |
89 | .ops = &rk817_boost_ops, \ | |
c4e0d344 EZ |
90 | } |
91 | ||
e444f6d6 HS |
92 | #define RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \ |
93 | _vmask, _ereg, _emask, _enval, _disval, _etime, _ops) \ | |
94 | { \ | |
9e9daa0a WE |
95 | .name = (_match), \ |
96 | .supply_name = (_supply), \ | |
97 | .of_match = of_match_ptr(_match), \ | |
98 | .regulators_node = of_match_ptr("regulators"), \ | |
99 | .type = REGULATOR_VOLTAGE, \ | |
100 | .id = (_id), \ | |
101 | .n_voltages = (((_max) - (_min)) / (_step) + 1), \ | |
102 | .owner = THIS_MODULE, \ | |
103 | .min_uV = (_min) * 1000, \ | |
104 | .uV_step = (_step) * 1000, \ | |
105 | .vsel_reg = (_vreg), \ | |
106 | .vsel_mask = (_vmask), \ | |
107 | .enable_reg = (_ereg), \ | |
108 | .enable_mask = (_emask), \ | |
e444f6d6 HS |
109 | .enable_val = (_enval), \ |
110 | .disable_val = (_disval), \ | |
9e9daa0a | 111 | .enable_time = (_etime), \ |
e444f6d6 | 112 | .ops = _ops, \ |
9e9daa0a WE |
113 | } |
114 | ||
e444f6d6 HS |
115 | #define RK805_DESC(_id, _match, _supply, _min, _max, _step, _vreg, \ |
116 | _vmask, _ereg, _emask, _etime) \ | |
117 | RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \ | |
118 | _vmask, _ereg, _emask, 0, 0, _etime, &rk805_reg_ops) | |
119 | ||
120 | #define RK8XX_DESC(_id, _match, _supply, _min, _max, _step, _vreg, \ | |
121 | _vmask, _ereg, _emask, _etime) \ | |
122 | RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \ | |
123 | _vmask, _ereg, _emask, 0, 0, _etime, &rk808_reg_ops) | |
124 | ||
125 | #define RK817_DESC(_id, _match, _supply, _min, _max, _step, _vreg, \ | |
126 | _vmask, _ereg, _emask, _disval, _etime) \ | |
127 | RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \ | |
128 | _vmask, _ereg, _emask, _emask, _disval, _etime, &rk817_reg_ops) | |
129 | ||
130 | #define RKXX_DESC_SWITCH_COM(_id, _match, _supply, _ereg, _emask, \ | |
131 | _enval, _disval, _ops) \ | |
132 | { \ | |
9e9daa0a WE |
133 | .name = (_match), \ |
134 | .supply_name = (_supply), \ | |
135 | .of_match = of_match_ptr(_match), \ | |
136 | .regulators_node = of_match_ptr("regulators"), \ | |
137 | .type = REGULATOR_VOLTAGE, \ | |
138 | .id = (_id), \ | |
139 | .enable_reg = (_ereg), \ | |
140 | .enable_mask = (_emask), \ | |
e444f6d6 HS |
141 | .enable_val = (_enval), \ |
142 | .disable_val = (_disval), \ | |
9e9daa0a | 143 | .owner = THIS_MODULE, \ |
e444f6d6 | 144 | .ops = _ops \ |
9e9daa0a WE |
145 | } |
146 | ||
e444f6d6 HS |
147 | #define RK817_DESC_SWITCH(_id, _match, _supply, _ereg, _emask, \ |
148 | _disval) \ | |
149 | RKXX_DESC_SWITCH_COM(_id, _match, _supply, _ereg, _emask, \ | |
150 | _emask, _disval, &rk817_switch_ops) | |
151 | ||
152 | #define RK8XX_DESC_SWITCH(_id, _match, _supply, _ereg, _emask) \ | |
153 | RKXX_DESC_SWITCH_COM(_id, _match, _supply, _ereg, _emask, \ | |
154 | 0, 0, &rk808_switch_ops) | |
9e9daa0a | 155 | |
bad47ad2 CZ |
156 | struct rk808_regulator_data { |
157 | struct gpio_desc *dvs_gpio[2]; | |
158 | }; | |
159 | ||
60ab7f41 | 160 | static const struct linear_range rk808_ldo3_voltage_ranges[] = { |
2cd64ae3 CZ |
161 | REGULATOR_LINEAR_RANGE(800000, 0, 13, 100000), |
162 | REGULATOR_LINEAR_RANGE(2500000, 15, 15, 0), | |
163 | }; | |
164 | ||
e444f6d6 HS |
165 | #define RK809_BUCK5_SEL_CNT (8) |
166 | ||
60ab7f41 | 167 | static const struct linear_range rk809_buck5_voltage_ranges[] = { |
e444f6d6 HS |
168 | REGULATOR_LINEAR_RANGE(1500000, 0, 0, 0), |
169 | REGULATOR_LINEAR_RANGE(1800000, 1, 3, 200000), | |
170 | REGULATOR_LINEAR_RANGE(2800000, 4, 5, 200000), | |
171 | REGULATOR_LINEAR_RANGE(3300000, 6, 7, 300000), | |
172 | }; | |
173 | ||
174 | #define RK817_BUCK1_MIN0 500000 | |
175 | #define RK817_BUCK1_MAX0 1500000 | |
176 | ||
177 | #define RK817_BUCK1_MIN1 1600000 | |
178 | #define RK817_BUCK1_MAX1 2400000 | |
179 | ||
180 | #define RK817_BUCK3_MAX1 3400000 | |
181 | ||
182 | #define RK817_BUCK1_STP0 12500 | |
183 | #define RK817_BUCK1_STP1 100000 | |
184 | ||
185 | #define RK817_BUCK1_SEL0 ((RK817_BUCK1_MAX0 - RK817_BUCK1_MIN0) /\ | |
186 | RK817_BUCK1_STP0) | |
187 | #define RK817_BUCK1_SEL1 ((RK817_BUCK1_MAX1 - RK817_BUCK1_MIN1) /\ | |
188 | RK817_BUCK1_STP1) | |
189 | ||
190 | #define RK817_BUCK3_SEL1 ((RK817_BUCK3_MAX1 - RK817_BUCK1_MIN1) /\ | |
191 | RK817_BUCK1_STP1) | |
192 | ||
193 | #define RK817_BUCK1_SEL_CNT (RK817_BUCK1_SEL0 + RK817_BUCK1_SEL1 + 1) | |
194 | #define RK817_BUCK3_SEL_CNT (RK817_BUCK1_SEL0 + RK817_BUCK3_SEL1 + 1) | |
195 | ||
60ab7f41 | 196 | static const struct linear_range rk817_buck1_voltage_ranges[] = { |
e444f6d6 HS |
197 | REGULATOR_LINEAR_RANGE(RK817_BUCK1_MIN0, 0, |
198 | RK817_BUCK1_SEL0, RK817_BUCK1_STP0), | |
199 | REGULATOR_LINEAR_RANGE(RK817_BUCK1_MIN1, RK817_BUCK1_SEL0 + 1, | |
200 | RK817_BUCK1_SEL_CNT, RK817_BUCK1_STP1), | |
201 | }; | |
202 | ||
60ab7f41 | 203 | static const struct linear_range rk817_buck3_voltage_ranges[] = { |
e444f6d6 HS |
204 | REGULATOR_LINEAR_RANGE(RK817_BUCK1_MIN0, 0, |
205 | RK817_BUCK1_SEL0, RK817_BUCK1_STP0), | |
206 | REGULATOR_LINEAR_RANGE(RK817_BUCK1_MIN1, RK817_BUCK1_SEL0 + 1, | |
207 | RK817_BUCK3_SEL_CNT, RK817_BUCK1_STP1), | |
208 | }; | |
209 | ||
f85ea494 AL |
210 | static const unsigned int rk808_buck1_2_ramp_table[] = { |
211 | 2000, 4000, 6000, 10000 | |
212 | }; | |
213 | ||
214 | /* RK817 RK809 */ | |
215 | static const unsigned int rk817_buck1_4_ramp_table[] = { | |
216 | 3000, 6300, 12500, 25000 | |
217 | }; | |
218 | ||
bad47ad2 CZ |
219 | static int rk808_buck1_2_get_voltage_sel_regmap(struct regulator_dev *rdev) |
220 | { | |
221 | struct rk808_regulator_data *pdata = rdev_get_drvdata(rdev); | |
bf8e2762 | 222 | int id = rdev_get_id(rdev); |
bad47ad2 CZ |
223 | struct gpio_desc *gpio = pdata->dvs_gpio[id]; |
224 | unsigned int val; | |
225 | int ret; | |
226 | ||
a13eaf02 | 227 | if (!gpio || gpiod_get_value(gpio) == 0) |
bad47ad2 CZ |
228 | return regulator_get_voltage_sel_regmap(rdev); |
229 | ||
230 | ret = regmap_read(rdev->regmap, | |
231 | rdev->desc->vsel_reg + RK808_DVS_REG_OFFSET, | |
232 | &val); | |
233 | if (ret != 0) | |
234 | return ret; | |
235 | ||
236 | val &= rdev->desc->vsel_mask; | |
237 | val >>= ffs(rdev->desc->vsel_mask) - 1; | |
238 | ||
239 | return val; | |
240 | } | |
241 | ||
242 | static int rk808_buck1_2_i2c_set_voltage_sel(struct regulator_dev *rdev, | |
243 | unsigned sel) | |
244 | { | |
245 | int ret, delta_sel; | |
246 | unsigned int old_sel, tmp, val, mask = rdev->desc->vsel_mask; | |
247 | ||
248 | ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val); | |
249 | if (ret != 0) | |
250 | return ret; | |
251 | ||
252 | tmp = val & ~mask; | |
253 | old_sel = val & mask; | |
254 | old_sel >>= ffs(mask) - 1; | |
255 | delta_sel = sel - old_sel; | |
256 | ||
257 | /* | |
258 | * If directly modify the register to change the voltage, we will face | |
259 | * the risk of overshoot. Put it into a multi-step, can effectively | |
260 | * avoid this problem, a step is 100mv here. | |
261 | */ | |
262 | while (delta_sel > MAX_STEPS_ONE_TIME) { | |
263 | old_sel += MAX_STEPS_ONE_TIME; | |
264 | val = old_sel << (ffs(mask) - 1); | |
265 | val |= tmp; | |
266 | ||
267 | /* | |
268 | * i2c is 400kHz (2.5us per bit) and we must transmit _at least_ | |
269 | * 3 bytes (24 bits) plus start and stop so 26 bits. So we've | |
270 | * got more than 65 us between each voltage change and thus | |
271 | * won't ramp faster than ~1500 uV / us. | |
272 | */ | |
273 | ret = regmap_write(rdev->regmap, rdev->desc->vsel_reg, val); | |
274 | delta_sel = sel - old_sel; | |
275 | } | |
276 | ||
277 | sel <<= ffs(mask) - 1; | |
278 | val = tmp | sel; | |
279 | ret = regmap_write(rdev->regmap, rdev->desc->vsel_reg, val); | |
280 | ||
281 | /* | |
282 | * When we change the voltage register directly, the ramp rate is about | |
283 | * 100000uv/us, wait 1us to make sure the target voltage to be stable, | |
284 | * so we needn't wait extra time after that. | |
285 | */ | |
286 | udelay(1); | |
287 | ||
288 | return ret; | |
289 | } | |
290 | ||
291 | static int rk808_buck1_2_set_voltage_sel(struct regulator_dev *rdev, | |
292 | unsigned sel) | |
293 | { | |
294 | struct rk808_regulator_data *pdata = rdev_get_drvdata(rdev); | |
bf8e2762 | 295 | int id = rdev_get_id(rdev); |
bad47ad2 CZ |
296 | struct gpio_desc *gpio = pdata->dvs_gpio[id]; |
297 | unsigned int reg = rdev->desc->vsel_reg; | |
298 | unsigned old_sel; | |
299 | int ret, gpio_level; | |
300 | ||
a13eaf02 | 301 | if (!gpio) |
bad47ad2 CZ |
302 | return rk808_buck1_2_i2c_set_voltage_sel(rdev, sel); |
303 | ||
304 | gpio_level = gpiod_get_value(gpio); | |
305 | if (gpio_level == 0) { | |
306 | reg += RK808_DVS_REG_OFFSET; | |
307 | ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &old_sel); | |
308 | } else { | |
309 | ret = regmap_read(rdev->regmap, | |
310 | reg + RK808_DVS_REG_OFFSET, | |
311 | &old_sel); | |
312 | } | |
313 | ||
314 | if (ret != 0) | |
315 | return ret; | |
316 | ||
317 | sel <<= ffs(rdev->desc->vsel_mask) - 1; | |
318 | sel |= old_sel & ~rdev->desc->vsel_mask; | |
319 | ||
320 | ret = regmap_write(rdev->regmap, reg, sel); | |
321 | if (ret) | |
322 | return ret; | |
323 | ||
324 | gpiod_set_value(gpio, !gpio_level); | |
325 | ||
326 | return ret; | |
327 | } | |
328 | ||
329 | static int rk808_buck1_2_set_voltage_time_sel(struct regulator_dev *rdev, | |
330 | unsigned int old_selector, | |
331 | unsigned int new_selector) | |
332 | { | |
333 | struct rk808_regulator_data *pdata = rdev_get_drvdata(rdev); | |
bf8e2762 | 334 | int id = rdev_get_id(rdev); |
bad47ad2 CZ |
335 | struct gpio_desc *gpio = pdata->dvs_gpio[id]; |
336 | ||
337 | /* if there is no dvs1/2 pin, we don't need wait extra time here. */ | |
a13eaf02 | 338 | if (!gpio) |
bad47ad2 CZ |
339 | return 0; |
340 | ||
341 | return regulator_set_voltage_time_sel(rdev, old_selector, new_selector); | |
342 | } | |
343 | ||
5cb2f03c | 344 | static int rk808_set_suspend_voltage(struct regulator_dev *rdev, int uv) |
afcd666d WE |
345 | { |
346 | unsigned int reg; | |
347 | int sel = regulator_map_voltage_linear(rdev, uv, uv); | |
348 | ||
349 | if (sel < 0) | |
350 | return -EINVAL; | |
351 | ||
352 | reg = rdev->desc->vsel_reg + RK808_SLP_REG_OFFSET; | |
353 | ||
354 | return regmap_update_bits(rdev->regmap, reg, | |
355 | rdev->desc->vsel_mask, | |
356 | sel); | |
357 | } | |
358 | ||
129d7cf9 WE |
359 | static int rk808_set_suspend_voltage_range(struct regulator_dev *rdev, int uv) |
360 | { | |
361 | unsigned int reg; | |
362 | int sel = regulator_map_voltage_linear_range(rdev, uv, uv); | |
363 | ||
364 | if (sel < 0) | |
365 | return -EINVAL; | |
366 | ||
367 | reg = rdev->desc->vsel_reg + RK808_SLP_REG_OFFSET; | |
368 | ||
369 | return regmap_update_bits(rdev->regmap, reg, | |
370 | rdev->desc->vsel_mask, | |
371 | sel); | |
372 | } | |
373 | ||
c4e0d344 EZ |
374 | static int rk805_set_suspend_enable(struct regulator_dev *rdev) |
375 | { | |
376 | unsigned int reg; | |
377 | ||
378 | reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET; | |
379 | ||
380 | return regmap_update_bits(rdev->regmap, reg, | |
381 | rdev->desc->enable_mask, | |
382 | rdev->desc->enable_mask); | |
383 | } | |
384 | ||
385 | static int rk805_set_suspend_disable(struct regulator_dev *rdev) | |
386 | { | |
387 | unsigned int reg; | |
388 | ||
389 | reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET; | |
390 | ||
391 | return regmap_update_bits(rdev->regmap, reg, | |
392 | rdev->desc->enable_mask, | |
393 | 0); | |
394 | } | |
395 | ||
5cb2f03c | 396 | static int rk808_set_suspend_enable(struct regulator_dev *rdev) |
251ce318 CZ |
397 | { |
398 | unsigned int reg; | |
399 | ||
400 | reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET; | |
401 | ||
402 | return regmap_update_bits(rdev->regmap, reg, | |
403 | rdev->desc->enable_mask, | |
404 | 0); | |
405 | } | |
406 | ||
5cb2f03c | 407 | static int rk808_set_suspend_disable(struct regulator_dev *rdev) |
251ce318 CZ |
408 | { |
409 | unsigned int reg; | |
410 | ||
411 | reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET; | |
412 | ||
413 | return regmap_update_bits(rdev->regmap, reg, | |
414 | rdev->desc->enable_mask, | |
415 | rdev->desc->enable_mask); | |
416 | } | |
417 | ||
e444f6d6 HS |
418 | static int rk817_set_suspend_enable_ctrl(struct regulator_dev *rdev, |
419 | unsigned int en) | |
420 | { | |
421 | unsigned int reg; | |
422 | int id = rdev_get_id(rdev); | |
423 | unsigned int id_slp, msk, val; | |
424 | ||
425 | if (id >= RK817_ID_DCDC1 && id <= RK817_ID_DCDC4) | |
426 | id_slp = id; | |
427 | else if (id >= RK817_ID_LDO1 && id <= RK817_ID_LDO8) | |
428 | id_slp = 8 + (id - RK817_ID_LDO1); | |
429 | else if (id >= RK817_ID_LDO9 && id <= RK809_ID_SW2) | |
430 | id_slp = 4 + (id - RK817_ID_LDO9); | |
431 | else | |
432 | return -EINVAL; | |
433 | ||
434 | reg = RK817_POWER_SLP_EN_REG(id_slp / 8); | |
435 | ||
436 | msk = BIT(id_slp % 8); | |
437 | if (en) | |
438 | val = msk; | |
439 | else | |
440 | val = 0; | |
441 | ||
442 | return regmap_update_bits(rdev->regmap, reg, msk, val); | |
443 | } | |
444 | ||
445 | static int rk817_set_suspend_enable(struct regulator_dev *rdev) | |
446 | { | |
447 | return rk817_set_suspend_enable_ctrl(rdev, 1); | |
448 | } | |
449 | ||
450 | static int rk817_set_suspend_disable(struct regulator_dev *rdev) | |
451 | { | |
452 | return rk817_set_suspend_enable_ctrl(rdev, 0); | |
453 | } | |
454 | ||
455 | static int rk8xx_set_suspend_mode(struct regulator_dev *rdev, unsigned int mode) | |
456 | { | |
457 | unsigned int reg; | |
458 | ||
459 | reg = rdev->desc->vsel_reg + RK808_SLP_REG_OFFSET; | |
460 | ||
461 | switch (mode) { | |
462 | case REGULATOR_MODE_FAST: | |
463 | return regmap_update_bits(rdev->regmap, reg, | |
464 | PWM_MODE_MSK, FPWM_MODE); | |
465 | case REGULATOR_MODE_NORMAL: | |
466 | return regmap_update_bits(rdev->regmap, reg, | |
467 | PWM_MODE_MSK, AUTO_PWM_MODE); | |
468 | default: | |
469 | dev_err(&rdev->dev, "do not support this mode\n"); | |
470 | return -EINVAL; | |
471 | } | |
472 | ||
473 | return 0; | |
474 | } | |
475 | ||
476 | static int rk8xx_set_mode(struct regulator_dev *rdev, unsigned int mode) | |
477 | { | |
478 | switch (mode) { | |
479 | case REGULATOR_MODE_FAST: | |
480 | return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg, | |
481 | PWM_MODE_MSK, FPWM_MODE); | |
482 | case REGULATOR_MODE_NORMAL: | |
483 | return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg, | |
484 | PWM_MODE_MSK, AUTO_PWM_MODE); | |
485 | default: | |
486 | dev_err(&rdev->dev, "do not support this mode\n"); | |
487 | return -EINVAL; | |
488 | } | |
489 | ||
490 | return 0; | |
491 | } | |
492 | ||
493 | static unsigned int rk8xx_get_mode(struct regulator_dev *rdev) | |
494 | { | |
495 | unsigned int val; | |
496 | int err; | |
497 | ||
498 | err = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val); | |
499 | if (err) | |
500 | return err; | |
501 | ||
502 | if (val & FPWM_MODE) | |
503 | return REGULATOR_MODE_FAST; | |
504 | else | |
505 | return REGULATOR_MODE_NORMAL; | |
506 | } | |
507 | ||
508 | static int rk8xx_is_enabled_wmsk_regmap(struct regulator_dev *rdev) | |
509 | { | |
510 | unsigned int val; | |
511 | int ret; | |
512 | ||
513 | ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val); | |
514 | if (ret != 0) | |
515 | return ret; | |
516 | ||
517 | /* add write mask bit */ | |
518 | val |= (rdev->desc->enable_mask & 0xf0); | |
519 | val &= rdev->desc->enable_mask; | |
520 | ||
521 | if (rdev->desc->enable_is_inverted) { | |
522 | if (rdev->desc->enable_val) | |
523 | return val != rdev->desc->enable_val; | |
524 | return (val == 0); | |
525 | } | |
526 | if (rdev->desc->enable_val) | |
527 | return val == rdev->desc->enable_val; | |
528 | return val != 0; | |
529 | } | |
530 | ||
531 | static unsigned int rk8xx_regulator_of_map_mode(unsigned int mode) | |
532 | { | |
533 | switch (mode) { | |
534 | case 1: | |
535 | return REGULATOR_MODE_FAST; | |
536 | case 2: | |
537 | return REGULATOR_MODE_NORMAL; | |
538 | default: | |
d850c6f5 | 539 | return REGULATOR_MODE_INVALID; |
e444f6d6 HS |
540 | } |
541 | } | |
542 | ||
dc6f23ed AL |
543 | static const struct regulator_ops rk805_reg_ops = { |
544 | .list_voltage = regulator_list_voltage_linear, | |
545 | .map_voltage = regulator_map_voltage_linear, | |
546 | .get_voltage_sel = regulator_get_voltage_sel_regmap, | |
547 | .set_voltage_sel = regulator_set_voltage_sel_regmap, | |
548 | .enable = regulator_enable_regmap, | |
549 | .disable = regulator_disable_regmap, | |
550 | .is_enabled = regulator_is_enabled_regmap, | |
551 | .set_suspend_voltage = rk808_set_suspend_voltage, | |
552 | .set_suspend_enable = rk805_set_suspend_enable, | |
553 | .set_suspend_disable = rk805_set_suspend_disable, | |
c4e0d344 EZ |
554 | }; |
555 | ||
dc6f23ed AL |
556 | static const struct regulator_ops rk805_switch_ops = { |
557 | .enable = regulator_enable_regmap, | |
558 | .disable = regulator_disable_regmap, | |
559 | .is_enabled = regulator_is_enabled_regmap, | |
560 | .set_suspend_enable = rk805_set_suspend_enable, | |
561 | .set_suspend_disable = rk805_set_suspend_disable, | |
c4e0d344 EZ |
562 | }; |
563 | ||
dc6f23ed | 564 | static const struct regulator_ops rk808_buck1_2_ops = { |
afcd666d WE |
565 | .list_voltage = regulator_list_voltage_linear, |
566 | .map_voltage = regulator_map_voltage_linear, | |
bad47ad2 CZ |
567 | .get_voltage_sel = rk808_buck1_2_get_voltage_sel_regmap, |
568 | .set_voltage_sel = rk808_buck1_2_set_voltage_sel, | |
569 | .set_voltage_time_sel = rk808_buck1_2_set_voltage_time_sel, | |
8af25227 DA |
570 | .enable = regulator_enable_regmap, |
571 | .disable = regulator_disable_regmap, | |
572 | .is_enabled = regulator_is_enabled_regmap, | |
f85ea494 | 573 | .set_ramp_delay = regulator_set_ramp_delay_regmap, |
251ce318 CZ |
574 | .set_suspend_voltage = rk808_set_suspend_voltage, |
575 | .set_suspend_enable = rk808_set_suspend_enable, | |
576 | .set_suspend_disable = rk808_set_suspend_disable, | |
8af25227 DA |
577 | }; |
578 | ||
dc6f23ed | 579 | static const struct regulator_ops rk808_reg_ops = { |
afcd666d WE |
580 | .list_voltage = regulator_list_voltage_linear, |
581 | .map_voltage = regulator_map_voltage_linear, | |
582 | .get_voltage_sel = regulator_get_voltage_sel_regmap, | |
583 | .set_voltage_sel = regulator_set_voltage_sel_regmap, | |
584 | .enable = regulator_enable_regmap, | |
585 | .disable = regulator_disable_regmap, | |
586 | .is_enabled = regulator_is_enabled_regmap, | |
587 | .set_suspend_voltage = rk808_set_suspend_voltage, | |
588 | .set_suspend_enable = rk808_set_suspend_enable, | |
589 | .set_suspend_disable = rk808_set_suspend_disable, | |
590 | }; | |
591 | ||
dc6f23ed | 592 | static const struct regulator_ops rk808_reg_ops_ranges = { |
129d7cf9 WE |
593 | .list_voltage = regulator_list_voltage_linear_range, |
594 | .map_voltage = regulator_map_voltage_linear_range, | |
595 | .get_voltage_sel = regulator_get_voltage_sel_regmap, | |
596 | .set_voltage_sel = regulator_set_voltage_sel_regmap, | |
597 | .enable = regulator_enable_regmap, | |
598 | .disable = regulator_disable_regmap, | |
599 | .is_enabled = regulator_is_enabled_regmap, | |
600 | .set_suspend_voltage = rk808_set_suspend_voltage_range, | |
601 | .set_suspend_enable = rk808_set_suspend_enable, | |
602 | .set_suspend_disable = rk808_set_suspend_disable, | |
603 | }; | |
604 | ||
dc6f23ed | 605 | static const struct regulator_ops rk808_switch_ops = { |
251ce318 CZ |
606 | .enable = regulator_enable_regmap, |
607 | .disable = regulator_disable_regmap, | |
608 | .is_enabled = regulator_is_enabled_regmap, | |
609 | .set_suspend_enable = rk808_set_suspend_enable, | |
610 | .set_suspend_disable = rk808_set_suspend_disable, | |
2cd64ae3 CZ |
611 | }; |
612 | ||
60ab7f41 | 613 | static const struct linear_range rk805_buck_1_2_voltage_ranges[] = { |
4f297062 AL |
614 | REGULATOR_LINEAR_RANGE(712500, 0, 59, 12500), |
615 | REGULATOR_LINEAR_RANGE(1800000, 60, 62, 200000), | |
616 | REGULATOR_LINEAR_RANGE(2300000, 63, 63, 0), | |
2b679ca1 OS |
617 | }; |
618 | ||
2e67f322 | 619 | static const struct regulator_ops rk809_buck5_ops_range = { |
e444f6d6 HS |
620 | .list_voltage = regulator_list_voltage_linear_range, |
621 | .map_voltage = regulator_map_voltage_linear_range, | |
622 | .get_voltage_sel = regulator_get_voltage_sel_regmap, | |
623 | .set_voltage_sel = regulator_set_voltage_sel_regmap, | |
624 | .set_voltage_time_sel = regulator_set_voltage_time_sel, | |
625 | .enable = regulator_enable_regmap, | |
626 | .disable = regulator_disable_regmap, | |
627 | .is_enabled = rk8xx_is_enabled_wmsk_regmap, | |
628 | .set_suspend_voltage = rk808_set_suspend_voltage_range, | |
629 | .set_suspend_enable = rk817_set_suspend_enable, | |
630 | .set_suspend_disable = rk817_set_suspend_disable, | |
631 | }; | |
632 | ||
2e67f322 | 633 | static const struct regulator_ops rk817_reg_ops = { |
e444f6d6 HS |
634 | .list_voltage = regulator_list_voltage_linear, |
635 | .map_voltage = regulator_map_voltage_linear, | |
636 | .get_voltage_sel = regulator_get_voltage_sel_regmap, | |
637 | .set_voltage_sel = regulator_set_voltage_sel_regmap, | |
638 | .enable = regulator_enable_regmap, | |
639 | .disable = regulator_disable_regmap, | |
640 | .is_enabled = rk8xx_is_enabled_wmsk_regmap, | |
9306a733 | 641 | .set_suspend_voltage = rk808_set_suspend_voltage, |
e444f6d6 HS |
642 | .set_suspend_enable = rk817_set_suspend_enable, |
643 | .set_suspend_disable = rk817_set_suspend_disable, | |
644 | }; | |
645 | ||
2e67f322 | 646 | static const struct regulator_ops rk817_boost_ops = { |
e444f6d6 HS |
647 | .list_voltage = regulator_list_voltage_linear, |
648 | .map_voltage = regulator_map_voltage_linear, | |
649 | .get_voltage_sel = regulator_get_voltage_sel_regmap, | |
650 | .set_voltage_sel = regulator_set_voltage_sel_regmap, | |
651 | .enable = regulator_enable_regmap, | |
652 | .disable = regulator_disable_regmap, | |
653 | .is_enabled = rk8xx_is_enabled_wmsk_regmap, | |
654 | .set_suspend_enable = rk817_set_suspend_enable, | |
655 | .set_suspend_disable = rk817_set_suspend_disable, | |
656 | }; | |
657 | ||
2e67f322 | 658 | static const struct regulator_ops rk817_buck_ops_range = { |
e444f6d6 HS |
659 | .list_voltage = regulator_list_voltage_linear_range, |
660 | .map_voltage = regulator_map_voltage_linear_range, | |
661 | .get_voltage_sel = regulator_get_voltage_sel_regmap, | |
662 | .set_voltage_sel = regulator_set_voltage_sel_regmap, | |
663 | .set_voltage_time_sel = regulator_set_voltage_time_sel, | |
664 | .enable = regulator_enable_regmap, | |
665 | .disable = regulator_disable_regmap, | |
666 | .is_enabled = rk8xx_is_enabled_wmsk_regmap, | |
667 | .set_mode = rk8xx_set_mode, | |
668 | .get_mode = rk8xx_get_mode, | |
669 | .set_suspend_mode = rk8xx_set_suspend_mode, | |
f85ea494 | 670 | .set_ramp_delay = regulator_set_ramp_delay_regmap, |
e444f6d6 HS |
671 | .set_suspend_voltage = rk808_set_suspend_voltage_range, |
672 | .set_suspend_enable = rk817_set_suspend_enable, | |
673 | .set_suspend_disable = rk817_set_suspend_disable, | |
674 | }; | |
675 | ||
2e67f322 | 676 | static const struct regulator_ops rk817_switch_ops = { |
e444f6d6 HS |
677 | .enable = regulator_enable_regmap, |
678 | .disable = regulator_disable_regmap, | |
679 | .is_enabled = rk8xx_is_enabled_wmsk_regmap, | |
680 | .set_suspend_enable = rk817_set_suspend_enable, | |
681 | .set_suspend_disable = rk817_set_suspend_disable, | |
682 | }; | |
683 | ||
c4e0d344 EZ |
684 | static const struct regulator_desc rk805_reg[] = { |
685 | { | |
686 | .name = "DCDC_REG1", | |
687 | .supply_name = "vcc1", | |
688 | .of_match = of_match_ptr("DCDC_REG1"), | |
689 | .regulators_node = of_match_ptr("regulators"), | |
690 | .id = RK805_ID_DCDC1, | |
4f297062 | 691 | .ops = &rk808_reg_ops_ranges, |
c4e0d344 | 692 | .type = REGULATOR_VOLTAGE, |
4f297062 AL |
693 | .n_voltages = 64, |
694 | .linear_ranges = rk805_buck_1_2_voltage_ranges, | |
695 | .n_linear_ranges = ARRAY_SIZE(rk805_buck_1_2_voltage_ranges), | |
c4e0d344 EZ |
696 | .vsel_reg = RK805_BUCK1_ON_VSEL_REG, |
697 | .vsel_mask = RK818_BUCK_VSEL_MASK, | |
698 | .enable_reg = RK805_DCDC_EN_REG, | |
699 | .enable_mask = BIT(0), | |
700 | .owner = THIS_MODULE, | |
701 | }, { | |
702 | .name = "DCDC_REG2", | |
703 | .supply_name = "vcc2", | |
704 | .of_match = of_match_ptr("DCDC_REG2"), | |
705 | .regulators_node = of_match_ptr("regulators"), | |
706 | .id = RK805_ID_DCDC2, | |
4f297062 | 707 | .ops = &rk808_reg_ops_ranges, |
c4e0d344 | 708 | .type = REGULATOR_VOLTAGE, |
4f297062 AL |
709 | .n_voltages = 64, |
710 | .linear_ranges = rk805_buck_1_2_voltage_ranges, | |
711 | .n_linear_ranges = ARRAY_SIZE(rk805_buck_1_2_voltage_ranges), | |
c4e0d344 EZ |
712 | .vsel_reg = RK805_BUCK2_ON_VSEL_REG, |
713 | .vsel_mask = RK818_BUCK_VSEL_MASK, | |
714 | .enable_reg = RK805_DCDC_EN_REG, | |
715 | .enable_mask = BIT(1), | |
716 | .owner = THIS_MODULE, | |
717 | }, { | |
718 | .name = "DCDC_REG3", | |
719 | .supply_name = "vcc3", | |
720 | .of_match = of_match_ptr("DCDC_REG3"), | |
721 | .regulators_node = of_match_ptr("regulators"), | |
722 | .id = RK805_ID_DCDC3, | |
723 | .ops = &rk805_switch_ops, | |
724 | .type = REGULATOR_VOLTAGE, | |
725 | .n_voltages = 1, | |
726 | .enable_reg = RK805_DCDC_EN_REG, | |
727 | .enable_mask = BIT(2), | |
728 | .owner = THIS_MODULE, | |
729 | }, | |
730 | ||
731 | RK805_DESC(RK805_ID_DCDC4, "DCDC_REG4", "vcc4", 800, 3400, 100, | |
732 | RK805_BUCK4_ON_VSEL_REG, RK818_BUCK4_VSEL_MASK, | |
733 | RK805_DCDC_EN_REG, BIT(3), 0), | |
734 | ||
735 | RK805_DESC(RK805_ID_LDO1, "LDO_REG1", "vcc5", 800, 3400, 100, | |
736 | RK805_LDO1_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK805_LDO_EN_REG, | |
737 | BIT(0), 400), | |
738 | RK805_DESC(RK805_ID_LDO2, "LDO_REG2", "vcc5", 800, 3400, 100, | |
739 | RK805_LDO2_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK805_LDO_EN_REG, | |
740 | BIT(1), 400), | |
741 | RK805_DESC(RK805_ID_LDO3, "LDO_REG3", "vcc6", 800, 3400, 100, | |
742 | RK805_LDO3_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK805_LDO_EN_REG, | |
743 | BIT(2), 400), | |
744 | }; | |
745 | ||
2cd64ae3 CZ |
746 | static const struct regulator_desc rk808_reg[] = { |
747 | { | |
748 | .name = "DCDC_REG1", | |
b8074eba | 749 | .supply_name = "vcc1", |
9e9daa0a WE |
750 | .of_match = of_match_ptr("DCDC_REG1"), |
751 | .regulators_node = of_match_ptr("regulators"), | |
2cd64ae3 | 752 | .id = RK808_ID_DCDC1, |
8af25227 | 753 | .ops = &rk808_buck1_2_ops, |
2cd64ae3 | 754 | .type = REGULATOR_VOLTAGE, |
afcd666d WE |
755 | .min_uV = 712500, |
756 | .uV_step = 12500, | |
2cd64ae3 | 757 | .n_voltages = 64, |
2cd64ae3 CZ |
758 | .vsel_reg = RK808_BUCK1_ON_VSEL_REG, |
759 | .vsel_mask = RK808_BUCK_VSEL_MASK, | |
760 | .enable_reg = RK808_DCDC_EN_REG, | |
761 | .enable_mask = BIT(0), | |
f85ea494 AL |
762 | .ramp_reg = RK808_BUCK1_CONFIG_REG, |
763 | .ramp_mask = RK808_RAMP_RATE_MASK, | |
764 | .ramp_delay_table = rk808_buck1_2_ramp_table, | |
765 | .n_ramp_values = ARRAY_SIZE(rk808_buck1_2_ramp_table), | |
2cd64ae3 CZ |
766 | .owner = THIS_MODULE, |
767 | }, { | |
768 | .name = "DCDC_REG2", | |
b8074eba | 769 | .supply_name = "vcc2", |
9e9daa0a WE |
770 | .of_match = of_match_ptr("DCDC_REG2"), |
771 | .regulators_node = of_match_ptr("regulators"), | |
2cd64ae3 | 772 | .id = RK808_ID_DCDC2, |
8af25227 | 773 | .ops = &rk808_buck1_2_ops, |
2cd64ae3 | 774 | .type = REGULATOR_VOLTAGE, |
afcd666d WE |
775 | .min_uV = 712500, |
776 | .uV_step = 12500, | |
2cd64ae3 | 777 | .n_voltages = 64, |
2cd64ae3 CZ |
778 | .vsel_reg = RK808_BUCK2_ON_VSEL_REG, |
779 | .vsel_mask = RK808_BUCK_VSEL_MASK, | |
780 | .enable_reg = RK808_DCDC_EN_REG, | |
781 | .enable_mask = BIT(1), | |
f85ea494 AL |
782 | .ramp_reg = RK808_BUCK2_CONFIG_REG, |
783 | .ramp_mask = RK808_RAMP_RATE_MASK, | |
784 | .ramp_delay_table = rk808_buck1_2_ramp_table, | |
785 | .n_ramp_values = ARRAY_SIZE(rk808_buck1_2_ramp_table), | |
2cd64ae3 CZ |
786 | .owner = THIS_MODULE, |
787 | }, { | |
788 | .name = "DCDC_REG3", | |
b8074eba | 789 | .supply_name = "vcc3", |
9e9daa0a WE |
790 | .of_match = of_match_ptr("DCDC_REG3"), |
791 | .regulators_node = of_match_ptr("regulators"), | |
2cd64ae3 CZ |
792 | .id = RK808_ID_DCDC3, |
793 | .ops = &rk808_switch_ops, | |
794 | .type = REGULATOR_VOLTAGE, | |
795 | .n_voltages = 1, | |
796 | .enable_reg = RK808_DCDC_EN_REG, | |
797 | .enable_mask = BIT(2), | |
798 | .owner = THIS_MODULE, | |
9e9daa0a WE |
799 | }, |
800 | RK8XX_DESC(RK808_ID_DCDC4, "DCDC_REG4", "vcc4", 1800, 3300, 100, | |
801 | RK808_BUCK4_ON_VSEL_REG, RK808_BUCK4_VSEL_MASK, | |
802 | RK808_DCDC_EN_REG, BIT(3), 0), | |
803 | RK8XX_DESC(RK808_ID_LDO1, "LDO_REG1", "vcc6", 1800, 3400, 100, | |
804 | RK808_LDO1_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG, | |
805 | BIT(0), 400), | |
806 | RK8XX_DESC(RK808_ID_LDO2, "LDO_REG2", "vcc6", 1800, 3400, 100, | |
807 | RK808_LDO2_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG, | |
808 | BIT(1), 400), | |
809 | { | |
2cd64ae3 | 810 | .name = "LDO_REG3", |
b8074eba | 811 | .supply_name = "vcc7", |
9e9daa0a WE |
812 | .of_match = of_match_ptr("LDO_REG3"), |
813 | .regulators_node = of_match_ptr("regulators"), | |
2cd64ae3 | 814 | .id = RK808_ID_LDO3, |
129d7cf9 | 815 | .ops = &rk808_reg_ops_ranges, |
2cd64ae3 CZ |
816 | .type = REGULATOR_VOLTAGE, |
817 | .n_voltages = 16, | |
818 | .linear_ranges = rk808_ldo3_voltage_ranges, | |
819 | .n_linear_ranges = ARRAY_SIZE(rk808_ldo3_voltage_ranges), | |
820 | .vsel_reg = RK808_LDO3_ON_VSEL_REG, | |
821 | .vsel_mask = RK808_BUCK4_VSEL_MASK, | |
822 | .enable_reg = RK808_LDO_EN_REG, | |
823 | .enable_mask = BIT(2), | |
28249b0c | 824 | .enable_time = 400, |
2cd64ae3 | 825 | .owner = THIS_MODULE, |
2cd64ae3 | 826 | }, |
9e9daa0a WE |
827 | RK8XX_DESC(RK808_ID_LDO4, "LDO_REG4", "vcc9", 1800, 3400, 100, |
828 | RK808_LDO4_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG, | |
829 | BIT(3), 400), | |
830 | RK8XX_DESC(RK808_ID_LDO5, "LDO_REG5", "vcc9", 1800, 3400, 100, | |
831 | RK808_LDO5_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG, | |
832 | BIT(4), 400), | |
833 | RK8XX_DESC(RK808_ID_LDO6, "LDO_REG6", "vcc10", 800, 2500, 100, | |
834 | RK808_LDO6_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG, | |
835 | BIT(5), 400), | |
836 | RK8XX_DESC(RK808_ID_LDO7, "LDO_REG7", "vcc7", 800, 2500, 100, | |
837 | RK808_LDO7_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG, | |
838 | BIT(6), 400), | |
839 | RK8XX_DESC(RK808_ID_LDO8, "LDO_REG8", "vcc11", 1800, 3400, 100, | |
840 | RK808_LDO8_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG, | |
841 | BIT(7), 400), | |
842 | RK8XX_DESC_SWITCH(RK808_ID_SWITCH1, "SWITCH_REG1", "vcc8", | |
843 | RK808_DCDC_EN_REG, BIT(5)), | |
844 | RK8XX_DESC_SWITCH(RK808_ID_SWITCH2, "SWITCH_REG2", "vcc12", | |
845 | RK808_DCDC_EN_REG, BIT(6)), | |
2cd64ae3 CZ |
846 | }; |
847 | ||
e444f6d6 HS |
848 | static const struct regulator_desc rk809_reg[] = { |
849 | { | |
850 | .name = "DCDC_REG1", | |
851 | .supply_name = "vcc1", | |
852 | .of_match = of_match_ptr("DCDC_REG1"), | |
853 | .regulators_node = of_match_ptr("regulators"), | |
854 | .id = RK817_ID_DCDC1, | |
855 | .ops = &rk817_buck_ops_range, | |
856 | .type = REGULATOR_VOLTAGE, | |
857 | .n_voltages = RK817_BUCK1_SEL_CNT + 1, | |
858 | .linear_ranges = rk817_buck1_voltage_ranges, | |
859 | .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges), | |
860 | .vsel_reg = RK817_BUCK1_ON_VSEL_REG, | |
861 | .vsel_mask = RK817_BUCK_VSEL_MASK, | |
862 | .enable_reg = RK817_POWER_EN_REG(0), | |
863 | .enable_mask = ENABLE_MASK(RK817_ID_DCDC1), | |
864 | .enable_val = ENABLE_MASK(RK817_ID_DCDC1), | |
865 | .disable_val = DISABLE_VAL(RK817_ID_DCDC1), | |
f85ea494 AL |
866 | .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC1), |
867 | .ramp_mask = RK817_RAMP_RATE_MASK, | |
868 | .ramp_delay_table = rk817_buck1_4_ramp_table, | |
869 | .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table), | |
e444f6d6 HS |
870 | .of_map_mode = rk8xx_regulator_of_map_mode, |
871 | .owner = THIS_MODULE, | |
872 | }, { | |
873 | .name = "DCDC_REG2", | |
874 | .supply_name = "vcc2", | |
875 | .of_match = of_match_ptr("DCDC_REG2"), | |
876 | .regulators_node = of_match_ptr("regulators"), | |
877 | .id = RK817_ID_DCDC2, | |
878 | .ops = &rk817_buck_ops_range, | |
879 | .type = REGULATOR_VOLTAGE, | |
880 | .n_voltages = RK817_BUCK1_SEL_CNT + 1, | |
881 | .linear_ranges = rk817_buck1_voltage_ranges, | |
882 | .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges), | |
883 | .vsel_reg = RK817_BUCK2_ON_VSEL_REG, | |
884 | .vsel_mask = RK817_BUCK_VSEL_MASK, | |
885 | .enable_reg = RK817_POWER_EN_REG(0), | |
886 | .enable_mask = ENABLE_MASK(RK817_ID_DCDC2), | |
887 | .enable_val = ENABLE_MASK(RK817_ID_DCDC2), | |
888 | .disable_val = DISABLE_VAL(RK817_ID_DCDC2), | |
f85ea494 AL |
889 | .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC2), |
890 | .ramp_mask = RK817_RAMP_RATE_MASK, | |
891 | .ramp_delay_table = rk817_buck1_4_ramp_table, | |
892 | .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table), | |
e444f6d6 HS |
893 | .of_map_mode = rk8xx_regulator_of_map_mode, |
894 | .owner = THIS_MODULE, | |
895 | }, { | |
896 | .name = "DCDC_REG3", | |
897 | .supply_name = "vcc3", | |
898 | .of_match = of_match_ptr("DCDC_REG3"), | |
899 | .regulators_node = of_match_ptr("regulators"), | |
900 | .id = RK817_ID_DCDC3, | |
901 | .ops = &rk817_buck_ops_range, | |
902 | .type = REGULATOR_VOLTAGE, | |
903 | .n_voltages = RK817_BUCK1_SEL_CNT + 1, | |
904 | .linear_ranges = rk817_buck1_voltage_ranges, | |
905 | .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges), | |
906 | .vsel_reg = RK817_BUCK3_ON_VSEL_REG, | |
907 | .vsel_mask = RK817_BUCK_VSEL_MASK, | |
908 | .enable_reg = RK817_POWER_EN_REG(0), | |
909 | .enable_mask = ENABLE_MASK(RK817_ID_DCDC3), | |
910 | .enable_val = ENABLE_MASK(RK817_ID_DCDC3), | |
911 | .disable_val = DISABLE_VAL(RK817_ID_DCDC3), | |
f85ea494 AL |
912 | .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC3), |
913 | .ramp_mask = RK817_RAMP_RATE_MASK, | |
914 | .ramp_delay_table = rk817_buck1_4_ramp_table, | |
915 | .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table), | |
e444f6d6 HS |
916 | .of_map_mode = rk8xx_regulator_of_map_mode, |
917 | .owner = THIS_MODULE, | |
918 | }, { | |
919 | .name = "DCDC_REG4", | |
920 | .supply_name = "vcc4", | |
921 | .of_match = of_match_ptr("DCDC_REG4"), | |
922 | .regulators_node = of_match_ptr("regulators"), | |
923 | .id = RK817_ID_DCDC4, | |
924 | .ops = &rk817_buck_ops_range, | |
925 | .type = REGULATOR_VOLTAGE, | |
926 | .n_voltages = RK817_BUCK3_SEL_CNT + 1, | |
927 | .linear_ranges = rk817_buck3_voltage_ranges, | |
928 | .n_linear_ranges = ARRAY_SIZE(rk817_buck3_voltage_ranges), | |
929 | .vsel_reg = RK817_BUCK4_ON_VSEL_REG, | |
930 | .vsel_mask = RK817_BUCK_VSEL_MASK, | |
931 | .enable_reg = RK817_POWER_EN_REG(0), | |
932 | .enable_mask = ENABLE_MASK(RK817_ID_DCDC4), | |
933 | .enable_val = ENABLE_MASK(RK817_ID_DCDC4), | |
934 | .disable_val = DISABLE_VAL(RK817_ID_DCDC4), | |
f85ea494 AL |
935 | .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC4), |
936 | .ramp_mask = RK817_RAMP_RATE_MASK, | |
937 | .ramp_delay_table = rk817_buck1_4_ramp_table, | |
938 | .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table), | |
e444f6d6 HS |
939 | .of_map_mode = rk8xx_regulator_of_map_mode, |
940 | .owner = THIS_MODULE, | |
941 | }, | |
942 | { | |
943 | .name = "DCDC_REG5", | |
944 | .supply_name = "vcc9", | |
945 | .of_match = of_match_ptr("DCDC_REG5"), | |
946 | .regulators_node = of_match_ptr("regulators"), | |
947 | .id = RK809_ID_DCDC5, | |
948 | .ops = &rk809_buck5_ops_range, | |
949 | .type = REGULATOR_VOLTAGE, | |
950 | .n_voltages = RK809_BUCK5_SEL_CNT, | |
951 | .linear_ranges = rk809_buck5_voltage_ranges, | |
952 | .n_linear_ranges = ARRAY_SIZE(rk809_buck5_voltage_ranges), | |
953 | .vsel_reg = RK809_BUCK5_CONFIG(0), | |
954 | .vsel_mask = RK809_BUCK5_VSEL_MASK, | |
955 | .enable_reg = RK817_POWER_EN_REG(3), | |
956 | .enable_mask = ENABLE_MASK(1), | |
957 | .enable_val = ENABLE_MASK(1), | |
958 | .disable_val = DISABLE_VAL(1), | |
959 | .of_map_mode = rk8xx_regulator_of_map_mode, | |
960 | .owner = THIS_MODULE, | |
961 | }, | |
962 | RK817_DESC(RK817_ID_LDO1, "LDO_REG1", "vcc5", 600, 3400, 25, | |
963 | RK817_LDO_ON_VSEL_REG(0), RK817_LDO_VSEL_MASK, | |
964 | RK817_POWER_EN_REG(1), ENABLE_MASK(0), | |
965 | DISABLE_VAL(0), 400), | |
966 | RK817_DESC(RK817_ID_LDO2, "LDO_REG2", "vcc5", 600, 3400, 25, | |
967 | RK817_LDO_ON_VSEL_REG(1), RK817_LDO_VSEL_MASK, | |
968 | RK817_POWER_EN_REG(1), ENABLE_MASK(1), | |
969 | DISABLE_VAL(1), 400), | |
970 | RK817_DESC(RK817_ID_LDO3, "LDO_REG3", "vcc5", 600, 3400, 25, | |
971 | RK817_LDO_ON_VSEL_REG(2), RK817_LDO_VSEL_MASK, | |
972 | RK817_POWER_EN_REG(1), ENABLE_MASK(2), | |
973 | DISABLE_VAL(2), 400), | |
974 | RK817_DESC(RK817_ID_LDO4, "LDO_REG4", "vcc6", 600, 3400, 25, | |
975 | RK817_LDO_ON_VSEL_REG(3), RK817_LDO_VSEL_MASK, | |
976 | RK817_POWER_EN_REG(1), ENABLE_MASK(3), | |
977 | DISABLE_VAL(3), 400), | |
978 | RK817_DESC(RK817_ID_LDO5, "LDO_REG5", "vcc6", 600, 3400, 25, | |
979 | RK817_LDO_ON_VSEL_REG(4), RK817_LDO_VSEL_MASK, | |
980 | RK817_POWER_EN_REG(2), ENABLE_MASK(0), | |
981 | DISABLE_VAL(0), 400), | |
982 | RK817_DESC(RK817_ID_LDO6, "LDO_REG6", "vcc6", 600, 3400, 25, | |
983 | RK817_LDO_ON_VSEL_REG(5), RK817_LDO_VSEL_MASK, | |
984 | RK817_POWER_EN_REG(2), ENABLE_MASK(1), | |
985 | DISABLE_VAL(1), 400), | |
986 | RK817_DESC(RK817_ID_LDO7, "LDO_REG7", "vcc7", 600, 3400, 25, | |
987 | RK817_LDO_ON_VSEL_REG(6), RK817_LDO_VSEL_MASK, | |
988 | RK817_POWER_EN_REG(2), ENABLE_MASK(2), | |
989 | DISABLE_VAL(2), 400), | |
990 | RK817_DESC(RK817_ID_LDO8, "LDO_REG8", "vcc7", 600, 3400, 25, | |
991 | RK817_LDO_ON_VSEL_REG(7), RK817_LDO_VSEL_MASK, | |
992 | RK817_POWER_EN_REG(2), ENABLE_MASK(3), | |
993 | DISABLE_VAL(3), 400), | |
994 | RK817_DESC(RK817_ID_LDO9, "LDO_REG9", "vcc7", 600, 3400, 25, | |
995 | RK817_LDO_ON_VSEL_REG(8), RK817_LDO_VSEL_MASK, | |
996 | RK817_POWER_EN_REG(3), ENABLE_MASK(0), | |
997 | DISABLE_VAL(0), 400), | |
998 | RK817_DESC_SWITCH(RK809_ID_SW1, "SWITCH_REG1", "vcc9", | |
999 | RK817_POWER_EN_REG(3), ENABLE_MASK(2), | |
1000 | DISABLE_VAL(2)), | |
1001 | RK817_DESC_SWITCH(RK809_ID_SW2, "SWITCH_REG2", "vcc8", | |
1002 | RK817_POWER_EN_REG(3), ENABLE_MASK(3), | |
1003 | DISABLE_VAL(3)), | |
1004 | }; | |
1005 | ||
1006 | static const struct regulator_desc rk817_reg[] = { | |
1007 | { | |
1008 | .name = "DCDC_REG1", | |
1009 | .supply_name = "vcc1", | |
1010 | .of_match = of_match_ptr("DCDC_REG1"), | |
1011 | .regulators_node = of_match_ptr("regulators"), | |
1012 | .id = RK817_ID_DCDC1, | |
1013 | .ops = &rk817_buck_ops_range, | |
1014 | .type = REGULATOR_VOLTAGE, | |
1015 | .n_voltages = RK817_BUCK1_SEL_CNT + 1, | |
1016 | .linear_ranges = rk817_buck1_voltage_ranges, | |
1017 | .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges), | |
1018 | .vsel_reg = RK817_BUCK1_ON_VSEL_REG, | |
1019 | .vsel_mask = RK817_BUCK_VSEL_MASK, | |
1020 | .enable_reg = RK817_POWER_EN_REG(0), | |
1021 | .enable_mask = ENABLE_MASK(RK817_ID_DCDC1), | |
1022 | .enable_val = ENABLE_MASK(RK817_ID_DCDC1), | |
1023 | .disable_val = DISABLE_VAL(RK817_ID_DCDC1), | |
f85ea494 AL |
1024 | .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC1), |
1025 | .ramp_mask = RK817_RAMP_RATE_MASK, | |
1026 | .ramp_delay_table = rk817_buck1_4_ramp_table, | |
1027 | .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table), | |
e444f6d6 HS |
1028 | .of_map_mode = rk8xx_regulator_of_map_mode, |
1029 | .owner = THIS_MODULE, | |
1030 | }, { | |
1031 | .name = "DCDC_REG2", | |
1032 | .supply_name = "vcc2", | |
1033 | .of_match = of_match_ptr("DCDC_REG2"), | |
1034 | .regulators_node = of_match_ptr("regulators"), | |
1035 | .id = RK817_ID_DCDC2, | |
1036 | .ops = &rk817_buck_ops_range, | |
1037 | .type = REGULATOR_VOLTAGE, | |
1038 | .n_voltages = RK817_BUCK1_SEL_CNT + 1, | |
1039 | .linear_ranges = rk817_buck1_voltage_ranges, | |
1040 | .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges), | |
1041 | .vsel_reg = RK817_BUCK2_ON_VSEL_REG, | |
1042 | .vsel_mask = RK817_BUCK_VSEL_MASK, | |
1043 | .enable_reg = RK817_POWER_EN_REG(0), | |
1044 | .enable_mask = ENABLE_MASK(RK817_ID_DCDC2), | |
1045 | .enable_val = ENABLE_MASK(RK817_ID_DCDC2), | |
1046 | .disable_val = DISABLE_VAL(RK817_ID_DCDC2), | |
f85ea494 AL |
1047 | .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC2), |
1048 | .ramp_mask = RK817_RAMP_RATE_MASK, | |
1049 | .ramp_delay_table = rk817_buck1_4_ramp_table, | |
1050 | .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table), | |
e444f6d6 HS |
1051 | .of_map_mode = rk8xx_regulator_of_map_mode, |
1052 | .owner = THIS_MODULE, | |
1053 | }, { | |
1054 | .name = "DCDC_REG3", | |
1055 | .supply_name = "vcc3", | |
1056 | .of_match = of_match_ptr("DCDC_REG3"), | |
1057 | .regulators_node = of_match_ptr("regulators"), | |
1058 | .id = RK817_ID_DCDC3, | |
1059 | .ops = &rk817_buck_ops_range, | |
1060 | .type = REGULATOR_VOLTAGE, | |
1061 | .n_voltages = RK817_BUCK1_SEL_CNT + 1, | |
1062 | .linear_ranges = rk817_buck1_voltage_ranges, | |
1063 | .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges), | |
1064 | .vsel_reg = RK817_BUCK3_ON_VSEL_REG, | |
1065 | .vsel_mask = RK817_BUCK_VSEL_MASK, | |
1066 | .enable_reg = RK817_POWER_EN_REG(0), | |
1067 | .enable_mask = ENABLE_MASK(RK817_ID_DCDC3), | |
1068 | .enable_val = ENABLE_MASK(RK817_ID_DCDC3), | |
1069 | .disable_val = DISABLE_VAL(RK817_ID_DCDC3), | |
f85ea494 AL |
1070 | .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC3), |
1071 | .ramp_mask = RK817_RAMP_RATE_MASK, | |
1072 | .ramp_delay_table = rk817_buck1_4_ramp_table, | |
1073 | .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table), | |
e444f6d6 HS |
1074 | .of_map_mode = rk8xx_regulator_of_map_mode, |
1075 | .owner = THIS_MODULE, | |
1076 | }, { | |
1077 | .name = "DCDC_REG4", | |
1078 | .supply_name = "vcc4", | |
1079 | .of_match = of_match_ptr("DCDC_REG4"), | |
1080 | .regulators_node = of_match_ptr("regulators"), | |
1081 | .id = RK817_ID_DCDC4, | |
1082 | .ops = &rk817_buck_ops_range, | |
1083 | .type = REGULATOR_VOLTAGE, | |
1084 | .n_voltages = RK817_BUCK3_SEL_CNT + 1, | |
1085 | .linear_ranges = rk817_buck3_voltage_ranges, | |
1086 | .n_linear_ranges = ARRAY_SIZE(rk817_buck3_voltage_ranges), | |
1087 | .vsel_reg = RK817_BUCK4_ON_VSEL_REG, | |
1088 | .vsel_mask = RK817_BUCK_VSEL_MASK, | |
1089 | .enable_reg = RK817_POWER_EN_REG(0), | |
1090 | .enable_mask = ENABLE_MASK(RK817_ID_DCDC4), | |
1091 | .enable_val = ENABLE_MASK(RK817_ID_DCDC4), | |
1092 | .disable_val = DISABLE_VAL(RK817_ID_DCDC4), | |
f85ea494 AL |
1093 | .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC4), |
1094 | .ramp_mask = RK817_RAMP_RATE_MASK, | |
1095 | .ramp_delay_table = rk817_buck1_4_ramp_table, | |
1096 | .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table), | |
e444f6d6 HS |
1097 | .of_map_mode = rk8xx_regulator_of_map_mode, |
1098 | .owner = THIS_MODULE, | |
1099 | }, | |
1100 | RK817_DESC(RK817_ID_LDO1, "LDO_REG1", "vcc5", 600, 3400, 25, | |
1101 | RK817_LDO_ON_VSEL_REG(0), RK817_LDO_VSEL_MASK, | |
1102 | RK817_POWER_EN_REG(1), ENABLE_MASK(0), | |
1103 | DISABLE_VAL(0), 400), | |
1104 | RK817_DESC(RK817_ID_LDO2, "LDO_REG2", "vcc5", 600, 3400, 25, | |
1105 | RK817_LDO_ON_VSEL_REG(1), RK817_LDO_VSEL_MASK, | |
1106 | RK817_POWER_EN_REG(1), ENABLE_MASK(1), | |
1107 | DISABLE_VAL(1), 400), | |
1108 | RK817_DESC(RK817_ID_LDO3, "LDO_REG3", "vcc5", 600, 3400, 25, | |
1109 | RK817_LDO_ON_VSEL_REG(2), RK817_LDO_VSEL_MASK, | |
1110 | RK817_POWER_EN_REG(1), ENABLE_MASK(2), | |
1111 | DISABLE_VAL(2), 400), | |
1112 | RK817_DESC(RK817_ID_LDO4, "LDO_REG4", "vcc6", 600, 3400, 25, | |
1113 | RK817_LDO_ON_VSEL_REG(3), RK817_LDO_VSEL_MASK, | |
1114 | RK817_POWER_EN_REG(1), ENABLE_MASK(3), | |
1115 | DISABLE_VAL(3), 400), | |
1116 | RK817_DESC(RK817_ID_LDO5, "LDO_REG5", "vcc6", 600, 3400, 25, | |
1117 | RK817_LDO_ON_VSEL_REG(4), RK817_LDO_VSEL_MASK, | |
1118 | RK817_POWER_EN_REG(2), ENABLE_MASK(0), | |
1119 | DISABLE_VAL(0), 400), | |
1120 | RK817_DESC(RK817_ID_LDO6, "LDO_REG6", "vcc6", 600, 3400, 25, | |
1121 | RK817_LDO_ON_VSEL_REG(5), RK817_LDO_VSEL_MASK, | |
1122 | RK817_POWER_EN_REG(2), ENABLE_MASK(1), | |
1123 | DISABLE_VAL(1), 400), | |
1124 | RK817_DESC(RK817_ID_LDO7, "LDO_REG7", "vcc7", 600, 3400, 25, | |
1125 | RK817_LDO_ON_VSEL_REG(6), RK817_LDO_VSEL_MASK, | |
1126 | RK817_POWER_EN_REG(2), ENABLE_MASK(2), | |
1127 | DISABLE_VAL(2), 400), | |
1128 | RK817_DESC(RK817_ID_LDO8, "LDO_REG8", "vcc7", 600, 3400, 25, | |
1129 | RK817_LDO_ON_VSEL_REG(7), RK817_LDO_VSEL_MASK, | |
1130 | RK817_POWER_EN_REG(2), ENABLE_MASK(3), | |
1131 | DISABLE_VAL(3), 400), | |
1132 | RK817_DESC(RK817_ID_LDO9, "LDO_REG9", "vcc7", 600, 3400, 25, | |
1133 | RK817_LDO_ON_VSEL_REG(8), RK817_LDO_VSEL_MASK, | |
1134 | RK817_POWER_EN_REG(3), ENABLE_MASK(0), | |
1135 | DISABLE_VAL(0), 400), | |
1136 | RK817_BOOST_DESC(RK817_ID_BOOST, "BOOST", "vcc8", 4700, 5400, 100, | |
1137 | RK817_BOOST_OTG_CFG, RK817_BOOST_VSEL_MASK, | |
1138 | RK817_POWER_EN_REG(3), ENABLE_MASK(1), ENABLE_MASK(1), | |
1139 | DISABLE_VAL(1), 400, 3500 - 5400), | |
1140 | RK817_DESC_SWITCH(RK817_ID_BOOST_OTG_SW, "OTG_SWITCH", "vcc9", | |
1141 | RK817_POWER_EN_REG(3), ENABLE_MASK(2), | |
1142 | DISABLE_VAL(2)), | |
1143 | }; | |
1144 | ||
11375293 WE |
1145 | static const struct regulator_desc rk818_reg[] = { |
1146 | { | |
1147 | .name = "DCDC_REG1", | |
1148 | .supply_name = "vcc1", | |
1149 | .of_match = of_match_ptr("DCDC_REG1"), | |
1150 | .regulators_node = of_match_ptr("regulators"), | |
1151 | .id = RK818_ID_DCDC1, | |
1152 | .ops = &rk808_reg_ops, | |
1153 | .type = REGULATOR_VOLTAGE, | |
1154 | .min_uV = 712500, | |
1155 | .uV_step = 12500, | |
1156 | .n_voltages = 64, | |
1157 | .vsel_reg = RK818_BUCK1_ON_VSEL_REG, | |
1158 | .vsel_mask = RK818_BUCK_VSEL_MASK, | |
1159 | .enable_reg = RK818_DCDC_EN_REG, | |
1160 | .enable_mask = BIT(0), | |
1161 | .owner = THIS_MODULE, | |
1162 | }, { | |
1163 | .name = "DCDC_REG2", | |
1164 | .supply_name = "vcc2", | |
1165 | .of_match = of_match_ptr("DCDC_REG2"), | |
1166 | .regulators_node = of_match_ptr("regulators"), | |
1167 | .id = RK818_ID_DCDC2, | |
1168 | .ops = &rk808_reg_ops, | |
1169 | .type = REGULATOR_VOLTAGE, | |
1170 | .min_uV = 712500, | |
1171 | .uV_step = 12500, | |
1172 | .n_voltages = 64, | |
1173 | .vsel_reg = RK818_BUCK2_ON_VSEL_REG, | |
1174 | .vsel_mask = RK818_BUCK_VSEL_MASK, | |
1175 | .enable_reg = RK818_DCDC_EN_REG, | |
1176 | .enable_mask = BIT(1), | |
1177 | .owner = THIS_MODULE, | |
1178 | }, { | |
1179 | .name = "DCDC_REG3", | |
1180 | .supply_name = "vcc3", | |
1181 | .of_match = of_match_ptr("DCDC_REG3"), | |
1182 | .regulators_node = of_match_ptr("regulators"), | |
1183 | .id = RK818_ID_DCDC3, | |
1184 | .ops = &rk808_switch_ops, | |
1185 | .type = REGULATOR_VOLTAGE, | |
1186 | .n_voltages = 1, | |
1187 | .enable_reg = RK818_DCDC_EN_REG, | |
1188 | .enable_mask = BIT(2), | |
1189 | .owner = THIS_MODULE, | |
1190 | }, | |
1191 | RK8XX_DESC(RK818_ID_DCDC4, "DCDC_REG4", "vcc4", 1800, 3600, 100, | |
1192 | RK818_BUCK4_ON_VSEL_REG, RK818_BUCK4_VSEL_MASK, | |
1193 | RK818_DCDC_EN_REG, BIT(3), 0), | |
1194 | RK8XX_DESC(RK818_ID_BOOST, "DCDC_BOOST", "boost", 4700, 5400, 100, | |
1195 | RK818_BOOST_LDO9_ON_VSEL_REG, RK818_BOOST_ON_VSEL_MASK, | |
1196 | RK818_DCDC_EN_REG, BIT(4), 0), | |
1197 | RK8XX_DESC(RK818_ID_LDO1, "LDO_REG1", "vcc6", 1800, 3400, 100, | |
1198 | RK818_LDO1_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG, | |
1199 | BIT(0), 400), | |
1200 | RK8XX_DESC(RK818_ID_LDO2, "LDO_REG2", "vcc6", 1800, 3400, 100, | |
75f88115 | 1201 | RK818_LDO2_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG, |
11375293 WE |
1202 | BIT(1), 400), |
1203 | { | |
1204 | .name = "LDO_REG3", | |
1205 | .supply_name = "vcc7", | |
1206 | .of_match = of_match_ptr("LDO_REG3"), | |
1207 | .regulators_node = of_match_ptr("regulators"), | |
1208 | .id = RK818_ID_LDO3, | |
1209 | .ops = &rk808_reg_ops_ranges, | |
1210 | .type = REGULATOR_VOLTAGE, | |
1211 | .n_voltages = 16, | |
1212 | .linear_ranges = rk808_ldo3_voltage_ranges, | |
1213 | .n_linear_ranges = ARRAY_SIZE(rk808_ldo3_voltage_ranges), | |
1214 | .vsel_reg = RK818_LDO3_ON_VSEL_REG, | |
1215 | .vsel_mask = RK818_LDO3_ON_VSEL_MASK, | |
1216 | .enable_reg = RK818_LDO_EN_REG, | |
1217 | .enable_mask = BIT(2), | |
1218 | .enable_time = 400, | |
1219 | .owner = THIS_MODULE, | |
1220 | }, | |
1221 | RK8XX_DESC(RK818_ID_LDO4, "LDO_REG4", "vcc8", 1800, 3400, 100, | |
1222 | RK818_LDO4_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG, | |
1223 | BIT(3), 400), | |
1224 | RK8XX_DESC(RK818_ID_LDO5, "LDO_REG5", "vcc7", 1800, 3400, 100, | |
1225 | RK818_LDO5_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG, | |
1226 | BIT(4), 400), | |
1227 | RK8XX_DESC(RK818_ID_LDO6, "LDO_REG6", "vcc8", 800, 2500, 100, | |
1228 | RK818_LDO6_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG, | |
1229 | BIT(5), 400), | |
1230 | RK8XX_DESC(RK818_ID_LDO7, "LDO_REG7", "vcc7", 800, 2500, 100, | |
1231 | RK818_LDO7_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG, | |
1232 | BIT(6), 400), | |
1233 | RK8XX_DESC(RK818_ID_LDO8, "LDO_REG8", "vcc8", 1800, 3400, 100, | |
1234 | RK818_LDO8_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG, | |
1235 | BIT(7), 400), | |
1236 | RK8XX_DESC(RK818_ID_LDO9, "LDO_REG9", "vcc9", 1800, 3400, 100, | |
1237 | RK818_BOOST_LDO9_ON_VSEL_REG, RK818_LDO_VSEL_MASK, | |
1238 | RK818_DCDC_EN_REG, BIT(5), 400), | |
1239 | RK8XX_DESC_SWITCH(RK818_ID_SWITCH, "SWITCH_REG", "vcc9", | |
1240 | RK818_DCDC_EN_REG, BIT(6)), | |
1241 | RK8XX_DESC_SWITCH(RK818_ID_HDMI_SWITCH, "HDMI_SWITCH", "h_5v", | |
1242 | RK818_H5V_EN_REG, BIT(0)), | |
1243 | RK8XX_DESC_SWITCH(RK818_ID_OTG_SWITCH, "OTG_SWITCH", "usb", | |
1244 | RK818_DCDC_EN_REG, BIT(7)), | |
1245 | }; | |
1246 | ||
bad47ad2 CZ |
1247 | static int rk808_regulator_dt_parse_pdata(struct device *dev, |
1248 | struct device *client_dev, | |
1249 | struct regmap *map, | |
1250 | struct rk808_regulator_data *pdata) | |
1251 | { | |
1252 | struct device_node *np; | |
9e9daa0a | 1253 | int tmp, ret = 0, i; |
bad47ad2 CZ |
1254 | |
1255 | np = of_get_child_by_name(client_dev->of_node, "regulators"); | |
1256 | if (!np) | |
1257 | return -ENXIO; | |
1258 | ||
bad47ad2 | 1259 | for (i = 0; i < ARRAY_SIZE(pdata->dvs_gpio); i++) { |
a13eaf02 UKK |
1260 | pdata->dvs_gpio[i] = |
1261 | devm_gpiod_get_index_optional(client_dev, "dvs", i, | |
1262 | GPIOD_OUT_LOW); | |
bad47ad2 | 1263 | if (IS_ERR(pdata->dvs_gpio[i])) { |
a13eaf02 UKK |
1264 | ret = PTR_ERR(pdata->dvs_gpio[i]); |
1265 | dev_err(dev, "failed to get dvs%d gpio (%d)\n", i, ret); | |
1266 | goto dt_parse_end; | |
1267 | } | |
1268 | ||
1269 | if (!pdata->dvs_gpio[i]) { | |
b8a039d3 | 1270 | dev_info(dev, "there is no dvs%d gpio\n", i); |
bad47ad2 CZ |
1271 | continue; |
1272 | } | |
1273 | ||
bad47ad2 CZ |
1274 | tmp = i ? RK808_DVS2_POL : RK808_DVS1_POL; |
1275 | ret = regmap_update_bits(map, RK808_IO_POL_REG, tmp, | |
1276 | gpiod_is_active_low(pdata->dvs_gpio[i]) ? | |
1277 | 0 : tmp); | |
1278 | } | |
1279 | ||
1280 | dt_parse_end: | |
1281 | of_node_put(np); | |
1282 | return ret; | |
1283 | } | |
1284 | ||
2cd64ae3 CZ |
1285 | static int rk808_regulator_probe(struct platform_device *pdev) |
1286 | { | |
1287 | struct rk808 *rk808 = dev_get_drvdata(pdev->dev.parent); | |
462004f1 | 1288 | struct regulator_config config = {}; |
2cd64ae3 | 1289 | struct regulator_dev *rk808_rdev; |
bad47ad2 | 1290 | struct rk808_regulator_data *pdata; |
11375293 | 1291 | const struct regulator_desc *regulators; |
647e5735 | 1292 | struct regmap *regmap; |
11375293 | 1293 | int ret, i, nregulators; |
2cd64ae3 | 1294 | |
647e5735 SR |
1295 | regmap = dev_get_regmap(pdev->dev.parent, NULL); |
1296 | if (!regmap) | |
1297 | return -ENODEV; | |
1298 | ||
bad47ad2 CZ |
1299 | pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); |
1300 | if (!pdata) | |
1301 | return -ENOMEM; | |
2cd64ae3 | 1302 | |
647e5735 SR |
1303 | ret = rk808_regulator_dt_parse_pdata(&pdev->dev, pdev->dev.parent, |
1304 | regmap, pdata); | |
571a4010 | 1305 | if (ret < 0) |
2cd64ae3 CZ |
1306 | return ret; |
1307 | ||
bad47ad2 CZ |
1308 | platform_set_drvdata(pdev, pdata); |
1309 | ||
11375293 | 1310 | switch (rk808->variant) { |
c4e0d344 EZ |
1311 | case RK805_ID: |
1312 | regulators = rk805_reg; | |
1313 | nregulators = RK805_NUM_REGULATORS; | |
1314 | break; | |
11375293 WE |
1315 | case RK808_ID: |
1316 | regulators = rk808_reg; | |
1317 | nregulators = RK808_NUM_REGULATORS; | |
1318 | break; | |
e444f6d6 HS |
1319 | case RK809_ID: |
1320 | regulators = rk809_reg; | |
1321 | nregulators = RK809_NUM_REGULATORS; | |
1322 | break; | |
1323 | case RK817_ID: | |
1324 | regulators = rk817_reg; | |
1325 | nregulators = RK817_NUM_REGULATORS; | |
1326 | break; | |
11375293 WE |
1327 | case RK818_ID: |
1328 | regulators = rk818_reg; | |
1329 | nregulators = RK818_NUM_REGULATORS; | |
1330 | break; | |
1331 | default: | |
647e5735 | 1332 | dev_err(&pdev->dev, "unsupported RK8XX ID %lu\n", |
11375293 WE |
1333 | rk808->variant); |
1334 | return -EINVAL; | |
1335 | } | |
1336 | ||
647e5735 SR |
1337 | config.dev = &pdev->dev; |
1338 | config.dev->of_node = pdev->dev.parent->of_node; | |
9e9daa0a | 1339 | config.driver_data = pdata; |
647e5735 | 1340 | config.regmap = regmap; |
9e9daa0a | 1341 | |
2cd64ae3 | 1342 | /* Instantiate the regulators */ |
11375293 | 1343 | for (i = 0; i < nregulators; i++) { |
2cd64ae3 | 1344 | rk808_rdev = devm_regulator_register(&pdev->dev, |
11375293 | 1345 | ®ulators[i], &config); |
f39f8709 SR |
1346 | if (IS_ERR(rk808_rdev)) |
1347 | return dev_err_probe(&pdev->dev, PTR_ERR(rk808_rdev), | |
1348 | "failed to register %d regulator\n", i); | |
2cd64ae3 | 1349 | } |
571a4010 | 1350 | |
2cd64ae3 CZ |
1351 | return 0; |
1352 | } | |
1353 | ||
1354 | static struct platform_driver rk808_regulator_driver = { | |
1355 | .probe = rk808_regulator_probe, | |
1356 | .driver = { | |
556ae220 | 1357 | .name = "rk808-regulator" |
2cd64ae3 CZ |
1358 | }, |
1359 | }; | |
1360 | ||
1361 | module_platform_driver(rk808_regulator_driver); | |
1362 | ||
a7567663 | 1363 | MODULE_DESCRIPTION("regulator driver for the RK805/RK808/RK818 series PMICs"); |
e444f6d6 | 1364 | MODULE_AUTHOR("Tony xie <tony.xie@rock-chips.com>"); |
11375293 WE |
1365 | MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>"); |
1366 | MODULE_AUTHOR("Zhang Qing <zhangqing@rock-chips.com>"); | |
1367 | MODULE_AUTHOR("Wadim Egorov <w.egorov@phytec.de>"); | |
2cd64ae3 CZ |
1368 | MODULE_LICENSE("GPL"); |
1369 | MODULE_ALIAS("platform:rk808-regulator"); |