common/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_SEQ       3
  14 #define LIMIT_DEVNAME   20
  15 #define LIMIT_OFNAME    20
  16 #define LIMIT_INFO      16
  17
  18 static struct udevice *currdev;
  19
  20 static int failed(const char *getset, const char *thing,
  21                   const char *for_dev, int ret)
  22 {
  23         printf("Can't %s %s %s.\nError: %d (%s)\n", getset, thing, for_dev,
  24                                                     ret, errno_str(ret));
  25         return CMD_RET_FAILURE;
  26 }
  27
  28 static int regulator_get(bool list_only, int get_seq, struct udevice **devp)
  29 {
  30         struct dm_regulator_uclass_platdata *uc_pdata;
  31         struct udevice *dev;
  32         int ret;
  33
  34         if (devp)
  35                 *devp = NULL;
  36
  37         for (ret = uclass_first_device(UCLASS_REGULATOR, &dev); dev;
  38              ret = uclass_next_device(&dev)) {
  39                 if (list_only) {
  40                         uc_pdata = dev_get_uclass_platdata(dev);
  41                         printf("|%*d | %*.*s @ %-*.*s| %s @ %s\n",
  42                                LIMIT_SEQ, dev->seq,
  43                                LIMIT_DEVNAME, LIMIT_DEVNAME, dev->name,
  44                                LIMIT_OFNAME, LIMIT_OFNAME, uc_pdata->name,
  45                                dev->parent->name,
  46                                dev_get_uclass_name(dev->parent));
  47                         continue;
  48                 }
  49
  50                 if (dev->seq == get_seq) {
  51                         if (devp)
  52                                 *devp = dev;
  53                         else
  54                                 return -EINVAL;
  55
  56                         return 0;
  57                 }
  58         }
  59
  60         if (list_only)
  61                 return ret;
  62
  63         return -ENODEV;
  64 }
  65
  66 static int do_dev(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  67 {
  68         struct dm_regulator_uclass_platdata *uc_pdata;
  69         int seq, ret = -ENXIO;
  70
  71         switch (argc) {
  72         case 2:
  73                 seq = simple_strtoul(argv[1], NULL, 0);
  74                 ret = uclass_get_device_by_seq(UCLASS_REGULATOR, seq, &currdev);
  75                 if (ret && (ret = regulator_get(false, seq, &currdev)))
  76                         goto failed;
  77         case 1:
  78                 uc_pdata = dev_get_uclass_platdata(currdev);
  79                 if (!uc_pdata)
  80                         goto failed;
  81
  82                 printf("dev: %d @ %s\n", currdev->seq, uc_pdata->name);
  83         }
  84
  85         return CMD_RET_SUCCESS;
  86 failed:
  87         return failed("get", "the", "device", ret);
  88 }
  89
  90 static int get_curr_dev_and_pl(struct udevice **devp,
  91                                struct dm_regulator_uclass_platdata **uc_pdata,
  92                                bool allow_type_fixed)
  93 {
  94         *devp = NULL;
  95         *uc_pdata = NULL;
  96
  97         if (!currdev)
  98                 return failed("get", "current", "device", -ENODEV);
  99
 100         *devp = currdev;
 101
 102         *uc_pdata = dev_get_uclass_platdata(*devp);
 103         if (!*uc_pdata)
 104                 return failed("get", "regulator", "platdata", -ENXIO);
 105
 106         if (!allow_type_fixed && (*uc_pdata)->type == REGULATOR_TYPE_FIXED) {
 107                 printf("Operation not allowed for fixed regulator!\n");
 108                 return CMD_RET_FAILURE;
 109         }
 110
 111         return CMD_RET_SUCCESS;
 112 }
 113
 114 static int do_list(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 115 {
 116         int ret;
 117
 118         printf("|%*s | %*.*s @ %-*.*s| %s @ %s\n",
 119                LIMIT_SEQ, "Seq",
 120                LIMIT_DEVNAME, LIMIT_DEVNAME, "Name",
 121                LIMIT_OFNAME, LIMIT_OFNAME, "fdtname",
 122                "Parent", "uclass");
 123
 124         ret = regulator_get(true, 0, NULL);
 125         if (ret)
 126                 return CMD_RET_FAILURE;
 127
 128         return CMD_RET_SUCCESS;
 129 }
 130
 131 static int constraint(const char *name, int val, const char *val_name)
 132 {
 133         printf("%-*s", LIMIT_INFO, name);
 134         if (val < 0) {
 135                 printf(" %s (err: %d)\n", errno_str(val), val);
 136                 return val;
 137         }
 138
 139         if (val_name)
 140                 printf(" %d (%s)\n", val, val_name);
 141         else
 142                 printf(" %d\n", val);
 143
 144         return 0;
 145 }
 146
 147 static const char *get_mode_name(struct dm_regulator_mode *mode,
 148                                  int mode_count,
 149                                  int mode_id)
 150 {
 151         while (mode_count--) {
 152                 if (mode->id == mode_id)
 153                         return mode->name;
 154                 mode++;
 155         }
 156
 157         return NULL;
 158 }
 159
 160 static int do_info(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 161 {
 162         struct udevice *dev;
 163         struct dm_regulator_uclass_platdata *uc_pdata;
 164         struct dm_regulator_mode *modes;
 165         const char *parent_uc;
 166         int mode_count;
 167         int ret;
 168         int i;
 169
 170         ret = get_curr_dev_and_pl(&dev, &uc_pdata, true);
 171         if (ret)
 172                 return ret;
 173
 174         parent_uc = dev_get_uclass_name(dev->parent);
 175
 176         printf("Uclass regulator dev %d info:\n", dev->seq);
 177         printf("%-*s %s @ %s\n%-*s %s\n%-*s %s\n%-*s\n",
 178                LIMIT_INFO, "* parent:", dev->parent->name, parent_uc,
 179                LIMIT_INFO, "* dev name:", dev->name,
 180                LIMIT_INFO, "* fdt name:", uc_pdata->name,
 181                LIMIT_INFO, "* constraints:");
 182
 183         constraint("  - min uV:", uc_pdata->min_uV, NULL);
 184         constraint("  - max uV:", uc_pdata->max_uV, NULL);
 185         constraint("  - min uA:", uc_pdata->min_uA, NULL);
 186         constraint("  - max uA:", uc_pdata->max_uA, NULL);
 187         constraint("  - always on:", uc_pdata->always_on,
 188                    uc_pdata->always_on ? "true" : "false");
 189         constraint("  - boot on:", uc_pdata->boot_on,
 190                    uc_pdata->boot_on ? "true" : "false");
 191
 192         mode_count = regulator_mode(dev, &modes);
 193         constraint("* op modes:", mode_count, NULL);
 194
 195         for (i = 0; i < mode_count; i++, modes++)
 196                 constraint("  - mode id:", modes->id, modes->name);
 197
 198         return CMD_RET_SUCCESS;
 199 }
 200
 201 static int do_status(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 202 {
 203         struct dm_regulator_uclass_platdata *uc_pdata;
 204         int current, value, mode, ret;
 205         const char *mode_name = NULL;
 206         struct udevice *dev;
 207         bool enabled;
 208
 209         ret = get_curr_dev_and_pl(&dev, &uc_pdata, true);
 210         if (ret)
 211                 return ret;
 212
 213         enabled = regulator_get_enable(dev);
 214         constraint(" * enable:", enabled, enabled ? "true" : "false");
 215
 216         value = regulator_get_value(dev);
 217         constraint(" * value uV:", value, NULL);
 218
 219         current = regulator_get_current(dev);
 220         constraint(" * current uA:", current, NULL);
 221
 222         mode = regulator_get_mode(dev);
 223         mode_name = get_mode_name(uc_pdata->mode, uc_pdata->mode_count, mode);
 224         constraint(" * mode id:", mode, mode_name);
 225
 226         return CMD_RET_SUCCESS;
 227 }
 228
 229 static int do_value(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 230 {
 231         struct udevice *dev;
 232         struct dm_regulator_uclass_platdata *uc_pdata;
 233         int value;
 234         int force;
 235         int ret;
 236
 237         ret = get_curr_dev_and_pl(&dev, &uc_pdata, argc == 1);
 238         if (ret)
 239                 return ret;
 240
 241         if (argc == 1) {
 242                 value = regulator_get_value(dev);
 243                 if (value < 0)
 244                         return failed("get", uc_pdata->name, "voltage", value);
 245
 246                 printf("%d uV\n", value);
 247                 return CMD_RET_SUCCESS;
 248         }
 249
 250         if (argc == 3)
 251                 force = !strcmp("-f", argv[2]);
 252         else
 253                 force = 0;
 254
 255         value = simple_strtoul(argv[1], NULL, 0);
 256         if ((value < uc_pdata->min_uV || value > uc_pdata->max_uV) && !force) {
 257                 printf("Value exceeds regulator constraint limits\n");
 258                 return CMD_RET_FAILURE;
 259         }
 260
 261         ret = regulator_set_value(dev, value);
 262         if (ret)
 263                 return failed("set", uc_pdata->name, "voltage value", ret);
 264
 265         return CMD_RET_SUCCESS;
 266 }
 267
 268 static int do_current(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 269 {
 270         struct udevice *dev;
 271         struct dm_regulator_uclass_platdata *uc_pdata;
 272         int current;
 273         int ret;
 274
 275         ret = get_curr_dev_and_pl(&dev, &uc_pdata, argc == 1);
 276         if (ret)
 277                 return ret;
 278
 279         if (argc == 1) {
 280                 current = regulator_get_current(dev);
 281                 if (current < 0)
 282                         return failed("get", uc_pdata->name, "current", current);
 283
 284                 printf("%d uA\n", current);
 285                 return CMD_RET_SUCCESS;
 286         }
 287
 288         current = simple_strtoul(argv[1], NULL, 0);
 289         if (current < uc_pdata->min_uA || current > uc_pdata->max_uA) {
 290                 printf("Current exceeds regulator constraint limits\n");
 291                 return CMD_RET_FAILURE;
 292         }
 293
 294         ret = regulator_set_current(dev, current);
 295         if (ret)
 296                 return failed("set", uc_pdata->name, "current value", ret);
 297
 298         return CMD_RET_SUCCESS;
 299 }
 300
 301 static int do_mode(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 302 {
 303         struct udevice *dev;
 304         struct dm_regulator_uclass_platdata *uc_pdata;
 305         int new_mode;
 306         int mode;
 307         int ret;
 308
 309         ret = get_curr_dev_and_pl(&dev, &uc_pdata, false);
 310         if (ret)
 311                 return ret;
 312
 313         if (argc == 1) {
 314                 mode = regulator_get_mode(dev);
 315                 if (mode < 0)
 316                         return failed("get", uc_pdata->name, "mode", mode);
 317
 318                 printf("mode id: %d\n", mode);
 319                 return CMD_RET_SUCCESS;
 320         }
 321
 322         new_mode = simple_strtoul(argv[1], NULL, 0);
 323
 324         ret = regulator_set_mode(dev, new_mode);
 325         if (ret)
 326                 return failed("set", uc_pdata->name, "mode", ret);
 327
 328         return CMD_RET_SUCCESS;
 329 }
 330
 331 static int do_enable(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 332 {
 333         struct udevice *dev;
 334         struct dm_regulator_uclass_platdata *uc_pdata;
 335         int ret;
 336
 337         ret = get_curr_dev_and_pl(&dev, &uc_pdata, true);
 338         if (ret)
 339                 return ret;
 340
 341         ret = regulator_set_enable(dev, true);
 342         if (ret)
 343                 return failed("enable", "regulator", uc_pdata->name, ret);
 344
 345         return CMD_RET_SUCCESS;
 346 }
 347
 348 static int do_disable(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 349 {
 350         struct udevice *dev;
 351         struct dm_regulator_uclass_platdata *uc_pdata;
 352         int ret;
 353
 354         ret = get_curr_dev_and_pl(&dev, &uc_pdata, true);
 355         if (ret)
 356                 return ret;
 357
 358         ret = regulator_set_enable(dev, false);
 359         if (ret)
 360                 return failed("disable", "regulator", uc_pdata->name, ret);
 361
 362         return CMD_RET_SUCCESS;
 363 }
 364
 365 static cmd_tbl_t subcmd[] = {
 366         U_BOOT_CMD_MKENT(dev, 2, 1, do_dev, "", ""),
 367         U_BOOT_CMD_MKENT(list, 1, 1, do_list, "", ""),
 368         U_BOOT_CMD_MKENT(info, 2, 1, do_info, "", ""),
 369         U_BOOT_CMD_MKENT(status, 2, 1, do_status, "", ""),
 370         U_BOOT_CMD_MKENT(value, 3, 1, do_value, "", ""),
 371         U_BOOT_CMD_MKENT(current, 3, 1, do_current, "", ""),
 372         U_BOOT_CMD_MKENT(mode, 2, 1, do_mode, "", ""),
 373         U_BOOT_CMD_MKENT(enable, 1, 1, do_enable, "", ""),
 374         U_BOOT_CMD_MKENT(disable, 1, 1, do_disable, "", ""),
 375 };
 376
 377 static int do_regulator(cmd_tbl_t *cmdtp, int flag, int argc,
 378                         char * const argv[])
 379 {
 380         cmd_tbl_t *cmd;
 381
 382         argc--;
 383         argv++;
 384
 385         cmd = find_cmd_tbl(argv[0], subcmd, ARRAY_SIZE(subcmd));
 386         if (cmd == NULL || argc > cmd->maxargs)
 387                 return CMD_RET_USAGE;
 388
 389         return cmd->cmd(cmdtp, flag, argc, argv);
 390 }
 391
 392 U_BOOT_CMD(regulator, CONFIG_SYS_MAXARGS, 1, do_regulator,
 393         "uclass operations",
 394         "list         - list UCLASS regulator devices\n"
 395         "regulator dev [id]     - show or [set] operating regulator device\n"
 396         "regulator [info]       - print constraints info\n"
 397         "regulator [status]     - print operating status\n"
 398         "regulator [value] [-f] - print/[set] voltage value [uV] (force)\n"
 399         "regulator [current]    - print/[set] current value [uA]\n"
 400         "regulator [mode_id]    - print/[set] operating mode id\n"
 401         "regulator [enable]     - enable the regulator output\n"
 402         "regulator [disable]    - disable the regulator output\n"
 403 );