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