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