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