]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame - drivers/regulator/bd718x7-regulator.c
projects / mirror_ubuntu-jammy-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'sound-5.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai...
[mirror_ubuntu-jammy-kernel.git] / drivers / regulator / bd718x7-regulator.c
CommitLineData
ba08799e
MV		 1// SPDX-License-Identifier: GPL-2.0
2// Copyright (C) 2018 ROHM Semiconductors
dd2be639 3// bd71837-regulator.c ROHM BD71837MWV/BD71847MWV regulator driver
ba08799e 4
c9dc4cfa 5#include <linux/delay.h>
ba08799e
MV		 6#include <linux/err.h>
7#include <linux/interrupt.h>
c9dc4cfa 8#include <linux/kernel.h>
410e8b4f 9#include <linux/mfd/rohm-bd718x7.h>
c9dc4cfa 10#include <linux/module.h>
9cce7244 11#include <linux/of.h>
ba08799e
MV		 12#include <linux/platform_device.h>
13#include <linux/regulator/driver.h>
14#include <linux/regulator/machine.h>
ba08799e 15#include <linux/regulator/of_regulator.h>
c9dc4cfa 16#include <linux/slab.h>
ba08799e 17
ba08799e
MV		 18/*
19 * BUCK1/2/3/4
20 * BUCK1RAMPRATE[1:0] BUCK1 DVS ramp rate setting
21 * 00: 10.00mV/usec 10mV 1uS
22 * 01: 5.00mV/usec 10mV 2uS
23 * 10: 2.50mV/usec 10mV 4uS
24 * 11: 1.25mV/usec 10mV 8uS
25 */
dd2be639 26static int bd718xx_buck1234_set_ramp_delay(struct regulator_dev *rdev,
ba08799e
MV		 27 int ramp_delay)
28{
0a245f0e
AL		 29 int id = rdev_get_id(rdev);
30 unsigned int ramp_value;
ba08799e 31
bcb047eb 32 dev_dbg(&rdev->dev, "Buck[%d] Set Ramp = %d\n", id + 1,
ba08799e
MV		 33 ramp_delay);
34 switch (ramp_delay) {
35 case 1 ... 1250:
36 ramp_value = BUCK_RAMPRATE_1P25MV;
37 break;
38 case 1251 ... 2500:
39 ramp_value = BUCK_RAMPRATE_2P50MV;
40 break;
41 case 2501 ... 5000:
42 ramp_value = BUCK_RAMPRATE_5P00MV;
43 break;
44 case 5001 ... 10000:
45 ramp_value = BUCK_RAMPRATE_10P00MV;
46 break;
47 default:
48 ramp_value = BUCK_RAMPRATE_10P00MV;
bcb047eb 49 dev_err(&rdev->dev,
ba08799e
MV		 50 "%s: ramp_delay: %d not supported, setting 10000mV//us\n",
51 rdev->desc->name, ramp_delay);
52 }
53
bcb047eb 54 return regmap_update_bits(rdev->regmap, BD718XX_REG_BUCK1_CTRL + id,
ba08799e
MV		 55 BUCK_RAMPRATE_MASK, ramp_value << 6);
56}
57
58/* Bucks 1 to 4 support DVS. PWM mode is used when voltage is changed.
59 * Bucks 5 to 8 and LDOs can use PFM and must be disabled when voltage
60 * is changed. Hence we return -EBUSY for these if voltage is changed
61 * when BUCK/LDO is enabled.
62 */
494edd26 63static int bd718xx_set_voltage_sel_restricted(struct regulator_dev *rdev,
ba08799e
MV		 64 unsigned int sel)
65{
ffdc4984
AL		 66 if (regulator_is_enabled_regmap(rdev))
67 return -EBUSY;
ba08799e 68
ffdc4984 69 return regulator_set_voltage_sel_regmap(rdev, sel);
ba08799e
MV		 70}
71
a4bfc2c2
MV		 72static int bd718xx_set_voltage_sel_pickable_restricted(
73 struct regulator_dev *rdev, unsigned int sel)
74{
75 if (regulator_is_enabled_regmap(rdev))
76 return -EBUSY;
77
78 return regulator_set_voltage_sel_pickable_regmap(rdev, sel);
79}
80
704c5c01 81static const struct regulator_ops bd718xx_pickable_range_ldo_ops = {
a4bfc2c2
MV		 82 .enable = regulator_enable_regmap,
83 .disable = regulator_disable_regmap,
84 .is_enabled = regulator_is_enabled_regmap,
85 .list_voltage = regulator_list_voltage_pickable_linear_range,
86 .set_voltage_sel = bd718xx_set_voltage_sel_pickable_restricted,
87 .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
88};
89
704c5c01 90static const struct regulator_ops bd718xx_pickable_range_buck_ops = {
a4bfc2c2
MV		 91 .enable = regulator_enable_regmap,
92 .disable = regulator_disable_regmap,
93 .is_enabled = regulator_is_enabled_regmap,
94 .list_voltage = regulator_list_voltage_pickable_linear_range,
95 .set_voltage_sel = bd718xx_set_voltage_sel_pickable_restricted,
96 .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
97 .set_voltage_time_sel = regulator_set_voltage_time_sel,
98};
99
704c5c01 100static const struct regulator_ops bd718xx_ldo_regulator_ops = {
ba08799e
MV		 101 .enable = regulator_enable_regmap,
102 .disable = regulator_disable_regmap,
103 .is_enabled = regulator_is_enabled_regmap,
104 .list_voltage = regulator_list_voltage_linear_range,
494edd26 105 .set_voltage_sel = bd718xx_set_voltage_sel_restricted,
ba08799e
MV		 106 .get_voltage_sel = regulator_get_voltage_sel_regmap,
107};
108
704c5c01 109static const struct regulator_ops bd718xx_ldo_regulator_nolinear_ops = {
ba08799e
MV		 110 .enable = regulator_enable_regmap,
111 .disable = regulator_disable_regmap,
112 .is_enabled = regulator_is_enabled_regmap,
113 .list_voltage = regulator_list_voltage_table,
494edd26 114 .set_voltage_sel = bd718xx_set_voltage_sel_restricted,
ba08799e
MV		 115 .get_voltage_sel = regulator_get_voltage_sel_regmap,
116};
117
704c5c01 118static const struct regulator_ops bd718xx_buck_regulator_ops = {
ba08799e
MV		 119 .enable = regulator_enable_regmap,
120 .disable = regulator_disable_regmap,
121 .is_enabled = regulator_is_enabled_regmap,
122 .list_voltage = regulator_list_voltage_linear_range,
494edd26 123 .set_voltage_sel = bd718xx_set_voltage_sel_restricted,
ba08799e
MV		 124 .get_voltage_sel = regulator_get_voltage_sel_regmap,
125 .set_voltage_time_sel = regulator_set_voltage_time_sel,
126};
127
704c5c01 128static const struct regulator_ops bd718xx_buck_regulator_nolinear_ops = {
ba08799e
MV		 129 .enable = regulator_enable_regmap,
130 .disable = regulator_disable_regmap,
131 .is_enabled = regulator_is_enabled_regmap,
132 .list_voltage = regulator_list_voltage_table,
2e61286d 133 .map_voltage = regulator_map_voltage_ascend,
494edd26 134 .set_voltage_sel = bd718xx_set_voltage_sel_restricted,
ba08799e
MV		 135 .get_voltage_sel = regulator_get_voltage_sel_regmap,
136 .set_voltage_time_sel = regulator_set_voltage_time_sel,
137};
138
704c5c01 139static const struct regulator_ops bd718xx_dvs_buck_regulator_ops = {
ba08799e
MV		 140 .enable = regulator_enable_regmap,
141 .disable = regulator_disable_regmap,
142 .is_enabled = regulator_is_enabled_regmap,
143 .list_voltage = regulator_list_voltage_linear_range,
144 .set_voltage_sel = regulator_set_voltage_sel_regmap,
145 .get_voltage_sel = regulator_get_voltage_sel_regmap,
146 .set_voltage_time_sel = regulator_set_voltage_time_sel,
dd2be639 147 .set_ramp_delay = bd718xx_buck1234_set_ramp_delay,
ba08799e
MV		 148};
149
150/*
494edd26
MV		 151 * BD71837 BUCK1/2/3/4
152 * BD71847 BUCK1/2
ba08799e
MV		 153 * 0.70 to 1.30V (10mV step)
154 */
494edd26 155static const struct regulator_linear_range bd718xx_dvs_buck_volts[] = {
ba08799e
MV		 156 REGULATOR_LINEAR_RANGE(700000, 0x00, 0x3C, 10000),
157 REGULATOR_LINEAR_RANGE(1300000, 0x3D, 0x3F, 0),
158};
159
160/*
494edd26 161 * BD71837 BUCK5
a4bfc2c2
MV		 162 * 0.7V to 1.35V (range 0)
163 * and
164 * 0.675 to 1.325 (range 1)
165 */
166static const struct regulator_linear_range bd71837_buck5_volts[] = {
167 /* Ranges when VOLT_SEL bit is 0 */
168 REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000),
169 REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000),
170 REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000),
171 /* Ranges when VOLT_SEL bit is 1 */
172 REGULATOR_LINEAR_RANGE(675000, 0x0, 0x3, 100000),
173 REGULATOR_LINEAR_RANGE(1025000, 0x4, 0x5, 50000),
174 REGULATOR_LINEAR_RANGE(1175000, 0x6, 0x7, 150000),
175};
176
177/*
178 * Range selector for first 3 linear ranges is 0x0
179 * and 0x1 for last 3 ranges.
180 */
181static const unsigned int bd71837_buck5_volt_range_sel[] = {
182 0x0, 0x0, 0x0, 0x80, 0x80, 0x80
183};
184
185/*
494edd26 186 * BD71847 BUCK3
ba08799e 187 */
a4bfc2c2
MV		 188static const struct regulator_linear_range bd71847_buck3_volts[] = {
189 /* Ranges when VOLT_SEL bits are 00 */
ba08799e
MV		 190 REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000),
191 REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000),
192 REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000),
a4bfc2c2
MV		 193 /* Ranges when VOLT_SEL bits are 01 */
194 REGULATOR_LINEAR_RANGE(550000, 0x0, 0x7, 50000),
195 /* Ranges when VOLT_SEL bits are 11 */
196 REGULATOR_LINEAR_RANGE(675000, 0x0, 0x3, 100000),
197 REGULATOR_LINEAR_RANGE(1025000, 0x4, 0x5, 50000),
198 REGULATOR_LINEAR_RANGE(1175000, 0x6, 0x7, 150000),
199};
200
201static const unsigned int bd71847_buck3_volt_range_sel[] = {
202 0x0, 0x0, 0x0, 0x40, 0x80, 0x80, 0x80
ba08799e
MV		 203};
204
a4bfc2c2 205static const struct regulator_linear_range bd71847_buck4_volts[] = {
494edd26 206 REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
a4bfc2c2 207 REGULATOR_LINEAR_RANGE(2600000, 0x00, 0x03, 100000),
494edd26
MV		 208};
209
a4bfc2c2
MV		 210static const unsigned int bd71847_buck4_volt_range_sel[] = { 0x0, 0x40 };
211
ba08799e
MV		 212/*
213 * BUCK6
214 * 3.0V to 3.3V (step 100mV)
215 */
a4bfc2c2 216static const struct regulator_linear_range bd71837_buck6_volts[] = {
ba08799e
MV		 217 REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
218};
219
220/*
494edd26
MV		 221 * BD71837 BUCK7
222 * BD71847 BUCK5
ba08799e
MV		 223 * 000 = 1.605V
224 * 001 = 1.695V
225 * 010 = 1.755V
226 * 011 = 1.8V (Initial)
227 * 100 = 1.845V
228 * 101 = 1.905V
229 * 110 = 1.95V
230 * 111 = 1.995V
231 */
494edd26 232static const unsigned int bd718xx_3rd_nodvs_buck_volts[] = {
ba08799e
MV		 233 1605000, 1695000, 1755000, 1800000, 1845000, 1905000, 1950000, 1995000
234};
235
236/*
237 * BUCK8
238 * 0.8V to 1.40V (step 10mV)
239 */
494edd26 240static const struct regulator_linear_range bd718xx_4th_nodvs_buck_volts[] = {
ba08799e 241 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x3C, 10000),
ba08799e
MV		 242};
243
244/*
245 * LDO1
246 * 3.0 to 3.3V (100mV step)
247 */
494edd26 248static const struct regulator_linear_range bd718xx_ldo1_volts[] = {
ba08799e 249 REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
a4bfc2c2 250 REGULATOR_LINEAR_RANGE(1600000, 0x00, 0x03, 100000),
ba08799e
MV		 251};
252
a4bfc2c2
MV		 253static const unsigned int bd718xx_ldo1_volt_range_sel[] = { 0x0, 0x20 };
254
ba08799e
MV		 255/*
256 * LDO2
257 * 0.8 or 0.9V
258 */
adb78a8e 259static const unsigned int ldo_2_volts[] = {
ba08799e
MV		 260 900000, 800000
261};
262
263/*
264 * LDO3
265 * 1.8 to 3.3V (100mV step)
266 */
494edd26 267static const struct regulator_linear_range bd718xx_ldo3_volts[] = {
ba08799e
MV		 268 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
269};
270
271/*
272 * LDO4
273 * 0.9 to 1.8V (100mV step)
274 */
494edd26 275static const struct regulator_linear_range bd718xx_ldo4_volts[] = {
ba08799e 276 REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000),
ba08799e
MV		 277};
278
279/*
494edd26 280 * LDO5 for BD71837
ba08799e
MV		 281 * 1.8 to 3.3V (100mV step)
282 */
a4bfc2c2 283static const struct regulator_linear_range bd71837_ldo5_volts[] = {
ba08799e
MV		 284 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
285};
286
a4bfc2c2
MV		 287/*
288 * LDO5 for BD71837
289 * 1.8 to 3.3V (100mV step)
290 */
291static const struct regulator_linear_range bd71847_ldo5_volts[] = {
292 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
293 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x0F, 100000),
294};
295
296static const unsigned int bd71847_ldo5_volt_range_sel[] = { 0x0, 0x20 };
297
ba08799e
MV		 298/*
299 * LDO6
300 * 0.9 to 1.8V (100mV step)
301 */
494edd26 302static const struct regulator_linear_range bd718xx_ldo6_volts[] = {
ba08799e 303 REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000),
ba08799e
MV		 304};
305
306/*
307 * LDO7
308 * 1.8 to 3.3V (100mV step)
309 */
494edd26 310static const struct regulator_linear_range bd71837_ldo7_volts[] = {
ba08799e
MV		 311 REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
312};
313
494edd26
MV		 314struct reg_init {
315 unsigned int reg;
316 unsigned int mask;
317 unsigned int val;
318};
319struct bd718xx_regulator_data {
320 struct regulator_desc desc;
21b72156 321 const struct rohm_dvs_config dvs;
494edd26
MV		 322 const struct reg_init init;
323 const struct reg_init *additional_inits;
324 int additional_init_amnt;
325};
326
327/*
328 * There is a HW quirk in BD71837. The shutdown sequence timings for
329 * bucks/LDOs which are controlled via register interface are changed.
330 * At PMIC poweroff the voltage for BUCK6/7 is cut immediately at the
331 * beginning of shut-down sequence. As bucks 6 and 7 are parent
332 * supplies for LDO5 and LDO6 - this causes LDO5/6 voltage
333 * monitoring to errorneously detect under voltage and force PMIC to
334 * emergency state instead of poweroff. In order to avoid this we
335 * disable voltage monitoring for LDO5 and LDO6
336 */
337static const struct reg_init bd71837_ldo5_inits[] = {
338 {
339 .reg = BD718XX_REG_MVRFLTMASK2,
340 .mask = BD718XX_LDO5_VRMON80,
341 .val = BD718XX_LDO5_VRMON80,
342 },
343};
344
345static const struct reg_init bd71837_ldo6_inits[] = {
346 {
347 .reg = BD718XX_REG_MVRFLTMASK2,
348 .mask = BD718XX_LDO6_VRMON80,
349 .val = BD718XX_LDO6_VRMON80,
350 },
351};
352
21b72156 353static int buck_set_hw_dvs_levels(struct device_node *np,
049369d4
MV		 354 const struct regulator_desc *desc,
355 struct regulator_config *cfg)
356{
21b72156 357 struct bd718xx_regulator_data *data;
049369d4 358
21b72156 359 data = container_of(desc, struct bd718xx_regulator_data, desc);
049369d4 360
21b72156 361 return rohm_regulator_set_dvs_levels(&data->dvs, np, desc, cfg->regmap);
049369d4
MV		 362}
363
494edd26
MV		 364static const struct bd718xx_regulator_data bd71847_regulators[] = {
365 {
366 .desc = {
367 .name = "buck1",
368 .of_match = of_match_ptr("BUCK1"),
369 .regulators_node = of_match_ptr("regulators"),
370 .id = BD718XX_BUCK1,
371 .ops = &bd718xx_dvs_buck_regulator_ops,
372 .type = REGULATOR_VOLTAGE,
373 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
374 .linear_ranges = bd718xx_dvs_buck_volts,
375 .n_linear_ranges =
376 ARRAY_SIZE(bd718xx_dvs_buck_volts),
377 .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN,
378 .vsel_mask = DVS_BUCK_RUN_MASK,
379 .enable_reg = BD718XX_REG_BUCK1_CTRL,
380 .enable_mask = BD718XX_BUCK_EN,
381 .owner = THIS_MODULE,
21b72156
MV		 382 .of_parse_cb = buck_set_hw_dvs_levels,
383 },
384 .dvs = {
385 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
386 ROHM_DVS_LEVEL_SUSPEND,
387 .run_reg = BD718XX_REG_BUCK1_VOLT_RUN,
388 .run_mask = DVS_BUCK_RUN_MASK,
389 .idle_reg = BD718XX_REG_BUCK1_VOLT_IDLE,
390 .idle_mask = DVS_BUCK_RUN_MASK,
391 .suspend_reg = BD718XX_REG_BUCK1_VOLT_SUSP,
392 .suspend_mask = DVS_BUCK_RUN_MASK,
494edd26
MV		 393 },
394 .init = {
395 .reg = BD718XX_REG_BUCK1_CTRL,
396 .mask = BD718XX_BUCK_SEL,
397 .val = BD718XX_BUCK_SEL,
398 },
399 },
ba08799e 400 {
494edd26
MV		 401 .desc = {
402 .name = "buck2",
403 .of_match = of_match_ptr("BUCK2"),
404 .regulators_node = of_match_ptr("regulators"),
405 .id = BD718XX_BUCK2,
406 .ops = &bd718xx_dvs_buck_regulator_ops,
407 .type = REGULATOR_VOLTAGE,
408 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
409 .linear_ranges = bd718xx_dvs_buck_volts,
410 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
411 .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN,
412 .vsel_mask = DVS_BUCK_RUN_MASK,
413 .enable_reg = BD718XX_REG_BUCK2_CTRL,
414 .enable_mask = BD718XX_BUCK_EN,
415 .owner = THIS_MODULE,
21b72156
MV		 416 .of_parse_cb = buck_set_hw_dvs_levels,
417 },
418 .dvs = {
419 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE,
420 .run_reg = BD718XX_REG_BUCK2_VOLT_RUN,
421 .run_mask = DVS_BUCK_RUN_MASK,
422 .idle_reg = BD718XX_REG_BUCK2_VOLT_IDLE,
423 .idle_mask = DVS_BUCK_RUN_MASK,
494edd26
MV		 424 },
425 .init = {
426 .reg = BD718XX_REG_BUCK2_CTRL,
427 .mask = BD718XX_BUCK_SEL,
428 .val = BD718XX_BUCK_SEL,
429 },
ba08799e
MV		 430 },
431 {
494edd26
MV		 432 .desc = {
433 .name = "buck3",
434 .of_match = of_match_ptr("BUCK3"),
435 .regulators_node = of_match_ptr("regulators"),
436 .id = BD718XX_BUCK3,
a4bfc2c2 437 .ops = &bd718xx_pickable_range_buck_ops,
494edd26 438 .type = REGULATOR_VOLTAGE,
a4bfc2c2
MV		 439 .n_voltages = BD71847_BUCK3_VOLTAGE_NUM,
440 .linear_ranges = bd71847_buck3_volts,
494edd26 441 .n_linear_ranges =
a4bfc2c2 442 ARRAY_SIZE(bd71847_buck3_volts),
494edd26
MV		 443 .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
444 .vsel_mask = BD718XX_1ST_NODVS_BUCK_MASK,
a4bfc2c2
MV		 445 .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
446 .vsel_range_mask = BD71847_BUCK3_RANGE_MASK,
447 .linear_range_selectors = bd71847_buck3_volt_range_sel,
494edd26
MV		 448 .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
449 .enable_mask = BD718XX_BUCK_EN,
450 .owner = THIS_MODULE,
451 },
452 .init = {
453 .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
454 .mask = BD718XX_BUCK_SEL,
455 .val = BD718XX_BUCK_SEL,
456 },
ba08799e
MV		 457 },
458 {
494edd26
MV		 459 .desc = {
460 .name = "buck4",
461 .of_match = of_match_ptr("BUCK4"),
462 .regulators_node = of_match_ptr("regulators"),
463 .id = BD718XX_BUCK4,
a4bfc2c2 464 .ops = &bd718xx_pickable_range_buck_ops,
494edd26
MV		 465 .type = REGULATOR_VOLTAGE,
466 .n_voltages = BD71847_BUCK4_VOLTAGE_NUM,
a4bfc2c2 467 .linear_ranges = bd71847_buck4_volts,
494edd26 468 .n_linear_ranges =
a4bfc2c2 469 ARRAY_SIZE(bd71847_buck4_volts),
494edd26
MV		 470 .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
471 .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
472 .vsel_mask = BD71847_BUCK4_MASK,
a4bfc2c2
MV		 473 .vsel_range_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
474 .vsel_range_mask = BD71847_BUCK4_RANGE_MASK,
475 .linear_range_selectors = bd71847_buck4_volt_range_sel,
494edd26
MV		 476 .enable_mask = BD718XX_BUCK_EN,
477 .owner = THIS_MODULE,
478 },
479 .init = {
480 .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
481 .mask = BD718XX_BUCK_SEL,
482 .val = BD718XX_BUCK_SEL,
483 },
ba08799e
MV		 484 },
485 {
494edd26
MV		 486 .desc = {
487 .name = "buck5",
488 .of_match = of_match_ptr("BUCK5"),
dd2be639 489 .regulators_node = of_match_ptr("regulators"),
494edd26
MV		 490 .id = BD718XX_BUCK5,
491 .ops = &bd718xx_buck_regulator_nolinear_ops,
492 .type = REGULATOR_VOLTAGE,
493 .volt_table = &bd718xx_3rd_nodvs_buck_volts[0],
494 .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts),
495 .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT,
496 .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK,
497 .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
498 .enable_mask = BD718XX_BUCK_EN,
499 .owner = THIS_MODULE,
500 },
501 .init = {
502 .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
503 .mask = BD718XX_BUCK_SEL,
504 .val = BD718XX_BUCK_SEL,
505 },
ba08799e
MV		 506 },
507 {
494edd26
MV		 508 .desc = {
509 .name = "buck6",
510 .of_match = of_match_ptr("BUCK6"),
511 .regulators_node = of_match_ptr("regulators"),
512 .id = BD718XX_BUCK6,
513 .ops = &bd718xx_buck_regulator_ops,
514 .type = REGULATOR_VOLTAGE,
dd2be639 515 .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM,
494edd26
MV		 516 .linear_ranges = bd718xx_4th_nodvs_buck_volts,
517 .n_linear_ranges =
518 ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts),
519 .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT,
520 .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK,
521 .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
522 .enable_mask = BD718XX_BUCK_EN,
523 .owner = THIS_MODULE,
524 },
525 .init = {
526 .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
527 .mask = BD718XX_BUCK_SEL,
528 .val = BD718XX_BUCK_SEL,
529 },
ba08799e
MV		 530 },
531 {
494edd26
MV		 532 .desc = {
533 .name = "ldo1",
534 .of_match = of_match_ptr("LDO1"),
535 .regulators_node = of_match_ptr("regulators"),
536 .id = BD718XX_LDO1,
a4bfc2c2 537 .ops = &bd718xx_pickable_range_ldo_ops,
494edd26
MV		 538 .type = REGULATOR_VOLTAGE,
539 .n_voltages = BD718XX_LDO1_VOLTAGE_NUM,
540 .linear_ranges = bd718xx_ldo1_volts,
541 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts),
542 .vsel_reg = BD718XX_REG_LDO1_VOLT,
543 .vsel_mask = BD718XX_LDO1_MASK,
a4bfc2c2
MV		 544 .vsel_range_reg = BD718XX_REG_LDO1_VOLT,
545 .vsel_range_mask = BD718XX_LDO1_RANGE_MASK,
546 .linear_range_selectors = bd718xx_ldo1_volt_range_sel,
494edd26
MV		 547 .enable_reg = BD718XX_REG_LDO1_VOLT,
548 .enable_mask = BD718XX_LDO_EN,
549 .owner = THIS_MODULE,
550 },
551 .init = {
552 .reg = BD718XX_REG_LDO1_VOLT,
553 .mask = BD718XX_LDO_SEL,
554 .val = BD718XX_LDO_SEL,
555 },
ba08799e
MV		 556 },
557 {
494edd26
MV		 558 .desc = {
559 .name = "ldo2",
560 .of_match = of_match_ptr("LDO2"),
561 .regulators_node = of_match_ptr("regulators"),
562 .id = BD718XX_LDO2,
563 .ops = &bd718xx_ldo_regulator_nolinear_ops,
564 .type = REGULATOR_VOLTAGE,
565 .volt_table = &ldo_2_volts[0],
566 .vsel_reg = BD718XX_REG_LDO2_VOLT,
567 .vsel_mask = BD718XX_LDO2_MASK,
568 .n_voltages = ARRAY_SIZE(ldo_2_volts),
569 .enable_reg = BD718XX_REG_LDO2_VOLT,
570 .enable_mask = BD718XX_LDO_EN,
571 .owner = THIS_MODULE,
572 },
573 .init = {
574 .reg = BD718XX_REG_LDO2_VOLT,
575 .mask = BD718XX_LDO_SEL,
576 .val = BD718XX_LDO_SEL,
577 },
ba08799e
MV		 578 },
579 {
494edd26
MV		 580 .desc = {
581 .name = "ldo3",
582 .of_match = of_match_ptr("LDO3"),
583 .regulators_node = of_match_ptr("regulators"),
584 .id = BD718XX_LDO3,
585 .ops = &bd718xx_ldo_regulator_ops,
586 .type = REGULATOR_VOLTAGE,
587 .n_voltages = BD718XX_LDO3_VOLTAGE_NUM,
588 .linear_ranges = bd718xx_ldo3_volts,
589 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts),
590 .vsel_reg = BD718XX_REG_LDO3_VOLT,
591 .vsel_mask = BD718XX_LDO3_MASK,
592 .enable_reg = BD718XX_REG_LDO3_VOLT,
593 .enable_mask = BD718XX_LDO_EN,
594 .owner = THIS_MODULE,
595 },
596 .init = {
597 .reg = BD718XX_REG_LDO3_VOLT,
598 .mask = BD718XX_LDO_SEL,
599 .val = BD718XX_LDO_SEL,
600 },
ba08799e
MV		 601 },
602 {
494edd26
MV		 603 .desc = {
604 .name = "ldo4",
605 .of_match = of_match_ptr("LDO4"),
606 .regulators_node = of_match_ptr("regulators"),
607 .id = BD718XX_LDO4,
608 .ops = &bd718xx_ldo_regulator_ops,
609 .type = REGULATOR_VOLTAGE,
610 .n_voltages = BD718XX_LDO4_VOLTAGE_NUM,
611 .linear_ranges = bd718xx_ldo4_volts,
612 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts),
613 .vsel_reg = BD718XX_REG_LDO4_VOLT,
614 .vsel_mask = BD718XX_LDO4_MASK,
615 .enable_reg = BD718XX_REG_LDO4_VOLT,
616 .enable_mask = BD718XX_LDO_EN,
617 .owner = THIS_MODULE,
618 },
619 .init = {
620 .reg = BD718XX_REG_LDO4_VOLT,
621 .mask = BD718XX_LDO_SEL,
622 .val = BD718XX_LDO_SEL,
623 },
ba08799e
MV		 624 },
625 {
494edd26
MV		 626 .desc = {
627 .name = "ldo5",
628 .of_match = of_match_ptr("LDO5"),
629 .regulators_node = of_match_ptr("regulators"),
630 .id = BD718XX_LDO5,
a4bfc2c2 631 .ops = &bd718xx_pickable_range_ldo_ops,
494edd26 632 .type = REGULATOR_VOLTAGE,
a4bfc2c2
MV		 633 .n_voltages = BD71847_LDO5_VOLTAGE_NUM,
634 .linear_ranges = bd71847_ldo5_volts,
635 .n_linear_ranges = ARRAY_SIZE(bd71847_ldo5_volts),
494edd26
MV		 636 .vsel_reg = BD718XX_REG_LDO5_VOLT,
637 .vsel_mask = BD71847_LDO5_MASK,
a4bfc2c2
MV		 638 .vsel_range_reg = BD718XX_REG_LDO5_VOLT,
639 .vsel_range_mask = BD71847_LDO5_RANGE_MASK,
640 .linear_range_selectors = bd71847_ldo5_volt_range_sel,
494edd26
MV		 641 .enable_reg = BD718XX_REG_LDO5_VOLT,
642 .enable_mask = BD718XX_LDO_EN,
643 .owner = THIS_MODULE,
644 },
645 .init = {
646 .reg = BD718XX_REG_LDO5_VOLT,
647 .mask = BD718XX_LDO_SEL,
648 .val = BD718XX_LDO_SEL,
649 },
ba08799e
MV		 650 },
651 {
494edd26
MV		 652 .desc = {
653 .name = "ldo6",
654 .of_match = of_match_ptr("LDO6"),
655 .regulators_node = of_match_ptr("regulators"),
656 .id = BD718XX_LDO6,
657 .ops = &bd718xx_ldo_regulator_ops,
658 .type = REGULATOR_VOLTAGE,
659 .n_voltages = BD718XX_LDO6_VOLTAGE_NUM,
660 .linear_ranges = bd718xx_ldo6_volts,
661 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts),
662 /* LDO6 is supplied by buck5 */
663 .supply_name = "buck5",
664 .vsel_reg = BD718XX_REG_LDO6_VOLT,
665 .vsel_mask = BD718XX_LDO6_MASK,
666 .enable_reg = BD718XX_REG_LDO6_VOLT,
667 .enable_mask = BD718XX_LDO_EN,
668 .owner = THIS_MODULE,
669 },
670 .init = {
671 .reg = BD718XX_REG_LDO6_VOLT,
672 .mask = BD718XX_LDO_SEL,
673 .val = BD718XX_LDO_SEL,
674 },
675 },
676};
677
678static const struct bd718xx_regulator_data bd71837_regulators[] = {
679 {
680 .desc = {
681 .name = "buck1",
682 .of_match = of_match_ptr("BUCK1"),
683 .regulators_node = of_match_ptr("regulators"),
684 .id = BD718XX_BUCK1,
685 .ops = &bd718xx_dvs_buck_regulator_ops,
686 .type = REGULATOR_VOLTAGE,
687 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
688 .linear_ranges = bd718xx_dvs_buck_volts,
689 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
690 .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN,
691 .vsel_mask = DVS_BUCK_RUN_MASK,
692 .enable_reg = BD718XX_REG_BUCK1_CTRL,
693 .enable_mask = BD718XX_BUCK_EN,
694 .owner = THIS_MODULE,
21b72156
MV		 695 .of_parse_cb = buck_set_hw_dvs_levels,
696 },
697 .dvs = {
698 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
699 ROHM_DVS_LEVEL_SUSPEND,
700 .run_reg = BD718XX_REG_BUCK1_VOLT_RUN,
701 .run_mask = DVS_BUCK_RUN_MASK,
702 .idle_reg = BD718XX_REG_BUCK1_VOLT_IDLE,
703 .idle_mask = DVS_BUCK_RUN_MASK,
704 .suspend_reg = BD718XX_REG_BUCK1_VOLT_SUSP,
705 .suspend_mask = DVS_BUCK_RUN_MASK,
494edd26
MV		 706 },
707 .init = {
708 .reg = BD718XX_REG_BUCK1_CTRL,
709 .mask = BD718XX_BUCK_SEL,
710 .val = BD718XX_BUCK_SEL,
711 },
712 },
713 {
714 .desc = {
715 .name = "buck2",
716 .of_match = of_match_ptr("BUCK2"),
717 .regulators_node = of_match_ptr("regulators"),
718 .id = BD718XX_BUCK2,
719 .ops = &bd718xx_dvs_buck_regulator_ops,
720 .type = REGULATOR_VOLTAGE,
721 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
722 .linear_ranges = bd718xx_dvs_buck_volts,
723 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
724 .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN,
725 .vsel_mask = DVS_BUCK_RUN_MASK,
726 .enable_reg = BD718XX_REG_BUCK2_CTRL,
727 .enable_mask = BD718XX_BUCK_EN,
728 .owner = THIS_MODULE,
21b72156
MV		 729 .of_parse_cb = buck_set_hw_dvs_levels,
730 },
731 .dvs = {
732 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE,
733 .run_reg = BD718XX_REG_BUCK2_VOLT_RUN,
734 .run_mask = DVS_BUCK_RUN_MASK,
735 .idle_reg = BD718XX_REG_BUCK2_VOLT_IDLE,
736 .idle_mask = DVS_BUCK_RUN_MASK,
494edd26
MV		 737 },
738 .init = {
739 .reg = BD718XX_REG_BUCK2_CTRL,
740 .mask = BD718XX_BUCK_SEL,
741 .val = BD718XX_BUCK_SEL,
742 },
743 },
744 {
745 .desc = {
746 .name = "buck3",
747 .of_match = of_match_ptr("BUCK3"),
748 .regulators_node = of_match_ptr("regulators"),
749 .id = BD718XX_BUCK3,
750 .ops = &bd718xx_dvs_buck_regulator_ops,
751 .type = REGULATOR_VOLTAGE,
752 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
753 .linear_ranges = bd718xx_dvs_buck_volts,
754 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
755 .vsel_reg = BD71837_REG_BUCK3_VOLT_RUN,
756 .vsel_mask = DVS_BUCK_RUN_MASK,
757 .enable_reg = BD71837_REG_BUCK3_CTRL,
758 .enable_mask = BD718XX_BUCK_EN,
759 .owner = THIS_MODULE,
21b72156
MV		 760 .of_parse_cb = buck_set_hw_dvs_levels,
761 },
762 .dvs = {
763 .level_map = ROHM_DVS_LEVEL_RUN,
764 .run_reg = BD71837_REG_BUCK3_VOLT_RUN,
765 .run_mask = DVS_BUCK_RUN_MASK,
494edd26
MV		 766 },
767 .init = {
768 .reg = BD71837_REG_BUCK3_CTRL,
769 .mask = BD718XX_BUCK_SEL,
770 .val = BD718XX_BUCK_SEL,
771 },
772 },
773 {
774 .desc = {
775 .name = "buck4",
776 .of_match = of_match_ptr("BUCK4"),
777 .regulators_node = of_match_ptr("regulators"),
778 .id = BD718XX_BUCK4,
779 .ops = &bd718xx_dvs_buck_regulator_ops,
780 .type = REGULATOR_VOLTAGE,
781 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
782 .linear_ranges = bd718xx_dvs_buck_volts,
783 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
784 .vsel_reg = BD71837_REG_BUCK4_VOLT_RUN,
785 .vsel_mask = DVS_BUCK_RUN_MASK,
786 .enable_reg = BD71837_REG_BUCK4_CTRL,
787 .enable_mask = BD718XX_BUCK_EN,
788 .owner = THIS_MODULE,
21b72156
MV		 789 .of_parse_cb = buck_set_hw_dvs_levels,
790 },
791 .dvs = {
792 .level_map = ROHM_DVS_LEVEL_RUN,
793 .run_reg = BD71837_REG_BUCK4_VOLT_RUN,
794 .run_mask = DVS_BUCK_RUN_MASK,
494edd26
MV		 795 },
796 .init = {
797 .reg = BD71837_REG_BUCK4_CTRL,
798 .mask = BD718XX_BUCK_SEL,
799 .val = BD718XX_BUCK_SEL,
800 },
ba08799e
MV		 801 },
802 {
494edd26
MV		 803 .desc = {
804 .name = "buck5",
805 .of_match = of_match_ptr("BUCK5"),
806 .regulators_node = of_match_ptr("regulators"),
807 .id = BD718XX_BUCK5,
a4bfc2c2 808 .ops = &bd718xx_pickable_range_buck_ops,
494edd26 809 .type = REGULATOR_VOLTAGE,
a4bfc2c2
MV		 810 .n_voltages = BD71837_BUCK5_VOLTAGE_NUM,
811 .linear_ranges = bd71837_buck5_volts,
494edd26 812 .n_linear_ranges =
a4bfc2c2 813 ARRAY_SIZE(bd71837_buck5_volts),
494edd26 814 .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
a4bfc2c2
MV		 815 .vsel_mask = BD71837_BUCK5_MASK,
816 .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
817 .vsel_range_mask = BD71837_BUCK5_RANGE_MASK,
818 .linear_range_selectors = bd71837_buck5_volt_range_sel,
494edd26
MV		 819 .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
820 .enable_mask = BD718XX_BUCK_EN,
821 .owner = THIS_MODULE,
822 },
823 .init = {
824 .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
825 .mask = BD718XX_BUCK_SEL,
826 .val = BD718XX_BUCK_SEL,
827 },
ba08799e
MV		 828 },
829 {
494edd26
MV		 830 .desc = {
831 .name = "buck6",
832 .of_match = of_match_ptr("BUCK6"),
833 .regulators_node = of_match_ptr("regulators"),
834 .id = BD718XX_BUCK6,
835 .ops = &bd718xx_buck_regulator_ops,
836 .type = REGULATOR_VOLTAGE,
837 .n_voltages = BD71837_BUCK6_VOLTAGE_NUM,
a4bfc2c2 838 .linear_ranges = bd71837_buck6_volts,
494edd26 839 .n_linear_ranges =
a4bfc2c2 840 ARRAY_SIZE(bd71837_buck6_volts),
494edd26
MV		 841 .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
842 .vsel_mask = BD71837_BUCK6_MASK,
843 .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
844 .enable_mask = BD718XX_BUCK_EN,
845 .owner = THIS_MODULE,
846 },
847 .init = {
848 .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
849 .mask = BD718XX_BUCK_SEL,
850 .val = BD718XX_BUCK_SEL,
851 },
ba08799e
MV		 852 },
853 {
494edd26
MV		 854 .desc = {
855 .name = "buck7",
856 .of_match = of_match_ptr("BUCK7"),
857 .regulators_node = of_match_ptr("regulators"),
858 .id = BD718XX_BUCK7,
859 .ops = &bd718xx_buck_regulator_nolinear_ops,
860 .type = REGULATOR_VOLTAGE,
861 .volt_table = &bd718xx_3rd_nodvs_buck_volts[0],
862 .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts),
863 .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT,
864 .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK,
865 .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
866 .enable_mask = BD718XX_BUCK_EN,
867 .owner = THIS_MODULE,
868 },
869 .init = {
870 .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
871 .mask = BD718XX_BUCK_SEL,
872 .val = BD718XX_BUCK_SEL,
873 },
ba08799e
MV		 874 },
875 {
494edd26
MV		 876 .desc = {
877 .name = "buck8",
878 .of_match = of_match_ptr("BUCK8"),
879 .regulators_node = of_match_ptr("regulators"),
880 .id = BD718XX_BUCK8,
881 .ops = &bd718xx_buck_regulator_ops,
882 .type = REGULATOR_VOLTAGE,
dd2be639 883 .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM,
494edd26
MV		 884 .linear_ranges = bd718xx_4th_nodvs_buck_volts,
885 .n_linear_ranges =
886 ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts),
887 .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT,
888 .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK,
889 .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
890 .enable_mask = BD718XX_BUCK_EN,
891 .owner = THIS_MODULE,
892 },
893 .init = {
894 .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
895 .mask = BD718XX_BUCK_SEL,
896 .val = BD718XX_BUCK_SEL,
897 },
898 },
899 {
900 .desc = {
901 .name = "ldo1",
902 .of_match = of_match_ptr("LDO1"),
903 .regulators_node = of_match_ptr("regulators"),
904 .id = BD718XX_LDO1,
a4bfc2c2 905 .ops = &bd718xx_pickable_range_ldo_ops,
494edd26
MV		 906 .type = REGULATOR_VOLTAGE,
907 .n_voltages = BD718XX_LDO1_VOLTAGE_NUM,
908 .linear_ranges = bd718xx_ldo1_volts,
909 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts),
910 .vsel_reg = BD718XX_REG_LDO1_VOLT,
911 .vsel_mask = BD718XX_LDO1_MASK,
a4bfc2c2
MV		 912 .vsel_range_reg = BD718XX_REG_LDO1_VOLT,
913 .vsel_range_mask = BD718XX_LDO1_RANGE_MASK,
914 .linear_range_selectors = bd718xx_ldo1_volt_range_sel,
494edd26
MV		 915 .enable_reg = BD718XX_REG_LDO1_VOLT,
916 .enable_mask = BD718XX_LDO_EN,
917 .owner = THIS_MODULE,
918 },
919 .init = {
920 .reg = BD718XX_REG_LDO1_VOLT,
921 .mask = BD718XX_LDO_SEL,
922 .val = BD718XX_LDO_SEL,
923 },
924 },
925 {
926 .desc = {
927 .name = "ldo2",
928 .of_match = of_match_ptr("LDO2"),
929 .regulators_node = of_match_ptr("regulators"),
930 .id = BD718XX_LDO2,
931 .ops = &bd718xx_ldo_regulator_nolinear_ops,
932 .type = REGULATOR_VOLTAGE,
933 .volt_table = &ldo_2_volts[0],
934 .vsel_reg = BD718XX_REG_LDO2_VOLT,
935 .vsel_mask = BD718XX_LDO2_MASK,
936 .n_voltages = ARRAY_SIZE(ldo_2_volts),
937 .enable_reg = BD718XX_REG_LDO2_VOLT,
938 .enable_mask = BD718XX_LDO_EN,
939 .owner = THIS_MODULE,
940 },
941 .init = {
942 .reg = BD718XX_REG_LDO2_VOLT,
943 .mask = BD718XX_LDO_SEL,
944 .val = BD718XX_LDO_SEL,
945 },
946 },
947 {
948 .desc = {
949 .name = "ldo3",
950 .of_match = of_match_ptr("LDO3"),
951 .regulators_node = of_match_ptr("regulators"),
952 .id = BD718XX_LDO3,
953 .ops = &bd718xx_ldo_regulator_ops,
954 .type = REGULATOR_VOLTAGE,
955 .n_voltages = BD718XX_LDO3_VOLTAGE_NUM,
956 .linear_ranges = bd718xx_ldo3_volts,
957 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts),
958 .vsel_reg = BD718XX_REG_LDO3_VOLT,
959 .vsel_mask = BD718XX_LDO3_MASK,
960 .enable_reg = BD718XX_REG_LDO3_VOLT,
961 .enable_mask = BD718XX_LDO_EN,
962 .owner = THIS_MODULE,
963 },
964 .init = {
965 .reg = BD718XX_REG_LDO3_VOLT,
966 .mask = BD718XX_LDO_SEL,
967 .val = BD718XX_LDO_SEL,
968 },
969 },
970 {
971 .desc = {
972 .name = "ldo4",
973 .of_match = of_match_ptr("LDO4"),
974 .regulators_node = of_match_ptr("regulators"),
975 .id = BD718XX_LDO4,
976 .ops = &bd718xx_ldo_regulator_ops,
977 .type = REGULATOR_VOLTAGE,
978 .n_voltages = BD718XX_LDO4_VOLTAGE_NUM,
979 .linear_ranges = bd718xx_ldo4_volts,
980 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts),
981 .vsel_reg = BD718XX_REG_LDO4_VOLT,
982 .vsel_mask = BD718XX_LDO4_MASK,
983 .enable_reg = BD718XX_REG_LDO4_VOLT,
984 .enable_mask = BD718XX_LDO_EN,
985 .owner = THIS_MODULE,
986 },
987 .init = {
988 .reg = BD718XX_REG_LDO4_VOLT,
989 .mask = BD718XX_LDO_SEL,
990 .val = BD718XX_LDO_SEL,
991 },
992 },
993 {
994 .desc = {
995 .name = "ldo5",
996 .of_match = of_match_ptr("LDO5"),
997 .regulators_node = of_match_ptr("regulators"),
998 .id = BD718XX_LDO5,
999 .ops = &bd718xx_ldo_regulator_ops,
1000 .type = REGULATOR_VOLTAGE,
a4bfc2c2
MV		 1001 .n_voltages = BD71837_LDO5_VOLTAGE_NUM,
1002 .linear_ranges = bd71837_ldo5_volts,
1003 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo5_volts),
494edd26
MV		 1004 /* LDO5 is supplied by buck6 */
1005 .supply_name = "buck6",
1006 .vsel_reg = BD718XX_REG_LDO5_VOLT,
1007 .vsel_mask = BD71837_LDO5_MASK,
1008 .enable_reg = BD718XX_REG_LDO5_VOLT,
1009 .enable_mask = BD718XX_LDO_EN,
1010 .owner = THIS_MODULE,
1011 },
1012 .init = {
1013 .reg = BD718XX_REG_LDO5_VOLT,
1014 .mask = BD718XX_LDO_SEL,
1015 .val = BD718XX_LDO_SEL,
1016 },
1017 .additional_inits = bd71837_ldo5_inits,
1018 .additional_init_amnt = ARRAY_SIZE(bd71837_ldo5_inits),
1019 },
1020 {
1021 .desc = {
1022 .name = "ldo6",
1023 .of_match = of_match_ptr("LDO6"),
1024 .regulators_node = of_match_ptr("regulators"),
1025 .id = BD718XX_LDO6,
1026 .ops = &bd718xx_ldo_regulator_ops,
1027 .type = REGULATOR_VOLTAGE,
1028 .n_voltages = BD718XX_LDO6_VOLTAGE_NUM,
1029 .linear_ranges = bd718xx_ldo6_volts,
1030 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts),
1031 /* LDO6 is supplied by buck7 */
1032 .supply_name = "buck7",
1033 .vsel_reg = BD718XX_REG_LDO6_VOLT,
1034 .vsel_mask = BD718XX_LDO6_MASK,
1035 .enable_reg = BD718XX_REG_LDO6_VOLT,
1036 .enable_mask = BD718XX_LDO_EN,
1037 .owner = THIS_MODULE,
1038 },
1039 .init = {
1040 .reg = BD718XX_REG_LDO6_VOLT,
1041 .mask = BD718XX_LDO_SEL,
1042 .val = BD718XX_LDO_SEL,
1043 },
1044 .additional_inits = bd71837_ldo6_inits,
1045 .additional_init_amnt = ARRAY_SIZE(bd71837_ldo6_inits),
1046 },
1047 {
1048 .desc = {
1049 .name = "ldo7",
1050 .of_match = of_match_ptr("LDO7"),
1051 .regulators_node = of_match_ptr("regulators"),
1052 .id = BD718XX_LDO7,
1053 .ops = &bd718xx_ldo_regulator_ops,
1054 .type = REGULATOR_VOLTAGE,
1055 .n_voltages = BD71837_LDO7_VOLTAGE_NUM,
1056 .linear_ranges = bd71837_ldo7_volts,
1057 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo7_volts),
1058 .vsel_reg = BD71837_REG_LDO7_VOLT,
1059 .vsel_mask = BD71837_LDO7_MASK,
1060 .enable_reg = BD71837_REG_LDO7_VOLT,
1061 .enable_mask = BD718XX_LDO_EN,
1062 .owner = THIS_MODULE,
1063 },
1064 .init = {
1065 .reg = BD71837_REG_LDO7_VOLT,
1066 .mask = BD718XX_LDO_SEL,
1067 .val = BD718XX_LDO_SEL,
1068 },
ba08799e
MV		 1069 },
1070};
1071
dd2be639 1072static int bd718xx_probe(struct platform_device *pdev)
ba08799e 1073{
bcb047eb 1074 struct bd718xx *mfd;
ba08799e 1075 struct regulator_config config = { 0 };
494edd26 1076 int i, j, err;
049369d4 1077 bool use_snvs;
b389ceae
AL		 1078 const struct bd718xx_regulator_data *reg_data;
1079 unsigned int num_reg_data;
1b1c26b2 1080 enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data;
ba08799e 1081
bcb047eb
AL		 1082 mfd = dev_get_drvdata(pdev->dev.parent);
1083 if (!mfd) {
ba08799e
MV		 1084 dev_err(&pdev->dev, "No MFD driver data\n");
1085 err = -EINVAL;
1086 goto err;
1087 }
bcb047eb 1088
af32f3a4 1089 switch (chip) {
b389ceae
AL		 1090 case ROHM_CHIP_TYPE_BD71837:
1091 reg_data = bd71837_regulators;
1092 num_reg_data = ARRAY_SIZE(bd71837_regulators);
1093 break;
1094 case ROHM_CHIP_TYPE_BD71847:
1095 reg_data = bd71847_regulators;
1096 num_reg_data = ARRAY_SIZE(bd71847_regulators);
1097 break;
1098 default:
494edd26
MV		 1099 dev_err(&pdev->dev, "Unsupported chip type\n");
1100 err = -EINVAL;
1101 goto err;
1102 }
1103
ba08799e 1104 /* Register LOCK release */
2a6a7aac 1105 err = regmap_update_bits(mfd->chip.regmap, BD718XX_REG_REGLOCK,
ba08799e
MV		 1106 (REGLOCK_PWRSEQ | REGLOCK_VREG), 0);
1107 if (err) {
bcb047eb 1108 dev_err(&pdev->dev, "Failed to unlock PMIC (%d)\n", err);
ba08799e
MV		 1109 goto err;
1110 } else {
bcb047eb 1111 dev_dbg(&pdev->dev, "Unlocked lock register 0x%x\n",
494edd26 1112 BD718XX_REG_REGLOCK);
823f18f8
MV		 1113 }
1114
049369d4
MV		 1115 use_snvs = of_property_read_bool(pdev->dev.parent->of_node,
1116 "rohm,reset-snvs-powered");
1117
1118 /*
e770b18b
MV		 1119 * Change the next stage from poweroff to be READY instead of SNVS
1120 * for all reset types because OTP loading at READY will clear SEL
1121 * bit allowing HW defaults for power rails to be used
1122 */
049369d4 1123 if (!use_snvs) {
2a6a7aac
MV		 1124 err = regmap_update_bits(mfd->chip.regmap,
1125 BD718XX_REG_TRANS_COND1,
049369d4
MV		 1126 BD718XX_ON_REQ_POWEROFF_MASK |
1127 BD718XX_SWRESET_POWEROFF_MASK |
1128 BD718XX_WDOG_POWEROFF_MASK |
1129 BD718XX_KEY_L_POWEROFF_MASK,
1130 BD718XX_POWOFF_TO_RDY);
1131 if (err) {
1132 dev_err(&pdev->dev, "Failed to change reset target\n");
1133 goto err;
1134 } else {
1135 dev_dbg(&pdev->dev,
1136 "Changed all resets from SVNS to READY\n");
1137 }
e770b18b
MV		 1138 }
1139
b389ceae 1140 for (i = 0; i < num_reg_data; i++) {
ba08799e 1141
494edd26 1142 const struct regulator_desc *desc;
ba08799e 1143 struct regulator_dev *rdev;
494edd26 1144 const struct bd718xx_regulator_data *r;
ba08799e 1145
b389ceae 1146 r = &reg_data[i];
494edd26 1147 desc = &r->desc;
ba08799e 1148
ba08799e 1149 config.dev = pdev->dev.parent;
2a6a7aac 1150 config.regmap = mfd->chip.regmap;
ba08799e
MV		 1151
1152 rdev = devm_regulator_register(&pdev->dev, desc, &config);
1153 if (IS_ERR(rdev)) {
bcb047eb 1154 dev_err(&pdev->dev,
ba08799e
MV		 1155 "failed to register %s regulator\n",
1156 desc->name);
1157 err = PTR_ERR(rdev);
1158 goto err;
1159 }
049369d4
MV		 1160
1161 /*
1162 * Regulator register gets the regulator constraints and
ba08799e
MV		 1163 * applies them (set_machine_constraints). This should have
1164 * turned the control register(s) to correct values and we
1165 * can now switch the control from PMIC state machine to the
1166 * register interface
049369d4
MV		 1167 *
1168 * At poweroff transition PMIC HW disables EN bit for
1169 * regulators but leaves SEL bit untouched. So if state
1170 * transition from POWEROFF is done to SNVS - then all power
1171 * rails controlled by SW (having SEL bit set) stay disabled
1172 * as EN is cleared. This will result boot failure if any
1173 * crucial systems are powered by these rails. We don't
1174 * enable SW control for crucial regulators if snvs state is
1175 * used
ba08799e 1176 */
049369d4
MV		 1177 if (!use_snvs || !rdev->constraints->always_on ||
1178 !rdev->constraints->boot_on) {
2a6a7aac 1179 err = regmap_update_bits(mfd->chip.regmap, r->init.reg,
049369d4
MV		 1180 r->init.mask, r->init.val);
1181 if (err) {
1182 dev_err(&pdev->dev,
1183 "Failed to take control for (%s)\n",
1184 desc->name);
1185 goto err;
1186 }
ba08799e 1187 }
494edd26 1188 for (j = 0; j < r->additional_init_amnt; j++) {
2a6a7aac 1189 err = regmap_update_bits(mfd->chip.regmap,
494edd26
MV		 1190 r->additional_inits[j].reg,
1191 r->additional_inits[j].mask,
1192 r->additional_inits[j].val);
1193 if (err) {
bcb047eb 1194 dev_err(&pdev->dev,
494edd26
MV		 1195 "Buck (%s) initialization failed\n",
1196 desc->name);
1197 goto err;
1198 }
1199 }
ba08799e
MV		 1200 }
1201
ba08799e
MV		 1202err:
1203 return err;
1204}
1205
1b1c26b2
MV		 1206static const struct platform_device_id bd718x7_pmic_id[] = {
1207 { "bd71837-pmic", ROHM_CHIP_TYPE_BD71837 },
1208 { "bd71847-pmic", ROHM_CHIP_TYPE_BD71847 },
1209 { },
1210};
1211MODULE_DEVICE_TABLE(platform, bd718x7_pmic_id);
1212
dd2be639 1213static struct platform_driver bd718xx_regulator = {
ba08799e 1214 .driver = {
494edd26 1215 .name = "bd718xx-pmic",
ba08799e 1216 },
dd2be639 1217 .probe = bd718xx_probe,
1b1c26b2 1218 .id_table = bd718x7_pmic_id,
ba08799e
MV		 1219};
1220
dd2be639 1221module_platform_driver(bd718xx_regulator);
ba08799e
MV		 1222
1223MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
dd2be639 1224MODULE_DESCRIPTION("BD71837/BD71847 voltage regulator driver");
ba08799e 1225MODULE_LICENSE("GPL");
95bddd8b 1226MODULE_ALIAS("platform:bd718xx-pmic");
Ubuntu Jammy Linux kernel mirror