drivers/regulator/rk808-regulator.c

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