xref: /openbmc/u-boot/cmd/regulator.c (revision 813d1fb5)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (C) 2014-2015 Samsung Electronics
4  * Przemyslaw Marczak <p.marczak@samsung.com>
5  */
6 #include <common.h>
7 #include <errno.h>
8 #include <dm.h>
9 #include <dm/uclass-internal.h>
10 #include <power/regulator.h>
11 
12 #define LIMIT_DEVNAME	20
13 #define LIMIT_OFNAME	32
14 #define LIMIT_INFO	18
15 
16 static struct udevice *currdev;
17 
failure(int ret)18 static int failure(int ret)
19 {
20 	printf("Error: %d (%s)\n", ret, errno_str(ret));
21 
22 	return CMD_RET_FAILURE;
23 }
24 
do_dev(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])25 static int do_dev(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
26 {
27 	struct dm_regulator_uclass_platdata *uc_pdata;
28 	const char *name;
29 	int ret = -ENXIO;
30 
31 	switch (argc) {
32 	case 2:
33 		name = argv[1];
34 		ret = regulator_get_by_platname(name, &currdev);
35 		if (ret) {
36 			printf("Can't get the regulator: %s!\n", name);
37 			return failure(ret);
38 		}
39 	case 1:
40 		if (!currdev) {
41 			printf("Regulator device is not set!\n\n");
42 			return CMD_RET_USAGE;
43 		}
44 
45 		uc_pdata = dev_get_uclass_platdata(currdev);
46 		if (!uc_pdata) {
47 			printf("%s: no regulator platform data!\n", currdev->name);
48 			return failure(ret);
49 		}
50 
51 		printf("dev: %s @ %s\n", uc_pdata->name, currdev->name);
52 	}
53 
54 	return CMD_RET_SUCCESS;
55 }
56 
curr_dev_and_platdata(struct udevice ** devp,struct dm_regulator_uclass_platdata ** uc_pdata,bool allow_type_fixed)57 static int curr_dev_and_platdata(struct udevice **devp,
58 				 struct dm_regulator_uclass_platdata **uc_pdata,
59 				 bool allow_type_fixed)
60 {
61 	*devp = NULL;
62 	*uc_pdata = NULL;
63 
64 	if (!currdev) {
65 		printf("First, set the regulator device!\n");
66 		return CMD_RET_FAILURE;
67 	}
68 
69 	*devp = currdev;
70 
71 	*uc_pdata = dev_get_uclass_platdata(*devp);
72 	if (!*uc_pdata) {
73 		pr_err("Regulator: %s - missing platform data!\n", currdev->name);
74 		return CMD_RET_FAILURE;
75 	}
76 
77 	if (!allow_type_fixed && (*uc_pdata)->type == REGULATOR_TYPE_FIXED) {
78 		printf("Operation not allowed for fixed regulator!\n");
79 		return CMD_RET_FAILURE;
80 	}
81 
82 	return CMD_RET_SUCCESS;
83 }
84 
do_list(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])85 static int do_list(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
86 {
87 	struct dm_regulator_uclass_platdata *uc_pdata;
88 	struct udevice *dev;
89 	int ret;
90 
91 	printf("| %-*.*s| %-*.*s| %s\n",
92 	       LIMIT_DEVNAME, LIMIT_DEVNAME, "Device",
93 	       LIMIT_OFNAME, LIMIT_OFNAME, "regulator-name",
94 	       "Parent");
95 
96 	for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev;
97 	     ret = uclass_find_next_device(&dev)) {
98 		if (ret)
99 			continue;
100 
101 		uc_pdata = dev_get_uclass_platdata(dev);
102 		printf("| %-*.*s| %-*.*s| %s\n",
103 		       LIMIT_DEVNAME, LIMIT_DEVNAME, dev->name,
104 		       LIMIT_OFNAME, LIMIT_OFNAME, uc_pdata->name,
105 		       dev->parent->name);
106 	}
107 
108 	return ret;
109 }
110 
constraint(const char * name,int val,const char * val_name)111 static int constraint(const char *name, int val, const char *val_name)
112 {
113 	printf("%-*s", LIMIT_INFO, name);
114 	if (val < 0) {
115 		printf(" %s (err: %d)\n", errno_str(val), val);
116 		return val;
117 	}
118 
119 	if (val_name)
120 		printf(" %d (%s)\n", val, val_name);
121 	else
122 		printf(" %d\n", val);
123 
124 	return 0;
125 }
126 
get_mode_name(struct dm_regulator_mode * mode,int mode_count,int mode_id)127 static const char *get_mode_name(struct dm_regulator_mode *mode,
128 				 int mode_count,
129 				 int mode_id)
130 {
131 	while (mode_count--) {
132 		if (mode->id == mode_id)
133 			return mode->name;
134 		mode++;
135 	}
136 
137 	return NULL;
138 }
139 
do_info(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])140 static int do_info(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
141 {
142 	struct udevice *dev;
143 	struct dm_regulator_uclass_platdata *uc_pdata;
144 	struct dm_regulator_mode *modes;
145 	const char *parent_uc;
146 	int mode_count;
147 	int ret;
148 	int i;
149 
150 	ret = curr_dev_and_platdata(&dev, &uc_pdata, true);
151 	if (ret)
152 		return ret;
153 
154 	parent_uc = dev_get_uclass_name(dev->parent);
155 
156 	printf("%s\n%-*s %s\n%-*s %s\n%-*s %s\n%-*s %s\n%-*s\n",
157 	       "Regulator info:",
158 	       LIMIT_INFO, "* regulator-name:", uc_pdata->name,
159 	       LIMIT_INFO, "* device name:", dev->name,
160 	       LIMIT_INFO, "* parent name:", dev->parent->name,
161 	       LIMIT_INFO, "* parent uclass:", parent_uc,
162 	       LIMIT_INFO, "* constraints:");
163 
164 	constraint("  - min uV:", uc_pdata->min_uV, NULL);
165 	constraint("  - max uV:", uc_pdata->max_uV, NULL);
166 	constraint("  - min uA:", uc_pdata->min_uA, NULL);
167 	constraint("  - max uA:", uc_pdata->max_uA, NULL);
168 	constraint("  - always on:", uc_pdata->always_on,
169 		   uc_pdata->always_on ? "true" : "false");
170 	constraint("  - boot on:", uc_pdata->boot_on,
171 		   uc_pdata->boot_on ? "true" : "false");
172 
173 	mode_count = regulator_mode(dev, &modes);
174 	constraint("* op modes:", mode_count, NULL);
175 
176 	for (i = 0; i < mode_count; i++, modes++)
177 		constraint("  - mode id:", modes->id, modes->name);
178 
179 	return CMD_RET_SUCCESS;
180 }
181 
do_status_detail(struct udevice * dev,struct dm_regulator_uclass_platdata * uc_pdata)182 static void do_status_detail(struct udevice *dev,
183 			     struct dm_regulator_uclass_platdata *uc_pdata)
184 {
185 	int current, value, mode;
186 	const char *mode_name;
187 	bool enabled;
188 
189 	printf("Regulator %s status:\n", uc_pdata->name);
190 
191 	enabled = regulator_get_enable(dev);
192 	constraint(" * enable:", enabled, enabled ? "true" : "false");
193 
194 	value = regulator_get_value(dev);
195 	constraint(" * value uV:", value, NULL);
196 
197 	current = regulator_get_current(dev);
198 	constraint(" * current uA:", current, NULL);
199 
200 	mode = regulator_get_mode(dev);
201 	mode_name = get_mode_name(uc_pdata->mode, uc_pdata->mode_count, mode);
202 	constraint(" * mode id:", mode, mode_name);
203 }
204 
do_status_line(struct udevice * dev)205 static void do_status_line(struct udevice *dev)
206 {
207 	struct dm_regulator_uclass_platdata *pdata;
208 	int current, value, mode;
209 	const char *mode_name;
210 	bool enabled;
211 
212 	pdata = dev_get_uclass_platdata(dev);
213 	enabled = regulator_get_enable(dev);
214 	value = regulator_get_value(dev);
215 	current = regulator_get_current(dev);
216 	mode = regulator_get_mode(dev);
217 	mode_name = get_mode_name(pdata->mode, pdata->mode_count, mode);
218 	printf("%-20s %-10s ", pdata->name, enabled ? "enabled" : "disabled");
219 	if (value >= 0)
220 		printf("%10d ", value);
221 	else
222 		printf("%10s ", "-");
223 	if (current >= 0)
224 		printf("%10d ", current);
225 	else
226 		printf("%10s ", "-");
227 	if (mode >= 0)
228 		printf("%-10s", mode_name);
229 	else
230 		printf("%-10s", "-");
231 	printf("\n");
232 }
233 
do_status(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])234 static int do_status(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
235 {
236 	struct dm_regulator_uclass_platdata *uc_pdata;
237 	struct udevice *dev;
238 	int ret;
239 
240 	if (currdev && (argc < 2 || strcmp(argv[1], "-a"))) {
241 		ret = curr_dev_and_platdata(&dev, &uc_pdata, true);
242 		if (ret)
243 			return CMD_RET_FAILURE;
244 		do_status_detail(dev, uc_pdata);
245 		return 0;
246 	}
247 
248 	/* Show all of them in a list, probing them as needed */
249 	printf("%-20s %-10s %10s %10s %-10s\n", "Name", "Enabled", "uV", "mA",
250 	       "Mode");
251 	for (ret = uclass_first_device(UCLASS_REGULATOR, &dev); dev;
252 	     ret = uclass_next_device(&dev))
253 		do_status_line(dev);
254 
255 	return CMD_RET_SUCCESS;
256 }
257 
do_value(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])258 static int do_value(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
259 {
260 	struct udevice *dev;
261 	struct dm_regulator_uclass_platdata *uc_pdata;
262 	int value;
263 	int force;
264 	int ret;
265 
266 	ret = curr_dev_and_platdata(&dev, &uc_pdata, argc == 1);
267 	if (ret)
268 		return ret;
269 
270 	if (argc == 1) {
271 		ret = regulator_get_value(dev);
272 		if (ret < 0) {
273 			printf("Regulator: %s - can't get the Voltage!\n",
274 			       uc_pdata->name);
275 			return failure(ret);
276 		}
277 
278 		printf("%d uV\n", ret);
279 		return CMD_RET_SUCCESS;
280 	}
281 
282 	if (argc == 3)
283 		force = !strcmp("-f", argv[2]);
284 	else
285 		force = 0;
286 
287 	value = simple_strtoul(argv[1], NULL, 0);
288 	if ((value < uc_pdata->min_uV || value > uc_pdata->max_uV) && !force) {
289 		printf("Value exceeds regulator constraint limits %d..%d uV\n",
290 		       uc_pdata->min_uV, uc_pdata->max_uV);
291 		return CMD_RET_FAILURE;
292 	}
293 
294 	if (!force)
295 		ret = regulator_set_value(dev, value);
296 	else
297 		ret = regulator_set_value_force(dev, value);
298 	if (ret) {
299 		printf("Regulator: %s - can't set the Voltage!\n",
300 		       uc_pdata->name);
301 		return failure(ret);
302 	}
303 
304 	return CMD_RET_SUCCESS;
305 }
306 
do_current(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])307 static int do_current(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
308 {
309 	struct udevice *dev;
310 	struct dm_regulator_uclass_platdata *uc_pdata;
311 	int current;
312 	int ret;
313 
314 	ret = curr_dev_and_platdata(&dev, &uc_pdata, argc == 1);
315 	if (ret)
316 		return ret;
317 
318 	if (argc == 1) {
319 		ret = regulator_get_current(dev);
320 		if (ret < 0) {
321 			printf("Regulator: %s - can't get the Current!\n",
322 			       uc_pdata->name);
323 			return failure(ret);
324 		}
325 
326 		printf("%d uA\n", ret);
327 		return CMD_RET_SUCCESS;
328 	}
329 
330 	current = simple_strtoul(argv[1], NULL, 0);
331 	if (current < uc_pdata->min_uA || current > uc_pdata->max_uA) {
332 		printf("Current exceeds regulator constraint limits\n");
333 		return CMD_RET_FAILURE;
334 	}
335 
336 	ret = regulator_set_current(dev, current);
337 	if (ret) {
338 		printf("Regulator: %s - can't set the Current!\n",
339 		       uc_pdata->name);
340 		return failure(ret);
341 	}
342 
343 	return CMD_RET_SUCCESS;
344 }
345 
do_mode(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])346 static int do_mode(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
347 {
348 	struct udevice *dev;
349 	struct dm_regulator_uclass_platdata *uc_pdata;
350 	int mode;
351 	int ret;
352 
353 	ret = curr_dev_and_platdata(&dev, &uc_pdata, false);
354 	if (ret)
355 		return ret;
356 
357 	if (argc == 1) {
358 		ret = regulator_get_mode(dev);
359 		if (ret < 0) {
360 			printf("Regulator: %s - can't get the operation mode!\n",
361 			       uc_pdata->name);
362 			return failure(ret);
363 		}
364 
365 		printf("mode id: %d\n", ret);
366 		return CMD_RET_SUCCESS;
367 	}
368 
369 	mode = simple_strtoul(argv[1], NULL, 0);
370 
371 	ret = regulator_set_mode(dev, mode);
372 	if (ret) {
373 		printf("Regulator: %s - can't set the operation mode!\n",
374 		       uc_pdata->name);
375 		return failure(ret);
376 	}
377 
378 	return CMD_RET_SUCCESS;
379 }
380 
do_enable(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])381 static int do_enable(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
382 {
383 	struct udevice *dev;
384 	struct dm_regulator_uclass_platdata *uc_pdata;
385 	int ret;
386 
387 	ret = curr_dev_and_platdata(&dev, &uc_pdata, true);
388 	if (ret)
389 		return ret;
390 
391 	ret = regulator_set_enable(dev, true);
392 	if (ret) {
393 		printf("Regulator: %s - can't enable!\n", uc_pdata->name);
394 		return failure(ret);
395 	}
396 
397 	return CMD_RET_SUCCESS;
398 }
399 
do_disable(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])400 static int do_disable(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
401 {
402 	struct udevice *dev;
403 	struct dm_regulator_uclass_platdata *uc_pdata;
404 	int ret;
405 
406 	ret = curr_dev_and_platdata(&dev, &uc_pdata, true);
407 	if (ret)
408 		return ret;
409 
410 	ret = regulator_set_enable(dev, false);
411 	if (ret) {
412 		printf("Regulator: %s - can't disable!\n", uc_pdata->name);
413 		return failure(ret);
414 	}
415 
416 	return CMD_RET_SUCCESS;
417 }
418 
419 static cmd_tbl_t subcmd[] = {
420 	U_BOOT_CMD_MKENT(dev, 2, 1, do_dev, "", ""),
421 	U_BOOT_CMD_MKENT(list, 1, 1, do_list, "", ""),
422 	U_BOOT_CMD_MKENT(info, 2, 1, do_info, "", ""),
423 	U_BOOT_CMD_MKENT(status, 2, 1, do_status, "", ""),
424 	U_BOOT_CMD_MKENT(value, 3, 1, do_value, "", ""),
425 	U_BOOT_CMD_MKENT(current, 3, 1, do_current, "", ""),
426 	U_BOOT_CMD_MKENT(mode, 2, 1, do_mode, "", ""),
427 	U_BOOT_CMD_MKENT(enable, 1, 1, do_enable, "", ""),
428 	U_BOOT_CMD_MKENT(disable, 1, 1, do_disable, "", ""),
429 };
430 
do_regulator(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])431 static int do_regulator(cmd_tbl_t *cmdtp, int flag, int argc,
432 			char * const argv[])
433 {
434 	cmd_tbl_t *cmd;
435 
436 	argc--;
437 	argv++;
438 
439 	cmd = find_cmd_tbl(argv[0], subcmd, ARRAY_SIZE(subcmd));
440 	if (cmd == NULL || argc > cmd->maxargs)
441 		return CMD_RET_USAGE;
442 
443 	return cmd->cmd(cmdtp, flag, argc, argv);
444 }
445 
446 U_BOOT_CMD(regulator, CONFIG_SYS_MAXARGS, 1, do_regulator,
447 	"uclass operations",
448 	"list             - list UCLASS regulator devices\n"
449 	"regulator dev [regulator-name] - show/[set] operating regulator device\n"
450 	"regulator info                 - print constraints info\n"
451 	"regulator status [-a]          - print operating status [for all]\n"
452 	"regulator value [val] [-f]     - print/[set] voltage value [uV] (force)\n"
453 	"regulator current [val]        - print/[set] current value [uA]\n"
454 	"regulator mode [id]            - print/[set] operating mode id\n"
455 	"regulator enable               - enable the regulator output\n"
456 	"regulator disable              - disable the regulator output\n"
457 );
458