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 regulator_autoset(struct udevice *dev)
142 {
143 	struct dm_regulator_uclass_platdata *uc_pdata;
144 	int ret = 0;
145 
146 	uc_pdata = dev_get_uclass_platdata(dev);
147 	if (!uc_pdata->always_on && !uc_pdata->boot_on)
148 		return -EMEDIUMTYPE;
149 
150 	if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UV)
151 		ret = regulator_set_value(dev, uc_pdata->min_uV);
152 	if (!ret && (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UA))
153 		ret = regulator_set_current(dev, uc_pdata->min_uA);
154 
155 	if (!ret)
156 		ret = regulator_set_enable(dev, true);
157 
158 	return ret;
159 }
160 
161 static void regulator_show(struct udevice *dev, int ret)
162 {
163 	struct dm_regulator_uclass_platdata *uc_pdata;
164 
165 	uc_pdata = dev_get_uclass_platdata(dev);
166 
167 	printf("%s@%s: ", dev->name, uc_pdata->name);
168 	if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UV)
169 		printf("set %d uV", uc_pdata->min_uV);
170 	if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UA)
171 		printf("; set %d uA", uc_pdata->min_uA);
172 	printf("; enabling");
173 	if (ret)
174 		printf(" (ret: %d)\n", ret);
175 	printf("\n");
176 }
177 
178 int regulator_autoset_by_name(const char *platname, struct udevice **devp)
179 {
180 	struct udevice *dev;
181 	int ret;
182 
183 	ret = regulator_get_by_platname(platname, &dev);
184 	if (devp)
185 		*devp = dev;
186 	if (ret) {
187 		debug("Can get the regulator: %s!", platname);
188 		return ret;
189 	}
190 
191 	return regulator_autoset(dev);
192 }
193 
194 int regulator_list_autoset(const char *list_platname[],
195 			   struct udevice *list_devp[],
196 			   bool verbose)
197 {
198 	struct udevice *dev;
199 	int error = 0, i = 0, ret;
200 
201 	while (list_platname[i]) {
202 		ret = regulator_autoset_by_name(list_platname[i], &dev);
203 		if (ret != -EMEDIUMTYPE && verbose)
204 			regulator_show(dev, ret);
205 		if (ret & !error)
206 			error = ret;
207 
208 		if (list_devp)
209 			list_devp[i] = dev;
210 
211 		i++;
212 	}
213 
214 	return error;
215 }
216 
217 static bool regulator_name_is_unique(struct udevice *check_dev,
218 				     const char *check_name)
219 {
220 	struct dm_regulator_uclass_platdata *uc_pdata;
221 	struct udevice *dev;
222 	int check_len = strlen(check_name);
223 	int ret;
224 	int len;
225 
226 	for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev;
227 	     ret = uclass_find_next_device(&dev)) {
228 		if (ret || dev == check_dev)
229 			continue;
230 
231 		uc_pdata = dev_get_uclass_platdata(dev);
232 		len = strlen(uc_pdata->name);
233 		if (len != check_len)
234 			continue;
235 
236 		if (!strcmp(uc_pdata->name, check_name))
237 			return false;
238 	}
239 
240 	return true;
241 }
242 
243 static int regulator_post_bind(struct udevice *dev)
244 {
245 	struct dm_regulator_uclass_platdata *uc_pdata;
246 	int offset = dev->of_offset;
247 	const void *blob = gd->fdt_blob;
248 	const char *property = "regulator-name";
249 
250 	uc_pdata = dev_get_uclass_platdata(dev);
251 	if (!uc_pdata)
252 		return -ENXIO;
253 
254 	/* Regulator's mandatory constraint */
255 	uc_pdata->name = fdt_getprop(blob, offset, property, NULL);
256 	if (!uc_pdata->name) {
257 		debug("%s: dev: %s has no property 'regulator-name'\n",
258 		      __func__, dev->name);
259 		uc_pdata->name = fdt_get_name(blob, offset, NULL);
260 		if (!uc_pdata->name)
261 			return -EINVAL;
262 	}
263 
264 	if (regulator_name_is_unique(dev, uc_pdata->name))
265 		return 0;
266 
267 	debug("\"%s\" of dev: \"%s\", has nonunique value: \"%s\"",
268 	      property, dev->name, uc_pdata->name);
269 
270 	return -EINVAL;
271 }
272 
273 static int regulator_pre_probe(struct udevice *dev)
274 {
275 	struct dm_regulator_uclass_platdata *uc_pdata;
276 	int offset = dev->of_offset;
277 
278 	uc_pdata = dev_get_uclass_platdata(dev);
279 	if (!uc_pdata)
280 		return -ENXIO;
281 
282 	/* Regulator's optional constraints */
283 	uc_pdata->min_uV = fdtdec_get_int(gd->fdt_blob, offset,
284 					  "regulator-min-microvolt", -ENODATA);
285 	uc_pdata->max_uV = fdtdec_get_int(gd->fdt_blob, offset,
286 					  "regulator-max-microvolt", -ENODATA);
287 	uc_pdata->min_uA = fdtdec_get_int(gd->fdt_blob, offset,
288 					  "regulator-min-microamp", -ENODATA);
289 	uc_pdata->max_uA = fdtdec_get_int(gd->fdt_blob, offset,
290 					  "regulator-max-microamp", -ENODATA);
291 	uc_pdata->always_on = fdtdec_get_bool(gd->fdt_blob, offset,
292 					      "regulator-always-on");
293 	uc_pdata->boot_on = fdtdec_get_bool(gd->fdt_blob, offset,
294 					    "regulator-boot-on");
295 
296 	/* Those values are optional (-ENODATA if unset) */
297 	if ((uc_pdata->min_uV != -ENODATA) &&
298 	    (uc_pdata->max_uV != -ENODATA) &&
299 	    (uc_pdata->min_uV == uc_pdata->max_uV))
300 		uc_pdata->flags |= REGULATOR_FLAG_AUTOSET_UV;
301 
302 	/* Those values are optional (-ENODATA if unset) */
303 	if ((uc_pdata->min_uA != -ENODATA) &&
304 	    (uc_pdata->max_uA != -ENODATA) &&
305 	    (uc_pdata->min_uA == uc_pdata->max_uA))
306 		uc_pdata->flags |= REGULATOR_FLAG_AUTOSET_UA;
307 
308 	return 0;
309 }
310 
311 int regulators_enable_boot_on(bool verbose)
312 {
313 	struct udevice *dev;
314 	struct uclass *uc;
315 	int ret;
316 
317 	ret = uclass_get(UCLASS_REGULATOR, &uc);
318 	if (ret)
319 		return ret;
320 	for (uclass_first_device(UCLASS_REGULATOR, &dev);
321 	     dev && !ret;
322 	     uclass_next_device(&dev)) {
323 		ret = regulator_autoset(dev);
324 		if (ret == -EMEDIUMTYPE) {
325 			ret = 0;
326 			continue;
327 		}
328 		if (verbose)
329 			regulator_show(dev, ret);
330 	}
331 
332 	return ret;
333 }
334 
335 UCLASS_DRIVER(regulator) = {
336 	.id		= UCLASS_REGULATOR,
337 	.name		= "regulator",
338 	.post_bind	= regulator_post_bind,
339 	.pre_probe	= regulator_pre_probe,
340 	.per_device_platdata_auto_alloc_size =
341 				sizeof(struct dm_regulator_uclass_platdata),
342 };
343