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