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