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