1 /*-
2 * Copyright 2016 Michal Meloun <mmel@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/bus.h>
33 #include <sys/gpio.h>
34 #include <sys/kernel.h>
35 #include <sys/module.h>
36 #include <sys/malloc.h>
37 #include <sys/rman.h>
38 #include <sys/sx.h>
39
40 #include <machine/bus.h>
41
42 #include <dev/extres/regulator/regulator.h>
43 #include <dev/gpio/gpiobusvar.h>
44
45 #include <dt-bindings/mfd/as3722.h>
46
47 #include "as3722.h"
48
49 MALLOC_DEFINE(M_AS3722_REG, "AS3722 regulator", "AS3722 power regulator");
50
51 #define DIV_ROUND_UP(n,d) howmany(n, d)
52
53 enum as3722_reg_id {
54 AS3722_REG_ID_SD0,
55 AS3722_REG_ID_SD1,
56 AS3722_REG_ID_SD2,
57 AS3722_REG_ID_SD3,
58 AS3722_REG_ID_SD4,
59 AS3722_REG_ID_SD5,
60 AS3722_REG_ID_SD6,
61 AS3722_REG_ID_LDO0,
62 AS3722_REG_ID_LDO1,
63 AS3722_REG_ID_LDO2,
64 AS3722_REG_ID_LDO3,
65 AS3722_REG_ID_LDO4,
66 AS3722_REG_ID_LDO5,
67 AS3722_REG_ID_LDO6,
68 AS3722_REG_ID_LDO7,
69 AS3722_REG_ID_LDO9,
70 AS3722_REG_ID_LDO10,
71 AS3722_REG_ID_LDO11,
72 };
73
74 /* Regulator HW definition. */
75 struct reg_def {
76 intptr_t id; /* ID */
77 char *name; /* Regulator name */
78 char *supply_name; /* Source property name */
79 uint8_t volt_reg;
80 uint8_t volt_vsel_mask;
81 uint8_t enable_reg;
82 uint8_t enable_mask;
83 uint8_t ext_enable_reg;
84 uint8_t ext_enable_mask;
85 struct regulator_range *ranges;
86 int nranges;
87 };
88
89 struct as3722_reg_sc {
90 struct regnode *regnode;
91 struct as3722_softc *base_sc;
92 struct reg_def *def;
93 phandle_t xref;
94
95 struct regnode_std_param *param;
96 int ext_control;
97 int enable_tracking;
98
99 int enable_usec;
100 };
101
102 static struct regulator_range as3722_sd016_ranges[] = {
103 REG_RANGE_INIT(0x00, 0x00, 0, 0),
104 REG_RANGE_INIT(0x01, 0x5A, 610000, 10000),
105 };
106
107 static struct regulator_range as3722_sd0_lv_ranges[] = {
108 REG_RANGE_INIT(0x00, 0x00, 0, 0),
109 REG_RANGE_INIT(0x01, 0x6E, 410000, 10000),
110 };
111
112 static struct regulator_range as3722_sd_ranges[] = {
113 REG_RANGE_INIT(0x00, 0x00, 0, 0),
114 REG_RANGE_INIT(0x01, 0x40, 612500, 12500),
115 REG_RANGE_INIT(0x41, 0x70, 1425000, 25000),
116 REG_RANGE_INIT(0x71, 0x7F, 2650000, 50000),
117 };
118
119 static struct regulator_range as3722_ldo3_ranges[] = {
120 REG_RANGE_INIT(0x00, 0x00, 0, 0),
121 REG_RANGE_INIT(0x01, 0x2D, 620000, 20000),
122 };
123
124 static struct regulator_range as3722_ldo_ranges[] = {
125 REG_RANGE_INIT(0x00, 0x00, 0, 0),
126 REG_RANGE_INIT(0x01, 0x24, 825000, 25000),
127 REG_RANGE_INIT(0x40, 0x7F, 1725000, 25000),
128 };
129
130 static struct reg_def as3722s_def[] = {
131 {
132 .id = AS3722_REG_ID_SD0,
133 .name = "sd0",
134 .volt_reg = AS3722_SD0_VOLTAGE,
135 .volt_vsel_mask = AS3722_SD_VSEL_MASK,
136 .enable_reg = AS3722_SD_CONTROL,
137 .enable_mask = AS3722_SDN_CTRL(0),
138 .ext_enable_reg = AS3722_ENABLE_CTRL1,
139 .ext_enable_mask = AS3722_SD0_EXT_ENABLE_MASK,
140 .ranges = as3722_sd016_ranges,
141 .nranges = nitems(as3722_sd016_ranges),
142 },
143 {
144 .id = AS3722_REG_ID_SD1,
145 .name = "sd1",
146 .volt_reg = AS3722_SD1_VOLTAGE,
147 .volt_vsel_mask = AS3722_SD_VSEL_MASK,
148 .enable_reg = AS3722_SD_CONTROL,
149 .enable_mask = AS3722_SDN_CTRL(1),
150 .ext_enable_reg = AS3722_ENABLE_CTRL1,
151 .ext_enable_mask = AS3722_SD1_EXT_ENABLE_MASK,
152 .ranges = as3722_sd_ranges,
153 .nranges = nitems(as3722_sd_ranges),
154 },
155 {
156 .id = AS3722_REG_ID_SD2,
157 .name = "sd2",
158 .supply_name = "vsup-sd2",
159 .volt_reg = AS3722_SD2_VOLTAGE,
160 .volt_vsel_mask = AS3722_SD_VSEL_MASK,
161 .enable_reg = AS3722_SD_CONTROL,
162 .enable_mask = AS3722_SDN_CTRL(2),
163 .ext_enable_reg = AS3722_ENABLE_CTRL1,
164 .ext_enable_mask = AS3722_SD2_EXT_ENABLE_MASK,
165 .ranges = as3722_sd_ranges,
166 .nranges = nitems(as3722_sd_ranges),
167 },
168 {
169 .id = AS3722_REG_ID_SD3,
170 .name = "sd3",
171 .supply_name = "vsup-sd3",
172 .volt_reg = AS3722_SD3_VOLTAGE,
173 .volt_vsel_mask = AS3722_SD_VSEL_MASK,
174 .enable_reg = AS3722_SD_CONTROL,
175 .enable_mask = AS3722_SDN_CTRL(3),
176 .ext_enable_reg = AS3722_ENABLE_CTRL1,
177 .ext_enable_mask = AS3722_SD3_EXT_ENABLE_MASK,
178 .ranges = as3722_sd_ranges,
179 .nranges = nitems(as3722_sd_ranges),
180 },
181 {
182 .id = AS3722_REG_ID_SD4,
183 .name = "sd4",
184 .supply_name = "vsup-sd4",
185 .volt_reg = AS3722_SD4_VOLTAGE,
186 .volt_vsel_mask = AS3722_SD_VSEL_MASK,
187 .enable_reg = AS3722_SD_CONTROL,
188 .enable_mask = AS3722_SDN_CTRL(4),
189 .ext_enable_reg = AS3722_ENABLE_CTRL2,
190 .ext_enable_mask = AS3722_SD4_EXT_ENABLE_MASK,
191 .ranges = as3722_sd_ranges,
192 .nranges = nitems(as3722_sd_ranges),
193 },
194 {
195 .id = AS3722_REG_ID_SD5,
196 .name = "sd5",
197 .supply_name = "vsup-sd5",
198 .volt_reg = AS3722_SD5_VOLTAGE,
199 .volt_vsel_mask = AS3722_SD_VSEL_MASK,
200 .enable_reg = AS3722_SD_CONTROL,
201 .enable_mask = AS3722_SDN_CTRL(5),
202 .ext_enable_reg = AS3722_ENABLE_CTRL2,
203 .ext_enable_mask = AS3722_SD5_EXT_ENABLE_MASK,
204 .ranges = as3722_sd_ranges,
205 .nranges = nitems(as3722_sd_ranges),
206 },
207 {
208 .id = AS3722_REG_ID_SD6,
209 .name = "sd6",
210 .volt_reg = AS3722_SD6_VOLTAGE,
211 .volt_vsel_mask = AS3722_SD_VSEL_MASK,
212 .enable_reg = AS3722_SD_CONTROL,
213 .enable_mask = AS3722_SDN_CTRL(6),
214 .ext_enable_reg = AS3722_ENABLE_CTRL2,
215 .ext_enable_mask = AS3722_SD6_EXT_ENABLE_MASK,
216 .ranges = as3722_sd016_ranges,
217 .nranges = nitems(as3722_sd016_ranges),
218 },
219 {
220 .id = AS3722_REG_ID_LDO0,
221 .name = "ldo0",
222 .supply_name = "vin-ldo0",
223 .volt_reg = AS3722_LDO0_VOLTAGE,
224 .volt_vsel_mask = AS3722_LDO0_VSEL_MASK,
225 .enable_reg = AS3722_LDO_CONTROL0,
226 .enable_mask = AS3722_LDO0_CTRL,
227 .ext_enable_reg = AS3722_ENABLE_CTRL3,
228 .ext_enable_mask = AS3722_LDO0_EXT_ENABLE_MASK,
229 .ranges = as3722_ldo_ranges,
230 .nranges = nitems(as3722_ldo_ranges),
231 },
232 {
233 .id = AS3722_REG_ID_LDO1,
234 .name = "ldo1",
235 .supply_name = "vin-ldo1-6",
236 .volt_reg = AS3722_LDO1_VOLTAGE,
237 .volt_vsel_mask = AS3722_LDO_VSEL_MASK,
238 .enable_reg = AS3722_LDO_CONTROL0,
239 .enable_mask = AS3722_LDO1_CTRL,
240 .ext_enable_reg = AS3722_ENABLE_CTRL3,
241 .ext_enable_mask = AS3722_LDO1_EXT_ENABLE_MASK,
242 .ranges = as3722_ldo_ranges,
243 .nranges = nitems(as3722_ldo_ranges),
244 },
245 {
246 .id = AS3722_REG_ID_LDO2,
247 .name = "ldo2",
248 .supply_name = "vin-ldo2-5-7",
249 .volt_reg = AS3722_LDO2_VOLTAGE,
250 .volt_vsel_mask = AS3722_LDO_VSEL_MASK,
251 .enable_reg = AS3722_LDO_CONTROL0,
252 .enable_mask = AS3722_LDO2_CTRL,
253 .ext_enable_reg = AS3722_ENABLE_CTRL3,
254 .ext_enable_mask = AS3722_LDO2_EXT_ENABLE_MASK,
255 .ranges = as3722_ldo_ranges,
256 .nranges = nitems(as3722_ldo_ranges),
257 },
258 {
259 .id = AS3722_REG_ID_LDO3,
260 .name = "ldo3",
261 .supply_name = "vin-ldo3-4",
262 .volt_reg = AS3722_LDO3_VOLTAGE,
263 .volt_vsel_mask = AS3722_LDO3_VSEL_MASK,
264 .enable_reg = AS3722_LDO_CONTROL0,
265 .enable_mask = AS3722_LDO3_CTRL,
266 .ext_enable_reg = AS3722_ENABLE_CTRL3,
267 .ext_enable_mask = AS3722_LDO3_EXT_ENABLE_MASK,
268 .ranges = as3722_ldo3_ranges,
269 .nranges = nitems(as3722_ldo3_ranges),
270 },
271 {
272 .id = AS3722_REG_ID_LDO4,
273 .name = "ldo4",
274 .supply_name = "vin-ldo3-4",
275 .volt_reg = AS3722_LDO4_VOLTAGE,
276 .volt_vsel_mask = AS3722_LDO_VSEL_MASK,
277 .enable_reg = AS3722_LDO_CONTROL0,
278 .enable_mask = AS3722_LDO4_CTRL,
279 .ext_enable_reg = AS3722_ENABLE_CTRL4,
280 .ext_enable_mask = AS3722_LDO4_EXT_ENABLE_MASK,
281 .ranges = as3722_ldo_ranges,
282 .nranges = nitems(as3722_ldo_ranges),
283 },
284 {
285 .id = AS3722_REG_ID_LDO5,
286 .name = "ldo5",
287 .supply_name = "vin-ldo2-5-7",
288 .volt_reg = AS3722_LDO5_VOLTAGE,
289 .volt_vsel_mask = AS3722_LDO_VSEL_MASK,
290 .enable_reg = AS3722_LDO_CONTROL0,
291 .enable_mask = AS3722_LDO5_CTRL,
292 .ext_enable_reg = AS3722_ENABLE_CTRL4,
293 .ext_enable_mask = AS3722_LDO5_EXT_ENABLE_MASK,
294 .ranges = as3722_ldo_ranges,
295 .nranges = nitems(as3722_ldo_ranges),
296 },
297 {
298 .id = AS3722_REG_ID_LDO6,
299 .name = "ldo6",
300 .supply_name = "vin-ldo1-6",
301 .volt_reg = AS3722_LDO6_VOLTAGE,
302 .volt_vsel_mask = AS3722_LDO_VSEL_MASK,
303 .enable_reg = AS3722_LDO_CONTROL0,
304 .enable_mask = AS3722_LDO6_CTRL,
305 .ext_enable_reg = AS3722_ENABLE_CTRL4,
306 .ext_enable_mask = AS3722_LDO6_EXT_ENABLE_MASK,
307 .ranges = as3722_ldo_ranges,
308 .nranges = nitems(as3722_ldo_ranges),
309 },
310 {
311 .id = AS3722_REG_ID_LDO7,
312 .name = "ldo7",
313 .supply_name = "vin-ldo2-5-7",
314 .volt_reg = AS3722_LDO7_VOLTAGE,
315 .volt_vsel_mask = AS3722_LDO_VSEL_MASK,
316 .enable_reg = AS3722_LDO_CONTROL0,
317 .enable_mask = AS3722_LDO7_CTRL,
318 .ext_enable_reg = AS3722_ENABLE_CTRL4,
319 .ext_enable_mask = AS3722_LDO7_EXT_ENABLE_MASK,
320 .ranges = as3722_ldo_ranges,
321 .nranges = nitems(as3722_ldo_ranges),
322 },
323 {
324 .id = AS3722_REG_ID_LDO9,
325 .name = "ldo9",
326 .supply_name = "vin-ldo9-10",
327 .volt_reg = AS3722_LDO9_VOLTAGE,
328 .volt_vsel_mask = AS3722_LDO_VSEL_MASK,
329 .enable_reg = AS3722_LDO_CONTROL1,
330 .enable_mask = AS3722_LDO9_CTRL,
331 .ext_enable_reg = AS3722_ENABLE_CTRL5,
332 .ext_enable_mask = AS3722_LDO9_EXT_ENABLE_MASK,
333 .ranges = as3722_ldo_ranges,
334 .nranges = nitems(as3722_ldo_ranges),
335 },
336 {
337 .id = AS3722_REG_ID_LDO10,
338 .name = "ldo10",
339 .supply_name = "vin-ldo9-10",
340 .volt_reg = AS3722_LDO10_VOLTAGE,
341 .volt_vsel_mask = AS3722_LDO_VSEL_MASK,
342 .enable_reg = AS3722_LDO_CONTROL1,
343 .enable_mask = AS3722_LDO10_CTRL,
344 .ext_enable_reg = AS3722_ENABLE_CTRL5,
345 .ext_enable_mask = AS3722_LDO10_EXT_ENABLE_MASK,
346 .ranges = as3722_ldo_ranges,
347 .nranges = nitems(as3722_ldo_ranges),
348 },
349 {
350 .id = AS3722_REG_ID_LDO11,
351 .name = "ldo11",
352 .supply_name = "vin-ldo11",
353 .volt_reg = AS3722_LDO11_VOLTAGE,
354 .volt_vsel_mask = AS3722_LDO_VSEL_MASK,
355 .enable_reg = AS3722_LDO_CONTROL1,
356 .enable_mask = AS3722_LDO11_CTRL,
357 .ext_enable_reg = AS3722_ENABLE_CTRL5,
358 .ext_enable_mask = AS3722_LDO11_EXT_ENABLE_MASK,
359 .ranges = as3722_ldo_ranges,
360 .nranges = nitems(as3722_ldo_ranges),
361 },
362 };
363
364 struct as3722_regnode_init_def {
365 struct regnode_init_def reg_init_def;
366 int ext_control;
367 int enable_tracking;
368 };
369
370 static int as3722_regnode_init(struct regnode *regnode);
371 static int as3722_regnode_enable(struct regnode *regnode, bool enable,
372 int *udelay);
373 static int as3722_regnode_set_volt(struct regnode *regnode, int min_uvolt,
374 int max_uvolt, int *udelay);
375 static int as3722_regnode_get_volt(struct regnode *regnode, int *uvolt);
376 static regnode_method_t as3722_regnode_methods[] = {
377 /* Regulator interface */
378 REGNODEMETHOD(regnode_init, as3722_regnode_init),
379 REGNODEMETHOD(regnode_enable, as3722_regnode_enable),
380 REGNODEMETHOD(regnode_set_voltage, as3722_regnode_set_volt),
381 REGNODEMETHOD(regnode_get_voltage, as3722_regnode_get_volt),
382 REGNODEMETHOD_END
383 };
384 DEFINE_CLASS_1(as3722_regnode, as3722_regnode_class, as3722_regnode_methods,
385 sizeof(struct as3722_reg_sc), regnode_class);
386
387 static int
388 as3722_read_sel(struct as3722_reg_sc *sc, uint8_t *sel)
389 {
390 int rv;
391
392 rv = RD1(sc->base_sc, sc->def->volt_reg, sel);
393 if (rv != 0)
394 return (rv);
395 *sel &= sc->def->volt_vsel_mask;
396 *sel >>= ffs(sc->def->volt_vsel_mask) - 1;
397 return (0);
398 }
399
400 static int
401 as3722_write_sel(struct as3722_reg_sc *sc, uint8_t sel)
402 {
403 int rv;
404
405 sel <<= ffs(sc->def->volt_vsel_mask) - 1;
406 sel &= sc->def->volt_vsel_mask;
407
408 rv = RM1(sc->base_sc, sc->def->volt_reg,
409 sc->def->volt_vsel_mask, sel);
410 if (rv != 0)
411 return (rv);
412 return (rv);
413 }
414
415 static bool
416 as3722_sd0_is_low_voltage(struct as3722_reg_sc *sc)
417 {
418 uint8_t val;
419 int rv;
420
421 rv = RD1(sc->base_sc, AS3722_FUSE7, &val);
422 if (rv != 0)
423 return (rv);
424 return (val & AS3722_FUSE7_SD0_LOW_VOLTAGE ? true : false);
425 }
426
427 static int
428 as3722_reg_extreg_setup(struct as3722_reg_sc *sc, int ext_pwr_ctrl)
429 {
430 uint8_t val;
431 int rv;
432
433 val = ext_pwr_ctrl << (ffs(sc->def->ext_enable_mask) - 1);
434 rv = RM1(sc->base_sc, sc->def->ext_enable_reg,
435 sc->def->ext_enable_mask, val);
436 return (rv);
437 }
438
439 static int
440 as3722_reg_enable(struct as3722_reg_sc *sc)
441 {
442 int rv;
443
444 rv = RM1(sc->base_sc, sc->def->enable_reg,
445 sc->def->enable_mask, sc->def->enable_mask);
446 return (rv);
447 }
448
449 static int
450 as3722_reg_disable(struct as3722_reg_sc *sc)
451 {
452 int rv;
453
454 rv = RM1(sc->base_sc, sc->def->enable_reg,
455 sc->def->enable_mask, 0);
456 return (rv);
457 }
458
459 static int
460 as3722_regnode_init(struct regnode *regnode)
461 {
462 struct as3722_reg_sc *sc;
463 int rv;
464
465 sc = regnode_get_softc(regnode);
466
467 sc->enable_usec = 500;
468 if (sc->def->id == AS3722_REG_ID_SD0) {
469 if (as3722_sd0_is_low_voltage(sc)) {
470 sc->def->ranges = as3722_sd0_lv_ranges;
471 sc->def->nranges = nitems(as3722_sd0_lv_ranges);
472 }
473 sc->enable_usec = 600;
474 } else if (sc->def->id == AS3722_REG_ID_LDO3) {
475 if (sc->enable_tracking) {
476 rv = RM1(sc->base_sc, sc->def->volt_reg,
477 AS3722_LDO3_MODE_MASK,
478 AS3722_LDO3_MODE_PMOS_TRACKING);
479 if (rv < 0) {
480 device_printf(sc->base_sc->dev,
481 "LDO3 tracking failed: %d\n", rv);
482 return (rv);
483 }
484 }
485 }
486
487 if (sc->ext_control) {
488 rv = as3722_reg_enable(sc);
489 if (rv < 0) {
490 device_printf(sc->base_sc->dev,
491 "Failed to enable %s regulator: %d\n",
492 sc->def->name, rv);
493 return (rv);
494 }
495 rv = as3722_reg_extreg_setup(sc, sc->ext_control);
496 if (rv < 0) {
497 device_printf(sc->base_sc->dev,
498 "%s ext control failed: %d", sc->def->name, rv);
499 return (rv);
500 }
501 }
502 return (0);
503 }
504
505 static void
506 as3722_fdt_parse(struct as3722_softc *sc, phandle_t node, struct reg_def *def,
507 struct as3722_regnode_init_def *init_def)
508 {
509 int rv;
510 phandle_t parent, supply_node;
511 char prop_name[64]; /* Maximum OFW property name length. */
512
513 rv = regulator_parse_ofw_stdparam(sc->dev, node,
514 &init_def->reg_init_def);
515
516 rv = OF_getencprop(node, "ams,ext-control", &init_def->ext_control,
517 sizeof(init_def->ext_control));
518 if (rv <= 0)
519 init_def->ext_control = 0;
520 if (init_def->ext_control > 3) {
521 device_printf(sc->dev,
522 "Invalid value for ams,ext-control property: %d\n",
523 init_def->ext_control);
524 init_def->ext_control = 0;
525 }
526 if (OF_hasprop(node, "ams,enable-tracking"))
527 init_def->enable_tracking = 1;
528
529 /* Get parent supply. */
530 if (def->supply_name == NULL)
531 return;
532
533 parent = OF_parent(node);
534 snprintf(prop_name, sizeof(prop_name), "%s-supply",
535 def->supply_name);
536 rv = OF_getencprop(parent, prop_name, &supply_node,
537 sizeof(supply_node));
538 if (rv <= 0)
539 return;
540 supply_node = OF_node_from_xref(supply_node);
541 rv = OF_getprop_alloc(supply_node, "regulator-name",
542 (void **)&init_def->reg_init_def.parent_name);
543 if (rv <= 0)
544 init_def->reg_init_def.parent_name = NULL;
545 }
546
547 static struct as3722_reg_sc *
548 as3722_attach(struct as3722_softc *sc, phandle_t node, struct reg_def *def)
549 {
550 struct as3722_reg_sc *reg_sc;
551 struct as3722_regnode_init_def init_def;
552 struct regnode *regnode;
553
554 bzero(&init_def, sizeof(init_def));
555
556 as3722_fdt_parse(sc, node, def, &init_def);
557 init_def.reg_init_def.id = def->id;
558 init_def.reg_init_def.ofw_node = node;
559 regnode = regnode_create(sc->dev, &as3722_regnode_class,
560 &init_def.reg_init_def);
561 if (regnode == NULL) {
562 device_printf(sc->dev, "Cannot create regulator.\n");
563 return (NULL);
564 }
565 reg_sc = regnode_get_softc(regnode);
566
567 /* Init regulator softc. */
568 reg_sc->regnode = regnode;
569 reg_sc->base_sc = sc;
570 reg_sc->def = def;
571 reg_sc->xref = OF_xref_from_node(node);
572
573 reg_sc->param = regnode_get_stdparam(regnode);
574 reg_sc->ext_control = init_def.ext_control;
575 reg_sc->enable_tracking = init_def.enable_tracking;
576
577 regnode_register(regnode);
578 if (bootverbose) {
579 int volt, rv;
580 regnode_topo_slock();
581 rv = regnode_get_voltage(regnode, &volt);
582 if (rv == ENODEV) {
583 device_printf(sc->dev,
584 " Regulator %s: parent doesn't exist yet.\n",
585 regnode_get_name(regnode));
586 } else if (rv != 0) {
587 device_printf(sc->dev,
588 " Regulator %s: voltage: INVALID!!!\n",
589 regnode_get_name(regnode));
590 } else {
591 device_printf(sc->dev,
592 " Regulator %s: voltage: %d uV\n",
593 regnode_get_name(regnode), volt);
594 }
595 regnode_topo_unlock();
596 }
597
598 return (reg_sc);
599 }
600
601 int
602 as3722_regulator_attach(struct as3722_softc *sc, phandle_t node)
603 {
604 struct as3722_reg_sc *reg;
605 phandle_t child, rnode;
606 int i;
607
608 rnode = ofw_bus_find_child(node, "regulators");
609 if (rnode <= 0) {
610 device_printf(sc->dev, " Cannot find regulators subnode\n");
611 return (ENXIO);
612 }
613
614 sc->nregs = nitems(as3722s_def);
615 sc->regs = malloc(sizeof(struct as3722_reg_sc *) * sc->nregs,
616 M_AS3722_REG, M_WAITOK | M_ZERO);
617
618 /* Attach all known regulators if exist in DT. */
619 for (i = 0; i < sc->nregs; i++) {
620 child = ofw_bus_find_child(rnode, as3722s_def[i].name);
621 if (child == 0) {
622 if (bootverbose)
623 device_printf(sc->dev,
624 "Regulator %s missing in DT\n",
625 as3722s_def[i].name);
626 continue;
627 }
628 reg = as3722_attach(sc, child, as3722s_def + i);
629 if (reg == NULL) {
630 device_printf(sc->dev, "Cannot attach regulator: %s\n",
631 as3722s_def[i].name);
632 return (ENXIO);
633 }
634 sc->regs[i] = reg;
635 }
636 return (0);
637 }
638
639 int
640 as3722_regulator_map(device_t dev, phandle_t xref, int ncells,
641 pcell_t *cells, int *num)
642 {
643 struct as3722_softc *sc;
644 int i;
645
646 sc = device_get_softc(dev);
647 for (i = 0; i < sc->nregs; i++) {
648 if (sc->regs[i] == NULL)
649 continue;
650 if (sc->regs[i]->xref == xref) {
651 *num = sc->regs[i]->def->id;
652 return (0);
653 }
654 }
655 return (ENXIO);
656 }
657
658 static int
659 as3722_regnode_enable(struct regnode *regnode, bool val, int *udelay)
660 {
661 struct as3722_reg_sc *sc;
662 int rv;
663
664 sc = regnode_get_softc(regnode);
665
666 if (val)
667 rv = as3722_reg_enable(sc);
668 else
669 rv = as3722_reg_disable(sc);
670 *udelay = sc->enable_usec;
671 return (rv);
672 }
673
674 static int
675 as3722_regnode_set_volt(struct regnode *regnode, int min_uvolt, int max_uvolt,
676 int *udelay)
677 {
678 struct as3722_reg_sc *sc;
679 uint8_t sel;
680 int rv;
681
682 sc = regnode_get_softc(regnode);
683
684 *udelay = 0;
685 rv = regulator_range_volt_to_sel8(sc->def->ranges, sc->def->nranges,
686 min_uvolt, max_uvolt, &sel);
687 if (rv != 0)
688 return (rv);
689 rv = as3722_write_sel(sc, sel);
690 return (rv);
691
692 }
693
694 static int
695 as3722_regnode_get_volt(struct regnode *regnode, int *uvolt)
696 {
697 struct as3722_reg_sc *sc;
698 uint8_t sel;
699 int rv;
700
701 sc = regnode_get_softc(regnode);
702 rv = as3722_read_sel(sc, &sel);
703 if (rv != 0)
704 return (rv);
705
706 /* LDO6 have bypass. */
707 if (sc->def->id == AS3722_REG_ID_LDO6 && sel == AS3722_LDO6_SEL_BYPASS)
708 return (ENOENT);
709 rv = regulator_range_sel8_to_volt(sc->def->ranges, sc->def->nranges,
710 sel, uvolt);
711 return (rv);
712 }
Cache object: d786d720487d136cb61154215ab71f79
|