cmd/pmic.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2014-2015 Samsung Electronics
   4  * Przemyslaw Marczak <[email protected]>
   5  */
   6 #include <command.h>
   7 #include <errno.h>
   8 #include <dm.h>
   9 #include <dm/uclass-internal.h>
  10 #include <power/pmic.h>
  11
  12 #define LIMIT_DEV       32
  13 #define LIMIT_PARENT    20
  14
  15 static struct udevice *currdev;
  16
  17 static int failure(int ret)
  18 {
  19         printf("Error: %d (%s)\n", ret, errno_str(ret));
  20
  21         return CMD_RET_FAILURE;
  22 }
  23
  24 static int do_dev(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
  25 {
  26         char *name;
  27         int ret = -ENODEV;
  28
  29         switch (argc) {
  30         case 2:
  31                 name = argv[1];
  32                 ret = pmic_get(name, &currdev);
  33                 if (ret) {
  34                         printf("Can't get PMIC: %s!\n", name);
  35                         return failure(ret);
  36                 }
  37         case 1:
  38                 if (!currdev) {
  39                         printf("PMIC device is not set!\n\n");
  40                         return CMD_RET_USAGE;
  41                 }
  42
  43                 printf("dev: %d @ %s\n", dev_seq(currdev), currdev->name);
  44         }
  45
  46         return CMD_RET_SUCCESS;
  47 }
  48
  49 static int do_list(struct cmd_tbl *cmdtp, int flag, int argc,
  50                    char *const argv[])
  51 {
  52         struct udevice *dev;
  53         int ret, err = 0;
  54
  55         printf("| %-*.*s| %-*.*s| %s @ %s\n",
  56                LIMIT_DEV, LIMIT_DEV, "Name",
  57                LIMIT_PARENT, LIMIT_PARENT, "Parent name",
  58                "Parent uclass", "seq");
  59
  60         for (ret = uclass_first_device_check(UCLASS_PMIC, &dev); dev;
  61              ret = uclass_next_device_check(&dev)) {
  62                 if (ret)
  63                         err = ret;
  64
  65                 printf("| %-*.*s| %-*.*s| %s @ %d | status: %i\n",
  66                        LIMIT_DEV, LIMIT_DEV, dev->name,
  67                        LIMIT_PARENT, LIMIT_PARENT, dev->parent->name,
  68                        dev_get_uclass_name(dev->parent), dev_seq(dev->parent),
  69                        ret);
  70         }
  71
  72         if (err)
  73                 return CMD_RET_FAILURE;
  74
  75         return CMD_RET_SUCCESS;
  76 }
  77
  78 static int do_dump(struct cmd_tbl *cmdtp, int flag, int argc,
  79                    char *const argv[])
  80 {
  81         struct uc_pmic_priv *priv;
  82         struct udevice *dev;
  83         char fmt[16];
  84         uint reg;
  85         int ret;
  86
  87         if (!currdev) {
  88                 printf("First, set the PMIC device!\n");
  89                 return CMD_RET_USAGE;
  90         }
  91
  92         dev = currdev;
  93         priv = dev_get_uclass_priv(dev);
  94         printf("Dump pmic: %s registers\n", dev->name);
  95
  96         sprintf(fmt, "%%%d.%dx ", priv->trans_len * 2,
  97                 priv->trans_len * 2);
  98
  99         for (reg = 0; reg < pmic_reg_count(dev); reg++) {
 100                 ret = pmic_reg_read(dev, reg);
 101                 if (ret < 0 && ret != -ENODATA) {
 102                         printf("Can't read register: %d\n", reg);
 103                         return failure(ret);
 104                 }
 105
 106                 if (!(reg % 16))
 107                         printf("\n0x%02x: ", reg);
 108
 109                 if (ret == -ENODATA) {
 110                         int i;
 111
 112                         for (i = 0; i < priv->trans_len; i++)
 113                                 puts("--");
 114                         puts(" ");
 115                 } else {
 116                         printf(fmt, ret);
 117                 }
 118         }
 119         printf("\n");
 120
 121         return CMD_RET_SUCCESS;
 122 }
 123
 124 static int do_read(struct cmd_tbl *cmdtp, int flag, int argc,
 125                    char *const argv[])
 126 {
 127         struct uc_pmic_priv *priv;
 128         struct udevice *dev;
 129         int regs, ret;
 130         char fmt[24];
 131         uint reg;
 132
 133         if (!currdev) {
 134                 printf("First, set the PMIC device!\n");
 135                 return CMD_RET_USAGE;
 136         }
 137
 138         dev = currdev;
 139         priv = dev_get_uclass_priv(dev);
 140
 141         if (argc != 2)
 142                 return CMD_RET_USAGE;
 143
 144         reg = simple_strtoul(argv[1], NULL, 0);
 145         regs = pmic_reg_count(dev);
 146         if (reg > regs) {
 147                 printf("PMIC max reg: %d\n", regs);
 148                 return failure(-EFAULT);
 149         }
 150
 151         ret = pmic_reg_read(dev, reg);
 152         if (ret < 0) {
 153                 printf("Can't read PMIC register: %d!\n", reg);
 154                 return failure(ret);
 155         }
 156
 157         sprintf(fmt, "0x%%02x: 0x%%%d.%dx\n", priv->trans_len * 2,
 158                 priv->trans_len * 2);
 159         printf(fmt, reg, ret);
 160
 161         return CMD_RET_SUCCESS;
 162 }
 163
 164 static int do_write(struct cmd_tbl *cmdtp, int flag, int argc,
 165                     char *const argv[])
 166 {
 167         struct udevice *dev;
 168         uint reg, value;
 169         int regs, ret;
 170
 171         if (!currdev) {
 172                 printf("First, set the PMIC device!\n");
 173                 return CMD_RET_USAGE;
 174         }
 175
 176         dev = currdev;
 177
 178         if (argc != 3)
 179                 return CMD_RET_USAGE;
 180
 181         reg = simple_strtoul(argv[1], NULL, 0);
 182         regs = pmic_reg_count(dev);
 183         if (reg > regs) {
 184                 printf("PMIC max reg: %d\n", regs);
 185                 return failure(-EFAULT);
 186         }
 187
 188         value = simple_strtoul(argv[2], NULL, 0);
 189
 190         ret = pmic_reg_write(dev, reg, value);
 191         if (ret) {
 192                 printf("Can't write PMIC register: %d!\n", reg);
 193                 return failure(ret);
 194         }
 195
 196         return CMD_RET_SUCCESS;
 197 }
 198
 199 static struct cmd_tbl subcmd[] = {
 200         U_BOOT_CMD_MKENT(dev, 2, 1, do_dev, "", ""),
 201         U_BOOT_CMD_MKENT(list, 1, 1, do_list, "", ""),
 202         U_BOOT_CMD_MKENT(dump, 1, 1, do_dump, "", ""),
 203         U_BOOT_CMD_MKENT(read, 2, 1, do_read, "", ""),
 204         U_BOOT_CMD_MKENT(write, 3, 1, do_write, "", ""),
 205 };
 206
 207 static int do_pmic(struct cmd_tbl *cmdtp, int flag, int argc,
 208                    char *const argv[])
 209 {
 210         struct cmd_tbl *cmd;
 211
 212         argc--;
 213         argv++;
 214
 215         cmd = find_cmd_tbl(argv[0], subcmd, ARRAY_SIZE(subcmd));
 216         if (cmd == NULL || argc > cmd->maxargs)
 217                 return CMD_RET_USAGE;
 218
 219         return cmd->cmd(cmdtp, flag, argc, argv);
 220 }
 221
 222 U_BOOT_CMD(pmic, CONFIG_SYS_MAXARGS, 1, do_pmic,
 223         "PMIC sub-system",
 224         "list          - list pmic devices\n"
 225         "pmic dev [name]    - show or [set] operating PMIC device\n"
 226         "pmic dump          - dump registers\n"
 227         "pmic read <reg>    - read byte of 'reg' register\n"
 228         "pmic write <reg> <byte> - write 'byte' byte to 'reg' register\n"
 229 );