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                 pr_err("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 );