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