drivers/regulator/rk808-regulator.c

   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 <[email protected]>
   9  * Author: Zhang Qing <[email protected]>
  10  * Author: Xu Shengfei <[email protected]>
  11  *
  12  * Copyright (C) 2016 PHYTEC Messtechnik GmbH
  13  *
  14  * Author: Wadim Egorov <[email protected]>
  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
 197 struct 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
 208 struct rk808_regulator_data {
 209         struct gpio_desc *dvs_gpio[2];
 210 };
 211
 212 static 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
 219 static 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
 248 static 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
 255 static 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
 262 static const unsigned int rk808_buck1_2_ramp_table[] = {
 263         2000, 4000, 6000, 10000
 264 };
 265
 266 /* RK817/RK809/RK816 (buck 1/2 only) */
 267 static const unsigned int rk817_buck1_4_ramp_table[] = {
 268         3000, 6300, 12500, 25000
 269 };
 270
 271 static 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
 296 static 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
 316 static 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
 329 static const unsigned int rk806_ramp_delay_table_dcdc[] = {
 330         50000, 25000, 12500, 6250, 3125, 1560, 961, 390
 331 };
 332
 333 static 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
 366 static const unsigned int rk806_ramp_delay_table_ldo[] = {
 367         100000, 50000, 25000, 12500, 6280, 3120, 1900, 780
 368 };
 369
 370 static 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
 383 static 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
 388 static 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
 393 static 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
 398 static 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
 421 static 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
 470 static 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
 508 static 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
 523 static 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
 538 static 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
 563 static 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
 574 static 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
 585 static 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
 609 static 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
 618 static 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
 626 static 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
 637 static 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
 648 static 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
 663 static 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
 672 static 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
 680 static 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
 707 static int rk817_set_suspend_enable(struct regulator_dev *rdev)
 708 {
 709         return rk817_set_suspend_enable_ctrl(rdev, 1);
 710 }
 711
 712 static int rk817_set_suspend_disable(struct regulator_dev *rdev)
 713 {
 714         return rk817_set_suspend_enable_ctrl(rdev, 0);
 715 }
 716
 717 static 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
 738 static 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
 755 static 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
 770 static int rk8xx_is_enabled_wmsk_regmap(struct regulator_dev *rdev)
 771 {
 772         unsigned int val;
 773         int ret;
 774
 775         ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
 776         if (ret != 0)
 777                 return ret;
 778
 779         /* 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
 793 static 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
 805 static 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
 818 static 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
 826 static 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
 847 static 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
 865 static 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
 884 static 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
 899 static 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
 912 static 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
 925 static 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
 933 static 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
 939 static 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
 953 static 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
 971 static 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
 988 static 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
1001 static 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
1014 static 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
1026 static 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
1044 static 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
1052 static 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
1114 static 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
1120 static 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
1125 static 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
1220 static 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
1322 static 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
1482 static 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
1487 static 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
1593 static 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
1732 static 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
1834 static 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
1863 dt_parse_end:
1864         of_node_put(np);
1865         return ret;
1866 }
1867
1868 static 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
1946 static 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
1954 module_platform_driver(rk808_regulator_driver);
1955
1956 MODULE_DESCRIPTION("Rockchip RK80x/RK81x PMIC series regulator driver");
1957 MODULE_AUTHOR("Tony xie <[email protected]>");
1958 MODULE_AUTHOR("Chris Zhong <[email protected]>");
1959 MODULE_AUTHOR("Zhang Qing <[email protected]>");
1960 MODULE_AUTHOR("Wadim Egorov <[email protected]>");
1961 MODULE_AUTHOR("Xu Shengfei <[email protected]>");
1962 MODULE_LICENSE("GPL");
1963 MODULE_ALIAS("platform:rk808-regulator");