projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'x86-pti-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6-block.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;
321 const struct reg_init init;
322 const struct reg_init *additional_inits;
323 int additional_init_amnt;
324};
325
326/*
327 * There is a HW quirk in BD71837. The shutdown sequence timings for
328 * bucks/LDOs which are controlled via register interface are changed.
329 * At PMIC poweroff the voltage for BUCK6/7 is cut immediately at the
330 * beginning of shut-down sequence. As bucks 6 and 7 are parent
331 * supplies for LDO5 and LDO6 - this causes LDO5/6 voltage
332 * monitoring to errorneously detect under voltage and force PMIC to
333 * emergency state instead of poweroff. In order to avoid this we
334 * disable voltage monitoring for LDO5 and LDO6
335 */
336static const struct reg_init bd71837_ldo5_inits[] = {
337 {
338 .reg = BD718XX_REG_MVRFLTMASK2,
339 .mask = BD718XX_LDO5_VRMON80,
340 .val = BD718XX_LDO5_VRMON80,
341 },
342};
343
344static const struct reg_init bd71837_ldo6_inits[] = {
345 {
346 .reg = BD718XX_REG_MVRFLTMASK2,
347 .mask = BD718XX_LDO6_VRMON80,
348 .val = BD718XX_LDO6_VRMON80,
349 },
350};
351
049369d4
MV		 352#define NUM_DVS_BUCKS 4
353
354struct of_dvs_setting {
355 const char *prop;
356 unsigned int reg;
357};
358
359static int set_dvs_levels(const struct of_dvs_setting *dvs,
360 struct device_node *np,
361 const struct regulator_desc *desc,
362 struct regmap *regmap)
363{
364 int ret, i;
365 unsigned int uv;
366
367 ret = of_property_read_u32(np, dvs->prop, &uv);
368 if (ret) {
369 if (ret != -EINVAL)
370 return ret;
371 return 0;
372 }
373
374 for (i = 0; i < desc->n_voltages; i++) {
375 ret = regulator_desc_list_voltage_linear_range(desc, i);
376 if (ret < 0)
377 continue;
378 if (ret == uv) {
379 i <<= ffs(desc->vsel_mask) - 1;
380 ret = regmap_update_bits(regmap, dvs->reg,
381 DVS_BUCK_RUN_MASK, i);
382 break;
383 }
384 }
385 return ret;
386}
387
388static int buck4_set_hw_dvs_levels(struct device_node *np,
389 const struct regulator_desc *desc,
390 struct regulator_config *cfg)
391{
392 int ret, i;
393 const struct of_dvs_setting dvs[] = {
394 {
395 .prop = "rohm,dvs-run-voltage",
396 .reg = BD71837_REG_BUCK4_VOLT_RUN,
397 },
398 };
399
400 for (i = 0; i < ARRAY_SIZE(dvs); i++) {
401 ret = set_dvs_levels(&dvs[i], np, desc, cfg->regmap);
402 if (ret)
403 break;
404 }
405 return ret;
406}
407static int buck3_set_hw_dvs_levels(struct device_node *np,
408 const struct regulator_desc *desc,
409 struct regulator_config *cfg)
410{
411 int ret, i;
412 const struct of_dvs_setting dvs[] = {
413 {
414 .prop = "rohm,dvs-run-voltage",
415 .reg = BD71837_REG_BUCK3_VOLT_RUN,
416 },
417 };
418
419 for (i = 0; i < ARRAY_SIZE(dvs); i++) {
420 ret = set_dvs_levels(&dvs[i], np, desc, cfg->regmap);
421 if (ret)
422 break;
423 }
424 return ret;
425}
426
427static int buck2_set_hw_dvs_levels(struct device_node *np,
428 const struct regulator_desc *desc,
429 struct regulator_config *cfg)
430{
431 int ret, i;
432 const struct of_dvs_setting dvs[] = {
433 {
434 .prop = "rohm,dvs-run-voltage",
435 .reg = BD718XX_REG_BUCK2_VOLT_RUN,
436 },
437 {
438 .prop = "rohm,dvs-idle-voltage",
439 .reg = BD718XX_REG_BUCK2_VOLT_IDLE,
440 },
441 };
442
443
444
445 for (i = 0; i < ARRAY_SIZE(dvs); i++) {
446 ret = set_dvs_levels(&dvs[i], np, desc, cfg->regmap);
447 if (ret)
448 break;
449 }
450 return ret;
451}
452
453static int buck1_set_hw_dvs_levels(struct device_node *np,
454 const struct regulator_desc *desc,
455 struct regulator_config *cfg)
456{
457 int ret, i;
458 const struct of_dvs_setting dvs[] = {
459 {
460 .prop = "rohm,dvs-run-voltage",
461 .reg = BD718XX_REG_BUCK1_VOLT_RUN,
462 },
463 {
464 .prop = "rohm,dvs-idle-voltage",
465 .reg = BD718XX_REG_BUCK1_VOLT_IDLE,
466 },
467 {
468 .prop = "rohm,dvs-suspend-voltage",
469 .reg = BD718XX_REG_BUCK1_VOLT_SUSP,
470 },
471 };
472
473 for (i = 0; i < ARRAY_SIZE(dvs); i++) {
474 ret = set_dvs_levels(&dvs[i], np, desc, cfg->regmap);
475 if (ret)
476 break;
477 }
478 return ret;
479}
480
494edd26
MV		 481static const struct bd718xx_regulator_data bd71847_regulators[] = {
482 {
483 .desc = {
484 .name = "buck1",
485 .of_match = of_match_ptr("BUCK1"),
486 .regulators_node = of_match_ptr("regulators"),
487 .id = BD718XX_BUCK1,
488 .ops = &bd718xx_dvs_buck_regulator_ops,
489 .type = REGULATOR_VOLTAGE,
490 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
491 .linear_ranges = bd718xx_dvs_buck_volts,
492 .n_linear_ranges =
493 ARRAY_SIZE(bd718xx_dvs_buck_volts),
494 .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN,
495 .vsel_mask = DVS_BUCK_RUN_MASK,
496 .enable_reg = BD718XX_REG_BUCK1_CTRL,
497 .enable_mask = BD718XX_BUCK_EN,
498 .owner = THIS_MODULE,
049369d4 499 .of_parse_cb = buck1_set_hw_dvs_levels,
494edd26
MV		 500 },
501 .init = {
502 .reg = BD718XX_REG_BUCK1_CTRL,
503 .mask = BD718XX_BUCK_SEL,
504 .val = BD718XX_BUCK_SEL,
505 },
506 },
ba08799e 507 {
494edd26
MV		 508 .desc = {
509 .name = "buck2",
510 .of_match = of_match_ptr("BUCK2"),
511 .regulators_node = of_match_ptr("regulators"),
512 .id = BD718XX_BUCK2,
513 .ops = &bd718xx_dvs_buck_regulator_ops,
514 .type = REGULATOR_VOLTAGE,
515 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
516 .linear_ranges = bd718xx_dvs_buck_volts,
517 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
518 .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN,
519 .vsel_mask = DVS_BUCK_RUN_MASK,
520 .enable_reg = BD718XX_REG_BUCK2_CTRL,
521 .enable_mask = BD718XX_BUCK_EN,
522 .owner = THIS_MODULE,
049369d4 523 .of_parse_cb = buck2_set_hw_dvs_levels,
494edd26
MV		 524 },
525 .init = {
526 .reg = BD718XX_REG_BUCK2_CTRL,
527 .mask = BD718XX_BUCK_SEL,
528 .val = BD718XX_BUCK_SEL,
529 },
ba08799e
MV		 530 },
531 {
494edd26
MV		 532 .desc = {
533 .name = "buck3",
534 .of_match = of_match_ptr("BUCK3"),
535 .regulators_node = of_match_ptr("regulators"),
536 .id = BD718XX_BUCK3,
a4bfc2c2 537 .ops = &bd718xx_pickable_range_buck_ops,
494edd26 538 .type = REGULATOR_VOLTAGE,
a4bfc2c2
MV		 539 .n_voltages = BD71847_BUCK3_VOLTAGE_NUM,
540 .linear_ranges = bd71847_buck3_volts,
494edd26 541 .n_linear_ranges =
a4bfc2c2 542 ARRAY_SIZE(bd71847_buck3_volts),
494edd26
MV		 543 .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
544 .vsel_mask = BD718XX_1ST_NODVS_BUCK_MASK,
a4bfc2c2
MV		 545 .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
546 .vsel_range_mask = BD71847_BUCK3_RANGE_MASK,
547 .linear_range_selectors = bd71847_buck3_volt_range_sel,
494edd26
MV		 548 .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
549 .enable_mask = BD718XX_BUCK_EN,
550 .owner = THIS_MODULE,
551 },
552 .init = {
553 .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
554 .mask = BD718XX_BUCK_SEL,
555 .val = BD718XX_BUCK_SEL,
556 },
ba08799e
MV		 557 },
558 {
494edd26
MV		 559 .desc = {
560 .name = "buck4",
561 .of_match = of_match_ptr("BUCK4"),
562 .regulators_node = of_match_ptr("regulators"),
563 .id = BD718XX_BUCK4,
a4bfc2c2 564 .ops = &bd718xx_pickable_range_buck_ops,
494edd26
MV		 565 .type = REGULATOR_VOLTAGE,
566 .n_voltages = BD71847_BUCK4_VOLTAGE_NUM,
a4bfc2c2 567 .linear_ranges = bd71847_buck4_volts,
494edd26 568 .n_linear_ranges =
a4bfc2c2 569 ARRAY_SIZE(bd71847_buck4_volts),
494edd26
MV		 570 .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
571 .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
572 .vsel_mask = BD71847_BUCK4_MASK,
a4bfc2c2
MV		 573 .vsel_range_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
574 .vsel_range_mask = BD71847_BUCK4_RANGE_MASK,
575 .linear_range_selectors = bd71847_buck4_volt_range_sel,
494edd26
MV		 576 .enable_mask = BD718XX_BUCK_EN,
577 .owner = THIS_MODULE,
578 },
579 .init = {
580 .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
581 .mask = BD718XX_BUCK_SEL,
582 .val = BD718XX_BUCK_SEL,
583 },
ba08799e
MV		 584 },
585 {
494edd26
MV		 586 .desc = {
587 .name = "buck5",
588 .of_match = of_match_ptr("BUCK5"),
dd2be639 589 .regulators_node = of_match_ptr("regulators"),
494edd26
MV		 590 .id = BD718XX_BUCK5,
591 .ops = &bd718xx_buck_regulator_nolinear_ops,
592 .type = REGULATOR_VOLTAGE,
593 .volt_table = &bd718xx_3rd_nodvs_buck_volts[0],
594 .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts),
595 .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT,
596 .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK,
597 .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
598 .enable_mask = BD718XX_BUCK_EN,
599 .owner = THIS_MODULE,
600 },
601 .init = {
602 .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
603 .mask = BD718XX_BUCK_SEL,
604 .val = BD718XX_BUCK_SEL,
605 },
ba08799e
MV		 606 },
607 {
494edd26
MV		 608 .desc = {
609 .name = "buck6",
610 .of_match = of_match_ptr("BUCK6"),
611 .regulators_node = of_match_ptr("regulators"),
612 .id = BD718XX_BUCK6,
613 .ops = &bd718xx_buck_regulator_ops,
614 .type = REGULATOR_VOLTAGE,
dd2be639 615 .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM,
494edd26
MV		 616 .linear_ranges = bd718xx_4th_nodvs_buck_volts,
617 .n_linear_ranges =
618 ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts),
619 .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT,
620 .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK,
621 .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
622 .enable_mask = BD718XX_BUCK_EN,
623 .owner = THIS_MODULE,
624 },
625 .init = {
626 .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
627 .mask = BD718XX_BUCK_SEL,
628 .val = BD718XX_BUCK_SEL,
629 },
ba08799e
MV		 630 },
631 {
494edd26
MV		 632 .desc = {
633 .name = "ldo1",
634 .of_match = of_match_ptr("LDO1"),
635 .regulators_node = of_match_ptr("regulators"),
636 .id = BD718XX_LDO1,
a4bfc2c2 637 .ops = &bd718xx_pickable_range_ldo_ops,
494edd26
MV		 638 .type = REGULATOR_VOLTAGE,
639 .n_voltages = BD718XX_LDO1_VOLTAGE_NUM,
640 .linear_ranges = bd718xx_ldo1_volts,
641 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts),
642 .vsel_reg = BD718XX_REG_LDO1_VOLT,
643 .vsel_mask = BD718XX_LDO1_MASK,
a4bfc2c2
MV		 644 .vsel_range_reg = BD718XX_REG_LDO1_VOLT,
645 .vsel_range_mask = BD718XX_LDO1_RANGE_MASK,
646 .linear_range_selectors = bd718xx_ldo1_volt_range_sel,
494edd26
MV		 647 .enable_reg = BD718XX_REG_LDO1_VOLT,
648 .enable_mask = BD718XX_LDO_EN,
649 .owner = THIS_MODULE,
650 },
651 .init = {
652 .reg = BD718XX_REG_LDO1_VOLT,
653 .mask = BD718XX_LDO_SEL,
654 .val = BD718XX_LDO_SEL,
655 },
ba08799e
MV		 656 },
657 {
494edd26
MV		 658 .desc = {
659 .name = "ldo2",
660 .of_match = of_match_ptr("LDO2"),
661 .regulators_node = of_match_ptr("regulators"),
662 .id = BD718XX_LDO2,
663 .ops = &bd718xx_ldo_regulator_nolinear_ops,
664 .type = REGULATOR_VOLTAGE,
665 .volt_table = &ldo_2_volts[0],
666 .vsel_reg = BD718XX_REG_LDO2_VOLT,
667 .vsel_mask = BD718XX_LDO2_MASK,
668 .n_voltages = ARRAY_SIZE(ldo_2_volts),
669 .enable_reg = BD718XX_REG_LDO2_VOLT,
670 .enable_mask = BD718XX_LDO_EN,
671 .owner = THIS_MODULE,
672 },
673 .init = {
674 .reg = BD718XX_REG_LDO2_VOLT,
675 .mask = BD718XX_LDO_SEL,
676 .val = BD718XX_LDO_SEL,
677 },
ba08799e
MV		 678 },
679 {
494edd26
MV		 680 .desc = {
681 .name = "ldo3",
682 .of_match = of_match_ptr("LDO3"),
683 .regulators_node = of_match_ptr("regulators"),
684 .id = BD718XX_LDO3,
685 .ops = &bd718xx_ldo_regulator_ops,
686 .type = REGULATOR_VOLTAGE,
687 .n_voltages = BD718XX_LDO3_VOLTAGE_NUM,
688 .linear_ranges = bd718xx_ldo3_volts,
689 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts),
690 .vsel_reg = BD718XX_REG_LDO3_VOLT,
691 .vsel_mask = BD718XX_LDO3_MASK,
692 .enable_reg = BD718XX_REG_LDO3_VOLT,
693 .enable_mask = BD718XX_LDO_EN,
694 .owner = THIS_MODULE,
695 },
696 .init = {
697 .reg = BD718XX_REG_LDO3_VOLT,
698 .mask = BD718XX_LDO_SEL,
699 .val = BD718XX_LDO_SEL,
700 },
ba08799e
MV		 701 },
702 {
494edd26
MV		 703 .desc = {
704 .name = "ldo4",
705 .of_match = of_match_ptr("LDO4"),
706 .regulators_node = of_match_ptr("regulators"),
707 .id = BD718XX_LDO4,
708 .ops = &bd718xx_ldo_regulator_ops,
709 .type = REGULATOR_VOLTAGE,
710 .n_voltages = BD718XX_LDO4_VOLTAGE_NUM,
711 .linear_ranges = bd718xx_ldo4_volts,
712 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts),
713 .vsel_reg = BD718XX_REG_LDO4_VOLT,
714 .vsel_mask = BD718XX_LDO4_MASK,
715 .enable_reg = BD718XX_REG_LDO4_VOLT,
716 .enable_mask = BD718XX_LDO_EN,
717 .owner = THIS_MODULE,
718 },
719 .init = {
720 .reg = BD718XX_REG_LDO4_VOLT,
721 .mask = BD718XX_LDO_SEL,
722 .val = BD718XX_LDO_SEL,
723 },
ba08799e
MV		 724 },
725 {
494edd26
MV		 726 .desc = {
727 .name = "ldo5",
728 .of_match = of_match_ptr("LDO5"),
729 .regulators_node = of_match_ptr("regulators"),
730 .id = BD718XX_LDO5,
a4bfc2c2 731 .ops = &bd718xx_pickable_range_ldo_ops,
494edd26 732 .type = REGULATOR_VOLTAGE,
a4bfc2c2
MV		 733 .n_voltages = BD71847_LDO5_VOLTAGE_NUM,
734 .linear_ranges = bd71847_ldo5_volts,
735 .n_linear_ranges = ARRAY_SIZE(bd71847_ldo5_volts),
494edd26
MV		 736 .vsel_reg = BD718XX_REG_LDO5_VOLT,
737 .vsel_mask = BD71847_LDO5_MASK,
a4bfc2c2
MV		 738 .vsel_range_reg = BD718XX_REG_LDO5_VOLT,
739 .vsel_range_mask = BD71847_LDO5_RANGE_MASK,
740 .linear_range_selectors = bd71847_ldo5_volt_range_sel,
494edd26
MV		 741 .enable_reg = BD718XX_REG_LDO5_VOLT,
742 .enable_mask = BD718XX_LDO_EN,
743 .owner = THIS_MODULE,
744 },
745 .init = {
746 .reg = BD718XX_REG_LDO5_VOLT,
747 .mask = BD718XX_LDO_SEL,
748 .val = BD718XX_LDO_SEL,
749 },
ba08799e
MV		 750 },
751 {
494edd26
MV		 752 .desc = {
753 .name = "ldo6",
754 .of_match = of_match_ptr("LDO6"),
755 .regulators_node = of_match_ptr("regulators"),
756 .id = BD718XX_LDO6,
757 .ops = &bd718xx_ldo_regulator_ops,
758 .type = REGULATOR_VOLTAGE,
759 .n_voltages = BD718XX_LDO6_VOLTAGE_NUM,
760 .linear_ranges = bd718xx_ldo6_volts,
761 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts),
762 /* LDO6 is supplied by buck5 */
763 .supply_name = "buck5",
764 .vsel_reg = BD718XX_REG_LDO6_VOLT,
765 .vsel_mask = BD718XX_LDO6_MASK,
766 .enable_reg = BD718XX_REG_LDO6_VOLT,
767 .enable_mask = BD718XX_LDO_EN,
768 .owner = THIS_MODULE,
769 },
770 .init = {
771 .reg = BD718XX_REG_LDO6_VOLT,
772 .mask = BD718XX_LDO_SEL,
773 .val = BD718XX_LDO_SEL,
774 },
775 },
776};
777
778static const struct bd718xx_regulator_data bd71837_regulators[] = {
779 {
780 .desc = {
781 .name = "buck1",
782 .of_match = of_match_ptr("BUCK1"),
783 .regulators_node = of_match_ptr("regulators"),
784 .id = BD718XX_BUCK1,
785 .ops = &bd718xx_dvs_buck_regulator_ops,
786 .type = REGULATOR_VOLTAGE,
787 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
788 .linear_ranges = bd718xx_dvs_buck_volts,
789 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
790 .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN,
791 .vsel_mask = DVS_BUCK_RUN_MASK,
792 .enable_reg = BD718XX_REG_BUCK1_CTRL,
793 .enable_mask = BD718XX_BUCK_EN,
794 .owner = THIS_MODULE,
049369d4 795 .of_parse_cb = buck1_set_hw_dvs_levels,
494edd26
MV		 796 },
797 .init = {
798 .reg = BD718XX_REG_BUCK1_CTRL,
799 .mask = BD718XX_BUCK_SEL,
800 .val = BD718XX_BUCK_SEL,
801 },
802 },
803 {
804 .desc = {
805 .name = "buck2",
806 .of_match = of_match_ptr("BUCK2"),
807 .regulators_node = of_match_ptr("regulators"),
808 .id = BD718XX_BUCK2,
809 .ops = &bd718xx_dvs_buck_regulator_ops,
810 .type = REGULATOR_VOLTAGE,
811 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
812 .linear_ranges = bd718xx_dvs_buck_volts,
813 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
814 .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN,
815 .vsel_mask = DVS_BUCK_RUN_MASK,
816 .enable_reg = BD718XX_REG_BUCK2_CTRL,
817 .enable_mask = BD718XX_BUCK_EN,
818 .owner = THIS_MODULE,
049369d4 819 .of_parse_cb = buck2_set_hw_dvs_levels,
494edd26
MV		 820 },
821 .init = {
822 .reg = BD718XX_REG_BUCK2_CTRL,
823 .mask = BD718XX_BUCK_SEL,
824 .val = BD718XX_BUCK_SEL,
825 },
826 },
827 {
828 .desc = {
829 .name = "buck3",
830 .of_match = of_match_ptr("BUCK3"),
831 .regulators_node = of_match_ptr("regulators"),
832 .id = BD718XX_BUCK3,
833 .ops = &bd718xx_dvs_buck_regulator_ops,
834 .type = REGULATOR_VOLTAGE,
835 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
836 .linear_ranges = bd718xx_dvs_buck_volts,
837 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
838 .vsel_reg = BD71837_REG_BUCK3_VOLT_RUN,
839 .vsel_mask = DVS_BUCK_RUN_MASK,
840 .enable_reg = BD71837_REG_BUCK3_CTRL,
841 .enable_mask = BD718XX_BUCK_EN,
842 .owner = THIS_MODULE,
049369d4 843 .of_parse_cb = buck3_set_hw_dvs_levels,
494edd26
MV		 844 },
845 .init = {
846 .reg = BD71837_REG_BUCK3_CTRL,
847 .mask = BD718XX_BUCK_SEL,
848 .val = BD718XX_BUCK_SEL,
849 },
850 },
851 {
852 .desc = {
853 .name = "buck4",
854 .of_match = of_match_ptr("BUCK4"),
855 .regulators_node = of_match_ptr("regulators"),
856 .id = BD718XX_BUCK4,
857 .ops = &bd718xx_dvs_buck_regulator_ops,
858 .type = REGULATOR_VOLTAGE,
859 .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
860 .linear_ranges = bd718xx_dvs_buck_volts,
861 .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
862 .vsel_reg = BD71837_REG_BUCK4_VOLT_RUN,
863 .vsel_mask = DVS_BUCK_RUN_MASK,
864 .enable_reg = BD71837_REG_BUCK4_CTRL,
865 .enable_mask = BD718XX_BUCK_EN,
866 .owner = THIS_MODULE,
049369d4 867 .of_parse_cb = buck4_set_hw_dvs_levels,
494edd26
MV		 868 },
869 .init = {
870 .reg = BD71837_REG_BUCK4_CTRL,
871 .mask = BD718XX_BUCK_SEL,
872 .val = BD718XX_BUCK_SEL,
873 },
ba08799e
MV		 874 },
875 {
494edd26
MV		 876 .desc = {
877 .name = "buck5",
878 .of_match = of_match_ptr("BUCK5"),
879 .regulators_node = of_match_ptr("regulators"),
880 .id = BD718XX_BUCK5,
a4bfc2c2 881 .ops = &bd718xx_pickable_range_buck_ops,
494edd26 882 .type = REGULATOR_VOLTAGE,
a4bfc2c2
MV		 883 .n_voltages = BD71837_BUCK5_VOLTAGE_NUM,
884 .linear_ranges = bd71837_buck5_volts,
494edd26 885 .n_linear_ranges =
a4bfc2c2 886 ARRAY_SIZE(bd71837_buck5_volts),
494edd26 887 .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
a4bfc2c2
MV		 888 .vsel_mask = BD71837_BUCK5_MASK,
889 .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
890 .vsel_range_mask = BD71837_BUCK5_RANGE_MASK,
891 .linear_range_selectors = bd71837_buck5_volt_range_sel,
494edd26
MV		 892 .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
893 .enable_mask = BD718XX_BUCK_EN,
894 .owner = THIS_MODULE,
895 },
896 .init = {
897 .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
898 .mask = BD718XX_BUCK_SEL,
899 .val = BD718XX_BUCK_SEL,
900 },
ba08799e
MV		 901 },
902 {
494edd26
MV		 903 .desc = {
904 .name = "buck6",
905 .of_match = of_match_ptr("BUCK6"),
906 .regulators_node = of_match_ptr("regulators"),
907 .id = BD718XX_BUCK6,
908 .ops = &bd718xx_buck_regulator_ops,
909 .type = REGULATOR_VOLTAGE,
910 .n_voltages = BD71837_BUCK6_VOLTAGE_NUM,
a4bfc2c2 911 .linear_ranges = bd71837_buck6_volts,
494edd26 912 .n_linear_ranges =
a4bfc2c2 913 ARRAY_SIZE(bd71837_buck6_volts),
494edd26
MV		 914 .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
915 .vsel_mask = BD71837_BUCK6_MASK,
916 .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
917 .enable_mask = BD718XX_BUCK_EN,
918 .owner = THIS_MODULE,
919 },
920 .init = {
921 .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
922 .mask = BD718XX_BUCK_SEL,
923 .val = BD718XX_BUCK_SEL,
924 },
ba08799e
MV		 925 },
926 {
494edd26
MV		 927 .desc = {
928 .name = "buck7",
929 .of_match = of_match_ptr("BUCK7"),
930 .regulators_node = of_match_ptr("regulators"),
931 .id = BD718XX_BUCK7,
932 .ops = &bd718xx_buck_regulator_nolinear_ops,
933 .type = REGULATOR_VOLTAGE,
934 .volt_table = &bd718xx_3rd_nodvs_buck_volts[0],
935 .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts),
936 .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT,
937 .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK,
938 .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
939 .enable_mask = BD718XX_BUCK_EN,
940 .owner = THIS_MODULE,
941 },
942 .init = {
943 .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
944 .mask = BD718XX_BUCK_SEL,
945 .val = BD718XX_BUCK_SEL,
946 },
ba08799e
MV		 947 },
948 {
494edd26
MV		 949 .desc = {
950 .name = "buck8",
951 .of_match = of_match_ptr("BUCK8"),
952 .regulators_node = of_match_ptr("regulators"),
953 .id = BD718XX_BUCK8,
954 .ops = &bd718xx_buck_regulator_ops,
955 .type = REGULATOR_VOLTAGE,
dd2be639 956 .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM,
494edd26
MV		 957 .linear_ranges = bd718xx_4th_nodvs_buck_volts,
958 .n_linear_ranges =
959 ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts),
960 .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT,
961 .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK,
962 .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
963 .enable_mask = BD718XX_BUCK_EN,
964 .owner = THIS_MODULE,
965 },
966 .init = {
967 .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
968 .mask = BD718XX_BUCK_SEL,
969 .val = BD718XX_BUCK_SEL,
970 },
971 },
972 {
973 .desc = {
974 .name = "ldo1",
975 .of_match = of_match_ptr("LDO1"),
976 .regulators_node = of_match_ptr("regulators"),
977 .id = BD718XX_LDO1,
a4bfc2c2 978 .ops = &bd718xx_pickable_range_ldo_ops,
494edd26
MV		 979 .type = REGULATOR_VOLTAGE,
980 .n_voltages = BD718XX_LDO1_VOLTAGE_NUM,
981 .linear_ranges = bd718xx_ldo1_volts,
982 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts),
983 .vsel_reg = BD718XX_REG_LDO1_VOLT,
984 .vsel_mask = BD718XX_LDO1_MASK,
a4bfc2c2
MV		 985 .vsel_range_reg = BD718XX_REG_LDO1_VOLT,
986 .vsel_range_mask = BD718XX_LDO1_RANGE_MASK,
987 .linear_range_selectors = bd718xx_ldo1_volt_range_sel,
494edd26
MV		 988 .enable_reg = BD718XX_REG_LDO1_VOLT,
989 .enable_mask = BD718XX_LDO_EN,
990 .owner = THIS_MODULE,
991 },
992 .init = {
993 .reg = BD718XX_REG_LDO1_VOLT,
994 .mask = BD718XX_LDO_SEL,
995 .val = BD718XX_LDO_SEL,
996 },
997 },
998 {
999 .desc = {
1000 .name = "ldo2",
1001 .of_match = of_match_ptr("LDO2"),
1002 .regulators_node = of_match_ptr("regulators"),
1003 .id = BD718XX_LDO2,
1004 .ops = &bd718xx_ldo_regulator_nolinear_ops,
1005 .type = REGULATOR_VOLTAGE,
1006 .volt_table = &ldo_2_volts[0],
1007 .vsel_reg = BD718XX_REG_LDO2_VOLT,
1008 .vsel_mask = BD718XX_LDO2_MASK,
1009 .n_voltages = ARRAY_SIZE(ldo_2_volts),
1010 .enable_reg = BD718XX_REG_LDO2_VOLT,
1011 .enable_mask = BD718XX_LDO_EN,
1012 .owner = THIS_MODULE,
1013 },
1014 .init = {
1015 .reg = BD718XX_REG_LDO2_VOLT,
1016 .mask = BD718XX_LDO_SEL,
1017 .val = BD718XX_LDO_SEL,
1018 },
1019 },
1020 {
1021 .desc = {
1022 .name = "ldo3",
1023 .of_match = of_match_ptr("LDO3"),
1024 .regulators_node = of_match_ptr("regulators"),
1025 .id = BD718XX_LDO3,
1026 .ops = &bd718xx_ldo_regulator_ops,
1027 .type = REGULATOR_VOLTAGE,
1028 .n_voltages = BD718XX_LDO3_VOLTAGE_NUM,
1029 .linear_ranges = bd718xx_ldo3_volts,
1030 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts),
1031 .vsel_reg = BD718XX_REG_LDO3_VOLT,
1032 .vsel_mask = BD718XX_LDO3_MASK,
1033 .enable_reg = BD718XX_REG_LDO3_VOLT,
1034 .enable_mask = BD718XX_LDO_EN,
1035 .owner = THIS_MODULE,
1036 },
1037 .init = {
1038 .reg = BD718XX_REG_LDO3_VOLT,
1039 .mask = BD718XX_LDO_SEL,
1040 .val = BD718XX_LDO_SEL,
1041 },
1042 },
1043 {
1044 .desc = {
1045 .name = "ldo4",
1046 .of_match = of_match_ptr("LDO4"),
1047 .regulators_node = of_match_ptr("regulators"),
1048 .id = BD718XX_LDO4,
1049 .ops = &bd718xx_ldo_regulator_ops,
1050 .type = REGULATOR_VOLTAGE,
1051 .n_voltages = BD718XX_LDO4_VOLTAGE_NUM,
1052 .linear_ranges = bd718xx_ldo4_volts,
1053 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts),
1054 .vsel_reg = BD718XX_REG_LDO4_VOLT,
1055 .vsel_mask = BD718XX_LDO4_MASK,
1056 .enable_reg = BD718XX_REG_LDO4_VOLT,
1057 .enable_mask = BD718XX_LDO_EN,
1058 .owner = THIS_MODULE,
1059 },
1060 .init = {
1061 .reg = BD718XX_REG_LDO4_VOLT,
1062 .mask = BD718XX_LDO_SEL,
1063 .val = BD718XX_LDO_SEL,
1064 },
1065 },
1066 {
1067 .desc = {
1068 .name = "ldo5",
1069 .of_match = of_match_ptr("LDO5"),
1070 .regulators_node = of_match_ptr("regulators"),
1071 .id = BD718XX_LDO5,
1072 .ops = &bd718xx_ldo_regulator_ops,
1073 .type = REGULATOR_VOLTAGE,
a4bfc2c2
MV		 1074 .n_voltages = BD71837_LDO5_VOLTAGE_NUM,
1075 .linear_ranges = bd71837_ldo5_volts,
1076 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo5_volts),
494edd26
MV		 1077 /* LDO5 is supplied by buck6 */
1078 .supply_name = "buck6",
1079 .vsel_reg = BD718XX_REG_LDO5_VOLT,
1080 .vsel_mask = BD71837_LDO5_MASK,
1081 .enable_reg = BD718XX_REG_LDO5_VOLT,
1082 .enable_mask = BD718XX_LDO_EN,
1083 .owner = THIS_MODULE,
1084 },
1085 .init = {
1086 .reg = BD718XX_REG_LDO5_VOLT,
1087 .mask = BD718XX_LDO_SEL,
1088 .val = BD718XX_LDO_SEL,
1089 },
1090 .additional_inits = bd71837_ldo5_inits,
1091 .additional_init_amnt = ARRAY_SIZE(bd71837_ldo5_inits),
1092 },
1093 {
1094 .desc = {
1095 .name = "ldo6",
1096 .of_match = of_match_ptr("LDO6"),
1097 .regulators_node = of_match_ptr("regulators"),
1098 .id = BD718XX_LDO6,
1099 .ops = &bd718xx_ldo_regulator_ops,
1100 .type = REGULATOR_VOLTAGE,
1101 .n_voltages = BD718XX_LDO6_VOLTAGE_NUM,
1102 .linear_ranges = bd718xx_ldo6_volts,
1103 .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts),
1104 /* LDO6 is supplied by buck7 */
1105 .supply_name = "buck7",
1106 .vsel_reg = BD718XX_REG_LDO6_VOLT,
1107 .vsel_mask = BD718XX_LDO6_MASK,
1108 .enable_reg = BD718XX_REG_LDO6_VOLT,
1109 .enable_mask = BD718XX_LDO_EN,
1110 .owner = THIS_MODULE,
1111 },
1112 .init = {
1113 .reg = BD718XX_REG_LDO6_VOLT,
1114 .mask = BD718XX_LDO_SEL,
1115 .val = BD718XX_LDO_SEL,
1116 },
1117 .additional_inits = bd71837_ldo6_inits,
1118 .additional_init_amnt = ARRAY_SIZE(bd71837_ldo6_inits),
1119 },
1120 {
1121 .desc = {
1122 .name = "ldo7",
1123 .of_match = of_match_ptr("LDO7"),
1124 .regulators_node = of_match_ptr("regulators"),
1125 .id = BD718XX_LDO7,
1126 .ops = &bd718xx_ldo_regulator_ops,
1127 .type = REGULATOR_VOLTAGE,
1128 .n_voltages = BD71837_LDO7_VOLTAGE_NUM,
1129 .linear_ranges = bd71837_ldo7_volts,
1130 .n_linear_ranges = ARRAY_SIZE(bd71837_ldo7_volts),
1131 .vsel_reg = BD71837_REG_LDO7_VOLT,
1132 .vsel_mask = BD71837_LDO7_MASK,
1133 .enable_reg = BD71837_REG_LDO7_VOLT,
1134 .enable_mask = BD718XX_LDO_EN,
1135 .owner = THIS_MODULE,
1136 },
1137 .init = {
1138 .reg = BD71837_REG_LDO7_VOLT,
1139 .mask = BD718XX_LDO_SEL,
1140 .val = BD718XX_LDO_SEL,
1141 },
ba08799e
MV		 1142 },
1143};
1144
494edd26 1145struct bd718xx_pmic_inits {
de226ebd 1146 const struct bd718xx_regulator_data *r_datas;
494edd26 1147 unsigned int r_amount;
ba08799e
MV		 1148};
1149
dd2be639 1150static int bd718xx_probe(struct platform_device *pdev)
ba08799e 1151{
bcb047eb 1152 struct bd718xx *mfd;
ba08799e 1153 struct regulator_config config = { 0 };
2a6a7aac
MV		 1154 struct bd718xx_pmic_inits pmic_regulators[ROHM_CHIP_TYPE_AMOUNT] = {
1155 [ROHM_CHIP_TYPE_BD71837] = {
de226ebd 1156 .r_datas = bd71837_regulators,
494edd26
MV		 1157 .r_amount = ARRAY_SIZE(bd71837_regulators),
1158 },
2a6a7aac 1159 [ROHM_CHIP_TYPE_BD71847] = {
de226ebd 1160 .r_datas = bd71847_regulators,
494edd26
MV		 1161 .r_amount = ARRAY_SIZE(bd71847_regulators),
1162 },
ba08799e
MV		 1163 };
1164
494edd26 1165 int i, j, err;
049369d4 1166 bool use_snvs;
ba08799e 1167
bcb047eb
AL		 1168 mfd = dev_get_drvdata(pdev->dev.parent);
1169 if (!mfd) {
ba08799e
MV		 1170 dev_err(&pdev->dev, "No MFD driver data\n");
1171 err = -EINVAL;
1172 goto err;
1173 }
bcb047eb 1174
2a6a7aac
MV		 1175 if (mfd->chip.chip_type >= ROHM_CHIP_TYPE_AMOUNT ||
1176 !pmic_regulators[mfd->chip.chip_type].r_datas) {
494edd26
MV		 1177 dev_err(&pdev->dev, "Unsupported chip type\n");
1178 err = -EINVAL;
1179 goto err;
1180 }
1181
ba08799e 1182 /* Register LOCK release */
2a6a7aac 1183 err = regmap_update_bits(mfd->chip.regmap, BD718XX_REG_REGLOCK,
ba08799e
MV		 1184 (REGLOCK_PWRSEQ | REGLOCK_VREG), 0);
1185 if (err) {
bcb047eb 1186 dev_err(&pdev->dev, "Failed to unlock PMIC (%d)\n", err);
ba08799e
MV		 1187 goto err;
1188 } else {
bcb047eb 1189 dev_dbg(&pdev->dev, "Unlocked lock register 0x%x\n",
494edd26 1190 BD718XX_REG_REGLOCK);
823f18f8
MV		 1191 }
1192
049369d4
MV		 1193 use_snvs = of_property_read_bool(pdev->dev.parent->of_node,
1194 "rohm,reset-snvs-powered");
1195
1196 /*
e770b18b
MV		 1197 * Change the next stage from poweroff to be READY instead of SNVS
1198 * for all reset types because OTP loading at READY will clear SEL
1199 * bit allowing HW defaults for power rails to be used
1200 */
049369d4 1201 if (!use_snvs) {
2a6a7aac
MV		 1202 err = regmap_update_bits(mfd->chip.regmap,
1203 BD718XX_REG_TRANS_COND1,
049369d4
MV		 1204 BD718XX_ON_REQ_POWEROFF_MASK |
1205 BD718XX_SWRESET_POWEROFF_MASK |
1206 BD718XX_WDOG_POWEROFF_MASK |
1207 BD718XX_KEY_L_POWEROFF_MASK,
1208 BD718XX_POWOFF_TO_RDY);
1209 if (err) {
1210 dev_err(&pdev->dev, "Failed to change reset target\n");
1211 goto err;
1212 } else {
1213 dev_dbg(&pdev->dev,
1214 "Changed all resets from SVNS to READY\n");
1215 }
e770b18b
MV		 1216 }
1217
2a6a7aac 1218 for (i = 0; i < pmic_regulators[mfd->chip.chip_type].r_amount; i++) {
ba08799e 1219
494edd26 1220 const struct regulator_desc *desc;
ba08799e 1221 struct regulator_dev *rdev;
494edd26 1222 const struct bd718xx_regulator_data *r;
ba08799e 1223
2a6a7aac 1224 r = &pmic_regulators[mfd->chip.chip_type].r_datas[i];
494edd26 1225 desc = &r->desc;
ba08799e 1226
ba08799e 1227 config.dev = pdev->dev.parent;
2a6a7aac 1228 config.regmap = mfd->chip.regmap;
ba08799e
MV		 1229
1230 rdev = devm_regulator_register(&pdev->dev, desc, &config);
1231 if (IS_ERR(rdev)) {
bcb047eb 1232 dev_err(&pdev->dev,
ba08799e
MV		 1233 "failed to register %s regulator\n",
1234 desc->name);
1235 err = PTR_ERR(rdev);
1236 goto err;
1237 }
049369d4
MV		 1238
1239 /*
1240 * Regulator register gets the regulator constraints and
ba08799e
MV		 1241 * applies them (set_machine_constraints). This should have
1242 * turned the control register(s) to correct values and we
1243 * can now switch the control from PMIC state machine to the
1244 * register interface
049369d4
MV		 1245 *
1246 * At poweroff transition PMIC HW disables EN bit for
1247 * regulators but leaves SEL bit untouched. So if state
1248 * transition from POWEROFF is done to SNVS - then all power
1249 * rails controlled by SW (having SEL bit set) stay disabled
1250 * as EN is cleared. This will result boot failure if any
1251 * crucial systems are powered by these rails. We don't
1252 * enable SW control for crucial regulators if snvs state is
1253 * used
ba08799e 1254 */
049369d4
MV		 1255 if (!use_snvs || !rdev->constraints->always_on ||
1256 !rdev->constraints->boot_on) {
2a6a7aac 1257 err = regmap_update_bits(mfd->chip.regmap, r->init.reg,
049369d4
MV		 1258 r->init.mask, r->init.val);
1259 if (err) {
1260 dev_err(&pdev->dev,
1261 "Failed to take control for (%s)\n",
1262 desc->name);
1263 goto err;
1264 }
ba08799e 1265 }
494edd26 1266 for (j = 0; j < r->additional_init_amnt; j++) {
2a6a7aac 1267 err = regmap_update_bits(mfd->chip.regmap,
494edd26
MV		 1268 r->additional_inits[j].reg,
1269 r->additional_inits[j].mask,
1270 r->additional_inits[j].val);
1271 if (err) {
bcb047eb 1272 dev_err(&pdev->dev,
494edd26
MV		 1273 "Buck (%s) initialization failed\n",
1274 desc->name);
1275 goto err;
1276 }
1277 }
ba08799e
MV		 1278 }
1279
ba08799e
MV		 1280err:
1281 return err;
1282}
1283
dd2be639 1284static struct platform_driver bd718xx_regulator = {
ba08799e 1285 .driver = {
494edd26 1286 .name = "bd718xx-pmic",
ba08799e 1287 },
dd2be639 1288 .probe = bd718xx_probe,
ba08799e
MV		 1289};
1290
dd2be639 1291module_platform_driver(bd718xx_regulator);
ba08799e
MV		 1292
1293MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
dd2be639 1294MODULE_DESCRIPTION("BD71837/BD71847 voltage regulator driver");
ba08799e 1295MODULE_LICENSE("GPL");
95bddd8b 1296MODULE_ALIAS("platform:bd718xx-pmic");
Linux 6.x block layer and io_uring tree(s)