1 // SPDX-License-Identifier: GPL-2.0-only
2 // Copyright (C) 2019 ROHM Semiconductors
3 // bd71828-regulator.c ROHM BD71828GW-DS1 regulator driver
4 //
5
6 #include <linux/cleanup.h>
7 #include <linux/delay.h>
8 #include <linux/err.h>
9 #include <linux/interrupt.h>
10 #include <linux/kernel.h>
11 #include <linux/mfd/rohm-bd71828.h>
12 #include <linux/mfd/rohm-bd72720.h>
13 #include <linux/module.h>
14 #include <linux/of.h>
15 #include <linux/platform_device.h>
16 #include <linux/regmap.h>
17 #include <linux/regulator/driver.h>
18 #include <linux/regulator/machine.h>
19 #include <linux/regulator/of_regulator.h>
20
21 #define BD72720_MASK_LDON_HEAD GENMASK(2, 0)
22 struct reg_init {
23 unsigned int reg;
24 unsigned int mask;
25 unsigned int val;
26 };
27 struct bd71828_regulator_data {
28 struct regulator_desc desc;
29 const struct rohm_dvs_config dvs;
30 const struct reg_init *reg_inits;
31 int reg_init_amnt;
32 };
33
34 static const struct reg_init bd71828_buck1_inits[] = {
35 /*
36 * DVS Buck voltages can be changed by register values or via GPIO.
37 * Use register accesses by default.
38 */
39 {
40 .reg = BD71828_REG_PS_CTRL_1,
41 .mask = BD71828_MASK_DVS_BUCK1_CTRL,
42 .val = BD71828_DVS_BUCK1_CTRL_I2C,
43 },
44 };
45
46 static const struct reg_init bd71828_buck2_inits[] = {
47 {
48 .reg = BD71828_REG_PS_CTRL_1,
49 .mask = BD71828_MASK_DVS_BUCK2_CTRL,
50 .val = BD71828_DVS_BUCK2_CTRL_I2C,
51 },
52 };
53
54 static const struct reg_init bd71828_buck6_inits[] = {
55 {
56 .reg = BD71828_REG_PS_CTRL_1,
57 .mask = BD71828_MASK_DVS_BUCK6_CTRL,
58 .val = BD71828_DVS_BUCK6_CTRL_I2C,
59 },
60 };
61
62 static const struct reg_init bd71828_buck7_inits[] = {
63 {
64 .reg = BD71828_REG_PS_CTRL_1,
65 .mask = BD71828_MASK_DVS_BUCK7_CTRL,
66 .val = BD71828_DVS_BUCK7_CTRL_I2C,
67 },
68 };
69
70 #define BD72720_MASK_DVS_BUCK1_CTRL BIT(4)
71 #define BD72720_MASK_DVS_LDO1_CTRL BIT(5)
72
73 static const struct reg_init bd72720_buck1_inits[] = {
74 {
75 .reg = BD72720_REG_PS_CTRL_2,
76 .mask = BD72720_MASK_DVS_BUCK1_CTRL,
77 .val = 0, /* Disable "run-level" control */
78 },
79 };
80
81 static const struct reg_init bd72720_ldo1_inits[] = {
82 {
83 .reg = BD72720_REG_PS_CTRL_2,
84 .mask = BD72720_MASK_DVS_LDO1_CTRL,
85 .val = 0, /* Disable "run-level" control */
86 },
87 };
88
89 /* BD71828 Buck voltages */
90 static const struct linear_range bd71828_buck1267_volts[] = {
91 REGULATOR_LINEAR_RANGE(500000, 0x00, 0xef, 6250),
92 REGULATOR_LINEAR_RANGE(2000000, 0xf0, 0xff, 0),
93 };
94
95 static const struct linear_range bd71828_buck3_volts[] = {
96 REGULATOR_LINEAR_RANGE(1200000, 0x00, 0x0f, 50000),
97 REGULATOR_LINEAR_RANGE(2000000, 0x10, 0x1f, 0),
98 };
99
100 static const struct linear_range bd71828_buck4_volts[] = {
101 REGULATOR_LINEAR_RANGE(1000000, 0x00, 0x1f, 25000),
102 REGULATOR_LINEAR_RANGE(1800000, 0x20, 0x3f, 0),
103 };
104
105 static const struct linear_range bd71828_buck5_volts[] = {
106 REGULATOR_LINEAR_RANGE(2500000, 0x00, 0x0f, 50000),
107 REGULATOR_LINEAR_RANGE(3300000, 0x10, 0x1f, 0),
108 };
109
110 /* BD71828 LDO voltages */
111 static const struct linear_range bd71828_ldo_volts[] = {
112 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x31, 50000),
113 REGULATOR_LINEAR_RANGE(3300000, 0x32, 0x3f, 0),
114 };
115
116 /* BD72720 Buck voltages */
117 static const struct linear_range bd72720_buck1234_volts[] = {
118 REGULATOR_LINEAR_RANGE(500000, 0x00, 0xc0, 6250),
119 REGULATOR_LINEAR_RANGE(1700000, 0xc1, 0xff, 0),
120 };
121
122 static const struct linear_range bd72720_buck589_volts[] = {
123 REGULATOR_LINEAR_RANGE(500000, 0x00, 0x78, 10000),
124 REGULATOR_LINEAR_RANGE(1700000, 0x79, 0xff, 0),
125 };
126
127 static const struct linear_range bd72720_buck67_volts[] = {
128 REGULATOR_LINEAR_RANGE(1500000, 0x00, 0xb4, 10000),
129 REGULATOR_LINEAR_RANGE(3300000, 0xb5, 0xff, 0),
130 };
131
132 /*
133 * The BUCK10 on BD72720 has two modes of operation, depending on a LDON_HEAD
134 * setting. When LDON_HEAD is 0x0, the behaviour is as with other bucks, eg.
135 * voltage can be set to a values indicated below using the VSEL register.
136 *
137 * However, when LDON_HEAD is set to 0x1 ... 0x7, BUCK 10 voltage is, according
138 * to the data-sheet, "automatically adjusted following LDON_HEAD setting and
139 * clamped to BUCK10_VID setting".
140 *
141 * Again, reading the data-sheet shows a "typical connection" where the BUCK10
142 * is used to supply the LDOs 1-4. My assumption is that in practice, this
143 * means that the BUCK10 voltage will be adjusted based on the maximum output
144 * of the LDO 1-4 (to minimize power loss). This makes sense.
145 *
146 * Auto-adjusting regulators aren't something I really like to model in the
147 * driver though - and, if the auto-adjustment works as intended, then there
148 * should really be no need to software to care about the buck10 voltages.
149 * If enable/disable control is still needed, we can implement buck10 as a
150 * regulator with only the enable/disable ops - and device-tree can be used
151 * to model the supply-relations. I believe this could allow the regulator
152 * framework to automagically disable the BUCK10 if all LDOs that are being
153 * supplied by it are disabled.
154 */
155 static const struct linear_range bd72720_buck10_volts[] = {
156 REGULATOR_LINEAR_RANGE(500000, 0x00, 0xc0, 6250),
157 REGULATOR_LINEAR_RANGE(1700000, 0xc1, 0xff, 0),
158 };
159
160 /* BD72720 LDO voltages */
161 static const struct linear_range bd72720_ldo1234_volts[] = {
162 REGULATOR_LINEAR_RANGE(500000, 0x00, 0x50, 6250),
163 REGULATOR_LINEAR_RANGE(1000000, 0x51, 0x7f, 0),
164 };
165
166 static const struct linear_range bd72720_ldo57891011_volts[] = {
167 REGULATOR_LINEAR_RANGE(750000, 0x00, 0xff, 10000),
168 };
169
170 static const struct linear_range bd72720_ldo6_volts[] = {
171 REGULATOR_LINEAR_RANGE(600000, 0x00, 0x78, 10000),
172 REGULATOR_LINEAR_RANGE(1800000, 0x79, 0x7f, 0),
173 };
174
175 static const unsigned int bd71828_ramp_delay[] = { 2500, 5000, 10000, 20000 };
176
177 /*
178 * BD72720 supports setting both the ramp-up and ramp-down values
179 * separately. Do we need to support ramp-down setting?
180 */
181 static const unsigned int bd72720_ramp_delay[] = { 5000, 7500, 10000, 12500 };
182
buck_set_hw_dvs_levels(struct device_node * np,const struct regulator_desc * desc,struct regulator_config * cfg)183 static int buck_set_hw_dvs_levels(struct device_node *np,
184 const struct regulator_desc *desc,
185 struct regulator_config *cfg)
186 {
187 const struct bd71828_regulator_data *data;
188
189 data = container_of_const(desc, struct bd71828_regulator_data, desc);
190
191 return rohm_regulator_set_dvs_levels(&data->dvs, np, desc, cfg->regmap);
192 }
193
bd71828_ldo6_parse_dt(struct device_node * np,const struct regulator_desc * desc,struct regulator_config * cfg)194 static int bd71828_ldo6_parse_dt(struct device_node *np,
195 const struct regulator_desc *desc,
196 struct regulator_config *cfg)
197 {
198 int ret, i;
199 uint32_t uv = 0;
200 unsigned int en;
201 struct regmap *regmap = cfg->regmap;
202 static const char * const props[] = { "rohm,dvs-run-voltage",
203 "rohm,dvs-idle-voltage",
204 "rohm,dvs-suspend-voltage",
205 "rohm,dvs-lpsr-voltage" };
206 unsigned int mask[] = { BD71828_MASK_RUN_EN, BD71828_MASK_IDLE_EN,
207 BD71828_MASK_SUSP_EN, BD71828_MASK_LPSR_EN };
208
209 for (i = 0; i < ARRAY_SIZE(props); i++) {
210 ret = of_property_read_u32(np, props[i], &uv);
211 if (ret) {
212 if (ret != -EINVAL)
213 return ret;
214 continue;
215 }
216 if (uv)
217 en = 0xffffffff;
218 else
219 en = 0;
220
221 ret = regmap_update_bits(regmap, desc->enable_reg, mask[i], en);
222 if (ret)
223 return ret;
224 }
225 return 0;
226 }
227
228 static const struct regulator_ops bd71828_buck_ops = {
229 .enable = regulator_enable_regmap,
230 .disable = regulator_disable_regmap,
231 .is_enabled = regulator_is_enabled_regmap,
232 .list_voltage = regulator_list_voltage_linear_range,
233 .set_voltage_sel = regulator_set_voltage_sel_regmap,
234 .get_voltage_sel = regulator_get_voltage_sel_regmap,
235 };
236
237 static const struct regulator_ops bd71828_dvs_buck_ops = {
238 .enable = regulator_enable_regmap,
239 .disable = regulator_disable_regmap,
240 .is_enabled = regulator_is_enabled_regmap,
241 .list_voltage = regulator_list_voltage_linear_range,
242 .set_voltage_sel = regulator_set_voltage_sel_regmap,
243 .get_voltage_sel = regulator_get_voltage_sel_regmap,
244 .set_voltage_time_sel = regulator_set_voltage_time_sel,
245 .set_ramp_delay = regulator_set_ramp_delay_regmap,
246 };
247
248 static const struct regulator_ops bd71828_ldo_ops = {
249 .enable = regulator_enable_regmap,
250 .disable = regulator_disable_regmap,
251 .is_enabled = regulator_is_enabled_regmap,
252 .list_voltage = regulator_list_voltage_linear_range,
253 .set_voltage_sel = regulator_set_voltage_sel_regmap,
254 .get_voltage_sel = regulator_get_voltage_sel_regmap,
255 };
256
257 static const struct regulator_ops bd71828_ldo6_ops = {
258 .enable = regulator_enable_regmap,
259 .disable = regulator_disable_regmap,
260 .is_enabled = regulator_is_enabled_regmap,
261 };
262
263 static const struct regulator_ops bd72720_regulator_ops = {
264 .enable = regulator_enable_regmap,
265 .disable = regulator_disable_regmap,
266 .is_enabled = regulator_is_enabled_regmap,
267 .list_voltage = regulator_list_voltage_linear_range,
268 .set_voltage_sel = regulator_set_voltage_sel_regmap,
269 .get_voltage_sel = regulator_get_voltage_sel_regmap,
270 .set_voltage_time_sel = regulator_set_voltage_time_sel,
271 .set_ramp_delay = regulator_set_ramp_delay_regmap,
272 };
273
274 static const struct regulator_ops bd72720_buck10_ldon_head_op = {
275 .enable = regulator_enable_regmap,
276 .disable = regulator_disable_regmap,
277 .is_enabled = regulator_is_enabled_regmap,
278 .set_ramp_delay = regulator_set_ramp_delay_regmap,
279 };
280
281 static const struct bd71828_regulator_data bd71828_rdata[] = {
282 {
283 .desc = {
284 .name = "buck1",
285 .of_match = of_match_ptr("BUCK1"),
286 .regulators_node = of_match_ptr("regulators"),
287 .id = BD71828_BUCK1,
288 .ops = &bd71828_dvs_buck_ops,
289 .type = REGULATOR_VOLTAGE,
290 .linear_ranges = bd71828_buck1267_volts,
291 .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
292 .n_voltages = BD71828_BUCK1267_VOLTS,
293 .enable_reg = BD71828_REG_BUCK1_EN,
294 .enable_mask = BD71828_MASK_RUN_EN,
295 .vsel_reg = BD71828_REG_BUCK1_VOLT,
296 .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
297 .ramp_delay_table = bd71828_ramp_delay,
298 .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
299 .ramp_reg = BD71828_REG_BUCK1_MODE,
300 .ramp_mask = BD71828_MASK_RAMP_DELAY,
301 .owner = THIS_MODULE,
302 .of_parse_cb = buck_set_hw_dvs_levels,
303 },
304 .dvs = {
305 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
306 ROHM_DVS_LEVEL_SUSPEND |
307 ROHM_DVS_LEVEL_LPSR,
308 .run_reg = BD71828_REG_BUCK1_VOLT,
309 .run_mask = BD71828_MASK_BUCK1267_VOLT,
310 .idle_reg = BD71828_REG_BUCK1_IDLE_VOLT,
311 .idle_mask = BD71828_MASK_BUCK1267_VOLT,
312 .idle_on_mask = BD71828_MASK_IDLE_EN,
313 .suspend_reg = BD71828_REG_BUCK1_SUSP_VOLT,
314 .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
315 .suspend_on_mask = BD71828_MASK_SUSP_EN,
316 /*
317 * LPSR voltage is same as SUSPEND voltage. Allow
318 * only enabling/disabling regulator for LPSR state
319 */
320 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
321 },
322 .reg_inits = bd71828_buck1_inits,
323 .reg_init_amnt = ARRAY_SIZE(bd71828_buck1_inits),
324 },
325 {
326 .desc = {
327 .name = "buck2",
328 .of_match = of_match_ptr("BUCK2"),
329 .regulators_node = of_match_ptr("regulators"),
330 .id = BD71828_BUCK2,
331 .ops = &bd71828_dvs_buck_ops,
332 .type = REGULATOR_VOLTAGE,
333 .linear_ranges = bd71828_buck1267_volts,
334 .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
335 .n_voltages = BD71828_BUCK1267_VOLTS,
336 .enable_reg = BD71828_REG_BUCK2_EN,
337 .enable_mask = BD71828_MASK_RUN_EN,
338 .vsel_reg = BD71828_REG_BUCK2_VOLT,
339 .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
340 .ramp_delay_table = bd71828_ramp_delay,
341 .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
342 .ramp_reg = BD71828_REG_BUCK2_MODE,
343 .ramp_mask = BD71828_MASK_RAMP_DELAY,
344 .owner = THIS_MODULE,
345 .of_parse_cb = buck_set_hw_dvs_levels,
346 },
347 .dvs = {
348 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
349 ROHM_DVS_LEVEL_SUSPEND |
350 ROHM_DVS_LEVEL_LPSR,
351 .run_reg = BD71828_REG_BUCK2_VOLT,
352 .run_mask = BD71828_MASK_BUCK1267_VOLT,
353 .idle_reg = BD71828_REG_BUCK2_IDLE_VOLT,
354 .idle_mask = BD71828_MASK_BUCK1267_VOLT,
355 .idle_on_mask = BD71828_MASK_IDLE_EN,
356 .suspend_reg = BD71828_REG_BUCK2_SUSP_VOLT,
357 .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
358 .suspend_on_mask = BD71828_MASK_SUSP_EN,
359 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
360 .lpsr_reg = BD71828_REG_BUCK2_SUSP_VOLT,
361 .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
362 },
363 .reg_inits = bd71828_buck2_inits,
364 .reg_init_amnt = ARRAY_SIZE(bd71828_buck2_inits),
365 },
366 {
367 .desc = {
368 .name = "buck3",
369 .of_match = of_match_ptr("BUCK3"),
370 .regulators_node = of_match_ptr("regulators"),
371 .id = BD71828_BUCK3,
372 .ops = &bd71828_buck_ops,
373 .type = REGULATOR_VOLTAGE,
374 .linear_ranges = bd71828_buck3_volts,
375 .n_linear_ranges = ARRAY_SIZE(bd71828_buck3_volts),
376 .n_voltages = BD71828_BUCK3_VOLTS,
377 .enable_reg = BD71828_REG_BUCK3_EN,
378 .enable_mask = BD71828_MASK_RUN_EN,
379 .vsel_reg = BD71828_REG_BUCK3_VOLT,
380 .vsel_mask = BD71828_MASK_BUCK3_VOLT,
381 .owner = THIS_MODULE,
382 .of_parse_cb = buck_set_hw_dvs_levels,
383 },
384 .dvs = {
385 /*
386 * BUCK3 only supports single voltage for all states.
387 * voltage can be individually enabled for each state
388 * though => allow setting all states to support
389 * enabling power rail on different states.
390 */
391 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
392 ROHM_DVS_LEVEL_SUSPEND |
393 ROHM_DVS_LEVEL_LPSR,
394 .run_reg = BD71828_REG_BUCK3_VOLT,
395 .run_mask = BD71828_MASK_BUCK3_VOLT,
396 .idle_on_mask = BD71828_MASK_IDLE_EN,
397 .suspend_on_mask = BD71828_MASK_SUSP_EN,
398 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
399 },
400 },
401 {
402 .desc = {
403 .name = "buck4",
404 .of_match = of_match_ptr("BUCK4"),
405 .regulators_node = of_match_ptr("regulators"),
406 .id = BD71828_BUCK4,
407 .ops = &bd71828_buck_ops,
408 .type = REGULATOR_VOLTAGE,
409 .linear_ranges = bd71828_buck4_volts,
410 .n_linear_ranges = ARRAY_SIZE(bd71828_buck4_volts),
411 .n_voltages = BD71828_BUCK4_VOLTS,
412 .enable_reg = BD71828_REG_BUCK4_EN,
413 .enable_mask = BD71828_MASK_RUN_EN,
414 .vsel_reg = BD71828_REG_BUCK4_VOLT,
415 .vsel_mask = BD71828_MASK_BUCK4_VOLT,
416 .owner = THIS_MODULE,
417 .of_parse_cb = buck_set_hw_dvs_levels,
418 },
419 .dvs = {
420 /*
421 * BUCK4 only supports single voltage for all states.
422 * voltage can be individually enabled for each state
423 * though => allow setting all states to support
424 * enabling power rail on different states.
425 */
426 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
427 ROHM_DVS_LEVEL_SUSPEND |
428 ROHM_DVS_LEVEL_LPSR,
429 .run_reg = BD71828_REG_BUCK4_VOLT,
430 .run_mask = BD71828_MASK_BUCK4_VOLT,
431 .idle_on_mask = BD71828_MASK_IDLE_EN,
432 .suspend_on_mask = BD71828_MASK_SUSP_EN,
433 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
434 },
435 },
436 {
437 .desc = {
438 .name = "buck5",
439 .of_match = of_match_ptr("BUCK5"),
440 .regulators_node = of_match_ptr("regulators"),
441 .id = BD71828_BUCK5,
442 .ops = &bd71828_buck_ops,
443 .type = REGULATOR_VOLTAGE,
444 .linear_ranges = bd71828_buck5_volts,
445 .n_linear_ranges = ARRAY_SIZE(bd71828_buck5_volts),
446 .n_voltages = BD71828_BUCK5_VOLTS,
447 .enable_reg = BD71828_REG_BUCK5_EN,
448 .enable_mask = BD71828_MASK_RUN_EN,
449 .vsel_reg = BD71828_REG_BUCK5_VOLT,
450 .vsel_mask = BD71828_MASK_BUCK5_VOLT,
451 .owner = THIS_MODULE,
452 .of_parse_cb = buck_set_hw_dvs_levels,
453 },
454 .dvs = {
455 /*
456 * BUCK5 only supports single voltage for all states.
457 * voltage can be individually enabled for each state
458 * though => allow setting all states to support
459 * enabling power rail on different states.
460 */
461 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
462 ROHM_DVS_LEVEL_SUSPEND |
463 ROHM_DVS_LEVEL_LPSR,
464 .run_reg = BD71828_REG_BUCK5_VOLT,
465 .run_mask = BD71828_MASK_BUCK5_VOLT,
466 .idle_on_mask = BD71828_MASK_IDLE_EN,
467 .suspend_on_mask = BD71828_MASK_SUSP_EN,
468 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
469 },
470 },
471 {
472 .desc = {
473 .name = "buck6",
474 .of_match = of_match_ptr("BUCK6"),
475 .regulators_node = of_match_ptr("regulators"),
476 .id = BD71828_BUCK6,
477 .ops = &bd71828_dvs_buck_ops,
478 .type = REGULATOR_VOLTAGE,
479 .linear_ranges = bd71828_buck1267_volts,
480 .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
481 .n_voltages = BD71828_BUCK1267_VOLTS,
482 .enable_reg = BD71828_REG_BUCK6_EN,
483 .enable_mask = BD71828_MASK_RUN_EN,
484 .vsel_reg = BD71828_REG_BUCK6_VOLT,
485 .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
486 .ramp_delay_table = bd71828_ramp_delay,
487 .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
488 .ramp_reg = BD71828_REG_BUCK6_MODE,
489 .ramp_mask = BD71828_MASK_RAMP_DELAY,
490 .owner = THIS_MODULE,
491 .of_parse_cb = buck_set_hw_dvs_levels,
492 },
493 .dvs = {
494 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
495 ROHM_DVS_LEVEL_SUSPEND |
496 ROHM_DVS_LEVEL_LPSR,
497 .run_reg = BD71828_REG_BUCK6_VOLT,
498 .run_mask = BD71828_MASK_BUCK1267_VOLT,
499 .idle_reg = BD71828_REG_BUCK6_IDLE_VOLT,
500 .idle_mask = BD71828_MASK_BUCK1267_VOLT,
501 .idle_on_mask = BD71828_MASK_IDLE_EN,
502 .suspend_reg = BD71828_REG_BUCK6_SUSP_VOLT,
503 .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
504 .suspend_on_mask = BD71828_MASK_SUSP_EN,
505 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
506 .lpsr_reg = BD71828_REG_BUCK6_SUSP_VOLT,
507 .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
508 },
509 .reg_inits = bd71828_buck6_inits,
510 .reg_init_amnt = ARRAY_SIZE(bd71828_buck6_inits),
511 },
512 {
513 .desc = {
514 .name = "buck7",
515 .of_match = of_match_ptr("BUCK7"),
516 .regulators_node = of_match_ptr("regulators"),
517 .id = BD71828_BUCK7,
518 .ops = &bd71828_dvs_buck_ops,
519 .type = REGULATOR_VOLTAGE,
520 .linear_ranges = bd71828_buck1267_volts,
521 .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
522 .n_voltages = BD71828_BUCK1267_VOLTS,
523 .enable_reg = BD71828_REG_BUCK7_EN,
524 .enable_mask = BD71828_MASK_RUN_EN,
525 .vsel_reg = BD71828_REG_BUCK7_VOLT,
526 .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
527 .ramp_delay_table = bd71828_ramp_delay,
528 .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
529 .ramp_reg = BD71828_REG_BUCK7_MODE,
530 .ramp_mask = BD71828_MASK_RAMP_DELAY,
531 .owner = THIS_MODULE,
532 .of_parse_cb = buck_set_hw_dvs_levels,
533 },
534 .dvs = {
535 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
536 ROHM_DVS_LEVEL_SUSPEND |
537 ROHM_DVS_LEVEL_LPSR,
538 .run_reg = BD71828_REG_BUCK7_VOLT,
539 .run_mask = BD71828_MASK_BUCK1267_VOLT,
540 .idle_reg = BD71828_REG_BUCK7_IDLE_VOLT,
541 .idle_mask = BD71828_MASK_BUCK1267_VOLT,
542 .idle_on_mask = BD71828_MASK_IDLE_EN,
543 .suspend_reg = BD71828_REG_BUCK7_SUSP_VOLT,
544 .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
545 .suspend_on_mask = BD71828_MASK_SUSP_EN,
546 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
547 .lpsr_reg = BD71828_REG_BUCK7_SUSP_VOLT,
548 .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
549 },
550 .reg_inits = bd71828_buck7_inits,
551 .reg_init_amnt = ARRAY_SIZE(bd71828_buck7_inits),
552 },
553 {
554 .desc = {
555 .name = "ldo1",
556 .of_match = of_match_ptr("LDO1"),
557 .regulators_node = of_match_ptr("regulators"),
558 .id = BD71828_LDO1,
559 .ops = &bd71828_ldo_ops,
560 .type = REGULATOR_VOLTAGE,
561 .linear_ranges = bd71828_ldo_volts,
562 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
563 .n_voltages = BD71828_LDO_VOLTS,
564 .enable_reg = BD71828_REG_LDO1_EN,
565 .enable_mask = BD71828_MASK_RUN_EN,
566 .vsel_reg = BD71828_REG_LDO1_VOLT,
567 .vsel_mask = BD71828_MASK_LDO_VOLT,
568 .owner = THIS_MODULE,
569 .of_parse_cb = buck_set_hw_dvs_levels,
570 },
571 .dvs = {
572 /*
573 * LDO1 only supports single voltage for all states.
574 * voltage can be individually enabled for each state
575 * though => allow setting all states to support
576 * enabling power rail on different states.
577 */
578 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
579 ROHM_DVS_LEVEL_SUSPEND |
580 ROHM_DVS_LEVEL_LPSR,
581 .run_reg = BD71828_REG_LDO1_VOLT,
582 .run_mask = BD71828_MASK_LDO_VOLT,
583 .idle_on_mask = BD71828_MASK_IDLE_EN,
584 .suspend_on_mask = BD71828_MASK_SUSP_EN,
585 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
586 },
587 }, {
588 .desc = {
589 .name = "ldo2",
590 .of_match = of_match_ptr("LDO2"),
591 .regulators_node = of_match_ptr("regulators"),
592 .id = BD71828_LDO2,
593 .ops = &bd71828_ldo_ops,
594 .type = REGULATOR_VOLTAGE,
595 .linear_ranges = bd71828_ldo_volts,
596 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
597 .n_voltages = BD71828_LDO_VOLTS,
598 .enable_reg = BD71828_REG_LDO2_EN,
599 .enable_mask = BD71828_MASK_RUN_EN,
600 .vsel_reg = BD71828_REG_LDO2_VOLT,
601 .vsel_mask = BD71828_MASK_LDO_VOLT,
602 .owner = THIS_MODULE,
603 .of_parse_cb = buck_set_hw_dvs_levels,
604 },
605 .dvs = {
606 /*
607 * LDO2 only supports single voltage for all states.
608 * voltage can be individually enabled for each state
609 * though => allow setting all states to support
610 * enabling power rail on different states.
611 */
612 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
613 ROHM_DVS_LEVEL_SUSPEND |
614 ROHM_DVS_LEVEL_LPSR,
615 .run_reg = BD71828_REG_LDO2_VOLT,
616 .run_mask = BD71828_MASK_LDO_VOLT,
617 .idle_on_mask = BD71828_MASK_IDLE_EN,
618 .suspend_on_mask = BD71828_MASK_SUSP_EN,
619 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
620 },
621 }, {
622 .desc = {
623 .name = "ldo3",
624 .of_match = of_match_ptr("LDO3"),
625 .regulators_node = of_match_ptr("regulators"),
626 .id = BD71828_LDO3,
627 .ops = &bd71828_ldo_ops,
628 .type = REGULATOR_VOLTAGE,
629 .linear_ranges = bd71828_ldo_volts,
630 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
631 .n_voltages = BD71828_LDO_VOLTS,
632 .enable_reg = BD71828_REG_LDO3_EN,
633 .enable_mask = BD71828_MASK_RUN_EN,
634 .vsel_reg = BD71828_REG_LDO3_VOLT,
635 .vsel_mask = BD71828_MASK_LDO_VOLT,
636 .owner = THIS_MODULE,
637 .of_parse_cb = buck_set_hw_dvs_levels,
638 },
639 .dvs = {
640 /*
641 * LDO3 only supports single voltage for all states.
642 * voltage can be individually enabled for each state
643 * though => allow setting all states to support
644 * enabling power rail on different states.
645 */
646 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
647 ROHM_DVS_LEVEL_SUSPEND |
648 ROHM_DVS_LEVEL_LPSR,
649 .run_reg = BD71828_REG_LDO3_VOLT,
650 .run_mask = BD71828_MASK_LDO_VOLT,
651 .idle_on_mask = BD71828_MASK_IDLE_EN,
652 .suspend_on_mask = BD71828_MASK_SUSP_EN,
653 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
654 },
655
656 }, {
657 .desc = {
658 .name = "ldo4",
659 .of_match = of_match_ptr("LDO4"),
660 .regulators_node = of_match_ptr("regulators"),
661 .id = BD71828_LDO4,
662 .ops = &bd71828_ldo_ops,
663 .type = REGULATOR_VOLTAGE,
664 .linear_ranges = bd71828_ldo_volts,
665 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
666 .n_voltages = BD71828_LDO_VOLTS,
667 .enable_reg = BD71828_REG_LDO4_EN,
668 .enable_mask = BD71828_MASK_RUN_EN,
669 .vsel_reg = BD71828_REG_LDO4_VOLT,
670 .vsel_mask = BD71828_MASK_LDO_VOLT,
671 .owner = THIS_MODULE,
672 .of_parse_cb = buck_set_hw_dvs_levels,
673 },
674 .dvs = {
675 /*
676 * LDO1 only supports single voltage for all states.
677 * voltage can be individually enabled for each state
678 * though => allow setting all states to support
679 * enabling power rail on different states.
680 */
681 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
682 ROHM_DVS_LEVEL_SUSPEND |
683 ROHM_DVS_LEVEL_LPSR,
684 .run_reg = BD71828_REG_LDO4_VOLT,
685 .run_mask = BD71828_MASK_LDO_VOLT,
686 .idle_on_mask = BD71828_MASK_IDLE_EN,
687 .suspend_on_mask = BD71828_MASK_SUSP_EN,
688 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
689 },
690 }, {
691 .desc = {
692 .name = "ldo5",
693 .of_match = of_match_ptr("LDO5"),
694 .regulators_node = of_match_ptr("regulators"),
695 .id = BD71828_LDO5,
696 .ops = &bd71828_ldo_ops,
697 .type = REGULATOR_VOLTAGE,
698 .linear_ranges = bd71828_ldo_volts,
699 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
700 .n_voltages = BD71828_LDO_VOLTS,
701 .enable_reg = BD71828_REG_LDO5_EN,
702 .enable_mask = BD71828_MASK_RUN_EN,
703 .vsel_reg = BD71828_REG_LDO5_VOLT,
704 .vsel_mask = BD71828_MASK_LDO_VOLT,
705 .of_parse_cb = buck_set_hw_dvs_levels,
706 .owner = THIS_MODULE,
707 },
708 /*
709 * LDO5 is special. It can choose vsel settings to be configured
710 * from 2 different registers (by GPIO).
711 *
712 * This driver supports only configuration where
713 * BD71828_REG_LDO5_VOLT_L is used.
714 */
715 .dvs = {
716 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
717 ROHM_DVS_LEVEL_SUSPEND |
718 ROHM_DVS_LEVEL_LPSR,
719 .run_reg = BD71828_REG_LDO5_VOLT,
720 .run_mask = BD71828_MASK_LDO_VOLT,
721 .idle_on_mask = BD71828_MASK_IDLE_EN,
722 .suspend_on_mask = BD71828_MASK_SUSP_EN,
723 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
724 },
725
726 }, {
727 .desc = {
728 .name = "ldo6",
729 .of_match = of_match_ptr("LDO6"),
730 .regulators_node = of_match_ptr("regulators"),
731 .id = BD71828_LDO6,
732 .ops = &bd71828_ldo6_ops,
733 .type = REGULATOR_VOLTAGE,
734 .fixed_uV = BD71828_LDO_6_VOLTAGE,
735 .n_voltages = 1,
736 .enable_reg = BD71828_REG_LDO6_EN,
737 .enable_mask = BD71828_MASK_RUN_EN,
738 .owner = THIS_MODULE,
739 /*
740 * LDO6 only supports enable/disable for all states.
741 * Voltage for LDO6 is fixed.
742 */
743 .of_parse_cb = bd71828_ldo6_parse_dt,
744 },
745 }, {
746 .desc = {
747 /* SNVS LDO in data-sheet */
748 .name = "ldo7",
749 .of_match = of_match_ptr("LDO7"),
750 .regulators_node = of_match_ptr("regulators"),
751 .id = BD71828_LDO_SNVS,
752 .ops = &bd71828_ldo_ops,
753 .type = REGULATOR_VOLTAGE,
754 .linear_ranges = bd71828_ldo_volts,
755 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
756 .n_voltages = BD71828_LDO_VOLTS,
757 .enable_reg = BD71828_REG_LDO7_EN,
758 .enable_mask = BD71828_MASK_RUN_EN,
759 .vsel_reg = BD71828_REG_LDO7_VOLT,
760 .vsel_mask = BD71828_MASK_LDO_VOLT,
761 .owner = THIS_MODULE,
762 .of_parse_cb = buck_set_hw_dvs_levels,
763 },
764 .dvs = {
765 /*
766 * LDO7 only supports single voltage for all states.
767 * voltage can be individually enabled for each state
768 * though => allow setting all states to support
769 * enabling power rail on different states.
770 */
771 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
772 ROHM_DVS_LEVEL_SUSPEND |
773 ROHM_DVS_LEVEL_LPSR,
774 .run_reg = BD71828_REG_LDO7_VOLT,
775 .idle_reg = BD71828_REG_LDO7_VOLT,
776 .suspend_reg = BD71828_REG_LDO7_VOLT,
777 .lpsr_reg = BD71828_REG_LDO7_VOLT,
778 .run_mask = BD71828_MASK_LDO_VOLT,
779 .idle_on_mask = BD71828_MASK_IDLE_EN,
780 .suspend_on_mask = BD71828_MASK_SUSP_EN,
781 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
782 },
783
784 },
785 };
786
787 #define BD72720_BUCK10_DESC_INDEX 9
788 #define BD72720_NUM_BUCK_VOLTS 0x100
789 #define BD72720_NUM_LDO_VOLTS 0x100
790 #define BD72720_NUM_LDO12346_VOLTS 0x80
791
792 static const struct bd71828_regulator_data bd72720_rdata[] = {
793 {
794 .desc = {
795 .name = "buck1",
796 .of_match = of_match_ptr("buck1"),
797 .regulators_node = of_match_ptr("regulators"),
798 .id = BD72720_BUCK1,
799 .type = REGULATOR_VOLTAGE,
800
801 /*
802 * The BD72720 BUCK1 and LDO1 support GPIO toggled
803 * sub-RUN states called RUN0, RUN1, RUN2 and RUN3.
804 * The "operating mode" (sub-RUN states or normal)
805 * can be changed by a register.
806 *
807 * When the sub-RUN states are used, the voltage and
808 * enable state depend on a state specific
809 * configuration. The voltage and enable configuration
810 * for BUCK1 and LDO1 can be defined for each sub-RUN
811 * state using BD72720_REG_[BUCK,LDO]1_VSEL_R[0,1,2,3]
812 * voltage selection registers and the bits
813 * BD72720_MASK_RUN_[0,1,2,3]_EN in the enable registers.
814 * The PMIC will change both the BUCK1 and LDO1 voltages
815 * to the states defined in these registers when
816 * "DVS GPIOs" are toggled.
817 *
818 * If RUN 0 .. RUN 4 states are to be used, the normal
819 * voltage configuration mechanisms do not apply
820 * and we should overwrite the ops and ignore the
821 * voltage setting/getting registers which are setup
822 * here. This is not supported for now. If you need
823 * this functionality, you may try merging functionality
824 * from a downstream driver:
825 * https://rohmsemiconductor.github.io/Linux-Kernel-PMIC-Drivers/BD72720/
826 */
827 .ops = &bd72720_regulator_ops,
828 .linear_ranges = bd72720_buck1234_volts,
829 .n_linear_ranges = ARRAY_SIZE(bd72720_buck1234_volts),
830 .n_voltages = BD72720_NUM_BUCK_VOLTS,
831 .enable_reg = BD72720_REG_BUCK1_ON,
832 .enable_mask = BD72720_MASK_RUN_B_EN,
833 .vsel_reg = BD72720_REG_BUCK1_VSEL_RB,
834 .vsel_mask = BD72720_MASK_BUCK_VSEL,
835
836 .ramp_delay_table = bd72720_ramp_delay,
837 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
838 .ramp_reg = BD72720_REG_BUCK1_MODE,
839 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
840 .owner = THIS_MODULE,
841 .of_parse_cb = buck_set_hw_dvs_levels,
842 },
843 .dvs = {
844 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
845 ROHM_DVS_LEVEL_SUSPEND |
846 ROHM_DVS_LEVEL_LPSR, /* Deep idle in data-sheet */
847 .run_reg = BD72720_REG_BUCK1_VSEL_RB,
848 .run_mask = BD72720_MASK_BUCK_VSEL,
849 .idle_reg = BD72720_REG_BUCK1_VSEL_I,
850 .idle_mask = BD72720_MASK_BUCK_VSEL,
851 .idle_on_mask = BD72720_MASK_IDLE_EN,
852 .suspend_reg = BD72720_REG_BUCK1_VSEL_S,
853 .suspend_mask = BD72720_MASK_BUCK_VSEL,
854 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
855 .lpsr_reg = BD72720_REG_BUCK1_VSEL_DI,
856 .lpsr_mask = BD72720_MASK_BUCK_VSEL,
857 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
858 },
859 .reg_inits = bd72720_buck1_inits,
860 .reg_init_amnt = ARRAY_SIZE(bd72720_buck1_inits),
861 }, {
862 .desc = {
863 .name = "buck2",
864 .of_match = of_match_ptr("buck2"),
865 .regulators_node = of_match_ptr("regulators"),
866 .id = BD72720_BUCK2,
867 .type = REGULATOR_VOLTAGE,
868 .ops = &bd72720_regulator_ops,
869 .linear_ranges = bd72720_buck1234_volts,
870 .n_linear_ranges = ARRAY_SIZE(bd72720_buck1234_volts),
871 .n_voltages = BD72720_NUM_BUCK_VOLTS,
872 .enable_reg = BD72720_REG_BUCK2_ON,
873 .enable_mask = BD72720_MASK_RUN_B_EN,
874 .vsel_reg = BD72720_REG_BUCK2_VSEL_R,
875 .vsel_mask = BD72720_MASK_BUCK_VSEL,
876
877 .ramp_delay_table = bd72720_ramp_delay,
878 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
879 .ramp_reg = BD72720_REG_BUCK2_MODE,
880 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
881 .owner = THIS_MODULE,
882 .of_parse_cb = buck_set_hw_dvs_levels,
883 },
884 .dvs = {
885 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
886 ROHM_DVS_LEVEL_SUSPEND |
887 ROHM_DVS_LEVEL_LPSR,
888 .run_reg = BD72720_REG_BUCK2_VSEL_R,
889 .run_mask = BD72720_MASK_BUCK_VSEL,
890 .idle_reg = BD72720_REG_BUCK2_VSEL_I,
891 .idle_mask = BD72720_MASK_BUCK_VSEL,
892 .idle_on_mask = BD72720_MASK_IDLE_EN,
893 .suspend_reg = BD72720_REG_BUCK2_VSEL_S,
894 .suspend_mask = BD72720_MASK_BUCK_VSEL,
895 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
896 .lpsr_reg = BD72720_REG_BUCK2_VSEL_DI,
897 .lpsr_mask = BD72720_MASK_BUCK_VSEL,
898 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
899 },
900 }, {
901 .desc = {
902 .name = "buck3",
903 .of_match = of_match_ptr("buck3"),
904 .regulators_node = of_match_ptr("regulators"),
905 .id = BD72720_BUCK3,
906 .type = REGULATOR_VOLTAGE,
907 .ops = &bd72720_regulator_ops,
908 .linear_ranges = bd72720_buck1234_volts,
909 .n_linear_ranges = ARRAY_SIZE(bd72720_buck1234_volts),
910 .n_voltages = BD72720_NUM_BUCK_VOLTS,
911 .enable_reg = BD72720_REG_BUCK3_ON,
912 .enable_mask = BD72720_MASK_RUN_B_EN,
913 .vsel_reg = BD72720_REG_BUCK3_VSEL_R,
914 .vsel_mask = BD72720_MASK_BUCK_VSEL,
915
916 .ramp_delay_table = bd72720_ramp_delay,
917 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
918 .ramp_reg = BD72720_REG_BUCK3_MODE,
919 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
920 .owner = THIS_MODULE,
921 .of_parse_cb = buck_set_hw_dvs_levels,
922 },
923 .dvs = {
924 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
925 ROHM_DVS_LEVEL_SUSPEND |
926 ROHM_DVS_LEVEL_LPSR,
927 .run_reg = BD72720_REG_BUCK3_VSEL_R,
928 .run_mask = BD72720_MASK_BUCK_VSEL,
929 .idle_reg = BD72720_REG_BUCK3_VSEL_I,
930 .idle_mask = BD72720_MASK_BUCK_VSEL,
931 .idle_on_mask = BD72720_MASK_IDLE_EN,
932 .suspend_reg = BD72720_REG_BUCK3_VSEL_S,
933 .suspend_mask = BD72720_MASK_BUCK_VSEL,
934 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
935 .lpsr_reg = BD72720_REG_BUCK3_VSEL_DI,
936 .lpsr_mask = BD72720_MASK_BUCK_VSEL,
937 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
938 },
939 }, {
940 .desc = {
941 .name = "buck4",
942 .of_match = of_match_ptr("buck4"),
943 .regulators_node = of_match_ptr("regulators"),
944 .id = BD72720_BUCK4,
945 .type = REGULATOR_VOLTAGE,
946 .ops = &bd72720_regulator_ops,
947 .linear_ranges = bd72720_buck1234_volts,
948 .n_linear_ranges = ARRAY_SIZE(bd72720_buck1234_volts),
949 .n_voltages = BD72720_NUM_BUCK_VOLTS,
950 .enable_reg = BD72720_REG_BUCK4_ON,
951 .enable_mask = BD72720_MASK_RUN_B_EN,
952 .vsel_reg = BD72720_REG_BUCK4_VSEL_R,
953 .vsel_mask = BD72720_MASK_BUCK_VSEL,
954
955 .ramp_delay_table = bd72720_ramp_delay,
956 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
957 .ramp_reg = BD72720_REG_BUCK4_MODE,
958 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
959 .owner = THIS_MODULE,
960 .of_parse_cb = buck_set_hw_dvs_levels,
961 },
962 .dvs = {
963 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
964 ROHM_DVS_LEVEL_SUSPEND |
965 ROHM_DVS_LEVEL_LPSR,
966 .run_reg = BD72720_REG_BUCK4_VSEL_R,
967 .run_mask = BD72720_MASK_BUCK_VSEL,
968 .idle_reg = BD72720_REG_BUCK4_VSEL_I,
969 .idle_mask = BD72720_MASK_BUCK_VSEL,
970 .idle_on_mask = BD72720_MASK_IDLE_EN,
971 .suspend_reg = BD72720_REG_BUCK4_VSEL_S,
972 .suspend_mask = BD72720_MASK_BUCK_VSEL,
973 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
974 .lpsr_reg = BD72720_REG_BUCK4_VSEL_DI,
975 .lpsr_mask = BD72720_MASK_BUCK_VSEL,
976 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
977 },
978 }, {
979 .desc = {
980 .name = "buck5",
981 .of_match = of_match_ptr("buck5"),
982 .regulators_node = of_match_ptr("regulators"),
983 .id = BD72720_BUCK5,
984 .type = REGULATOR_VOLTAGE,
985 .ops = &bd72720_regulator_ops,
986 .linear_ranges = bd72720_buck589_volts,
987 .n_linear_ranges = ARRAY_SIZE(bd72720_buck589_volts),
988 .n_voltages = BD72720_NUM_BUCK_VOLTS,
989 .enable_reg = BD72720_REG_BUCK5_ON,
990 .enable_mask = BD72720_MASK_RUN_B_EN,
991 .vsel_reg = BD72720_REG_BUCK5_VSEL,
992 .vsel_mask = BD72720_MASK_BUCK_VSEL,
993
994 .ramp_delay_table = bd72720_ramp_delay,
995 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
996 .ramp_reg = BD72720_REG_BUCK5_MODE,
997 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
998 .owner = THIS_MODULE,
999 .of_parse_cb = buck_set_hw_dvs_levels,
1000 },
1001 .dvs = {
1002 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1003 ROHM_DVS_LEVEL_SUSPEND |
1004 ROHM_DVS_LEVEL_LPSR,
1005 .run_reg = BD72720_REG_BUCK5_VSEL,
1006 .run_mask = BD72720_MASK_BUCK_VSEL,
1007 .idle_on_mask = BD72720_MASK_IDLE_EN,
1008 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1009 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1010 },
1011 }, {
1012 .desc = {
1013 .name = "buck6",
1014 .of_match = of_match_ptr("buck6"),
1015 .regulators_node = of_match_ptr("regulators"),
1016 .id = BD72720_BUCK6,
1017 .type = REGULATOR_VOLTAGE,
1018 .ops = &bd72720_regulator_ops,
1019 .linear_ranges = bd72720_buck67_volts,
1020 .n_linear_ranges = ARRAY_SIZE(bd72720_buck67_volts),
1021 .n_voltages = BD72720_NUM_BUCK_VOLTS,
1022 .enable_reg = BD72720_REG_BUCK6_ON,
1023 .enable_mask = BD72720_MASK_RUN_B_EN,
1024 .vsel_reg = BD72720_REG_BUCK6_VSEL,
1025 .vsel_mask = BD72720_MASK_BUCK_VSEL,
1026
1027 .ramp_delay_table = bd72720_ramp_delay,
1028 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
1029 .ramp_reg = BD72720_REG_BUCK6_MODE,
1030 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
1031 .owner = THIS_MODULE,
1032 .of_parse_cb = buck_set_hw_dvs_levels,
1033 },
1034 .dvs = {
1035 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1036 ROHM_DVS_LEVEL_SUSPEND |
1037 ROHM_DVS_LEVEL_LPSR,
1038 .run_reg = BD72720_REG_BUCK6_VSEL,
1039 .run_mask = BD72720_MASK_BUCK_VSEL,
1040 .idle_on_mask = BD72720_MASK_IDLE_EN,
1041 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1042 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1043 },
1044 }, {
1045 .desc = {
1046 .name = "buck7",
1047 .of_match = of_match_ptr("buck7"),
1048 .regulators_node = of_match_ptr("regulators"),
1049 .id = BD72720_BUCK7,
1050 .type = REGULATOR_VOLTAGE,
1051 .ops = &bd72720_regulator_ops,
1052 .linear_ranges = bd72720_buck67_volts,
1053 .n_linear_ranges = ARRAY_SIZE(bd72720_buck67_volts),
1054 .n_voltages = BD72720_NUM_BUCK_VOLTS,
1055 .enable_reg = BD72720_REG_BUCK7_ON,
1056 .enable_mask = BD72720_MASK_RUN_B_EN,
1057 .vsel_reg = BD72720_REG_BUCK7_VSEL,
1058 .vsel_mask = BD72720_MASK_BUCK_VSEL,
1059
1060 .ramp_delay_table = bd72720_ramp_delay,
1061 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
1062 .ramp_reg = BD72720_REG_BUCK7_MODE,
1063 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
1064 .owner = THIS_MODULE,
1065 .of_parse_cb = buck_set_hw_dvs_levels,
1066 },
1067 .dvs = {
1068 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1069 ROHM_DVS_LEVEL_SUSPEND |
1070 ROHM_DVS_LEVEL_LPSR,
1071 .run_reg = BD72720_REG_BUCK7_VSEL,
1072 .run_mask = BD72720_MASK_BUCK_VSEL,
1073 .idle_on_mask = BD72720_MASK_IDLE_EN,
1074 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1075 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1076 },
1077 }, {
1078 .desc = {
1079 .name = "buck8",
1080 .of_match = of_match_ptr("buck8"),
1081 .regulators_node = of_match_ptr("regulators"),
1082 .id = BD72720_BUCK8,
1083 .type = REGULATOR_VOLTAGE,
1084 .ops = &bd72720_regulator_ops,
1085 .linear_ranges = bd72720_buck589_volts,
1086 .n_linear_ranges = ARRAY_SIZE(bd72720_buck589_volts),
1087 .n_voltages = BD72720_NUM_BUCK_VOLTS,
1088 .enable_reg = BD72720_REG_BUCK8_ON,
1089 .enable_mask = BD72720_MASK_RUN_B_EN,
1090 .vsel_reg = BD72720_REG_BUCK8_VSEL,
1091 .vsel_mask = BD72720_MASK_BUCK_VSEL,
1092
1093 .ramp_delay_table = bd72720_ramp_delay,
1094 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
1095 .ramp_reg = BD72720_REG_BUCK8_MODE,
1096 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
1097 .owner = THIS_MODULE,
1098 .of_parse_cb = buck_set_hw_dvs_levels,
1099 },
1100 .dvs = {
1101 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1102 ROHM_DVS_LEVEL_SUSPEND |
1103 ROHM_DVS_LEVEL_LPSR,
1104 .run_reg = BD72720_REG_BUCK8_VSEL,
1105 .run_mask = BD72720_MASK_BUCK_VSEL,
1106 .idle_on_mask = BD72720_MASK_IDLE_EN,
1107 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1108 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1109 },
1110 }, {
1111 .desc = {
1112 .name = "buck9",
1113 .of_match = of_match_ptr("buck9"),
1114 .regulators_node = of_match_ptr("regulators"),
1115 .id = BD72720_BUCK9,
1116 .type = REGULATOR_VOLTAGE,
1117 .ops = &bd72720_regulator_ops,
1118 .linear_ranges = bd72720_buck589_volts,
1119 .n_linear_ranges = ARRAY_SIZE(bd72720_buck589_volts),
1120 .n_voltages = BD72720_NUM_BUCK_VOLTS,
1121 .enable_reg = BD72720_REG_BUCK9_ON,
1122 .enable_mask = BD72720_MASK_RUN_B_EN,
1123 .vsel_reg = BD72720_REG_BUCK9_VSEL,
1124 .vsel_mask = BD72720_MASK_BUCK_VSEL,
1125
1126 .ramp_delay_table = bd72720_ramp_delay,
1127 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
1128 .ramp_reg = BD72720_REG_BUCK9_MODE,
1129 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
1130 .owner = THIS_MODULE,
1131 .of_parse_cb = buck_set_hw_dvs_levels,
1132 },
1133 .dvs = {
1134 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1135 ROHM_DVS_LEVEL_SUSPEND |
1136 ROHM_DVS_LEVEL_LPSR,
1137 .run_reg = BD72720_REG_BUCK9_VSEL,
1138 .run_mask = BD72720_MASK_BUCK_VSEL,
1139 .idle_on_mask = BD72720_MASK_IDLE_EN,
1140 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1141 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1142 },
1143 }, {
1144 .desc = {
1145 .name = "buck10",
1146 .of_match = of_match_ptr("buck10"),
1147 .regulators_node = of_match_ptr("regulators"),
1148 .id = BD72720_BUCK10,
1149 .type = REGULATOR_VOLTAGE,
1150 .ops = &bd72720_regulator_ops,
1151 .linear_ranges = bd72720_buck10_volts,
1152 .n_linear_ranges = ARRAY_SIZE(bd72720_buck10_volts),
1153 .n_voltages = BD72720_NUM_BUCK_VOLTS,
1154 .enable_reg = BD72720_REG_BUCK10_ON,
1155 .enable_mask = BD72720_MASK_RUN_B_EN,
1156 .vsel_reg = BD72720_REG_BUCK10_VSEL,
1157 .vsel_mask = BD72720_MASK_BUCK_VSEL,
1158
1159 .ramp_delay_table = bd72720_ramp_delay,
1160 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
1161 .ramp_reg = BD72720_REG_BUCK10_MODE,
1162 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
1163 .owner = THIS_MODULE,
1164 .of_parse_cb = buck_set_hw_dvs_levels,
1165 },
1166 .dvs = {
1167 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1168 ROHM_DVS_LEVEL_SUSPEND |
1169 ROHM_DVS_LEVEL_LPSR,
1170 .run_reg = BD72720_REG_BUCK10_VSEL,
1171 .run_mask = BD72720_MASK_BUCK_VSEL,
1172 .idle_on_mask = BD72720_MASK_IDLE_EN,
1173 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1174 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1175 },
1176 }, {
1177 .desc = {
1178 .name = "ldo1",
1179 .of_match = of_match_ptr("ldo1"),
1180 .regulators_node = of_match_ptr("regulators"),
1181 .id = BD72720_LDO1,
1182 .type = REGULATOR_VOLTAGE,
1183 .ops = &bd72720_regulator_ops,
1184 .linear_ranges = bd72720_ldo1234_volts,
1185 .n_linear_ranges = ARRAY_SIZE(bd72720_ldo1234_volts),
1186 .n_voltages = BD72720_NUM_LDO12346_VOLTS,
1187 .enable_reg = BD72720_REG_LDO1_ON,
1188 .enable_mask = BD72720_MASK_RUN_B_EN,
1189 .vsel_reg = BD72720_REG_LDO1_VSEL_RB,
1190 .vsel_mask = BD72720_MASK_LDO12346_VSEL,
1191
1192 .ramp_delay_table = bd72720_ramp_delay,
1193 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
1194 .ramp_reg = BD72720_REG_LDO1_MODE1,
1195 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
1196 .owner = THIS_MODULE,
1197 .of_parse_cb = buck_set_hw_dvs_levels,
1198 },
1199 .dvs = {
1200 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1201 ROHM_DVS_LEVEL_SUSPEND |
1202 ROHM_DVS_LEVEL_LPSR,
1203 .run_reg = BD72720_REG_LDO1_VSEL_RB,
1204 .run_mask = BD72720_MASK_LDO12346_VSEL,
1205 .idle_reg = BD72720_REG_LDO1_VSEL_I,
1206 .idle_mask = BD72720_MASK_LDO12346_VSEL,
1207 .idle_on_mask = BD72720_MASK_IDLE_EN,
1208 .suspend_reg = BD72720_REG_LDO1_VSEL_S,
1209 .suspend_mask = BD72720_MASK_LDO12346_VSEL,
1210 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1211 .lpsr_reg = BD72720_REG_LDO1_VSEL_DI,
1212 .lpsr_mask = BD72720_MASK_LDO12346_VSEL,
1213 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1214 },
1215 .reg_inits = bd72720_ldo1_inits,
1216 .reg_init_amnt = ARRAY_SIZE(bd72720_ldo1_inits),
1217 }, {
1218 .desc = {
1219 .name = "ldo2",
1220 .of_match = of_match_ptr("ldo2"),
1221 .regulators_node = of_match_ptr("regulators"),
1222 .id = BD72720_LDO2,
1223 .type = REGULATOR_VOLTAGE,
1224 .ops = &bd72720_regulator_ops,
1225 .linear_ranges = bd72720_ldo1234_volts,
1226 .n_linear_ranges = ARRAY_SIZE(bd72720_ldo1234_volts),
1227 .n_voltages = BD72720_NUM_LDO12346_VOLTS,
1228 .enable_reg = BD72720_REG_LDO2_ON,
1229 .enable_mask = BD72720_MASK_RUN_B_EN,
1230 .vsel_reg = BD72720_REG_LDO2_VSEL_R,
1231 .vsel_mask = BD72720_MASK_LDO12346_VSEL,
1232
1233 .ramp_delay_table = bd72720_ramp_delay,
1234 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
1235 .ramp_reg = BD72720_REG_LDO2_MODE,
1236 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
1237 .owner = THIS_MODULE,
1238 .of_parse_cb = buck_set_hw_dvs_levels,
1239 },
1240 .dvs = {
1241 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1242 ROHM_DVS_LEVEL_SUSPEND |
1243 ROHM_DVS_LEVEL_LPSR,
1244 .run_reg = BD72720_REG_LDO2_VSEL_R,
1245 .run_mask = BD72720_MASK_LDO12346_VSEL,
1246 .idle_reg = BD72720_REG_LDO2_VSEL_I,
1247 .idle_mask = BD72720_MASK_LDO12346_VSEL,
1248 .idle_on_mask = BD72720_MASK_IDLE_EN,
1249 .suspend_reg = BD72720_REG_LDO2_VSEL_S,
1250 .suspend_mask = BD72720_MASK_LDO12346_VSEL,
1251 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1252 .lpsr_reg = BD72720_REG_LDO2_VSEL_DI,
1253 .lpsr_mask = BD72720_MASK_LDO12346_VSEL,
1254 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1255 },
1256 }, {
1257 .desc = {
1258 .name = "ldo3",
1259 .of_match = of_match_ptr("ldo3"),
1260 .regulators_node = of_match_ptr("regulators"),
1261 .id = BD72720_LDO3,
1262 .type = REGULATOR_VOLTAGE,
1263 .ops = &bd72720_regulator_ops,
1264 .linear_ranges = bd72720_ldo1234_volts,
1265 .n_linear_ranges = ARRAY_SIZE(bd72720_ldo1234_volts),
1266 .n_voltages = BD72720_NUM_LDO12346_VOLTS,
1267 .enable_reg = BD72720_REG_LDO3_ON,
1268 .enable_mask = BD72720_MASK_RUN_B_EN,
1269 .vsel_reg = BD72720_REG_LDO3_VSEL_R,
1270 .vsel_mask = BD72720_MASK_LDO12346_VSEL,
1271
1272 .ramp_delay_table = bd72720_ramp_delay,
1273 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
1274 .ramp_reg = BD72720_REG_LDO3_MODE,
1275 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
1276 .owner = THIS_MODULE,
1277 .of_parse_cb = buck_set_hw_dvs_levels,
1278 },
1279 .dvs = {
1280 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1281 ROHM_DVS_LEVEL_SUSPEND |
1282 ROHM_DVS_LEVEL_LPSR,
1283 .run_reg = BD72720_REG_LDO3_VSEL_R,
1284 .run_mask = BD72720_MASK_LDO12346_VSEL,
1285 .idle_reg = BD72720_REG_LDO3_VSEL_I,
1286 .idle_mask = BD72720_MASK_LDO12346_VSEL,
1287 .idle_on_mask = BD72720_MASK_IDLE_EN,
1288 .suspend_reg = BD72720_REG_LDO3_VSEL_S,
1289 .suspend_mask = BD72720_MASK_LDO12346_VSEL,
1290 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1291 .lpsr_reg = BD72720_REG_LDO3_VSEL_DI,
1292 .lpsr_mask = BD72720_MASK_LDO12346_VSEL,
1293 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1294 },
1295 }, {
1296 .desc = {
1297 .name = "ldo4",
1298 .of_match = of_match_ptr("ldo4"),
1299 .regulators_node = of_match_ptr("regulators"),
1300 .id = BD72720_LDO4,
1301 .type = REGULATOR_VOLTAGE,
1302 .ops = &bd72720_regulator_ops,
1303 .linear_ranges = bd72720_ldo1234_volts,
1304 .n_linear_ranges = ARRAY_SIZE(bd72720_ldo1234_volts),
1305 .n_voltages = BD72720_NUM_LDO12346_VOLTS,
1306 .enable_reg = BD72720_REG_LDO4_ON,
1307 .enable_mask = BD72720_MASK_RUN_B_EN,
1308 .vsel_reg = BD72720_REG_LDO4_VSEL_R,
1309 .vsel_mask = BD72720_MASK_LDO12346_VSEL,
1310
1311 .ramp_delay_table = bd72720_ramp_delay,
1312 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
1313 .ramp_reg = BD72720_REG_LDO4_MODE,
1314 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
1315 .owner = THIS_MODULE,
1316 .of_parse_cb = buck_set_hw_dvs_levels,
1317 },
1318 .dvs = {
1319 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1320 ROHM_DVS_LEVEL_SUSPEND |
1321 ROHM_DVS_LEVEL_LPSR,
1322 .run_reg = BD72720_REG_LDO4_VSEL_R,
1323 .run_mask = BD72720_MASK_LDO12346_VSEL,
1324 .idle_reg = BD72720_REG_LDO4_VSEL_I,
1325 .idle_mask = BD72720_MASK_LDO12346_VSEL,
1326 .idle_on_mask = BD72720_MASK_IDLE_EN,
1327 .suspend_reg = BD72720_REG_LDO4_VSEL_S,
1328 .suspend_mask = BD72720_MASK_LDO12346_VSEL,
1329 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1330 .lpsr_reg = BD72720_REG_LDO4_VSEL_DI,
1331 .lpsr_mask = BD72720_MASK_LDO12346_VSEL,
1332 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1333 },
1334 }, {
1335 .desc = {
1336 .name = "ldo5",
1337 .of_match = of_match_ptr("ldo5"),
1338 .regulators_node = of_match_ptr("regulators"),
1339 .id = BD72720_LDO5,
1340 .type = REGULATOR_VOLTAGE,
1341 .ops = &bd72720_regulator_ops,
1342 .linear_ranges = bd72720_ldo57891011_volts,
1343 .n_linear_ranges = ARRAY_SIZE(bd72720_ldo57891011_volts),
1344 .n_voltages = BD72720_NUM_LDO_VOLTS,
1345 .enable_reg = BD72720_REG_LDO5_ON,
1346 .enable_mask = BD72720_MASK_RUN_B_EN,
1347 .vsel_reg = BD72720_REG_LDO5_VSEL,
1348 .vsel_mask = BD72720_MASK_LDO_VSEL,
1349
1350 .ramp_delay_table = bd72720_ramp_delay,
1351 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
1352 .ramp_reg = BD72720_REG_LDO5_MODE,
1353 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
1354 .owner = THIS_MODULE,
1355 .of_parse_cb = buck_set_hw_dvs_levels,
1356 },
1357 .dvs = {
1358 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1359 ROHM_DVS_LEVEL_SUSPEND |
1360 ROHM_DVS_LEVEL_LPSR,
1361 .run_reg = BD72720_REG_LDO5_VSEL,
1362 .run_mask = BD72720_MASK_LDO_VSEL,
1363 .idle_on_mask = BD72720_MASK_IDLE_EN,
1364 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1365 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1366 },
1367 }, {
1368 .desc = {
1369 .name = "ldo6",
1370 .of_match = of_match_ptr("ldo6"),
1371 .regulators_node = of_match_ptr("regulators"),
1372 .id = BD72720_LDO6,
1373 .type = REGULATOR_VOLTAGE,
1374 .ops = &bd72720_regulator_ops,
1375 .linear_ranges = bd72720_ldo6_volts,
1376 .n_linear_ranges = ARRAY_SIZE(bd72720_ldo6_volts),
1377 .n_voltages = BD72720_NUM_LDO12346_VOLTS,
1378 .enable_reg = BD72720_REG_LDO6_ON,
1379 .enable_mask = BD72720_MASK_RUN_B_EN,
1380 .vsel_reg = BD72720_REG_LDO6_VSEL,
1381 .vsel_mask = BD72720_MASK_LDO12346_VSEL,
1382
1383 .ramp_delay_table = bd72720_ramp_delay,
1384 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
1385 .ramp_reg = BD72720_REG_LDO6_MODE,
1386 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
1387 .owner = THIS_MODULE,
1388 .of_parse_cb = buck_set_hw_dvs_levels,
1389 },
1390 .dvs = {
1391 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1392 ROHM_DVS_LEVEL_SUSPEND |
1393 ROHM_DVS_LEVEL_LPSR,
1394 .run_reg = BD72720_REG_LDO6_VSEL,
1395 .run_mask = BD72720_MASK_LDO12346_VSEL,
1396 .idle_on_mask = BD72720_MASK_IDLE_EN,
1397 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1398 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1399 },
1400 }, {
1401 .desc = {
1402 .name = "ldo7",
1403 .of_match = of_match_ptr("ldo7"),
1404 .regulators_node = of_match_ptr("regulators"),
1405 .id = BD72720_LDO7,
1406 .type = REGULATOR_VOLTAGE,
1407 .ops = &bd72720_regulator_ops,
1408 .linear_ranges = bd72720_ldo57891011_volts,
1409 .n_linear_ranges = ARRAY_SIZE(bd72720_ldo57891011_volts),
1410 .n_voltages = BD72720_NUM_LDO_VOLTS,
1411 .enable_reg = BD72720_REG_LDO7_ON,
1412 .enable_mask = BD72720_MASK_RUN_B_EN,
1413 .vsel_reg = BD72720_REG_LDO7_VSEL,
1414 .vsel_mask = BD72720_MASK_LDO_VSEL,
1415
1416 .ramp_delay_table = bd72720_ramp_delay,
1417 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
1418 .ramp_reg = BD72720_REG_LDO7_MODE,
1419 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
1420 .owner = THIS_MODULE,
1421 .of_parse_cb = buck_set_hw_dvs_levels,
1422 },
1423 .dvs = {
1424 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1425 ROHM_DVS_LEVEL_SUSPEND |
1426 ROHM_DVS_LEVEL_LPSR,
1427 .run_reg = BD72720_REG_LDO7_VSEL,
1428 .run_mask = BD72720_MASK_LDO_VSEL,
1429 .idle_on_mask = BD72720_MASK_IDLE_EN,
1430 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1431 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1432 },
1433 }, {
1434 .desc = {
1435 .name = "ldo8",
1436 .of_match = of_match_ptr("ldo8"),
1437 .regulators_node = of_match_ptr("regulators"),
1438 .id = BD72720_LDO8,
1439 .type = REGULATOR_VOLTAGE,
1440 .ops = &bd72720_regulator_ops,
1441 .linear_ranges = bd72720_ldo57891011_volts,
1442 .n_linear_ranges = ARRAY_SIZE(bd72720_ldo57891011_volts),
1443 .n_voltages = BD72720_NUM_LDO_VOLTS,
1444 .enable_reg = BD72720_REG_LDO8_ON,
1445 .enable_mask = BD72720_MASK_RUN_B_EN,
1446 .vsel_reg = BD72720_REG_LDO8_VSEL,
1447 .vsel_mask = BD72720_MASK_LDO_VSEL,
1448
1449 .ramp_delay_table = bd72720_ramp_delay,
1450 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
1451 .ramp_reg = BD72720_REG_LDO8_MODE,
1452 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
1453 .owner = THIS_MODULE,
1454 .of_parse_cb = buck_set_hw_dvs_levels,
1455 },
1456 .dvs = {
1457 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1458 ROHM_DVS_LEVEL_SUSPEND |
1459 ROHM_DVS_LEVEL_LPSR,
1460 .run_reg = BD72720_REG_LDO8_VSEL,
1461 .run_mask = BD72720_MASK_LDO_VSEL,
1462 .idle_on_mask = BD72720_MASK_IDLE_EN,
1463 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1464 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1465 },
1466 }, {
1467 .desc = {
1468 .name = "ldo9",
1469 .of_match = of_match_ptr("ldo9"),
1470 .regulators_node = of_match_ptr("regulators"),
1471 .id = BD72720_LDO9,
1472 .type = REGULATOR_VOLTAGE,
1473 .ops = &bd72720_regulator_ops,
1474 .linear_ranges = bd72720_ldo57891011_volts,
1475 .n_linear_ranges = ARRAY_SIZE(bd72720_ldo57891011_volts),
1476 .n_voltages = BD72720_NUM_LDO_VOLTS,
1477 .enable_reg = BD72720_REG_LDO9_ON,
1478 .enable_mask = BD72720_MASK_RUN_B_EN,
1479 .vsel_reg = BD72720_REG_LDO9_VSEL,
1480 .vsel_mask = BD72720_MASK_LDO_VSEL,
1481
1482 .ramp_delay_table = bd72720_ramp_delay,
1483 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
1484 .ramp_reg = BD72720_REG_LDO9_MODE,
1485 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
1486 .owner = THIS_MODULE,
1487 .of_parse_cb = buck_set_hw_dvs_levels,
1488 },
1489 .dvs = {
1490 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1491 ROHM_DVS_LEVEL_SUSPEND |
1492 ROHM_DVS_LEVEL_LPSR,
1493 .run_reg = BD72720_REG_LDO9_VSEL,
1494 .run_mask = BD72720_MASK_LDO_VSEL,
1495 .idle_on_mask = BD72720_MASK_IDLE_EN,
1496 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1497 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1498 },
1499 }, {
1500 .desc = {
1501 .name = "ldo10",
1502 .of_match = of_match_ptr("ldo10"),
1503 .regulators_node = of_match_ptr("regulators"),
1504 .id = BD72720_LDO10,
1505 .type = REGULATOR_VOLTAGE,
1506 .ops = &bd72720_regulator_ops,
1507 .linear_ranges = bd72720_ldo57891011_volts,
1508 .n_linear_ranges = ARRAY_SIZE(bd72720_ldo57891011_volts),
1509 .n_voltages = BD72720_NUM_LDO_VOLTS,
1510 .enable_reg = BD72720_REG_LDO10_ON,
1511 .enable_mask = BD72720_MASK_RUN_B_EN,
1512 .vsel_reg = BD72720_REG_LDO10_VSEL,
1513 .vsel_mask = BD72720_MASK_LDO_VSEL,
1514
1515 .ramp_delay_table = bd72720_ramp_delay,
1516 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
1517 .ramp_reg = BD72720_REG_LDO10_MODE,
1518 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
1519 .owner = THIS_MODULE,
1520 .of_parse_cb = buck_set_hw_dvs_levels,
1521 },
1522 .dvs = {
1523 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1524 ROHM_DVS_LEVEL_SUSPEND |
1525 ROHM_DVS_LEVEL_LPSR,
1526 .run_reg = BD72720_REG_LDO10_VSEL,
1527 .run_mask = BD72720_MASK_LDO_VSEL,
1528 .idle_on_mask = BD72720_MASK_IDLE_EN,
1529 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1530 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1531 },
1532 }, {
1533 .desc = {
1534 .name = "ldo11",
1535 .of_match = of_match_ptr("ldo11"),
1536 .regulators_node = of_match_ptr("regulators"),
1537 .id = BD72720_LDO11,
1538 .type = REGULATOR_VOLTAGE,
1539 .ops = &bd72720_regulator_ops,
1540 .linear_ranges = bd72720_ldo57891011_volts,
1541 .n_linear_ranges = ARRAY_SIZE(bd72720_ldo57891011_volts),
1542 .n_voltages = BD72720_NUM_LDO_VOLTS,
1543 .enable_reg = BD72720_REG_LDO11_ON,
1544 .enable_mask = BD72720_MASK_RUN_B_EN,
1545 .vsel_reg = BD72720_REG_LDO11_VSEL,
1546 .vsel_mask = BD72720_MASK_LDO_VSEL,
1547
1548 .ramp_delay_table = bd72720_ramp_delay,
1549 .n_ramp_values = ARRAY_SIZE(bd72720_ramp_delay),
1550 .ramp_reg = BD72720_REG_LDO11_MODE,
1551 .ramp_mask = BD72720_MASK_RAMP_UP_DELAY,
1552 .owner = THIS_MODULE,
1553 .of_parse_cb = buck_set_hw_dvs_levels,
1554 },
1555 .dvs = {
1556 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
1557 ROHM_DVS_LEVEL_SUSPEND |
1558 ROHM_DVS_LEVEL_LPSR,
1559 .run_reg = BD72720_REG_LDO11_VSEL,
1560 .run_mask = BD72720_MASK_LDO_VSEL,
1561 .idle_on_mask = BD72720_MASK_IDLE_EN,
1562 .suspend_on_mask = BD72720_MASK_SUSPEND_EN,
1563 .lpsr_on_mask = BD72720_MASK_DEEP_IDLE_EN,
1564 },
1565 },
1566 };
1567
bd72720_buck10_ldon_head_mode(struct device * dev,struct device_node * npreg,struct regmap * regmap,struct regulator_desc * buck10_desc)1568 static int bd72720_buck10_ldon_head_mode(struct device *dev,
1569 struct device_node *npreg,
1570 struct regmap *regmap,
1571 struct regulator_desc *buck10_desc)
1572 {
1573 struct device_node *np __free(device_node) =
1574 of_get_child_by_name(npreg, "buck10");
1575 uint32_t ldon_head;
1576 int ldon_val;
1577 int ret;
1578
1579 if (!np) {
1580 dev_err(dev, "failed to find buck10 regulator node\n");
1581 return -ENODEV;
1582 }
1583
1584 ret = of_property_read_u32(np, "rohm,ldon-head-microvolt", &ldon_head);
1585 if (ret == -EINVAL)
1586 return 0;
1587 if (ret)
1588 return ret;
1589
1590 /*
1591 * LDON_HEAD mode means the BUCK10 is used to supply LDOs 1-4 and
1592 * the BUCK 10 voltage is automatically set to follow LDO 1-4
1593 * settings. Thus the BUCK10 should not allow voltage [g/s]etting.
1594 */
1595 buck10_desc->ops = &bd72720_buck10_ldon_head_op;
1596
1597 ldon_val = ldon_head / 50000 + 1;
1598 if (ldon_head > 300000) {
1599 dev_warn(dev, "Unsupported LDON_HEAD, clamping to 300 mV\n");
1600 ldon_val = 7;
1601 }
1602
1603 return regmap_update_bits(regmap, BD72720_REG_LDO1_MODE2,
1604 BD72720_MASK_LDON_HEAD, ldon_val);
1605 }
1606
bd72720_dt_parse(struct device * dev,struct regulator_desc * buck10_desc,struct regmap * regmap)1607 static int bd72720_dt_parse(struct device *dev,
1608 struct regulator_desc *buck10_desc,
1609 struct regmap *regmap)
1610 {
1611 struct device_node *nproot __free(device_node) =
1612 of_get_child_by_name(dev->parent->of_node, "regulators");
1613
1614 if (!nproot) {
1615 dev_err(dev, "failed to find regulators node\n");
1616 return -ENODEV;
1617 }
1618
1619 return bd72720_buck10_ldon_head_mode(dev, nproot, regmap, buck10_desc);
1620 }
1621
bd71828_probe(struct platform_device * pdev)1622 static int bd71828_probe(struct platform_device *pdev)
1623 {
1624 int i, j, ret, num_regulators;
1625 struct regulator_config config = {
1626 .dev = pdev->dev.parent,
1627 };
1628 enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data;
1629 struct bd71828_regulator_data *rdata;
1630
1631 config.regmap = dev_get_regmap(pdev->dev.parent, NULL);
1632 if (!config.regmap)
1633 return -ENODEV;
1634
1635 switch (chip) {
1636 case ROHM_CHIP_TYPE_BD72720:
1637 rdata = devm_kmemdup(&pdev->dev, bd72720_rdata,
1638 sizeof(bd72720_rdata), GFP_KERNEL);
1639 if (!rdata)
1640 return -ENOMEM;
1641
1642 ret = bd72720_dt_parse(&pdev->dev, &rdata[BD72720_BUCK10_DESC_INDEX].desc,
1643 config.regmap);
1644 if (ret)
1645 return ret;
1646
1647 num_regulators = ARRAY_SIZE(bd72720_rdata);
1648 break;
1649
1650 case ROHM_CHIP_TYPE_BD71828:
1651 rdata = devm_kmemdup(&pdev->dev, bd71828_rdata,
1652 sizeof(bd71828_rdata), GFP_KERNEL);
1653 if (!rdata)
1654 return -ENOMEM;
1655
1656 num_regulators = ARRAY_SIZE(bd71828_rdata);
1657
1658 break;
1659 default:
1660 return dev_err_probe(&pdev->dev, -EINVAL,
1661 "Unsupported device\n");
1662 }
1663
1664 for (i = 0; i < num_regulators; i++) {
1665 struct regulator_dev *rdev;
1666 struct bd71828_regulator_data *rd;
1667
1668 rd = &rdata[i];
1669
1670 config.driver_data = rd;
1671 rdev = devm_regulator_register(&pdev->dev,
1672 &rd->desc, &config);
1673 if (IS_ERR(rdev))
1674 return dev_err_probe(&pdev->dev, PTR_ERR(rdev),
1675 "failed to register %s regulator\n",
1676 rd->desc.name);
1677
1678 for (j = 0; j < rd->reg_init_amnt; j++) {
1679 ret = regmap_update_bits(config.regmap,
1680 rd->reg_inits[j].reg,
1681 rd->reg_inits[j].mask,
1682 rd->reg_inits[j].val);
1683 if (ret)
1684 return dev_err_probe(&pdev->dev, ret,
1685 "regulator %s init failed\n",
1686 rd->desc.name);
1687 }
1688 }
1689 return 0;
1690 }
1691
1692 static const struct platform_device_id bd71828_pmic_id[] = {
1693 { .name = "bd71828-pmic", .driver_data = ROHM_CHIP_TYPE_BD71828 },
1694 { .name = "bd72720-pmic", .driver_data = ROHM_CHIP_TYPE_BD72720 },
1695 { }
1696 };
1697 MODULE_DEVICE_TABLE(platform, bd71828_pmic_id);
1698
1699 static struct platform_driver bd71828_regulator = {
1700 .driver = {
1701 .name = "bd71828-pmic",
1702 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
1703 },
1704 .probe = bd71828_probe,
1705 .id_table = bd71828_pmic_id,
1706 };
1707
1708 module_platform_driver(bd71828_regulator);
1709
1710 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
1711 MODULE_DESCRIPTION("BD71828 voltage regulator driver");
1712 MODULE_LICENSE("GPL");
1713