cmd/pmic.c

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