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