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