u-boot/common/cmd_regulator.c
Simon Glass 224d1ddcc5 dm: pmic: Display the regulator limits on error
When a regulator command cannot honour the requested voltage, display the
limits to try to be helpful.

Signed-off-by: Simon Glass <sjg@chromium.org>
Acked-by: Przemyslaw Marczak <p.marczak@samsung.com>
2015-08-05 21:06:13 -06:00

410 lines
9.8 KiB
C

/*
* Copyright (C) 2014-2015 Samsung Electronics
* Przemyslaw Marczak <p.marczak@samsung.com>
*
* SPDX-License-Identifier: GPL-2.0+
*/
#include <common.h>
#include <errno.h>
#include <dm.h>
#include <dm/uclass-internal.h>
#include <power/regulator.h>
#define LIMIT_DEVNAME 20
#define LIMIT_OFNAME 32
#define LIMIT_INFO 18
static struct udevice *currdev;
static int failure(int ret)
{
printf("Error: %d (%s)\n", ret, errno_str(ret));
return CMD_RET_FAILURE;
}
static int do_dev(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
struct dm_regulator_uclass_platdata *uc_pdata;
const char *name;
int ret = -ENXIO;
switch (argc) {
case 2:
name = argv[1];
ret = regulator_get_by_platname(name, &currdev);
if (ret) {
printf("Can't get the regulator: %s!\n", name);
return failure(ret);
}
case 1:
if (!currdev) {
printf("Regulator device is not set!\n\n");
return CMD_RET_USAGE;
}
uc_pdata = dev_get_uclass_platdata(currdev);
if (!uc_pdata) {
printf("%s: no regulator platform data!\n", currdev->name);
return failure(ret);
}
printf("dev: %s @ %s\n", uc_pdata->name, currdev->name);
}
return CMD_RET_SUCCESS;
}
static int curr_dev_and_platdata(struct udevice **devp,
struct dm_regulator_uclass_platdata **uc_pdata,
bool allow_type_fixed)
{
*devp = NULL;
*uc_pdata = NULL;
if (!currdev) {
printf("First, set the regulator device!\n");
return CMD_RET_FAILURE;
}
*devp = currdev;
*uc_pdata = dev_get_uclass_platdata(*devp);
if (!*uc_pdata) {
error("Regulator: %s - missing platform data!", currdev->name);
return CMD_RET_FAILURE;
}
if (!allow_type_fixed && (*uc_pdata)->type == REGULATOR_TYPE_FIXED) {
printf("Operation not allowed for fixed regulator!\n");
return CMD_RET_FAILURE;
}
return CMD_RET_SUCCESS;
}
static int do_list(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
struct dm_regulator_uclass_platdata *uc_pdata;
struct udevice *dev;
int ret;
printf("| %-*.*s| %-*.*s| %s\n",
LIMIT_DEVNAME, LIMIT_DEVNAME, "Device",
LIMIT_OFNAME, LIMIT_OFNAME, "regulator-name",
"Parent");
for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev;
ret = uclass_find_next_device(&dev)) {
if (ret)
continue;
uc_pdata = dev_get_uclass_platdata(dev);
printf("| %-*.*s| %-*.*s| %s\n",
LIMIT_DEVNAME, LIMIT_DEVNAME, dev->name,
LIMIT_OFNAME, LIMIT_OFNAME, uc_pdata->name,
dev->parent->name);
}
return ret;
}
static int constraint(const char *name, int val, const char *val_name)
{
printf("%-*s", LIMIT_INFO, name);
if (val < 0) {
printf(" %s (err: %d)\n", errno_str(val), val);
return val;
}
if (val_name)
printf(" %d (%s)\n", val, val_name);
else
printf(" %d\n", val);
return 0;
}
static const char *get_mode_name(struct dm_regulator_mode *mode,
int mode_count,
int mode_id)
{
while (mode_count--) {
if (mode->id == mode_id)
return mode->name;
mode++;
}
return NULL;
}
static int do_info(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
struct udevice *dev;
struct dm_regulator_uclass_platdata *uc_pdata;
struct dm_regulator_mode *modes;
const char *parent_uc;
int mode_count;
int ret;
int i;
ret = curr_dev_and_platdata(&dev, &uc_pdata, true);
if (ret)
return ret;
parent_uc = dev_get_uclass_name(dev->parent);
printf("%s\n%-*s %s\n%-*s %s\n%-*s %s\n%-*s %s\n%-*s\n",
"Regulator info:",
LIMIT_INFO, "* regulator-name:", uc_pdata->name,
LIMIT_INFO, "* device name:", dev->name,
LIMIT_INFO, "* parent name:", dev->parent->name,
LIMIT_INFO, "* parent uclass:", parent_uc,
LIMIT_INFO, "* constraints:");
constraint(" - min uV:", uc_pdata->min_uV, NULL);
constraint(" - max uV:", uc_pdata->max_uV, NULL);
constraint(" - min uA:", uc_pdata->min_uA, NULL);
constraint(" - max uA:", uc_pdata->max_uA, NULL);
constraint(" - always on:", uc_pdata->always_on,
uc_pdata->always_on ? "true" : "false");
constraint(" - boot on:", uc_pdata->boot_on,
uc_pdata->boot_on ? "true" : "false");
mode_count = regulator_mode(dev, &modes);
constraint("* op modes:", mode_count, NULL);
for (i = 0; i < mode_count; i++, modes++)
constraint(" - mode id:", modes->id, modes->name);
return CMD_RET_SUCCESS;
}
static int do_status(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
struct dm_regulator_uclass_platdata *uc_pdata;
int current, value, mode, ret;
const char *mode_name = NULL;
struct udevice *dev;
bool enabled;
ret = curr_dev_and_platdata(&dev, &uc_pdata, true);
if (ret)
return ret;
printf("Regulator %s status:\n", uc_pdata->name);
enabled = regulator_get_enable(dev);
constraint(" * enable:", enabled, enabled ? "true" : "false");
value = regulator_get_value(dev);
constraint(" * value uV:", value, NULL);
current = regulator_get_current(dev);
constraint(" * current uA:", current, NULL);
mode = regulator_get_mode(dev);
mode_name = get_mode_name(uc_pdata->mode, uc_pdata->mode_count, mode);
constraint(" * mode id:", mode, mode_name);
return CMD_RET_SUCCESS;
}
static int do_value(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
struct udevice *dev;
struct dm_regulator_uclass_platdata *uc_pdata;
int value;
int force;
int ret;
ret = curr_dev_and_platdata(&dev, &uc_pdata, argc == 1);
if (ret)
return ret;
if (argc == 1) {
ret = regulator_get_value(dev);
if (ret < 0) {
printf("Regulator: %s - can't get the Voltage!\n",
uc_pdata->name);
return failure(ret);
}
printf("%d uV\n", ret);
return CMD_RET_SUCCESS;
}
if (argc == 3)
force = !strcmp("-f", argv[2]);
else
force = 0;
value = simple_strtoul(argv[1], NULL, 0);
if ((value < uc_pdata->min_uV || value > uc_pdata->max_uV) && !force) {
printf("Value exceeds regulator constraint limits %d..%d uV\n",
uc_pdata->min_uV, uc_pdata->max_uV);
return CMD_RET_FAILURE;
}
ret = regulator_set_value(dev, value);
if (ret) {
printf("Regulator: %s - can't set the Voltage!\n",
uc_pdata->name);
return failure(ret);
}
return CMD_RET_SUCCESS;
}
static int do_current(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
struct udevice *dev;
struct dm_regulator_uclass_platdata *uc_pdata;
int current;
int ret;
ret = curr_dev_and_platdata(&dev, &uc_pdata, argc == 1);
if (ret)
return ret;
if (argc == 1) {
ret = regulator_get_current(dev);
if (ret < 0) {
printf("Regulator: %s - can't get the Current!\n",
uc_pdata->name);
return failure(ret);
}
printf("%d uA\n", ret);
return CMD_RET_SUCCESS;
}
current = simple_strtoul(argv[1], NULL, 0);
if (current < uc_pdata->min_uA || current > uc_pdata->max_uA) {
printf("Current exceeds regulator constraint limits\n");
return CMD_RET_FAILURE;
}
ret = regulator_set_current(dev, current);
if (ret) {
printf("Regulator: %s - can't set the Current!\n",
uc_pdata->name);
return failure(ret);
}
return CMD_RET_SUCCESS;
}
static int do_mode(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
struct udevice *dev;
struct dm_regulator_uclass_platdata *uc_pdata;
int mode;
int ret;
ret = curr_dev_and_platdata(&dev, &uc_pdata, false);
if (ret)
return ret;
if (argc == 1) {
ret = regulator_get_mode(dev);
if (ret < 0) {
printf("Regulator: %s - can't get the operation mode!\n",
uc_pdata->name);
return failure(ret);
}
printf("mode id: %d\n", ret);
return CMD_RET_SUCCESS;
}
mode = simple_strtoul(argv[1], NULL, 0);
ret = regulator_set_mode(dev, mode);
if (ret) {
printf("Regulator: %s - can't set the operation mode!\n",
uc_pdata->name);
return failure(ret);
}
return CMD_RET_SUCCESS;
}
static int do_enable(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
struct udevice *dev;
struct dm_regulator_uclass_platdata *uc_pdata;
int ret;
ret = curr_dev_and_platdata(&dev, &uc_pdata, true);
if (ret)
return ret;
ret = regulator_set_enable(dev, true);
if (ret) {
printf("Regulator: %s - can't enable!\n", uc_pdata->name);
return failure(ret);
}
return CMD_RET_SUCCESS;
}
static int do_disable(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
struct udevice *dev;
struct dm_regulator_uclass_platdata *uc_pdata;
int ret;
ret = curr_dev_and_platdata(&dev, &uc_pdata, true);
if (ret)
return ret;
ret = regulator_set_enable(dev, false);
if (ret) {
printf("Regulator: %s - can't disable!\n", uc_pdata->name);
return failure(ret);
}
return CMD_RET_SUCCESS;
}
static cmd_tbl_t subcmd[] = {
U_BOOT_CMD_MKENT(dev, 2, 1, do_dev, "", ""),
U_BOOT_CMD_MKENT(list, 1, 1, do_list, "", ""),
U_BOOT_CMD_MKENT(info, 2, 1, do_info, "", ""),
U_BOOT_CMD_MKENT(status, 2, 1, do_status, "", ""),
U_BOOT_CMD_MKENT(value, 3, 1, do_value, "", ""),
U_BOOT_CMD_MKENT(current, 3, 1, do_current, "", ""),
U_BOOT_CMD_MKENT(mode, 2, 1, do_mode, "", ""),
U_BOOT_CMD_MKENT(enable, 1, 1, do_enable, "", ""),
U_BOOT_CMD_MKENT(disable, 1, 1, do_disable, "", ""),
};
static int do_regulator(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
cmd_tbl_t *cmd;
argc--;
argv++;
cmd = find_cmd_tbl(argv[0], subcmd, ARRAY_SIZE(subcmd));
if (cmd == NULL || argc > cmd->maxargs)
return CMD_RET_USAGE;
return cmd->cmd(cmdtp, flag, argc, argv);
}
U_BOOT_CMD(regulator, CONFIG_SYS_MAXARGS, 1, do_regulator,
"uclass operations",
"list - list UCLASS regulator devices\n"
"regulator dev [regulator-name] - show/[set] operating regulator device\n"
"regulator info - print constraints info\n"
"regulator status - print operating status\n"
"regulator value [val] [-f] - print/[set] voltage value [uV] (force)\n"
"regulator current [val] - print/[set] current value [uA]\n"
"regulator mode [id] - print/[set] operating mode id\n"
"regulator enable - enable the regulator output\n"
"regulator disable - disable the regulator output\n"
);