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