cmd/pmic.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/pmic.h>
  12
  13 #define LIMIT_DEV       32
  14 #define LIMIT_PARENT    20
  15
  16 static struct udevice *currdev;
  17
  18 static int failure(int ret)
  19 {
  20         printf("Error: %d (%s)\n", ret, errno_str(ret));
  21
  22         return CMD_RET_FAILURE;
  23 }
  24
  25 static int do_dev(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  26 {
  27         char *name;
  28         int ret = -ENODEV;
  29
  30         switch (argc) {
  31         case 2:
  32                 name = argv[1];
  33                 ret = pmic_get(name, &currdev);
  34                 if (ret) {
  35                         printf("Can't get PMIC: %s!\n", name);
  36                         return failure(ret);
  37                 }
  38         case 1:
  39                 if (!currdev) {
  40                         printf("PMIC device is not set!\n\n");
  41                         return CMD_RET_USAGE;
  42                 }
  43
  44                 printf("dev: %d @ %s\n", currdev->seq, currdev->name);
  45         }
  46
  47         return CMD_RET_SUCCESS;
  48 }
  49
  50 static int do_list(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  51 {
  52         struct udevice *dev;
  53         int ret;
  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(UCLASS_PMIC, &dev); dev;
  61              ret = uclass_next_device(&dev)) {
  62                 if (ret)
  63                         continue;
  64
  65                 printf("| %-*.*s| %-*.*s| %s @ %d\n",
  66                        LIMIT_DEV, LIMIT_DEV, dev->name,
  67                        LIMIT_PARENT, LIMIT_PARENT, dev->parent->name,
  68                        dev_get_uclass_name(dev->parent), dev->parent->seq);
  69         }
  70
  71         if (ret)
  72                 return CMD_RET_FAILURE;
  73
  74         return CMD_RET_SUCCESS;
  75 }
  76
  77 static int do_dump(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  78 {
  79         struct udevice *dev;
  80         uint reg;
  81         int ret;
  82
  83         if (!currdev) {
  84                 printf("First, set the PMIC device!\n");
  85                 return CMD_RET_USAGE;
  86         }
  87
  88         dev = currdev;
  89
  90         printf("Dump pmic: %s registers\n", dev->name);
  91
  92         for (reg = 0; reg < pmic_reg_count(dev); reg++) {
  93                 ret = pmic_reg_read(dev, reg);
  94                 if (ret < 0) {
  95                         printf("Can't read register: %04x!\n", reg);
  96                         return failure(ret);
  97                 }
  98
  99                 if (!(reg % 16))
 100                         printf("\n0x%02x: ", reg);
 101
 102                 printf("%02x ", ret);
 103         }
 104         printf("\n");
 105
 106         return CMD_RET_SUCCESS;
 107 }
 108
 109 static int do_read(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 110 {
 111         struct udevice *dev;
 112         int regs, ret;
 113         uint reg;
 114
 115         if (!currdev) {
 116                 printf("First, set the PMIC device!\n");
 117                 return CMD_RET_USAGE;
 118         }
 119
 120         dev = currdev;
 121
 122         if (argc != 2)
 123                 return CMD_RET_USAGE;
 124
 125         reg = simple_strtoul(argv[1], NULL, 16);
 126         regs = pmic_reg_count(dev);
 127         if (reg > regs) {
 128                 printf("PMIC max reg: %d\n", regs);
 129                 return failure(-EFAULT);
 130         }
 131
 132         ret = pmic_reg_read(dev, reg);
 133         if (ret < 0) {
 134                 printf("Can't read PMIC register: %0x4!\n", reg);
 135                 return failure(ret);
 136         }
 137
 138         printf("0x%02x: 0x%02x\n", reg, ret);
 139
 140         return CMD_RET_SUCCESS;
 141 }
 142
 143 static int do_write(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 144 {
 145         struct udevice *dev;
 146         int regs, ret;
 147         uint value;
 148         uint reg;
 149
 150         if (!currdev) {
 151                 printf("First, set the PMIC device!\n");
 152                 return CMD_RET_USAGE;
 153         }
 154
 155         dev = currdev;
 156
 157         if (argc != 3)
 158                 return CMD_RET_USAGE;
 159
 160         reg = simple_strtoul(argv[1], NULL, 16);
 161         regs = pmic_reg_count(dev);
 162         if (reg > regs) {
 163                 printf("PMIC max reg: %d\n", regs);
 164                 return failure(-EFAULT);
 165         }
 166
 167         value = simple_strtoul(argv[2], NULL, 16);
 168         if (value > 255) {
 169                 printf("ERROR: value 0x%x out of range [0x00..0xff]\n", value);
 170                 return failure(-EINVAL);
 171         }
 172         ret = pmic_reg_write(dev, reg, value);
 173         if (ret < 0) {
 174                 printf("Can't write PMIC register: %04x!\n", reg);
 175                 return failure(ret);
 176         }
 177
 178         return CMD_RET_SUCCESS;
 179 }
 180
 181 static cmd_tbl_t subcmd[] = {
 182         U_BOOT_CMD_MKENT(dev, 2, 1, do_dev, "", ""),
 183         U_BOOT_CMD_MKENT(list, 1, 1, do_list, "", ""),
 184         U_BOOT_CMD_MKENT(dump, 1, 1, do_dump, "", ""),
 185         U_BOOT_CMD_MKENT(read, 2, 1, do_read, "", ""),
 186         U_BOOT_CMD_MKENT(write, 3, 1, do_write, "", ""),
 187 };
 188
 189 static int do_pmic(cmd_tbl_t *cmdtp, int flag, int argc,
 190                         char * const argv[])
 191 {
 192         cmd_tbl_t *cmd;
 193
 194         argc--;
 195         argv++;
 196
 197         cmd = find_cmd_tbl(argv[0], subcmd, ARRAY_SIZE(subcmd));
 198         if (cmd == NULL || argc > cmd->maxargs)
 199                 return CMD_RET_USAGE;
 200
 201         return cmd->cmd(cmdtp, flag, argc, argv);
 202 }
 203
 204 U_BOOT_CMD(pmic, CONFIG_SYS_MAXARGS, 1, do_pmic,
 205         " operations",
 206         "list                      - list pmic devices\n"
 207         "pmic dev [name]           - show or [set] operating PMIC device\n"
 208         "pmic dump                 - dump registers\n"
 209         "pmic read address         - read byte of register at address\n"
 210         "pmic write address value  - write value to register at address\n"
 211 );