xref: /freebsd/sys/arm/nvidia/as3722_regulators.c (revision 273c26a3c3bea87a241d6879abd4f991db180bf0)
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 <gnu/dts/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 struct regulator_range {
75 	u_int	min_uvolt;
76 	u_int	step_uvolt;
77 	u_int	min_sel;
78 	u_int	max_sel;
79 };
80 
81 
82 /* Regulator HW definition. */
83 struct reg_def {
84 	intptr_t		id;		/* ID */
85 	char			*name;		/* Regulator name */
86 	char			*supply_name;	/* Source property name */
87 	uint8_t			volt_reg;
88 	uint8_t			volt_vsel_mask;
89 	uint8_t			enable_reg;
90 	uint8_t			enable_mask;
91 	uint8_t			ext_enable_reg;
92 	uint8_t			ext_enable_mask;
93 	struct regulator_range	*ranges;
94 	int			nranges;
95 };
96 
97 struct as3722_reg_sc {
98 	struct regnode		*regnode;
99 	struct as3722_softc	*base_sc;
100 	struct reg_def		*def;
101 	phandle_t		xref;
102 
103 	struct regnode_std_param *param;
104 	int 			ext_control;
105 	int	 		enable_tracking;
106 
107 	int			enable_usec;
108 };
109 
110 #define	RANGE_INIT(_min_sel, _max_sel, _min_uvolt, _step_uvolt)		\
111 {									\
112 	.min_sel	= _min_sel,					\
113 	.max_sel	= _max_sel,					\
114 	.min_uvolt	= _min_uvolt,					\
115 	.step_uvolt	= _step_uvolt,					\
116 }
117 
118 static struct regulator_range as3722_sd016_ranges[] = {
119 	RANGE_INIT(0x00, 0x00,       0,     0),
120 	RANGE_INIT(0x01, 0x5A,  610000, 10000),
121 };
122 
123 static struct regulator_range as3722_sd0_lv_ranges[] = {
124 	RANGE_INIT(0x00, 0x00,       0,     0),
125 	RANGE_INIT(0x01, 0x6E,  410000, 10000),
126 };
127 
128 static struct regulator_range as3722_sd_ranges[] = {
129 	RANGE_INIT(0x00, 0x00,       0,     0),
130 	RANGE_INIT(0x01, 0x40,  612500, 12500),
131 	RANGE_INIT(0x41, 0x70, 1425000, 25000),
132 	RANGE_INIT(0x71, 0x7F, 2650000, 50000),
133 };
134 
135 static struct regulator_range as3722_ldo3_ranges[] = {
136 	RANGE_INIT(0x00, 0x00,       0,     0),
137 	RANGE_INIT(0x01, 0x2D,  620000, 20000),
138 };
139 
140 static struct regulator_range as3722_ldo_ranges[] = {
141 	RANGE_INIT(0x00, 0x00,       0,     0),
142 	RANGE_INIT(0x01, 0x24,  825000, 25000),
143 	RANGE_INIT(0x40, 0x7F, 1725000, 25000),
144 };
145 
146 static struct reg_def as3722s_def[] = {
147 	{
148 		.id = AS3722_REG_ID_SD0,
149 		.name = "sd0",
150 		.volt_reg = AS3722_SD0_VOLTAGE,
151 		.volt_vsel_mask = AS3722_SD_VSEL_MASK,
152 		.enable_reg = AS3722_SD_CONTROL,
153 		.enable_mask = AS3722_SDN_CTRL(0),
154 		.ext_enable_reg = AS3722_ENABLE_CTRL1,
155 		.ext_enable_mask = AS3722_SD0_EXT_ENABLE_MASK,
156 		.ranges = as3722_sd016_ranges,
157 		.nranges = nitems(as3722_sd016_ranges),
158 	},
159 	{
160 		.id = AS3722_REG_ID_SD1,
161 		.name = "sd1",
162 		.volt_reg = AS3722_SD1_VOLTAGE,
163 		.volt_vsel_mask = AS3722_SD_VSEL_MASK,
164 		.enable_reg = AS3722_SD_CONTROL,
165 		.enable_mask = AS3722_SDN_CTRL(1),
166 		.ext_enable_reg = AS3722_ENABLE_CTRL1,
167 		.ext_enable_mask = AS3722_SD1_EXT_ENABLE_MASK,
168 		.ranges = as3722_sd_ranges,
169 		.nranges = nitems(as3722_sd_ranges),
170 	},
171 	{
172 		.id = AS3722_REG_ID_SD2,
173 		.name = "sd2",
174 		.supply_name = "vsup-sd2",
175 		.volt_reg = AS3722_SD2_VOLTAGE,
176 		.volt_vsel_mask = AS3722_SD_VSEL_MASK,
177 		.enable_reg = AS3722_SD_CONTROL,
178 		.enable_mask = AS3722_SDN_CTRL(2),
179 		.ext_enable_reg = AS3722_ENABLE_CTRL1,
180 		.ext_enable_mask = AS3722_SD2_EXT_ENABLE_MASK,
181 		.ranges = as3722_sd_ranges,
182 		.nranges = nitems(as3722_sd_ranges),
183 	},
184 	{
185 		.id = AS3722_REG_ID_SD3,
186 		.name = "sd3",
187 		.supply_name = "vsup-sd3",
188 		.volt_reg = AS3722_SD3_VOLTAGE,
189 		.volt_vsel_mask = AS3722_SD_VSEL_MASK,
190 		.enable_reg = AS3722_SD_CONTROL,
191 		.enable_mask = AS3722_SDN_CTRL(3),
192 		.ext_enable_reg = AS3722_ENABLE_CTRL1,
193 		.ext_enable_mask = AS3722_SD3_EXT_ENABLE_MASK,
194 		.ranges = as3722_sd_ranges,
195 		.nranges = nitems(as3722_sd_ranges),
196 	},
197 	{
198 		.id = AS3722_REG_ID_SD4,
199 		.name = "sd4",
200 		.supply_name = "vsup-sd4",
201 		.volt_reg = AS3722_SD4_VOLTAGE,
202 		.volt_vsel_mask = AS3722_SD_VSEL_MASK,
203 		.enable_reg = AS3722_SD_CONTROL,
204 		.enable_mask = AS3722_SDN_CTRL(4),
205 		.ext_enable_reg = AS3722_ENABLE_CTRL2,
206 		.ext_enable_mask = AS3722_SD4_EXT_ENABLE_MASK,
207 		.ranges = as3722_sd_ranges,
208 		.nranges = nitems(as3722_sd_ranges),
209 	},
210 	{
211 		.id = AS3722_REG_ID_SD5,
212 		.name = "sd5",
213 		.supply_name = "vsup-sd5",
214 		.volt_reg = AS3722_SD5_VOLTAGE,
215 		.volt_vsel_mask = AS3722_SD_VSEL_MASK,
216 		.enable_reg = AS3722_SD_CONTROL,
217 		.enable_mask = AS3722_SDN_CTRL(5),
218 		.ext_enable_reg = AS3722_ENABLE_CTRL2,
219 		.ext_enable_mask = AS3722_SD5_EXT_ENABLE_MASK,
220 		.ranges = as3722_sd_ranges,
221 		.nranges = nitems(as3722_sd_ranges),
222 	},
223 	{
224 		.id = AS3722_REG_ID_SD6,
225 		.name = "sd6",
226 		.volt_reg = AS3722_SD6_VOLTAGE,
227 		.volt_vsel_mask = AS3722_SD_VSEL_MASK,
228 		.enable_reg = AS3722_SD_CONTROL,
229 		.enable_mask = AS3722_SDN_CTRL(6),
230 		.ext_enable_reg = AS3722_ENABLE_CTRL2,
231 		.ext_enable_mask = AS3722_SD6_EXT_ENABLE_MASK,
232 		.ranges = as3722_sd016_ranges,
233 		.nranges = nitems(as3722_sd016_ranges),
234 	},
235 	{
236 		.id = AS3722_REG_ID_LDO0,
237 		.name = "ldo0",
238 		.supply_name = "vin-ldo0",
239 		.volt_reg = AS3722_LDO0_VOLTAGE,
240 		.volt_vsel_mask = AS3722_LDO0_VSEL_MASK,
241 		.enable_reg = AS3722_LDO_CONTROL0,
242 		.enable_mask = AS3722_LDO0_CTRL,
243 		.ext_enable_reg = AS3722_ENABLE_CTRL3,
244 		.ext_enable_mask = AS3722_LDO0_EXT_ENABLE_MASK,
245 		.ranges = as3722_ldo_ranges,
246 		.nranges = nitems(as3722_ldo_ranges),
247 	},
248 	{
249 		.id = AS3722_REG_ID_LDO1,
250 		.name = "ldo1",
251 		.supply_name = "vin-ldo1-6",
252 		.volt_reg = AS3722_LDO1_VOLTAGE,
253 		.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
254 		.enable_reg = AS3722_LDO_CONTROL0,
255 		.enable_mask = AS3722_LDO1_CTRL,
256 		.ext_enable_reg = AS3722_ENABLE_CTRL3,
257 		.ext_enable_mask = AS3722_LDO1_EXT_ENABLE_MASK,
258 		.ranges = as3722_ldo_ranges,
259 		.nranges = nitems(as3722_ldo_ranges),
260 	},
261 	{
262 		.id = AS3722_REG_ID_LDO2,
263 		.name = "ldo2",
264 		.supply_name = "vin-ldo2-5-7",
265 		.volt_reg = AS3722_LDO2_VOLTAGE,
266 		.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
267 		.enable_reg = AS3722_LDO_CONTROL0,
268 		.enable_mask = AS3722_LDO2_CTRL,
269 		.ext_enable_reg = AS3722_ENABLE_CTRL3,
270 		.ext_enable_mask = AS3722_LDO2_EXT_ENABLE_MASK,
271 		.ranges = as3722_ldo_ranges,
272 		.nranges = nitems(as3722_ldo_ranges),
273 	},
274 	{
275 		.id = AS3722_REG_ID_LDO3,
276 		.name = "ldo3",
277 		.supply_name = "vin-ldo3-4",
278 		.volt_reg = AS3722_LDO3_VOLTAGE,
279 		.volt_vsel_mask = AS3722_LDO3_VSEL_MASK,
280 		.enable_reg = AS3722_LDO_CONTROL0,
281 		.enable_mask = AS3722_LDO3_CTRL,
282 		.ext_enable_reg = AS3722_ENABLE_CTRL3,
283 		.ext_enable_mask = AS3722_LDO3_EXT_ENABLE_MASK,
284 		.ranges = as3722_ldo3_ranges,
285 		.nranges = nitems(as3722_ldo3_ranges),
286 	},
287 	{
288 		.id = AS3722_REG_ID_LDO4,
289 		.name = "ldo4",
290 		.supply_name = "vin-ldo3-4",
291 		.volt_reg = AS3722_LDO4_VOLTAGE,
292 		.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
293 		.enable_reg = AS3722_LDO_CONTROL0,
294 		.enable_mask = AS3722_LDO4_CTRL,
295 		.ext_enable_reg = AS3722_ENABLE_CTRL4,
296 		.ext_enable_mask = AS3722_LDO4_EXT_ENABLE_MASK,
297 		.ranges = as3722_ldo_ranges,
298 		.nranges = nitems(as3722_ldo_ranges),
299 	},
300 	{
301 		.id = AS3722_REG_ID_LDO5,
302 		.name = "ldo5",
303 		.supply_name = "vin-ldo2-5-7",
304 		.volt_reg = AS3722_LDO5_VOLTAGE,
305 		.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
306 		.enable_reg = AS3722_LDO_CONTROL0,
307 		.enable_mask = AS3722_LDO5_CTRL,
308 		.ext_enable_reg = AS3722_ENABLE_CTRL4,
309 		.ext_enable_mask = AS3722_LDO5_EXT_ENABLE_MASK,
310 		.ranges = as3722_ldo_ranges,
311 		.nranges = nitems(as3722_ldo_ranges),
312 	},
313 	{
314 		.id = AS3722_REG_ID_LDO6,
315 		.name = "ldo6",
316 		.supply_name = "vin-ldo1-6",
317 		.volt_reg = AS3722_LDO6_VOLTAGE,
318 		.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
319 		.enable_reg = AS3722_LDO_CONTROL0,
320 		.enable_mask = AS3722_LDO6_CTRL,
321 		.ext_enable_reg = AS3722_ENABLE_CTRL4,
322 		.ext_enable_mask = AS3722_LDO6_EXT_ENABLE_MASK,
323 		.ranges = as3722_ldo_ranges,
324 		.nranges = nitems(as3722_ldo_ranges),
325 	},
326 	{
327 		.id = AS3722_REG_ID_LDO7,
328 		.name = "ldo7",
329 		.supply_name = "vin-ldo2-5-7",
330 		.volt_reg = AS3722_LDO7_VOLTAGE,
331 		.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
332 		.enable_reg = AS3722_LDO_CONTROL0,
333 		.enable_mask = AS3722_LDO7_CTRL,
334 		.ext_enable_reg = AS3722_ENABLE_CTRL4,
335 		.ext_enable_mask = AS3722_LDO7_EXT_ENABLE_MASK,
336 		.ranges = as3722_ldo_ranges,
337 		.nranges = nitems(as3722_ldo_ranges),
338 	},
339 	{
340 		.id = AS3722_REG_ID_LDO9,
341 		.name = "ldo9",
342 		.supply_name = "vin-ldo9-10",
343 		.volt_reg = AS3722_LDO9_VOLTAGE,
344 		.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
345 		.enable_reg = AS3722_LDO_CONTROL1,
346 		.enable_mask = AS3722_LDO9_CTRL,
347 		.ext_enable_reg = AS3722_ENABLE_CTRL5,
348 		.ext_enable_mask = AS3722_LDO9_EXT_ENABLE_MASK,
349 		.ranges = as3722_ldo_ranges,
350 		.nranges = nitems(as3722_ldo_ranges),
351 	},
352 	{
353 		.id = AS3722_REG_ID_LDO10,
354 		.name = "ldo10",
355 		.supply_name = "vin-ldo9-10",
356 		.volt_reg = AS3722_LDO10_VOLTAGE,
357 		.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
358 		.enable_reg = AS3722_LDO_CONTROL1,
359 		.enable_mask = AS3722_LDO10_CTRL,
360 		.ext_enable_reg = AS3722_ENABLE_CTRL5,
361 		.ext_enable_mask = AS3722_LDO10_EXT_ENABLE_MASK,
362 		.ranges = as3722_ldo_ranges,
363 		.nranges = nitems(as3722_ldo_ranges),
364 	},
365 	{
366 		.id = AS3722_REG_ID_LDO11,
367 		.name = "ldo11",
368 		.supply_name = "vin-ldo11",
369 		.volt_reg = AS3722_LDO11_VOLTAGE,
370 		.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
371 		.enable_reg = AS3722_LDO_CONTROL1,
372 		.enable_mask = AS3722_LDO11_CTRL,
373 		.ext_enable_reg = AS3722_ENABLE_CTRL5,
374 		.ext_enable_mask = AS3722_LDO11_EXT_ENABLE_MASK,
375 		.ranges = as3722_ldo_ranges,
376 		.nranges = nitems(as3722_ldo_ranges),
377 	},
378 };
379 
380 
381 struct as3722_regnode_init_def {
382 	struct regnode_init_def	reg_init_def;
383 	int 			ext_control;
384 	int	 		enable_tracking;
385 };
386 
387 static int as3722_regnode_init(struct regnode *regnode);
388 static int as3722_regnode_enable(struct regnode *regnode, bool enable,
389     int *udelay);
390 static int as3722_regnode_set_volt(struct regnode *regnode, int min_uvolt,
391     int max_uvolt, int *udelay);
392 static int as3722_regnode_get_volt(struct regnode *regnode, int *uvolt);
393 static regnode_method_t as3722_regnode_methods[] = {
394 	/* Regulator interface */
395 	REGNODEMETHOD(regnode_init,		as3722_regnode_init),
396 	REGNODEMETHOD(regnode_enable,		as3722_regnode_enable),
397 	REGNODEMETHOD(regnode_set_voltage,	as3722_regnode_set_volt),
398 	REGNODEMETHOD(regnode_get_voltage,	as3722_regnode_get_volt),
399 	REGNODEMETHOD_END
400 };
401 DEFINE_CLASS_1(as3722_regnode, as3722_regnode_class, as3722_regnode_methods,
402    sizeof(struct as3722_reg_sc), regnode_class);
403 
404 static int
405 regulator_range_sel_to_volt(struct as3722_reg_sc *sc, uint8_t sel, int *volt)
406 {
407 	struct regulator_range *range;
408 	struct reg_def *def;
409 	int i;
410 
411 	def = sc->def;
412 	if (def->nranges == 0)
413 		panic("Voltage regulator have zero ranges\n");
414 
415 	for (i = 0; i < def->nranges ; i++) {
416 		range = def->ranges  + i;
417 
418 		if (!(sel >= range->min_sel &&
419 		      sel <= range->max_sel))
420 			continue;
421 
422 		sel -= range->min_sel;
423 
424 		*volt = range->min_uvolt + sel * range->step_uvolt;
425 		return (0);
426 	}
427 
428 	return (ERANGE);
429 }
430 
431 static int
432 regulator_range_volt_to_sel(struct as3722_reg_sc *sc, int min_uvolt,
433     int max_uvolt, uint8_t *out_sel)
434 {
435 	struct regulator_range *range;
436 	struct reg_def *def;
437 	uint8_t sel;
438 	int uvolt;
439 	int rv, i;
440 
441 	def = sc->def;
442 	if (def->nranges == 0)
443 		panic("Voltage regulator have zero ranges\n");
444 
445 	for (i = 0; i < def->nranges; i++) {
446 		range = def->ranges  + i;
447 		uvolt = range->min_uvolt +
448 			(range->max_sel - range->min_sel) * range->step_uvolt;
449 
450 		if ((min_uvolt > uvolt) ||
451 		    (max_uvolt < range->min_uvolt))
452 			continue;
453 
454 		if (min_uvolt <= range->min_uvolt)
455 			min_uvolt = range->min_uvolt;
456 
457 		/* If step is zero then range is fixed voltage range. */
458 		if (range->step_uvolt == 0)
459 			sel = 0;
460 		else
461 			sel = DIV_ROUND_UP(min_uvolt - range->min_uvolt,
462 			   range->step_uvolt);
463 
464 
465 		sel += range->min_sel;
466 
467 		break;
468 	}
469 
470 	if (i >= def->nranges)
471 		return (ERANGE);
472 
473 	/* Verify new settings. */
474 	rv = regulator_range_sel_to_volt(sc, sel, &uvolt);
475 	if (rv != 0)
476 		return (rv);
477 	if ((uvolt < min_uvolt) || (uvolt > max_uvolt))
478 		return (ERANGE);
479 
480 	*out_sel = sel;
481 	return (0);
482 }
483 
484 
485 static int
486 as3722_read_sel(struct as3722_reg_sc *sc, uint8_t *sel)
487 {
488 	int rv;
489 
490 	rv = RD1(sc->base_sc, sc->def->volt_reg, sel);
491 	if (rv != 0)
492 		return (rv);
493 	*sel &= sc->def->volt_vsel_mask;
494 	*sel >>= ffs(sc->def->volt_vsel_mask) - 1;
495 	return (0);
496 }
497 
498 static int
499 as3722_write_sel(struct as3722_reg_sc *sc, uint8_t sel)
500 {
501 	int rv;
502 
503 	sel <<= ffs(sc->def->volt_vsel_mask) - 1;
504 	sel &= sc->def->volt_vsel_mask;
505 
506 	rv = RM1(sc->base_sc, sc->def->volt_reg,
507 	    sc->def->volt_vsel_mask, sel);
508 	if (rv != 0)
509 		return (rv);
510 	return (rv);
511 }
512 
513 static bool
514 as3722_sd0_is_low_voltage(struct as3722_reg_sc *sc)
515 {
516 	uint8_t val;
517 	int rv;
518 
519 	rv = RD1(sc->base_sc, AS3722_FUSE7, &val);
520 	if (rv != 0)
521 		return (rv);
522 	return (val & AS3722_FUSE7_SD0_LOW_VOLTAGE ? true : false);
523 }
524 
525 static int
526 as3722_reg_extreg_setup(struct as3722_reg_sc *sc, int ext_pwr_ctrl)
527 {
528 	uint8_t val;
529 	int rv;
530 
531 	val =  ext_pwr_ctrl << (ffs(sc->def->ext_enable_mask) - 1);
532 	rv = RM1(sc->base_sc, sc->def->ext_enable_reg,
533 	    sc->def->ext_enable_mask, val);
534 	return (rv);
535 }
536 
537 static int
538 as3722_reg_enable(struct as3722_reg_sc *sc)
539 {
540 	int rv;
541 
542 	rv = RM1(sc->base_sc, sc->def->enable_reg,
543 	    sc->def->enable_mask, sc->def->enable_mask);
544 	return (rv);
545 }
546 
547 static int
548 as3722_reg_disable(struct as3722_reg_sc *sc)
549 {
550 	int rv;
551 
552 	rv = RM1(sc->base_sc, sc->def->enable_reg,
553 	    sc->def->enable_mask, 0);
554 	return (rv);
555 }
556 
557 static int
558 as3722_regnode_init(struct regnode *regnode)
559 {
560 	struct as3722_reg_sc *sc;
561 	int rv;
562 
563 	sc = regnode_get_softc(regnode);
564 
565 	sc->enable_usec = 500;
566 	if (sc->def->id == AS3722_REG_ID_SD0) {
567 		if (as3722_sd0_is_low_voltage(sc)) {
568 			sc->def->ranges = as3722_sd0_lv_ranges;
569 			sc->def->nranges = nitems(as3722_sd0_lv_ranges);
570 		}
571 		sc->enable_usec = 600;
572 	} else if (sc->def->id == AS3722_REG_ID_LDO3) {
573 		if (sc->enable_tracking) {
574 			rv = RM1(sc->base_sc, sc->def->volt_reg,
575 			    AS3722_LDO3_MODE_MASK,
576 			    AS3722_LDO3_MODE_PMOS_TRACKING);
577 			if (rv < 0) {
578 				device_printf(sc->base_sc->dev,
579 					"LDO3 tracking failed: %d\n", rv);
580 				return (rv);
581 			}
582 		}
583 	}
584 
585 	if (sc->ext_control) {
586 
587 		rv = as3722_reg_enable(sc);
588 		if (rv < 0) {
589 			device_printf(sc->base_sc->dev,
590 				"Failed to enable %s regulator: %d\n",
591 				sc->def->name, rv);
592 			return (rv);
593 		}
594 		rv = as3722_reg_extreg_setup(sc, sc->ext_control);
595 		if (rv < 0) {
596 			device_printf(sc->base_sc->dev,
597 				"%s ext control failed: %d", sc->def->name, rv);
598 			return (rv);
599 		}
600 	}
601 	return (0);
602 }
603 
604 static void
605 as3722_fdt_parse(struct as3722_softc *sc, phandle_t node, struct reg_def *def,
606 struct as3722_regnode_init_def *init_def)
607 {
608 	int rv;
609 	phandle_t parent, supply_node;
610 	char prop_name[64]; /* Maximum OFW property name length. */
611 
612 	rv = regulator_parse_ofw_stdparam(sc->dev, node,
613 	    &init_def->reg_init_def);
614 
615 	rv = OF_getencprop(node, "ams,ext-control", &init_def->ext_control,
616 	    sizeof(init_def->ext_control));
617 	if (rv <= 0)
618 		init_def->ext_control = 0;
619 	if (init_def->ext_control > 3) {
620 		device_printf(sc->dev,
621 		    "Invalid value for ams,ext-control property: %d\n",
622 		    init_def->ext_control);
623 		init_def->ext_control = 0;
624 	}
625 	if (OF_hasprop(node, "ams,enable-tracking"))
626 		init_def->enable_tracking = 1;
627 
628 
629 	/* Get parent supply. */
630 	if (def->supply_name == NULL)
631 		 return;
632 
633 	parent = OF_parent(node);
634 	snprintf(prop_name, sizeof(prop_name), "%s-supply",
635 	    def->supply_name);
636 	rv = OF_getencprop(parent, prop_name, &supply_node,
637 	    sizeof(supply_node));
638 	if (rv <= 0)
639 		return;
640 	supply_node = OF_node_from_xref(supply_node);
641 	rv = OF_getprop_alloc(supply_node, "regulator-name", 1,
642 	    (void **)&init_def->reg_init_def.parent_name);
643 	if (rv <= 0)
644 		init_def->reg_init_def.parent_name = NULL;
645 }
646 
647 static struct as3722_reg_sc *
648 as3722_attach(struct as3722_softc *sc, phandle_t node, struct reg_def *def)
649 {
650 	struct as3722_reg_sc *reg_sc;
651 	struct as3722_regnode_init_def init_def;
652 	struct regnode *regnode;
653 
654 	bzero(&init_def, sizeof(init_def));
655 
656 	as3722_fdt_parse(sc, node, def, &init_def);
657 	init_def.reg_init_def.id = def->id;
658 	init_def.reg_init_def.ofw_node = node;
659 	regnode = regnode_create(sc->dev, &as3722_regnode_class,
660 	    &init_def.reg_init_def);
661 	if (regnode == NULL) {
662 		device_printf(sc->dev, "Cannot create regulator.\n");
663 		return (NULL);
664 	}
665 	reg_sc = regnode_get_softc(regnode);
666 
667 	/* Init regulator softc. */
668 	reg_sc->regnode = regnode;
669 	reg_sc->base_sc = sc;
670 	reg_sc->def = def;
671 	reg_sc->xref = OF_xref_from_node(node);
672 
673 	reg_sc->param = regnode_get_stdparam(regnode);
674 	reg_sc->ext_control = init_def.ext_control;
675 	reg_sc->enable_tracking = init_def.enable_tracking;
676 
677 	regnode_register(regnode);
678 	if (bootverbose) {
679 		int volt, rv;
680 		regnode_topo_slock();
681 		rv = regnode_get_voltage(regnode, &volt);
682 		if (rv == ENODEV) {
683 			device_printf(sc->dev,
684 			   " Regulator %s: parent doesn't exist yet.\n",
685 			   regnode_get_name(regnode));
686 		} else if (rv != 0) {
687 			device_printf(sc->dev,
688 			   " Regulator %s: voltage: INVALID!!!\n",
689 			   regnode_get_name(regnode));
690 		} else {
691 			device_printf(sc->dev,
692 			    " Regulator %s: voltage: %d uV\n",
693 			    regnode_get_name(regnode), volt);
694 		}
695 		regnode_topo_unlock();
696 	}
697 
698 	return (reg_sc);
699 }
700 
701 int
702 as3722_regulator_attach(struct as3722_softc *sc, phandle_t node)
703 {
704 	struct as3722_reg_sc *reg;
705 	phandle_t child, rnode;
706 	int i;
707 
708 	rnode = ofw_bus_find_child(node, "regulators");
709 	if (rnode <= 0) {
710 		device_printf(sc->dev, " Cannot find regulators subnode\n");
711 		return (ENXIO);
712 	}
713 
714 	sc->nregs = nitems(as3722s_def);
715 	sc->regs = malloc(sizeof(struct as3722_reg_sc *) * sc->nregs,
716 	    M_AS3722_REG, M_WAITOK | M_ZERO);
717 
718 
719 	/* Attach all known regulators if exist in DT. */
720 	for (i = 0; i < sc->nregs; i++) {
721 		child = ofw_bus_find_child(rnode, as3722s_def[i].name);
722 		if (child == 0) {
723 			if (bootverbose)
724 				device_printf(sc->dev,
725 				    "Regulator %s missing in DT\n",
726 				    as3722s_def[i].name);
727 			continue;
728 		}
729 		reg = as3722_attach(sc, child, as3722s_def + i);
730 		if (reg == NULL) {
731 			device_printf(sc->dev, "Cannot attach regulator: %s\n",
732 			    as3722s_def[i].name);
733 			return (ENXIO);
734 		}
735 		sc->regs[i] = reg;
736 	}
737 	return (0);
738 }
739 
740 int
741 as3722_regulator_map(device_t dev, phandle_t xref, int ncells,
742     pcell_t *cells, int *num)
743 {
744 	struct as3722_softc *sc;
745 	int i;
746 
747 	sc = device_get_softc(dev);
748 	for (i = 0; i < sc->nregs; i++) {
749 		if (sc->regs[i] == NULL)
750 			continue;
751 		if (sc->regs[i]->xref == xref) {
752 			*num = sc->regs[i]->def->id;
753 			return (0);
754 		}
755 	}
756 	return (ENXIO);
757 }
758 
759 static int
760 as3722_regnode_enable(struct regnode *regnode, bool val, int *udelay)
761 {
762 	struct as3722_reg_sc *sc;
763 	int rv;
764 
765 	sc = regnode_get_softc(regnode);
766 
767 	if (val)
768 		rv = as3722_reg_enable(sc);
769 	else
770 		rv = as3722_reg_disable(sc);
771 	*udelay = sc->enable_usec;
772 	return (rv);
773 }
774 
775 static int
776 as3722_regnode_set_volt(struct regnode *regnode, int min_uvolt, int max_uvolt,
777     int *udelay)
778 {
779 	struct as3722_reg_sc *sc;
780 	uint8_t sel;
781 	int rv;
782 
783 	sc = regnode_get_softc(regnode);
784 
785 	*udelay = 0;
786 	rv = regulator_range_volt_to_sel(sc, min_uvolt, max_uvolt, &sel);
787 	if (rv != 0)
788 		return (rv);
789 	rv = as3722_write_sel(sc, sel);
790 	return (rv);
791 
792 }
793 
794 static int
795 as3722_regnode_get_volt(struct regnode *regnode, int *uvolt)
796 {
797 	struct as3722_reg_sc *sc;
798 	uint8_t sel;
799 	int rv;
800 
801 	sc = regnode_get_softc(regnode);
802 	rv = as3722_read_sel(sc, &sel);
803 	if (rv != 0)
804 		return (rv);
805 
806 	/* LDO6 have bypass. */
807 	if (sc->def->id == AS3722_REG_ID_LDO6 && sel == AS3722_LDO6_SEL_BYPASS)
808 		return (ENOENT);
809 	rv = regulator_range_sel_to_volt(sc, sel, uvolt);
810 	return (rv);
811 }
812