2 * Copyright 2016 Michal Meloun <mmel@FreeBSD.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
30 #include "opt_platform.h"
31 #include <sys/param.h>
34 #include <sys/kernel.h>
35 #include <sys/queue.h>
37 #include <sys/malloc.h>
38 #include <sys/mutex.h>
39 #include <sys/limits.h>
41 #include <sys/sysctl.h>
42 #include <sys/systm.h>
46 #include <dev/fdt/fdt_common.h>
47 #include <dev/ofw/ofw_bus.h>
48 #include <dev/ofw/ofw_bus_subr.h>
50 #include <dev/extres/regulator/regulator.h>
52 #include "regdev_if.h"
54 SYSCTL_NODE(_hw, OID_AUTO, regulator, CTLFLAG_RD, NULL, "Regulators");
56 MALLOC_DEFINE(M_REGULATOR, "regulator", "Regulator framework");
58 #define DIV_ROUND_UP(n,d) howmany(n, d)
60 /* Forward declarations. */
64 typedef TAILQ_HEAD(regnode_list, regnode) regnode_list_t;
65 typedef TAILQ_HEAD(regulator_list, regulator) regulator_list_t;
67 /* Default regulator methods. */
68 static int regnode_method_enable(struct regnode *regnode, bool enable,
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);
77 * Regulator controller methods.
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),
87 DEFINE_CLASS_0(regnode, regnode_class, regnode_methods, 0);
90 * Regulator node - basic element for modelling SOC and bard power supply
91 * chains. Its contains producer data.
96 TAILQ_ENTRY(regnode) reglist_link; /* Global list entry */
97 regulator_list_t consumers_list; /* Consumers list */
99 /* Cache for already resolved names */
100 struct regnode *parent; /* Resolved parent */
102 /* Details of this device. */
103 const char *name; /* Globally unique name */
104 const char *parent_name; /* Parent name */
106 device_t pdev; /* Producer device_t */
107 void *softc; /* Producer softc */
108 intptr_t id; /* Per producer unique id */
110 phandle_t ofw_node; /* OFW node of regulator */
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 */
117 struct regnode_std_param std_param; /* Standard parameters */
119 struct sysctl_ctx_list sysctl_ctx;
123 * Per consumer data, information about how a consumer is using a regulator
125 * A pointer to this structure is used as a handle in the consumer interface.
128 device_t cdev; /* Consumer device */
129 struct regnode *regnode;
130 TAILQ_ENTRY(regulator) link; /* Consumers list entry */
133 int min_uvolt; /* Requested uvolt range */
138 * Regulator names must be system wide unique.
140 static regnode_list_t regnode_list = TAILQ_HEAD_INITIALIZER(regnode_list);
142 static struct sx regnode_topo_lock;
143 SX_SYSINIT(regulator_topology, ®node_topo_lock, "Regulator topology lock");
145 #define REG_TOPO_SLOCK() sx_slock(®node_topo_lock)
146 #define REG_TOPO_XLOCK() sx_xlock(®node_topo_lock)
147 #define REG_TOPO_UNLOCK() sx_unlock(®node_topo_lock)
148 #define REG_TOPO_ASSERT() sx_assert(®node_topo_lock, SA_LOCKED)
149 #define REG_TOPO_XASSERT() sx_assert(®node_topo_lock, SA_XLOCKED)
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))
155 SYSINIT(regulator_shutdown, SI_SUB_LAST, SI_ORDER_ANY, regulator_shutdown,
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.
166 regulator_shutdown(void *dummy)
168 struct regnode *entry;
173 TUNABLE_INT_FETCH("hw.regulator.disable_unused", &disable);
174 TAILQ_FOREACH(entry, ®node_list, reglist_link) {
175 if (!entry->std_param.always_on && disable) {
177 printf("regulator: shutting down %s\n",
179 ret = regnode_status(entry, &status);
180 if (ret == 0 && status == REGULATOR_STATUS_ENABLED)
181 regnode_stop(entry, 0);
191 regnode_uvolt_sysctl(SYSCTL_HANDLER_ARGS)
193 struct regnode *regnode = arg1;
196 if (regnode->std_param.min_uvolt == regnode->std_param.max_uvolt) {
197 uvolt = regnode->std_param.min_uvolt;
200 if ((rv = regnode_get_voltage(regnode, &uvolt)) != 0) {
207 return sysctl_handle_int(oidp, &uvolt, sizeof(uvolt), req);
210 /* ----------------------------------------------------------------------------
212 * Default regulator methods for base class.
216 regnode_method_enable(struct regnode *regnode, bool enable, int *udelay)
227 regnode_method_status(struct regnode *regnode, int *status)
229 *status = REGULATOR_STATUS_ENABLED;
234 regnode_method_set_voltage(struct regnode *regnode, int min_uvolt, int max_uvolt,
238 if ((min_uvolt > regnode->std_param.max_uvolt) ||
239 (max_uvolt < regnode->std_param.min_uvolt))
246 regnode_method_get_voltage(struct regnode *regnode, int *uvolt)
249 return (regnode->std_param.min_uvolt +
250 (regnode->std_param.max_uvolt - regnode->std_param.min_uvolt) / 2);
253 /* ----------------------------------------------------------------------------
255 * Internal functions.
259 static struct regnode *
260 regnode_find_by_name(const char *name)
262 struct regnode *entry;
266 TAILQ_FOREACH(entry, ®node_list, reglist_link) {
267 if (strcmp(entry->name, name) == 0)
273 static struct regnode *
274 regnode_find_by_id(device_t dev, intptr_t id)
276 struct regnode *entry;
280 TAILQ_FOREACH(entry, ®node_list, reglist_link) {
281 if ((entry->pdev == dev) && (entry->id == id))
289 * Create and initialize regulator object, but do not register it.
292 regnode_create(device_t pdev, regnode_class_t regnode_class,
293 struct regnode_init_def *def)
295 struct regnode *regnode;
296 struct sysctl_oid *regnode_oid;
298 KASSERT(def->name != NULL, ("regulator name is NULL"));
299 KASSERT(def->name[0] != '\0', ("regulator name is empty"));
302 if (regnode_find_by_name(def->name) != NULL)
303 panic("Duplicated regulator registration: %s\n", def->name);
306 /* Create object and initialize it. */
307 regnode = malloc(sizeof(struct regnode), M_REGULATOR,
309 kobj_init((kobj_t)regnode, (kobj_class_t)regnode_class);
310 sx_init(®node->lock, "Regulator node lock");
312 /* Allocate softc if required. */
313 if (regnode_class->size > 0) {
314 regnode->softc = malloc(regnode_class->size, M_REGULATOR,
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;
324 regnode->name = strdup(def->name, M_REGULATOR);
325 if (def->parent_name != NULL)
326 regnode->parent_name = strdup(def->parent_name,
331 TAILQ_INIT(®node->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;
338 regnode->ofw_node = def->ofw_node;
341 sysctl_ctx_init(®node->sysctl_ctx);
342 regnode_oid = SYSCTL_ADD_NODE(®node->sysctl_ctx,
343 SYSCTL_STATIC_CHILDREN(_hw_regulator),
344 OID_AUTO, regnode->name,
345 CTLFLAG_RD, 0, "A regulator node");
347 SYSCTL_ADD_INT(®node->sysctl_ctx,
348 SYSCTL_CHILDREN(regnode_oid),
349 OID_AUTO, "min_uvolt",
350 CTLFLAG_RD, ®node->std_param.min_uvolt, 0,
351 "Minimal voltage (in uV)");
352 SYSCTL_ADD_INT(®node->sysctl_ctx,
353 SYSCTL_CHILDREN(regnode_oid),
354 OID_AUTO, "max_uvolt",
355 CTLFLAG_RD, ®node->std_param.max_uvolt, 0,
356 "Maximal voltage (in uV)");
357 SYSCTL_ADD_INT(®node->sysctl_ctx,
358 SYSCTL_CHILDREN(regnode_oid),
359 OID_AUTO, "min_uamp",
360 CTLFLAG_RD, ®node->std_param.min_uamp, 0,
361 "Minimal amperage (in uA)");
362 SYSCTL_ADD_INT(®node->sysctl_ctx,
363 SYSCTL_CHILDREN(regnode_oid),
364 OID_AUTO, "max_uamp",
365 CTLFLAG_RD, ®node->std_param.max_uamp, 0,
366 "Maximal amperage (in uA)");
367 SYSCTL_ADD_INT(®node->sysctl_ctx,
368 SYSCTL_CHILDREN(regnode_oid),
369 OID_AUTO, "ramp_delay",
370 CTLFLAG_RD, ®node->std_param.ramp_delay, 0,
371 "Ramp delay (in uV/us)");
372 SYSCTL_ADD_INT(®node->sysctl_ctx,
373 SYSCTL_CHILDREN(regnode_oid),
374 OID_AUTO, "enable_delay",
375 CTLFLAG_RD, ®node->std_param.enable_delay, 0,
376 "Enable delay (in us)");
377 SYSCTL_ADD_INT(®node->sysctl_ctx,
378 SYSCTL_CHILDREN(regnode_oid),
379 OID_AUTO, "enable_cnt",
380 CTLFLAG_RD, ®node->enable_cnt, 0,
381 "The regulator enable counter");
382 SYSCTL_ADD_U8(®node->sysctl_ctx,
383 SYSCTL_CHILDREN(regnode_oid),
385 CTLFLAG_RD, (uint8_t *) ®node->std_param.boot_on, 0,
386 "Is enabled on boot");
387 SYSCTL_ADD_U8(®node->sysctl_ctx,
388 SYSCTL_CHILDREN(regnode_oid),
389 OID_AUTO, "always_on",
390 CTLFLAG_RD, (uint8_t *)®node->std_param.always_on, 0,
391 "Is always enabled");
393 SYSCTL_ADD_PROC(®node->sysctl_ctx,
394 SYSCTL_CHILDREN(regnode_oid),
396 CTLTYPE_INT | CTLFLAG_RD,
397 regnode, 0, regnode_uvolt_sysctl,
399 "Current voltage (in uV)");
404 /* Register regulator object. */
406 regnode_register(struct regnode *regnode)
411 if (regnode->ofw_node <= 0)
412 regnode->ofw_node = ofw_bus_get_node(regnode->pdev);
413 if (regnode->ofw_node <= 0)
417 rv = REGNODE_INIT(regnode);
419 printf("REGNODE_INIT failed: %d\n", rv);
424 TAILQ_INSERT_TAIL(®node_list, regnode, reglist_link);
427 OF_device_register_xref(OF_xref_from_node(regnode->ofw_node),
434 regnode_resolve_parent(struct regnode *regnode)
437 /* All ready resolved or no parent? */
438 if ((regnode->parent != NULL) ||
439 (regnode->parent_name == NULL))
442 regnode->parent = regnode_find_by_name(regnode->parent_name);
443 if (regnode->parent == NULL)
449 regnode_delay(int usec)
455 ticks = (usec * hz + 999999) / 1000000;
457 if (cold || ticks < 2)
460 pause("REGULATOR", ticks);
463 /* --------------------------------------------------------------------------
465 * Regulator providers interface
470 regnode_get_name(struct regnode *regnode)
473 return (regnode->name);
477 regnode_get_parent_name(struct regnode *regnode)
480 return (regnode->parent_name);
484 regnode_get_flags(struct regnode *regnode)
487 return (regnode->flags);
491 regnode_get_softc(struct regnode *regnode)
494 return (regnode->softc);
498 regnode_get_device(struct regnode *regnode)
501 return (regnode->pdev);
504 struct regnode_std_param *regnode_get_stdparam(struct regnode *regnode)
507 return (®node->std_param);
510 void regnode_topo_unlock(void)
516 void regnode_topo_xlock(void)
522 void regnode_topo_slock(void)
529 /* --------------------------------------------------------------------------
531 * Real consumers executive
535 regnode_get_parent(struct regnode *regnode)
541 rv = regnode_resolve_parent(regnode);
545 return (regnode->parent);
552 regnode_enable(struct regnode *regnode)
559 /* Enable regulator for each node in chain, starting from source. */
560 rv = regnode_resolve_parent(regnode);
563 if (regnode->parent != NULL) {
564 rv = regnode_enable(regnode->parent);
569 /* Handle this node. */
570 REGNODE_XLOCK(regnode);
571 if (regnode->enable_cnt == 0) {
572 rv = REGNODE_ENABLE(regnode, true, &udelay);
574 REGNODE_UNLOCK(regnode);
577 regnode_delay(udelay);
579 regnode->enable_cnt++;
580 REGNODE_UNLOCK(regnode);
588 regnode_disable(struct regnode *regnode)
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);
603 REGNODE_UNLOCK(regnode);
606 regnode_delay(udelay);
608 regnode->enable_cnt--;
609 REGNODE_UNLOCK(regnode);
611 rv = regnode_resolve_parent(regnode);
614 if (regnode->parent != NULL)
615 rv = regnode_disable(regnode->parent);
623 regnode_stop(struct regnode *regnode, int depth)
631 REGNODE_XLOCK(regnode);
632 /* The first node must not be enabled. */
633 if ((regnode->enable_cnt != 0) && (depth == 0)) {
634 REGNODE_UNLOCK(regnode);
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);
642 REGNODE_UNLOCK(regnode);
645 regnode_delay(udelay);
647 REGNODE_UNLOCK(regnode);
649 rv = regnode_resolve_parent(regnode);
652 if (regnode->parent != NULL && regnode->parent->enable_cnt == 0)
653 rv = regnode_stop(regnode->parent, depth + 1);
658 * Get regulator status. (REGULATOR_STATUS_*)
661 regnode_status(struct regnode *regnode, int *status)
667 REGNODE_XLOCK(regnode);
668 rv = REGNODE_STATUS(regnode, status);
669 REGNODE_UNLOCK(regnode);
674 * Get actual regulator voltage.
677 regnode_get_voltage(struct regnode *regnode, int *uvolt)
683 REGNODE_XLOCK(regnode);
684 rv = REGNODE_GET_VOLTAGE(regnode, uvolt);
685 REGNODE_UNLOCK(regnode);
687 /* Pass call into parent, if regulator is in bypass mode. */
689 rv = regnode_resolve_parent(regnode);
692 if (regnode->parent != NULL)
693 rv = regnode_get_voltage(regnode->parent, uvolt);
700 * Set regulator voltage.
703 regnode_set_voltage(struct regnode *regnode, int min_uvolt, int max_uvolt)
710 REGNODE_XLOCK(regnode);
712 rv = REGNODE_SET_VOLTAGE(regnode, min_uvolt, max_uvolt, &udelay);
714 regnode_delay(udelay);
715 REGNODE_UNLOCK(regnode);
720 * Consumer variant of regnode_set_voltage().
723 regnode_set_voltage_checked(struct regnode *regnode, struct regulator *reg,
724 int min_uvolt, int max_uvolt)
729 struct regulator *tmp;
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);
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, ®node->consumers_list, link) {
746 /* Don't take requestor in account. */
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;
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);
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;
768 rv = REGNODE_SET_VOLTAGE(regnode, min_uvolt, max_uvolt, &udelay);
769 regnode_delay(udelay);
770 REGNODE_UNLOCK(regnode);
776 regnode_get_ofw_node(struct regnode *regnode)
779 return (regnode->ofw_node);
783 /* --------------------------------------------------------------------------
785 * Regulator consumers interface.
788 /* Helper function for regulator_get*() */
790 regulator_create(struct regnode *regnode, device_t cdev)
792 struct regulator *reg;
796 reg = malloc(sizeof(struct regulator), M_REGULATOR,
799 reg->regnode = regnode;
802 REGNODE_XLOCK(regnode);
804 TAILQ_INSERT_TAIL(®node->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);
813 regulator_enable(regulator_t reg)
816 struct regnode *regnode;
818 regnode = reg->regnode;
819 KASSERT(regnode->ref_cnt > 0,
820 ("Attempt to access unreferenced regulator: %s\n", regnode->name));
822 rv = regnode_enable(regnode);
830 regulator_disable(regulator_t reg)
833 struct regnode *regnode;
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",
842 rv = regnode_disable(regnode);
850 regulator_stop(regulator_t reg)
853 struct regnode *regnode;
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));
862 rv = regnode_stop(regnode, 0);
868 regulator_status(regulator_t reg, int *status)
871 struct regnode *regnode;
873 regnode = reg->regnode;
874 KASSERT(regnode->ref_cnt > 0,
875 ("Attempt to access unreferenced regulator: %s\n", regnode->name));
878 rv = regnode_status(regnode, status);
884 regulator_get_voltage(regulator_t reg, int *uvolt)
887 struct regnode *regnode;
889 regnode = reg->regnode;
890 KASSERT(regnode->ref_cnt > 0,
891 ("Attempt to access unreferenced regulator: %s\n", regnode->name));
894 rv = regnode_get_voltage(regnode, uvolt);
900 regulator_set_voltage(regulator_t reg, int min_uvolt, int max_uvolt)
902 struct regnode *regnode;
905 regnode = reg->regnode;
906 KASSERT(regnode->ref_cnt > 0,
907 ("Attempt to access unreferenced regulator: %s\n", regnode->name));
911 rv = regnode_set_voltage_checked(regnode, reg, min_uvolt, max_uvolt);
913 reg->min_uvolt = min_uvolt;
914 reg->max_uvolt = max_uvolt;
921 regulator_get_name(regulator_t reg)
923 struct regnode *regnode;
925 regnode = reg->regnode;
926 KASSERT(regnode->ref_cnt > 0,
927 ("Attempt to access unreferenced regulator: %s\n", regnode->name));
928 return (regnode->name);
932 regulator_get_by_name(device_t cdev, const char *name, regulator_t *reg)
934 struct regnode *regnode;
937 regnode = regnode_find_by_name(name);
938 if (regnode == NULL) {
942 *reg = regulator_create(regnode, cdev);
948 regulator_get_by_id(device_t cdev, device_t pdev, intptr_t id, regulator_t *reg)
950 struct regnode *regnode;
954 regnode = regnode_find_by_id(pdev, id);
955 if (regnode == NULL) {
959 *reg = regulator_create(regnode, cdev);
966 regulator_release(regulator_t reg)
968 struct regnode *regnode;
970 regnode = reg->regnode;
971 KASSERT(regnode->ref_cnt > 0,
972 ("Attempt to access unreferenced regulator: %s\n", regnode->name));
974 while (reg->enable_cnt > 0) {
975 regnode_disable(regnode);
978 REGNODE_XLOCK(regnode);
979 TAILQ_REMOVE(®node->consumers_list, reg, link);
981 REGNODE_UNLOCK(regnode);
984 free(reg, M_REGULATOR);
989 /* Default DT mapper. */
991 regdev_default_ofw_map(device_t dev, phandle_t xref, int ncells,
992 pcell_t *cells, intptr_t *id)
996 else if (ncells == 1)
1005 regulator_parse_ofw_stdparam(device_t pdev, phandle_t node,
1006 struct regnode_init_def *def)
1008 phandle_t supply_xref;
1009 struct regnode_std_param *par;
1012 par = &def->std_param;
1013 rv = OF_getprop_alloc(node, "regulator-name",
1014 (void **)&def->name);
1016 device_printf(pdev, "%s: Missing regulator name\n",
1021 rv = OF_getencprop(node, "regulator-min-microvolt", &par->min_uvolt,
1022 sizeof(par->min_uvolt));
1026 rv = OF_getencprop(node, "regulator-max-microvolt", &par->max_uvolt,
1027 sizeof(par->max_uvolt));
1031 rv = OF_getencprop(node, "regulator-min-microamp", &par->min_uamp,
1032 sizeof(par->min_uamp));
1036 rv = OF_getencprop(node, "regulator-max-microamp", &par->max_uamp,
1037 sizeof(par->max_uamp));
1041 rv = OF_getencprop(node, "regulator-ramp-delay", &par->ramp_delay,
1042 sizeof(par->ramp_delay));
1044 par->ramp_delay = 0;
1046 rv = OF_getencprop(node, "regulator-enable-ramp-delay",
1047 &par->enable_delay, sizeof(par->enable_delay));
1049 par->enable_delay = 0;
1051 if (OF_hasprop(node, "regulator-boot-on"))
1052 par->boot_on = true;
1054 if (OF_hasprop(node, "regulator-always-on"))
1055 par->always_on = true;
1057 if (OF_hasprop(node, "enable-active-high"))
1058 par->enable_active_high = 1;
1060 rv = OF_getencprop(node, "vin-supply", &supply_xref,
1061 sizeof(supply_xref));
1063 rv = OF_getprop_alloc(supply_xref, "regulator-name",
1064 (void **)&def->parent_name);
1066 def->parent_name = NULL;
1072 regulator_get_by_ofw_property(device_t cdev, phandle_t cnode, char *name,
1083 cnode = ofw_bus_get_node(cdev);
1085 device_printf(cdev, "%s called on not ofw based device\n",
1091 ncells = OF_getencprop_alloc_multi(cnode, name, sizeof(*cells),
1096 /* Translate xref to device */
1097 regdev = OF_device_from_xref(cells[0]);
1098 if (regdev == NULL) {
1099 OF_prop_free(cells);
1103 /* Map regulator to number */
1104 rv = REGDEV_MAP(regdev, cells[0], ncells - 1, cells + 1, &id);
1105 OF_prop_free(cells);
1108 return (regulator_get_by_id(cdev, regdev, id, reg));
1112 /* --------------------------------------------------------------------------
1114 * Regulator utility functions.
1118 /* Convert raw selector value to real voltage */
1120 regulator_range_sel8_to_volt(struct regulator_range *ranges, int nranges,
1121 uint8_t sel, int *volt)
1123 struct regulator_range *range;
1127 panic("Voltage regulator have zero ranges\n");
1129 for (i = 0; i < nranges ; i++) {
1132 if (!(sel >= range->min_sel &&
1133 sel <= range->max_sel))
1136 sel -= range->min_sel;
1138 *volt = range->min_uvolt + sel * range->step_uvolt;
1146 regulator_range_volt_to_sel8(struct regulator_range *ranges, int nranges,
1147 int min_uvolt, int max_uvolt, uint8_t *out_sel)
1149 struct regulator_range *range;
1155 panic("Voltage regulator have zero ranges\n");
1157 for (i = 0; i < nranges; i++) {
1159 uvolt = range->min_uvolt +
1160 (range->max_sel - range->min_sel) * range->step_uvolt;
1162 if ((min_uvolt > uvolt) ||
1163 (max_uvolt < range->min_uvolt))
1166 if (min_uvolt <= range->min_uvolt)
1167 min_uvolt = range->min_uvolt;
1169 /* if step == 0 -> fixed voltage range. */
1170 if (range->step_uvolt == 0)
1173 sel = DIV_ROUND_UP(min_uvolt - range->min_uvolt,
1177 sel += range->min_sel;
1185 /* Verify new settings. */
1186 rv = regulator_range_sel8_to_volt(ranges, nranges, sel, &uvolt);
1189 if ((uvolt < min_uvolt) || (uvolt > max_uvolt))