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