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