Merge git://git.denx.de/u-boot-rockchip
[platform/kernel/u-boot.git] / cmd / regulator.c
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
13 #define LIMIT_DEVNAME   20
14 #define LIMIT_OFNAME    32
15 #define LIMIT_INFO      18
16
17 static struct udevice *currdev;
18
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
26 static int do_dev(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
27 {
28         struct dm_regulator_uclass_platdata *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_platdata(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
58 static int curr_dev_and_platdata(struct udevice **devp,
59                                  struct dm_regulator_uclass_platdata **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_platdata(*devp);
73         if (!*uc_pdata) {
74                 error("Regulator: %s - missing platform data!", 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
86 static int do_list(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
87 {
88         struct dm_regulator_uclass_platdata *uc_pdata;
89         struct udevice *dev;
90         int ret;
91
92         printf("| %-*.*s| %-*.*s| %s\n",
93                LIMIT_DEVNAME, LIMIT_DEVNAME, "Device",
94                LIMIT_OFNAME, LIMIT_OFNAME, "regulator-name",
95                "Parent");
96
97         for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev;
98              ret = uclass_find_next_device(&dev)) {
99                 if (ret)
100                         continue;
101
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;
110 }
111
112 static 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
128 static 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
141 static 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
151         ret = curr_dev_and_platdata(&dev, &uc_pdata, true);
152         if (ret)
153                 return ret;
154
155         parent_uc = dev_get_uclass_name(dev->parent);
156
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,
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
183 static void do_status_detail(struct udevice *dev,
184                              struct dm_regulator_uclass_platdata *uc_pdata)
185 {
186         int current, value, mode;
187         const char *mode_name;
188         bool enabled;
189
190         printf("Regulator %s status:\n", uc_pdata->name);
191
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);
204 }
205
206 static 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
235 static 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);
255
256         return CMD_RET_SUCCESS;
257 }
258
259 static 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
267         ret = curr_dev_and_platdata(&dev, &uc_pdata, argc == 1);
268         if (ret)
269                 return ret;
270
271         if (argc == 1) {
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                 }
278
279                 printf("%d uV\n", ret);
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) {
290                 printf("Value exceeds regulator constraint limits %d..%d uV\n",
291                        uc_pdata->min_uV, uc_pdata->max_uV);
292                 return CMD_RET_FAILURE;
293         }
294
295         if (!force)
296                 ret = regulator_set_value(dev, value);
297         else
298                 ret = regulator_set_value_force(dev, value);
299         if (ret) {
300                 printf("Regulator: %s - can't set the Voltage!\n",
301                        uc_pdata->name);
302                 return failure(ret);
303         }
304
305         return CMD_RET_SUCCESS;
306 }
307
308 static 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
315         ret = curr_dev_and_platdata(&dev, &uc_pdata, argc == 1);
316         if (ret)
317                 return ret;
318
319         if (argc == 1) {
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                 }
326
327                 printf("%d uA\n", ret);
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);
338         if (ret) {
339                 printf("Regulator: %s - can't set the Current!\n",
340                        uc_pdata->name);
341                 return failure(ret);
342         }
343
344         return CMD_RET_SUCCESS;
345 }
346
347 static 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;
351         int mode;
352         int ret;
353
354         ret = curr_dev_and_platdata(&dev, &uc_pdata, false);
355         if (ret)
356                 return ret;
357
358         if (argc == 1) {
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                 }
365
366                 printf("mode id: %d\n", ret);
367                 return CMD_RET_SUCCESS;
368         }
369
370         mode = simple_strtoul(argv[1], NULL, 0);
371
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         }
378
379         return CMD_RET_SUCCESS;
380 }
381
382 static 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
388         ret = curr_dev_and_platdata(&dev, &uc_pdata, true);
389         if (ret)
390                 return ret;
391
392         ret = regulator_set_enable(dev, true);
393         if (ret) {
394                 printf("Regulator: %s - can't enable!\n", uc_pdata->name);
395                 return failure(ret);
396         }
397
398         return CMD_RET_SUCCESS;
399 }
400
401 static 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
407         ret = curr_dev_and_platdata(&dev, &uc_pdata, true);
408         if (ret)
409                 return ret;
410
411         ret = regulator_set_enable(dev, false);
412         if (ret) {
413                 printf("Regulator: %s - can't disable!\n", uc_pdata->name);
414                 return failure(ret);
415         }
416
417         return CMD_RET_SUCCESS;
418 }
419
420 static 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
432 static 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
447 U_BOOT_CMD(regulator, CONFIG_SYS_MAXARGS, 1, do_regulator,
448         "uclass operations",
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"
452         "regulator status [-a]          - print operating status [for all]\n"
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"
458 );