1 /*-
2  * Copyright 2016 Michal Meloun <[email protected]>
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 "opt_platform.h"
31 #include <sys/param.h>
32 #include <sys/conf.h>
33 #include <sys/bus.h>
34 #include <sys/kernel.h>
35 #include <sys/queue.h>
36 #include <sys/kobj.h>
37 #include <sys/malloc.h>
38 #include <sys/mutex.h>
39 #include <sys/limits.h>
40 #include <sys/lock.h>
41 #include <sys/sysctl.h>
42 #include <sys/systm.h>
43 #include <sys/sx.h>
44 
45 #ifdef FDT
46 #include <dev/fdt/fdt_common.h>
47 #include <dev/ofw/ofw_bus.h>
48 #include <dev/ofw/ofw_bus_subr.h>
49 #endif
50 #include <dev/extres/regulator/regulator.h>
51 
52 #include "regdev_if.h"
53 
54 SYSCTL_NODE(_hw, OID_AUTO, regulator, CTLFLAG_RD, NULL, "Regulators");
55 
56 MALLOC_DEFINE(M_REGULATOR, "regulator", "Regulator framework");
57 
58 #define	DIV_ROUND_UP(n,d) howmany(n, d)
59 
60 /* Forward declarations. */
61 struct regulator;
62 struct regnode;
63 
64 typedef TAILQ_HEAD(regnode_list, regnode) regnode_list_t;
65 typedef TAILQ_HEAD(regulator_list, regulator) regulator_list_t;
66 
67 /* Default regulator methods. */
68 static int regnode_method_enable(struct regnode *regnode, bool enable,
69     int *udelay);
70 static int regnode_method_status(struct regnode *regnode, int *status);
71 static int regnode_method_set_voltage(struct regnode *regnode, int min_uvolt,
72     int max_uvolt, int *udelay);
73 static int regnode_method_get_voltage(struct regnode *regnode, int *uvolt);
74 static void regulator_shutdown(void *dummy);
75 
76 /*
77  * Regulator controller methods.
78  */
79 static regnode_method_t regnode_methods[] = {
80 	REGNODEMETHOD(regnode_enable,		regnode_method_enable),
81 	REGNODEMETHOD(regnode_status,		regnode_method_status),
82 	REGNODEMETHOD(regnode_set_voltage,	regnode_method_set_voltage),
83 	REGNODEMETHOD(regnode_get_voltage,	regnode_method_get_voltage),
84 
85 	REGNODEMETHOD_END
86 };
87 DEFINE_CLASS_0(regnode, regnode_class, regnode_methods, 0);
88 
89 /*
90  * Regulator node - basic element for modelling SOC and bard power supply
91  * chains. Its contains producer data.
92  */
93 struct regnode {
94 	KOBJ_FIELDS;
95 
96 	TAILQ_ENTRY(regnode)	reglist_link;	/* Global list entry */
97 	regulator_list_t	consumers_list;	/* Consumers list */
98 
99 	/* Cache for already resolved names */
100 	struct regnode		*parent;	/* Resolved parent */
101 
102 	/* Details of this device. */
103 	const char		*name;		/* Globally unique name */
104 	const char		*parent_name;	/* Parent name */
105 
106 	device_t		pdev;		/* Producer device_t */
107 	void			*softc;		/* Producer softc */
108 	intptr_t		id;		/* Per producer unique id */
109 #ifdef FDT
110 	 phandle_t 		ofw_node;	/* OFW node of regulator */
111 #endif
112 	int			flags;		/* REGULATOR_FLAGS_ */
113 	struct sx		lock;		/* Lock for this regulator */
114 	int			ref_cnt;	/* Reference counter */
115 	int			enable_cnt;	/* Enabled counter */
116 
117 	struct regnode_std_param std_param;	/* Standard parameters */
118 
119 	struct sysctl_ctx_list	sysctl_ctx;
120 };
121 
122 /*
123  * Per consumer data, information about how a consumer is using a regulator
124  * node.
125  * A pointer to this structure is used as a handle in the consumer interface.
126  */
127 struct regulator {
128 	device_t		cdev;		/* Consumer device */
129 	struct regnode		*regnode;
130 	TAILQ_ENTRY(regulator)	link;		/* Consumers list entry */
131 
132 	int			enable_cnt;
133 	int 			min_uvolt;	/* Requested uvolt range */
134 	int 			max_uvolt;
135 };
136 
137 /*
138  * Regulator names must be system wide unique.
139  */
140 static regnode_list_t regnode_list = TAILQ_HEAD_INITIALIZER(regnode_list);
141 
142 static struct sx		regnode_topo_lock;
143 SX_SYSINIT(regulator_topology, &regnode_topo_lock, "Regulator topology lock");
144 
145 #define REG_TOPO_SLOCK()	sx_slock(&regnode_topo_lock)
146 #define REG_TOPO_XLOCK()	sx_xlock(&regnode_topo_lock)
147 #define REG_TOPO_UNLOCK()	sx_unlock(&regnode_topo_lock)
148 #define REG_TOPO_ASSERT()	sx_assert(&regnode_topo_lock, SA_LOCKED)
149 #define REG_TOPO_XASSERT() 	sx_assert(&regnode_topo_lock, SA_XLOCKED)
150 
151 #define REGNODE_SLOCK(_sc)	sx_slock(&((_sc)->lock))
152 #define REGNODE_XLOCK(_sc)	sx_xlock(&((_sc)->lock))
153 #define REGNODE_UNLOCK(_sc)	sx_unlock(&((_sc)->lock))
154 
155 SYSINIT(regulator_shutdown, SI_SUB_LAST, SI_ORDER_ANY, regulator_shutdown,
156     NULL);
157 
158 /*
159  * Disable unused regulator
160  * We run this function at SI_SUB_LAST which mean that every driver that needs
161  * regulator should have already enable them.
162  * All the remaining regulators should be those left enabled by the bootloader
163  * or enable by default by the PMIC.
164  */
165 static void
166 regulator_shutdown(void *dummy)
167 {
168 	struct regnode *entry;
169 	int status, ret;
170 	int disable = 1;
171 
172 	REG_TOPO_SLOCK();
173 	TUNABLE_INT_FETCH("hw.regulator.disable_unused", &disable);
174 	TAILQ_FOREACH(entry, &regnode_list, reglist_link) {
175 		if (!entry->std_param.always_on && disable) {
176 			if (bootverbose)
177 				printf("regulator: shutting down %s\n",
178 				    entry->name);
179 			ret = regnode_status(entry, &status);
180 			if (ret == 0 && status == REGULATOR_STATUS_ENABLED)
181 				regnode_stop(entry, 0);
182 		}
183 	}
184 	REG_TOPO_UNLOCK();
185 }
186 
187 /*
188  * sysctl handler
189  */
190 static int
191 regnode_uvolt_sysctl(SYSCTL_HANDLER_ARGS)
192 {
193 	struct regnode *regnode = arg1;
194 	int rv, uvolt;
195 
196 	if (regnode->std_param.min_uvolt == regnode->std_param.max_uvolt) {
197 		uvolt = regnode->std_param.min_uvolt;
198 	} else {
199 		REG_TOPO_SLOCK();
200 		if ((rv = regnode_get_voltage(regnode, &uvolt)) != 0) {
201 			REG_TOPO_UNLOCK();
202 			return (rv);
203 		}
204 		REG_TOPO_UNLOCK();
205 	}
206 
207 	return sysctl_handle_int(oidp, &uvolt, sizeof(uvolt), req);
208 }
209 
210 /* ----------------------------------------------------------------------------
211  *
212  * Default regulator methods for base class.
213  *
214  */
215 static int
216 regnode_method_enable(struct regnode *regnode, bool enable, int *udelay)
217 {
218 
219 	if (!enable)
220 		return (ENXIO);
221 
222 	*udelay = 0;
223 	return (0);
224 }
225 
226 static int
227 regnode_method_status(struct regnode *regnode, int *status)
228 {
229 	*status = REGULATOR_STATUS_ENABLED;
230 	return (0);
231 }
232 
233 static int
234 regnode_method_set_voltage(struct regnode *regnode, int min_uvolt, int max_uvolt,
235     int *udelay)
236 {
237 
238 	if ((min_uvolt > regnode->std_param.max_uvolt) ||
239 	    (max_uvolt < regnode->std_param.min_uvolt))
240 		return (ERANGE);
241 	*udelay = 0;
242 	return (0);
243 }
244 
245 static int
246 regnode_method_get_voltage(struct regnode *regnode, int *uvolt)
247 {
248 
249 	return (regnode->std_param.min_uvolt +
250 	    (regnode->std_param.max_uvolt - regnode->std_param.min_uvolt) / 2);
251 }
252 
253 /* ----------------------------------------------------------------------------
254  *
255  * Internal functions.
256  *
257  */
258 
259 static struct regnode *
260 regnode_find_by_name(const char *name)
261 {
262 	struct regnode *entry;
263 
264 	REG_TOPO_ASSERT();
265 
266 	TAILQ_FOREACH(entry, &regnode_list, reglist_link) {
267 		if (strcmp(entry->name, name) == 0)
268 			return (entry);
269 	}
270 	return (NULL);
271 }
272 
273 static struct regnode *
274 regnode_find_by_id(device_t dev, intptr_t id)
275 {
276 	struct regnode *entry;
277 
278 	REG_TOPO_ASSERT();
279 
280 	TAILQ_FOREACH(entry, &regnode_list, reglist_link) {
281 		if ((entry->pdev == dev) && (entry->id ==  id))
282 			return (entry);
283 	}
284 
285 	return (NULL);
286 }
287 
288 /*
289  * Create and initialize regulator object, but do not register it.
290  */
291 struct regnode *
292 regnode_create(device_t pdev, regnode_class_t regnode_class,
293     struct regnode_init_def *def)
294 {
295 	struct regnode *regnode;
296 	struct sysctl_oid *regnode_oid;
297 
298 	KASSERT(def->name != NULL, ("regulator name is NULL"));
299 	KASSERT(def->name[0] != '\0', ("regulator name is empty"));
300 
301 	REG_TOPO_SLOCK();
302 	if (regnode_find_by_name(def->name) != NULL)
303 		panic("Duplicated regulator registration: %s\n", def->name);
304 	REG_TOPO_UNLOCK();
305 
306 	/* Create object and initialize it. */
307 	regnode = malloc(sizeof(struct regnode), M_REGULATOR,
308 	    M_WAITOK | M_ZERO);
309 	kobj_init((kobj_t)regnode, (kobj_class_t)regnode_class);
310 	sx_init(&regnode->lock, "Regulator node lock");
311 
312 	/* Allocate softc if required. */
313 	if (regnode_class->size > 0) {
314 		regnode->softc = malloc(regnode_class->size, M_REGULATOR,
315 		    M_WAITOK | M_ZERO);
316 	}
317 
318 
319 	/* Copy all strings unless they're flagged as static. */
320 	if (def->flags & REGULATOR_FLAGS_STATIC) {
321 		regnode->name = def->name;
322 		regnode->parent_name = def->parent_name;
323 	} else {
324 		regnode->name = strdup(def->name, M_REGULATOR);
325 		if (def->parent_name != NULL)
326 			regnode->parent_name = strdup(def->parent_name,
327 			    M_REGULATOR);
328 	}
329 
330 	/* Rest of init. */
331 	TAILQ_INIT(&regnode->consumers_list);
332 	regnode->id = def->id;
333 	regnode->pdev = pdev;
334 	regnode->flags = def->flags;
335 	regnode->parent = NULL;
336 	regnode->std_param = def->std_param;
337 #ifdef FDT
338 	regnode->ofw_node = def->ofw_node;
339 #endif
340 
341 	sysctl_ctx_init(&regnode->sysctl_ctx);
342 	regnode_oid = SYSCTL_ADD_NODE(&regnode->sysctl_ctx,
343 	    SYSCTL_STATIC_CHILDREN(_hw_regulator),
344 	    OID_AUTO, regnode->name,
345 	    CTLFLAG_RD, 0, "A regulator node");
346 
347 	SYSCTL_ADD_INT(&regnode->sysctl_ctx,
348 	    SYSCTL_CHILDREN(regnode_oid),
349 	    OID_AUTO, "min_uvolt",
350 	    CTLFLAG_RD, &regnode->std_param.min_uvolt, 0,
351 	    "Minimal voltage (in uV)");
352 	SYSCTL_ADD_INT(&regnode->sysctl_ctx,
353 	    SYSCTL_CHILDREN(regnode_oid),
354 	    OID_AUTO, "max_uvolt",
355 	    CTLFLAG_RD, &regnode->std_param.max_uvolt, 0,
356 	    "Maximal voltage (in uV)");
357 	SYSCTL_ADD_INT(&regnode->sysctl_ctx,
358 	    SYSCTL_CHILDREN(regnode_oid),
359 	    OID_AUTO, "min_uamp",
360 	    CTLFLAG_RD, &regnode->std_param.min_uamp, 0,
361 	    "Minimal amperage (in uA)");
362 	SYSCTL_ADD_INT(&regnode->sysctl_ctx,
363 	    SYSCTL_CHILDREN(regnode_oid),
364 	    OID_AUTO, "max_uamp",
365 	    CTLFLAG_RD, &regnode->std_param.max_uamp, 0,
366 	    "Maximal amperage (in uA)");
367 	SYSCTL_ADD_INT(&regnode->sysctl_ctx,
368 	    SYSCTL_CHILDREN(regnode_oid),
369 	    OID_AUTO, "ramp_delay",
370 	    CTLFLAG_RD, &regnode->std_param.ramp_delay, 0,
371 	    "Ramp delay (in uV/us)");
372 	SYSCTL_ADD_INT(&regnode->sysctl_ctx,
373 	    SYSCTL_CHILDREN(regnode_oid),
374 	    OID_AUTO, "enable_delay",
375 	    CTLFLAG_RD, &regnode->std_param.enable_delay, 0,
376 	    "Enable delay (in us)");
377 	SYSCTL_ADD_INT(&regnode->sysctl_ctx,
378 	    SYSCTL_CHILDREN(regnode_oid),
379 	    OID_AUTO, "enable_cnt",
380 	    CTLFLAG_RD, &regnode->enable_cnt, 0,
381 	    "The regulator enable counter");
382 	SYSCTL_ADD_U8(&regnode->sysctl_ctx,
383 	    SYSCTL_CHILDREN(regnode_oid),
384 	    OID_AUTO, "boot_on",
385 	    CTLFLAG_RD, (uint8_t *) &regnode->std_param.boot_on, 0,
386 	    "Is enabled on boot");
387 	SYSCTL_ADD_U8(&regnode->sysctl_ctx,
388 	    SYSCTL_CHILDREN(regnode_oid),
389 	    OID_AUTO, "always_on",
390 	    CTLFLAG_RD, (uint8_t *)&regnode->std_param.always_on, 0,
391 	    "Is always enabled");
392 
393 	SYSCTL_ADD_PROC(&regnode->sysctl_ctx,
394 	    SYSCTL_CHILDREN(regnode_oid),
395 	    OID_AUTO, "uvolt",
396 	    CTLTYPE_INT | CTLFLAG_RD,
397 	    regnode, 0, regnode_uvolt_sysctl,
398 	    "I",
399 	    "Current voltage (in uV)");
400 
401 	return (regnode);
402 }
403 
404 /* Register regulator object. */
405 struct regnode *
406 regnode_register(struct regnode *regnode)
407 {
408 	int rv;
409 
410 #ifdef FDT
411 	if (regnode->ofw_node <= 0)
412 		regnode->ofw_node = ofw_bus_get_node(regnode->pdev);
413 	if (regnode->ofw_node <= 0)
414 		return (NULL);
415 #endif
416 
417 	rv = REGNODE_INIT(regnode);
418 	if (rv != 0) {
419 		printf("REGNODE_INIT failed: %d\n", rv);
420 		return (NULL);
421 	}
422 
423 	REG_TOPO_XLOCK();
424 	TAILQ_INSERT_TAIL(&regnode_list, regnode, reglist_link);
425 	REG_TOPO_UNLOCK();
426 #ifdef FDT
427 	OF_device_register_xref(OF_xref_from_node(regnode->ofw_node),
428 	    regnode->pdev);
429 #endif
430 	return (regnode);
431 }
432 
433 static int
434 regnode_resolve_parent(struct regnode *regnode)
435 {
436 
437 	/* All ready resolved or no parent? */
438 	if ((regnode->parent != NULL) ||
439 	    (regnode->parent_name == NULL))
440 		return (0);
441 
442 	regnode->parent = regnode_find_by_name(regnode->parent_name);
443 	if (regnode->parent == NULL)
444 		return (ENODEV);
445 	return (0);
446 }
447 
448 static void
449 regnode_delay(int usec)
450 {
451 	int ticks;
452 
453 	if (usec == 0)
454 		return;
455 	ticks = (usec * hz + 999999) / 1000000;
456 
457 	if (cold || ticks < 2)
458 		DELAY(usec);
459 	else
460 		pause("REGULATOR", ticks);
461 }
462 
463 /* --------------------------------------------------------------------------
464  *
465  * Regulator providers interface
466  *
467  */
468 
469 const char *
470 regnode_get_name(struct regnode *regnode)
471 {
472 
473 	return (regnode->name);
474 }
475 
476 const char *
477 regnode_get_parent_name(struct regnode *regnode)
478 {
479 
480 	return (regnode->parent_name);
481 }
482 
483 int
484 regnode_get_flags(struct regnode *regnode)
485 {
486 
487 	return (regnode->flags);
488 }
489 
490 void *
491 regnode_get_softc(struct regnode *regnode)
492 {
493 
494 	return (regnode->softc);
495 }
496 
497 device_t
498 regnode_get_device(struct regnode *regnode)
499 {
500 
501 	return (regnode->pdev);
502 }
503 
504 struct regnode_std_param *regnode_get_stdparam(struct regnode *regnode)
505 {
506 
507 	return (&regnode->std_param);
508 }
509 
510 void regnode_topo_unlock(void)
511 {
512 
513 	REG_TOPO_UNLOCK();
514 }
515 
516 void regnode_topo_xlock(void)
517 {
518 
519 	REG_TOPO_XLOCK();
520 }
521 
522 void regnode_topo_slock(void)
523 {
524 
525 	REG_TOPO_SLOCK();
526 }
527 
528 
529 /* --------------------------------------------------------------------------
530  *
531  * Real consumers executive
532  *
533  */
534 struct regnode *
535 regnode_get_parent(struct regnode *regnode)
536 {
537 	int rv;
538 
539 	REG_TOPO_ASSERT();
540 
541 	rv = regnode_resolve_parent(regnode);
542 	if (rv != 0)
543 		return (NULL);
544 
545 	return (regnode->parent);
546 }
547 
548 /*
549  * Enable regulator.
550  */
551 int
552 regnode_enable(struct regnode *regnode)
553 {
554 	int udelay;
555 	int rv;
556 
557 	REG_TOPO_ASSERT();
558 
559 	/* Enable regulator for each node in chain, starting from source. */
560 	rv = regnode_resolve_parent(regnode);
561 	if (rv != 0)
562 		return (rv);
563 	if (regnode->parent != NULL) {
564 		rv = regnode_enable(regnode->parent);
565 		if (rv != 0)
566 			return (rv);
567 	}
568 
569 	/* Handle this node. */
570 	REGNODE_XLOCK(regnode);
571 	if (regnode->enable_cnt == 0) {
572 		rv = REGNODE_ENABLE(regnode, true, &udelay);
573 		if (rv != 0) {
574 			REGNODE_UNLOCK(regnode);
575 			return (rv);
576 		}
577 		regnode_delay(udelay);
578 	}
579 	regnode->enable_cnt++;
580 	REGNODE_UNLOCK(regnode);
581 	return (0);
582 }
583 
584 /*
585  * Disable regulator.
586  */
587 int
588 regnode_disable(struct regnode *regnode)
589 {
590 	int udelay;
591 	int rv;
592 
593 	REG_TOPO_ASSERT();
594 	rv = 0;
595 
596 	REGNODE_XLOCK(regnode);
597 	/* Disable regulator for each node in chain, starting from consumer. */
598 	if (regnode->enable_cnt == 1 &&
599 	    (regnode->flags & REGULATOR_FLAGS_NOT_DISABLE) == 0 &&
600 	    !regnode->std_param.always_on) {
601 		rv = REGNODE_ENABLE(regnode, false, &udelay);
602 		if (rv != 0) {
603 			REGNODE_UNLOCK(regnode);
604 			return (rv);
605 		}
606 		regnode_delay(udelay);
607 	}
608 	regnode->enable_cnt--;
609 	REGNODE_UNLOCK(regnode);
610 
611 	rv = regnode_resolve_parent(regnode);
612 	if (rv != 0)
613 		return (rv);
614 	if (regnode->parent != NULL)
615 		rv = regnode_disable(regnode->parent);
616 	return (rv);
617 }
618 
619 /*
620  * Stop regulator.
621  */
622 int
623 regnode_stop(struct regnode *regnode, int depth)
624 {
625 	int udelay;
626 	int rv;
627 
628 	REG_TOPO_ASSERT();
629 	rv = 0;
630 
631 	REGNODE_XLOCK(regnode);
632 	/* The first node must not be enabled. */
633 	if ((regnode->enable_cnt != 0) && (depth == 0)) {
634 		REGNODE_UNLOCK(regnode);
635 		return (EBUSY);
636 	}
637 	/* Disable regulator for each node in chain, starting from consumer */
638 	if ((regnode->enable_cnt == 0) &&
639 	    ((regnode->flags & REGULATOR_FLAGS_NOT_DISABLE) == 0)) {
640 		rv = REGNODE_STOP(regnode, &udelay);
641 		if (rv != 0) {
642 			REGNODE_UNLOCK(regnode);
643 			return (rv);
644 		}
645 		regnode_delay(udelay);
646 	}
647 	REGNODE_UNLOCK(regnode);
648 
649 	rv = regnode_resolve_parent(regnode);
650 	if (rv != 0)
651 		return (rv);
652 	if (regnode->parent != NULL && regnode->parent->enable_cnt == 0)
653 		rv = regnode_stop(regnode->parent, depth + 1);
654 	return (rv);
655 }
656 
657 /*
658  * Get regulator status. (REGULATOR_STATUS_*)
659  */
660 int
661 regnode_status(struct regnode *regnode, int *status)
662 {
663 	int rv;
664 
665 	REG_TOPO_ASSERT();
666 
667 	REGNODE_XLOCK(regnode);
668 	rv = REGNODE_STATUS(regnode, status);
669 	REGNODE_UNLOCK(regnode);
670 	return (rv);
671 }
672 
673 /*
674  * Get actual regulator voltage.
675  */
676 int
677 regnode_get_voltage(struct regnode *regnode, int *uvolt)
678 {
679 	int rv;
680 
681 	REG_TOPO_ASSERT();
682 
683 	REGNODE_XLOCK(regnode);
684 	rv = REGNODE_GET_VOLTAGE(regnode, uvolt);
685 	REGNODE_UNLOCK(regnode);
686 
687 	/* Pass call into parent, if regulator is in bypass mode. */
688 	if (rv == ENOENT) {
689 		rv = regnode_resolve_parent(regnode);
690 		if (rv != 0)
691 			return (rv);
692 		if (regnode->parent != NULL)
693 			rv = regnode_get_voltage(regnode->parent, uvolt);
694 
695 	}
696 	return (rv);
697 }
698 
699 /*
700  * Set regulator voltage.
701  */
702 int
703 regnode_set_voltage(struct regnode *regnode, int min_uvolt, int max_uvolt)
704 {
705 	int udelay;
706 	int rv;
707 
708 	REG_TOPO_ASSERT();
709 
710 	REGNODE_XLOCK(regnode);
711 
712 	rv = REGNODE_SET_VOLTAGE(regnode, min_uvolt, max_uvolt, &udelay);
713 	if (rv == 0)
714 		regnode_delay(udelay);
715 	REGNODE_UNLOCK(regnode);
716 	return (rv);
717 }
718 
719 /*
720  * Consumer variant of regnode_set_voltage().
721  */
722 static int
723 regnode_set_voltage_checked(struct regnode *regnode, struct regulator *reg,
724     int min_uvolt, int max_uvolt)
725 {
726 	int udelay;
727 	int all_max_uvolt;
728 	int all_min_uvolt;
729 	struct regulator *tmp;
730 	int rv;
731 
732 	REG_TOPO_ASSERT();
733 
734 	REGNODE_XLOCK(regnode);
735 	/* Return error if requested range is outside of regulator range. */
736 	if ((min_uvolt > regnode->std_param.max_uvolt) ||
737 	    (max_uvolt < regnode->std_param.min_uvolt)) {
738 		REGNODE_UNLOCK(regnode);
739 		return (ERANGE);
740 	}
741 
742 	/* Get actual voltage range for all consumers. */
743 	all_min_uvolt = regnode->std_param.min_uvolt;
744 	all_max_uvolt = regnode->std_param.max_uvolt;
745 	TAILQ_FOREACH(tmp, &regnode->consumers_list, link) {
746 		/* Don't take requestor in account. */
747 		if (tmp == reg)
748 			continue;
749 		if (all_min_uvolt < tmp->min_uvolt)
750 			all_min_uvolt = tmp->min_uvolt;
751 		if (all_max_uvolt > tmp->max_uvolt)
752 			all_max_uvolt = tmp->max_uvolt;
753 	}
754 
755 	/* Test if request fits to actual contract. */
756 	if ((min_uvolt > all_max_uvolt) ||
757 	    (max_uvolt < all_min_uvolt)) {
758 		REGNODE_UNLOCK(regnode);
759 		return (ERANGE);
760 	}
761 
762 	/* Adjust new range.*/
763 	if (min_uvolt < all_min_uvolt)
764 		min_uvolt = all_min_uvolt;
765 	if (max_uvolt > all_max_uvolt)
766 		max_uvolt = all_max_uvolt;
767 
768 	rv = REGNODE_SET_VOLTAGE(regnode, min_uvolt, max_uvolt, &udelay);
769 	regnode_delay(udelay);
770 	REGNODE_UNLOCK(regnode);
771 	return (rv);
772 }
773 
774 #ifdef FDT
775 phandle_t
776 regnode_get_ofw_node(struct regnode *regnode)
777 {
778 
779 	return (regnode->ofw_node);
780 }
781 #endif
782 
783 /* --------------------------------------------------------------------------
784  *
785  * Regulator consumers interface.
786  *
787  */
788 /* Helper function for regulator_get*() */
789 static regulator_t
790 regulator_create(struct regnode *regnode, device_t cdev)
791 {
792 	struct regulator *reg;
793 
794 	REG_TOPO_ASSERT();
795 
796 	reg =  malloc(sizeof(struct regulator), M_REGULATOR,
797 	    M_WAITOK | M_ZERO);
798 	reg->cdev = cdev;
799 	reg->regnode = regnode;
800 	reg->enable_cnt = 0;
801 
802 	REGNODE_XLOCK(regnode);
803 	regnode->ref_cnt++;
804 	TAILQ_INSERT_TAIL(&regnode->consumers_list, reg, link);
805 	reg ->min_uvolt = regnode->std_param.min_uvolt;
806 	reg ->max_uvolt = regnode->std_param.max_uvolt;
807 	REGNODE_UNLOCK(regnode);
808 
809 	return (reg);
810 }
811 
812 int
813 regulator_enable(regulator_t reg)
814 {
815 	int rv;
816 	struct regnode *regnode;
817 
818 	regnode = reg->regnode;
819 	KASSERT(regnode->ref_cnt > 0,
820 	   ("Attempt to access unreferenced regulator: %s\n", regnode->name));
821 	REG_TOPO_SLOCK();
822 	rv = regnode_enable(regnode);
823 	if (rv == 0)
824 		reg->enable_cnt++;
825 	REG_TOPO_UNLOCK();
826 	return (rv);
827 }
828 
829 int
830 regulator_disable(regulator_t reg)
831 {
832 	int rv;
833 	struct regnode *regnode;
834 
835 	regnode = reg->regnode;
836 	KASSERT(regnode->ref_cnt > 0,
837 	   ("Attempt to access unreferenced regulator: %s\n", regnode->name));
838 	KASSERT(reg->enable_cnt > 0,
839 	   ("Attempt to disable already disabled regulator: %s\n",
840 	   regnode->name));
841 	REG_TOPO_SLOCK();
842 	rv = regnode_disable(regnode);
843 	if (rv == 0)
844 		reg->enable_cnt--;
845 	REG_TOPO_UNLOCK();
846 	return (rv);
847 }
848 
849 int
850 regulator_stop(regulator_t reg)
851 {
852 	int rv;
853 	struct regnode *regnode;
854 
855 	regnode = reg->regnode;
856 	KASSERT(regnode->ref_cnt > 0,
857 	   ("Attempt to access unreferenced regulator: %s\n", regnode->name));
858 	KASSERT(reg->enable_cnt == 0,
859 	   ("Attempt to stop already enabled regulator: %s\n", regnode->name));
860 
861 	REG_TOPO_SLOCK();
862 	rv = regnode_stop(regnode, 0);
863 	REG_TOPO_UNLOCK();
864 	return (rv);
865 }
866 
867 int
868 regulator_status(regulator_t reg, int *status)
869 {
870 	int rv;
871 	struct regnode *regnode;
872 
873 	regnode = reg->regnode;
874 	KASSERT(regnode->ref_cnt > 0,
875 	   ("Attempt to access unreferenced regulator: %s\n", regnode->name));
876 
877 	REG_TOPO_SLOCK();
878 	rv = regnode_status(regnode, status);
879 	REG_TOPO_UNLOCK();
880 	return (rv);
881 }
882 
883 int
884 regulator_get_voltage(regulator_t reg, int *uvolt)
885 {
886 	int rv;
887 	struct regnode *regnode;
888 
889 	regnode = reg->regnode;
890 	KASSERT(regnode->ref_cnt > 0,
891 	   ("Attempt to access unreferenced regulator: %s\n", regnode->name));
892 
893 	REG_TOPO_SLOCK();
894 	rv = regnode_get_voltage(regnode, uvolt);
895 	REG_TOPO_UNLOCK();
896 	return (rv);
897 }
898 
899 int
900 regulator_set_voltage(regulator_t reg, int min_uvolt, int max_uvolt)
901 {
902 	struct regnode *regnode;
903 	int rv;
904 
905 	regnode = reg->regnode;
906 	KASSERT(regnode->ref_cnt > 0,
907 	   ("Attempt to access unreferenced regulator: %s\n", regnode->name));
908 
909 	REG_TOPO_SLOCK();
910 
911 	rv = regnode_set_voltage_checked(regnode, reg, min_uvolt, max_uvolt);
912 	if (rv == 0) {
913 		reg->min_uvolt = min_uvolt;
914 		reg->max_uvolt = max_uvolt;
915 	}
916 	REG_TOPO_UNLOCK();
917 	return (rv);
918 }
919 
920 const char *
921 regulator_get_name(regulator_t reg)
922 {
923 	struct regnode *regnode;
924 
925 	regnode = reg->regnode;
926 	KASSERT(regnode->ref_cnt > 0,
927 	   ("Attempt to access unreferenced regulator: %s\n", regnode->name));
928 	return (regnode->name);
929 }
930 
931 int
932 regulator_get_by_name(device_t cdev, const char *name, regulator_t *reg)
933 {
934 	struct regnode *regnode;
935 
936 	REG_TOPO_SLOCK();
937 	regnode = regnode_find_by_name(name);
938 	if (regnode == NULL) {
939 		REG_TOPO_UNLOCK();
940 		return (ENODEV);
941 	}
942 	*reg = regulator_create(regnode, cdev);
943 	REG_TOPO_UNLOCK();
944 	return (0);
945 }
946 
947 int
948 regulator_get_by_id(device_t cdev, device_t pdev, intptr_t id, regulator_t *reg)
949 {
950 	struct regnode *regnode;
951 
952 	REG_TOPO_SLOCK();
953 
954 	regnode = regnode_find_by_id(pdev, id);
955 	if (regnode == NULL) {
956 		REG_TOPO_UNLOCK();
957 		return (ENODEV);
958 	}
959 	*reg = regulator_create(regnode, cdev);
960 	REG_TOPO_UNLOCK();
961 
962 	return (0);
963 }
964 
965 int
966 regulator_release(regulator_t reg)
967 {
968 	struct regnode *regnode;
969 
970 	regnode = reg->regnode;
971 	KASSERT(regnode->ref_cnt > 0,
972 	   ("Attempt to access unreferenced regulator: %s\n", regnode->name));
973 	REG_TOPO_SLOCK();
974 	while (reg->enable_cnt > 0) {
975 		regnode_disable(regnode);
976 		reg->enable_cnt--;
977 	}
978 	REGNODE_XLOCK(regnode);
979 	TAILQ_REMOVE(&regnode->consumers_list, reg, link);
980 	regnode->ref_cnt--;
981 	REGNODE_UNLOCK(regnode);
982 	REG_TOPO_UNLOCK();
983 
984 	free(reg, M_REGULATOR);
985 	return (0);
986 }
987 
988 #ifdef FDT
989 /* Default DT mapper. */
990 int
991 regdev_default_ofw_map(device_t dev, phandle_t 	xref, int ncells,
992     pcell_t *cells, intptr_t *id)
993 {
994 	if (ncells == 0)
995 		*id = 1;
996 	else if (ncells == 1)
997 		*id = cells[0];
998 	else
999 		return  (ERANGE);
1000 
1001 	return (0);
1002 }
1003 
1004 int
1005 regulator_parse_ofw_stdparam(device_t pdev, phandle_t node,
1006     struct regnode_init_def *def)
1007 {
1008 	phandle_t supply_xref;
1009 	struct regnode_std_param *par;
1010 	int rv;
1011 
1012 	par = &def->std_param;
1013 	rv = OF_getprop_alloc(node, "regulator-name",
1014 	    (void **)&def->name);
1015 	if (rv <= 0) {
1016 		device_printf(pdev, "%s: Missing regulator name\n",
1017 		 __func__);
1018 		return (ENXIO);
1019 	}
1020 
1021 	rv = OF_getencprop(node, "regulator-min-microvolt", &par->min_uvolt,
1022 	    sizeof(par->min_uvolt));
1023 	if (rv <= 0)
1024 		par->min_uvolt = 0;
1025 
1026 	rv = OF_getencprop(node, "regulator-max-microvolt", &par->max_uvolt,
1027 	    sizeof(par->max_uvolt));
1028 	if (rv <= 0)
1029 		par->max_uvolt = 0;
1030 
1031 	rv = OF_getencprop(node, "regulator-min-microamp", &par->min_uamp,
1032 	    sizeof(par->min_uamp));
1033 	if (rv <= 0)
1034 		par->min_uamp = 0;
1035 
1036 	rv = OF_getencprop(node, "regulator-max-microamp", &par->max_uamp,
1037 	    sizeof(par->max_uamp));
1038 	if (rv <= 0)
1039 		par->max_uamp = 0;
1040 
1041 	rv = OF_getencprop(node, "regulator-ramp-delay", &par->ramp_delay,
1042 	    sizeof(par->ramp_delay));
1043 	if (rv <= 0)
1044 		par->ramp_delay = 0;
1045 
1046 	rv = OF_getencprop(node, "regulator-enable-ramp-delay",
1047 	    &par->enable_delay, sizeof(par->enable_delay));
1048 	if (rv <= 0)
1049 		par->enable_delay = 0;
1050 
1051 	if (OF_hasprop(node, "regulator-boot-on"))
1052 		par->boot_on = true;
1053 
1054 	if (OF_hasprop(node, "regulator-always-on"))
1055 		par->always_on = true;
1056 
1057 	if (OF_hasprop(node, "enable-active-high"))
1058 		par->enable_active_high = 1;
1059 
1060 	rv = OF_getencprop(node, "vin-supply", &supply_xref,
1061 	    sizeof(supply_xref));
1062 	if (rv >=  0) {
1063 		rv = OF_getprop_alloc(supply_xref, "regulator-name",
1064 		    (void **)&def->parent_name);
1065 		if (rv <= 0)
1066 			def->parent_name = NULL;
1067 	}
1068 	return (0);
1069 }
1070 
1071 int
1072 regulator_get_by_ofw_property(device_t cdev, phandle_t cnode, char *name,
1073     regulator_t *reg)
1074 {
1075 	phandle_t *cells;
1076 	device_t regdev;
1077 	int ncells, rv;
1078 	intptr_t id;
1079 
1080 	*reg = NULL;
1081 
1082 	if (cnode <= 0)
1083 		cnode = ofw_bus_get_node(cdev);
1084 	if (cnode <= 0) {
1085 		device_printf(cdev, "%s called on not ofw based device\n",
1086 		 __func__);
1087 		return (ENXIO);
1088 	}
1089 
1090 	cells = NULL;
1091 	ncells = OF_getencprop_alloc_multi(cnode, name, sizeof(*cells),
1092 	    (void **)&cells);
1093 	if (ncells <= 0)
1094 		return (ENOENT);
1095 
1096 	/* Translate xref to device */
1097 	regdev = OF_device_from_xref(cells[0]);
1098 	if (regdev == NULL) {
1099 		OF_prop_free(cells);
1100 		return (ENODEV);
1101 	}
1102 
1103 	/* Map regulator to number */
1104 	rv = REGDEV_MAP(regdev, cells[0], ncells - 1, cells + 1, &id);
1105 	OF_prop_free(cells);
1106 	if (rv != 0)
1107 		return (rv);
1108 	return (regulator_get_by_id(cdev, regdev, id, reg));
1109 }
1110 #endif
1111 
1112 /* --------------------------------------------------------------------------
1113  *
1114  * Regulator utility functions.
1115  *
1116  */
1117 
1118 /* Convert raw selector value to real voltage */
1119 int
1120 regulator_range_sel8_to_volt(struct regulator_range *ranges, int nranges,
1121    uint8_t sel, int *volt)
1122 {
1123 	struct regulator_range *range;
1124 	int i;
1125 
1126 	if (nranges == 0)
1127 		panic("Voltage regulator have zero ranges\n");
1128 
1129 	for (i = 0; i < nranges ; i++) {
1130 		range = ranges  + i;
1131 
1132 		if (!(sel >= range->min_sel &&
1133 		      sel <= range->max_sel))
1134 			continue;
1135 
1136 		sel -= range->min_sel;
1137 
1138 		*volt = range->min_uvolt + sel * range->step_uvolt;
1139 		return (0);
1140 	}
1141 
1142 	return (ERANGE);
1143 }
1144 
1145 int
1146 regulator_range_volt_to_sel8(struct regulator_range *ranges, int nranges,
1147     int min_uvolt, int max_uvolt, uint8_t *out_sel)
1148 {
1149 	struct regulator_range *range;
1150 	uint8_t sel;
1151 	int uvolt;
1152 	int rv, i;
1153 
1154 	if (nranges == 0)
1155 		panic("Voltage regulator have zero ranges\n");
1156 
1157 	for (i = 0; i < nranges; i++) {
1158 		range = ranges  + i;
1159 		uvolt = range->min_uvolt +
1160 		    (range->max_sel - range->min_sel) * range->step_uvolt;
1161 
1162 		if ((min_uvolt > uvolt) ||
1163 		    (max_uvolt < range->min_uvolt))
1164 			continue;
1165 
1166 		if (min_uvolt <= range->min_uvolt)
1167 			min_uvolt = range->min_uvolt;
1168 
1169 		/* if step == 0 -> fixed voltage range. */
1170 		if (range->step_uvolt == 0)
1171 			sel = 0;
1172 		else
1173 			sel = DIV_ROUND_UP(min_uvolt - range->min_uvolt,
1174 			   range->step_uvolt);
1175 
1176 
1177 		sel += range->min_sel;
1178 
1179 		break;
1180 	}
1181 
1182 	if (i >= nranges)
1183 		return (ERANGE);
1184 
1185 	/* Verify new settings. */
1186 	rv = regulator_range_sel8_to_volt(ranges, nranges, sel, &uvolt);
1187 	if (rv != 0)
1188 		return (rv);
1189 	if ((uvolt < min_uvolt) || (uvolt > max_uvolt))
1190 		return (ERANGE);
1191 
1192 	*out_sel = sel;
1193 	return (0);
1194 }
1195