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 MALLOC_DEFINE(M_REGULATOR, "regulator", "Regulator framework");
56 #define DIV_ROUND_UP(n,d) howmany(n, d)
58 /* Forward declarations. */
62 typedef TAILQ_HEAD(regnode_list, regnode) regnode_list_t;
63 typedef TAILQ_HEAD(regulator_list, regulator) regulator_list_t;
65 /* Default regulator methods. */
66 static int regnode_method_enable(struct regnode *regnode, bool enable,
68 static int regnode_method_status(struct regnode *regnode, int *status);
69 static int regnode_method_set_voltage(struct regnode *regnode, int min_uvolt,
70 int max_uvolt, int *udelay);
71 static int regnode_method_get_voltage(struct regnode *regnode, int *uvolt);
74 * Regulator controller methods.
76 static regnode_method_t regnode_methods[] = {
77 REGNODEMETHOD(regnode_enable, regnode_method_enable),
78 REGNODEMETHOD(regnode_status, regnode_method_status),
79 REGNODEMETHOD(regnode_set_voltage, regnode_method_set_voltage),
80 REGNODEMETHOD(regnode_get_voltage, regnode_method_get_voltage),
84 DEFINE_CLASS_0(regnode, regnode_class, regnode_methods, 0);
87 * Regulator node - basic element for modelling SOC and bard power supply
88 * chains. Its contains producer data.
93 TAILQ_ENTRY(regnode) reglist_link; /* Global list entry */
94 regulator_list_t consumers_list; /* Consumers list */
96 /* Cache for already resolved names */
97 struct regnode *parent; /* Resolved parent */
99 /* Details of this device. */
100 const char *name; /* Globally unique name */
101 const char *parent_name; /* Parent name */
103 device_t pdev; /* Producer device_t */
104 void *softc; /* Producer softc */
105 intptr_t id; /* Per producer unique id */
107 phandle_t ofw_node; /* OFW node of regulator */
109 int flags; /* REGULATOR_FLAGS_ */
110 struct sx lock; /* Lock for this regulator */
111 int ref_cnt; /* Reference counter */
112 int enable_cnt; /* Enabled counter */
114 struct regnode_std_param std_param; /* Standard parameters */
118 * Per consumer data, information about how a consumer is using a regulator
120 * A pointer to this structure is used as a handle in the consumer interface.
123 device_t cdev; /* Consumer device */
124 struct regnode *regnode;
125 TAILQ_ENTRY(regulator) link; /* Consumers list entry */
128 int min_uvolt; /* Requested uvolt range */
133 * Regulator names must be system wide unique.
135 static regnode_list_t regnode_list = TAILQ_HEAD_INITIALIZER(regnode_list);
137 static struct sx regnode_topo_lock;
138 SX_SYSINIT(regulator_topology, ®node_topo_lock, "Regulator topology lock");
140 #define REG_TOPO_SLOCK() sx_slock(®node_topo_lock)
141 #define REG_TOPO_XLOCK() sx_xlock(®node_topo_lock)
142 #define REG_TOPO_UNLOCK() sx_unlock(®node_topo_lock)
143 #define REG_TOPO_ASSERT() sx_assert(®node_topo_lock, SA_LOCKED)
144 #define REG_TOPO_XASSERT() sx_assert(®node_topo_lock, SA_XLOCKED)
146 #define REGNODE_SLOCK(_sc) sx_slock(&((_sc)->lock))
147 #define REGNODE_XLOCK(_sc) sx_xlock(&((_sc)->lock))
148 #define REGNODE_UNLOCK(_sc) sx_unlock(&((_sc)->lock))
150 /* ----------------------------------------------------------------------------
152 * Default regulator methods for base class.
156 regnode_method_enable(struct regnode *regnode, bool enable, int *udelay)
167 regnode_method_status(struct regnode *regnode, int *status)
169 *status = REGULATOR_STATUS_ENABLED;
174 regnode_method_set_voltage(struct regnode *regnode, int min_uvolt, int max_uvolt,
178 if ((min_uvolt > regnode->std_param.max_uvolt) ||
179 (max_uvolt < regnode->std_param.min_uvolt))
186 regnode_method_get_voltage(struct regnode *regnode, int *uvolt)
189 return (regnode->std_param.min_uvolt +
190 (regnode->std_param.max_uvolt - regnode->std_param.min_uvolt) / 2);
193 /* ----------------------------------------------------------------------------
195 * Internal functions.
199 static struct regnode *
200 regnode_find_by_name(const char *name)
202 struct regnode *entry;
206 TAILQ_FOREACH(entry, ®node_list, reglist_link) {
207 if (strcmp(entry->name, name) == 0)
213 static struct regnode *
214 regnode_find_by_id(device_t dev, intptr_t id)
216 struct regnode *entry;
220 TAILQ_FOREACH(entry, ®node_list, reglist_link) {
221 if ((entry->pdev == dev) && (entry->id == id))
229 * Create and initialize regulator object, but do not register it.
232 regnode_create(device_t pdev, regnode_class_t regnode_class,
233 struct regnode_init_def *def)
235 struct regnode *regnode;
237 KASSERT(def->name != NULL, ("regulator name is NULL"));
238 KASSERT(def->name[0] != '\0', ("regulator name is empty"));
241 if (regnode_find_by_name(def->name) != NULL)
242 panic("Duplicated regulator registration: %s\n", def->name);
245 /* Create object and initialize it. */
246 regnode = malloc(sizeof(struct regnode), M_REGULATOR,
248 kobj_init((kobj_t)regnode, (kobj_class_t)regnode_class);
249 sx_init(®node->lock, "Regulator node lock");
251 /* Allocate softc if required. */
252 if (regnode_class->size > 0) {
253 regnode->softc = malloc(regnode_class->size, M_REGULATOR,
258 /* Copy all strings unless they're flagged as static. */
259 if (def->flags & REGULATOR_FLAGS_STATIC) {
260 regnode->name = def->name;
261 regnode->parent_name = def->parent_name;
263 regnode->name = strdup(def->name, M_REGULATOR);
264 if (def->parent_name != NULL)
265 regnode->parent_name = strdup(def->parent_name,
270 TAILQ_INIT(®node->consumers_list);
271 regnode->id = def->id;
272 regnode->pdev = pdev;
273 regnode->flags = def->flags;
274 regnode->parent = NULL;
275 regnode->std_param = def->std_param;
277 regnode->ofw_node = def->ofw_node;
283 /* Register regulator object. */
285 regnode_register(struct regnode *regnode)
290 if (regnode->ofw_node <= 0)
291 regnode->ofw_node = ofw_bus_get_node(regnode->pdev);
292 if (regnode->ofw_node <= 0)
296 rv = REGNODE_INIT(regnode);
298 printf("REGNODE_INIT failed: %d\n", rv);
303 TAILQ_INSERT_TAIL(®node_list, regnode, reglist_link);
306 OF_device_register_xref(OF_xref_from_node(regnode->ofw_node),
313 regnode_resolve_parent(struct regnode *regnode)
316 /* All ready resolved or no parent? */
317 if ((regnode->parent != NULL) ||
318 (regnode->parent_name == NULL))
321 regnode->parent = regnode_find_by_name(regnode->parent_name);
322 if (regnode->parent == NULL)
328 regnode_delay(int usec)
334 ticks = (usec * hz + 999999) / 1000000;
336 if (cold || ticks < 2)
339 pause("REGULATOR", ticks);
342 /* --------------------------------------------------------------------------
344 * Regulator providers interface
349 regnode_get_name(struct regnode *regnode)
352 return (regnode->name);
356 regnode_get_parent_name(struct regnode *regnode)
359 return (regnode->parent_name);
363 regnode_get_flags(struct regnode *regnode)
366 return (regnode->flags);
370 regnode_get_softc(struct regnode *regnode)
373 return (regnode->softc);
377 regnode_get_device(struct regnode *regnode)
380 return (regnode->pdev);
383 struct regnode_std_param *regnode_get_stdparam(struct regnode *regnode)
386 return (®node->std_param);
389 void regnode_topo_unlock(void)
395 void regnode_topo_xlock(void)
401 void regnode_topo_slock(void)
408 /* --------------------------------------------------------------------------
410 * Real consumers executive
414 regnode_get_parent(struct regnode *regnode)
420 rv = regnode_resolve_parent(regnode);
424 return (regnode->parent);
431 regnode_enable(struct regnode *regnode)
438 /* Enable regulator for each node in chain, starting from source. */
439 rv = regnode_resolve_parent(regnode);
442 if (regnode->parent != NULL) {
443 rv = regnode_enable(regnode->parent);
448 /* Handle this node. */
449 REGNODE_XLOCK(regnode);
450 if (regnode->enable_cnt == 0) {
451 rv = REGNODE_ENABLE(regnode, true, &udelay);
453 REGNODE_UNLOCK(regnode);
456 regnode_delay(udelay);
458 regnode->enable_cnt++;
459 REGNODE_UNLOCK(regnode);
467 regnode_disable(struct regnode *regnode)
475 REGNODE_XLOCK(regnode);
476 /* Disable regulator for each node in chain, starting from consumer. */
477 if ((regnode->enable_cnt == 1) &&
478 ((regnode->flags & REGULATOR_FLAGS_NOT_DISABLE) == 0)) {
479 rv = REGNODE_ENABLE(regnode, false, &udelay);
481 REGNODE_UNLOCK(regnode);
484 regnode_delay(udelay);
486 regnode->enable_cnt--;
487 REGNODE_UNLOCK(regnode);
489 rv = regnode_resolve_parent(regnode);
492 if (regnode->parent != NULL)
493 rv = regnode_disable(regnode->parent);
501 regnode_stop(struct regnode *regnode, int depth)
509 REGNODE_XLOCK(regnode);
510 /* The first node must not be enabled. */
511 if ((regnode->enable_cnt != 0) && (depth == 0)) {
512 REGNODE_UNLOCK(regnode);
515 /* Disable regulator for each node in chain, starting from consumer */
516 if ((regnode->enable_cnt == 0) &&
517 ((regnode->flags & REGULATOR_FLAGS_NOT_DISABLE) == 0)) {
518 rv = REGNODE_ENABLE(regnode, false, &udelay);
520 REGNODE_UNLOCK(regnode);
523 regnode_delay(udelay);
525 REGNODE_UNLOCK(regnode);
527 rv = regnode_resolve_parent(regnode);
530 if (regnode->parent != NULL)
531 rv = regnode_stop(regnode->parent, depth + 1);
536 * Get regulator status. (REGULATOR_STATUS_*)
539 regnode_status(struct regnode *regnode, int *status)
545 REGNODE_XLOCK(regnode);
546 rv = REGNODE_STATUS(regnode, status);
547 REGNODE_UNLOCK(regnode);
552 * Get actual regulator voltage.
555 regnode_get_voltage(struct regnode *regnode, int *uvolt)
561 REGNODE_XLOCK(regnode);
562 rv = REGNODE_GET_VOLTAGE(regnode, uvolt);
563 REGNODE_UNLOCK(regnode);
565 /* Pass call into parent, if regulator is in bypass mode. */
567 rv = regnode_resolve_parent(regnode);
570 if (regnode->parent != NULL)
571 rv = regnode_get_voltage(regnode->parent, uvolt);
578 * Set regulator voltage.
581 regnode_set_voltage(struct regnode *regnode, int min_uvolt, int max_uvolt)
588 REGNODE_XLOCK(regnode);
590 rv = REGNODE_SET_VOLTAGE(regnode, min_uvolt, max_uvolt, &udelay);
592 regnode_delay(udelay);
593 REGNODE_UNLOCK(regnode);
598 * Consumer variant of regnode_set_voltage().
601 regnode_set_voltage_checked(struct regnode *regnode, struct regulator *reg,
602 int min_uvolt, int max_uvolt)
607 struct regulator *tmp;
612 REGNODE_XLOCK(regnode);
613 /* Return error if requested range is outside of regulator range. */
614 if ((min_uvolt > regnode->std_param.max_uvolt) ||
615 (max_uvolt < regnode->std_param.min_uvolt)) {
616 REGNODE_UNLOCK(regnode);
620 /* Get actual voltage range for all consumers. */
621 all_min_uvolt = regnode->std_param.min_uvolt;
622 all_max_uvolt = regnode->std_param.max_uvolt;
623 TAILQ_FOREACH(tmp, ®node->consumers_list, link) {
624 /* Don't take requestor in account. */
627 if (all_min_uvolt < tmp->min_uvolt)
628 all_min_uvolt = tmp->min_uvolt;
629 if (all_max_uvolt > tmp->max_uvolt)
630 all_max_uvolt = tmp->max_uvolt;
633 /* Test if request fits to actual contract. */
634 if ((min_uvolt > all_max_uvolt) ||
635 (max_uvolt < all_min_uvolt)) {
636 REGNODE_UNLOCK(regnode);
640 /* Adjust new range.*/
641 if (min_uvolt < all_min_uvolt)
642 min_uvolt = all_min_uvolt;
643 if (max_uvolt > all_max_uvolt)
644 max_uvolt = all_max_uvolt;
646 rv = REGNODE_SET_VOLTAGE(regnode, min_uvolt, max_uvolt, &udelay);
647 regnode_delay(udelay);
648 REGNODE_UNLOCK(regnode);
654 regnode_get_ofw_node(struct regnode *regnode)
657 return (regnode->ofw_node);
661 /* --------------------------------------------------------------------------
663 * Regulator consumers interface.
666 /* Helper function for regulator_get*() */
668 regulator_create(struct regnode *regnode, device_t cdev)
670 struct regulator *reg;
674 reg = malloc(sizeof(struct regulator), M_REGULATOR,
677 reg->regnode = regnode;
680 REGNODE_XLOCK(regnode);
682 TAILQ_INSERT_TAIL(®node->consumers_list, reg, link);
683 reg ->min_uvolt = regnode->std_param.min_uvolt;
684 reg ->max_uvolt = regnode->std_param.max_uvolt;
685 REGNODE_UNLOCK(regnode);
691 regulator_enable(regulator_t reg)
694 struct regnode *regnode;
696 regnode = reg->regnode;
697 KASSERT(regnode->ref_cnt > 0,
698 ("Attempt to access unreferenced regulator: %s\n", regnode->name));
700 rv = regnode_enable(regnode);
708 regulator_disable(regulator_t reg)
711 struct regnode *regnode;
713 regnode = reg->regnode;
714 KASSERT(regnode->ref_cnt > 0,
715 ("Attempt to access unreferenced regulator: %s\n", regnode->name));
716 KASSERT(reg->enable_cnt > 0,
717 ("Attempt to disable already disabled regulator: %s\n",
720 rv = regnode_disable(regnode);
728 regulator_stop(regulator_t reg)
731 struct regnode *regnode;
733 regnode = reg->regnode;
734 KASSERT(regnode->ref_cnt > 0,
735 ("Attempt to access unreferenced regulator: %s\n", regnode->name));
736 KASSERT(reg->enable_cnt == 0,
737 ("Attempt to stop already enabled regulator: %s\n", regnode->name));
740 rv = regnode_stop(regnode, 0);
746 regulator_status(regulator_t reg, int *status)
749 struct regnode *regnode;
751 regnode = reg->regnode;
752 KASSERT(regnode->ref_cnt > 0,
753 ("Attempt to access unreferenced regulator: %s\n", regnode->name));
756 rv = regnode_status(regnode, status);
762 regulator_get_voltage(regulator_t reg, int *uvolt)
765 struct regnode *regnode;
767 regnode = reg->regnode;
768 KASSERT(regnode->ref_cnt > 0,
769 ("Attempt to access unreferenced regulator: %s\n", regnode->name));
772 rv = regnode_get_voltage(regnode, uvolt);
778 regulator_set_voltage(regulator_t reg, int min_uvolt, int max_uvolt)
780 struct regnode *regnode;
783 regnode = reg->regnode;
784 KASSERT(regnode->ref_cnt > 0,
785 ("Attempt to access unreferenced regulator: %s\n", regnode->name));
789 rv = regnode_set_voltage_checked(regnode, reg, min_uvolt, max_uvolt);
791 reg->min_uvolt = min_uvolt;
792 reg->max_uvolt = max_uvolt;
799 regulator_get_name(regulator_t reg)
801 struct regnode *regnode;
803 regnode = reg->regnode;
804 KASSERT(regnode->ref_cnt > 0,
805 ("Attempt to access unreferenced regulator: %s\n", regnode->name));
806 return (regnode->name);
810 regulator_get_by_name(device_t cdev, const char *name, regulator_t *reg)
812 struct regnode *regnode;
815 regnode = regnode_find_by_name(name);
816 if (regnode == NULL) {
820 *reg = regulator_create(regnode, cdev);
826 regulator_get_by_id(device_t cdev, device_t pdev, intptr_t id, regulator_t *reg)
828 struct regnode *regnode;
832 regnode = regnode_find_by_id(pdev, id);
833 if (regnode == NULL) {
837 *reg = regulator_create(regnode, cdev);
844 regulator_release(regulator_t reg)
846 struct regnode *regnode;
848 regnode = reg->regnode;
849 KASSERT(regnode->ref_cnt > 0,
850 ("Attempt to access unreferenced regulator: %s\n", regnode->name));
852 while (reg->enable_cnt > 0) {
853 regnode_disable(regnode);
856 REGNODE_XLOCK(regnode);
857 TAILQ_REMOVE(®node->consumers_list, reg, link);
859 REGNODE_UNLOCK(regnode);
862 free(reg, M_REGULATOR);
867 /* Default DT mapper. */
869 regdev_default_ofw_map(device_t dev, phandle_t xref, int ncells,
870 pcell_t *cells, intptr_t *id)
874 else if (ncells == 1)
883 regulator_parse_ofw_stdparam(device_t pdev, phandle_t node,
884 struct regnode_init_def *def)
886 phandle_t supply_xref;
887 struct regnode_std_param *par;
890 par = &def->std_param;
891 rv = OF_getprop_alloc(node, "regulator-name", 1,
892 (void **)&def->name);
894 device_printf(pdev, "%s: Missing regulator name\n",
899 rv = OF_getencprop(node, "regulator-min-microvolt", &par->min_uvolt,
900 sizeof(par->min_uvolt));
904 rv = OF_getencprop(node, "regulator-max-microvolt", &par->max_uvolt,
905 sizeof(par->max_uvolt));
909 rv = OF_getencprop(node, "regulator-min-microamp", &par->min_uamp,
910 sizeof(par->min_uamp));
914 rv = OF_getencprop(node, "regulator-max-microamp", &par->max_uamp,
915 sizeof(par->max_uamp));
919 rv = OF_getencprop(node, "regulator-ramp-delay", &par->ramp_delay,
920 sizeof(par->ramp_delay));
924 rv = OF_getencprop(node, "regulator-enable-ramp-delay",
925 &par->enable_delay, sizeof(par->enable_delay));
927 par->enable_delay = 0;
929 if (OF_hasprop(node, "regulator-boot-on"))
932 if (OF_hasprop(node, "regulator-always-on"))
935 if (OF_hasprop(node, "enable-active-high"))
936 par->enable_active_high = 1;
938 rv = OF_getencprop(node, "vin-supply", &supply_xref,
939 sizeof(supply_xref));
941 rv = OF_getprop_alloc(supply_xref, "regulator-name", 1,
942 (void **)&def->parent_name);
944 def->parent_name = NULL;
950 regulator_get_by_ofw_property(device_t cdev, phandle_t cnode, char *name,
961 cnode = ofw_bus_get_node(cdev);
963 device_printf(cdev, "%s called on not ofw based device\n",
969 ncells = OF_getencprop_alloc(cnode, name, sizeof(*cells),
974 /* Translate xref to device */
975 regdev = OF_device_from_xref(cells[0]);
976 if (regdev == NULL) {
981 /* Map regulator to number */
982 rv = REGDEV_MAP(regdev, cells[0], ncells - 1, cells + 1, &id);
986 return (regulator_get_by_id(cdev, regdev, id, reg));
990 /* --------------------------------------------------------------------------
992 * Regulator utility functions.
996 /* Convert raw selector value to real voltage */
998 regulator_range_sel8_to_volt(struct regulator_range *ranges, int nranges,
999 uint8_t sel, int *volt)
1001 struct regulator_range *range;
1005 panic("Voltage regulator have zero ranges\n");
1007 for (i = 0; i < nranges ; i++) {
1010 if (!(sel >= range->min_sel &&
1011 sel <= range->max_sel))
1014 sel -= range->min_sel;
1016 *volt = range->min_uvolt + sel * range->step_uvolt;
1024 regulator_range_volt_to_sel8(struct regulator_range *ranges, int nranges,
1025 int min_uvolt, int max_uvolt, uint8_t *out_sel)
1027 struct regulator_range *range;
1033 panic("Voltage regulator have zero ranges\n");
1035 for (i = 0; i < nranges; i++) {
1037 uvolt = range->min_uvolt +
1038 (range->max_sel - range->min_sel) * range->step_uvolt;
1040 if ((min_uvolt > uvolt) ||
1041 (max_uvolt < range->min_uvolt))
1044 if (min_uvolt <= range->min_uvolt)
1045 min_uvolt = range->min_uvolt;
1047 /* if step == 0 -> fixed voltage range. */
1048 if (range->step_uvolt == 0)
1051 sel = DIV_ROUND_UP(min_uvolt - range->min_uvolt,
1055 sel += range->min_sel;
1063 /* Verify new settings. */
1064 rv = regulator_range_sel8_to_volt(ranges, nranges, sel, &uvolt);
1067 if ((uvolt < min_uvolt) || (uvolt > max_uvolt))