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 10000\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 rk817_set_suspend_voltage(struct regulator_dev *rdev, int uv) 415 { 416 unsigned int reg; 417 int sel = regulator_map_voltage_linear(rdev, uv, uv); 418 /* only ldo1~ldo9 */ 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 rk808_set_suspend_voltage_range(struct regulator_dev *rdev, int uv) 430 { 431 unsigned int reg; 432 int sel = regulator_map_voltage_linear_range(rdev, uv, uv); 433 434 if (sel < 0) 435 return -EINVAL; 436 437 reg = rdev->desc->vsel_reg + RK808_SLP_REG_OFFSET; 438 439 return regmap_update_bits(rdev->regmap, reg, 440 rdev->desc->vsel_mask, 441 sel); 442 } 443 444 static int rk805_set_suspend_enable(struct regulator_dev *rdev) 445 { 446 unsigned int reg; 447 448 reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET; 449 450 return regmap_update_bits(rdev->regmap, reg, 451 rdev->desc->enable_mask, 452 rdev->desc->enable_mask); 453 } 454 455 static int rk805_set_suspend_disable(struct regulator_dev *rdev) 456 { 457 unsigned int reg; 458 459 reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET; 460 461 return regmap_update_bits(rdev->regmap, reg, 462 rdev->desc->enable_mask, 463 0); 464 } 465 466 static int rk808_set_suspend_enable(struct regulator_dev *rdev) 467 { 468 unsigned int reg; 469 470 reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET; 471 472 return regmap_update_bits(rdev->regmap, reg, 473 rdev->desc->enable_mask, 474 0); 475 } 476 477 static int rk808_set_suspend_disable(struct regulator_dev *rdev) 478 { 479 unsigned int reg; 480 481 reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET; 482 483 return regmap_update_bits(rdev->regmap, reg, 484 rdev->desc->enable_mask, 485 rdev->desc->enable_mask); 486 } 487 488 static int rk817_set_suspend_enable_ctrl(struct regulator_dev *rdev, 489 unsigned int en) 490 { 491 unsigned int reg; 492 int id = rdev_get_id(rdev); 493 unsigned int id_slp, msk, val; 494 495 if (id >= RK817_ID_DCDC1 && id <= RK817_ID_DCDC4) 496 id_slp = id; 497 else if (id >= RK817_ID_LDO1 && id <= RK817_ID_LDO8) 498 id_slp = 8 + (id - RK817_ID_LDO1); 499 else if (id >= RK817_ID_LDO9 && id <= RK809_ID_SW2) 500 id_slp = 4 + (id - RK817_ID_LDO9); 501 else 502 return -EINVAL; 503 504 reg = RK817_POWER_SLP_EN_REG(id_slp / 8); 505 506 msk = BIT(id_slp % 8); 507 if (en) 508 val = msk; 509 else 510 val = 0; 511 512 return regmap_update_bits(rdev->regmap, reg, msk, val); 513 } 514 515 static int rk817_set_suspend_enable(struct regulator_dev *rdev) 516 { 517 return rk817_set_suspend_enable_ctrl(rdev, 1); 518 } 519 520 static int rk817_set_suspend_disable(struct regulator_dev *rdev) 521 { 522 return rk817_set_suspend_enable_ctrl(rdev, 0); 523 } 524 525 static int rk8xx_set_suspend_mode(struct regulator_dev *rdev, unsigned int mode) 526 { 527 unsigned int reg; 528 529 reg = rdev->desc->vsel_reg + RK808_SLP_REG_OFFSET; 530 531 switch (mode) { 532 case REGULATOR_MODE_FAST: 533 return regmap_update_bits(rdev->regmap, reg, 534 PWM_MODE_MSK, FPWM_MODE); 535 case REGULATOR_MODE_NORMAL: 536 return regmap_update_bits(rdev->regmap, reg, 537 PWM_MODE_MSK, AUTO_PWM_MODE); 538 default: 539 dev_err(&rdev->dev, "do not support this mode\n"); 540 return -EINVAL; 541 } 542 543 return 0; 544 } 545 546 static int rk8xx_set_mode(struct regulator_dev *rdev, unsigned int mode) 547 { 548 switch (mode) { 549 case REGULATOR_MODE_FAST: 550 return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg, 551 PWM_MODE_MSK, FPWM_MODE); 552 case REGULATOR_MODE_NORMAL: 553 return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg, 554 PWM_MODE_MSK, AUTO_PWM_MODE); 555 default: 556 dev_err(&rdev->dev, "do not support this mode\n"); 557 return -EINVAL; 558 } 559 560 return 0; 561 } 562 563 static unsigned int rk8xx_get_mode(struct regulator_dev *rdev) 564 { 565 unsigned int val; 566 int err; 567 568 err = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val); 569 if (err) 570 return err; 571 572 if (val & FPWM_MODE) 573 return REGULATOR_MODE_FAST; 574 else 575 return REGULATOR_MODE_NORMAL; 576 } 577 578 static int rk8xx_is_enabled_wmsk_regmap(struct regulator_dev *rdev) 579 { 580 unsigned int val; 581 int ret; 582 583 ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val); 584 if (ret != 0) 585 return ret; 586 587 /* add write mask bit */ 588 val |= (rdev->desc->enable_mask & 0xf0); 589 val &= rdev->desc->enable_mask; 590 591 if (rdev->desc->enable_is_inverted) { 592 if (rdev->desc->enable_val) 593 return val != rdev->desc->enable_val; 594 return (val == 0); 595 } 596 if (rdev->desc->enable_val) 597 return val == rdev->desc->enable_val; 598 return val != 0; 599 } 600 601 static unsigned int rk8xx_regulator_of_map_mode(unsigned int mode) 602 { 603 switch (mode) { 604 case 1: 605 return REGULATOR_MODE_FAST; 606 case 2: 607 return REGULATOR_MODE_NORMAL; 608 default: 609 return REGULATOR_MODE_INVALID; 610 } 611 } 612 613 static const struct regulator_ops rk805_reg_ops = { 614 .list_voltage = regulator_list_voltage_linear, 615 .map_voltage = regulator_map_voltage_linear, 616 .get_voltage_sel = regulator_get_voltage_sel_regmap, 617 .set_voltage_sel = regulator_set_voltage_sel_regmap, 618 .enable = regulator_enable_regmap, 619 .disable = regulator_disable_regmap, 620 .is_enabled = regulator_is_enabled_regmap, 621 .set_suspend_voltage = rk808_set_suspend_voltage, 622 .set_suspend_enable = rk805_set_suspend_enable, 623 .set_suspend_disable = rk805_set_suspend_disable, 624 }; 625 626 static const struct regulator_ops rk805_switch_ops = { 627 .enable = regulator_enable_regmap, 628 .disable = regulator_disable_regmap, 629 .is_enabled = regulator_is_enabled_regmap, 630 .set_suspend_enable = rk805_set_suspend_enable, 631 .set_suspend_disable = rk805_set_suspend_disable, 632 }; 633 634 static const struct regulator_ops rk808_buck1_2_ops = { 635 .list_voltage = regulator_list_voltage_linear, 636 .map_voltage = regulator_map_voltage_linear, 637 .get_voltage_sel = rk808_buck1_2_get_voltage_sel_regmap, 638 .set_voltage_sel = rk808_buck1_2_set_voltage_sel, 639 .set_voltage_time_sel = rk808_buck1_2_set_voltage_time_sel, 640 .enable = regulator_enable_regmap, 641 .disable = regulator_disable_regmap, 642 .is_enabled = regulator_is_enabled_regmap, 643 .set_ramp_delay = rk808_set_ramp_delay, 644 .set_suspend_voltage = rk808_set_suspend_voltage, 645 .set_suspend_enable = rk808_set_suspend_enable, 646 .set_suspend_disable = rk808_set_suspend_disable, 647 }; 648 649 static const struct regulator_ops rk808_reg_ops = { 650 .list_voltage = regulator_list_voltage_linear, 651 .map_voltage = regulator_map_voltage_linear, 652 .get_voltage_sel = regulator_get_voltage_sel_regmap, 653 .set_voltage_sel = regulator_set_voltage_sel_regmap, 654 .enable = regulator_enable_regmap, 655 .disable = regulator_disable_regmap, 656 .is_enabled = regulator_is_enabled_regmap, 657 .set_suspend_voltage = rk808_set_suspend_voltage, 658 .set_suspend_enable = rk808_set_suspend_enable, 659 .set_suspend_disable = rk808_set_suspend_disable, 660 }; 661 662 static const struct regulator_ops rk808_reg_ops_ranges = { 663 .list_voltage = regulator_list_voltage_linear_range, 664 .map_voltage = regulator_map_voltage_linear_range, 665 .get_voltage_sel = regulator_get_voltage_sel_regmap, 666 .set_voltage_sel = regulator_set_voltage_sel_regmap, 667 .enable = regulator_enable_regmap, 668 .disable = regulator_disable_regmap, 669 .is_enabled = regulator_is_enabled_regmap, 670 .set_suspend_voltage = rk808_set_suspend_voltage_range, 671 .set_suspend_enable = rk808_set_suspend_enable, 672 .set_suspend_disable = rk808_set_suspend_disable, 673 }; 674 675 static const struct regulator_ops rk808_switch_ops = { 676 .enable = regulator_enable_regmap, 677 .disable = regulator_disable_regmap, 678 .is_enabled = regulator_is_enabled_regmap, 679 .set_suspend_enable = rk808_set_suspend_enable, 680 .set_suspend_disable = rk808_set_suspend_disable, 681 }; 682 683 static const struct regulator_linear_range rk805_buck_1_2_voltage_ranges[] = { 684 REGULATOR_LINEAR_RANGE(712500, 0, 59, 12500), 685 REGULATOR_LINEAR_RANGE(1800000, 60, 62, 200000), 686 REGULATOR_LINEAR_RANGE(2300000, 63, 63, 0), 687 }; 688 689 static struct regulator_ops rk809_buck5_ops_range = { 690 .list_voltage = regulator_list_voltage_linear_range, 691 .map_voltage = regulator_map_voltage_linear_range, 692 .get_voltage_sel = regulator_get_voltage_sel_regmap, 693 .set_voltage_sel = regulator_set_voltage_sel_regmap, 694 .set_voltage_time_sel = regulator_set_voltage_time_sel, 695 .enable = regulator_enable_regmap, 696 .disable = regulator_disable_regmap, 697 .is_enabled = rk8xx_is_enabled_wmsk_regmap, 698 .set_suspend_voltage = rk808_set_suspend_voltage_range, 699 .set_suspend_enable = rk817_set_suspend_enable, 700 .set_suspend_disable = rk817_set_suspend_disable, 701 }; 702 703 static struct regulator_ops rk817_reg_ops = { 704 .list_voltage = regulator_list_voltage_linear, 705 .map_voltage = regulator_map_voltage_linear, 706 .get_voltage_sel = regulator_get_voltage_sel_regmap, 707 .set_voltage_sel = regulator_set_voltage_sel_regmap, 708 .enable = regulator_enable_regmap, 709 .disable = regulator_disable_regmap, 710 .is_enabled = rk8xx_is_enabled_wmsk_regmap, 711 .set_suspend_voltage = rk817_set_suspend_voltage, 712 .set_suspend_enable = rk817_set_suspend_enable, 713 .set_suspend_disable = rk817_set_suspend_disable, 714 }; 715 716 static struct regulator_ops rk817_boost_ops = { 717 .list_voltage = regulator_list_voltage_linear, 718 .map_voltage = regulator_map_voltage_linear, 719 .get_voltage_sel = regulator_get_voltage_sel_regmap, 720 .set_voltage_sel = regulator_set_voltage_sel_regmap, 721 .enable = regulator_enable_regmap, 722 .disable = regulator_disable_regmap, 723 .is_enabled = rk8xx_is_enabled_wmsk_regmap, 724 .set_suspend_enable = rk817_set_suspend_enable, 725 .set_suspend_disable = rk817_set_suspend_disable, 726 }; 727 728 static struct regulator_ops rk817_buck_ops_range = { 729 .list_voltage = regulator_list_voltage_linear_range, 730 .map_voltage = regulator_map_voltage_linear_range, 731 .get_voltage_sel = regulator_get_voltage_sel_regmap, 732 .set_voltage_sel = regulator_set_voltage_sel_regmap, 733 .set_voltage_time_sel = regulator_set_voltage_time_sel, 734 .enable = regulator_enable_regmap, 735 .disable = regulator_disable_regmap, 736 .is_enabled = rk8xx_is_enabled_wmsk_regmap, 737 .set_mode = rk8xx_set_mode, 738 .get_mode = rk8xx_get_mode, 739 .set_suspend_mode = rk8xx_set_suspend_mode, 740 .set_ramp_delay = rk817_set_ramp_delay, 741 .set_suspend_voltage = rk808_set_suspend_voltage_range, 742 .set_suspend_enable = rk817_set_suspend_enable, 743 .set_suspend_disable = rk817_set_suspend_disable, 744 }; 745 746 static struct regulator_ops rk817_switch_ops = { 747 .enable = regulator_enable_regmap, 748 .disable = regulator_disable_regmap, 749 .is_enabled = rk8xx_is_enabled_wmsk_regmap, 750 .set_suspend_enable = rk817_set_suspend_enable, 751 .set_suspend_disable = rk817_set_suspend_disable, 752 }; 753 754 static const struct regulator_desc rk805_reg[] = { 755 { 756 .name = "DCDC_REG1", 757 .supply_name = "vcc1", 758 .of_match = of_match_ptr("DCDC_REG1"), 759 .regulators_node = of_match_ptr("regulators"), 760 .id = RK805_ID_DCDC1, 761 .ops = &rk808_reg_ops_ranges, 762 .type = REGULATOR_VOLTAGE, 763 .n_voltages = 64, 764 .linear_ranges = rk805_buck_1_2_voltage_ranges, 765 .n_linear_ranges = ARRAY_SIZE(rk805_buck_1_2_voltage_ranges), 766 .vsel_reg = RK805_BUCK1_ON_VSEL_REG, 767 .vsel_mask = RK818_BUCK_VSEL_MASK, 768 .enable_reg = RK805_DCDC_EN_REG, 769 .enable_mask = BIT(0), 770 .owner = THIS_MODULE, 771 }, { 772 .name = "DCDC_REG2", 773 .supply_name = "vcc2", 774 .of_match = of_match_ptr("DCDC_REG2"), 775 .regulators_node = of_match_ptr("regulators"), 776 .id = RK805_ID_DCDC2, 777 .ops = &rk808_reg_ops_ranges, 778 .type = REGULATOR_VOLTAGE, 779 .n_voltages = 64, 780 .linear_ranges = rk805_buck_1_2_voltage_ranges, 781 .n_linear_ranges = ARRAY_SIZE(rk805_buck_1_2_voltage_ranges), 782 .vsel_reg = RK805_BUCK2_ON_VSEL_REG, 783 .vsel_mask = RK818_BUCK_VSEL_MASK, 784 .enable_reg = RK805_DCDC_EN_REG, 785 .enable_mask = BIT(1), 786 .owner = THIS_MODULE, 787 }, { 788 .name = "DCDC_REG3", 789 .supply_name = "vcc3", 790 .of_match = of_match_ptr("DCDC_REG3"), 791 .regulators_node = of_match_ptr("regulators"), 792 .id = RK805_ID_DCDC3, 793 .ops = &rk805_switch_ops, 794 .type = REGULATOR_VOLTAGE, 795 .n_voltages = 1, 796 .enable_reg = RK805_DCDC_EN_REG, 797 .enable_mask = BIT(2), 798 .owner = THIS_MODULE, 799 }, 800 801 RK805_DESC(RK805_ID_DCDC4, "DCDC_REG4", "vcc4", 800, 3400, 100, 802 RK805_BUCK4_ON_VSEL_REG, RK818_BUCK4_VSEL_MASK, 803 RK805_DCDC_EN_REG, BIT(3), 0), 804 805 RK805_DESC(RK805_ID_LDO1, "LDO_REG1", "vcc5", 800, 3400, 100, 806 RK805_LDO1_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK805_LDO_EN_REG, 807 BIT(0), 400), 808 RK805_DESC(RK805_ID_LDO2, "LDO_REG2", "vcc5", 800, 3400, 100, 809 RK805_LDO2_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK805_LDO_EN_REG, 810 BIT(1), 400), 811 RK805_DESC(RK805_ID_LDO3, "LDO_REG3", "vcc6", 800, 3400, 100, 812 RK805_LDO3_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK805_LDO_EN_REG, 813 BIT(2), 400), 814 }; 815 816 static const struct regulator_desc rk808_reg[] = { 817 { 818 .name = "DCDC_REG1", 819 .supply_name = "vcc1", 820 .of_match = of_match_ptr("DCDC_REG1"), 821 .regulators_node = of_match_ptr("regulators"), 822 .id = RK808_ID_DCDC1, 823 .ops = &rk808_buck1_2_ops, 824 .type = REGULATOR_VOLTAGE, 825 .min_uV = 712500, 826 .uV_step = 12500, 827 .n_voltages = 64, 828 .vsel_reg = RK808_BUCK1_ON_VSEL_REG, 829 .vsel_mask = RK808_BUCK_VSEL_MASK, 830 .enable_reg = RK808_DCDC_EN_REG, 831 .enable_mask = BIT(0), 832 .owner = THIS_MODULE, 833 }, { 834 .name = "DCDC_REG2", 835 .supply_name = "vcc2", 836 .of_match = of_match_ptr("DCDC_REG2"), 837 .regulators_node = of_match_ptr("regulators"), 838 .id = RK808_ID_DCDC2, 839 .ops = &rk808_buck1_2_ops, 840 .type = REGULATOR_VOLTAGE, 841 .min_uV = 712500, 842 .uV_step = 12500, 843 .n_voltages = 64, 844 .vsel_reg = RK808_BUCK2_ON_VSEL_REG, 845 .vsel_mask = RK808_BUCK_VSEL_MASK, 846 .enable_reg = RK808_DCDC_EN_REG, 847 .enable_mask = BIT(1), 848 .owner = THIS_MODULE, 849 }, { 850 .name = "DCDC_REG3", 851 .supply_name = "vcc3", 852 .of_match = of_match_ptr("DCDC_REG3"), 853 .regulators_node = of_match_ptr("regulators"), 854 .id = RK808_ID_DCDC3, 855 .ops = &rk808_switch_ops, 856 .type = REGULATOR_VOLTAGE, 857 .n_voltages = 1, 858 .enable_reg = RK808_DCDC_EN_REG, 859 .enable_mask = BIT(2), 860 .owner = THIS_MODULE, 861 }, 862 RK8XX_DESC(RK808_ID_DCDC4, "DCDC_REG4", "vcc4", 1800, 3300, 100, 863 RK808_BUCK4_ON_VSEL_REG, RK808_BUCK4_VSEL_MASK, 864 RK808_DCDC_EN_REG, BIT(3), 0), 865 RK8XX_DESC(RK808_ID_LDO1, "LDO_REG1", "vcc6", 1800, 3400, 100, 866 RK808_LDO1_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG, 867 BIT(0), 400), 868 RK8XX_DESC(RK808_ID_LDO2, "LDO_REG2", "vcc6", 1800, 3400, 100, 869 RK808_LDO2_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG, 870 BIT(1), 400), 871 { 872 .name = "LDO_REG3", 873 .supply_name = "vcc7", 874 .of_match = of_match_ptr("LDO_REG3"), 875 .regulators_node = of_match_ptr("regulators"), 876 .id = RK808_ID_LDO3, 877 .ops = &rk808_reg_ops_ranges, 878 .type = REGULATOR_VOLTAGE, 879 .n_voltages = 16, 880 .linear_ranges = rk808_ldo3_voltage_ranges, 881 .n_linear_ranges = ARRAY_SIZE(rk808_ldo3_voltage_ranges), 882 .vsel_reg = RK808_LDO3_ON_VSEL_REG, 883 .vsel_mask = RK808_BUCK4_VSEL_MASK, 884 .enable_reg = RK808_LDO_EN_REG, 885 .enable_mask = BIT(2), 886 .enable_time = 400, 887 .owner = THIS_MODULE, 888 }, 889 RK8XX_DESC(RK808_ID_LDO4, "LDO_REG4", "vcc9", 1800, 3400, 100, 890 RK808_LDO4_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG, 891 BIT(3), 400), 892 RK8XX_DESC(RK808_ID_LDO5, "LDO_REG5", "vcc9", 1800, 3400, 100, 893 RK808_LDO5_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG, 894 BIT(4), 400), 895 RK8XX_DESC(RK808_ID_LDO6, "LDO_REG6", "vcc10", 800, 2500, 100, 896 RK808_LDO6_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG, 897 BIT(5), 400), 898 RK8XX_DESC(RK808_ID_LDO7, "LDO_REG7", "vcc7", 800, 2500, 100, 899 RK808_LDO7_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG, 900 BIT(6), 400), 901 RK8XX_DESC(RK808_ID_LDO8, "LDO_REG8", "vcc11", 1800, 3400, 100, 902 RK808_LDO8_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG, 903 BIT(7), 400), 904 RK8XX_DESC_SWITCH(RK808_ID_SWITCH1, "SWITCH_REG1", "vcc8", 905 RK808_DCDC_EN_REG, BIT(5)), 906 RK8XX_DESC_SWITCH(RK808_ID_SWITCH2, "SWITCH_REG2", "vcc12", 907 RK808_DCDC_EN_REG, BIT(6)), 908 }; 909 910 static const struct regulator_desc rk809_reg[] = { 911 { 912 .name = "DCDC_REG1", 913 .supply_name = "vcc1", 914 .of_match = of_match_ptr("DCDC_REG1"), 915 .regulators_node = of_match_ptr("regulators"), 916 .id = RK817_ID_DCDC1, 917 .ops = &rk817_buck_ops_range, 918 .type = REGULATOR_VOLTAGE, 919 .n_voltages = RK817_BUCK1_SEL_CNT + 1, 920 .linear_ranges = rk817_buck1_voltage_ranges, 921 .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges), 922 .vsel_reg = RK817_BUCK1_ON_VSEL_REG, 923 .vsel_mask = RK817_BUCK_VSEL_MASK, 924 .enable_reg = RK817_POWER_EN_REG(0), 925 .enable_mask = ENABLE_MASK(RK817_ID_DCDC1), 926 .enable_val = ENABLE_MASK(RK817_ID_DCDC1), 927 .disable_val = DISABLE_VAL(RK817_ID_DCDC1), 928 .of_map_mode = rk8xx_regulator_of_map_mode, 929 .owner = THIS_MODULE, 930 }, { 931 .name = "DCDC_REG2", 932 .supply_name = "vcc2", 933 .of_match = of_match_ptr("DCDC_REG2"), 934 .regulators_node = of_match_ptr("regulators"), 935 .id = RK817_ID_DCDC2, 936 .ops = &rk817_buck_ops_range, 937 .type = REGULATOR_VOLTAGE, 938 .n_voltages = RK817_BUCK1_SEL_CNT + 1, 939 .linear_ranges = rk817_buck1_voltage_ranges, 940 .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges), 941 .vsel_reg = RK817_BUCK2_ON_VSEL_REG, 942 .vsel_mask = RK817_BUCK_VSEL_MASK, 943 .enable_reg = RK817_POWER_EN_REG(0), 944 .enable_mask = ENABLE_MASK(RK817_ID_DCDC2), 945 .enable_val = ENABLE_MASK(RK817_ID_DCDC2), 946 .disable_val = DISABLE_VAL(RK817_ID_DCDC2), 947 .of_map_mode = rk8xx_regulator_of_map_mode, 948 .owner = THIS_MODULE, 949 }, { 950 .name = "DCDC_REG3", 951 .supply_name = "vcc3", 952 .of_match = of_match_ptr("DCDC_REG3"), 953 .regulators_node = of_match_ptr("regulators"), 954 .id = RK817_ID_DCDC3, 955 .ops = &rk817_buck_ops_range, 956 .type = REGULATOR_VOLTAGE, 957 .n_voltages = RK817_BUCK1_SEL_CNT + 1, 958 .linear_ranges = rk817_buck1_voltage_ranges, 959 .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges), 960 .vsel_reg = RK817_BUCK3_ON_VSEL_REG, 961 .vsel_mask = RK817_BUCK_VSEL_MASK, 962 .enable_reg = RK817_POWER_EN_REG(0), 963 .enable_mask = ENABLE_MASK(RK817_ID_DCDC3), 964 .enable_val = ENABLE_MASK(RK817_ID_DCDC3), 965 .disable_val = DISABLE_VAL(RK817_ID_DCDC3), 966 .of_map_mode = rk8xx_regulator_of_map_mode, 967 .owner = THIS_MODULE, 968 }, { 969 .name = "DCDC_REG4", 970 .supply_name = "vcc4", 971 .of_match = of_match_ptr("DCDC_REG4"), 972 .regulators_node = of_match_ptr("regulators"), 973 .id = RK817_ID_DCDC4, 974 .ops = &rk817_buck_ops_range, 975 .type = REGULATOR_VOLTAGE, 976 .n_voltages = RK817_BUCK3_SEL_CNT + 1, 977 .linear_ranges = rk817_buck3_voltage_ranges, 978 .n_linear_ranges = ARRAY_SIZE(rk817_buck3_voltage_ranges), 979 .vsel_reg = RK817_BUCK4_ON_VSEL_REG, 980 .vsel_mask = RK817_BUCK_VSEL_MASK, 981 .enable_reg = RK817_POWER_EN_REG(0), 982 .enable_mask = ENABLE_MASK(RK817_ID_DCDC4), 983 .enable_val = ENABLE_MASK(RK817_ID_DCDC4), 984 .disable_val = DISABLE_VAL(RK817_ID_DCDC4), 985 .of_map_mode = rk8xx_regulator_of_map_mode, 986 .owner = THIS_MODULE, 987 }, 988 { 989 .name = "DCDC_REG5", 990 .supply_name = "vcc9", 991 .of_match = of_match_ptr("DCDC_REG5"), 992 .regulators_node = of_match_ptr("regulators"), 993 .id = RK809_ID_DCDC5, 994 .ops = &rk809_buck5_ops_range, 995 .type = REGULATOR_VOLTAGE, 996 .n_voltages = RK809_BUCK5_SEL_CNT, 997 .linear_ranges = rk809_buck5_voltage_ranges, 998 .n_linear_ranges = ARRAY_SIZE(rk809_buck5_voltage_ranges), 999 .vsel_reg = RK809_BUCK5_CONFIG(0), 1000 .vsel_mask = RK809_BUCK5_VSEL_MASK, 1001 .enable_reg = RK817_POWER_EN_REG(3), 1002 .enable_mask = ENABLE_MASK(1), 1003 .enable_val = ENABLE_MASK(1), 1004 .disable_val = DISABLE_VAL(1), 1005 .of_map_mode = rk8xx_regulator_of_map_mode, 1006 .owner = THIS_MODULE, 1007 }, 1008 RK817_DESC(RK817_ID_LDO1, "LDO_REG1", "vcc5", 600, 3400, 25, 1009 RK817_LDO_ON_VSEL_REG(0), RK817_LDO_VSEL_MASK, 1010 RK817_POWER_EN_REG(1), ENABLE_MASK(0), 1011 DISABLE_VAL(0), 400), 1012 RK817_DESC(RK817_ID_LDO2, "LDO_REG2", "vcc5", 600, 3400, 25, 1013 RK817_LDO_ON_VSEL_REG(1), RK817_LDO_VSEL_MASK, 1014 RK817_POWER_EN_REG(1), ENABLE_MASK(1), 1015 DISABLE_VAL(1), 400), 1016 RK817_DESC(RK817_ID_LDO3, "LDO_REG3", "vcc5", 600, 3400, 25, 1017 RK817_LDO_ON_VSEL_REG(2), RK817_LDO_VSEL_MASK, 1018 RK817_POWER_EN_REG(1), ENABLE_MASK(2), 1019 DISABLE_VAL(2), 400), 1020 RK817_DESC(RK817_ID_LDO4, "LDO_REG4", "vcc6", 600, 3400, 25, 1021 RK817_LDO_ON_VSEL_REG(3), RK817_LDO_VSEL_MASK, 1022 RK817_POWER_EN_REG(1), ENABLE_MASK(3), 1023 DISABLE_VAL(3), 400), 1024 RK817_DESC(RK817_ID_LDO5, "LDO_REG5", "vcc6", 600, 3400, 25, 1025 RK817_LDO_ON_VSEL_REG(4), RK817_LDO_VSEL_MASK, 1026 RK817_POWER_EN_REG(2), ENABLE_MASK(0), 1027 DISABLE_VAL(0), 400), 1028 RK817_DESC(RK817_ID_LDO6, "LDO_REG6", "vcc6", 600, 3400, 25, 1029 RK817_LDO_ON_VSEL_REG(5), RK817_LDO_VSEL_MASK, 1030 RK817_POWER_EN_REG(2), ENABLE_MASK(1), 1031 DISABLE_VAL(1), 400), 1032 RK817_DESC(RK817_ID_LDO7, "LDO_REG7", "vcc7", 600, 3400, 25, 1033 RK817_LDO_ON_VSEL_REG(6), RK817_LDO_VSEL_MASK, 1034 RK817_POWER_EN_REG(2), ENABLE_MASK(2), 1035 DISABLE_VAL(2), 400), 1036 RK817_DESC(RK817_ID_LDO8, "LDO_REG8", "vcc7", 600, 3400, 25, 1037 RK817_LDO_ON_VSEL_REG(7), RK817_LDO_VSEL_MASK, 1038 RK817_POWER_EN_REG(2), ENABLE_MASK(3), 1039 DISABLE_VAL(3), 400), 1040 RK817_DESC(RK817_ID_LDO9, "LDO_REG9", "vcc7", 600, 3400, 25, 1041 RK817_LDO_ON_VSEL_REG(8), RK817_LDO_VSEL_MASK, 1042 RK817_POWER_EN_REG(3), ENABLE_MASK(0), 1043 DISABLE_VAL(0), 400), 1044 RK817_DESC_SWITCH(RK809_ID_SW1, "SWITCH_REG1", "vcc9", 1045 RK817_POWER_EN_REG(3), ENABLE_MASK(2), 1046 DISABLE_VAL(2)), 1047 RK817_DESC_SWITCH(RK809_ID_SW2, "SWITCH_REG2", "vcc8", 1048 RK817_POWER_EN_REG(3), ENABLE_MASK(3), 1049 DISABLE_VAL(3)), 1050 }; 1051 1052 static const struct regulator_desc rk817_reg[] = { 1053 { 1054 .name = "DCDC_REG1", 1055 .supply_name = "vcc1", 1056 .of_match = of_match_ptr("DCDC_REG1"), 1057 .regulators_node = of_match_ptr("regulators"), 1058 .id = RK817_ID_DCDC1, 1059 .ops = &rk817_buck_ops_range, 1060 .type = REGULATOR_VOLTAGE, 1061 .n_voltages = RK817_BUCK1_SEL_CNT + 1, 1062 .linear_ranges = rk817_buck1_voltage_ranges, 1063 .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges), 1064 .vsel_reg = RK817_BUCK1_ON_VSEL_REG, 1065 .vsel_mask = RK817_BUCK_VSEL_MASK, 1066 .enable_reg = RK817_POWER_EN_REG(0), 1067 .enable_mask = ENABLE_MASK(RK817_ID_DCDC1), 1068 .enable_val = ENABLE_MASK(RK817_ID_DCDC1), 1069 .disable_val = DISABLE_VAL(RK817_ID_DCDC1), 1070 .of_map_mode = rk8xx_regulator_of_map_mode, 1071 .owner = THIS_MODULE, 1072 }, { 1073 .name = "DCDC_REG2", 1074 .supply_name = "vcc2", 1075 .of_match = of_match_ptr("DCDC_REG2"), 1076 .regulators_node = of_match_ptr("regulators"), 1077 .id = RK817_ID_DCDC2, 1078 .ops = &rk817_buck_ops_range, 1079 .type = REGULATOR_VOLTAGE, 1080 .n_voltages = RK817_BUCK1_SEL_CNT + 1, 1081 .linear_ranges = rk817_buck1_voltage_ranges, 1082 .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges), 1083 .vsel_reg = RK817_BUCK2_ON_VSEL_REG, 1084 .vsel_mask = RK817_BUCK_VSEL_MASK, 1085 .enable_reg = RK817_POWER_EN_REG(0), 1086 .enable_mask = ENABLE_MASK(RK817_ID_DCDC2), 1087 .enable_val = ENABLE_MASK(RK817_ID_DCDC2), 1088 .disable_val = DISABLE_VAL(RK817_ID_DCDC2), 1089 .of_map_mode = rk8xx_regulator_of_map_mode, 1090 .owner = THIS_MODULE, 1091 }, { 1092 .name = "DCDC_REG3", 1093 .supply_name = "vcc3", 1094 .of_match = of_match_ptr("DCDC_REG3"), 1095 .regulators_node = of_match_ptr("regulators"), 1096 .id = RK817_ID_DCDC3, 1097 .ops = &rk817_buck_ops_range, 1098 .type = REGULATOR_VOLTAGE, 1099 .n_voltages = RK817_BUCK1_SEL_CNT + 1, 1100 .linear_ranges = rk817_buck1_voltage_ranges, 1101 .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges), 1102 .vsel_reg = RK817_BUCK3_ON_VSEL_REG, 1103 .vsel_mask = RK817_BUCK_VSEL_MASK, 1104 .enable_reg = RK817_POWER_EN_REG(0), 1105 .enable_mask = ENABLE_MASK(RK817_ID_DCDC3), 1106 .enable_val = ENABLE_MASK(RK817_ID_DCDC3), 1107 .disable_val = DISABLE_VAL(RK817_ID_DCDC3), 1108 .of_map_mode = rk8xx_regulator_of_map_mode, 1109 .owner = THIS_MODULE, 1110 }, { 1111 .name = "DCDC_REG4", 1112 .supply_name = "vcc4", 1113 .of_match = of_match_ptr("DCDC_REG4"), 1114 .regulators_node = of_match_ptr("regulators"), 1115 .id = RK817_ID_DCDC4, 1116 .ops = &rk817_buck_ops_range, 1117 .type = REGULATOR_VOLTAGE, 1118 .n_voltages = RK817_BUCK3_SEL_CNT + 1, 1119 .linear_ranges = rk817_buck3_voltage_ranges, 1120 .n_linear_ranges = ARRAY_SIZE(rk817_buck3_voltage_ranges), 1121 .vsel_reg = RK817_BUCK4_ON_VSEL_REG, 1122 .vsel_mask = RK817_BUCK_VSEL_MASK, 1123 .enable_reg = RK817_POWER_EN_REG(0), 1124 .enable_mask = ENABLE_MASK(RK817_ID_DCDC4), 1125 .enable_val = ENABLE_MASK(RK817_ID_DCDC4), 1126 .disable_val = DISABLE_VAL(RK817_ID_DCDC4), 1127 .of_map_mode = rk8xx_regulator_of_map_mode, 1128 .owner = THIS_MODULE, 1129 }, 1130 RK817_DESC(RK817_ID_LDO1, "LDO_REG1", "vcc5", 600, 3400, 25, 1131 RK817_LDO_ON_VSEL_REG(0), RK817_LDO_VSEL_MASK, 1132 RK817_POWER_EN_REG(1), ENABLE_MASK(0), 1133 DISABLE_VAL(0), 400), 1134 RK817_DESC(RK817_ID_LDO2, "LDO_REG2", "vcc5", 600, 3400, 25, 1135 RK817_LDO_ON_VSEL_REG(1), RK817_LDO_VSEL_MASK, 1136 RK817_POWER_EN_REG(1), ENABLE_MASK(1), 1137 DISABLE_VAL(1), 400), 1138 RK817_DESC(RK817_ID_LDO3, "LDO_REG3", "vcc5", 600, 3400, 25, 1139 RK817_LDO_ON_VSEL_REG(2), RK817_LDO_VSEL_MASK, 1140 RK817_POWER_EN_REG(1), ENABLE_MASK(2), 1141 DISABLE_VAL(2), 400), 1142 RK817_DESC(RK817_ID_LDO4, "LDO_REG4", "vcc6", 600, 3400, 25, 1143 RK817_LDO_ON_VSEL_REG(3), RK817_LDO_VSEL_MASK, 1144 RK817_POWER_EN_REG(1), ENABLE_MASK(3), 1145 DISABLE_VAL(3), 400), 1146 RK817_DESC(RK817_ID_LDO5, "LDO_REG5", "vcc6", 600, 3400, 25, 1147 RK817_LDO_ON_VSEL_REG(4), RK817_LDO_VSEL_MASK, 1148 RK817_POWER_EN_REG(2), ENABLE_MASK(0), 1149 DISABLE_VAL(0), 400), 1150 RK817_DESC(RK817_ID_LDO6, "LDO_REG6", "vcc6", 600, 3400, 25, 1151 RK817_LDO_ON_VSEL_REG(5), RK817_LDO_VSEL_MASK, 1152 RK817_POWER_EN_REG(2), ENABLE_MASK(1), 1153 DISABLE_VAL(1), 400), 1154 RK817_DESC(RK817_ID_LDO7, "LDO_REG7", "vcc7", 600, 3400, 25, 1155 RK817_LDO_ON_VSEL_REG(6), RK817_LDO_VSEL_MASK, 1156 RK817_POWER_EN_REG(2), ENABLE_MASK(2), 1157 DISABLE_VAL(2), 400), 1158 RK817_DESC(RK817_ID_LDO8, "LDO_REG8", "vcc7", 600, 3400, 25, 1159 RK817_LDO_ON_VSEL_REG(7), RK817_LDO_VSEL_MASK, 1160 RK817_POWER_EN_REG(2), ENABLE_MASK(3), 1161 DISABLE_VAL(3), 400), 1162 RK817_DESC(RK817_ID_LDO9, "LDO_REG9", "vcc7", 600, 3400, 25, 1163 RK817_LDO_ON_VSEL_REG(8), RK817_LDO_VSEL_MASK, 1164 RK817_POWER_EN_REG(3), ENABLE_MASK(0), 1165 DISABLE_VAL(0), 400), 1166 RK817_BOOST_DESC(RK817_ID_BOOST, "BOOST", "vcc8", 4700, 5400, 100, 1167 RK817_BOOST_OTG_CFG, RK817_BOOST_VSEL_MASK, 1168 RK817_POWER_EN_REG(3), ENABLE_MASK(1), ENABLE_MASK(1), 1169 DISABLE_VAL(1), 400, 3500 - 5400), 1170 RK817_DESC_SWITCH(RK817_ID_BOOST_OTG_SW, "OTG_SWITCH", "vcc9", 1171 RK817_POWER_EN_REG(3), ENABLE_MASK(2), 1172 DISABLE_VAL(2)), 1173 }; 1174 1175 static const struct regulator_desc rk818_reg[] = { 1176 { 1177 .name = "DCDC_REG1", 1178 .supply_name = "vcc1", 1179 .of_match = of_match_ptr("DCDC_REG1"), 1180 .regulators_node = of_match_ptr("regulators"), 1181 .id = RK818_ID_DCDC1, 1182 .ops = &rk808_reg_ops, 1183 .type = REGULATOR_VOLTAGE, 1184 .min_uV = 712500, 1185 .uV_step = 12500, 1186 .n_voltages = 64, 1187 .vsel_reg = RK818_BUCK1_ON_VSEL_REG, 1188 .vsel_mask = RK818_BUCK_VSEL_MASK, 1189 .enable_reg = RK818_DCDC_EN_REG, 1190 .enable_mask = BIT(0), 1191 .owner = THIS_MODULE, 1192 }, { 1193 .name = "DCDC_REG2", 1194 .supply_name = "vcc2", 1195 .of_match = of_match_ptr("DCDC_REG2"), 1196 .regulators_node = of_match_ptr("regulators"), 1197 .id = RK818_ID_DCDC2, 1198 .ops = &rk808_reg_ops, 1199 .type = REGULATOR_VOLTAGE, 1200 .min_uV = 712500, 1201 .uV_step = 12500, 1202 .n_voltages = 64, 1203 .vsel_reg = RK818_BUCK2_ON_VSEL_REG, 1204 .vsel_mask = RK818_BUCK_VSEL_MASK, 1205 .enable_reg = RK818_DCDC_EN_REG, 1206 .enable_mask = BIT(1), 1207 .owner = THIS_MODULE, 1208 }, { 1209 .name = "DCDC_REG3", 1210 .supply_name = "vcc3", 1211 .of_match = of_match_ptr("DCDC_REG3"), 1212 .regulators_node = of_match_ptr("regulators"), 1213 .id = RK818_ID_DCDC3, 1214 .ops = &rk808_switch_ops, 1215 .type = REGULATOR_VOLTAGE, 1216 .n_voltages = 1, 1217 .enable_reg = RK818_DCDC_EN_REG, 1218 .enable_mask = BIT(2), 1219 .owner = THIS_MODULE, 1220 }, 1221 RK8XX_DESC(RK818_ID_DCDC4, "DCDC_REG4", "vcc4", 1800, 3600, 100, 1222 RK818_BUCK4_ON_VSEL_REG, RK818_BUCK4_VSEL_MASK, 1223 RK818_DCDC_EN_REG, BIT(3), 0), 1224 RK8XX_DESC(RK818_ID_BOOST, "DCDC_BOOST", "boost", 4700, 5400, 100, 1225 RK818_BOOST_LDO9_ON_VSEL_REG, RK818_BOOST_ON_VSEL_MASK, 1226 RK818_DCDC_EN_REG, BIT(4), 0), 1227 RK8XX_DESC(RK818_ID_LDO1, "LDO_REG1", "vcc6", 1800, 3400, 100, 1228 RK818_LDO1_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG, 1229 BIT(0), 400), 1230 RK8XX_DESC(RK818_ID_LDO2, "LDO_REG2", "vcc6", 1800, 3400, 100, 1231 RK818_LDO2_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG, 1232 BIT(1), 400), 1233 { 1234 .name = "LDO_REG3", 1235 .supply_name = "vcc7", 1236 .of_match = of_match_ptr("LDO_REG3"), 1237 .regulators_node = of_match_ptr("regulators"), 1238 .id = RK818_ID_LDO3, 1239 .ops = &rk808_reg_ops_ranges, 1240 .type = REGULATOR_VOLTAGE, 1241 .n_voltages = 16, 1242 .linear_ranges = rk808_ldo3_voltage_ranges, 1243 .n_linear_ranges = ARRAY_SIZE(rk808_ldo3_voltage_ranges), 1244 .vsel_reg = RK818_LDO3_ON_VSEL_REG, 1245 .vsel_mask = RK818_LDO3_ON_VSEL_MASK, 1246 .enable_reg = RK818_LDO_EN_REG, 1247 .enable_mask = BIT(2), 1248 .enable_time = 400, 1249 .owner = THIS_MODULE, 1250 }, 1251 RK8XX_DESC(RK818_ID_LDO4, "LDO_REG4", "vcc8", 1800, 3400, 100, 1252 RK818_LDO4_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG, 1253 BIT(3), 400), 1254 RK8XX_DESC(RK818_ID_LDO5, "LDO_REG5", "vcc7", 1800, 3400, 100, 1255 RK818_LDO5_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG, 1256 BIT(4), 400), 1257 RK8XX_DESC(RK818_ID_LDO6, "LDO_REG6", "vcc8", 800, 2500, 100, 1258 RK818_LDO6_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG, 1259 BIT(5), 400), 1260 RK8XX_DESC(RK818_ID_LDO7, "LDO_REG7", "vcc7", 800, 2500, 100, 1261 RK818_LDO7_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG, 1262 BIT(6), 400), 1263 RK8XX_DESC(RK818_ID_LDO8, "LDO_REG8", "vcc8", 1800, 3400, 100, 1264 RK818_LDO8_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG, 1265 BIT(7), 400), 1266 RK8XX_DESC(RK818_ID_LDO9, "LDO_REG9", "vcc9", 1800, 3400, 100, 1267 RK818_BOOST_LDO9_ON_VSEL_REG, RK818_LDO_VSEL_MASK, 1268 RK818_DCDC_EN_REG, BIT(5), 400), 1269 RK8XX_DESC_SWITCH(RK818_ID_SWITCH, "SWITCH_REG", "vcc9", 1270 RK818_DCDC_EN_REG, BIT(6)), 1271 RK8XX_DESC_SWITCH(RK818_ID_HDMI_SWITCH, "HDMI_SWITCH", "h_5v", 1272 RK818_H5V_EN_REG, BIT(0)), 1273 RK8XX_DESC_SWITCH(RK818_ID_OTG_SWITCH, "OTG_SWITCH", "usb", 1274 RK818_DCDC_EN_REG, BIT(7)), 1275 }; 1276 1277 static int rk808_regulator_dt_parse_pdata(struct device *dev, 1278 struct device *client_dev, 1279 struct regmap *map, 1280 struct rk808_regulator_data *pdata) 1281 { 1282 struct device_node *np; 1283 int tmp, ret = 0, i; 1284 1285 np = of_get_child_by_name(client_dev->of_node, "regulators"); 1286 if (!np) 1287 return -ENXIO; 1288 1289 for (i = 0; i < ARRAY_SIZE(pdata->dvs_gpio); i++) { 1290 pdata->dvs_gpio[i] = 1291 devm_gpiod_get_index_optional(client_dev, "dvs", i, 1292 GPIOD_OUT_LOW); 1293 if (IS_ERR(pdata->dvs_gpio[i])) { 1294 ret = PTR_ERR(pdata->dvs_gpio[i]); 1295 dev_err(dev, "failed to get dvs%d gpio (%d)\n", i, ret); 1296 goto dt_parse_end; 1297 } 1298 1299 if (!pdata->dvs_gpio[i]) { 1300 dev_warn(dev, "there is no dvs%d gpio\n", i); 1301 continue; 1302 } 1303 1304 tmp = i ? RK808_DVS2_POL : RK808_DVS1_POL; 1305 ret = regmap_update_bits(map, RK808_IO_POL_REG, tmp, 1306 gpiod_is_active_low(pdata->dvs_gpio[i]) ? 1307 0 : tmp); 1308 } 1309 1310 dt_parse_end: 1311 of_node_put(np); 1312 return ret; 1313 } 1314 1315 static int rk808_regulator_probe(struct platform_device *pdev) 1316 { 1317 struct rk808 *rk808 = dev_get_drvdata(pdev->dev.parent); 1318 struct i2c_client *client = rk808->i2c; 1319 struct regulator_config config = {}; 1320 struct regulator_dev *rk808_rdev; 1321 struct rk808_regulator_data *pdata; 1322 const struct regulator_desc *regulators; 1323 int ret, i, nregulators; 1324 1325 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 1326 if (!pdata) 1327 return -ENOMEM; 1328 1329 ret = rk808_regulator_dt_parse_pdata(&pdev->dev, &client->dev, 1330 rk808->regmap, pdata); 1331 if (ret < 0) 1332 return ret; 1333 1334 platform_set_drvdata(pdev, pdata); 1335 1336 switch (rk808->variant) { 1337 case RK805_ID: 1338 regulators = rk805_reg; 1339 nregulators = RK805_NUM_REGULATORS; 1340 break; 1341 case RK808_ID: 1342 regulators = rk808_reg; 1343 nregulators = RK808_NUM_REGULATORS; 1344 break; 1345 case RK809_ID: 1346 regulators = rk809_reg; 1347 nregulators = RK809_NUM_REGULATORS; 1348 break; 1349 case RK817_ID: 1350 regulators = rk817_reg; 1351 nregulators = RK817_NUM_REGULATORS; 1352 break; 1353 case RK818_ID: 1354 regulators = rk818_reg; 1355 nregulators = RK818_NUM_REGULATORS; 1356 break; 1357 default: 1358 dev_err(&client->dev, "unsupported RK8XX ID %lu\n", 1359 rk808->variant); 1360 return -EINVAL; 1361 } 1362 1363 config.dev = &client->dev; 1364 config.driver_data = pdata; 1365 config.regmap = rk808->regmap; 1366 1367 /* Instantiate the regulators */ 1368 for (i = 0; i < nregulators; i++) { 1369 rk808_rdev = devm_regulator_register(&pdev->dev, 1370 ®ulators[i], &config); 1371 if (IS_ERR(rk808_rdev)) { 1372 dev_err(&client->dev, 1373 "failed to register %d regulator\n", i); 1374 return PTR_ERR(rk808_rdev); 1375 } 1376 } 1377 1378 return 0; 1379 } 1380 1381 static struct platform_driver rk808_regulator_driver = { 1382 .probe = rk808_regulator_probe, 1383 .driver = { 1384 .name = "rk808-regulator" 1385 }, 1386 }; 1387 1388 module_platform_driver(rk808_regulator_driver); 1389 1390 MODULE_DESCRIPTION("regulator driver for the RK805/RK808/RK818 series PMICs"); 1391 MODULE_AUTHOR("Tony xie <tony.xie@rock-chips.com>"); 1392 MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>"); 1393 MODULE_AUTHOR("Zhang Qing <zhangqing@rock-chips.com>"); 1394 MODULE_AUTHOR("Wadim Egorov <w.egorov@phytec.de>"); 1395 MODULE_LICENSE("GPL"); 1396 MODULE_ALIAS("platform:rk808-regulator"); 1397