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