1 /*
2  * Copyright (C) 2014-2015 Samsung Electronics
3  * Przemyslaw Marczak <p.marczak@samsung.com>
4  *
5  * SPDX-License-Identifier:	GPL-2.0+
6  */
7 #include <common.h>
8 #include <fdtdec.h>
9 #include <errno.h>
10 #include <dm.h>
11 #include <dm/uclass-internal.h>
12 #include <power/pmic.h>
13 #include <power/regulator.h>
14 
15 DECLARE_GLOBAL_DATA_PTR;
16 
17 int regulator_mode(struct udevice *dev, struct dm_regulator_mode **modep)
18 {
19 	struct dm_regulator_uclass_platdata *uc_pdata;
20 
21 	*modep = NULL;
22 
23 	uc_pdata = dev_get_uclass_platdata(dev);
24 	if (!uc_pdata)
25 		return -ENXIO;
26 
27 	*modep = uc_pdata->mode;
28 	return uc_pdata->mode_count;
29 }
30 
31 int regulator_get_value(struct udevice *dev)
32 {
33 	const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
34 
35 	if (!ops || !ops->get_value)
36 		return -ENOSYS;
37 
38 	return ops->get_value(dev);
39 }
40 
41 int regulator_set_value(struct udevice *dev, int uV)
42 {
43 	const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
44 
45 	if (!ops || !ops->set_value)
46 		return -ENOSYS;
47 
48 	return ops->set_value(dev, uV);
49 }
50 
51 int regulator_get_current(struct udevice *dev)
52 {
53 	const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
54 
55 	if (!ops || !ops->get_current)
56 		return -ENOSYS;
57 
58 	return ops->get_current(dev);
59 }
60 
61 int regulator_set_current(struct udevice *dev, int uA)
62 {
63 	const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
64 
65 	if (!ops || !ops->set_current)
66 		return -ENOSYS;
67 
68 	return ops->set_current(dev, uA);
69 }
70 
71 bool regulator_get_enable(struct udevice *dev)
72 {
73 	const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
74 
75 	if (!ops || !ops->get_enable)
76 		return -ENOSYS;
77 
78 	return ops->get_enable(dev);
79 }
80 
81 int regulator_set_enable(struct udevice *dev, bool enable)
82 {
83 	const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
84 
85 	if (!ops || !ops->set_enable)
86 		return -ENOSYS;
87 
88 	return ops->set_enable(dev, enable);
89 }
90 
91 int regulator_get_mode(struct udevice *dev)
92 {
93 	const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
94 
95 	if (!ops || !ops->get_mode)
96 		return -ENOSYS;
97 
98 	return ops->get_mode(dev);
99 }
100 
101 int regulator_set_mode(struct udevice *dev, int mode)
102 {
103 	const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
104 
105 	if (!ops || !ops->set_mode)
106 		return -ENOSYS;
107 
108 	return ops->set_mode(dev, mode);
109 }
110 
111 int regulator_get_by_platname(const char *plat_name, struct udevice **devp)
112 {
113 	struct dm_regulator_uclass_platdata *uc_pdata;
114 	struct udevice *dev;
115 	int ret;
116 
117 	*devp = NULL;
118 
119 	for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev;
120 	     ret = uclass_find_next_device(&dev)) {
121 		if (ret)
122 			continue;
123 
124 		uc_pdata = dev_get_uclass_platdata(dev);
125 		if (!uc_pdata || strcmp(plat_name, uc_pdata->name))
126 			continue;
127 
128 		return uclass_get_device_tail(dev, 0, devp);
129 	}
130 
131 	debug("%s: can't find: %s\n", __func__, plat_name);
132 
133 	return -ENODEV;
134 }
135 
136 int regulator_get_by_devname(const char *devname, struct udevice **devp)
137 {
138 	return uclass_get_device_by_name(UCLASS_REGULATOR, devname, devp);
139 }
140 
141 int device_get_supply_regulator(struct udevice *dev, const char *supply_name,
142 				struct udevice **devp)
143 {
144 	return uclass_get_device_by_phandle(UCLASS_REGULATOR, dev,
145 					    supply_name, devp);
146 }
147 
148 int regulator_autoset(struct udevice *dev)
149 {
150 	struct dm_regulator_uclass_platdata *uc_pdata;
151 	int ret = 0;
152 
153 	uc_pdata = dev_get_uclass_platdata(dev);
154 	if (!uc_pdata->always_on && !uc_pdata->boot_on)
155 		return -EMEDIUMTYPE;
156 
157 	if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UV)
158 		ret = regulator_set_value(dev, uc_pdata->min_uV);
159 	if (!ret && (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UA))
160 		ret = regulator_set_current(dev, uc_pdata->min_uA);
161 
162 	if (!ret)
163 		ret = regulator_set_enable(dev, true);
164 
165 	return ret;
166 }
167 
168 static void regulator_show(struct udevice *dev, int ret)
169 {
170 	struct dm_regulator_uclass_platdata *uc_pdata;
171 
172 	uc_pdata = dev_get_uclass_platdata(dev);
173 
174 	printf("%s@%s: ", dev->name, uc_pdata->name);
175 	if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UV)
176 		printf("set %d uV", uc_pdata->min_uV);
177 	if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UA)
178 		printf("; set %d uA", uc_pdata->min_uA);
179 	printf("; enabling");
180 	if (ret)
181 		printf(" (ret: %d)\n", ret);
182 	printf("\n");
183 }
184 
185 int regulator_autoset_by_name(const char *platname, struct udevice **devp)
186 {
187 	struct udevice *dev;
188 	int ret;
189 
190 	ret = regulator_get_by_platname(platname, &dev);
191 	if (devp)
192 		*devp = dev;
193 	if (ret) {
194 		debug("Can get the regulator: %s!", platname);
195 		return ret;
196 	}
197 
198 	return regulator_autoset(dev);
199 }
200 
201 int regulator_list_autoset(const char *list_platname[],
202 			   struct udevice *list_devp[],
203 			   bool verbose)
204 {
205 	struct udevice *dev;
206 	int error = 0, i = 0, ret;
207 
208 	while (list_platname[i]) {
209 		ret = regulator_autoset_by_name(list_platname[i], &dev);
210 		if (ret != -EMEDIUMTYPE && verbose)
211 			regulator_show(dev, ret);
212 		if (ret & !error)
213 			error = ret;
214 
215 		if (list_devp)
216 			list_devp[i] = dev;
217 
218 		i++;
219 	}
220 
221 	return error;
222 }
223 
224 static bool regulator_name_is_unique(struct udevice *check_dev,
225 				     const char *check_name)
226 {
227 	struct dm_regulator_uclass_platdata *uc_pdata;
228 	struct udevice *dev;
229 	int check_len = strlen(check_name);
230 	int ret;
231 	int len;
232 
233 	for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev;
234 	     ret = uclass_find_next_device(&dev)) {
235 		if (ret || dev == check_dev)
236 			continue;
237 
238 		uc_pdata = dev_get_uclass_platdata(dev);
239 		len = strlen(uc_pdata->name);
240 		if (len != check_len)
241 			continue;
242 
243 		if (!strcmp(uc_pdata->name, check_name))
244 			return false;
245 	}
246 
247 	return true;
248 }
249 
250 static int regulator_post_bind(struct udevice *dev)
251 {
252 	struct dm_regulator_uclass_platdata *uc_pdata;
253 	int offset = dev->of_offset;
254 	const void *blob = gd->fdt_blob;
255 	const char *property = "regulator-name";
256 
257 	uc_pdata = dev_get_uclass_platdata(dev);
258 	if (!uc_pdata)
259 		return -ENXIO;
260 
261 	/* Regulator's mandatory constraint */
262 	uc_pdata->name = fdt_getprop(blob, offset, property, NULL);
263 	if (!uc_pdata->name) {
264 		debug("%s: dev: %s has no property 'regulator-name'\n",
265 		      __func__, dev->name);
266 		uc_pdata->name = fdt_get_name(blob, offset, NULL);
267 		if (!uc_pdata->name)
268 			return -EINVAL;
269 	}
270 
271 	if (regulator_name_is_unique(dev, uc_pdata->name))
272 		return 0;
273 
274 	debug("\"%s\" of dev: \"%s\", has nonunique value: \"%s\"",
275 	      property, dev->name, uc_pdata->name);
276 
277 	return -EINVAL;
278 }
279 
280 static int regulator_pre_probe(struct udevice *dev)
281 {
282 	struct dm_regulator_uclass_platdata *uc_pdata;
283 	int offset = dev->of_offset;
284 
285 	uc_pdata = dev_get_uclass_platdata(dev);
286 	if (!uc_pdata)
287 		return -ENXIO;
288 
289 	/* Regulator's optional constraints */
290 	uc_pdata->min_uV = fdtdec_get_int(gd->fdt_blob, offset,
291 					  "regulator-min-microvolt", -ENODATA);
292 	uc_pdata->max_uV = fdtdec_get_int(gd->fdt_blob, offset,
293 					  "regulator-max-microvolt", -ENODATA);
294 	uc_pdata->min_uA = fdtdec_get_int(gd->fdt_blob, offset,
295 					  "regulator-min-microamp", -ENODATA);
296 	uc_pdata->max_uA = fdtdec_get_int(gd->fdt_blob, offset,
297 					  "regulator-max-microamp", -ENODATA);
298 	uc_pdata->always_on = fdtdec_get_bool(gd->fdt_blob, offset,
299 					      "regulator-always-on");
300 	uc_pdata->boot_on = fdtdec_get_bool(gd->fdt_blob, offset,
301 					    "regulator-boot-on");
302 
303 	/* Those values are optional (-ENODATA if unset) */
304 	if ((uc_pdata->min_uV != -ENODATA) &&
305 	    (uc_pdata->max_uV != -ENODATA) &&
306 	    (uc_pdata->min_uV == uc_pdata->max_uV))
307 		uc_pdata->flags |= REGULATOR_FLAG_AUTOSET_UV;
308 
309 	/* Those values are optional (-ENODATA if unset) */
310 	if ((uc_pdata->min_uA != -ENODATA) &&
311 	    (uc_pdata->max_uA != -ENODATA) &&
312 	    (uc_pdata->min_uA == uc_pdata->max_uA))
313 		uc_pdata->flags |= REGULATOR_FLAG_AUTOSET_UA;
314 
315 	return 0;
316 }
317 
318 int regulators_enable_boot_on(bool verbose)
319 {
320 	struct udevice *dev;
321 	struct uclass *uc;
322 	int ret;
323 
324 	ret = uclass_get(UCLASS_REGULATOR, &uc);
325 	if (ret)
326 		return ret;
327 	for (uclass_first_device(UCLASS_REGULATOR, &dev);
328 	     dev && !ret;
329 	     uclass_next_device(&dev)) {
330 		ret = regulator_autoset(dev);
331 		if (ret == -EMEDIUMTYPE) {
332 			ret = 0;
333 			continue;
334 		}
335 		if (verbose)
336 			regulator_show(dev, ret);
337 	}
338 
339 	return ret;
340 }
341 
342 UCLASS_DRIVER(regulator) = {
343 	.id		= UCLASS_REGULATOR,
344 	.name		= "regulator",
345 	.post_bind	= regulator_post_bind,
346 	.pre_probe	= regulator_pre_probe,
347 	.per_device_platdata_auto_alloc_size =
348 				sizeof(struct dm_regulator_uclass_platdata),
349 };
350