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