1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Regulator driver for Rockchip RK80x and RK81x PMIC series
4 *
5 * Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd
6 * Copyright (c) 2021 Rockchip Electronics Co., Ltd.
7 *
8 * Author: Chris Zhong <zyw@rock-chips.com>
9 * Author: Zhang Qing <zhangqing@rock-chips.com>
10 * Author: Xu Shengfei <xsf@rock-chips.com>
11 *
12 * Copyright (C) 2016 PHYTEC Messtechnik GmbH
13 *
14 * Author: Wadim Egorov <w.egorov@phytec.de>
15 */
16
17 #include <linux/delay.h>
18 #include <linux/module.h>
19 #include <linux/of.h>
20 #include <linux/mfd/rk808.h>
21 #include <linux/platform_device.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 RK801_BUCK_VSEL_MASK 0x7f
28 #define RK801_LDO_VSEL_MASK 0x3f
29
30 #define RK808_BUCK_VSEL_MASK 0x3f
31 #define RK808_BUCK4_VSEL_MASK 0xf
32 #define RK808_LDO_VSEL_MASK 0x1f
33
34 #define RK809_BUCK5_VSEL_MASK 0x7
35
36 #define RK817_LDO_VSEL_MASK 0x7f
37 #define RK817_BOOST_VSEL_MASK 0x7
38 #define RK817_BUCK_VSEL_MASK 0x7f
39
40 #define RK818_BUCK_VSEL_MASK 0x3f
41 #define RK818_BUCK4_VSEL_MASK 0x1f
42 #define RK818_LDO_VSEL_MASK 0x1f
43 #define RK818_LDO3_ON_VSEL_MASK 0xf
44 #define RK818_BOOST_ON_VSEL_MASK 0xe0
45
46 #define RK806_DCDC_SLP_REG_OFFSET 0x0A
47 #define RK806_NLDO_SLP_REG_OFFSET 0x05
48 #define RK806_PLDO_SLP_REG_OFFSET 0x06
49
50 #define RK806_BUCK_SEL_CNT 0xff
51 #define RK806_LDO_SEL_CNT 0xff
52
53 /* Ramp rate definitions for buck1 / buck2 only */
54 #define RK808_RAMP_RATE_OFFSET 3
55 #define RK808_RAMP_RATE_MASK (3 << RK808_RAMP_RATE_OFFSET)
56 #define RK808_RAMP_RATE_2MV_PER_US (0 << RK808_RAMP_RATE_OFFSET)
57 #define RK808_RAMP_RATE_4MV_PER_US (1 << RK808_RAMP_RATE_OFFSET)
58 #define RK808_RAMP_RATE_6MV_PER_US (2 << RK808_RAMP_RATE_OFFSET)
59 #define RK808_RAMP_RATE_10MV_PER_US (3 << RK808_RAMP_RATE_OFFSET)
60
61 #define RK808_DVS2_POL BIT(2)
62 #define RK808_DVS1_POL BIT(1)
63
64 /* Offset from XXX_ON_VSEL to XXX_SLP_VSEL */
65 #define RK808_SLP_REG_OFFSET 1
66
67 /* Offset from XXX_ON_VSEL to XXX_DVS_VSEL */
68 #define RK808_DVS_REG_OFFSET 2
69
70 /* Offset from XXX_EN_REG to SLEEP_SET_OFF_XXX */
71 #define RK808_SLP_SET_OFF_REG_OFFSET 2
72
73 /* max steps for increase voltage of Buck1/2, equal 100mv*/
74 #define MAX_STEPS_ONE_TIME 8
75
76 #define ENABLE_MASK(id) (BIT(id) | BIT(4 + (id)))
77 #define DISABLE_VAL(id) (BIT(4 + (id)))
78
79 #define RK817_BOOST_DESC(_id, _match, _supply, _min, _max, _step, _vreg,\
80 _vmask, _ereg, _emask, _enval, _disval, _etime, m_drop) \
81 { \
82 .name = (_match), \
83 .supply_name = (_supply), \
84 .of_match = of_match_ptr(_match), \
85 .regulators_node = of_match_ptr("regulators"), \
86 .type = REGULATOR_VOLTAGE, \
87 .id = (_id), \
88 .n_voltages = (((_max) - (_min)) / (_step) + 1), \
89 .owner = THIS_MODULE, \
90 .min_uV = (_min) * 1000, \
91 .uV_step = (_step) * 1000, \
92 .vsel_reg = (_vreg), \
93 .vsel_mask = (_vmask), \
94 .enable_reg = (_ereg), \
95 .enable_mask = (_emask), \
96 .enable_val = (_enval), \
97 .disable_val = (_disval), \
98 .enable_time = (_etime), \
99 .min_dropout_uV = (m_drop) * 1000, \
100 .ops = &rk817_boost_ops, \
101 }
102
103 #define RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \
104 _vmask, _ereg, _emask, _enval, _disval, _etime, _ops) \
105 { \
106 .name = (_match), \
107 .supply_name = (_supply), \
108 .of_match = of_match_ptr(_match), \
109 .regulators_node = of_match_ptr("regulators"), \
110 .type = REGULATOR_VOLTAGE, \
111 .id = (_id), \
112 .n_voltages = (((_max) - (_min)) / (_step) + 1), \
113 .owner = THIS_MODULE, \
114 .min_uV = (_min) * 1000, \
115 .uV_step = (_step) * 1000, \
116 .vsel_reg = (_vreg), \
117 .vsel_mask = (_vmask), \
118 .enable_reg = (_ereg), \
119 .enable_mask = (_emask), \
120 .enable_val = (_enval), \
121 .disable_val = (_disval), \
122 .enable_time = (_etime), \
123 .ops = _ops, \
124 }
125
126 #define RK805_DESC(_id, _match, _supply, _min, _max, _step, _vreg, \
127 _vmask, _ereg, _emask, _etime) \
128 RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \
129 _vmask, _ereg, _emask, 0, 0, _etime, &rk805_reg_ops)
130
131 #define RK806_REGULATOR(_name, _supply_name, _id, _ops,\
132 _n_voltages, _vr, _er, _lr, ctrl_bit,\
133 _rr, _rm, _rt)\
134 [_id] = {\
135 .name = _name,\
136 .supply_name = _supply_name,\
137 .of_match = of_match_ptr(_name),\
138 .regulators_node = of_match_ptr("regulators"),\
139 .id = _id,\
140 .ops = &_ops,\
141 .type = REGULATOR_VOLTAGE,\
142 .n_voltages = _n_voltages,\
143 .linear_ranges = _lr,\
144 .n_linear_ranges = ARRAY_SIZE(_lr),\
145 .vsel_reg = _vr,\
146 .vsel_mask = 0xff,\
147 .enable_reg = _er,\
148 .enable_mask = ENABLE_MASK(ctrl_bit),\
149 .enable_val = ENABLE_MASK(ctrl_bit),\
150 .disable_val = DISABLE_VAL(ctrl_bit),\
151 .of_map_mode = rk8xx_regulator_of_map_mode,\
152 .ramp_reg = _rr,\
153 .ramp_mask = _rm,\
154 .ramp_delay_table = _rt, \
155 .n_ramp_values = ARRAY_SIZE(_rt), \
156 .owner = THIS_MODULE,\
157 }
158
159 #define RK8XX_DESC(_id, _match, _supply, _min, _max, _step, _vreg, \
160 _vmask, _ereg, _emask, _etime) \
161 RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \
162 _vmask, _ereg, _emask, 0, 0, _etime, &rk808_reg_ops)
163
164 #define RK801_DESC(_id, _match, _supply, _min, _max, _step, _vreg, \
165 _vmask, _ereg, _emask, _disval, _etime) \
166 RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \
167 _vmask, _ereg, _emask, _emask, _disval, _etime, &rk801_reg_ops)
168
169 #define RK816_DESC(_id, _match, _supply, _min, _max, _step, _vreg, \
170 _vmask, _ereg, _emask, _disval, _etime) \
171 RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \
172 _vmask, _ereg, _emask, _emask, _disval, _etime, &rk816_reg_ops)
173
174 #define RK817_DESC(_id, _match, _supply, _min, _max, _step, _vreg, \
175 _vmask, _ereg, _emask, _disval, _etime) \
176 RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \
177 _vmask, _ereg, _emask, _emask, _disval, _etime, &rk817_reg_ops)
178
179 #define RKXX_DESC_SWITCH_COM(_id, _match, _supply, _ereg, _emask, \
180 _enval, _disval, _ops) \
181 { \
182 .name = (_match), \
183 .supply_name = (_supply), \
184 .of_match = of_match_ptr(_match), \
185 .regulators_node = of_match_ptr("regulators"), \
186 .type = REGULATOR_VOLTAGE, \
187 .id = (_id), \
188 .enable_reg = (_ereg), \
189 .enable_mask = (_emask), \
190 .enable_val = (_enval), \
191 .disable_val = (_disval), \
192 .owner = THIS_MODULE, \
193 .ops = _ops \
194 }
195
196 #define RK801_DESC_SWITCH(_id, _match, _supply, _ereg, _emask, \
197 _disval) \
198 RKXX_DESC_SWITCH_COM(_id, _match, _supply, _ereg, _emask, \
199 _emask, _disval, &rk801_switch_ops)
200
201 #define RK817_DESC_SWITCH(_id, _match, _supply, _ereg, _emask, \
202 _disval) \
203 RKXX_DESC_SWITCH_COM(_id, _match, _supply, _ereg, _emask, \
204 _emask, _disval, &rk817_switch_ops)
205
206 #define RK8XX_DESC_SWITCH(_id, _match, _supply, _ereg, _emask) \
207 RKXX_DESC_SWITCH_COM(_id, _match, _supply, _ereg, _emask, \
208 0, 0, &rk808_switch_ops)
209
210 struct rk8xx_register_bit {
211 u8 reg;
212 u8 bit;
213 };
214
215 #define RK8XX_REG_BIT(_reg, _bit) \
216 { \
217 .reg = _reg, \
218 .bit = BIT(_bit), \
219 }
220
221 struct rk808_regulator_data {
222 struct gpio_desc *dvs_gpio[2];
223 };
224
225 static const struct linear_range rk808_ldo3_voltage_ranges[] = {
226 REGULATOR_LINEAR_RANGE(800000, 0, 13, 100000),
227 REGULATOR_LINEAR_RANGE(2500000, 15, 15, 0),
228 };
229
230 #define RK809_BUCK5_SEL_CNT (8)
231
232 static const struct linear_range rk809_buck5_voltage_ranges[] = {
233 REGULATOR_LINEAR_RANGE(1500000, 0, 0, 0),
234 REGULATOR_LINEAR_RANGE(1800000, 1, 3, 200000),
235 REGULATOR_LINEAR_RANGE(2800000, 4, 5, 200000),
236 REGULATOR_LINEAR_RANGE(3300000, 6, 7, 300000),
237 };
238
239 #define RK817_BUCK1_MIN0 500000
240 #define RK817_BUCK1_MAX0 1500000
241
242 #define RK817_BUCK1_MIN1 1600000
243 #define RK817_BUCK1_MAX1 2400000
244
245 #define RK817_BUCK3_MAX1 3400000
246
247 #define RK817_BUCK1_STP0 12500
248 #define RK817_BUCK1_STP1 100000
249
250 #define RK817_BUCK1_SEL0 ((RK817_BUCK1_MAX0 - RK817_BUCK1_MIN0) /\
251 RK817_BUCK1_STP0)
252 #define RK817_BUCK1_SEL1 ((RK817_BUCK1_MAX1 - RK817_BUCK1_MIN1) /\
253 RK817_BUCK1_STP1)
254
255 #define RK817_BUCK3_SEL1 ((RK817_BUCK3_MAX1 - RK817_BUCK1_MIN1) /\
256 RK817_BUCK1_STP1)
257
258 #define RK817_BUCK1_SEL_CNT (RK817_BUCK1_SEL0 + RK817_BUCK1_SEL1 + 1)
259 #define RK817_BUCK3_SEL_CNT (RK817_BUCK1_SEL0 + RK817_BUCK3_SEL1 + 1)
260
261 static const struct linear_range rk817_buck1_voltage_ranges[] = {
262 REGULATOR_LINEAR_RANGE(RK817_BUCK1_MIN0, 0,
263 RK817_BUCK1_SEL0, RK817_BUCK1_STP0),
264 REGULATOR_LINEAR_RANGE(RK817_BUCK1_MIN1, RK817_BUCK1_SEL0 + 1,
265 RK817_BUCK1_SEL_CNT, RK817_BUCK1_STP1),
266 };
267
268 static const struct linear_range rk817_buck3_voltage_ranges[] = {
269 REGULATOR_LINEAR_RANGE(RK817_BUCK1_MIN0, 0,
270 RK817_BUCK1_SEL0, RK817_BUCK1_STP0),
271 REGULATOR_LINEAR_RANGE(RK817_BUCK1_MIN1, RK817_BUCK1_SEL0 + 1,
272 RK817_BUCK3_SEL_CNT, RK817_BUCK1_STP1),
273 };
274
275 static const unsigned int rk808_buck1_2_ramp_table[] = {
276 2000, 4000, 6000, 10000
277 };
278
279 /* RK817/RK809/RK816 (buck 1/2 only) */
280 static const unsigned int rk817_buck1_4_ramp_table[] = {
281 3000, 6300, 12500, 25000
282 };
283
rk806_set_mode_dcdc(struct regulator_dev * rdev,unsigned int mode)284 static int rk806_set_mode_dcdc(struct regulator_dev *rdev, unsigned int mode)
285 {
286 unsigned int rid = rdev_get_id(rdev);
287 unsigned int ctr_bit, reg;
288
289 reg = RK806_POWER_FPWM_EN0 + rid / 8;
290 ctr_bit = rid % 8;
291
292 switch (mode) {
293 case REGULATOR_MODE_FAST:
294 return regmap_update_bits(rdev->regmap, reg,
295 PWM_MODE_MSK << ctr_bit,
296 FPWM_MODE << ctr_bit);
297 case REGULATOR_MODE_NORMAL:
298 return regmap_update_bits(rdev->regmap, reg,
299 PWM_MODE_MSK << ctr_bit,
300 AUTO_PWM_MODE << ctr_bit);
301 default:
302 dev_err(rdev_get_dev(rdev), "mode unsupported: %u\n", mode);
303 return -EINVAL;
304 }
305
306 return 0;
307 }
308
rk806_get_mode_dcdc(struct regulator_dev * rdev)309 static unsigned int rk806_get_mode_dcdc(struct regulator_dev *rdev)
310 {
311 int rid = rdev_get_id(rdev);
312 int ctr_bit, reg;
313 unsigned int val;
314 int err;
315
316 reg = RK806_POWER_FPWM_EN0 + rid / 8;
317 ctr_bit = rid % 8;
318
319 err = regmap_read(rdev->regmap, reg, &val);
320 if (err)
321 return err;
322
323 if ((val >> ctr_bit) & FPWM_MODE)
324 return REGULATOR_MODE_FAST;
325 else
326 return REGULATOR_MODE_NORMAL;
327 }
328
329 static const struct rk8xx_register_bit rk806_dcdc_rate2[] = {
330 RK8XX_REG_BIT(0xEB, 0),
331 RK8XX_REG_BIT(0xEB, 1),
332 RK8XX_REG_BIT(0xEB, 2),
333 RK8XX_REG_BIT(0xEB, 3),
334 RK8XX_REG_BIT(0xEB, 4),
335 RK8XX_REG_BIT(0xEB, 5),
336 RK8XX_REG_BIT(0xEB, 6),
337 RK8XX_REG_BIT(0xEB, 7),
338 RK8XX_REG_BIT(0xEA, 0),
339 RK8XX_REG_BIT(0xEA, 1),
340 };
341
342 static const unsigned int rk806_ramp_delay_table_dcdc[] = {
343 50000, 25000, 12500, 6250, 3125, 1560, 961, 390
344 };
345
rk806_set_ramp_delay_dcdc(struct regulator_dev * rdev,int ramp_delay)346 static int rk806_set_ramp_delay_dcdc(struct regulator_dev *rdev, int ramp_delay)
347 {
348 int rid = rdev_get_id(rdev);
349 int regval, ramp_value, ret;
350
351 ret = regulator_find_closest_bigger(ramp_delay, rdev->desc->ramp_delay_table,
352 rdev->desc->n_ramp_values, &ramp_value);
353 if (ret) {
354 dev_warn(rdev_get_dev(rdev),
355 "Can't set ramp-delay %u, setting %u\n", ramp_delay,
356 rdev->desc->ramp_delay_table[ramp_value]);
357 }
358
359 regval = ramp_value << (ffs(rdev->desc->ramp_mask) - 1);
360
361 ret = regmap_update_bits(rdev->regmap, rdev->desc->ramp_reg,
362 rdev->desc->ramp_mask, regval);
363 if (ret)
364 return ret;
365
366 /*
367 * The above is effectively a copy of regulator_set_ramp_delay_regmap(),
368 * but that only stores the lower 2 bits for rk806 DCDC ramp. The MSB must
369 * be stored in a separate register, so this open codes the implementation
370 * to have access to the ramp_value.
371 */
372
373 regval = (ramp_value >> 2) & 0x1 ? rk806_dcdc_rate2[rid].bit : 0;
374 return regmap_update_bits(rdev->regmap, rk806_dcdc_rate2[rid].reg,
375 rk806_dcdc_rate2[rid].bit,
376 regval);
377 }
378
379 static const unsigned int rk806_ramp_delay_table_ldo[] = {
380 100000, 50000, 25000, 12500, 6280, 3120, 1900, 780
381 };
382
rk806_set_suspend_voltage_range(struct regulator_dev * rdev,int reg_offset,int uv)383 static int rk806_set_suspend_voltage_range(struct regulator_dev *rdev, int reg_offset, int uv)
384 {
385 int sel = regulator_map_voltage_linear_range(rdev, uv, uv);
386 unsigned int reg;
387
388 if (sel < 0)
389 return -EINVAL;
390
391 reg = rdev->desc->vsel_reg + reg_offset;
392
393 return regmap_update_bits(rdev->regmap, reg, rdev->desc->vsel_mask, sel);
394 }
395
rk806_set_suspend_voltage_range_dcdc(struct regulator_dev * rdev,int uv)396 static int rk806_set_suspend_voltage_range_dcdc(struct regulator_dev *rdev, int uv)
397 {
398 return rk806_set_suspend_voltage_range(rdev, RK806_DCDC_SLP_REG_OFFSET, uv);
399 }
400
rk806_set_suspend_voltage_range_nldo(struct regulator_dev * rdev,int uv)401 static int rk806_set_suspend_voltage_range_nldo(struct regulator_dev *rdev, int uv)
402 {
403 return rk806_set_suspend_voltage_range(rdev, RK806_NLDO_SLP_REG_OFFSET, uv);
404 }
405
rk806_set_suspend_voltage_range_pldo(struct regulator_dev * rdev,int uv)406 static int rk806_set_suspend_voltage_range_pldo(struct regulator_dev *rdev, int uv)
407 {
408 return rk806_set_suspend_voltage_range(rdev, RK806_PLDO_SLP_REG_OFFSET, uv);
409 }
410
rk808_buck1_2_get_voltage_sel_regmap(struct regulator_dev * rdev)411 static int rk808_buck1_2_get_voltage_sel_regmap(struct regulator_dev *rdev)
412 {
413 struct rk808_regulator_data *pdata = rdev_get_drvdata(rdev);
414 int id = rdev_get_id(rdev);
415 struct gpio_desc *gpio = pdata->dvs_gpio[id];
416 unsigned int val;
417 int ret;
418
419 if (!gpio || gpiod_get_value(gpio) == 0)
420 return regulator_get_voltage_sel_regmap(rdev);
421
422 ret = regmap_read(rdev->regmap,
423 rdev->desc->vsel_reg + RK808_DVS_REG_OFFSET,
424 &val);
425 if (ret != 0)
426 return ret;
427
428 val &= rdev->desc->vsel_mask;
429 val >>= ffs(rdev->desc->vsel_mask) - 1;
430
431 return val;
432 }
433
rk808_buck1_2_i2c_set_voltage_sel(struct regulator_dev * rdev,unsigned sel)434 static int rk808_buck1_2_i2c_set_voltage_sel(struct regulator_dev *rdev,
435 unsigned sel)
436 {
437 int ret, delta_sel;
438 unsigned int old_sel, tmp, val, mask = rdev->desc->vsel_mask;
439
440 ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
441 if (ret != 0)
442 return ret;
443
444 tmp = val & ~mask;
445 old_sel = val & mask;
446 old_sel >>= ffs(mask) - 1;
447 delta_sel = sel - old_sel;
448
449 /*
450 * If directly modify the register to change the voltage, we will face
451 * the risk of overshoot. Put it into a multi-step, can effectively
452 * avoid this problem, a step is 100mv here.
453 */
454 while (delta_sel > MAX_STEPS_ONE_TIME) {
455 old_sel += MAX_STEPS_ONE_TIME;
456 val = old_sel << (ffs(mask) - 1);
457 val |= tmp;
458
459 /*
460 * i2c is 400kHz (2.5us per bit) and we must transmit _at least_
461 * 3 bytes (24 bits) plus start and stop so 26 bits. So we've
462 * got more than 65 us between each voltage change and thus
463 * won't ramp faster than ~1500 uV / us.
464 */
465 ret = regmap_write(rdev->regmap, rdev->desc->vsel_reg, val);
466 delta_sel = sel - old_sel;
467 }
468
469 sel <<= ffs(mask) - 1;
470 val = tmp | sel;
471 ret = regmap_write(rdev->regmap, rdev->desc->vsel_reg, val);
472
473 /*
474 * When we change the voltage register directly, the ramp rate is about
475 * 100000uv/us, wait 1us to make sure the target voltage to be stable,
476 * so we needn't wait extra time after that.
477 */
478 udelay(1);
479
480 return ret;
481 }
482
rk808_buck1_2_set_voltage_sel(struct regulator_dev * rdev,unsigned sel)483 static int rk808_buck1_2_set_voltage_sel(struct regulator_dev *rdev,
484 unsigned sel)
485 {
486 struct rk808_regulator_data *pdata = rdev_get_drvdata(rdev);
487 int id = rdev_get_id(rdev);
488 struct gpio_desc *gpio = pdata->dvs_gpio[id];
489 unsigned int reg = rdev->desc->vsel_reg;
490 unsigned old_sel;
491 int ret, gpio_level;
492
493 if (!gpio)
494 return rk808_buck1_2_i2c_set_voltage_sel(rdev, sel);
495
496 gpio_level = gpiod_get_value(gpio);
497 if (gpio_level == 0) {
498 reg += RK808_DVS_REG_OFFSET;
499 ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &old_sel);
500 } else {
501 ret = regmap_read(rdev->regmap,
502 reg + RK808_DVS_REG_OFFSET,
503 &old_sel);
504 }
505
506 if (ret != 0)
507 return ret;
508
509 sel <<= ffs(rdev->desc->vsel_mask) - 1;
510 sel |= old_sel & ~rdev->desc->vsel_mask;
511
512 ret = regmap_write(rdev->regmap, reg, sel);
513 if (ret)
514 return ret;
515
516 gpiod_set_value(gpio, !gpio_level);
517
518 return ret;
519 }
520
rk808_buck1_2_set_voltage_time_sel(struct regulator_dev * rdev,unsigned int old_selector,unsigned int new_selector)521 static int rk808_buck1_2_set_voltage_time_sel(struct regulator_dev *rdev,
522 unsigned int old_selector,
523 unsigned int new_selector)
524 {
525 struct rk808_regulator_data *pdata = rdev_get_drvdata(rdev);
526 int id = rdev_get_id(rdev);
527 struct gpio_desc *gpio = pdata->dvs_gpio[id];
528
529 /* if there is no dvs1/2 pin, we don't need wait extra time here. */
530 if (!gpio)
531 return 0;
532
533 return regulator_set_voltage_time_sel(rdev, old_selector, new_selector);
534 }
535
rk808_set_suspend_voltage(struct regulator_dev * rdev,int uv)536 static int rk808_set_suspend_voltage(struct regulator_dev *rdev, int uv)
537 {
538 unsigned int reg;
539 int sel = regulator_map_voltage_linear(rdev, uv, uv);
540
541 if (sel < 0)
542 return -EINVAL;
543
544 reg = rdev->desc->vsel_reg + RK808_SLP_REG_OFFSET;
545
546 return regmap_update_bits(rdev->regmap, reg,
547 rdev->desc->vsel_mask,
548 sel);
549 }
550
rk808_set_suspend_voltage_range(struct regulator_dev * rdev,int uv)551 static int rk808_set_suspend_voltage_range(struct regulator_dev *rdev, int uv)
552 {
553 unsigned int reg;
554 int sel = regulator_map_voltage_linear_range(rdev, uv, uv);
555 int ret;
556
557 if (sel < 0)
558 return -EINVAL;
559
560 reg = rdev->desc->vsel_reg + RK808_SLP_REG_OFFSET;
561
562 ret = regmap_update_bits(rdev->regmap, reg,
563 rdev->desc->vsel_mask,
564 sel);
565 if (ret)
566 return ret;
567
568 if (rdev->desc->apply_bit)
569 ret = regmap_update_bits(rdev->regmap, rdev->desc->apply_reg,
570 rdev->desc->apply_bit,
571 rdev->desc->apply_bit);
572
573 return ret;
574 }
575
rk805_set_suspend_enable(struct regulator_dev * rdev)576 static int rk805_set_suspend_enable(struct regulator_dev *rdev)
577 {
578 unsigned int reg;
579
580 reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET;
581
582 return regmap_update_bits(rdev->regmap, reg,
583 rdev->desc->enable_mask,
584 rdev->desc->enable_mask);
585 }
586
rk805_set_suspend_disable(struct regulator_dev * rdev)587 static int rk805_set_suspend_disable(struct regulator_dev *rdev)
588 {
589 unsigned int reg;
590
591 reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET;
592
593 return regmap_update_bits(rdev->regmap, reg,
594 rdev->desc->enable_mask,
595 0);
596 }
597
598 static const struct rk8xx_register_bit rk806_suspend_bits[] = {
599 RK8XX_REG_BIT(RK806_POWER_SLP_EN0, 0),
600 RK8XX_REG_BIT(RK806_POWER_SLP_EN0, 1),
601 RK8XX_REG_BIT(RK806_POWER_SLP_EN0, 2),
602 RK8XX_REG_BIT(RK806_POWER_SLP_EN0, 3),
603 RK8XX_REG_BIT(RK806_POWER_SLP_EN0, 4),
604 RK8XX_REG_BIT(RK806_POWER_SLP_EN0, 5),
605 RK8XX_REG_BIT(RK806_POWER_SLP_EN0, 6),
606 RK8XX_REG_BIT(RK806_POWER_SLP_EN0, 7),
607 RK8XX_REG_BIT(RK806_POWER_SLP_EN1, 6),
608 RK8XX_REG_BIT(RK806_POWER_SLP_EN1, 7),
609 RK8XX_REG_BIT(RK806_POWER_SLP_EN1, 0),
610 RK8XX_REG_BIT(RK806_POWER_SLP_EN1, 1),
611 RK8XX_REG_BIT(RK806_POWER_SLP_EN1, 2),
612 RK8XX_REG_BIT(RK806_POWER_SLP_EN1, 3),
613 RK8XX_REG_BIT(RK806_POWER_SLP_EN1, 4),
614 RK8XX_REG_BIT(RK806_POWER_SLP_EN2, 1),
615 RK8XX_REG_BIT(RK806_POWER_SLP_EN2, 2),
616 RK8XX_REG_BIT(RK806_POWER_SLP_EN2, 3),
617 RK8XX_REG_BIT(RK806_POWER_SLP_EN2, 4),
618 RK8XX_REG_BIT(RK806_POWER_SLP_EN2, 5),
619 RK8XX_REG_BIT(RK806_POWER_SLP_EN2, 0),
620 };
621
rk806_set_suspend_enable(struct regulator_dev * rdev)622 static int rk806_set_suspend_enable(struct regulator_dev *rdev)
623 {
624 int rid = rdev_get_id(rdev);
625
626 return regmap_update_bits(rdev->regmap, rk806_suspend_bits[rid].reg,
627 rk806_suspend_bits[rid].bit,
628 rk806_suspend_bits[rid].bit);
629 }
630
rk806_set_suspend_disable(struct regulator_dev * rdev)631 static int rk806_set_suspend_disable(struct regulator_dev *rdev)
632 {
633 int rid = rdev_get_id(rdev);
634
635 return regmap_update_bits(rdev->regmap, rk806_suspend_bits[rid].reg,
636 rk806_suspend_bits[rid].bit, 0);
637 }
638
rk808_set_suspend_enable(struct regulator_dev * rdev)639 static int rk808_set_suspend_enable(struct regulator_dev *rdev)
640 {
641 unsigned int reg;
642
643 reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET;
644
645 return regmap_update_bits(rdev->regmap, reg,
646 rdev->desc->enable_mask,
647 0);
648 }
649
rk808_set_suspend_disable(struct regulator_dev * rdev)650 static int rk808_set_suspend_disable(struct regulator_dev *rdev)
651 {
652 unsigned int reg;
653
654 reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET;
655
656 return regmap_update_bits(rdev->regmap, reg,
657 rdev->desc->enable_mask,
658 rdev->desc->enable_mask);
659 }
660
661 static const struct rk8xx_register_bit rk816_suspend_bits[] = {
662 RK8XX_REG_BIT(RK818_SLEEP_SET_OFF_REG1, 0),
663 RK8XX_REG_BIT(RK818_SLEEP_SET_OFF_REG1, 1),
664 RK8XX_REG_BIT(RK818_SLEEP_SET_OFF_REG1, 2),
665 RK8XX_REG_BIT(RK818_SLEEP_SET_OFF_REG1, 3),
666 RK8XX_REG_BIT(RK818_SLEEP_SET_OFF_REG2, 0),
667 RK8XX_REG_BIT(RK818_SLEEP_SET_OFF_REG2, 1),
668 RK8XX_REG_BIT(RK818_SLEEP_SET_OFF_REG2, 2),
669 RK8XX_REG_BIT(RK818_SLEEP_SET_OFF_REG2, 3),
670 RK8XX_REG_BIT(RK818_SLEEP_SET_OFF_REG2, 4),
671 RK8XX_REG_BIT(RK818_SLEEP_SET_OFF_REG2, 5),
672 RK8XX_REG_BIT(RK818_SLEEP_SET_OFF_REG1, 5),
673 RK8XX_REG_BIT(RK818_SLEEP_SET_OFF_REG1, 6),
674 };
675
rk816_set_suspend_enable(struct regulator_dev * rdev)676 static int rk816_set_suspend_enable(struct regulator_dev *rdev)
677 {
678 int rid = rdev_get_id(rdev);
679
680 return regmap_update_bits(rdev->regmap, rk816_suspend_bits[rid].reg,
681 rk816_suspend_bits[rid].bit,
682 rk816_suspend_bits[rid].bit);
683 }
684
rk816_set_suspend_disable(struct regulator_dev * rdev)685 static int rk816_set_suspend_disable(struct regulator_dev *rdev)
686 {
687 int rid = rdev_get_id(rdev);
688
689 return regmap_update_bits(rdev->regmap, rk816_suspend_bits[rid].reg,
690 rk816_suspend_bits[rid].bit, 0);
691 }
692
rk817_set_suspend_enable_ctrl(struct regulator_dev * rdev,unsigned int en)693 static int rk817_set_suspend_enable_ctrl(struct regulator_dev *rdev,
694 unsigned int en)
695 {
696 unsigned int reg;
697 int id = rdev_get_id(rdev);
698 unsigned int id_slp, msk, val;
699
700 if (id >= RK817_ID_DCDC1 && id <= RK817_ID_DCDC4)
701 id_slp = id;
702 else if (id >= RK817_ID_LDO1 && id <= RK817_ID_LDO8)
703 id_slp = 8 + (id - RK817_ID_LDO1);
704 else if (id >= RK817_ID_LDO9 && id <= RK809_ID_SW2)
705 id_slp = 4 + (id - RK817_ID_LDO9);
706 else
707 return -EINVAL;
708
709 reg = RK817_POWER_SLP_EN_REG(id_slp / 8);
710
711 msk = BIT(id_slp % 8);
712 if (en)
713 val = msk;
714 else
715 val = 0;
716
717 return regmap_update_bits(rdev->regmap, reg, msk, val);
718 }
719
rk817_set_suspend_enable(struct regulator_dev * rdev)720 static int rk817_set_suspend_enable(struct regulator_dev *rdev)
721 {
722 return rk817_set_suspend_enable_ctrl(rdev, 1);
723 }
724
rk817_set_suspend_disable(struct regulator_dev * rdev)725 static int rk817_set_suspend_disable(struct regulator_dev *rdev)
726 {
727 return rk817_set_suspend_enable_ctrl(rdev, 0);
728 }
729
rk8xx_set_suspend_mode(struct regulator_dev * rdev,unsigned int mode)730 static int rk8xx_set_suspend_mode(struct regulator_dev *rdev, unsigned int mode)
731 {
732 unsigned int reg;
733
734 reg = rdev->desc->vsel_reg + RK808_SLP_REG_OFFSET;
735
736 switch (mode) {
737 case REGULATOR_MODE_FAST:
738 return regmap_update_bits(rdev->regmap, reg,
739 PWM_MODE_MSK, FPWM_MODE);
740 case REGULATOR_MODE_NORMAL:
741 return regmap_update_bits(rdev->regmap, reg,
742 PWM_MODE_MSK, AUTO_PWM_MODE);
743 default:
744 dev_err(&rdev->dev, "do not support this mode\n");
745 return -EINVAL;
746 }
747
748 return 0;
749 }
750
rk8xx_set_mode(struct regulator_dev * rdev,unsigned int mode)751 static int rk8xx_set_mode(struct regulator_dev *rdev, unsigned int mode)
752 {
753 switch (mode) {
754 case REGULATOR_MODE_FAST:
755 return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
756 PWM_MODE_MSK, FPWM_MODE);
757 case REGULATOR_MODE_NORMAL:
758 return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
759 PWM_MODE_MSK, AUTO_PWM_MODE);
760 default:
761 dev_err(&rdev->dev, "do not support this mode\n");
762 return -EINVAL;
763 }
764
765 return 0;
766 }
767
rk8xx_get_mode(struct regulator_dev * rdev)768 static unsigned int rk8xx_get_mode(struct regulator_dev *rdev)
769 {
770 unsigned int val;
771 int err;
772
773 err = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
774 if (err)
775 return err;
776
777 if (val & FPWM_MODE)
778 return REGULATOR_MODE_FAST;
779 else
780 return REGULATOR_MODE_NORMAL;
781 }
782
rk8xx_is_enabled_wmsk_regmap(struct regulator_dev * rdev)783 static int rk8xx_is_enabled_wmsk_regmap(struct regulator_dev *rdev)
784 {
785 unsigned int val;
786 int ret;
787
788 ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
789 if (ret != 0)
790 return ret;
791
792 /* add write mask bit */
793 val |= (rdev->desc->enable_mask & 0xf0);
794 val &= rdev->desc->enable_mask;
795
796 if (rdev->desc->enable_is_inverted) {
797 if (rdev->desc->enable_val)
798 return val != rdev->desc->enable_val;
799 return (val == 0);
800 }
801 if (rdev->desc->enable_val)
802 return val == rdev->desc->enable_val;
803 return val != 0;
804 }
805
rk8xx_regulator_of_map_mode(unsigned int mode)806 static unsigned int rk8xx_regulator_of_map_mode(unsigned int mode)
807 {
808 switch (mode) {
809 case 1:
810 return REGULATOR_MODE_FAST;
811 case 2:
812 return REGULATOR_MODE_NORMAL;
813 default:
814 return REGULATOR_MODE_INVALID;
815 }
816 }
817
rk801_get_mode(struct regulator_dev * rdev)818 static unsigned int rk801_get_mode(struct regulator_dev *rdev)
819 {
820 unsigned int val;
821 int err;
822
823 err = regmap_read(rdev->regmap, RK801_POWER_FPWM_EN_REG, &val);
824 if (err)
825 return err;
826
827 if (val & BIT(rdev->desc->id))
828 return REGULATOR_MODE_FAST;
829 else
830 return REGULATOR_MODE_NORMAL;
831 }
832
rk801_set_mode(struct regulator_dev * rdev,unsigned int mode)833 static int rk801_set_mode(struct regulator_dev *rdev, unsigned int mode)
834 {
835 unsigned int offset = rdev->desc->id;
836
837 switch (mode) {
838 case REGULATOR_MODE_FAST:
839 return regmap_update_bits(rdev->regmap, RK801_POWER_FPWM_EN_REG,
840 BIT(offset), RK801_FPWM_MODE << offset);
841 case REGULATOR_MODE_NORMAL:
842 return regmap_update_bits(rdev->regmap, RK801_POWER_FPWM_EN_REG,
843 BIT(offset), RK801_AUTO_PWM_MODE << offset);
844 default:
845 dev_err(&rdev->dev, "do not support this mode\n");
846 return -EINVAL;
847 }
848
849 return 0;
850 }
851
rk801_set_suspend_voltage(struct regulator_dev * rdev,int uv)852 static int rk801_set_suspend_voltage(struct regulator_dev *rdev, int uv)
853 {
854 unsigned int reg;
855 int sel;
856
857 if (rdev->desc->id < RK801_ID_LDO1)
858 sel = regulator_map_voltage_linear_range(rdev, uv, uv);
859 else
860 sel = regulator_map_voltage_linear(rdev, uv, uv);
861 if (sel < 0)
862 return -EINVAL;
863
864 reg = rdev->desc->vsel_reg + RK801_SLP_REG_OFFSET;
865
866 return regmap_update_bits(rdev->regmap, reg,
867 rdev->desc->vsel_mask, sel);
868 }
869
rk801_set_suspend_enable(struct regulator_dev * rdev)870 static int rk801_set_suspend_enable(struct regulator_dev *rdev)
871 {
872 return regmap_update_bits(rdev->regmap, RK801_POWER_SLP_EN_REG,
873 BIT(rdev->desc->id), BIT(rdev->desc->id));
874 }
875
rk801_set_suspend_disable(struct regulator_dev * rdev)876 static int rk801_set_suspend_disable(struct regulator_dev *rdev)
877 {
878 return regmap_update_bits(rdev->regmap, RK801_POWER_SLP_EN_REG,
879 BIT(rdev->desc->id), 0);
880 }
881
rk801_set_voltage_time_sel(struct regulator_dev * rdev,unsigned int old_selector,unsigned int new_selector)882 static int rk801_set_voltage_time_sel(struct regulator_dev *rdev,
883 unsigned int old_selector,
884 unsigned int new_selector)
885 {
886 return regulator_set_voltage_time_sel(rdev, old_selector,
887 new_selector) + RK801_HW_SYNC_US;
888 }
889
890 static const struct regulator_ops rk801_buck_ops = {
891 .list_voltage = regulator_list_voltage_linear_range,
892 .map_voltage = regulator_map_voltage_linear_range,
893 .get_voltage_sel = regulator_get_voltage_sel_regmap,
894 .set_voltage_sel = regulator_set_voltage_sel_regmap,
895 .set_voltage_time_sel = rk801_set_voltage_time_sel,
896 .enable = regulator_enable_regmap,
897 .disable = regulator_disable_regmap,
898 .is_enabled = regulator_is_enabled_regmap,
899 .set_mode = rk801_set_mode,
900 .get_mode = rk801_get_mode,
901 .set_suspend_voltage = rk801_set_suspend_voltage,
902 .set_suspend_enable = rk801_set_suspend_enable,
903 .set_suspend_disable = rk801_set_suspend_disable,
904 };
905
906 static const struct regulator_ops rk801_reg_ops = {
907 .list_voltage = regulator_list_voltage_linear,
908 .map_voltage = regulator_map_voltage_linear,
909 .get_voltage_sel = regulator_get_voltage_sel_regmap,
910 .set_voltage_sel = regulator_set_voltage_sel_regmap,
911 .enable = regulator_enable_regmap,
912 .disable = regulator_disable_regmap,
913 .is_enabled = regulator_is_enabled_regmap,
914 .set_suspend_voltage = rk801_set_suspend_voltage,
915 .set_suspend_enable = rk801_set_suspend_enable,
916 .set_suspend_disable = rk801_set_suspend_disable,
917 };
918
919 static const struct regulator_ops rk801_switch_ops = {
920 .enable = regulator_enable_regmap,
921 .disable = regulator_disable_regmap,
922 .is_enabled = regulator_is_enabled_regmap,
923 .set_suspend_enable = rk801_set_suspend_enable,
924 .set_suspend_disable = rk801_set_suspend_disable,
925 };
926
927 static const struct regulator_ops rk805_reg_ops = {
928 .list_voltage = regulator_list_voltage_linear,
929 .map_voltage = regulator_map_voltage_linear,
930 .get_voltage_sel = regulator_get_voltage_sel_regmap,
931 .set_voltage_sel = regulator_set_voltage_sel_regmap,
932 .enable = regulator_enable_regmap,
933 .disable = regulator_disable_regmap,
934 .is_enabled = regulator_is_enabled_regmap,
935 .set_suspend_voltage = rk808_set_suspend_voltage,
936 .set_suspend_enable = rk805_set_suspend_enable,
937 .set_suspend_disable = rk805_set_suspend_disable,
938 };
939
940 static const struct regulator_ops rk805_switch_ops = {
941 .enable = regulator_enable_regmap,
942 .disable = regulator_disable_regmap,
943 .is_enabled = regulator_is_enabled_regmap,
944 .set_suspend_enable = rk805_set_suspend_enable,
945 .set_suspend_disable = rk805_set_suspend_disable,
946 };
947
948 static const struct regulator_ops rk806_ops_dcdc = {
949 .list_voltage = regulator_list_voltage_linear_range,
950 .map_voltage = regulator_map_voltage_linear_range,
951 .get_voltage_sel = regulator_get_voltage_sel_regmap,
952 .set_voltage_sel = regulator_set_voltage_sel_regmap,
953 .set_voltage_time_sel = regulator_set_voltage_time_sel,
954 .set_mode = rk806_set_mode_dcdc,
955 .get_mode = rk806_get_mode_dcdc,
956
957 .enable = regulator_enable_regmap,
958 .disable = regulator_disable_regmap,
959 .is_enabled = rk8xx_is_enabled_wmsk_regmap,
960
961 .set_suspend_mode = rk806_set_mode_dcdc,
962 .set_ramp_delay = rk806_set_ramp_delay_dcdc,
963
964 .set_suspend_voltage = rk806_set_suspend_voltage_range_dcdc,
965 .set_suspend_enable = rk806_set_suspend_enable,
966 .set_suspend_disable = rk806_set_suspend_disable,
967 };
968
969 static const struct regulator_ops rk806_ops_nldo = {
970 .list_voltage = regulator_list_voltage_linear_range,
971 .map_voltage = regulator_map_voltage_linear_range,
972 .get_voltage_sel = regulator_get_voltage_sel_regmap,
973 .set_voltage_sel = regulator_set_voltage_sel_regmap,
974 .set_voltage_time_sel = regulator_set_voltage_time_sel,
975
976 .enable = regulator_enable_regmap,
977 .disable = regulator_disable_regmap,
978 .is_enabled = regulator_is_enabled_regmap,
979
980 .set_ramp_delay = regulator_set_ramp_delay_regmap,
981
982 .set_suspend_voltage = rk806_set_suspend_voltage_range_nldo,
983 .set_suspend_enable = rk806_set_suspend_enable,
984 .set_suspend_disable = rk806_set_suspend_disable,
985 };
986
987 static const struct regulator_ops rk806_ops_pldo = {
988 .list_voltage = regulator_list_voltage_linear_range,
989 .map_voltage = regulator_map_voltage_linear_range,
990
991 .get_voltage_sel = regulator_get_voltage_sel_regmap,
992 .set_voltage_sel = regulator_set_voltage_sel_regmap,
993 .set_voltage_time_sel = regulator_set_voltage_time_sel,
994
995 .enable = regulator_enable_regmap,
996 .disable = regulator_disable_regmap,
997 .is_enabled = regulator_is_enabled_regmap,
998
999 .set_ramp_delay = regulator_set_ramp_delay_regmap,
1000
1001 .set_suspend_voltage = rk806_set_suspend_voltage_range_pldo,
1002 .set_suspend_enable = rk806_set_suspend_enable,
1003 .set_suspend_disable = rk806_set_suspend_disable,
1004 };
1005
1006 static const struct regulator_ops rk808_buck1_2_ops = {
1007 .list_voltage = regulator_list_voltage_linear,
1008 .map_voltage = regulator_map_voltage_linear,
1009 .get_voltage_sel = rk808_buck1_2_get_voltage_sel_regmap,
1010 .set_voltage_sel = rk808_buck1_2_set_voltage_sel,
1011 .set_voltage_time_sel = rk808_buck1_2_set_voltage_time_sel,
1012 .enable = regulator_enable_regmap,
1013 .disable = regulator_disable_regmap,
1014 .is_enabled = regulator_is_enabled_regmap,
1015 .set_ramp_delay = regulator_set_ramp_delay_regmap,
1016 .set_suspend_voltage = rk808_set_suspend_voltage,
1017 .set_suspend_enable = rk808_set_suspend_enable,
1018 .set_suspend_disable = rk808_set_suspend_disable,
1019 };
1020
1021 static const struct regulator_ops rk808_reg_ops = {
1022 .list_voltage = regulator_list_voltage_linear,
1023 .map_voltage = regulator_map_voltage_linear,
1024 .get_voltage_sel = regulator_get_voltage_sel_regmap,
1025 .set_voltage_sel = regulator_set_voltage_sel_regmap,
1026 .enable = regulator_enable_regmap,
1027 .disable = regulator_disable_regmap,
1028 .is_enabled = regulator_is_enabled_regmap,
1029 .set_suspend_voltage = rk808_set_suspend_voltage,
1030 .set_suspend_enable = rk808_set_suspend_enable,
1031 .set_suspend_disable = rk808_set_suspend_disable,
1032 };
1033
1034 static const struct regulator_ops rk808_reg_ops_ranges = {
1035 .list_voltage = regulator_list_voltage_linear_range,
1036 .map_voltage = regulator_map_voltage_linear_range,
1037 .get_voltage_sel = regulator_get_voltage_sel_regmap,
1038 .set_voltage_sel = regulator_set_voltage_sel_regmap,
1039 .enable = regulator_enable_regmap,
1040 .disable = regulator_disable_regmap,
1041 .is_enabled = regulator_is_enabled_regmap,
1042 .set_suspend_voltage = rk808_set_suspend_voltage_range,
1043 .set_suspend_enable = rk808_set_suspend_enable,
1044 .set_suspend_disable = rk808_set_suspend_disable,
1045 };
1046
1047 static const struct regulator_ops rk808_switch_ops = {
1048 .enable = regulator_enable_regmap,
1049 .disable = regulator_disable_regmap,
1050 .is_enabled = regulator_is_enabled_regmap,
1051 .set_suspend_enable = rk808_set_suspend_enable,
1052 .set_suspend_disable = rk808_set_suspend_disable,
1053 };
1054
1055 static const struct linear_range rk805_buck_1_2_voltage_ranges[] = {
1056 REGULATOR_LINEAR_RANGE(712500, 0, 59, 12500),
1057 REGULATOR_LINEAR_RANGE(1800000, 60, 62, 200000),
1058 REGULATOR_LINEAR_RANGE(2300000, 63, 63, 0),
1059 };
1060
1061 static const struct regulator_ops rk809_buck5_ops_range = {
1062 .list_voltage = regulator_list_voltage_linear_range,
1063 .map_voltage = regulator_map_voltage_linear_range,
1064 .get_voltage_sel = regulator_get_voltage_sel_regmap,
1065 .set_voltage_sel = regulator_set_voltage_sel_regmap,
1066 .set_voltage_time_sel = regulator_set_voltage_time_sel,
1067 .enable = regulator_enable_regmap,
1068 .disable = regulator_disable_regmap,
1069 .is_enabled = rk8xx_is_enabled_wmsk_regmap,
1070 .set_suspend_voltage = rk808_set_suspend_voltage_range,
1071 .set_suspend_enable = rk817_set_suspend_enable,
1072 .set_suspend_disable = rk817_set_suspend_disable,
1073 };
1074
1075 static const struct regulator_ops rk816_buck1_2_ops_ranges = {
1076 .list_voltage = regulator_list_voltage_linear_range,
1077 .map_voltage = regulator_map_voltage_linear_range,
1078 .get_voltage_sel = regulator_get_voltage_sel_regmap,
1079 .set_voltage_sel = regulator_set_voltage_sel_regmap,
1080 .set_voltage_time_sel = regulator_set_voltage_time_sel,
1081 .enable = regulator_enable_regmap,
1082 .disable = regulator_disable_regmap,
1083 .is_enabled = regulator_is_enabled_regmap,
1084 .set_mode = rk8xx_set_mode,
1085 .get_mode = rk8xx_get_mode,
1086 .set_suspend_mode = rk8xx_set_suspend_mode,
1087 .set_ramp_delay = regulator_set_ramp_delay_regmap,
1088 .set_suspend_voltage = rk808_set_suspend_voltage_range,
1089 .set_suspend_enable = rk816_set_suspend_enable,
1090 .set_suspend_disable = rk816_set_suspend_disable,
1091 };
1092
1093 static const struct regulator_ops rk816_buck4_ops_ranges = {
1094 .list_voltage = regulator_list_voltage_linear_range,
1095 .map_voltage = regulator_map_voltage_linear_range,
1096 .get_voltage_sel = regulator_get_voltage_sel_regmap,
1097 .set_voltage_sel = regulator_set_voltage_sel_regmap,
1098 .set_voltage_time_sel = regulator_set_voltage_time_sel,
1099 .enable = regulator_enable_regmap,
1100 .disable = regulator_disable_regmap,
1101 .is_enabled = regulator_is_enabled_regmap,
1102 .set_mode = rk8xx_set_mode,
1103 .get_mode = rk8xx_get_mode,
1104 .set_suspend_mode = rk8xx_set_suspend_mode,
1105 .set_suspend_voltage = rk808_set_suspend_voltage_range,
1106 .set_suspend_enable = rk816_set_suspend_enable,
1107 .set_suspend_disable = rk816_set_suspend_disable,
1108 };
1109
1110 static const struct regulator_ops rk816_reg_ops = {
1111 .list_voltage = regulator_list_voltage_linear,
1112 .map_voltage = regulator_map_voltage_linear,
1113 .get_voltage_sel = regulator_get_voltage_sel_regmap,
1114 .set_voltage_sel = regulator_set_voltage_sel_regmap,
1115 .enable = regulator_enable_regmap,
1116 .disable = regulator_disable_regmap,
1117 .is_enabled = rk8xx_is_enabled_wmsk_regmap,
1118 .set_suspend_voltage = rk808_set_suspend_voltage,
1119 .set_suspend_enable = rk816_set_suspend_enable,
1120 .set_suspend_disable = rk816_set_suspend_disable,
1121 };
1122
1123 static const struct regulator_ops rk817_reg_ops = {
1124 .list_voltage = regulator_list_voltage_linear,
1125 .map_voltage = regulator_map_voltage_linear,
1126 .get_voltage_sel = regulator_get_voltage_sel_regmap,
1127 .set_voltage_sel = regulator_set_voltage_sel_regmap,
1128 .enable = regulator_enable_regmap,
1129 .disable = regulator_disable_regmap,
1130 .is_enabled = rk8xx_is_enabled_wmsk_regmap,
1131 .set_suspend_voltage = rk808_set_suspend_voltage,
1132 .set_suspend_enable = rk817_set_suspend_enable,
1133 .set_suspend_disable = rk817_set_suspend_disable,
1134 };
1135
1136 static const struct regulator_ops rk817_boost_ops = {
1137 .list_voltage = regulator_list_voltage_linear,
1138 .map_voltage = regulator_map_voltage_linear,
1139 .get_voltage_sel = regulator_get_voltage_sel_regmap,
1140 .set_voltage_sel = regulator_set_voltage_sel_regmap,
1141 .enable = regulator_enable_regmap,
1142 .disable = regulator_disable_regmap,
1143 .is_enabled = rk8xx_is_enabled_wmsk_regmap,
1144 .set_suspend_enable = rk817_set_suspend_enable,
1145 .set_suspend_disable = rk817_set_suspend_disable,
1146 };
1147
1148 static const struct regulator_ops rk817_buck_ops_range = {
1149 .list_voltage = regulator_list_voltage_linear_range,
1150 .map_voltage = regulator_map_voltage_linear_range,
1151 .get_voltage_sel = regulator_get_voltage_sel_regmap,
1152 .set_voltage_sel = regulator_set_voltage_sel_regmap,
1153 .set_voltage_time_sel = regulator_set_voltage_time_sel,
1154 .enable = regulator_enable_regmap,
1155 .disable = regulator_disable_regmap,
1156 .is_enabled = rk8xx_is_enabled_wmsk_regmap,
1157 .set_mode = rk8xx_set_mode,
1158 .get_mode = rk8xx_get_mode,
1159 .set_suspend_mode = rk8xx_set_suspend_mode,
1160 .set_ramp_delay = regulator_set_ramp_delay_regmap,
1161 .set_suspend_voltage = rk808_set_suspend_voltage_range,
1162 .set_suspend_enable = rk817_set_suspend_enable,
1163 .set_suspend_disable = rk817_set_suspend_disable,
1164 };
1165
1166 static const struct regulator_ops rk817_switch_ops = {
1167 .enable = regulator_enable_regmap,
1168 .disable = regulator_disable_regmap,
1169 .is_enabled = rk8xx_is_enabled_wmsk_regmap,
1170 .set_suspend_enable = rk817_set_suspend_enable,
1171 .set_suspend_disable = rk817_set_suspend_disable,
1172 };
1173
1174 static const struct linear_range rk801_buck1_voltage_ranges[] = {
1175 REGULATOR_LINEAR_RANGE(500000, 0, 80, 12500), /* 0.5v - 1.5v */
1176 REGULATOR_LINEAR_RANGE(1800000, 81, 82, 400000),/* 1.8v - 2.2v */
1177 REGULATOR_LINEAR_RANGE(3300000, 83, 83, 0), /* 3.3v */
1178 REGULATOR_LINEAR_RANGE(5000000, 84, 84, 0), /* 5.0v */
1179 REGULATOR_LINEAR_RANGE(5250000, 85, 85, 0), /* 5.25v */
1180 };
1181
1182 static const struct linear_range rk801_buck2_voltage_ranges[] = {
1183 REGULATOR_LINEAR_RANGE(800000, 0, 2, 50000), /* 0.8v - 0.9v */
1184 REGULATOR_LINEAR_RANGE(1800000, 3, 4, 400000), /* 1.8v - 2.2v */
1185 REGULATOR_LINEAR_RANGE(3300000, 5, 5, 0), /* 3.3v */
1186 REGULATOR_LINEAR_RANGE(5000000, 6, 6, 0), /* 5.0v */
1187 REGULATOR_LINEAR_RANGE(5250000, 7, 7, 0), /* 5.25v */
1188 };
1189
1190 static const struct linear_range rk801_buck4_voltage_ranges[] = {
1191 REGULATOR_LINEAR_RANGE(500000, 0, 80, 12500), /* 0.5v - 1.5v */
1192 REGULATOR_LINEAR_RANGE(1800000, 81, 82, 400000),/* 1.8v - 2.2v */
1193 REGULATOR_LINEAR_RANGE(2500000, 83, 83, 0), /* 2.5v */
1194 REGULATOR_LINEAR_RANGE(2800000, 84, 84, 0), /* 2.8v */
1195 REGULATOR_LINEAR_RANGE(3000000, 85, 85, 0), /* 3.0v */
1196 REGULATOR_LINEAR_RANGE(3300000, 86, 86, 0), /* 3.3v */
1197 };
1198
1199 static const struct regulator_desc rk801_reg[] = {
1200 {
1201 .name = "dcdc1",
1202 .supply_name = "vcc1",
1203 .of_match = of_match_ptr("dcdc1"),
1204 .regulators_node = of_match_ptr("regulators"),
1205 .id = RK801_ID_DCDC1,
1206 .ops = &rk801_buck_ops,
1207 .type = REGULATOR_VOLTAGE,
1208 .n_voltages = 86,
1209 .linear_ranges = rk801_buck1_voltage_ranges,
1210 .n_linear_ranges = ARRAY_SIZE(rk801_buck1_voltage_ranges),
1211 .vsel_reg = RK801_BUCK1_ON_VSEL_REG,
1212 .vsel_mask = RK801_BUCK_VSEL_MASK,
1213 .enable_reg = RK801_POWER_EN0_REG,
1214 .enable_mask = ENABLE_MASK(RK801_ID_DCDC1),
1215 .enable_val = ENABLE_MASK(RK801_ID_DCDC1),
1216 .disable_val = DISABLE_VAL(RK801_ID_DCDC1),
1217 .ramp_delay = 1000,
1218 .of_map_mode = rk8xx_regulator_of_map_mode,
1219 .enable_time = 400,
1220 .owner = THIS_MODULE,
1221 }, {
1222 .name = "dcdc2",
1223 .supply_name = "vcc2",
1224 .of_match = of_match_ptr("dcdc2"),
1225 .regulators_node = of_match_ptr("regulators"),
1226 .id = RK801_ID_DCDC2,
1227 .ops = &rk801_buck_ops,
1228 .type = REGULATOR_VOLTAGE,
1229 .n_voltages = 8,
1230 .linear_ranges = rk801_buck2_voltage_ranges,
1231 .n_linear_ranges = ARRAY_SIZE(rk801_buck2_voltage_ranges),
1232 .vsel_reg = RK801_BUCK2_ON_VSEL_REG,
1233 .vsel_mask = RK801_BUCK_VSEL_MASK,
1234 .enable_reg = RK801_POWER_EN0_REG,
1235 .enable_mask = ENABLE_MASK(RK801_ID_DCDC2),
1236 .enable_val = ENABLE_MASK(RK801_ID_DCDC2),
1237 .disable_val = DISABLE_VAL(RK801_ID_DCDC2),
1238 .ramp_delay = 1000,
1239 .of_map_mode = rk8xx_regulator_of_map_mode,
1240 .enable_time = 400,
1241 .owner = THIS_MODULE,
1242 }, {
1243 .name = "dcdc3",
1244 .supply_name = "vcc3",
1245 .of_match = of_match_ptr("dcdc3"),
1246 .regulators_node = of_match_ptr("regulators"),
1247 .id = RK801_ID_DCDC3,
1248 .ops = &rk801_switch_ops,
1249 .type = REGULATOR_VOLTAGE,
1250 .n_voltages = 1,
1251 .enable_reg = RK801_POWER_EN0_REG,
1252 .enable_mask = ENABLE_MASK(RK801_ID_DCDC3),
1253 .enable_val = ENABLE_MASK(RK801_ID_DCDC3),
1254 .disable_val = DISABLE_VAL(RK801_ID_DCDC3),
1255 .of_map_mode = rk8xx_regulator_of_map_mode,
1256 .enable_time = 400,
1257 .owner = THIS_MODULE,
1258 }, {
1259 .name = "dcdc4",
1260 .supply_name = "vcc4",
1261 .of_match = of_match_ptr("dcdc4"),
1262 .regulators_node = of_match_ptr("regulators"),
1263 .id = RK801_ID_DCDC4,
1264 .ops = &rk801_buck_ops,
1265 .type = REGULATOR_VOLTAGE,
1266 .n_voltages = 87,
1267 .linear_ranges = rk801_buck4_voltage_ranges,
1268 .n_linear_ranges = ARRAY_SIZE(rk801_buck4_voltage_ranges),
1269 .vsel_reg = RK801_BUCK4_ON_VSEL_REG,
1270 .vsel_mask = RK801_BUCK_VSEL_MASK,
1271 .enable_reg = RK801_POWER_EN0_REG,
1272 .enable_mask = ENABLE_MASK(RK801_ID_DCDC4),
1273 .enable_val = ENABLE_MASK(RK801_ID_DCDC4),
1274 .disable_val = DISABLE_VAL(RK801_ID_DCDC4),
1275 .ramp_delay = 1000,
1276 .of_map_mode = rk8xx_regulator_of_map_mode,
1277 .enable_time = 400,
1278 .owner = THIS_MODULE,
1279 },
1280
1281 RK801_DESC(RK801_ID_LDO1, "ldo1", "vcc5", 500, 3400, 50,
1282 RK801_LDO1_ON_VSEL_REG, RK801_LDO_VSEL_MASK, RK801_POWER_EN1_REG,
1283 ENABLE_MASK(0), DISABLE_VAL(0), 400),
1284 RK801_DESC(RK801_ID_LDO2, "ldo2", "vcc6", 500, 3400, 50,
1285 RK801_LDO2_ON_VSEL_REG, RK801_LDO_VSEL_MASK, RK801_POWER_EN1_REG,
1286 ENABLE_MASK(1), DISABLE_VAL(1), 400),
1287 RK801_DESC_SWITCH(RK801_ID_SWITCH, "switch", "vcc7", RK801_POWER_EN1_REG,
1288 ENABLE_MASK(2), DISABLE_VAL(2)),
1289 };
1290
1291 static const struct regulator_desc rk805_reg[] = {
1292 {
1293 .name = "DCDC_REG1",
1294 .supply_name = "vcc1",
1295 .of_match = of_match_ptr("DCDC_REG1"),
1296 .regulators_node = of_match_ptr("regulators"),
1297 .id = RK805_ID_DCDC1,
1298 .ops = &rk808_reg_ops_ranges,
1299 .type = REGULATOR_VOLTAGE,
1300 .n_voltages = 64,
1301 .linear_ranges = rk805_buck_1_2_voltage_ranges,
1302 .n_linear_ranges = ARRAY_SIZE(rk805_buck_1_2_voltage_ranges),
1303 .vsel_reg = RK805_BUCK1_ON_VSEL_REG,
1304 .vsel_mask = RK818_BUCK_VSEL_MASK,
1305 .enable_reg = RK805_DCDC_EN_REG,
1306 .enable_mask = BIT(0),
1307 .owner = THIS_MODULE,
1308 }, {
1309 .name = "DCDC_REG2",
1310 .supply_name = "vcc2",
1311 .of_match = of_match_ptr("DCDC_REG2"),
1312 .regulators_node = of_match_ptr("regulators"),
1313 .id = RK805_ID_DCDC2,
1314 .ops = &rk808_reg_ops_ranges,
1315 .type = REGULATOR_VOLTAGE,
1316 .n_voltages = 64,
1317 .linear_ranges = rk805_buck_1_2_voltage_ranges,
1318 .n_linear_ranges = ARRAY_SIZE(rk805_buck_1_2_voltage_ranges),
1319 .vsel_reg = RK805_BUCK2_ON_VSEL_REG,
1320 .vsel_mask = RK818_BUCK_VSEL_MASK,
1321 .enable_reg = RK805_DCDC_EN_REG,
1322 .enable_mask = BIT(1),
1323 .owner = THIS_MODULE,
1324 }, {
1325 .name = "DCDC_REG3",
1326 .supply_name = "vcc3",
1327 .of_match = of_match_ptr("DCDC_REG3"),
1328 .regulators_node = of_match_ptr("regulators"),
1329 .id = RK805_ID_DCDC3,
1330 .ops = &rk805_switch_ops,
1331 .type = REGULATOR_VOLTAGE,
1332 .n_voltages = 1,
1333 .enable_reg = RK805_DCDC_EN_REG,
1334 .enable_mask = BIT(2),
1335 .owner = THIS_MODULE,
1336 },
1337
1338 RK805_DESC(RK805_ID_DCDC4, "DCDC_REG4", "vcc4", 800, 3400, 100,
1339 RK805_BUCK4_ON_VSEL_REG, RK818_BUCK4_VSEL_MASK,
1340 RK805_DCDC_EN_REG, BIT(3), 0),
1341
1342 RK805_DESC(RK805_ID_LDO1, "LDO_REG1", "vcc5", 800, 3400, 100,
1343 RK805_LDO1_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK805_LDO_EN_REG,
1344 BIT(0), 400),
1345 RK805_DESC(RK805_ID_LDO2, "LDO_REG2", "vcc5", 800, 3400, 100,
1346 RK805_LDO2_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK805_LDO_EN_REG,
1347 BIT(1), 400),
1348 RK805_DESC(RK805_ID_LDO3, "LDO_REG3", "vcc6", 800, 3400, 100,
1349 RK805_LDO3_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK805_LDO_EN_REG,
1350 BIT(2), 400),
1351 };
1352
1353 static const struct linear_range rk806_buck_voltage_ranges[] = {
1354 REGULATOR_LINEAR_RANGE(500000, 0, 159, 6250), /* 500mV ~ 1500mV */
1355 REGULATOR_LINEAR_RANGE(1500000, 160, 235, 25000), /* 1500mV ~ 3400mV */
1356 REGULATOR_LINEAR_RANGE(3400000, 236, 255, 0),
1357 };
1358
1359 static const struct linear_range rk806_ldo_voltage_ranges[] = {
1360 REGULATOR_LINEAR_RANGE(500000, 0, 231, 12500), /* 500mV ~ 3400mV */
1361 REGULATOR_LINEAR_RANGE(3400000, 232, 255, 0),
1362 };
1363
1364 static const struct regulator_desc rk806_reg[] = {
1365 RK806_REGULATOR("dcdc-reg1", "vcc1", RK806_ID_DCDC1, rk806_ops_dcdc,
1366 RK806_BUCK_SEL_CNT, RK806_BUCK1_ON_VSEL,
1367 RK806_POWER_EN0, rk806_buck_voltage_ranges, 0,
1368 RK806_BUCK1_CONFIG, 0xc0, rk806_ramp_delay_table_dcdc),
1369 RK806_REGULATOR("dcdc-reg2", "vcc2", RK806_ID_DCDC2, rk806_ops_dcdc,
1370 RK806_BUCK_SEL_CNT, RK806_BUCK2_ON_VSEL,
1371 RK806_POWER_EN0, rk806_buck_voltage_ranges, 1,
1372 RK806_BUCK2_CONFIG, 0xc0, rk806_ramp_delay_table_dcdc),
1373 RK806_REGULATOR("dcdc-reg3", "vcc3", RK806_ID_DCDC3, rk806_ops_dcdc,
1374 RK806_BUCK_SEL_CNT, RK806_BUCK3_ON_VSEL,
1375 RK806_POWER_EN0, rk806_buck_voltage_ranges, 2,
1376 RK806_BUCK3_CONFIG, 0xc0, rk806_ramp_delay_table_dcdc),
1377 RK806_REGULATOR("dcdc-reg4", "vcc4", RK806_ID_DCDC4, rk806_ops_dcdc,
1378 RK806_BUCK_SEL_CNT, RK806_BUCK4_ON_VSEL,
1379 RK806_POWER_EN0, rk806_buck_voltage_ranges, 3,
1380 RK806_BUCK4_CONFIG, 0xc0, rk806_ramp_delay_table_dcdc),
1381
1382 RK806_REGULATOR("dcdc-reg5", "vcc5", RK806_ID_DCDC5, rk806_ops_dcdc,
1383 RK806_BUCK_SEL_CNT, RK806_BUCK5_ON_VSEL,
1384 RK806_POWER_EN1, rk806_buck_voltage_ranges, 0,
1385 RK806_BUCK5_CONFIG, 0xc0, rk806_ramp_delay_table_dcdc),
1386 RK806_REGULATOR("dcdc-reg6", "vcc6", RK806_ID_DCDC6, rk806_ops_dcdc,
1387 RK806_BUCK_SEL_CNT, RK806_BUCK6_ON_VSEL,
1388 RK806_POWER_EN1, rk806_buck_voltage_ranges, 1,
1389 RK806_BUCK6_CONFIG, 0xc0, rk806_ramp_delay_table_dcdc),
1390 RK806_REGULATOR("dcdc-reg7", "vcc7", RK806_ID_DCDC7, rk806_ops_dcdc,
1391 RK806_BUCK_SEL_CNT, RK806_BUCK7_ON_VSEL,
1392 RK806_POWER_EN1, rk806_buck_voltage_ranges, 2,
1393 RK806_BUCK7_CONFIG, 0xc0, rk806_ramp_delay_table_dcdc),
1394 RK806_REGULATOR("dcdc-reg8", "vcc8", RK806_ID_DCDC8, rk806_ops_dcdc,
1395 RK806_BUCK_SEL_CNT, RK806_BUCK8_ON_VSEL,
1396 RK806_POWER_EN1, rk806_buck_voltage_ranges, 3,
1397 RK806_BUCK8_CONFIG, 0xc0, rk806_ramp_delay_table_dcdc),
1398
1399 RK806_REGULATOR("dcdc-reg9", "vcc9", RK806_ID_DCDC9, rk806_ops_dcdc,
1400 RK806_BUCK_SEL_CNT, RK806_BUCK9_ON_VSEL,
1401 RK806_POWER_EN2, rk806_buck_voltage_ranges, 0,
1402 RK806_BUCK9_CONFIG, 0xc0, rk806_ramp_delay_table_dcdc),
1403 RK806_REGULATOR("dcdc-reg10", "vcc10", RK806_ID_DCDC10, rk806_ops_dcdc,
1404 RK806_BUCK_SEL_CNT, RK806_BUCK10_ON_VSEL,
1405 RK806_POWER_EN2, rk806_buck_voltage_ranges, 1,
1406 RK806_BUCK10_CONFIG, 0xc0, rk806_ramp_delay_table_dcdc),
1407
1408 RK806_REGULATOR("nldo-reg1", "vcc13", RK806_ID_NLDO1, rk806_ops_nldo,
1409 RK806_LDO_SEL_CNT, RK806_NLDO1_ON_VSEL,
1410 RK806_POWER_EN3, rk806_ldo_voltage_ranges, 0,
1411 0xEA, 0x38, rk806_ramp_delay_table_ldo),
1412 RK806_REGULATOR("nldo-reg2", "vcc13", RK806_ID_NLDO2, rk806_ops_nldo,
1413 RK806_LDO_SEL_CNT, RK806_NLDO2_ON_VSEL,
1414 RK806_POWER_EN3, rk806_ldo_voltage_ranges, 1,
1415 0xEA, 0x38, rk806_ramp_delay_table_ldo),
1416 RK806_REGULATOR("nldo-reg3", "vcc13", RK806_ID_NLDO3, rk806_ops_nldo,
1417 RK806_LDO_SEL_CNT, RK806_NLDO3_ON_VSEL,
1418 RK806_POWER_EN3, rk806_ldo_voltage_ranges, 2,
1419 0xEA, 0x38, rk806_ramp_delay_table_ldo),
1420 RK806_REGULATOR("nldo-reg4", "vcc14", RK806_ID_NLDO4, rk806_ops_nldo,
1421 RK806_LDO_SEL_CNT, RK806_NLDO4_ON_VSEL,
1422 RK806_POWER_EN3, rk806_ldo_voltage_ranges, 3,
1423 0xEA, 0x38, rk806_ramp_delay_table_ldo),
1424
1425 RK806_REGULATOR("nldo-reg5", "vcc14", RK806_ID_NLDO5, rk806_ops_nldo,
1426 RK806_LDO_SEL_CNT, RK806_NLDO5_ON_VSEL,
1427 RK806_POWER_EN5, rk806_ldo_voltage_ranges, 2,
1428 0xEA, 0x38, rk806_ramp_delay_table_ldo),
1429
1430 RK806_REGULATOR("pldo-reg1", "vcc11", RK806_ID_PLDO1, rk806_ops_pldo,
1431 RK806_LDO_SEL_CNT, RK806_PLDO1_ON_VSEL,
1432 RK806_POWER_EN4, rk806_ldo_voltage_ranges, 1,
1433 0xEA, 0x38, rk806_ramp_delay_table_ldo),
1434 RK806_REGULATOR("pldo-reg2", "vcc11", RK806_ID_PLDO2, rk806_ops_pldo,
1435 RK806_LDO_SEL_CNT, RK806_PLDO2_ON_VSEL,
1436 RK806_POWER_EN4, rk806_ldo_voltage_ranges, 2,
1437 0xEA, 0x38, rk806_ramp_delay_table_ldo),
1438 RK806_REGULATOR("pldo-reg3", "vcc11", RK806_ID_PLDO3, rk806_ops_pldo,
1439 RK806_LDO_SEL_CNT, RK806_PLDO3_ON_VSEL,
1440 RK806_POWER_EN4, rk806_ldo_voltage_ranges, 3,
1441 0xEA, 0x38, rk806_ramp_delay_table_ldo),
1442
1443 RK806_REGULATOR("pldo-reg4", "vcc12", RK806_ID_PLDO4, rk806_ops_pldo,
1444 RK806_LDO_SEL_CNT, RK806_PLDO4_ON_VSEL,
1445 RK806_POWER_EN5, rk806_ldo_voltage_ranges, 0,
1446 0xEA, 0x38, rk806_ramp_delay_table_ldo),
1447 RK806_REGULATOR("pldo-reg5", "vcc12", RK806_ID_PLDO5, rk806_ops_pldo,
1448 RK806_LDO_SEL_CNT, RK806_PLDO5_ON_VSEL,
1449 RK806_POWER_EN5, rk806_ldo_voltage_ranges, 1,
1450 0xEA, 0x38, rk806_ramp_delay_table_ldo),
1451
1452 RK806_REGULATOR("pldo-reg6", "vcca", RK806_ID_PLDO6, rk806_ops_pldo,
1453 RK806_LDO_SEL_CNT, RK806_PLDO6_ON_VSEL,
1454 RK806_POWER_EN4, rk806_ldo_voltage_ranges, 0,
1455 0xEA, 0x38, rk806_ramp_delay_table_ldo),
1456 };
1457
1458
1459 static const struct regulator_desc rk808_reg[] = {
1460 {
1461 .name = "DCDC_REG1",
1462 .supply_name = "vcc1",
1463 .of_match = of_match_ptr("DCDC_REG1"),
1464 .regulators_node = of_match_ptr("regulators"),
1465 .id = RK808_ID_DCDC1,
1466 .ops = &rk808_buck1_2_ops,
1467 .type = REGULATOR_VOLTAGE,
1468 .min_uV = 712500,
1469 .uV_step = 12500,
1470 .n_voltages = 64,
1471 .vsel_reg = RK808_BUCK1_ON_VSEL_REG,
1472 .vsel_mask = RK808_BUCK_VSEL_MASK,
1473 .enable_reg = RK808_DCDC_EN_REG,
1474 .enable_mask = BIT(0),
1475 .ramp_reg = RK808_BUCK1_CONFIG_REG,
1476 .ramp_mask = RK808_RAMP_RATE_MASK,
1477 .ramp_delay_table = rk808_buck1_2_ramp_table,
1478 .n_ramp_values = ARRAY_SIZE(rk808_buck1_2_ramp_table),
1479 .owner = THIS_MODULE,
1480 }, {
1481 .name = "DCDC_REG2",
1482 .supply_name = "vcc2",
1483 .of_match = of_match_ptr("DCDC_REG2"),
1484 .regulators_node = of_match_ptr("regulators"),
1485 .id = RK808_ID_DCDC2,
1486 .ops = &rk808_buck1_2_ops,
1487 .type = REGULATOR_VOLTAGE,
1488 .min_uV = 712500,
1489 .uV_step = 12500,
1490 .n_voltages = 64,
1491 .vsel_reg = RK808_BUCK2_ON_VSEL_REG,
1492 .vsel_mask = RK808_BUCK_VSEL_MASK,
1493 .enable_reg = RK808_DCDC_EN_REG,
1494 .enable_mask = BIT(1),
1495 .ramp_reg = RK808_BUCK2_CONFIG_REG,
1496 .ramp_mask = RK808_RAMP_RATE_MASK,
1497 .ramp_delay_table = rk808_buck1_2_ramp_table,
1498 .n_ramp_values = ARRAY_SIZE(rk808_buck1_2_ramp_table),
1499 .owner = THIS_MODULE,
1500 }, {
1501 .name = "DCDC_REG3",
1502 .supply_name = "vcc3",
1503 .of_match = of_match_ptr("DCDC_REG3"),
1504 .regulators_node = of_match_ptr("regulators"),
1505 .id = RK808_ID_DCDC3,
1506 .ops = &rk808_switch_ops,
1507 .type = REGULATOR_VOLTAGE,
1508 .n_voltages = 1,
1509 .enable_reg = RK808_DCDC_EN_REG,
1510 .enable_mask = BIT(2),
1511 .owner = THIS_MODULE,
1512 },
1513 RK8XX_DESC(RK808_ID_DCDC4, "DCDC_REG4", "vcc4", 1800, 3300, 100,
1514 RK808_BUCK4_ON_VSEL_REG, RK808_BUCK4_VSEL_MASK,
1515 RK808_DCDC_EN_REG, BIT(3), 0),
1516 RK8XX_DESC(RK808_ID_LDO1, "LDO_REG1", "vcc6", 1800, 3400, 100,
1517 RK808_LDO1_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
1518 BIT(0), 400),
1519 RK8XX_DESC(RK808_ID_LDO2, "LDO_REG2", "vcc6", 1800, 3400, 100,
1520 RK808_LDO2_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
1521 BIT(1), 400),
1522 {
1523 .name = "LDO_REG3",
1524 .supply_name = "vcc7",
1525 .of_match = of_match_ptr("LDO_REG3"),
1526 .regulators_node = of_match_ptr("regulators"),
1527 .id = RK808_ID_LDO3,
1528 .ops = &rk808_reg_ops_ranges,
1529 .type = REGULATOR_VOLTAGE,
1530 .n_voltages = 16,
1531 .linear_ranges = rk808_ldo3_voltage_ranges,
1532 .n_linear_ranges = ARRAY_SIZE(rk808_ldo3_voltage_ranges),
1533 .vsel_reg = RK808_LDO3_ON_VSEL_REG,
1534 .vsel_mask = RK808_BUCK4_VSEL_MASK,
1535 .enable_reg = RK808_LDO_EN_REG,
1536 .enable_mask = BIT(2),
1537 .enable_time = 400,
1538 .owner = THIS_MODULE,
1539 },
1540 RK8XX_DESC(RK808_ID_LDO4, "LDO_REG4", "vcc9", 1800, 3400, 100,
1541 RK808_LDO4_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
1542 BIT(3), 400),
1543 RK8XX_DESC(RK808_ID_LDO5, "LDO_REG5", "vcc9", 1800, 3400, 100,
1544 RK808_LDO5_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
1545 BIT(4), 400),
1546 RK8XX_DESC(RK808_ID_LDO6, "LDO_REG6", "vcc10", 800, 2500, 100,
1547 RK808_LDO6_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
1548 BIT(5), 400),
1549 RK8XX_DESC(RK808_ID_LDO7, "LDO_REG7", "vcc7", 800, 2500, 100,
1550 RK808_LDO7_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
1551 BIT(6), 400),
1552 RK8XX_DESC(RK808_ID_LDO8, "LDO_REG8", "vcc11", 1800, 3400, 100,
1553 RK808_LDO8_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
1554 BIT(7), 400),
1555 RK8XX_DESC_SWITCH(RK808_ID_SWITCH1, "SWITCH_REG1", "vcc8",
1556 RK808_DCDC_EN_REG, BIT(5)),
1557 RK8XX_DESC_SWITCH(RK808_ID_SWITCH2, "SWITCH_REG2", "vcc12",
1558 RK808_DCDC_EN_REG, BIT(6)),
1559 };
1560
1561 static const struct regulator_desc rk809_reg[] = {
1562 {
1563 .name = "DCDC_REG1",
1564 .supply_name = "vcc1",
1565 .of_match = of_match_ptr("DCDC_REG1"),
1566 .regulators_node = of_match_ptr("regulators"),
1567 .id = RK817_ID_DCDC1,
1568 .ops = &rk817_buck_ops_range,
1569 .type = REGULATOR_VOLTAGE,
1570 .n_voltages = RK817_BUCK1_SEL_CNT + 1,
1571 .linear_ranges = rk817_buck1_voltage_ranges,
1572 .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
1573 .vsel_reg = RK817_BUCK1_ON_VSEL_REG,
1574 .vsel_mask = RK817_BUCK_VSEL_MASK,
1575 .enable_reg = RK817_POWER_EN_REG(0),
1576 .enable_mask = ENABLE_MASK(RK817_ID_DCDC1),
1577 .enable_val = ENABLE_MASK(RK817_ID_DCDC1),
1578 .disable_val = DISABLE_VAL(RK817_ID_DCDC1),
1579 .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC1),
1580 .ramp_mask = RK817_RAMP_RATE_MASK,
1581 .ramp_delay_table = rk817_buck1_4_ramp_table,
1582 .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
1583 .of_map_mode = rk8xx_regulator_of_map_mode,
1584 .owner = THIS_MODULE,
1585 }, {
1586 .name = "DCDC_REG2",
1587 .supply_name = "vcc2",
1588 .of_match = of_match_ptr("DCDC_REG2"),
1589 .regulators_node = of_match_ptr("regulators"),
1590 .id = RK817_ID_DCDC2,
1591 .ops = &rk817_buck_ops_range,
1592 .type = REGULATOR_VOLTAGE,
1593 .n_voltages = RK817_BUCK1_SEL_CNT + 1,
1594 .linear_ranges = rk817_buck1_voltage_ranges,
1595 .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
1596 .vsel_reg = RK817_BUCK2_ON_VSEL_REG,
1597 .vsel_mask = RK817_BUCK_VSEL_MASK,
1598 .enable_reg = RK817_POWER_EN_REG(0),
1599 .enable_mask = ENABLE_MASK(RK817_ID_DCDC2),
1600 .enable_val = ENABLE_MASK(RK817_ID_DCDC2),
1601 .disable_val = DISABLE_VAL(RK817_ID_DCDC2),
1602 .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC2),
1603 .ramp_mask = RK817_RAMP_RATE_MASK,
1604 .ramp_delay_table = rk817_buck1_4_ramp_table,
1605 .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
1606 .of_map_mode = rk8xx_regulator_of_map_mode,
1607 .owner = THIS_MODULE,
1608 }, {
1609 .name = "DCDC_REG3",
1610 .supply_name = "vcc3",
1611 .of_match = of_match_ptr("DCDC_REG3"),
1612 .regulators_node = of_match_ptr("regulators"),
1613 .id = RK817_ID_DCDC3,
1614 .ops = &rk817_buck_ops_range,
1615 .type = REGULATOR_VOLTAGE,
1616 .n_voltages = RK817_BUCK1_SEL_CNT + 1,
1617 .linear_ranges = rk817_buck1_voltage_ranges,
1618 .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
1619 .vsel_reg = RK817_BUCK3_ON_VSEL_REG,
1620 .vsel_mask = RK817_BUCK_VSEL_MASK,
1621 .apply_reg = RK817_POWER_CONFIG,
1622 .apply_bit = RK817_BUCK3_FB_RES_INTER,
1623 .enable_reg = RK817_POWER_EN_REG(0),
1624 .enable_mask = ENABLE_MASK(RK817_ID_DCDC3),
1625 .enable_val = ENABLE_MASK(RK817_ID_DCDC3),
1626 .disable_val = DISABLE_VAL(RK817_ID_DCDC3),
1627 .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC3),
1628 .ramp_mask = RK817_RAMP_RATE_MASK,
1629 .ramp_delay_table = rk817_buck1_4_ramp_table,
1630 .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
1631 .of_map_mode = rk8xx_regulator_of_map_mode,
1632 .owner = THIS_MODULE,
1633 }, {
1634 .name = "DCDC_REG4",
1635 .supply_name = "vcc4",
1636 .of_match = of_match_ptr("DCDC_REG4"),
1637 .regulators_node = of_match_ptr("regulators"),
1638 .id = RK817_ID_DCDC4,
1639 .ops = &rk817_buck_ops_range,
1640 .type = REGULATOR_VOLTAGE,
1641 .n_voltages = RK817_BUCK3_SEL_CNT + 1,
1642 .linear_ranges = rk817_buck3_voltage_ranges,
1643 .n_linear_ranges = ARRAY_SIZE(rk817_buck3_voltage_ranges),
1644 .vsel_reg = RK817_BUCK4_ON_VSEL_REG,
1645 .vsel_mask = RK817_BUCK_VSEL_MASK,
1646 .enable_reg = RK817_POWER_EN_REG(0),
1647 .enable_mask = ENABLE_MASK(RK817_ID_DCDC4),
1648 .enable_val = ENABLE_MASK(RK817_ID_DCDC4),
1649 .disable_val = DISABLE_VAL(RK817_ID_DCDC4),
1650 .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC4),
1651 .ramp_mask = RK817_RAMP_RATE_MASK,
1652 .ramp_delay_table = rk817_buck1_4_ramp_table,
1653 .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
1654 .of_map_mode = rk8xx_regulator_of_map_mode,
1655 .owner = THIS_MODULE,
1656 },
1657 {
1658 .name = "DCDC_REG5",
1659 .supply_name = "vcc9",
1660 .of_match = of_match_ptr("DCDC_REG5"),
1661 .regulators_node = of_match_ptr("regulators"),
1662 .id = RK809_ID_DCDC5,
1663 .ops = &rk809_buck5_ops_range,
1664 .type = REGULATOR_VOLTAGE,
1665 .n_voltages = RK809_BUCK5_SEL_CNT,
1666 .linear_ranges = rk809_buck5_voltage_ranges,
1667 .n_linear_ranges = ARRAY_SIZE(rk809_buck5_voltage_ranges),
1668 .vsel_reg = RK809_BUCK5_CONFIG(0),
1669 .vsel_mask = RK809_BUCK5_VSEL_MASK,
1670 .enable_reg = RK817_POWER_EN_REG(3),
1671 .enable_mask = ENABLE_MASK(1),
1672 .enable_val = ENABLE_MASK(1),
1673 .disable_val = DISABLE_VAL(1),
1674 .of_map_mode = rk8xx_regulator_of_map_mode,
1675 .owner = THIS_MODULE,
1676 },
1677 RK817_DESC(RK817_ID_LDO1, "LDO_REG1", "vcc5", 600, 3400, 25,
1678 RK817_LDO_ON_VSEL_REG(0), RK817_LDO_VSEL_MASK,
1679 RK817_POWER_EN_REG(1), ENABLE_MASK(0),
1680 DISABLE_VAL(0), 400),
1681 RK817_DESC(RK817_ID_LDO2, "LDO_REG2", "vcc5", 600, 3400, 25,
1682 RK817_LDO_ON_VSEL_REG(1), RK817_LDO_VSEL_MASK,
1683 RK817_POWER_EN_REG(1), ENABLE_MASK(1),
1684 DISABLE_VAL(1), 400),
1685 RK817_DESC(RK817_ID_LDO3, "LDO_REG3", "vcc5", 600, 3400, 25,
1686 RK817_LDO_ON_VSEL_REG(2), RK817_LDO_VSEL_MASK,
1687 RK817_POWER_EN_REG(1), ENABLE_MASK(2),
1688 DISABLE_VAL(2), 400),
1689 RK817_DESC(RK817_ID_LDO4, "LDO_REG4", "vcc6", 600, 3400, 25,
1690 RK817_LDO_ON_VSEL_REG(3), RK817_LDO_VSEL_MASK,
1691 RK817_POWER_EN_REG(1), ENABLE_MASK(3),
1692 DISABLE_VAL(3), 400),
1693 RK817_DESC(RK817_ID_LDO5, "LDO_REG5", "vcc6", 600, 3400, 25,
1694 RK817_LDO_ON_VSEL_REG(4), RK817_LDO_VSEL_MASK,
1695 RK817_POWER_EN_REG(2), ENABLE_MASK(0),
1696 DISABLE_VAL(0), 400),
1697 RK817_DESC(RK817_ID_LDO6, "LDO_REG6", "vcc6", 600, 3400, 25,
1698 RK817_LDO_ON_VSEL_REG(5), RK817_LDO_VSEL_MASK,
1699 RK817_POWER_EN_REG(2), ENABLE_MASK(1),
1700 DISABLE_VAL(1), 400),
1701 RK817_DESC(RK817_ID_LDO7, "LDO_REG7", "vcc7", 600, 3400, 25,
1702 RK817_LDO_ON_VSEL_REG(6), RK817_LDO_VSEL_MASK,
1703 RK817_POWER_EN_REG(2), ENABLE_MASK(2),
1704 DISABLE_VAL(2), 400),
1705 RK817_DESC(RK817_ID_LDO8, "LDO_REG8", "vcc7", 600, 3400, 25,
1706 RK817_LDO_ON_VSEL_REG(7), RK817_LDO_VSEL_MASK,
1707 RK817_POWER_EN_REG(2), ENABLE_MASK(3),
1708 DISABLE_VAL(3), 400),
1709 RK817_DESC(RK817_ID_LDO9, "LDO_REG9", "vcc7", 600, 3400, 25,
1710 RK817_LDO_ON_VSEL_REG(8), RK817_LDO_VSEL_MASK,
1711 RK817_POWER_EN_REG(3), ENABLE_MASK(0),
1712 DISABLE_VAL(0), 400),
1713 RK817_DESC_SWITCH(RK809_ID_SW1, "SWITCH_REG1", "vcc9",
1714 RK817_POWER_EN_REG(3), ENABLE_MASK(2),
1715 DISABLE_VAL(2)),
1716 RK817_DESC_SWITCH(RK809_ID_SW2, "SWITCH_REG2", "vcc8",
1717 RK817_POWER_EN_REG(3), ENABLE_MASK(3),
1718 DISABLE_VAL(3)),
1719 };
1720
1721 static const struct linear_range rk816_buck_4_voltage_ranges[] = {
1722 REGULATOR_LINEAR_RANGE(800000, 0, 26, 100000),
1723 REGULATOR_LINEAR_RANGE(3500000, 27, 31, 0),
1724 };
1725
1726 static const struct regulator_desc rk816_reg[] = {
1727 {
1728 .name = "dcdc1",
1729 .supply_name = "vcc1",
1730 .of_match = of_match_ptr("dcdc1"),
1731 .regulators_node = of_match_ptr("regulators"),
1732 .id = RK816_ID_DCDC1,
1733 .ops = &rk816_buck1_2_ops_ranges,
1734 .type = REGULATOR_VOLTAGE,
1735 .n_voltages = 64,
1736 .linear_ranges = rk805_buck_1_2_voltage_ranges,
1737 .n_linear_ranges = ARRAY_SIZE(rk805_buck_1_2_voltage_ranges),
1738 .vsel_reg = RK818_BUCK1_ON_VSEL_REG,
1739 .vsel_mask = RK818_BUCK_VSEL_MASK,
1740 .apply_reg = RK816_DCDC_EN_REG2,
1741 .apply_bit = RK816_BUCK_DVS_CONFIRM,
1742 .enable_reg = RK816_DCDC_EN_REG1,
1743 .enable_mask = BIT(4) | BIT(0),
1744 .enable_val = BIT(4) | BIT(0),
1745 .disable_val = BIT(4),
1746 .ramp_reg = RK818_BUCK1_CONFIG_REG,
1747 .ramp_mask = RK808_RAMP_RATE_MASK,
1748 .ramp_delay_table = rk817_buck1_4_ramp_table,
1749 .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
1750 .of_map_mode = rk8xx_regulator_of_map_mode,
1751 .owner = THIS_MODULE,
1752 }, {
1753 .name = "dcdc2",
1754 .supply_name = "vcc2",
1755 .of_match = of_match_ptr("dcdc2"),
1756 .regulators_node = of_match_ptr("regulators"),
1757 .id = RK816_ID_DCDC2,
1758 .ops = &rk816_buck1_2_ops_ranges,
1759 .type = REGULATOR_VOLTAGE,
1760 .n_voltages = 64,
1761 .linear_ranges = rk805_buck_1_2_voltage_ranges,
1762 .n_linear_ranges = ARRAY_SIZE(rk805_buck_1_2_voltage_ranges),
1763 .vsel_reg = RK818_BUCK2_ON_VSEL_REG,
1764 .vsel_mask = RK818_BUCK_VSEL_MASK,
1765 .apply_reg = RK816_DCDC_EN_REG2,
1766 .apply_bit = RK816_BUCK_DVS_CONFIRM,
1767 .enable_reg = RK816_DCDC_EN_REG1,
1768 .enable_mask = BIT(5) | BIT(1),
1769 .enable_val = BIT(5) | BIT(1),
1770 .disable_val = BIT(5),
1771 .ramp_reg = RK818_BUCK2_CONFIG_REG,
1772 .ramp_mask = RK808_RAMP_RATE_MASK,
1773 .ramp_delay_table = rk817_buck1_4_ramp_table,
1774 .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
1775 .of_map_mode = rk8xx_regulator_of_map_mode,
1776 .owner = THIS_MODULE,
1777 }, {
1778 .name = "dcdc3",
1779 .supply_name = "vcc3",
1780 .of_match = of_match_ptr("dcdc3"),
1781 .regulators_node = of_match_ptr("regulators"),
1782 .id = RK816_ID_DCDC3,
1783 .ops = &rk808_switch_ops,
1784 .type = REGULATOR_VOLTAGE,
1785 .n_voltages = 1,
1786 .enable_reg = RK816_DCDC_EN_REG1,
1787 .enable_mask = BIT(6) | BIT(2),
1788 .enable_val = BIT(6) | BIT(2),
1789 .disable_val = BIT(6),
1790 .of_map_mode = rk8xx_regulator_of_map_mode,
1791 .owner = THIS_MODULE,
1792 }, {
1793 .name = "dcdc4",
1794 .supply_name = "vcc4",
1795 .of_match = of_match_ptr("dcdc4"),
1796 .regulators_node = of_match_ptr("regulators"),
1797 .id = RK816_ID_DCDC4,
1798 .ops = &rk816_buck4_ops_ranges,
1799 .type = REGULATOR_VOLTAGE,
1800 .n_voltages = 32,
1801 .linear_ranges = rk816_buck_4_voltage_ranges,
1802 .n_linear_ranges = ARRAY_SIZE(rk816_buck_4_voltage_ranges),
1803 .vsel_reg = RK818_BUCK4_ON_VSEL_REG,
1804 .vsel_mask = RK818_BUCK4_VSEL_MASK,
1805 .enable_reg = RK816_DCDC_EN_REG1,
1806 .enable_mask = BIT(7) | BIT(3),
1807 .enable_val = BIT(7) | BIT(3),
1808 .disable_val = BIT(7),
1809 .of_map_mode = rk8xx_regulator_of_map_mode,
1810 .owner = THIS_MODULE,
1811 },
1812 RK816_DESC(RK816_ID_LDO1, "ldo1", "vcc5", 800, 3400, 100,
1813 RK818_LDO1_ON_VSEL_REG, RK818_LDO_VSEL_MASK,
1814 RK816_LDO_EN_REG1, ENABLE_MASK(0), DISABLE_VAL(0), 400),
1815 RK816_DESC(RK816_ID_LDO2, "ldo2", "vcc5", 800, 3400, 100,
1816 RK818_LDO2_ON_VSEL_REG, RK818_LDO_VSEL_MASK,
1817 RK816_LDO_EN_REG1, ENABLE_MASK(1), DISABLE_VAL(1), 400),
1818 RK816_DESC(RK816_ID_LDO3, "ldo3", "vcc5", 800, 3400, 100,
1819 RK818_LDO3_ON_VSEL_REG, RK818_LDO_VSEL_MASK,
1820 RK816_LDO_EN_REG1, ENABLE_MASK(2), DISABLE_VAL(2), 400),
1821 RK816_DESC(RK816_ID_LDO4, "ldo4", "vcc6", 800, 3400, 100,
1822 RK818_LDO4_ON_VSEL_REG, RK818_LDO_VSEL_MASK,
1823 RK816_LDO_EN_REG1, ENABLE_MASK(3), DISABLE_VAL(3), 400),
1824 RK816_DESC(RK816_ID_LDO5, "ldo5", "vcc6", 800, 3400, 100,
1825 RK818_LDO5_ON_VSEL_REG, RK818_LDO_VSEL_MASK,
1826 RK816_LDO_EN_REG2, ENABLE_MASK(0), DISABLE_VAL(0), 400),
1827 RK816_DESC(RK816_ID_LDO6, "ldo6", "vcc6", 800, 3400, 100,
1828 RK818_LDO6_ON_VSEL_REG, RK818_LDO_VSEL_MASK,
1829 RK816_LDO_EN_REG2, ENABLE_MASK(1), DISABLE_VAL(1), 400),
1830 };
1831
1832 static const struct regulator_desc rk817_reg[] = {
1833 {
1834 .name = "DCDC_REG1",
1835 .supply_name = "vcc1",
1836 .of_match = of_match_ptr("DCDC_REG1"),
1837 .regulators_node = of_match_ptr("regulators"),
1838 .id = RK817_ID_DCDC1,
1839 .ops = &rk817_buck_ops_range,
1840 .type = REGULATOR_VOLTAGE,
1841 .n_voltages = RK817_BUCK1_SEL_CNT + 1,
1842 .linear_ranges = rk817_buck1_voltage_ranges,
1843 .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
1844 .vsel_reg = RK817_BUCK1_ON_VSEL_REG,
1845 .vsel_mask = RK817_BUCK_VSEL_MASK,
1846 .enable_reg = RK817_POWER_EN_REG(0),
1847 .enable_mask = ENABLE_MASK(RK817_ID_DCDC1),
1848 .enable_val = ENABLE_MASK(RK817_ID_DCDC1),
1849 .disable_val = DISABLE_VAL(RK817_ID_DCDC1),
1850 .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC1),
1851 .ramp_mask = RK817_RAMP_RATE_MASK,
1852 .ramp_delay_table = rk817_buck1_4_ramp_table,
1853 .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
1854 .of_map_mode = rk8xx_regulator_of_map_mode,
1855 .owner = THIS_MODULE,
1856 }, {
1857 .name = "DCDC_REG2",
1858 .supply_name = "vcc2",
1859 .of_match = of_match_ptr("DCDC_REG2"),
1860 .regulators_node = of_match_ptr("regulators"),
1861 .id = RK817_ID_DCDC2,
1862 .ops = &rk817_buck_ops_range,
1863 .type = REGULATOR_VOLTAGE,
1864 .n_voltages = RK817_BUCK1_SEL_CNT + 1,
1865 .linear_ranges = rk817_buck1_voltage_ranges,
1866 .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
1867 .vsel_reg = RK817_BUCK2_ON_VSEL_REG,
1868 .vsel_mask = RK817_BUCK_VSEL_MASK,
1869 .enable_reg = RK817_POWER_EN_REG(0),
1870 .enable_mask = ENABLE_MASK(RK817_ID_DCDC2),
1871 .enable_val = ENABLE_MASK(RK817_ID_DCDC2),
1872 .disable_val = DISABLE_VAL(RK817_ID_DCDC2),
1873 .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC2),
1874 .ramp_mask = RK817_RAMP_RATE_MASK,
1875 .ramp_delay_table = rk817_buck1_4_ramp_table,
1876 .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
1877 .of_map_mode = rk8xx_regulator_of_map_mode,
1878 .owner = THIS_MODULE,
1879 }, {
1880 .name = "DCDC_REG3",
1881 .supply_name = "vcc3",
1882 .of_match = of_match_ptr("DCDC_REG3"),
1883 .regulators_node = of_match_ptr("regulators"),
1884 .id = RK817_ID_DCDC3,
1885 .ops = &rk817_buck_ops_range,
1886 .type = REGULATOR_VOLTAGE,
1887 .n_voltages = RK817_BUCK1_SEL_CNT + 1,
1888 .linear_ranges = rk817_buck1_voltage_ranges,
1889 .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
1890 .vsel_reg = RK817_BUCK3_ON_VSEL_REG,
1891 .vsel_mask = RK817_BUCK_VSEL_MASK,
1892 .enable_reg = RK817_POWER_EN_REG(0),
1893 .enable_mask = ENABLE_MASK(RK817_ID_DCDC3),
1894 .enable_val = ENABLE_MASK(RK817_ID_DCDC3),
1895 .disable_val = DISABLE_VAL(RK817_ID_DCDC3),
1896 .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC3),
1897 .ramp_mask = RK817_RAMP_RATE_MASK,
1898 .ramp_delay_table = rk817_buck1_4_ramp_table,
1899 .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
1900 .of_map_mode = rk8xx_regulator_of_map_mode,
1901 .owner = THIS_MODULE,
1902 }, {
1903 .name = "DCDC_REG4",
1904 .supply_name = "vcc4",
1905 .of_match = of_match_ptr("DCDC_REG4"),
1906 .regulators_node = of_match_ptr("regulators"),
1907 .id = RK817_ID_DCDC4,
1908 .ops = &rk817_buck_ops_range,
1909 .type = REGULATOR_VOLTAGE,
1910 .n_voltages = RK817_BUCK3_SEL_CNT + 1,
1911 .linear_ranges = rk817_buck3_voltage_ranges,
1912 .n_linear_ranges = ARRAY_SIZE(rk817_buck3_voltage_ranges),
1913 .vsel_reg = RK817_BUCK4_ON_VSEL_REG,
1914 .vsel_mask = RK817_BUCK_VSEL_MASK,
1915 .enable_reg = RK817_POWER_EN_REG(0),
1916 .enable_mask = ENABLE_MASK(RK817_ID_DCDC4),
1917 .enable_val = ENABLE_MASK(RK817_ID_DCDC4),
1918 .disable_val = DISABLE_VAL(RK817_ID_DCDC4),
1919 .ramp_reg = RK817_BUCK_CONFIG_REG(RK817_ID_DCDC4),
1920 .ramp_mask = RK817_RAMP_RATE_MASK,
1921 .ramp_delay_table = rk817_buck1_4_ramp_table,
1922 .n_ramp_values = ARRAY_SIZE(rk817_buck1_4_ramp_table),
1923 .of_map_mode = rk8xx_regulator_of_map_mode,
1924 .owner = THIS_MODULE,
1925 },
1926 RK817_DESC(RK817_ID_LDO1, "LDO_REG1", "vcc5", 600, 3400, 25,
1927 RK817_LDO_ON_VSEL_REG(0), RK817_LDO_VSEL_MASK,
1928 RK817_POWER_EN_REG(1), ENABLE_MASK(0),
1929 DISABLE_VAL(0), 400),
1930 RK817_DESC(RK817_ID_LDO2, "LDO_REG2", "vcc5", 600, 3400, 25,
1931 RK817_LDO_ON_VSEL_REG(1), RK817_LDO_VSEL_MASK,
1932 RK817_POWER_EN_REG(1), ENABLE_MASK(1),
1933 DISABLE_VAL(1), 400),
1934 RK817_DESC(RK817_ID_LDO3, "LDO_REG3", "vcc5", 600, 3400, 25,
1935 RK817_LDO_ON_VSEL_REG(2), RK817_LDO_VSEL_MASK,
1936 RK817_POWER_EN_REG(1), ENABLE_MASK(2),
1937 DISABLE_VAL(2), 400),
1938 RK817_DESC(RK817_ID_LDO4, "LDO_REG4", "vcc6", 600, 3400, 25,
1939 RK817_LDO_ON_VSEL_REG(3), RK817_LDO_VSEL_MASK,
1940 RK817_POWER_EN_REG(1), ENABLE_MASK(3),
1941 DISABLE_VAL(3), 400),
1942 RK817_DESC(RK817_ID_LDO5, "LDO_REG5", "vcc6", 600, 3400, 25,
1943 RK817_LDO_ON_VSEL_REG(4), RK817_LDO_VSEL_MASK,
1944 RK817_POWER_EN_REG(2), ENABLE_MASK(0),
1945 DISABLE_VAL(0), 400),
1946 RK817_DESC(RK817_ID_LDO6, "LDO_REG6", "vcc6", 600, 3400, 25,
1947 RK817_LDO_ON_VSEL_REG(5), RK817_LDO_VSEL_MASK,
1948 RK817_POWER_EN_REG(2), ENABLE_MASK(1),
1949 DISABLE_VAL(1), 400),
1950 RK817_DESC(RK817_ID_LDO7, "LDO_REG7", "vcc7", 600, 3400, 25,
1951 RK817_LDO_ON_VSEL_REG(6), RK817_LDO_VSEL_MASK,
1952 RK817_POWER_EN_REG(2), ENABLE_MASK(2),
1953 DISABLE_VAL(2), 400),
1954 RK817_DESC(RK817_ID_LDO8, "LDO_REG8", "vcc7", 600, 3400, 25,
1955 RK817_LDO_ON_VSEL_REG(7), RK817_LDO_VSEL_MASK,
1956 RK817_POWER_EN_REG(2), ENABLE_MASK(3),
1957 DISABLE_VAL(3), 400),
1958 RK817_DESC(RK817_ID_LDO9, "LDO_REG9", "vcc7", 600, 3400, 25,
1959 RK817_LDO_ON_VSEL_REG(8), RK817_LDO_VSEL_MASK,
1960 RK817_POWER_EN_REG(3), ENABLE_MASK(0),
1961 DISABLE_VAL(0), 400),
1962 RK817_BOOST_DESC(RK817_ID_BOOST, "BOOST", "vcc8", 4700, 5400, 100,
1963 RK817_BOOST_OTG_CFG, RK817_BOOST_VSEL_MASK,
1964 RK817_POWER_EN_REG(3), ENABLE_MASK(1), ENABLE_MASK(1),
1965 DISABLE_VAL(1), 400, 3500 - 5400),
1966 RK817_DESC_SWITCH(RK817_ID_BOOST_OTG_SW, "OTG_SWITCH", "vcc9",
1967 RK817_POWER_EN_REG(3), ENABLE_MASK(2),
1968 DISABLE_VAL(2)),
1969 };
1970
1971 static const struct regulator_desc rk818_reg[] = {
1972 {
1973 .name = "DCDC_REG1",
1974 .supply_name = "vcc1",
1975 .of_match = of_match_ptr("DCDC_REG1"),
1976 .regulators_node = of_match_ptr("regulators"),
1977 .id = RK818_ID_DCDC1,
1978 .ops = &rk808_reg_ops,
1979 .type = REGULATOR_VOLTAGE,
1980 .min_uV = 712500,
1981 .uV_step = 12500,
1982 .n_voltages = 64,
1983 .vsel_reg = RK818_BUCK1_ON_VSEL_REG,
1984 .vsel_mask = RK818_BUCK_VSEL_MASK,
1985 .enable_reg = RK818_DCDC_EN_REG,
1986 .enable_mask = BIT(0),
1987 .owner = THIS_MODULE,
1988 }, {
1989 .name = "DCDC_REG2",
1990 .supply_name = "vcc2",
1991 .of_match = of_match_ptr("DCDC_REG2"),
1992 .regulators_node = of_match_ptr("regulators"),
1993 .id = RK818_ID_DCDC2,
1994 .ops = &rk808_reg_ops,
1995 .type = REGULATOR_VOLTAGE,
1996 .min_uV = 712500,
1997 .uV_step = 12500,
1998 .n_voltages = 64,
1999 .vsel_reg = RK818_BUCK2_ON_VSEL_REG,
2000 .vsel_mask = RK818_BUCK_VSEL_MASK,
2001 .enable_reg = RK818_DCDC_EN_REG,
2002 .enable_mask = BIT(1),
2003 .owner = THIS_MODULE,
2004 }, {
2005 .name = "DCDC_REG3",
2006 .supply_name = "vcc3",
2007 .of_match = of_match_ptr("DCDC_REG3"),
2008 .regulators_node = of_match_ptr("regulators"),
2009 .id = RK818_ID_DCDC3,
2010 .ops = &rk808_switch_ops,
2011 .type = REGULATOR_VOLTAGE,
2012 .n_voltages = 1,
2013 .enable_reg = RK818_DCDC_EN_REG,
2014 .enable_mask = BIT(2),
2015 .owner = THIS_MODULE,
2016 },
2017 RK8XX_DESC(RK818_ID_DCDC4, "DCDC_REG4", "vcc4", 1800, 3600, 100,
2018 RK818_BUCK4_ON_VSEL_REG, RK818_BUCK4_VSEL_MASK,
2019 RK818_DCDC_EN_REG, BIT(3), 0),
2020 RK8XX_DESC(RK818_ID_BOOST, "DCDC_BOOST", "boost", 4700, 5400, 100,
2021 RK818_BOOST_LDO9_ON_VSEL_REG, RK818_BOOST_ON_VSEL_MASK,
2022 RK818_DCDC_EN_REG, BIT(4), 0),
2023 RK8XX_DESC(RK818_ID_LDO1, "LDO_REG1", "vcc6", 1800, 3400, 100,
2024 RK818_LDO1_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
2025 BIT(0), 400),
2026 RK8XX_DESC(RK818_ID_LDO2, "LDO_REG2", "vcc6", 1800, 3400, 100,
2027 RK818_LDO2_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
2028 BIT(1), 400),
2029 {
2030 .name = "LDO_REG3",
2031 .supply_name = "vcc7",
2032 .of_match = of_match_ptr("LDO_REG3"),
2033 .regulators_node = of_match_ptr("regulators"),
2034 .id = RK818_ID_LDO3,
2035 .ops = &rk808_reg_ops_ranges,
2036 .type = REGULATOR_VOLTAGE,
2037 .n_voltages = 16,
2038 .linear_ranges = rk808_ldo3_voltage_ranges,
2039 .n_linear_ranges = ARRAY_SIZE(rk808_ldo3_voltage_ranges),
2040 .vsel_reg = RK818_LDO3_ON_VSEL_REG,
2041 .vsel_mask = RK818_LDO3_ON_VSEL_MASK,
2042 .enable_reg = RK818_LDO_EN_REG,
2043 .enable_mask = BIT(2),
2044 .enable_time = 400,
2045 .owner = THIS_MODULE,
2046 },
2047 RK8XX_DESC(RK818_ID_LDO4, "LDO_REG4", "vcc8", 1800, 3400, 100,
2048 RK818_LDO4_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
2049 BIT(3), 400),
2050 RK8XX_DESC(RK818_ID_LDO5, "LDO_REG5", "vcc7", 1800, 3400, 100,
2051 RK818_LDO5_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
2052 BIT(4), 400),
2053 RK8XX_DESC(RK818_ID_LDO6, "LDO_REG6", "vcc8", 800, 2500, 100,
2054 RK818_LDO6_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
2055 BIT(5), 400),
2056 RK8XX_DESC(RK818_ID_LDO7, "LDO_REG7", "vcc7", 800, 2500, 100,
2057 RK818_LDO7_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
2058 BIT(6), 400),
2059 RK8XX_DESC(RK818_ID_LDO8, "LDO_REG8", "vcc8", 1800, 3400, 100,
2060 RK818_LDO8_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
2061 BIT(7), 400),
2062 RK8XX_DESC(RK818_ID_LDO9, "LDO_REG9", "vcc9", 1800, 3400, 100,
2063 RK818_BOOST_LDO9_ON_VSEL_REG, RK818_LDO_VSEL_MASK,
2064 RK818_DCDC_EN_REG, BIT(5), 400),
2065 RK8XX_DESC_SWITCH(RK818_ID_SWITCH, "SWITCH_REG", "vcc9",
2066 RK818_DCDC_EN_REG, BIT(6)),
2067 RK8XX_DESC_SWITCH(RK818_ID_HDMI_SWITCH, "HDMI_SWITCH", "h_5v",
2068 RK818_H5V_EN_REG, BIT(0)),
2069 RK8XX_DESC_SWITCH(RK818_ID_OTG_SWITCH, "OTG_SWITCH", "usb",
2070 RK818_DCDC_EN_REG, BIT(7)),
2071 };
2072
rk808_regulator_dt_parse_pdata(struct device * dev,struct regmap * map,struct rk808_regulator_data * pdata)2073 static int rk808_regulator_dt_parse_pdata(struct device *dev, struct regmap *map,
2074 struct rk808_regulator_data *pdata)
2075 {
2076 struct device_node *np;
2077 int tmp, ret = 0, i;
2078
2079 np = of_get_child_by_name(dev->of_node, "regulators");
2080 if (!np)
2081 return -ENXIO;
2082
2083 for (i = 0; i < ARRAY_SIZE(pdata->dvs_gpio); i++) {
2084 pdata->dvs_gpio[i] =
2085 devm_gpiod_get_index_optional(dev, "dvs", i, GPIOD_OUT_LOW);
2086 if (IS_ERR(pdata->dvs_gpio[i])) {
2087 ret = dev_err_probe(dev, PTR_ERR(pdata->dvs_gpio[i]),
2088 "failed to get dvs%d gpio\n", i);
2089 goto dt_parse_end;
2090 }
2091
2092 if (!pdata->dvs_gpio[i]) {
2093 dev_dbg(dev, "there is no dvs%d gpio\n", i);
2094 continue;
2095 }
2096
2097 tmp = i ? RK808_DVS2_POL : RK808_DVS1_POL;
2098 ret = regmap_update_bits(map, RK808_IO_POL_REG, tmp,
2099 gpiod_is_active_low(pdata->dvs_gpio[i]) ? 0 : tmp);
2100 }
2101
2102 dt_parse_end:
2103 of_node_put(np);
2104 return ret;
2105 }
2106
rk808_regulator_probe(struct platform_device * pdev)2107 static int rk808_regulator_probe(struct platform_device *pdev)
2108 {
2109 struct rk808 *rk808 = dev_get_drvdata(pdev->dev.parent);
2110 struct regulator_config config = {};
2111 struct regulator_dev *rk808_rdev;
2112 struct rk808_regulator_data *pdata;
2113 const struct regulator_desc *regulators;
2114 struct regmap *regmap;
2115 int ret, i, nregulators;
2116
2117 pdev->dev.of_node = pdev->dev.parent->of_node;
2118 pdev->dev.of_node_reused = true;
2119
2120 regmap = dev_get_regmap(pdev->dev.parent, NULL);
2121 if (!regmap)
2122 return -ENODEV;
2123
2124 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
2125 if (!pdata)
2126 return -ENOMEM;
2127
2128 switch (rk808->variant) {
2129 case RK801_ID:
2130 regulators = rk801_reg;
2131 nregulators = RK801_NUM_REGULATORS;
2132 break;
2133 case RK805_ID:
2134 regulators = rk805_reg;
2135 nregulators = RK805_NUM_REGULATORS;
2136 break;
2137 case RK806_ID:
2138 regulators = rk806_reg;
2139 nregulators = ARRAY_SIZE(rk806_reg);
2140 break;
2141 case RK808_ID:
2142 /* DVS0/1 GPIOs are supported on the RK808 only */
2143 ret = rk808_regulator_dt_parse_pdata(&pdev->dev, regmap, pdata);
2144 if (ret < 0)
2145 return ret;
2146
2147 regulators = rk808_reg;
2148 nregulators = RK808_NUM_REGULATORS;
2149 break;
2150 case RK809_ID:
2151 regulators = rk809_reg;
2152 nregulators = RK809_NUM_REGULATORS;
2153 break;
2154 case RK816_ID:
2155 regulators = rk816_reg;
2156 nregulators = ARRAY_SIZE(rk816_reg);
2157 break;
2158 case RK817_ID:
2159 regulators = rk817_reg;
2160 nregulators = RK817_NUM_REGULATORS;
2161 break;
2162 case RK818_ID:
2163 regulators = rk818_reg;
2164 nregulators = RK818_NUM_REGULATORS;
2165 break;
2166 default:
2167 return dev_err_probe(&pdev->dev, -EINVAL,
2168 "unsupported RK8xx ID %lu\n", rk808->variant);
2169 }
2170
2171 platform_set_drvdata(pdev, pdata);
2172
2173 config.dev = &pdev->dev;
2174 config.driver_data = pdata;
2175 config.regmap = regmap;
2176
2177 /* Instantiate the regulators */
2178 for (i = 0; i < nregulators; i++) {
2179 rk808_rdev = devm_regulator_register(&pdev->dev,
2180 ®ulators[i], &config);
2181 if (IS_ERR(rk808_rdev))
2182 return dev_err_probe(&pdev->dev, PTR_ERR(rk808_rdev),
2183 "failed to register %d regulator\n", i);
2184 }
2185
2186 return 0;
2187 }
2188
2189 static struct platform_driver rk808_regulator_driver = {
2190 .probe = rk808_regulator_probe,
2191 .driver = {
2192 .name = "rk808-regulator",
2193 .probe_type = PROBE_FORCE_SYNCHRONOUS,
2194 },
2195 };
2196
2197 module_platform_driver(rk808_regulator_driver);
2198
2199 MODULE_DESCRIPTION("Rockchip RK80x/RK81x PMIC series regulator driver");
2200 MODULE_AUTHOR("Tony xie <tony.xie@rock-chips.com>");
2201 MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>");
2202 MODULE_AUTHOR("Zhang Qing <zhangqing@rock-chips.com>");
2203 MODULE_AUTHOR("Wadim Egorov <w.egorov@phytec.de>");
2204 MODULE_AUTHOR("Xu Shengfei <xsf@rock-chips.com>");
2205 MODULE_LICENSE("GPL");
2206 MODULE_ALIAS("platform:rk808-regulator");
2207