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