1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (C) 2018 ROHM Semiconductors 3 // bd71837-regulator.c ROHM BD71837MWV/BD71847MWV regulator driver 4 5 #include <linux/cleanup.h> 6 #include <linux/delay.h> 7 #include <linux/err.h> 8 #include <linux/interrupt.h> 9 #include <linux/kernel.h> 10 #include <linux/mfd/rohm-bd718x7.h> 11 #include <linux/module.h> 12 #include <linux/of.h> 13 #include <linux/platform_device.h> 14 #include <linux/regulator/driver.h> 15 #include <linux/regulator/machine.h> 16 #include <linux/regulator/of_regulator.h> 17 #include <linux/slab.h> 18 19 /* Typical regulator startup times as per data sheet in uS */ 20 #define BD71847_BUCK1_STARTUP_TIME 144 21 #define BD71847_BUCK2_STARTUP_TIME 162 22 #define BD71847_BUCK3_STARTUP_TIME 162 23 #define BD71847_BUCK4_STARTUP_TIME 240 24 #define BD71847_BUCK5_STARTUP_TIME 270 25 #define BD71847_BUCK6_STARTUP_TIME 200 26 #define BD71847_LDO1_STARTUP_TIME 440 27 #define BD71847_LDO2_STARTUP_TIME 370 28 #define BD71847_LDO3_STARTUP_TIME 310 29 #define BD71847_LDO4_STARTUP_TIME 400 30 #define BD71847_LDO5_STARTUP_TIME 530 31 #define BD71847_LDO6_STARTUP_TIME 400 32 33 #define BD71837_BUCK1_STARTUP_TIME 160 34 #define BD71837_BUCK2_STARTUP_TIME 180 35 #define BD71837_BUCK3_STARTUP_TIME 180 36 #define BD71837_BUCK4_STARTUP_TIME 180 37 #define BD71837_BUCK5_STARTUP_TIME 160 38 #define BD71837_BUCK6_STARTUP_TIME 240 39 #define BD71837_BUCK7_STARTUP_TIME 220 40 #define BD71837_BUCK8_STARTUP_TIME 200 41 #define BD71837_LDO1_STARTUP_TIME 440 42 #define BD71837_LDO2_STARTUP_TIME 370 43 #define BD71837_LDO3_STARTUP_TIME 310 44 #define BD71837_LDO4_STARTUP_TIME 400 45 #define BD71837_LDO5_STARTUP_TIME 310 46 #define BD71837_LDO6_STARTUP_TIME 400 47 #define BD71837_LDO7_STARTUP_TIME 530 48 49 /* 50 * BD718(37/47/50) have two "enable control modes". ON/OFF can either be 51 * controlled by software - or by PMIC internal HW state machine. Whether 52 * regulator should be under SW or HW control can be defined from device-tree. 53 * Let's provide separate ops for regulators to use depending on the "enable 54 * control mode". 55 */ 56 #define BD718XX_HWOPNAME(swopname) swopname##_hwcontrol 57 58 #define BD718XX_OPS(name, _list_voltage, _map_voltage, _set_voltage_sel, \ 59 _get_voltage_sel, _set_voltage_time_sel, _set_ramp_delay, \ 60 _set_uvp, _set_ovp) \ 61 static const struct regulator_ops name = { \ 62 .enable = regulator_enable_regmap, \ 63 .disable = regulator_disable_regmap, \ 64 .is_enabled = regulator_is_enabled_regmap, \ 65 .list_voltage = (_list_voltage), \ 66 .map_voltage = (_map_voltage), \ 67 .set_voltage_sel = (_set_voltage_sel), \ 68 .get_voltage_sel = (_get_voltage_sel), \ 69 .set_voltage_time_sel = (_set_voltage_time_sel), \ 70 .set_ramp_delay = (_set_ramp_delay), \ 71 .set_under_voltage_protection = (_set_uvp), \ 72 .set_over_voltage_protection = (_set_ovp), \ 73 }; \ 74 \ 75 static const struct regulator_ops BD718XX_HWOPNAME(name) = { \ 76 .is_enabled = always_enabled_by_hwstate, \ 77 .list_voltage = (_list_voltage), \ 78 .map_voltage = (_map_voltage), \ 79 .set_voltage_sel = (_set_voltage_sel), \ 80 .get_voltage_sel = (_get_voltage_sel), \ 81 .set_voltage_time_sel = (_set_voltage_time_sel), \ 82 .set_ramp_delay = (_set_ramp_delay), \ 83 .set_under_voltage_protection = (_set_uvp), \ 84 .set_over_voltage_protection = (_set_ovp), \ 85 } \ 86 87 /* 88 * BUCK1/2/3/4 89 * BUCK1RAMPRATE[1:0] BUCK1 DVS ramp rate setting 90 * 00: 10.00mV/usec 10mV 1uS 91 * 01: 5.00mV/usec 10mV 2uS 92 * 10: 2.50mV/usec 10mV 4uS 93 * 11: 1.25mV/usec 10mV 8uS 94 */ 95 static const unsigned int bd718xx_ramp_delay[] = { 10000, 5000, 2500, 1250 }; 96 97 /* These functions are used when regulators are under HW state machine control. 98 * We assume PMIC is in RUN state because SW running and able to query the 99 * status. Most of the regulators have fixed ON or OFF state at RUN/IDLE so for 100 * them we just return a constant. BD71837 BUCK3 and BUCK4 are exceptions as 101 * they support configuring the ON/OFF state for RUN. 102 * 103 * Note for next hacker - these PMICs have a register where the HW state can be 104 * read. If assuming RUN appears to be false in your use-case - you can 105 * implement state reading (although that is not going to be atomic) before 106 * returning the enable state. 107 */ 108 static int always_enabled_by_hwstate(struct regulator_dev *rdev) 109 { 110 return 1; 111 } 112 113 static int never_enabled_by_hwstate(struct regulator_dev *rdev) 114 { 115 return 0; 116 } 117 118 static int bd71837_get_buck34_enable_hwctrl(struct regulator_dev *rdev) 119 { 120 int ret; 121 unsigned int val; 122 123 ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val); 124 if (ret) 125 return ret; 126 127 return !!(BD718XX_BUCK_RUN_ON & val); 128 } 129 130 static void voltage_change_done(struct regulator_dev *rdev, unsigned int sel, 131 unsigned int *mask) 132 { 133 int ret; 134 135 if (*mask) { 136 /* 137 * Let's allow scheduling as we use I2C anyways. We just need to 138 * guarantee minimum of 1ms sleep - it shouldn't matter if we 139 * exceed it due to the scheduling. 140 */ 141 msleep(1); 142 143 ret = regmap_clear_bits(rdev->regmap, BD718XX_REG_MVRFLTMASK2, 144 *mask); 145 if (ret) 146 dev_err(&rdev->dev, 147 "Failed to re-enable voltage monitoring (%d)\n", 148 ret); 149 } 150 } 151 152 static int voltage_change_prepare(struct regulator_dev *rdev, unsigned int sel, 153 unsigned int *mask) 154 { 155 int ret; 156 157 *mask = 0; 158 if (rdev->desc->ops->is_enabled(rdev)) { 159 int now, new; 160 161 now = rdev->desc->ops->get_voltage_sel(rdev); 162 if (now < 0) 163 return now; 164 165 now = rdev->desc->ops->list_voltage(rdev, now); 166 if (now < 0) 167 return now; 168 169 new = rdev->desc->ops->list_voltage(rdev, sel); 170 if (new < 0) 171 return new; 172 173 /* 174 * If we increase LDO voltage when LDO is enabled we need to 175 * disable the power-good detection until voltage has reached 176 * the new level. According to HW colleagues the maximum time 177 * it takes is 1000us. I assume that on systems with light load 178 * this might be less - and we could probably use DT to give 179 * system specific delay value if performance matters. 180 * 181 * Well, knowing we use I2C here and can add scheduling delays 182 * I don't think it is worth the hassle and I just add fixed 183 * 1ms sleep here (and allow scheduling). If this turns out to 184 * be a problem we can change it to delay and make the delay 185 * time configurable. 186 */ 187 if (new > now) { 188 int tmp; 189 int prot_bit; 190 int ldo_offset = rdev->desc->id - BD718XX_LDO1; 191 192 prot_bit = BD718XX_LDO1_VRMON80 << ldo_offset; 193 ret = regmap_read(rdev->regmap, BD718XX_REG_MVRFLTMASK2, 194 &tmp); 195 if (ret) { 196 dev_err(&rdev->dev, 197 "Failed to read voltage monitoring state\n"); 198 return ret; 199 } 200 201 if (!(tmp & prot_bit)) { 202 /* We disable protection if it was enabled... */ 203 ret = regmap_set_bits(rdev->regmap, 204 BD718XX_REG_MVRFLTMASK2, 205 prot_bit); 206 /* ...and we also want to re-enable it */ 207 *mask = prot_bit; 208 } 209 if (ret) { 210 dev_err(&rdev->dev, 211 "Failed to stop voltage monitoring\n"); 212 return ret; 213 } 214 } 215 } 216 217 return 0; 218 } 219 220 static int bd718xx_set_voltage_sel_restricted(struct regulator_dev *rdev, 221 unsigned int sel) 222 { 223 int ret; 224 int mask; 225 226 ret = voltage_change_prepare(rdev, sel, &mask); 227 if (ret) 228 return ret; 229 230 ret = regulator_set_voltage_sel_regmap(rdev, sel); 231 voltage_change_done(rdev, sel, &mask); 232 233 return ret; 234 } 235 236 static int bd718xx_set_voltage_sel_pickable_restricted( 237 struct regulator_dev *rdev, unsigned int sel) 238 { 239 int ret; 240 int mask; 241 242 ret = voltage_change_prepare(rdev, sel, &mask); 243 if (ret) 244 return ret; 245 246 ret = regulator_set_voltage_sel_pickable_regmap(rdev, sel); 247 voltage_change_done(rdev, sel, &mask); 248 249 return ret; 250 } 251 252 static int bd71837_set_voltage_sel_pickable_restricted( 253 struct regulator_dev *rdev, unsigned int sel) 254 { 255 if (rdev->desc->ops->is_enabled(rdev)) 256 return -EBUSY; 257 258 return regulator_set_voltage_sel_pickable_regmap(rdev, sel); 259 } 260 261 /* 262 * BD71837 BUCK1/2/3/4 263 * BD71847 BUCK1/2 264 * 0.70 to 1.30V (10mV step) 265 */ 266 static const struct linear_range bd718xx_dvs_buck_volts[] = { 267 REGULATOR_LINEAR_RANGE(700000, 0x00, 0x3C, 10000), 268 REGULATOR_LINEAR_RANGE(1300000, 0x3D, 0x3F, 0), 269 }; 270 271 /* 272 * BD71837 BUCK5 273 * 0.7V to 1.35V (range 0) 274 * and 275 * 0.675 to 1.325 (range 1) 276 */ 277 static const struct linear_range bd71837_buck5_volts[] = { 278 /* Ranges when VOLT_SEL bit is 0 */ 279 REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000), 280 REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000), 281 REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000), 282 /* Ranges when VOLT_SEL bit is 1 */ 283 REGULATOR_LINEAR_RANGE(675000, 0x0, 0x3, 100000), 284 REGULATOR_LINEAR_RANGE(1025000, 0x4, 0x5, 50000), 285 REGULATOR_LINEAR_RANGE(1175000, 0x6, 0x7, 150000), 286 }; 287 288 /* 289 * Range selector for first 3 linear ranges is 0x0 290 * and 0x1 for last 3 ranges. 291 */ 292 static const unsigned int bd71837_buck5_volt_range_sel[] = { 293 0x0, 0x0, 0x0, 0x1, 0x1, 0x1 294 }; 295 296 /* 297 * BD71847 BUCK3 298 */ 299 static const struct linear_range bd71847_buck3_volts[] = { 300 /* Ranges when VOLT_SEL bits are 00 */ 301 REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000), 302 REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000), 303 REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000), 304 /* Ranges when VOLT_SEL bits are 01 */ 305 REGULATOR_LINEAR_RANGE(550000, 0x0, 0x7, 50000), 306 /* Ranges when VOLT_SEL bits are 11 */ 307 REGULATOR_LINEAR_RANGE(675000, 0x0, 0x3, 100000), 308 REGULATOR_LINEAR_RANGE(1025000, 0x4, 0x5, 50000), 309 REGULATOR_LINEAR_RANGE(1175000, 0x6, 0x7, 150000), 310 }; 311 312 static const unsigned int bd71847_buck3_volt_range_sel[] = { 313 0x0, 0x0, 0x0, 0x1, 0x2, 0x2, 0x2 314 }; 315 316 static const struct linear_range bd71847_buck4_volts[] = { 317 REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000), 318 REGULATOR_LINEAR_RANGE(2600000, 0x00, 0x03, 100000), 319 }; 320 321 static const unsigned int bd71847_buck4_volt_range_sel[] = { 0x0, 0x1 }; 322 323 /* 324 * BUCK6 325 * 3.0V to 3.3V (step 100mV) 326 */ 327 static const struct linear_range bd71837_buck6_volts[] = { 328 REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000), 329 }; 330 331 /* 332 * BD71837 BUCK7 333 * BD71847 BUCK5 334 * 000 = 1.605V 335 * 001 = 1.695V 336 * 010 = 1.755V 337 * 011 = 1.8V (Initial) 338 * 100 = 1.845V 339 * 101 = 1.905V 340 * 110 = 1.95V 341 * 111 = 1.995V 342 */ 343 static const unsigned int bd718xx_3rd_nodvs_buck_volts[] = { 344 1605000, 1695000, 1755000, 1800000, 1845000, 1905000, 1950000, 1995000 345 }; 346 347 /* 348 * BUCK8 349 * 0.8V to 1.40V (step 10mV) 350 */ 351 static const struct linear_range bd718xx_4th_nodvs_buck_volts[] = { 352 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x3C, 10000), 353 }; 354 355 /* 356 * LDO1 357 * 3.0 to 3.3V (100mV step) 358 */ 359 static const struct linear_range bd718xx_ldo1_volts[] = { 360 REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000), 361 REGULATOR_LINEAR_RANGE(1600000, 0x00, 0x03, 100000), 362 }; 363 364 static const unsigned int bd718xx_ldo1_volt_range_sel[] = { 0x0, 0x1 }; 365 366 /* 367 * LDO2 368 * 0.8 or 0.9V 369 */ 370 static const unsigned int ldo_2_volts[] = { 371 900000, 800000 372 }; 373 374 /* 375 * LDO3 376 * 1.8 to 3.3V (100mV step) 377 */ 378 static const struct linear_range bd718xx_ldo3_volts[] = { 379 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000), 380 }; 381 382 /* 383 * LDO4 384 * 0.9 to 1.8V (100mV step) 385 */ 386 static const struct linear_range bd718xx_ldo4_volts[] = { 387 REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000), 388 }; 389 390 /* 391 * LDO5 for BD71837 392 * 1.8 to 3.3V (100mV step) 393 */ 394 static const struct linear_range bd71837_ldo5_volts[] = { 395 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000), 396 }; 397 398 /* 399 * LDO5 for BD71837 400 * 1.8 to 3.3V (100mV step) 401 */ 402 static const struct linear_range bd71847_ldo5_volts[] = { 403 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000), 404 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x0F, 100000), 405 }; 406 407 static const unsigned int bd71847_ldo5_volt_range_sel[] = { 0x0, 0x1 }; 408 409 /* 410 * LDO6 411 * 0.9 to 1.8V (100mV step) 412 */ 413 static const struct linear_range bd718xx_ldo6_volts[] = { 414 REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000), 415 }; 416 417 /* 418 * LDO7 419 * 1.8 to 3.3V (100mV step) 420 */ 421 static const struct linear_range bd71837_ldo7_volts[] = { 422 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000), 423 }; 424 425 struct reg_init { 426 unsigned int reg; 427 unsigned int mask; 428 unsigned int val; 429 }; 430 struct bd718xx_regulator_data { 431 struct regulator_desc desc; 432 const struct rohm_dvs_config dvs; 433 const struct reg_init init; 434 const struct reg_init *additional_inits; 435 int additional_init_amnt; 436 }; 437 438 static int bd718x7_xvp_sanity_check(struct regulator_dev *rdev, int lim_uV, 439 int severity) 440 { 441 /* 442 * BD71837/47/50 ... (ICs supported by this driver) do not provide 443 * warnings, only protection 444 */ 445 if (severity != REGULATOR_SEVERITY_PROT) { 446 dev_err(&rdev->dev, 447 "Unsupported Under Voltage protection level\n"); 448 return -EINVAL; 449 } 450 451 /* 452 * And protection limit is not changeable. It can only be enabled 453 * or disabled 454 */ 455 if (lim_uV) 456 return -EINVAL; 457 458 return 0; 459 } 460 461 static int bd718x7_set_ldo_uvp(struct regulator_dev *rdev, int lim_uV, 462 int severity, bool enable) 463 { 464 int ldo_offset = rdev->desc->id - BD718XX_LDO1; 465 int prot_bit, ret; 466 467 ret = bd718x7_xvp_sanity_check(rdev, lim_uV, severity); 468 if (ret) 469 return ret; 470 471 prot_bit = BD718XX_LDO1_VRMON80 << ldo_offset; 472 473 if (enable) 474 return regmap_clear_bits(rdev->regmap, BD718XX_REG_MVRFLTMASK2, 475 prot_bit); 476 477 return regmap_set_bits(rdev->regmap, BD718XX_REG_MVRFLTMASK2, 478 prot_bit); 479 } 480 481 static int bd718x7_get_buck_prot_reg(int id, int *reg) 482 { 483 484 if (id > BD718XX_BUCK8) { 485 WARN_ON(id > BD718XX_BUCK8); 486 return -EINVAL; 487 } 488 489 if (id > BD718XX_BUCK4) 490 *reg = BD718XX_REG_MVRFLTMASK0; 491 else 492 *reg = BD718XX_REG_MVRFLTMASK1; 493 494 return 0; 495 } 496 497 static int bd718x7_get_buck_ovp_info(int id, int *reg, int *bit) 498 { 499 int ret; 500 501 ret = bd718x7_get_buck_prot_reg(id, reg); 502 if (ret) 503 return ret; 504 505 *bit = BIT((id % 4) * 2 + 1); 506 507 return 0; 508 } 509 510 static int bd718x7_get_buck_uvp_info(int id, int *reg, int *bit) 511 { 512 int ret; 513 514 ret = bd718x7_get_buck_prot_reg(id, reg); 515 if (ret) 516 return ret; 517 518 *bit = BIT((id % 4) * 2); 519 520 return 0; 521 } 522 523 static int bd718x7_set_buck_uvp(struct regulator_dev *rdev, int lim_uV, 524 int severity, bool enable) 525 { 526 int bit, reg, ret; 527 528 ret = bd718x7_xvp_sanity_check(rdev, lim_uV, severity); 529 if (ret) 530 return ret; 531 532 ret = bd718x7_get_buck_uvp_info(rdev->desc->id, ®, &bit); 533 if (ret) 534 return ret; 535 536 if (enable) 537 return regmap_clear_bits(rdev->regmap, reg, bit); 538 539 return regmap_set_bits(rdev->regmap, reg, bit); 540 541 } 542 543 static int bd718x7_set_buck_ovp(struct regulator_dev *rdev, int lim_uV, 544 int severity, 545 bool enable) 546 { 547 int bit, reg, ret; 548 549 ret = bd718x7_xvp_sanity_check(rdev, lim_uV, severity); 550 if (ret) 551 return ret; 552 553 ret = bd718x7_get_buck_ovp_info(rdev->desc->id, ®, &bit); 554 if (ret) 555 return ret; 556 557 if (enable) 558 return regmap_clear_bits(rdev->regmap, reg, bit); 559 560 return regmap_set_bits(rdev->regmap, reg, bit); 561 } 562 563 /* 564 * OPS common for BD71847 and BD71850 565 */ 566 BD718XX_OPS(bd718xx_pickable_range_ldo_ops, 567 regulator_list_voltage_pickable_linear_range, NULL, 568 bd718xx_set_voltage_sel_pickable_restricted, 569 regulator_get_voltage_sel_pickable_regmap, NULL, NULL, 570 bd718x7_set_ldo_uvp, NULL); 571 572 /* BD71847 and BD71850 LDO 5 is by default OFF at RUN state */ 573 static const struct regulator_ops bd718xx_ldo5_ops_hwstate = { 574 .is_enabled = never_enabled_by_hwstate, 575 .list_voltage = regulator_list_voltage_pickable_linear_range, 576 .set_voltage_sel = bd718xx_set_voltage_sel_pickable_restricted, 577 .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap, 578 .set_under_voltage_protection = bd718x7_set_ldo_uvp, 579 }; 580 581 BD718XX_OPS(bd718xx_pickable_range_buck_ops, 582 regulator_list_voltage_pickable_linear_range, NULL, 583 regulator_set_voltage_sel_pickable_regmap, 584 regulator_get_voltage_sel_pickable_regmap, 585 regulator_set_voltage_time_sel, NULL, bd718x7_set_buck_uvp, 586 bd718x7_set_buck_ovp); 587 588 BD718XX_OPS(bd718xx_ldo_regulator_ops, regulator_list_voltage_linear_range, 589 NULL, bd718xx_set_voltage_sel_restricted, 590 regulator_get_voltage_sel_regmap, NULL, NULL, bd718x7_set_ldo_uvp, 591 NULL); 592 593 BD718XX_OPS(bd718xx_ldo_regulator_nolinear_ops, regulator_list_voltage_table, 594 NULL, bd718xx_set_voltage_sel_restricted, 595 regulator_get_voltage_sel_regmap, NULL, NULL, bd718x7_set_ldo_uvp, 596 NULL); 597 598 BD718XX_OPS(bd718xx_buck_regulator_ops, regulator_list_voltage_linear_range, 599 NULL, regulator_set_voltage_sel_regmap, 600 regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel, 601 NULL, bd718x7_set_buck_uvp, bd718x7_set_buck_ovp); 602 603 BD718XX_OPS(bd718xx_buck_regulator_nolinear_ops, regulator_list_voltage_table, 604 regulator_map_voltage_ascend, regulator_set_voltage_sel_regmap, 605 regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel, 606 NULL, bd718x7_set_buck_uvp, bd718x7_set_buck_ovp); 607 608 /* 609 * OPS for BD71837 610 */ 611 BD718XX_OPS(bd71837_pickable_range_ldo_ops, 612 regulator_list_voltage_pickable_linear_range, NULL, 613 bd71837_set_voltage_sel_pickable_restricted, 614 regulator_get_voltage_sel_pickable_regmap, NULL, NULL, 615 bd718x7_set_ldo_uvp, NULL); 616 617 BD718XX_OPS(bd71837_pickable_range_buck_ops, 618 regulator_list_voltage_pickable_linear_range, NULL, 619 bd71837_set_voltage_sel_pickable_restricted, 620 regulator_get_voltage_sel_pickable_regmap, 621 regulator_set_voltage_time_sel, NULL, bd718x7_set_buck_uvp, 622 bd718x7_set_buck_ovp); 623 624 BD718XX_OPS(bd71837_ldo_regulator_ops, regulator_list_voltage_linear_range, 625 NULL, rohm_regulator_set_voltage_sel_restricted, 626 regulator_get_voltage_sel_regmap, NULL, NULL, bd718x7_set_ldo_uvp, 627 NULL); 628 629 BD718XX_OPS(bd71837_ldo_regulator_nolinear_ops, regulator_list_voltage_table, 630 NULL, rohm_regulator_set_voltage_sel_restricted, 631 regulator_get_voltage_sel_regmap, NULL, NULL, bd718x7_set_ldo_uvp, 632 NULL); 633 634 BD718XX_OPS(bd71837_buck_regulator_ops, regulator_list_voltage_linear_range, 635 NULL, rohm_regulator_set_voltage_sel_restricted, 636 regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel, 637 NULL, bd718x7_set_buck_uvp, bd718x7_set_buck_ovp); 638 639 BD718XX_OPS(bd71837_buck_regulator_nolinear_ops, regulator_list_voltage_table, 640 regulator_map_voltage_ascend, rohm_regulator_set_voltage_sel_restricted, 641 regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel, 642 NULL, bd718x7_set_buck_uvp, bd718x7_set_buck_ovp); 643 /* 644 * BD71837 bucks 3 and 4 support defining their enable/disable state also 645 * when buck enable state is under HW state machine control. In that case the 646 * bit [2] in CTRL register is used to indicate if regulator should be ON. 647 */ 648 static const struct regulator_ops bd71837_buck34_ops_hwctrl = { 649 .is_enabled = bd71837_get_buck34_enable_hwctrl, 650 .list_voltage = regulator_list_voltage_linear_range, 651 .set_voltage_sel = regulator_set_voltage_sel_regmap, 652 .get_voltage_sel = regulator_get_voltage_sel_regmap, 653 .set_voltage_time_sel = regulator_set_voltage_time_sel, 654 .set_ramp_delay = regulator_set_ramp_delay_regmap, 655 .set_under_voltage_protection = bd718x7_set_buck_uvp, 656 .set_over_voltage_protection = bd718x7_set_buck_ovp, 657 }; 658 659 /* 660 * OPS for all of the ICs - BD718(37/47/50) 661 */ 662 BD718XX_OPS(bd718xx_dvs_buck_regulator_ops, regulator_list_voltage_linear_range, 663 NULL, regulator_set_voltage_sel_regmap, 664 regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel, 665 regulator_set_ramp_delay_regmap, bd718x7_set_buck_uvp, 666 bd718x7_set_buck_ovp); 667 668 669 670 /* 671 * There is a HW quirk in BD71837. The shutdown sequence timings for 672 * bucks/LDOs which are controlled via register interface are changed. 673 * At PMIC poweroff the voltage for BUCK6/7 is cut immediately at the 674 * beginning of shut-down sequence. As bucks 6 and 7 are parent 675 * supplies for LDO5 and LDO6 - this causes LDO5/6 voltage 676 * monitoring to errorneously detect under voltage and force PMIC to 677 * emergency state instead of poweroff. In order to avoid this we 678 * disable voltage monitoring for LDO5 and LDO6 679 */ 680 static const struct reg_init bd71837_ldo5_inits[] = { 681 { 682 .reg = BD718XX_REG_MVRFLTMASK2, 683 .mask = BD718XX_LDO5_VRMON80, 684 .val = BD718XX_LDO5_VRMON80, 685 }, 686 }; 687 688 static const struct reg_init bd71837_ldo6_inits[] = { 689 { 690 .reg = BD718XX_REG_MVRFLTMASK2, 691 .mask = BD718XX_LDO6_VRMON80, 692 .val = BD718XX_LDO6_VRMON80, 693 }, 694 }; 695 696 static int buck_set_hw_dvs_levels(struct device_node *np, 697 const struct regulator_desc *desc, 698 struct regulator_config *cfg) 699 { 700 struct bd718xx_regulator_data *data; 701 702 data = container_of(desc, struct bd718xx_regulator_data, desc); 703 704 return rohm_regulator_set_dvs_levels(&data->dvs, np, desc, cfg->regmap); 705 } 706 707 static const struct regulator_ops *bd71847_swcontrol_ops[] = { 708 &bd718xx_dvs_buck_regulator_ops, &bd718xx_dvs_buck_regulator_ops, 709 &bd718xx_pickable_range_buck_ops, &bd718xx_pickable_range_buck_ops, 710 &bd718xx_buck_regulator_nolinear_ops, &bd718xx_buck_regulator_ops, 711 &bd718xx_pickable_range_ldo_ops, &bd718xx_ldo_regulator_nolinear_ops, 712 &bd718xx_ldo_regulator_ops, &bd718xx_ldo_regulator_ops, 713 &bd718xx_pickable_range_ldo_ops, &bd718xx_ldo_regulator_ops, 714 }; 715 716 static const struct regulator_ops *bd71847_hwcontrol_ops[] = { 717 &BD718XX_HWOPNAME(bd718xx_dvs_buck_regulator_ops), 718 &BD718XX_HWOPNAME(bd718xx_dvs_buck_regulator_ops), 719 &BD718XX_HWOPNAME(bd718xx_pickable_range_buck_ops), 720 &BD718XX_HWOPNAME(bd718xx_pickable_range_buck_ops), 721 &BD718XX_HWOPNAME(bd718xx_buck_regulator_nolinear_ops), 722 &BD718XX_HWOPNAME(bd718xx_buck_regulator_ops), 723 &BD718XX_HWOPNAME(bd718xx_pickable_range_ldo_ops), 724 &BD718XX_HWOPNAME(bd718xx_ldo_regulator_nolinear_ops), 725 &BD718XX_HWOPNAME(bd718xx_ldo_regulator_ops), 726 &BD718XX_HWOPNAME(bd718xx_ldo_regulator_ops), 727 &bd718xx_ldo5_ops_hwstate, 728 &BD718XX_HWOPNAME(bd718xx_ldo_regulator_ops), 729 }; 730 731 static struct bd718xx_regulator_data bd71847_regulators[] = { 732 { 733 .desc = { 734 .name = "buck1", 735 .of_match = of_match_ptr("BUCK1"), 736 .regulators_node = of_match_ptr("regulators"), 737 .id = BD718XX_BUCK1, 738 .type = REGULATOR_VOLTAGE, 739 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM, 740 .linear_ranges = bd718xx_dvs_buck_volts, 741 .n_linear_ranges = 742 ARRAY_SIZE(bd718xx_dvs_buck_volts), 743 .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN, 744 .vsel_mask = DVS_BUCK_RUN_MASK, 745 .enable_reg = BD718XX_REG_BUCK1_CTRL, 746 .enable_mask = BD718XX_BUCK_EN, 747 .enable_time = BD71847_BUCK1_STARTUP_TIME, 748 .owner = THIS_MODULE, 749 .ramp_delay_table = bd718xx_ramp_delay, 750 .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay), 751 .ramp_reg = BD718XX_REG_BUCK1_CTRL, 752 .ramp_mask = BUCK_RAMPRATE_MASK, 753 .of_parse_cb = buck_set_hw_dvs_levels, 754 }, 755 .dvs = { 756 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | 757 ROHM_DVS_LEVEL_SUSPEND, 758 .run_reg = BD718XX_REG_BUCK1_VOLT_RUN, 759 .run_mask = DVS_BUCK_RUN_MASK, 760 .idle_reg = BD718XX_REG_BUCK1_VOLT_IDLE, 761 .idle_mask = DVS_BUCK_RUN_MASK, 762 .suspend_reg = BD718XX_REG_BUCK1_VOLT_SUSP, 763 .suspend_mask = DVS_BUCK_RUN_MASK, 764 }, 765 .init = { 766 .reg = BD718XX_REG_BUCK1_CTRL, 767 .mask = BD718XX_BUCK_SEL, 768 .val = BD718XX_BUCK_SEL, 769 }, 770 }, 771 { 772 .desc = { 773 .name = "buck2", 774 .of_match = of_match_ptr("BUCK2"), 775 .regulators_node = of_match_ptr("regulators"), 776 .id = BD718XX_BUCK2, 777 .type = REGULATOR_VOLTAGE, 778 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM, 779 .linear_ranges = bd718xx_dvs_buck_volts, 780 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts), 781 .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN, 782 .vsel_mask = DVS_BUCK_RUN_MASK, 783 .enable_reg = BD718XX_REG_BUCK2_CTRL, 784 .enable_mask = BD718XX_BUCK_EN, 785 .enable_time = BD71847_BUCK2_STARTUP_TIME, 786 .ramp_delay_table = bd718xx_ramp_delay, 787 .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay), 788 .ramp_reg = BD718XX_REG_BUCK2_CTRL, 789 .ramp_mask = BUCK_RAMPRATE_MASK, 790 .owner = THIS_MODULE, 791 .of_parse_cb = buck_set_hw_dvs_levels, 792 }, 793 .dvs = { 794 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE, 795 .run_reg = BD718XX_REG_BUCK2_VOLT_RUN, 796 .run_mask = DVS_BUCK_RUN_MASK, 797 .idle_reg = BD718XX_REG_BUCK2_VOLT_IDLE, 798 .idle_mask = DVS_BUCK_RUN_MASK, 799 }, 800 .init = { 801 .reg = BD718XX_REG_BUCK2_CTRL, 802 .mask = BD718XX_BUCK_SEL, 803 .val = BD718XX_BUCK_SEL, 804 }, 805 }, 806 { 807 .desc = { 808 .name = "buck3", 809 .of_match = of_match_ptr("BUCK3"), 810 .regulators_node = of_match_ptr("regulators"), 811 .id = BD718XX_BUCK3, 812 .type = REGULATOR_VOLTAGE, 813 .n_voltages = BD71847_BUCK3_VOLTAGE_NUM, 814 .linear_ranges = bd71847_buck3_volts, 815 .n_linear_ranges = 816 ARRAY_SIZE(bd71847_buck3_volts), 817 .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT, 818 .vsel_mask = BD718XX_1ST_NODVS_BUCK_MASK, 819 .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT, 820 .vsel_range_mask = BD71847_BUCK3_RANGE_MASK, 821 .linear_range_selectors_bitfield = bd71847_buck3_volt_range_sel, 822 .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL, 823 .enable_mask = BD718XX_BUCK_EN, 824 .enable_time = BD71847_BUCK3_STARTUP_TIME, 825 .owner = THIS_MODULE, 826 }, 827 .init = { 828 .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL, 829 .mask = BD718XX_BUCK_SEL, 830 .val = BD718XX_BUCK_SEL, 831 }, 832 }, 833 { 834 .desc = { 835 .name = "buck4", 836 .of_match = of_match_ptr("BUCK4"), 837 .regulators_node = of_match_ptr("regulators"), 838 .id = BD718XX_BUCK4, 839 .type = REGULATOR_VOLTAGE, 840 .n_voltages = BD71847_BUCK4_VOLTAGE_NUM, 841 .linear_ranges = bd71847_buck4_volts, 842 .n_linear_ranges = 843 ARRAY_SIZE(bd71847_buck4_volts), 844 .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL, 845 .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT, 846 .vsel_mask = BD71847_BUCK4_MASK, 847 .vsel_range_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT, 848 .vsel_range_mask = BD71847_BUCK4_RANGE_MASK, 849 .linear_range_selectors_bitfield = bd71847_buck4_volt_range_sel, 850 .enable_mask = BD718XX_BUCK_EN, 851 .enable_time = BD71847_BUCK4_STARTUP_TIME, 852 .owner = THIS_MODULE, 853 }, 854 .init = { 855 .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL, 856 .mask = BD718XX_BUCK_SEL, 857 .val = BD718XX_BUCK_SEL, 858 }, 859 }, 860 { 861 .desc = { 862 .name = "buck5", 863 .of_match = of_match_ptr("BUCK5"), 864 .regulators_node = of_match_ptr("regulators"), 865 .id = BD718XX_BUCK5, 866 .type = REGULATOR_VOLTAGE, 867 .volt_table = &bd718xx_3rd_nodvs_buck_volts[0], 868 .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts), 869 .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT, 870 .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK, 871 .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL, 872 .enable_mask = BD718XX_BUCK_EN, 873 .enable_time = BD71847_BUCK5_STARTUP_TIME, 874 .owner = THIS_MODULE, 875 }, 876 .init = { 877 .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL, 878 .mask = BD718XX_BUCK_SEL, 879 .val = BD718XX_BUCK_SEL, 880 }, 881 }, 882 { 883 .desc = { 884 .name = "buck6", 885 .of_match = of_match_ptr("BUCK6"), 886 .regulators_node = of_match_ptr("regulators"), 887 .id = BD718XX_BUCK6, 888 .type = REGULATOR_VOLTAGE, 889 .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM, 890 .linear_ranges = bd718xx_4th_nodvs_buck_volts, 891 .n_linear_ranges = 892 ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts), 893 .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT, 894 .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK, 895 .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL, 896 .enable_mask = BD718XX_BUCK_EN, 897 .enable_time = BD71847_BUCK6_STARTUP_TIME, 898 .owner = THIS_MODULE, 899 }, 900 .init = { 901 .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL, 902 .mask = BD718XX_BUCK_SEL, 903 .val = BD718XX_BUCK_SEL, 904 }, 905 }, 906 { 907 .desc = { 908 .name = "ldo1", 909 .of_match = of_match_ptr("LDO1"), 910 .regulators_node = of_match_ptr("regulators"), 911 .id = BD718XX_LDO1, 912 .type = REGULATOR_VOLTAGE, 913 .n_voltages = BD718XX_LDO1_VOLTAGE_NUM, 914 .linear_ranges = bd718xx_ldo1_volts, 915 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts), 916 .vsel_reg = BD718XX_REG_LDO1_VOLT, 917 .vsel_mask = BD718XX_LDO1_MASK, 918 .vsel_range_reg = BD718XX_REG_LDO1_VOLT, 919 .vsel_range_mask = BD718XX_LDO1_RANGE_MASK, 920 .linear_range_selectors_bitfield = bd718xx_ldo1_volt_range_sel, 921 .enable_reg = BD718XX_REG_LDO1_VOLT, 922 .enable_mask = BD718XX_LDO_EN, 923 .enable_time = BD71847_LDO1_STARTUP_TIME, 924 .owner = THIS_MODULE, 925 }, 926 .init = { 927 .reg = BD718XX_REG_LDO1_VOLT, 928 .mask = BD718XX_LDO_SEL, 929 .val = BD718XX_LDO_SEL, 930 }, 931 }, 932 { 933 .desc = { 934 .name = "ldo2", 935 .of_match = of_match_ptr("LDO2"), 936 .regulators_node = of_match_ptr("regulators"), 937 .id = BD718XX_LDO2, 938 .type = REGULATOR_VOLTAGE, 939 .volt_table = &ldo_2_volts[0], 940 .vsel_reg = BD718XX_REG_LDO2_VOLT, 941 .vsel_mask = BD718XX_LDO2_MASK, 942 .n_voltages = ARRAY_SIZE(ldo_2_volts), 943 .enable_reg = BD718XX_REG_LDO2_VOLT, 944 .enable_mask = BD718XX_LDO_EN, 945 .enable_time = BD71847_LDO2_STARTUP_TIME, 946 .owner = THIS_MODULE, 947 }, 948 .init = { 949 .reg = BD718XX_REG_LDO2_VOLT, 950 .mask = BD718XX_LDO_SEL, 951 .val = BD718XX_LDO_SEL, 952 }, 953 }, 954 { 955 .desc = { 956 .name = "ldo3", 957 .of_match = of_match_ptr("LDO3"), 958 .regulators_node = of_match_ptr("regulators"), 959 .id = BD718XX_LDO3, 960 .type = REGULATOR_VOLTAGE, 961 .n_voltages = BD718XX_LDO3_VOLTAGE_NUM, 962 .linear_ranges = bd718xx_ldo3_volts, 963 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts), 964 .vsel_reg = BD718XX_REG_LDO3_VOLT, 965 .vsel_mask = BD718XX_LDO3_MASK, 966 .enable_reg = BD718XX_REG_LDO3_VOLT, 967 .enable_mask = BD718XX_LDO_EN, 968 .enable_time = BD71847_LDO3_STARTUP_TIME, 969 .owner = THIS_MODULE, 970 }, 971 .init = { 972 .reg = BD718XX_REG_LDO3_VOLT, 973 .mask = BD718XX_LDO_SEL, 974 .val = BD718XX_LDO_SEL, 975 }, 976 }, 977 { 978 .desc = { 979 .name = "ldo4", 980 .of_match = of_match_ptr("LDO4"), 981 .regulators_node = of_match_ptr("regulators"), 982 .id = BD718XX_LDO4, 983 .type = REGULATOR_VOLTAGE, 984 .n_voltages = BD718XX_LDO4_VOLTAGE_NUM, 985 .linear_ranges = bd718xx_ldo4_volts, 986 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts), 987 .vsel_reg = BD718XX_REG_LDO4_VOLT, 988 .vsel_mask = BD718XX_LDO4_MASK, 989 .enable_reg = BD718XX_REG_LDO4_VOLT, 990 .enable_mask = BD718XX_LDO_EN, 991 .enable_time = BD71847_LDO4_STARTUP_TIME, 992 .owner = THIS_MODULE, 993 }, 994 .init = { 995 .reg = BD718XX_REG_LDO4_VOLT, 996 .mask = BD718XX_LDO_SEL, 997 .val = BD718XX_LDO_SEL, 998 }, 999 }, 1000 { 1001 .desc = { 1002 .name = "ldo5", 1003 .of_match = of_match_ptr("LDO5"), 1004 .regulators_node = of_match_ptr("regulators"), 1005 .id = BD718XX_LDO5, 1006 .type = REGULATOR_VOLTAGE, 1007 .n_voltages = BD71847_LDO5_VOLTAGE_NUM, 1008 .linear_ranges = bd71847_ldo5_volts, 1009 .n_linear_ranges = ARRAY_SIZE(bd71847_ldo5_volts), 1010 .vsel_reg = BD718XX_REG_LDO5_VOLT, 1011 .vsel_mask = BD71847_LDO5_MASK, 1012 .vsel_range_reg = BD718XX_REG_LDO5_VOLT, 1013 .vsel_range_mask = BD71847_LDO5_RANGE_MASK, 1014 .linear_range_selectors_bitfield = bd71847_ldo5_volt_range_sel, 1015 .enable_reg = BD718XX_REG_LDO5_VOLT, 1016 .enable_mask = BD718XX_LDO_EN, 1017 .enable_time = BD71847_LDO5_STARTUP_TIME, 1018 .owner = THIS_MODULE, 1019 }, 1020 .init = { 1021 .reg = BD718XX_REG_LDO5_VOLT, 1022 .mask = BD718XX_LDO_SEL, 1023 .val = BD718XX_LDO_SEL, 1024 }, 1025 }, 1026 { 1027 .desc = { 1028 .name = "ldo6", 1029 .of_match = of_match_ptr("LDO6"), 1030 .regulators_node = of_match_ptr("regulators"), 1031 .id = BD718XX_LDO6, 1032 .type = REGULATOR_VOLTAGE, 1033 .n_voltages = BD718XX_LDO6_VOLTAGE_NUM, 1034 .linear_ranges = bd718xx_ldo6_volts, 1035 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts), 1036 /* LDO6 is supplied by buck5 */ 1037 .supply_name = "buck5", 1038 .vsel_reg = BD718XX_REG_LDO6_VOLT, 1039 .vsel_mask = BD718XX_LDO6_MASK, 1040 .enable_reg = BD718XX_REG_LDO6_VOLT, 1041 .enable_mask = BD718XX_LDO_EN, 1042 .enable_time = BD71847_LDO6_STARTUP_TIME, 1043 .owner = THIS_MODULE, 1044 }, 1045 .init = { 1046 .reg = BD718XX_REG_LDO6_VOLT, 1047 .mask = BD718XX_LDO_SEL, 1048 .val = BD718XX_LDO_SEL, 1049 }, 1050 }, 1051 }; 1052 1053 static const struct regulator_ops *bd71837_swcontrol_ops[] = { 1054 &bd718xx_dvs_buck_regulator_ops, &bd718xx_dvs_buck_regulator_ops, 1055 &bd718xx_dvs_buck_regulator_ops, &bd718xx_dvs_buck_regulator_ops, 1056 &bd71837_pickable_range_buck_ops, &bd71837_buck_regulator_ops, 1057 &bd71837_buck_regulator_nolinear_ops, &bd71837_buck_regulator_ops, 1058 &bd71837_pickable_range_ldo_ops, &bd71837_ldo_regulator_nolinear_ops, 1059 &bd71837_ldo_regulator_ops, &bd71837_ldo_regulator_ops, 1060 &bd71837_ldo_regulator_ops, &bd71837_ldo_regulator_ops, 1061 &bd71837_ldo_regulator_ops, 1062 }; 1063 1064 static const struct regulator_ops *bd71837_hwcontrol_ops[] = { 1065 &BD718XX_HWOPNAME(bd718xx_dvs_buck_regulator_ops), 1066 &BD718XX_HWOPNAME(bd718xx_dvs_buck_regulator_ops), 1067 &bd71837_buck34_ops_hwctrl, &bd71837_buck34_ops_hwctrl, 1068 &BD718XX_HWOPNAME(bd71837_pickable_range_buck_ops), 1069 &BD718XX_HWOPNAME(bd71837_buck_regulator_ops), 1070 &BD718XX_HWOPNAME(bd71837_buck_regulator_nolinear_ops), 1071 &BD718XX_HWOPNAME(bd71837_buck_regulator_ops), 1072 &BD718XX_HWOPNAME(bd71837_pickable_range_ldo_ops), 1073 &BD718XX_HWOPNAME(bd71837_ldo_regulator_nolinear_ops), 1074 &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops), 1075 &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops), 1076 &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops), 1077 &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops), 1078 &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops), 1079 }; 1080 1081 static struct bd718xx_regulator_data bd71837_regulators[] = { 1082 { 1083 .desc = { 1084 .name = "buck1", 1085 .of_match = of_match_ptr("BUCK1"), 1086 .regulators_node = of_match_ptr("regulators"), 1087 .id = BD718XX_BUCK1, 1088 .type = REGULATOR_VOLTAGE, 1089 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM, 1090 .linear_ranges = bd718xx_dvs_buck_volts, 1091 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts), 1092 .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN, 1093 .vsel_mask = DVS_BUCK_RUN_MASK, 1094 .enable_reg = BD718XX_REG_BUCK1_CTRL, 1095 .enable_mask = BD718XX_BUCK_EN, 1096 .enable_time = BD71837_BUCK1_STARTUP_TIME, 1097 .ramp_delay_table = bd718xx_ramp_delay, 1098 .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay), 1099 .ramp_reg = BD718XX_REG_BUCK1_CTRL, 1100 .ramp_mask = BUCK_RAMPRATE_MASK, 1101 .owner = THIS_MODULE, 1102 .of_parse_cb = buck_set_hw_dvs_levels, 1103 }, 1104 .dvs = { 1105 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | 1106 ROHM_DVS_LEVEL_SUSPEND, 1107 .run_reg = BD718XX_REG_BUCK1_VOLT_RUN, 1108 .run_mask = DVS_BUCK_RUN_MASK, 1109 .idle_reg = BD718XX_REG_BUCK1_VOLT_IDLE, 1110 .idle_mask = DVS_BUCK_RUN_MASK, 1111 .suspend_reg = BD718XX_REG_BUCK1_VOLT_SUSP, 1112 .suspend_mask = DVS_BUCK_RUN_MASK, 1113 }, 1114 .init = { 1115 .reg = BD718XX_REG_BUCK1_CTRL, 1116 .mask = BD718XX_BUCK_SEL, 1117 .val = BD718XX_BUCK_SEL, 1118 }, 1119 }, 1120 { 1121 .desc = { 1122 .name = "buck2", 1123 .of_match = of_match_ptr("BUCK2"), 1124 .regulators_node = of_match_ptr("regulators"), 1125 .id = BD718XX_BUCK2, 1126 .type = REGULATOR_VOLTAGE, 1127 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM, 1128 .linear_ranges = bd718xx_dvs_buck_volts, 1129 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts), 1130 .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN, 1131 .vsel_mask = DVS_BUCK_RUN_MASK, 1132 .enable_reg = BD718XX_REG_BUCK2_CTRL, 1133 .enable_mask = BD718XX_BUCK_EN, 1134 .enable_time = BD71837_BUCK2_STARTUP_TIME, 1135 .ramp_delay_table = bd718xx_ramp_delay, 1136 .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay), 1137 .ramp_reg = BD718XX_REG_BUCK2_CTRL, 1138 .ramp_mask = BUCK_RAMPRATE_MASK, 1139 .owner = THIS_MODULE, 1140 .of_parse_cb = buck_set_hw_dvs_levels, 1141 }, 1142 .dvs = { 1143 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE, 1144 .run_reg = BD718XX_REG_BUCK2_VOLT_RUN, 1145 .run_mask = DVS_BUCK_RUN_MASK, 1146 .idle_reg = BD718XX_REG_BUCK2_VOLT_IDLE, 1147 .idle_mask = DVS_BUCK_RUN_MASK, 1148 }, 1149 .init = { 1150 .reg = BD718XX_REG_BUCK2_CTRL, 1151 .mask = BD718XX_BUCK_SEL, 1152 .val = BD718XX_BUCK_SEL, 1153 }, 1154 }, 1155 { 1156 .desc = { 1157 .name = "buck3", 1158 .of_match = of_match_ptr("BUCK3"), 1159 .regulators_node = of_match_ptr("regulators"), 1160 .id = BD718XX_BUCK3, 1161 .type = REGULATOR_VOLTAGE, 1162 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM, 1163 .linear_ranges = bd718xx_dvs_buck_volts, 1164 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts), 1165 .vsel_reg = BD71837_REG_BUCK3_VOLT_RUN, 1166 .vsel_mask = DVS_BUCK_RUN_MASK, 1167 .enable_reg = BD71837_REG_BUCK3_CTRL, 1168 .enable_mask = BD718XX_BUCK_EN, 1169 .enable_time = BD71837_BUCK3_STARTUP_TIME, 1170 .ramp_delay_table = bd718xx_ramp_delay, 1171 .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay), 1172 .ramp_reg = BD71837_REG_BUCK3_CTRL, 1173 .ramp_mask = BUCK_RAMPRATE_MASK, 1174 .owner = THIS_MODULE, 1175 .of_parse_cb = buck_set_hw_dvs_levels, 1176 }, 1177 .dvs = { 1178 .level_map = ROHM_DVS_LEVEL_RUN, 1179 .run_reg = BD71837_REG_BUCK3_VOLT_RUN, 1180 .run_mask = DVS_BUCK_RUN_MASK, 1181 }, 1182 .init = { 1183 .reg = BD71837_REG_BUCK3_CTRL, 1184 .mask = BD718XX_BUCK_SEL, 1185 .val = BD718XX_BUCK_SEL, 1186 }, 1187 }, 1188 { 1189 .desc = { 1190 .name = "buck4", 1191 .of_match = of_match_ptr("BUCK4"), 1192 .regulators_node = of_match_ptr("regulators"), 1193 .id = BD718XX_BUCK4, 1194 .type = REGULATOR_VOLTAGE, 1195 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM, 1196 .linear_ranges = bd718xx_dvs_buck_volts, 1197 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts), 1198 .vsel_reg = BD71837_REG_BUCK4_VOLT_RUN, 1199 .vsel_mask = DVS_BUCK_RUN_MASK, 1200 .enable_reg = BD71837_REG_BUCK4_CTRL, 1201 .enable_mask = BD718XX_BUCK_EN, 1202 .enable_time = BD71837_BUCK4_STARTUP_TIME, 1203 .ramp_delay_table = bd718xx_ramp_delay, 1204 .n_ramp_values = ARRAY_SIZE(bd718xx_ramp_delay), 1205 .ramp_reg = BD71837_REG_BUCK4_CTRL, 1206 .ramp_mask = BUCK_RAMPRATE_MASK, 1207 .owner = THIS_MODULE, 1208 .of_parse_cb = buck_set_hw_dvs_levels, 1209 }, 1210 .dvs = { 1211 .level_map = ROHM_DVS_LEVEL_RUN, 1212 .run_reg = BD71837_REG_BUCK4_VOLT_RUN, 1213 .run_mask = DVS_BUCK_RUN_MASK, 1214 }, 1215 .init = { 1216 .reg = BD71837_REG_BUCK4_CTRL, 1217 .mask = BD718XX_BUCK_SEL, 1218 .val = BD718XX_BUCK_SEL, 1219 }, 1220 }, 1221 { 1222 .desc = { 1223 .name = "buck5", 1224 .of_match = of_match_ptr("BUCK5"), 1225 .regulators_node = of_match_ptr("regulators"), 1226 .id = BD718XX_BUCK5, 1227 .type = REGULATOR_VOLTAGE, 1228 .n_voltages = BD71837_BUCK5_VOLTAGE_NUM, 1229 .linear_ranges = bd71837_buck5_volts, 1230 .n_linear_ranges = 1231 ARRAY_SIZE(bd71837_buck5_volts), 1232 .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT, 1233 .vsel_mask = BD71837_BUCK5_MASK, 1234 .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT, 1235 .vsel_range_mask = BD71837_BUCK5_RANGE_MASK, 1236 .linear_range_selectors_bitfield = bd71837_buck5_volt_range_sel, 1237 .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL, 1238 .enable_mask = BD718XX_BUCK_EN, 1239 .enable_time = BD71837_BUCK5_STARTUP_TIME, 1240 .owner = THIS_MODULE, 1241 }, 1242 .init = { 1243 .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL, 1244 .mask = BD718XX_BUCK_SEL, 1245 .val = BD718XX_BUCK_SEL, 1246 }, 1247 }, 1248 { 1249 .desc = { 1250 .name = "buck6", 1251 .of_match = of_match_ptr("BUCK6"), 1252 .regulators_node = of_match_ptr("regulators"), 1253 .id = BD718XX_BUCK6, 1254 .type = REGULATOR_VOLTAGE, 1255 .n_voltages = BD71837_BUCK6_VOLTAGE_NUM, 1256 .linear_ranges = bd71837_buck6_volts, 1257 .n_linear_ranges = 1258 ARRAY_SIZE(bd71837_buck6_volts), 1259 .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT, 1260 .vsel_mask = BD71837_BUCK6_MASK, 1261 .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL, 1262 .enable_mask = BD718XX_BUCK_EN, 1263 .enable_time = BD71837_BUCK6_STARTUP_TIME, 1264 .owner = THIS_MODULE, 1265 }, 1266 .init = { 1267 .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL, 1268 .mask = BD718XX_BUCK_SEL, 1269 .val = BD718XX_BUCK_SEL, 1270 }, 1271 }, 1272 { 1273 .desc = { 1274 .name = "buck7", 1275 .of_match = of_match_ptr("BUCK7"), 1276 .regulators_node = of_match_ptr("regulators"), 1277 .id = BD718XX_BUCK7, 1278 .type = REGULATOR_VOLTAGE, 1279 .volt_table = &bd718xx_3rd_nodvs_buck_volts[0], 1280 .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts), 1281 .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT, 1282 .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK, 1283 .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL, 1284 .enable_mask = BD718XX_BUCK_EN, 1285 .enable_time = BD71837_BUCK7_STARTUP_TIME, 1286 .owner = THIS_MODULE, 1287 }, 1288 .init = { 1289 .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL, 1290 .mask = BD718XX_BUCK_SEL, 1291 .val = BD718XX_BUCK_SEL, 1292 }, 1293 }, 1294 { 1295 .desc = { 1296 .name = "buck8", 1297 .of_match = of_match_ptr("BUCK8"), 1298 .regulators_node = of_match_ptr("regulators"), 1299 .id = BD718XX_BUCK8, 1300 .type = REGULATOR_VOLTAGE, 1301 .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM, 1302 .linear_ranges = bd718xx_4th_nodvs_buck_volts, 1303 .n_linear_ranges = 1304 ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts), 1305 .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT, 1306 .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK, 1307 .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL, 1308 .enable_mask = BD718XX_BUCK_EN, 1309 .enable_time = BD71837_BUCK8_STARTUP_TIME, 1310 .owner = THIS_MODULE, 1311 }, 1312 .init = { 1313 .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL, 1314 .mask = BD718XX_BUCK_SEL, 1315 .val = BD718XX_BUCK_SEL, 1316 }, 1317 }, 1318 { 1319 .desc = { 1320 .name = "ldo1", 1321 .of_match = of_match_ptr("LDO1"), 1322 .regulators_node = of_match_ptr("regulators"), 1323 .id = BD718XX_LDO1, 1324 .type = REGULATOR_VOLTAGE, 1325 .n_voltages = BD718XX_LDO1_VOLTAGE_NUM, 1326 .linear_ranges = bd718xx_ldo1_volts, 1327 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts), 1328 .vsel_reg = BD718XX_REG_LDO1_VOLT, 1329 .vsel_mask = BD718XX_LDO1_MASK, 1330 .vsel_range_reg = BD718XX_REG_LDO1_VOLT, 1331 .vsel_range_mask = BD718XX_LDO1_RANGE_MASK, 1332 .linear_range_selectors_bitfield = bd718xx_ldo1_volt_range_sel, 1333 .enable_reg = BD718XX_REG_LDO1_VOLT, 1334 .enable_mask = BD718XX_LDO_EN, 1335 .enable_time = BD71837_LDO1_STARTUP_TIME, 1336 .owner = THIS_MODULE, 1337 }, 1338 .init = { 1339 .reg = BD718XX_REG_LDO1_VOLT, 1340 .mask = BD718XX_LDO_SEL, 1341 .val = BD718XX_LDO_SEL, 1342 }, 1343 }, 1344 { 1345 .desc = { 1346 .name = "ldo2", 1347 .of_match = of_match_ptr("LDO2"), 1348 .regulators_node = of_match_ptr("regulators"), 1349 .id = BD718XX_LDO2, 1350 .type = REGULATOR_VOLTAGE, 1351 .volt_table = &ldo_2_volts[0], 1352 .vsel_reg = BD718XX_REG_LDO2_VOLT, 1353 .vsel_mask = BD718XX_LDO2_MASK, 1354 .n_voltages = ARRAY_SIZE(ldo_2_volts), 1355 .enable_reg = BD718XX_REG_LDO2_VOLT, 1356 .enable_mask = BD718XX_LDO_EN, 1357 .enable_time = BD71837_LDO2_STARTUP_TIME, 1358 .owner = THIS_MODULE, 1359 }, 1360 .init = { 1361 .reg = BD718XX_REG_LDO2_VOLT, 1362 .mask = BD718XX_LDO_SEL, 1363 .val = BD718XX_LDO_SEL, 1364 }, 1365 }, 1366 { 1367 .desc = { 1368 .name = "ldo3", 1369 .of_match = of_match_ptr("LDO3"), 1370 .regulators_node = of_match_ptr("regulators"), 1371 .id = BD718XX_LDO3, 1372 .type = REGULATOR_VOLTAGE, 1373 .n_voltages = BD718XX_LDO3_VOLTAGE_NUM, 1374 .linear_ranges = bd718xx_ldo3_volts, 1375 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts), 1376 .vsel_reg = BD718XX_REG_LDO3_VOLT, 1377 .vsel_mask = BD718XX_LDO3_MASK, 1378 .enable_reg = BD718XX_REG_LDO3_VOLT, 1379 .enable_mask = BD718XX_LDO_EN, 1380 .enable_time = BD71837_LDO3_STARTUP_TIME, 1381 .owner = THIS_MODULE, 1382 }, 1383 .init = { 1384 .reg = BD718XX_REG_LDO3_VOLT, 1385 .mask = BD718XX_LDO_SEL, 1386 .val = BD718XX_LDO_SEL, 1387 }, 1388 }, 1389 { 1390 .desc = { 1391 .name = "ldo4", 1392 .of_match = of_match_ptr("LDO4"), 1393 .regulators_node = of_match_ptr("regulators"), 1394 .id = BD718XX_LDO4, 1395 .type = REGULATOR_VOLTAGE, 1396 .n_voltages = BD718XX_LDO4_VOLTAGE_NUM, 1397 .linear_ranges = bd718xx_ldo4_volts, 1398 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts), 1399 .vsel_reg = BD718XX_REG_LDO4_VOLT, 1400 .vsel_mask = BD718XX_LDO4_MASK, 1401 .enable_reg = BD718XX_REG_LDO4_VOLT, 1402 .enable_mask = BD718XX_LDO_EN, 1403 .enable_time = BD71837_LDO4_STARTUP_TIME, 1404 .owner = THIS_MODULE, 1405 }, 1406 .init = { 1407 .reg = BD718XX_REG_LDO4_VOLT, 1408 .mask = BD718XX_LDO_SEL, 1409 .val = BD718XX_LDO_SEL, 1410 }, 1411 }, 1412 { 1413 .desc = { 1414 .name = "ldo5", 1415 .of_match = of_match_ptr("LDO5"), 1416 .regulators_node = of_match_ptr("regulators"), 1417 .id = BD718XX_LDO5, 1418 .type = REGULATOR_VOLTAGE, 1419 .n_voltages = BD71837_LDO5_VOLTAGE_NUM, 1420 .linear_ranges = bd71837_ldo5_volts, 1421 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo5_volts), 1422 /* LDO5 is supplied by buck6 */ 1423 .supply_name = "buck6", 1424 .vsel_reg = BD718XX_REG_LDO5_VOLT, 1425 .vsel_mask = BD71837_LDO5_MASK, 1426 .enable_reg = BD718XX_REG_LDO5_VOLT, 1427 .enable_mask = BD718XX_LDO_EN, 1428 .enable_time = BD71837_LDO5_STARTUP_TIME, 1429 .owner = THIS_MODULE, 1430 }, 1431 .init = { 1432 .reg = BD718XX_REG_LDO5_VOLT, 1433 .mask = BD718XX_LDO_SEL, 1434 .val = BD718XX_LDO_SEL, 1435 }, 1436 .additional_inits = bd71837_ldo5_inits, 1437 .additional_init_amnt = ARRAY_SIZE(bd71837_ldo5_inits), 1438 }, 1439 { 1440 .desc = { 1441 .name = "ldo6", 1442 .of_match = of_match_ptr("LDO6"), 1443 .regulators_node = of_match_ptr("regulators"), 1444 .id = BD718XX_LDO6, 1445 .type = REGULATOR_VOLTAGE, 1446 .n_voltages = BD718XX_LDO6_VOLTAGE_NUM, 1447 .linear_ranges = bd718xx_ldo6_volts, 1448 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts), 1449 /* LDO6 is supplied by buck7 */ 1450 .supply_name = "buck7", 1451 .vsel_reg = BD718XX_REG_LDO6_VOLT, 1452 .vsel_mask = BD718XX_LDO6_MASK, 1453 .enable_reg = BD718XX_REG_LDO6_VOLT, 1454 .enable_mask = BD718XX_LDO_EN, 1455 .enable_time = BD71837_LDO6_STARTUP_TIME, 1456 .owner = THIS_MODULE, 1457 }, 1458 .init = { 1459 .reg = BD718XX_REG_LDO6_VOLT, 1460 .mask = BD718XX_LDO_SEL, 1461 .val = BD718XX_LDO_SEL, 1462 }, 1463 .additional_inits = bd71837_ldo6_inits, 1464 .additional_init_amnt = ARRAY_SIZE(bd71837_ldo6_inits), 1465 }, 1466 { 1467 .desc = { 1468 .name = "ldo7", 1469 .of_match = of_match_ptr("LDO7"), 1470 .regulators_node = of_match_ptr("regulators"), 1471 .id = BD718XX_LDO7, 1472 .type = REGULATOR_VOLTAGE, 1473 .n_voltages = BD71837_LDO7_VOLTAGE_NUM, 1474 .linear_ranges = bd71837_ldo7_volts, 1475 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo7_volts), 1476 .vsel_reg = BD71837_REG_LDO7_VOLT, 1477 .vsel_mask = BD71837_LDO7_MASK, 1478 .enable_reg = BD71837_REG_LDO7_VOLT, 1479 .enable_mask = BD718XX_LDO_EN, 1480 .enable_time = BD71837_LDO7_STARTUP_TIME, 1481 .owner = THIS_MODULE, 1482 }, 1483 .init = { 1484 .reg = BD71837_REG_LDO7_VOLT, 1485 .mask = BD718XX_LDO_SEL, 1486 .val = BD718XX_LDO_SEL, 1487 }, 1488 }, 1489 }; 1490 1491 static void mark_hw_controlled(struct device *dev, struct device_node *np, 1492 struct bd718xx_regulator_data *reg_data, 1493 unsigned int num_reg_data, int *info) 1494 { 1495 int i; 1496 1497 for (i = 1; i <= num_reg_data; i++) { 1498 if (!of_node_name_eq(np, reg_data[i-1].desc.of_match)) 1499 continue; 1500 1501 *info |= 1 << (i - 1); 1502 dev_dbg(dev, "regulator %d runlevel controlled\n", i); 1503 return; 1504 } 1505 dev_warn(dev, "Bad regulator node\n"); 1506 } 1507 1508 /* 1509 * Setups where regulator (especially the buck8) output voltage is scaled 1510 * by adding external connection where some other regulator output is connected 1511 * to feedback-pin (over suitable resistors) is getting popular amongst users 1512 * of BD71837. (This allows for example scaling down the buck8 voltages to suit 1513 * lover GPU voltages for projects where buck8 is (ab)used to supply power 1514 * for GPU. Additionally some setups do allow DVS for buck8 but as this do 1515 * produce voltage spikes the HW must be evaluated to be able to survive this 1516 * - hence I keep the DVS disabled for non DVS bucks by default. I don't want 1517 * to help you burn your proto board) 1518 * 1519 * So we allow describing this external connection from DT and scale the 1520 * voltages accordingly. This is what the connection should look like: 1521 * 1522 * |------------| 1523 * | buck 8 |-------+----->Vout 1524 * | | | 1525 * |------------| | 1526 * | FB pin | 1527 * | | 1528 * +-------+--R2---+ 1529 * | 1530 * R1 1531 * | 1532 * V FB-pull-up 1533 * 1534 * Here the buck output is sifted according to formula: 1535 * 1536 * Vout_o = Vo - (Vpu - Vo)*R2/R1 1537 * Linear_step = step_orig*(R1+R2)/R1 1538 * 1539 * where: 1540 * Vout_o is adjusted voltage output at vsel reg value 0 1541 * Vo is original voltage output at vsel reg value 0 1542 * Vpu is the pull-up voltage V FB-pull-up in the picture 1543 * R1 and R2 are resistor values. 1544 * 1545 * As a real world example for buck8 and a specific GPU: 1546 * VLDO = 1.6V (used as FB-pull-up) 1547 * R1 = 1000ohms 1548 * R2 = 150ohms 1549 * VSEL 0x0 => 0.8V – (VLDO – 0.8) * R2 / R1 = 0.68V 1550 * Linear Step = 10mV * (R1 + R2) / R1 = 11.5mV 1551 */ 1552 static int setup_feedback_loop(struct device *dev, struct device_node *np, 1553 struct bd718xx_regulator_data *reg_data, 1554 unsigned int num_reg_data, int fb_uv) 1555 { 1556 int i, r1, r2, ret; 1557 1558 /* 1559 * We do adjust the values in the global desc based on DT settings. 1560 * This may not be best approach as it can cause problems if more than 1561 * one PMIC is controlled from same processor. I don't see such use-case 1562 * for BD718x7 now - so we spare some bits. 1563 * 1564 * If this will point out to be a problem - then we can allocate new 1565 * bd718xx_regulator_data array at probe and just use the global 1566 * array as a template where we copy initial values. Then we can 1567 * use allocated descs for regultor registration and do IC specific 1568 * modifications to this copy while leaving other PMICs untouched. But 1569 * that means allocating new array for each PMIC - and currently I see 1570 * no need for that. 1571 */ 1572 1573 for (i = 0; i < num_reg_data; i++) { 1574 struct regulator_desc *desc = ®_data[i].desc; 1575 int j; 1576 1577 if (!of_node_name_eq(np, desc->of_match)) 1578 continue; 1579 1580 /* The feedback loop connection does not make sense for LDOs */ 1581 if (desc->id >= BD718XX_LDO1) 1582 return -EINVAL; 1583 1584 ret = of_property_read_u32(np, "rohm,feedback-pull-up-r1-ohms", 1585 &r1); 1586 if (ret) 1587 return ret; 1588 1589 if (!r1) 1590 return -EINVAL; 1591 1592 ret = of_property_read_u32(np, "rohm,feedback-pull-up-r2-ohms", 1593 &r2); 1594 if (ret) 1595 return ret; 1596 1597 if (desc->n_linear_ranges && desc->linear_ranges) { 1598 struct linear_range *new; 1599 1600 new = devm_kzalloc(dev, desc->n_linear_ranges * 1601 sizeof(struct linear_range), 1602 GFP_KERNEL); 1603 if (!new) 1604 return -ENOMEM; 1605 1606 for (j = 0; j < desc->n_linear_ranges; j++) { 1607 int min = desc->linear_ranges[j].min; 1608 int step = desc->linear_ranges[j].step; 1609 1610 min -= (fb_uv - min)*r2/r1; 1611 step = step * (r1 + r2); 1612 step /= r1; 1613 1614 new[j].min = min; 1615 new[j].step = step; 1616 1617 dev_dbg(dev, "%s: old range min %d, step %d\n", 1618 desc->name, desc->linear_ranges[j].min, 1619 desc->linear_ranges[j].step); 1620 dev_dbg(dev, "new range min %d, step %d\n", min, 1621 step); 1622 } 1623 desc->linear_ranges = new; 1624 } 1625 dev_dbg(dev, "regulator '%s' has FB pull-up configured\n", 1626 desc->name); 1627 1628 return 0; 1629 } 1630 1631 return -ENODEV; 1632 } 1633 1634 static int get_special_regulators(struct device *dev, 1635 struct bd718xx_regulator_data *reg_data, 1636 unsigned int num_reg_data, int *info) 1637 { 1638 int ret; 1639 int uv; 1640 1641 *info = 0; 1642 1643 struct device_node *nproot __free(device_node) = of_get_child_by_name(dev->of_node, 1644 "regulators"); 1645 if (!nproot) { 1646 dev_err(dev, "failed to find regulators node\n"); 1647 return -ENODEV; 1648 } 1649 for_each_child_of_node_scoped(nproot, np) { 1650 if (of_property_read_bool(np, "rohm,no-regulator-enable-control")) 1651 mark_hw_controlled(dev, np, reg_data, num_reg_data, 1652 info); 1653 ret = of_property_read_u32(np, "rohm,fb-pull-up-microvolt", 1654 &uv); 1655 if (ret) { 1656 if (ret == -EINVAL) 1657 continue; 1658 else 1659 return ret; 1660 } 1661 1662 ret = setup_feedback_loop(dev, np, reg_data, num_reg_data, uv); 1663 if (ret) 1664 return ret; 1665 } 1666 1667 return 0; 1668 } 1669 1670 static int bd718xx_probe(struct platform_device *pdev) 1671 { 1672 struct regmap *regmap; 1673 struct regulator_config config = { 0 }; 1674 int i, j, err, omit_enable; 1675 bool use_snvs; 1676 struct bd718xx_regulator_data *reg_data; 1677 unsigned int num_reg_data; 1678 enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data; 1679 const struct regulator_ops **swops, **hwops; 1680 1681 regmap = dev_get_regmap(pdev->dev.parent, NULL); 1682 if (!regmap) { 1683 dev_err(&pdev->dev, "No MFD driver data\n"); 1684 return -EINVAL; 1685 } 1686 1687 switch (chip) { 1688 case ROHM_CHIP_TYPE_BD71837: 1689 reg_data = bd71837_regulators; 1690 num_reg_data = ARRAY_SIZE(bd71837_regulators); 1691 swops = &bd71837_swcontrol_ops[0]; 1692 hwops = &bd71837_hwcontrol_ops[0]; 1693 break; 1694 case ROHM_CHIP_TYPE_BD71847: 1695 reg_data = bd71847_regulators; 1696 num_reg_data = ARRAY_SIZE(bd71847_regulators); 1697 swops = &bd71847_swcontrol_ops[0]; 1698 hwops = &bd71847_hwcontrol_ops[0]; 1699 break; 1700 default: 1701 dev_err(&pdev->dev, "Unsupported chip type\n"); 1702 return -EINVAL; 1703 } 1704 1705 /* Register LOCK release */ 1706 err = regmap_update_bits(regmap, BD718XX_REG_REGLOCK, 1707 (REGLOCK_PWRSEQ | REGLOCK_VREG), 0); 1708 if (err) 1709 return dev_err_probe(&pdev->dev, err, "Failed to unlock PMIC\n"); 1710 1711 dev_dbg(&pdev->dev, "Unlocked lock register 0x%x\n", 1712 BD718XX_REG_REGLOCK); 1713 1714 use_snvs = of_property_read_bool(pdev->dev.parent->of_node, 1715 "rohm,reset-snvs-powered"); 1716 1717 /* 1718 * Change the next stage from poweroff to be READY instead of SNVS 1719 * for all reset types because OTP loading at READY will clear SEL 1720 * bit allowing HW defaults for power rails to be used 1721 */ 1722 if (!use_snvs) { 1723 err = regmap_update_bits(regmap, BD718XX_REG_TRANS_COND1, 1724 BD718XX_ON_REQ_POWEROFF_MASK | 1725 BD718XX_SWRESET_POWEROFF_MASK | 1726 BD718XX_WDOG_POWEROFF_MASK | 1727 BD718XX_KEY_L_POWEROFF_MASK, 1728 BD718XX_POWOFF_TO_RDY); 1729 if (err) 1730 return dev_err_probe(&pdev->dev, err, 1731 "Failed to change reset target\n"); 1732 1733 dev_dbg(&pdev->dev, "Changed all resets from SVNS to READY\n"); 1734 } 1735 1736 config.dev = pdev->dev.parent; 1737 config.regmap = regmap; 1738 /* 1739 * There are cases when we want to leave the enable-control for 1740 * the HW state machine and use this driver only for voltage control. 1741 * One special case is when we use PMIC_STBY_REQ line from SoC to PMIC 1742 * in order to set the system to SUSPEND state. 1743 * 1744 * If regulator is taken under SW control the regulator state will not 1745 * be affected by PMIC state machine - Eg. regulator is likely to stay 1746 * on even in SUSPEND 1747 */ 1748 err = get_special_regulators(pdev->dev.parent, reg_data, num_reg_data, 1749 &omit_enable); 1750 if (err) 1751 return err; 1752 1753 for (i = 0; i < num_reg_data; i++) { 1754 1755 struct regulator_desc *desc; 1756 struct regulator_dev *rdev; 1757 struct bd718xx_regulator_data *r; 1758 int no_enable_control = omit_enable & (1 << i); 1759 1760 r = ®_data[i]; 1761 desc = &r->desc; 1762 1763 if (no_enable_control) 1764 desc->ops = hwops[i]; 1765 else 1766 desc->ops = swops[i]; 1767 1768 rdev = devm_regulator_register(&pdev->dev, desc, &config); 1769 if (IS_ERR(rdev)) 1770 return dev_err_probe(&pdev->dev, PTR_ERR(rdev), 1771 "failed to register %s regulator\n", 1772 desc->name); 1773 1774 /* 1775 * Regulator register gets the regulator constraints and 1776 * applies them (set_machine_constraints). This should have 1777 * turned the control register(s) to correct values and we 1778 * can now switch the control from PMIC state machine to the 1779 * register interface 1780 * 1781 * At poweroff transition PMIC HW disables EN bit for 1782 * regulators but leaves SEL bit untouched. So if state 1783 * transition from POWEROFF is done to SNVS - then all power 1784 * rails controlled by SW (having SEL bit set) stay disabled 1785 * as EN is cleared. This will result boot failure if any 1786 * crucial systems are powered by these rails. We don't 1787 * enable SW control for crucial regulators if snvs state is 1788 * used 1789 */ 1790 if (!no_enable_control && (!use_snvs || 1791 !rdev->constraints->always_on || 1792 !rdev->constraints->boot_on)) { 1793 err = regmap_update_bits(regmap, r->init.reg, 1794 r->init.mask, r->init.val); 1795 if (err) 1796 return dev_err_probe(&pdev->dev, err, 1797 "Failed to take control for (%s)\n", 1798 desc->name); 1799 } 1800 for (j = 0; j < r->additional_init_amnt; j++) { 1801 err = regmap_update_bits(regmap, 1802 r->additional_inits[j].reg, 1803 r->additional_inits[j].mask, 1804 r->additional_inits[j].val); 1805 if (err) 1806 return dev_err_probe(&pdev->dev, err, 1807 "Buck (%s) initialization failed\n", 1808 desc->name); 1809 } 1810 } 1811 1812 return err; 1813 } 1814 1815 static const struct platform_device_id bd718x7_pmic_id[] = { 1816 { "bd71837-pmic", ROHM_CHIP_TYPE_BD71837 }, 1817 { "bd71847-pmic", ROHM_CHIP_TYPE_BD71847 }, 1818 { }, 1819 }; 1820 MODULE_DEVICE_TABLE(platform, bd718x7_pmic_id); 1821 1822 static struct platform_driver bd718xx_regulator = { 1823 .driver = { 1824 .name = "bd718xx-pmic", 1825 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 1826 }, 1827 .probe = bd718xx_probe, 1828 .id_table = bd718x7_pmic_id, 1829 }; 1830 1831 module_platform_driver(bd718xx_regulator); 1832 1833 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>"); 1834 MODULE_DESCRIPTION("BD71837/BD71847 voltage regulator driver"); 1835 MODULE_LICENSE("GPL"); 1836 MODULE_ALIAS("platform:bd718xx-pmic"); 1837