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