1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (C) 2018 ROHM Semiconductors 3 // bd71837-regulator.c ROHM BD71837MWV/BD71847MWV regulator driver 4 5 #include <linux/delay.h> 6 #include <linux/err.h> 7 #include <linux/interrupt.h> 8 #include <linux/kernel.h> 9 #include <linux/mfd/rohm-bd718x7.h> 10 #include <linux/module.h> 11 #include <linux/of.h> 12 #include <linux/platform_device.h> 13 #include <linux/regulator/driver.h> 14 #include <linux/regulator/machine.h> 15 #include <linux/regulator/of_regulator.h> 16 #include <linux/slab.h> 17 18 /* Typical regulator startup times as per data sheet in uS */ 19 #define BD71847_BUCK1_STARTUP_TIME 144 20 #define BD71847_BUCK2_STARTUP_TIME 162 21 #define BD71847_BUCK3_STARTUP_TIME 162 22 #define BD71847_BUCK4_STARTUP_TIME 240 23 #define BD71847_BUCK5_STARTUP_TIME 270 24 #define BD71847_BUCK6_STARTUP_TIME 200 25 #define BD71847_LDO1_STARTUP_TIME 440 26 #define BD71847_LDO2_STARTUP_TIME 370 27 #define BD71847_LDO3_STARTUP_TIME 310 28 #define BD71847_LDO4_STARTUP_TIME 400 29 #define BD71847_LDO5_STARTUP_TIME 530 30 #define BD71847_LDO6_STARTUP_TIME 400 31 32 #define BD71837_BUCK1_STARTUP_TIME 160 33 #define BD71837_BUCK2_STARTUP_TIME 180 34 #define BD71837_BUCK3_STARTUP_TIME 180 35 #define BD71837_BUCK4_STARTUP_TIME 180 36 #define BD71837_BUCK5_STARTUP_TIME 160 37 #define BD71837_BUCK6_STARTUP_TIME 240 38 #define BD71837_BUCK7_STARTUP_TIME 220 39 #define BD71837_BUCK8_STARTUP_TIME 200 40 #define BD71837_LDO1_STARTUP_TIME 440 41 #define BD71837_LDO2_STARTUP_TIME 370 42 #define BD71837_LDO3_STARTUP_TIME 310 43 #define BD71837_LDO4_STARTUP_TIME 400 44 #define BD71837_LDO5_STARTUP_TIME 310 45 #define BD71837_LDO6_STARTUP_TIME 400 46 #define BD71837_LDO7_STARTUP_TIME 530 47 48 /* 49 * BD718(37/47/50) have two "enable control modes". ON/OFF can either be 50 * controlled by software - or by PMIC internal HW state machine. Whether 51 * regulator should be under SW or HW control can be defined from device-tree. 52 * Let's provide separate ops for regulators to use depending on the "enable 53 * control mode". 54 */ 55 #define BD718XX_HWOPNAME(swopname) swopname##_hwcontrol 56 57 #define BD718XX_OPS(name, _list_voltage, _map_voltage, _set_voltage_sel, \ 58 _get_voltage_sel, _set_voltage_time_sel, _set_ramp_delay) \ 59 static 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 \ 71 static 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 */ 89 static 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 */ 132 static int always_enabled_by_hwstate(struct regulator_dev *rdev) 133 { 134 return 1; 135 } 136 137 static int never_enabled_by_hwstate(struct regulator_dev *rdev) 138 { 139 return 0; 140 } 141 142 static 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 */ 166 static 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 175 static 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 205 static 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 258 static 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 274 static 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 290 static 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 */ 302 BD718XX_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 */ 308 static 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 315 BD718XX_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 321 BD718XX_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 325 BD718XX_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 329 BD718XX_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 334 BD718XX_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 */ 342 BD718XX_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 347 BD718XX_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 353 BD718XX_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 357 BD718XX_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 361 BD718XX_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 366 BD718XX_OPS(bd71837_buck_regulator_nolinear_ops, regulator_list_voltage_table, 367 regulator_map_voltage_ascend, bd718xx_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 */ 375 static 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 */ 387 BD718XX_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 */ 397 static 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 */ 408 static 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 */ 423 static const unsigned int bd71837_buck5_volt_range_sel[] = { 424 0x0, 0x0, 0x0, 0x80, 0x80, 0x80 425 }; 426 427 /* 428 * BD71847 BUCK3 429 */ 430 static 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 443 static const unsigned int bd71847_buck3_volt_range_sel[] = { 444 0x0, 0x0, 0x0, 0x40, 0x80, 0x80, 0x80 445 }; 446 447 static 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 452 static const unsigned int bd71847_buck4_volt_range_sel[] = { 0x0, 0x40 }; 453 454 /* 455 * BUCK6 456 * 3.0V to 3.3V (step 100mV) 457 */ 458 static 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 */ 474 static 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 */ 482 static 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 */ 490 static 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 495 static const unsigned int bd718xx_ldo1_volt_range_sel[] = { 0x0, 0x20 }; 496 497 /* 498 * LDO2 499 * 0.8 or 0.9V 500 */ 501 static const unsigned int ldo_2_volts[] = { 502 900000, 800000 503 }; 504 505 /* 506 * LDO3 507 * 1.8 to 3.3V (100mV step) 508 */ 509 static 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 */ 517 static 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 */ 525 static 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 */ 533 static 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 538 static const unsigned int bd71847_ldo5_volt_range_sel[] = { 0x0, 0x20 }; 539 540 /* 541 * LDO6 542 * 0.9 to 1.8V (100mV step) 543 */ 544 static 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 */ 552 static const struct linear_range bd71837_ldo7_volts[] = { 553 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000), 554 }; 555 556 struct reg_init { 557 unsigned int reg; 558 unsigned int mask; 559 unsigned int val; 560 }; 561 struct 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 */ 579 static 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 587 static 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 595 static 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 606 static 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 615 static 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 630 static 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 944 static 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 955 static 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 972 static 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 1366 static 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 1383 /* 1384 * Setups where regulator (especially the buck8) output voltage is scaled 1385 * by adding external connection where some other regulator output is connected 1386 * to feedback-pin (over suitable resistors) is getting popular amongst users 1387 * of BD71837. (This allows for example scaling down the buck8 voltages to suit 1388 * lover GPU voltages for projects where buck8 is (ab)used to supply power 1389 * for GPU. Additionally some setups do allow DVS for buck8 but as this do 1390 * produce voltage spikes the HW must be evaluated to be able to survive this 1391 * - hence I keep the DVS disabled for non DVS bucks by default. I don't want 1392 * to help you burn your proto board) 1393 * 1394 * So we allow describing this external connection from DT and scale the 1395 * voltages accordingly. This is what the connection should look like: 1396 * 1397 * |------------| 1398 * | buck 8 |-------+----->Vout 1399 * | | | 1400 * |------------| | 1401 * | FB pin | 1402 * | | 1403 * +-------+--R2---+ 1404 * | 1405 * R1 1406 * | 1407 * V FB-pull-up 1408 * 1409 * Here the buck output is sifted according to formula: 1410 * 1411 * Vout_o = Vo - (Vpu - Vo)*R2/R1 1412 * Linear_step = step_orig*(R1+R2)/R1 1413 * 1414 * where: 1415 * Vout_o is adjusted voltage output at vsel reg value 0 1416 * Vo is original voltage output at vsel reg value 0 1417 * Vpu is the pull-up voltage V FB-pull-up in the picture 1418 * R1 and R2 are resistor values. 1419 * 1420 * As a real world example for buck8 and a specific GPU: 1421 * VLDO = 1.6V (used as FB-pull-up) 1422 * R1 = 1000ohms 1423 * R2 = 150ohms 1424 * VSEL 0x0 => 0.8V – (VLDO – 0.8) * R2 / R1 = 0.68V 1425 * Linear Step = 10mV * (R1 + R2) / R1 = 11.5mV 1426 */ 1427 static int setup_feedback_loop(struct device *dev, struct device_node *np, 1428 struct bd718xx_regulator_data *reg_data, 1429 unsigned int num_reg_data, int fb_uv) 1430 { 1431 int i, r1, r2, ret; 1432 1433 /* 1434 * We do adjust the values in the global desc based on DT settings. 1435 * This may not be best approach as it can cause problems if more than 1436 * one PMIC is controlled from same processor. I don't see such use-case 1437 * for BD718x7 now - so we spare some bits. 1438 * 1439 * If this will point out to be a problem - then we can allocate new 1440 * bd718xx_regulator_data array at probe and just use the global 1441 * array as a template where we copy initial values. Then we can 1442 * use allocated descs for regultor registration and do IC specific 1443 * modifications to this copy while leaving other PMICs untouched. But 1444 * that means allocating new array for each PMIC - and currently I see 1445 * no need for that. 1446 */ 1447 1448 for (i = 0; i < num_reg_data; i++) { 1449 struct regulator_desc *desc = ®_data[i].desc; 1450 int j; 1451 1452 if (!of_node_name_eq(np, desc->of_match)) 1453 continue; 1454 1455 pr_info("Looking at node '%s'\n", desc->of_match); 1456 1457 /* The feedback loop connection does not make sense for LDOs */ 1458 if (desc->id >= BD718XX_LDO1) 1459 return -EINVAL; 1460 1461 ret = of_property_read_u32(np, "rohm,feedback-pull-up-r1-ohms", 1462 &r1); 1463 if (ret) 1464 return ret; 1465 1466 if (!r1) 1467 return -EINVAL; 1468 1469 ret = of_property_read_u32(np, "rohm,feedback-pull-up-r2-ohms", 1470 &r2); 1471 if (ret) 1472 return ret; 1473 1474 if (desc->n_linear_ranges && desc->linear_ranges) { 1475 struct linear_range *new; 1476 1477 new = devm_kzalloc(dev, desc->n_linear_ranges * 1478 sizeof(struct linear_range), 1479 GFP_KERNEL); 1480 if (!new) 1481 return -ENOMEM; 1482 1483 for (j = 0; j < desc->n_linear_ranges; j++) { 1484 int min = desc->linear_ranges[j].min; 1485 int step = desc->linear_ranges[j].step; 1486 1487 min -= (fb_uv - min)*r2/r1; 1488 step = step * (r1 + r2); 1489 step /= r1; 1490 1491 new[j].min = min; 1492 new[j].step = step; 1493 1494 dev_dbg(dev, "%s: old range min %d, step %d\n", 1495 desc->name, desc->linear_ranges[j].min, 1496 desc->linear_ranges[j].step); 1497 dev_dbg(dev, "new range min %d, step %d\n", min, 1498 step); 1499 } 1500 desc->linear_ranges = new; 1501 } 1502 dev_dbg(dev, "regulator '%s' has FB pull-up configured\n", 1503 desc->name); 1504 1505 return 0; 1506 } 1507 1508 return -ENODEV; 1509 } 1510 1511 static int get_special_regulators(struct device *dev, 1512 struct bd718xx_regulator_data *reg_data, 1513 unsigned int num_reg_data, int *info) 1514 { 1515 int ret; 1516 struct device_node *np; 1517 struct device_node *nproot = dev->of_node; 1518 int uv; 1519 1520 *info = 0; 1521 1522 nproot = of_get_child_by_name(nproot, "regulators"); 1523 if (!nproot) { 1524 dev_err(dev, "failed to find regulators node\n"); 1525 return -ENODEV; 1526 } 1527 for_each_child_of_node(nproot, np) { 1528 if (of_property_read_bool(np, "rohm,no-regulator-enable-control")) 1529 mark_hw_controlled(dev, np, reg_data, num_reg_data, 1530 info); 1531 ret = of_property_read_u32(np, "rohm,fb-pull-up-microvolt", 1532 &uv); 1533 if (ret) { 1534 if (ret == -EINVAL) 1535 continue; 1536 else 1537 goto err_out; 1538 } 1539 1540 ret = setup_feedback_loop(dev, np, reg_data, num_reg_data, uv); 1541 if (ret) 1542 goto err_out; 1543 } 1544 1545 of_node_put(nproot); 1546 return 0; 1547 1548 err_out: 1549 of_node_put(np); 1550 of_node_put(nproot); 1551 1552 return ret; 1553 } 1554 1555 static int bd718xx_probe(struct platform_device *pdev) 1556 { 1557 struct regmap *regmap; 1558 struct regulator_config config = { 0 }; 1559 int i, j, err, omit_enable; 1560 bool use_snvs; 1561 struct bd718xx_regulator_data *reg_data; 1562 unsigned int num_reg_data; 1563 enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data; 1564 const struct regulator_ops **swops, **hwops; 1565 1566 regmap = dev_get_regmap(pdev->dev.parent, NULL); 1567 if (!regmap) { 1568 dev_err(&pdev->dev, "No MFD driver data\n"); 1569 return -EINVAL; 1570 } 1571 1572 switch (chip) { 1573 case ROHM_CHIP_TYPE_BD71837: 1574 reg_data = bd71837_regulators; 1575 num_reg_data = ARRAY_SIZE(bd71837_regulators); 1576 swops = &bd71837_swcontrol_ops[0]; 1577 hwops = &bd71837_hwcontrol_ops[0]; 1578 break; 1579 case ROHM_CHIP_TYPE_BD71847: 1580 reg_data = bd71847_regulators; 1581 num_reg_data = ARRAY_SIZE(bd71847_regulators); 1582 swops = &bd71847_swcontrol_ops[0]; 1583 hwops = &bd71847_hwcontrol_ops[0]; 1584 break; 1585 default: 1586 dev_err(&pdev->dev, "Unsupported chip type\n"); 1587 err = -EINVAL; 1588 goto err; 1589 } 1590 1591 /* Register LOCK release */ 1592 err = regmap_update_bits(regmap, BD718XX_REG_REGLOCK, 1593 (REGLOCK_PWRSEQ | REGLOCK_VREG), 0); 1594 if (err) { 1595 dev_err(&pdev->dev, "Failed to unlock PMIC (%d)\n", err); 1596 goto err; 1597 } else { 1598 dev_dbg(&pdev->dev, "Unlocked lock register 0x%x\n", 1599 BD718XX_REG_REGLOCK); 1600 } 1601 1602 use_snvs = of_property_read_bool(pdev->dev.parent->of_node, 1603 "rohm,reset-snvs-powered"); 1604 1605 /* 1606 * Change the next stage from poweroff to be READY instead of SNVS 1607 * for all reset types because OTP loading at READY will clear SEL 1608 * bit allowing HW defaults for power rails to be used 1609 */ 1610 if (!use_snvs) { 1611 err = regmap_update_bits(regmap, BD718XX_REG_TRANS_COND1, 1612 BD718XX_ON_REQ_POWEROFF_MASK | 1613 BD718XX_SWRESET_POWEROFF_MASK | 1614 BD718XX_WDOG_POWEROFF_MASK | 1615 BD718XX_KEY_L_POWEROFF_MASK, 1616 BD718XX_POWOFF_TO_RDY); 1617 if (err) { 1618 dev_err(&pdev->dev, "Failed to change reset target\n"); 1619 goto err; 1620 } else { 1621 dev_dbg(&pdev->dev, 1622 "Changed all resets from SVNS to READY\n"); 1623 } 1624 } 1625 1626 config.dev = pdev->dev.parent; 1627 config.regmap = regmap; 1628 /* 1629 * There are cases when we want to leave the enable-control for 1630 * the HW state machine and use this driver only for voltage control. 1631 * One special case is when we use PMIC_STBY_REQ line from SoC to PMIC 1632 * in order to set the system to SUSPEND state. 1633 * 1634 * If regulator is taken under SW control the regulator state will not 1635 * be affected by PMIC state machine - Eg. regulator is likely to stay 1636 * on even in SUSPEND 1637 */ 1638 err = get_special_regulators(pdev->dev.parent, reg_data, num_reg_data, 1639 &omit_enable); 1640 if (err) 1641 return err; 1642 1643 for (i = 0; i < num_reg_data; i++) { 1644 1645 struct regulator_desc *desc; 1646 struct regulator_dev *rdev; 1647 struct bd718xx_regulator_data *r; 1648 int no_enable_control = omit_enable & (1 << i); 1649 1650 r = ®_data[i]; 1651 desc = &r->desc; 1652 1653 if (no_enable_control) 1654 desc->ops = hwops[i]; 1655 else 1656 desc->ops = swops[i]; 1657 1658 rdev = devm_regulator_register(&pdev->dev, desc, &config); 1659 if (IS_ERR(rdev)) { 1660 dev_err(&pdev->dev, 1661 "failed to register %s regulator\n", 1662 desc->name); 1663 err = PTR_ERR(rdev); 1664 goto err; 1665 } 1666 1667 /* 1668 * Regulator register gets the regulator constraints and 1669 * applies them (set_machine_constraints). This should have 1670 * turned the control register(s) to correct values and we 1671 * can now switch the control from PMIC state machine to the 1672 * register interface 1673 * 1674 * At poweroff transition PMIC HW disables EN bit for 1675 * regulators but leaves SEL bit untouched. So if state 1676 * transition from POWEROFF is done to SNVS - then all power 1677 * rails controlled by SW (having SEL bit set) stay disabled 1678 * as EN is cleared. This will result boot failure if any 1679 * crucial systems are powered by these rails. We don't 1680 * enable SW control for crucial regulators if snvs state is 1681 * used 1682 */ 1683 if (!no_enable_control && (!use_snvs || 1684 !rdev->constraints->always_on || 1685 !rdev->constraints->boot_on)) { 1686 err = regmap_update_bits(regmap, r->init.reg, 1687 r->init.mask, r->init.val); 1688 if (err) { 1689 dev_err(&pdev->dev, 1690 "Failed to take control for (%s)\n", 1691 desc->name); 1692 goto err; 1693 } 1694 } 1695 for (j = 0; j < r->additional_init_amnt; j++) { 1696 err = regmap_update_bits(regmap, 1697 r->additional_inits[j].reg, 1698 r->additional_inits[j].mask, 1699 r->additional_inits[j].val); 1700 if (err) { 1701 dev_err(&pdev->dev, 1702 "Buck (%s) initialization failed\n", 1703 desc->name); 1704 goto err; 1705 } 1706 } 1707 } 1708 1709 err: 1710 return err; 1711 } 1712 1713 static const struct platform_device_id bd718x7_pmic_id[] = { 1714 { "bd71837-pmic", ROHM_CHIP_TYPE_BD71837 }, 1715 { "bd71847-pmic", ROHM_CHIP_TYPE_BD71847 }, 1716 { }, 1717 }; 1718 MODULE_DEVICE_TABLE(platform, bd718x7_pmic_id); 1719 1720 static struct platform_driver bd718xx_regulator = { 1721 .driver = { 1722 .name = "bd718xx-pmic", 1723 }, 1724 .probe = bd718xx_probe, 1725 .id_table = bd718x7_pmic_id, 1726 }; 1727 1728 module_platform_driver(bd718xx_regulator); 1729 1730 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>"); 1731 MODULE_DESCRIPTION("BD71837/BD71847 voltage regulator driver"); 1732 MODULE_LICENSE("GPL"); 1733 MODULE_ALIAS("platform:bd718xx-pmic"); 1734