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