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/delay.h>
7 #include <linux/err.h>
8 #include <linux/interrupt.h>
9 #include <linux/kernel.h>
10 #include <linux/mfd/rohm-bd71828.h>
11 #include <linux/module.h>
12 #include <linux/of.h>
13 #include <linux/platform_device.h>
14 #include <linux/regmap.h>
15 #include <linux/regulator/driver.h>
16 #include <linux/regulator/machine.h>
17 #include <linux/regulator/of_regulator.h>
18
19 struct reg_init {
20 unsigned int reg;
21 unsigned int mask;
22 unsigned int val;
23 };
24 struct bd71828_regulator_data {
25 struct regulator_desc desc;
26 const struct rohm_dvs_config dvs;
27 const struct reg_init *reg_inits;
28 int reg_init_amnt;
29 };
30
31 static const struct reg_init buck1_inits[] = {
32 /*
33 * DVS Buck voltages can be changed by register values or via GPIO.
34 * Use register accesses by default.
35 */
36 {
37 .reg = BD71828_REG_PS_CTRL_1,
38 .mask = BD71828_MASK_DVS_BUCK1_CTRL,
39 .val = BD71828_DVS_BUCK1_CTRL_I2C,
40 },
41 };
42
43 static const struct reg_init buck2_inits[] = {
44 {
45 .reg = BD71828_REG_PS_CTRL_1,
46 .mask = BD71828_MASK_DVS_BUCK2_CTRL,
47 .val = BD71828_DVS_BUCK2_CTRL_I2C,
48 },
49 };
50
51 static const struct reg_init buck6_inits[] = {
52 {
53 .reg = BD71828_REG_PS_CTRL_1,
54 .mask = BD71828_MASK_DVS_BUCK6_CTRL,
55 .val = BD71828_DVS_BUCK6_CTRL_I2C,
56 },
57 };
58
59 static const struct reg_init buck7_inits[] = {
60 {
61 .reg = BD71828_REG_PS_CTRL_1,
62 .mask = BD71828_MASK_DVS_BUCK7_CTRL,
63 .val = BD71828_DVS_BUCK7_CTRL_I2C,
64 },
65 };
66
67 static const struct linear_range bd71828_buck1267_volts[] = {
68 REGULATOR_LINEAR_RANGE(500000, 0x00, 0xef, 6250),
69 REGULATOR_LINEAR_RANGE(2000000, 0xf0, 0xff, 0),
70 };
71
72 static const struct linear_range bd71828_buck3_volts[] = {
73 REGULATOR_LINEAR_RANGE(1200000, 0x00, 0x0f, 50000),
74 REGULATOR_LINEAR_RANGE(2000000, 0x10, 0x1f, 0),
75 };
76
77 static const struct linear_range bd71828_buck4_volts[] = {
78 REGULATOR_LINEAR_RANGE(1000000, 0x00, 0x1f, 25000),
79 REGULATOR_LINEAR_RANGE(1800000, 0x20, 0x3f, 0),
80 };
81
82 static const struct linear_range bd71828_buck5_volts[] = {
83 REGULATOR_LINEAR_RANGE(2500000, 0x00, 0x0f, 50000),
84 REGULATOR_LINEAR_RANGE(3300000, 0x10, 0x1f, 0),
85 };
86
87 static const struct linear_range bd71828_ldo_volts[] = {
88 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x31, 50000),
89 REGULATOR_LINEAR_RANGE(3300000, 0x32, 0x3f, 0),
90 };
91
92 static const unsigned int bd71828_ramp_delay[] = { 2500, 5000, 10000, 20000 };
93
buck_set_hw_dvs_levels(struct device_node * np,const struct regulator_desc * desc,struct regulator_config * cfg)94 static int buck_set_hw_dvs_levels(struct device_node *np,
95 const struct regulator_desc *desc,
96 struct regulator_config *cfg)
97 {
98 struct bd71828_regulator_data *data;
99
100 data = container_of(desc, struct bd71828_regulator_data, desc);
101
102 return rohm_regulator_set_dvs_levels(&data->dvs, np, desc, cfg->regmap);
103 }
104
ldo6_parse_dt(struct device_node * np,const struct regulator_desc * desc,struct regulator_config * cfg)105 static int ldo6_parse_dt(struct device_node *np,
106 const struct regulator_desc *desc,
107 struct regulator_config *cfg)
108 {
109 int ret, i;
110 uint32_t uv = 0;
111 unsigned int en;
112 struct regmap *regmap = cfg->regmap;
113 static const char * const props[] = { "rohm,dvs-run-voltage",
114 "rohm,dvs-idle-voltage",
115 "rohm,dvs-suspend-voltage",
116 "rohm,dvs-lpsr-voltage" };
117 unsigned int mask[] = { BD71828_MASK_RUN_EN, BD71828_MASK_IDLE_EN,
118 BD71828_MASK_SUSP_EN, BD71828_MASK_LPSR_EN };
119
120 for (i = 0; i < ARRAY_SIZE(props); i++) {
121 ret = of_property_read_u32(np, props[i], &uv);
122 if (ret) {
123 if (ret != -EINVAL)
124 return ret;
125 continue;
126 }
127 if (uv)
128 en = 0xffffffff;
129 else
130 en = 0;
131
132 ret = regmap_update_bits(regmap, desc->enable_reg, mask[i], en);
133 if (ret)
134 return ret;
135 }
136 return 0;
137 }
138
139 static const struct regulator_ops bd71828_buck_ops = {
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 };
147
148 static const struct regulator_ops bd71828_dvs_buck_ops = {
149 .enable = regulator_enable_regmap,
150 .disable = regulator_disable_regmap,
151 .is_enabled = regulator_is_enabled_regmap,
152 .list_voltage = regulator_list_voltage_linear_range,
153 .set_voltage_sel = regulator_set_voltage_sel_regmap,
154 .get_voltage_sel = regulator_get_voltage_sel_regmap,
155 .set_voltage_time_sel = regulator_set_voltage_time_sel,
156 .set_ramp_delay = regulator_set_ramp_delay_regmap,
157 };
158
159 static const struct regulator_ops bd71828_ldo_ops = {
160 .enable = regulator_enable_regmap,
161 .disable = regulator_disable_regmap,
162 .is_enabled = regulator_is_enabled_regmap,
163 .list_voltage = regulator_list_voltage_linear_range,
164 .set_voltage_sel = regulator_set_voltage_sel_regmap,
165 .get_voltage_sel = regulator_get_voltage_sel_regmap,
166 };
167
168 static const struct regulator_ops bd71828_ldo6_ops = {
169 .enable = regulator_enable_regmap,
170 .disable = regulator_disable_regmap,
171 .is_enabled = regulator_is_enabled_regmap,
172 };
173
174 static const struct bd71828_regulator_data bd71828_rdata[] = {
175 {
176 .desc = {
177 .name = "buck1",
178 .of_match = of_match_ptr("BUCK1"),
179 .regulators_node = of_match_ptr("regulators"),
180 .id = BD71828_BUCK1,
181 .ops = &bd71828_dvs_buck_ops,
182 .type = REGULATOR_VOLTAGE,
183 .linear_ranges = bd71828_buck1267_volts,
184 .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
185 .n_voltages = BD71828_BUCK1267_VOLTS,
186 .enable_reg = BD71828_REG_BUCK1_EN,
187 .enable_mask = BD71828_MASK_RUN_EN,
188 .vsel_reg = BD71828_REG_BUCK1_VOLT,
189 .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
190 .ramp_delay_table = bd71828_ramp_delay,
191 .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
192 .ramp_reg = BD71828_REG_BUCK1_MODE,
193 .ramp_mask = BD71828_MASK_RAMP_DELAY,
194 .owner = THIS_MODULE,
195 .of_parse_cb = buck_set_hw_dvs_levels,
196 },
197 .dvs = {
198 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
199 ROHM_DVS_LEVEL_SUSPEND |
200 ROHM_DVS_LEVEL_LPSR,
201 .run_reg = BD71828_REG_BUCK1_VOLT,
202 .run_mask = BD71828_MASK_BUCK1267_VOLT,
203 .idle_reg = BD71828_REG_BUCK1_IDLE_VOLT,
204 .idle_mask = BD71828_MASK_BUCK1267_VOLT,
205 .idle_on_mask = BD71828_MASK_IDLE_EN,
206 .suspend_reg = BD71828_REG_BUCK1_SUSP_VOLT,
207 .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
208 .suspend_on_mask = BD71828_MASK_SUSP_EN,
209 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
210 /*
211 * LPSR voltage is same as SUSPEND voltage. Allow
212 * setting it so that regulator can be set enabled at
213 * LPSR state
214 */
215 .lpsr_reg = BD71828_REG_BUCK1_SUSP_VOLT,
216 .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
217 },
218 .reg_inits = buck1_inits,
219 .reg_init_amnt = ARRAY_SIZE(buck1_inits),
220 },
221 {
222 .desc = {
223 .name = "buck2",
224 .of_match = of_match_ptr("BUCK2"),
225 .regulators_node = of_match_ptr("regulators"),
226 .id = BD71828_BUCK2,
227 .ops = &bd71828_dvs_buck_ops,
228 .type = REGULATOR_VOLTAGE,
229 .linear_ranges = bd71828_buck1267_volts,
230 .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
231 .n_voltages = BD71828_BUCK1267_VOLTS,
232 .enable_reg = BD71828_REG_BUCK2_EN,
233 .enable_mask = BD71828_MASK_RUN_EN,
234 .vsel_reg = BD71828_REG_BUCK2_VOLT,
235 .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
236 .ramp_delay_table = bd71828_ramp_delay,
237 .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
238 .ramp_reg = BD71828_REG_BUCK2_MODE,
239 .ramp_mask = BD71828_MASK_RAMP_DELAY,
240 .owner = THIS_MODULE,
241 .of_parse_cb = buck_set_hw_dvs_levels,
242 },
243 .dvs = {
244 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
245 ROHM_DVS_LEVEL_SUSPEND |
246 ROHM_DVS_LEVEL_LPSR,
247 .run_reg = BD71828_REG_BUCK2_VOLT,
248 .run_mask = BD71828_MASK_BUCK1267_VOLT,
249 .idle_reg = BD71828_REG_BUCK2_IDLE_VOLT,
250 .idle_mask = BD71828_MASK_BUCK1267_VOLT,
251 .idle_on_mask = BD71828_MASK_IDLE_EN,
252 .suspend_reg = BD71828_REG_BUCK2_SUSP_VOLT,
253 .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
254 .suspend_on_mask = BD71828_MASK_SUSP_EN,
255 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
256 .lpsr_reg = BD71828_REG_BUCK2_SUSP_VOLT,
257 .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
258 },
259 .reg_inits = buck2_inits,
260 .reg_init_amnt = ARRAY_SIZE(buck2_inits),
261 },
262 {
263 .desc = {
264 .name = "buck3",
265 .of_match = of_match_ptr("BUCK3"),
266 .regulators_node = of_match_ptr("regulators"),
267 .id = BD71828_BUCK3,
268 .ops = &bd71828_buck_ops,
269 .type = REGULATOR_VOLTAGE,
270 .linear_ranges = bd71828_buck3_volts,
271 .n_linear_ranges = ARRAY_SIZE(bd71828_buck3_volts),
272 .n_voltages = BD71828_BUCK3_VOLTS,
273 .enable_reg = BD71828_REG_BUCK3_EN,
274 .enable_mask = BD71828_MASK_RUN_EN,
275 .vsel_reg = BD71828_REG_BUCK3_VOLT,
276 .vsel_mask = BD71828_MASK_BUCK3_VOLT,
277 .owner = THIS_MODULE,
278 .of_parse_cb = buck_set_hw_dvs_levels,
279 },
280 .dvs = {
281 /*
282 * BUCK3 only supports single voltage for all states.
283 * voltage can be individually enabled for each state
284 * though => allow setting all states to support
285 * enabling power rail on different states.
286 */
287 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
288 ROHM_DVS_LEVEL_SUSPEND |
289 ROHM_DVS_LEVEL_LPSR,
290 .run_reg = BD71828_REG_BUCK3_VOLT,
291 .idle_reg = BD71828_REG_BUCK3_VOLT,
292 .suspend_reg = BD71828_REG_BUCK3_VOLT,
293 .lpsr_reg = BD71828_REG_BUCK3_VOLT,
294 .run_mask = BD71828_MASK_BUCK3_VOLT,
295 .idle_mask = BD71828_MASK_BUCK3_VOLT,
296 .suspend_mask = BD71828_MASK_BUCK3_VOLT,
297 .lpsr_mask = BD71828_MASK_BUCK3_VOLT,
298 .idle_on_mask = BD71828_MASK_IDLE_EN,
299 .suspend_on_mask = BD71828_MASK_SUSP_EN,
300 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
301 },
302 },
303 {
304 .desc = {
305 .name = "buck4",
306 .of_match = of_match_ptr("BUCK4"),
307 .regulators_node = of_match_ptr("regulators"),
308 .id = BD71828_BUCK4,
309 .ops = &bd71828_buck_ops,
310 .type = REGULATOR_VOLTAGE,
311 .linear_ranges = bd71828_buck4_volts,
312 .n_linear_ranges = ARRAY_SIZE(bd71828_buck4_volts),
313 .n_voltages = BD71828_BUCK4_VOLTS,
314 .enable_reg = BD71828_REG_BUCK4_EN,
315 .enable_mask = BD71828_MASK_RUN_EN,
316 .vsel_reg = BD71828_REG_BUCK4_VOLT,
317 .vsel_mask = BD71828_MASK_BUCK4_VOLT,
318 .owner = THIS_MODULE,
319 .of_parse_cb = buck_set_hw_dvs_levels,
320 },
321 .dvs = {
322 /*
323 * BUCK4 only supports single voltage for all states.
324 * voltage can be individually enabled for each state
325 * though => allow setting all states to support
326 * enabling power rail on different states.
327 */
328 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
329 ROHM_DVS_LEVEL_SUSPEND |
330 ROHM_DVS_LEVEL_LPSR,
331 .run_reg = BD71828_REG_BUCK4_VOLT,
332 .idle_reg = BD71828_REG_BUCK4_VOLT,
333 .suspend_reg = BD71828_REG_BUCK4_VOLT,
334 .lpsr_reg = BD71828_REG_BUCK4_VOLT,
335 .run_mask = BD71828_MASK_BUCK4_VOLT,
336 .idle_mask = BD71828_MASK_BUCK4_VOLT,
337 .suspend_mask = BD71828_MASK_BUCK4_VOLT,
338 .lpsr_mask = BD71828_MASK_BUCK4_VOLT,
339 .idle_on_mask = BD71828_MASK_IDLE_EN,
340 .suspend_on_mask = BD71828_MASK_SUSP_EN,
341 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
342 },
343 },
344 {
345 .desc = {
346 .name = "buck5",
347 .of_match = of_match_ptr("BUCK5"),
348 .regulators_node = of_match_ptr("regulators"),
349 .id = BD71828_BUCK5,
350 .ops = &bd71828_buck_ops,
351 .type = REGULATOR_VOLTAGE,
352 .linear_ranges = bd71828_buck5_volts,
353 .n_linear_ranges = ARRAY_SIZE(bd71828_buck5_volts),
354 .n_voltages = BD71828_BUCK5_VOLTS,
355 .enable_reg = BD71828_REG_BUCK5_EN,
356 .enable_mask = BD71828_MASK_RUN_EN,
357 .vsel_reg = BD71828_REG_BUCK5_VOLT,
358 .vsel_mask = BD71828_MASK_BUCK5_VOLT,
359 .owner = THIS_MODULE,
360 .of_parse_cb = buck_set_hw_dvs_levels,
361 },
362 .dvs = {
363 /*
364 * BUCK5 only supports single voltage for all states.
365 * voltage can be individually enabled for each state
366 * though => allow setting all states to support
367 * enabling power rail on different states.
368 */
369 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
370 ROHM_DVS_LEVEL_SUSPEND |
371 ROHM_DVS_LEVEL_LPSR,
372 .run_reg = BD71828_REG_BUCK5_VOLT,
373 .idle_reg = BD71828_REG_BUCK5_VOLT,
374 .suspend_reg = BD71828_REG_BUCK5_VOLT,
375 .lpsr_reg = BD71828_REG_BUCK5_VOLT,
376 .run_mask = BD71828_MASK_BUCK5_VOLT,
377 .idle_mask = BD71828_MASK_BUCK5_VOLT,
378 .suspend_mask = BD71828_MASK_BUCK5_VOLT,
379 .lpsr_mask = BD71828_MASK_BUCK5_VOLT,
380 .idle_on_mask = BD71828_MASK_IDLE_EN,
381 .suspend_on_mask = BD71828_MASK_SUSP_EN,
382 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
383 },
384 },
385 {
386 .desc = {
387 .name = "buck6",
388 .of_match = of_match_ptr("BUCK6"),
389 .regulators_node = of_match_ptr("regulators"),
390 .id = BD71828_BUCK6,
391 .ops = &bd71828_dvs_buck_ops,
392 .type = REGULATOR_VOLTAGE,
393 .linear_ranges = bd71828_buck1267_volts,
394 .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
395 .n_voltages = BD71828_BUCK1267_VOLTS,
396 .enable_reg = BD71828_REG_BUCK6_EN,
397 .enable_mask = BD71828_MASK_RUN_EN,
398 .vsel_reg = BD71828_REG_BUCK6_VOLT,
399 .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
400 .ramp_delay_table = bd71828_ramp_delay,
401 .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
402 .ramp_reg = BD71828_REG_BUCK6_MODE,
403 .ramp_mask = BD71828_MASK_RAMP_DELAY,
404 .owner = THIS_MODULE,
405 .of_parse_cb = buck_set_hw_dvs_levels,
406 },
407 .dvs = {
408 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
409 ROHM_DVS_LEVEL_SUSPEND |
410 ROHM_DVS_LEVEL_LPSR,
411 .run_reg = BD71828_REG_BUCK6_VOLT,
412 .run_mask = BD71828_MASK_BUCK1267_VOLT,
413 .idle_reg = BD71828_REG_BUCK6_IDLE_VOLT,
414 .idle_mask = BD71828_MASK_BUCK1267_VOLT,
415 .idle_on_mask = BD71828_MASK_IDLE_EN,
416 .suspend_reg = BD71828_REG_BUCK6_SUSP_VOLT,
417 .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
418 .suspend_on_mask = BD71828_MASK_SUSP_EN,
419 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
420 .lpsr_reg = BD71828_REG_BUCK6_SUSP_VOLT,
421 .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
422 },
423 .reg_inits = buck6_inits,
424 .reg_init_amnt = ARRAY_SIZE(buck6_inits),
425 },
426 {
427 .desc = {
428 .name = "buck7",
429 .of_match = of_match_ptr("BUCK7"),
430 .regulators_node = of_match_ptr("regulators"),
431 .id = BD71828_BUCK7,
432 .ops = &bd71828_dvs_buck_ops,
433 .type = REGULATOR_VOLTAGE,
434 .linear_ranges = bd71828_buck1267_volts,
435 .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts),
436 .n_voltages = BD71828_BUCK1267_VOLTS,
437 .enable_reg = BD71828_REG_BUCK7_EN,
438 .enable_mask = BD71828_MASK_RUN_EN,
439 .vsel_reg = BD71828_REG_BUCK7_VOLT,
440 .vsel_mask = BD71828_MASK_BUCK1267_VOLT,
441 .ramp_delay_table = bd71828_ramp_delay,
442 .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay),
443 .ramp_reg = BD71828_REG_BUCK7_MODE,
444 .ramp_mask = BD71828_MASK_RAMP_DELAY,
445 .owner = THIS_MODULE,
446 .of_parse_cb = buck_set_hw_dvs_levels,
447 },
448 .dvs = {
449 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
450 ROHM_DVS_LEVEL_SUSPEND |
451 ROHM_DVS_LEVEL_LPSR,
452 .run_reg = BD71828_REG_BUCK7_VOLT,
453 .run_mask = BD71828_MASK_BUCK1267_VOLT,
454 .idle_reg = BD71828_REG_BUCK7_IDLE_VOLT,
455 .idle_mask = BD71828_MASK_BUCK1267_VOLT,
456 .idle_on_mask = BD71828_MASK_IDLE_EN,
457 .suspend_reg = BD71828_REG_BUCK7_SUSP_VOLT,
458 .suspend_mask = BD71828_MASK_BUCK1267_VOLT,
459 .suspend_on_mask = BD71828_MASK_SUSP_EN,
460 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
461 .lpsr_reg = BD71828_REG_BUCK7_SUSP_VOLT,
462 .lpsr_mask = BD71828_MASK_BUCK1267_VOLT,
463 },
464 .reg_inits = buck7_inits,
465 .reg_init_amnt = ARRAY_SIZE(buck7_inits),
466 },
467 {
468 .desc = {
469 .name = "ldo1",
470 .of_match = of_match_ptr("LDO1"),
471 .regulators_node = of_match_ptr("regulators"),
472 .id = BD71828_LDO1,
473 .ops = &bd71828_ldo_ops,
474 .type = REGULATOR_VOLTAGE,
475 .linear_ranges = bd71828_ldo_volts,
476 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
477 .n_voltages = BD71828_LDO_VOLTS,
478 .enable_reg = BD71828_REG_LDO1_EN,
479 .enable_mask = BD71828_MASK_RUN_EN,
480 .vsel_reg = BD71828_REG_LDO1_VOLT,
481 .vsel_mask = BD71828_MASK_LDO_VOLT,
482 .owner = THIS_MODULE,
483 .of_parse_cb = buck_set_hw_dvs_levels,
484 },
485 .dvs = {
486 /*
487 * LDO1 only supports single voltage for all states.
488 * voltage can be individually enabled for each state
489 * though => allow setting all states to support
490 * enabling power rail on different states.
491 */
492 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
493 ROHM_DVS_LEVEL_SUSPEND |
494 ROHM_DVS_LEVEL_LPSR,
495 .run_reg = BD71828_REG_LDO1_VOLT,
496 .idle_reg = BD71828_REG_LDO1_VOLT,
497 .suspend_reg = BD71828_REG_LDO1_VOLT,
498 .lpsr_reg = BD71828_REG_LDO1_VOLT,
499 .run_mask = BD71828_MASK_LDO_VOLT,
500 .idle_mask = BD71828_MASK_LDO_VOLT,
501 .suspend_mask = BD71828_MASK_LDO_VOLT,
502 .lpsr_mask = BD71828_MASK_LDO_VOLT,
503 .idle_on_mask = BD71828_MASK_IDLE_EN,
504 .suspend_on_mask = BD71828_MASK_SUSP_EN,
505 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
506 },
507 }, {
508 .desc = {
509 .name = "ldo2",
510 .of_match = of_match_ptr("LDO2"),
511 .regulators_node = of_match_ptr("regulators"),
512 .id = BD71828_LDO2,
513 .ops = &bd71828_ldo_ops,
514 .type = REGULATOR_VOLTAGE,
515 .linear_ranges = bd71828_ldo_volts,
516 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
517 .n_voltages = BD71828_LDO_VOLTS,
518 .enable_reg = BD71828_REG_LDO2_EN,
519 .enable_mask = BD71828_MASK_RUN_EN,
520 .vsel_reg = BD71828_REG_LDO2_VOLT,
521 .vsel_mask = BD71828_MASK_LDO_VOLT,
522 .owner = THIS_MODULE,
523 .of_parse_cb = buck_set_hw_dvs_levels,
524 },
525 .dvs = {
526 /*
527 * LDO2 only supports single voltage for all states.
528 * voltage can be individually enabled for each state
529 * though => allow setting all states to support
530 * enabling power rail on different states.
531 */
532 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
533 ROHM_DVS_LEVEL_SUSPEND |
534 ROHM_DVS_LEVEL_LPSR,
535 .run_reg = BD71828_REG_LDO2_VOLT,
536 .idle_reg = BD71828_REG_LDO2_VOLT,
537 .suspend_reg = BD71828_REG_LDO2_VOLT,
538 .lpsr_reg = BD71828_REG_LDO2_VOLT,
539 .run_mask = BD71828_MASK_LDO_VOLT,
540 .idle_mask = BD71828_MASK_LDO_VOLT,
541 .suspend_mask = BD71828_MASK_LDO_VOLT,
542 .lpsr_mask = BD71828_MASK_LDO_VOLT,
543 .idle_on_mask = BD71828_MASK_IDLE_EN,
544 .suspend_on_mask = BD71828_MASK_SUSP_EN,
545 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
546 },
547 }, {
548 .desc = {
549 .name = "ldo3",
550 .of_match = of_match_ptr("LDO3"),
551 .regulators_node = of_match_ptr("regulators"),
552 .id = BD71828_LDO3,
553 .ops = &bd71828_ldo_ops,
554 .type = REGULATOR_VOLTAGE,
555 .linear_ranges = bd71828_ldo_volts,
556 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
557 .n_voltages = BD71828_LDO_VOLTS,
558 .enable_reg = BD71828_REG_LDO3_EN,
559 .enable_mask = BD71828_MASK_RUN_EN,
560 .vsel_reg = BD71828_REG_LDO3_VOLT,
561 .vsel_mask = BD71828_MASK_LDO_VOLT,
562 .owner = THIS_MODULE,
563 .of_parse_cb = buck_set_hw_dvs_levels,
564 },
565 .dvs = {
566 /*
567 * LDO3 only supports single voltage for all states.
568 * voltage can be individually enabled for each state
569 * though => allow setting all states to support
570 * enabling power rail on different states.
571 */
572 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
573 ROHM_DVS_LEVEL_SUSPEND |
574 ROHM_DVS_LEVEL_LPSR,
575 .run_reg = BD71828_REG_LDO3_VOLT,
576 .idle_reg = BD71828_REG_LDO3_VOLT,
577 .suspend_reg = BD71828_REG_LDO3_VOLT,
578 .lpsr_reg = BD71828_REG_LDO3_VOLT,
579 .run_mask = BD71828_MASK_LDO_VOLT,
580 .idle_mask = BD71828_MASK_LDO_VOLT,
581 .suspend_mask = BD71828_MASK_LDO_VOLT,
582 .lpsr_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 }, {
589 .desc = {
590 .name = "ldo4",
591 .of_match = of_match_ptr("LDO4"),
592 .regulators_node = of_match_ptr("regulators"),
593 .id = BD71828_LDO4,
594 .ops = &bd71828_ldo_ops,
595 .type = REGULATOR_VOLTAGE,
596 .linear_ranges = bd71828_ldo_volts,
597 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
598 .n_voltages = BD71828_LDO_VOLTS,
599 .enable_reg = BD71828_REG_LDO4_EN,
600 .enable_mask = BD71828_MASK_RUN_EN,
601 .vsel_reg = BD71828_REG_LDO4_VOLT,
602 .vsel_mask = BD71828_MASK_LDO_VOLT,
603 .owner = THIS_MODULE,
604 .of_parse_cb = buck_set_hw_dvs_levels,
605 },
606 .dvs = {
607 /*
608 * LDO1 only supports single voltage for all states.
609 * voltage can be individually enabled for each state
610 * though => allow setting all states to support
611 * enabling power rail on different states.
612 */
613 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
614 ROHM_DVS_LEVEL_SUSPEND |
615 ROHM_DVS_LEVEL_LPSR,
616 .run_reg = BD71828_REG_LDO4_VOLT,
617 .idle_reg = BD71828_REG_LDO4_VOLT,
618 .suspend_reg = BD71828_REG_LDO4_VOLT,
619 .lpsr_reg = BD71828_REG_LDO4_VOLT,
620 .run_mask = BD71828_MASK_LDO_VOLT,
621 .idle_mask = BD71828_MASK_LDO_VOLT,
622 .suspend_mask = BD71828_MASK_LDO_VOLT,
623 .lpsr_mask = BD71828_MASK_LDO_VOLT,
624 .idle_on_mask = BD71828_MASK_IDLE_EN,
625 .suspend_on_mask = BD71828_MASK_SUSP_EN,
626 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
627 },
628 }, {
629 .desc = {
630 .name = "ldo5",
631 .of_match = of_match_ptr("LDO5"),
632 .regulators_node = of_match_ptr("regulators"),
633 .id = BD71828_LDO5,
634 .ops = &bd71828_ldo_ops,
635 .type = REGULATOR_VOLTAGE,
636 .linear_ranges = bd71828_ldo_volts,
637 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts),
638 .n_voltages = BD71828_LDO_VOLTS,
639 .enable_reg = BD71828_REG_LDO5_EN,
640 .enable_mask = BD71828_MASK_RUN_EN,
641 .vsel_reg = BD71828_REG_LDO5_VOLT,
642 .vsel_mask = BD71828_MASK_LDO_VOLT,
643 .of_parse_cb = buck_set_hw_dvs_levels,
644 .owner = THIS_MODULE,
645 },
646 /*
647 * LDO5 is special. It can choose vsel settings to be configured
648 * from 2 different registers (by GPIO).
649 *
650 * This driver supports only configuration where
651 * BD71828_REG_LDO5_VOLT_L is used.
652 */
653 .dvs = {
654 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
655 ROHM_DVS_LEVEL_SUSPEND |
656 ROHM_DVS_LEVEL_LPSR,
657 .run_reg = BD71828_REG_LDO5_VOLT,
658 .idle_reg = BD71828_REG_LDO5_VOLT,
659 .suspend_reg = BD71828_REG_LDO5_VOLT,
660 .lpsr_reg = BD71828_REG_LDO5_VOLT,
661 .run_mask = BD71828_MASK_LDO_VOLT,
662 .idle_mask = BD71828_MASK_LDO_VOLT,
663 .suspend_mask = BD71828_MASK_LDO_VOLT,
664 .lpsr_mask = BD71828_MASK_LDO_VOLT,
665 .idle_on_mask = BD71828_MASK_IDLE_EN,
666 .suspend_on_mask = BD71828_MASK_SUSP_EN,
667 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
668 },
669
670 }, {
671 .desc = {
672 .name = "ldo6",
673 .of_match = of_match_ptr("LDO6"),
674 .regulators_node = of_match_ptr("regulators"),
675 .id = BD71828_LDO6,
676 .ops = &bd71828_ldo6_ops,
677 .type = REGULATOR_VOLTAGE,
678 .fixed_uV = BD71828_LDO_6_VOLTAGE,
679 .n_voltages = 1,
680 .enable_reg = BD71828_REG_LDO6_EN,
681 .enable_mask = BD71828_MASK_RUN_EN,
682 .owner = THIS_MODULE,
683 /*
684 * LDO6 only supports enable/disable for all states.
685 * Voltage for LDO6 is fixed.
686 */
687 .of_parse_cb = ldo6_parse_dt,
688 },
689 }, {
690 .desc = {
691 /* SNVS LDO in data-sheet */
692 .name = "ldo7",
693 .of_match = of_match_ptr("LDO7"),
694 .regulators_node = of_match_ptr("regulators"),
695 .id = BD71828_LDO_SNVS,
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_LDO7_EN,
702 .enable_mask = BD71828_MASK_RUN_EN,
703 .vsel_reg = BD71828_REG_LDO7_VOLT,
704 .vsel_mask = BD71828_MASK_LDO_VOLT,
705 .owner = THIS_MODULE,
706 .of_parse_cb = buck_set_hw_dvs_levels,
707 },
708 .dvs = {
709 /*
710 * LDO7 only supports single voltage for all states.
711 * voltage can be individually enabled for each state
712 * though => allow setting all states to support
713 * enabling power rail on different states.
714 */
715 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
716 ROHM_DVS_LEVEL_SUSPEND |
717 ROHM_DVS_LEVEL_LPSR,
718 .run_reg = BD71828_REG_LDO7_VOLT,
719 .idle_reg = BD71828_REG_LDO7_VOLT,
720 .suspend_reg = BD71828_REG_LDO7_VOLT,
721 .lpsr_reg = BD71828_REG_LDO7_VOLT,
722 .run_mask = BD71828_MASK_LDO_VOLT,
723 .idle_mask = BD71828_MASK_LDO_VOLT,
724 .suspend_mask = BD71828_MASK_LDO_VOLT,
725 .lpsr_mask = BD71828_MASK_LDO_VOLT,
726 .idle_on_mask = BD71828_MASK_IDLE_EN,
727 .suspend_on_mask = BD71828_MASK_SUSP_EN,
728 .lpsr_on_mask = BD71828_MASK_LPSR_EN,
729 },
730
731 },
732 };
733
bd71828_probe(struct platform_device * pdev)734 static int bd71828_probe(struct platform_device *pdev)
735 {
736 int i, j, ret;
737 struct regulator_config config = {
738 .dev = pdev->dev.parent,
739 };
740
741 config.regmap = dev_get_regmap(pdev->dev.parent, NULL);
742 if (!config.regmap)
743 return -ENODEV;
744
745 for (i = 0; i < ARRAY_SIZE(bd71828_rdata); i++) {
746 struct regulator_dev *rdev;
747 const struct bd71828_regulator_data *rd;
748
749 rd = &bd71828_rdata[i];
750 rdev = devm_regulator_register(&pdev->dev,
751 &rd->desc, &config);
752 if (IS_ERR(rdev))
753 return dev_err_probe(&pdev->dev, PTR_ERR(rdev),
754 "failed to register %s regulator\n",
755 rd->desc.name);
756
757 for (j = 0; j < rd->reg_init_amnt; j++) {
758 ret = regmap_update_bits(config.regmap,
759 rd->reg_inits[j].reg,
760 rd->reg_inits[j].mask,
761 rd->reg_inits[j].val);
762 if (ret)
763 return dev_err_probe(&pdev->dev, ret,
764 "regulator %s init failed\n",
765 rd->desc.name);
766 }
767 }
768 return 0;
769 }
770
771 static struct platform_driver bd71828_regulator = {
772 .driver = {
773 .name = "bd71828-pmic",
774 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
775 },
776 .probe = bd71828_probe,
777 };
778
779 module_platform_driver(bd71828_regulator);
780
781 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
782 MODULE_DESCRIPTION("BD71828 voltage regulator driver");
783 MODULE_LICENSE("GPL");
784 MODULE_ALIAS("platform:bd71828-pmic");
785
