vhaudiquet/u-boot-krane
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9e596aee6855edc7e786b90db07e24a4f263daed
u-boot-krane/cmd/pmbus.c
T
Vincent JardinandPeng Fan cfb4272552 pmbus: add PMBus 1.x framework, CLI, and binding 
Add U-Boot's PMBus 1.x layer: the decoder/transport library, the
pmbus CLI command and a generic DT binding.

The subsequent commits provide the UCLASS_REGULATOR adapter and per-chip
drivers.

U-Boot's PMBus support is not a hwmon clone of Linux's
drivers/hwmon/pmbus/. Linux owns the runtime side (polling, sysfs,
alert IRQs, fan loops). U-Boot owns the boot-time side in order to,

 - identify the PMBus regulators a board carries: MFR_ID/
   MFR_MODEL/MFR_REVISION + sanity checks.
 - print telemetry (VIN/VOUT/IIN/IOUT/POUT/TEMP) so an
   operator can confirm rail voltages and faults before the kernel
 - decode any chip alerts (STATUS_VOUT/STATUS_IOUT/STATUS_INPUT/
   STATUS_TEMPERATURE/STATUS_CML) so a boot log shows why the
   previous boot failed or the board had been power cycled because
   of an outage (typically over temperature or under current).

Out of scope by design: no periodic polling, no sysfs, no fan-speed
control loop, no PMBUS_VIRT_* sensor virtualisation, no caching.
If a use case needs any of those, the answer should be "wait until
Linux comes up". It shall remain a thin layer.

The constants and structural shape (command codes, status bit names,
sensor-class enum, format enum, struct pmbus_driver_info) are
mirrored from Linux drivers/hwmon/pmbus/pmbus.h verbatim. The
decoders/encoders are reimplemented from the PMBus 1.3
specification because the surrounding hwmon context (struct
pmbus_data, sysfs caching, hwmon publication) does not apply.

The main benefits:

  - One framework + CLI for any board carrying PMBus regulators:
    no per-board PMBus implementation required anymore.
  - Boards call pmbus_print_telemetry() / pmbus_print_status_word()
    directly from boot init for a snapshot, sharing all decode +
    format-dispatch with the CLI.
  - Linux-compatible constants and DT binding so porting an existing
    drivers/hwmon/pmbus/ chip is mechanical.
  - Boot-time AVS/VID rail trim reuses the same decoders and
    encoders as the CLI and the regulator path: no duplicate math.

Signed-off-by: Vincent Jardin <vjardin@free.fr>
Signed-off-by: Peng Fan <peng.fan@nxp.com>
2026-07-13 09:16:57 +08:00

815 lines
22 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright 2026 Free Mobile, Vincent Jardin
*
* pmbus U-Boot CLI command.
*
* Generic command surface over the PMBus 1.x framework defined in
* <pmbus.h> + lib/pmbus.c.
*
* See doc/develop/pmbus.rst for the full usage reference.
*/
#include <command.h>
#include <dm.h>
#include <i2c.h>
#include <log.h>
#include <pmbus.h>
#include <vsprintf.h>
#include <linux/ctype.h>
#include <power/regulator.h>
static int parse_bus_addr(const char *s, int *bus_seq, u8 *addr)
{
char busbuf[8];
const char *colon;
unsigned long b, a;
size_t buslen;
colon = strchr(s, ':');
if (!colon)
return -EINVAL;
buslen = colon - s;
if (buslen == 0 || buslen >= sizeof(busbuf))
return -EINVAL;
memcpy(busbuf, s, buslen);
busbuf[buslen] = '\0';
if (strict_strtoul(busbuf, 10, &b))
return -EINVAL;
if (strict_strtoul(colon + 1, 16, &a) || a > 0x7f)
return -EINVAL;
*bus_seq = (int)b;
*addr = (u8)a;
return 0;
}
static const struct {
const char *name;
u8 reg;
} pmbus_reg_syms[] = {
{ "PAGE", PMBUS_PAGE },
{ "OPERATION", PMBUS_OPERATION },
{ "ON_OFF_CONFIG", PMBUS_ON_OFF_CONFIG },
{ "CLEAR_FAULTS", PMBUS_CLEAR_FAULTS },
{ "WRITE_PROTECT", PMBUS_WRITE_PROTECT },
{ "CAPABILITY", PMBUS_CAPABILITY },
{ "VOUT_MODE", PMBUS_VOUT_MODE },
{ "VOUT_COMMAND", PMBUS_VOUT_COMMAND },
{ "VOUT_TRIM", PMBUS_VOUT_TRIM },
{ "VOUT_MAX", PMBUS_VOUT_MAX },
{ "VOUT_SCALE_LOOP", PMBUS_VOUT_SCALE_LOOP },
{ "STATUS_BYTE", PMBUS_STATUS_BYTE },
{ "STATUS_WORD", PMBUS_STATUS_WORD },
{ "STATUS_VOUT", PMBUS_STATUS_VOUT },
{ "STATUS_IOUT", PMBUS_STATUS_IOUT },
{ "STATUS_INPUT", PMBUS_STATUS_INPUT },
{ "STATUS_TEMP", PMBUS_STATUS_TEMPERATURE },
{ "STATUS_CML", PMBUS_STATUS_CML },
{ "READ_VIN", PMBUS_READ_VIN },
{ "READ_IIN", PMBUS_READ_IIN },
{ "READ_VOUT", PMBUS_READ_VOUT },
{ "READ_IOUT", PMBUS_READ_IOUT },
{ "READ_TEMP1", PMBUS_READ_TEMPERATURE_1 },
{ "READ_TEMP2", PMBUS_READ_TEMPERATURE_2 },
{ "READ_TEMP3", PMBUS_READ_TEMPERATURE_3 },
{ "READ_DUTY", PMBUS_READ_DUTY_CYCLE },
{ "READ_FREQ", PMBUS_READ_FREQUENCY },
{ "READ_POUT", PMBUS_READ_POUT },
{ "READ_PIN", PMBUS_READ_PIN },
{ "REVISION", PMBUS_REVISION },
{ "MFR_ID", PMBUS_MFR_ID },
{ "MFR_MODEL", PMBUS_MFR_MODEL },
{ "MFR_REVISION", PMBUS_MFR_REVISION },
};
static int parse_reg(const char *s, u8 *reg)
{
unsigned long v;
unsigned int i;
for (i = 0; i < ARRAY_SIZE(pmbus_reg_syms); i++) {
if (!strcasecmp(s, pmbus_reg_syms[i].name)) {
*reg = pmbus_reg_syms[i].reg;
return 0;
}
}
if (strict_strtoul(s, 16, &v) || v > 0xff)
return -EINVAL;
*reg = (u8)v;
return 0;
}
static const char *pmbus_reg_name(u8 reg)
{
unsigned int i;
for (i = 0; i < ARRAY_SIZE(pmbus_reg_syms); i++)
if (pmbus_reg_syms[i].reg == reg)
return pmbus_reg_syms[i].name;
return "?";
}
static int require_active(struct udevice **chip,
const struct pmbus_active_dev **act)
{
*act = pmbus_active();
if (!*act) {
printf("pmbus: no active device. Use 'pmbus dev <bus>:<addr>' first.\n");
return CMD_RET_FAILURE;
}
if (pmbus_active_get_i2c(chip)) {
printf("pmbus: cannot reach i2c%d:0x%02x\n",
(*act)->bus_seq, (*act)->addr);
return CMD_RET_FAILURE;
}
return CMD_RET_SUCCESS;
}
static void print_micro(s64 micro, const char *unit)
{
s64 abs_milli;
abs_milli = (micro < 0 ? -micro : micro) / 1000LL;
printf("%lld.%03lld%s",
(long long)(micro / 1000000LL),
(long long)(abs_milli % 1000LL), unit);
}
static void print_active(const struct pmbus_active_dev *act)
{
printf("pmbus: active i2c%d:0x%02x", act->bus_seq, act->addr);
if (act->name[0])
printf(" rail=\"%s\"", act->name);
printf(" MFR_ID=\"%s\" MODEL=\"%s\" vendor=%s%s\n",
act->mfr_id[0] ? act->mfr_id : "?",
act->mfr_model[0] ? act->mfr_model : "?",
act->vendor[0] ? act->vendor : "(generic)",
act->info ? "" : " [no driver_info]");
}
static int do_dev(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
const struct pmbus_active_dev *act;
int bus_seq, ret;
u8 addr;
if (argc < 2) {
act = pmbus_active();
if (!act) {
printf("pmbus: no active device\n");
return CMD_RET_SUCCESS;
}
print_active(act);
return CMD_RET_SUCCESS;
}
if (parse_bus_addr(argv[1], &bus_seq, &addr) < 0) {
ret = pmbus_resolve_by_name(argv[1], &bus_seq, &addr);
if (ret) {
printf("pmbus: '%s' is neither <bus>:<addr> nor a known regulator-name (%d)\n",
argv[1], ret);
return CMD_RET_FAILURE;
}
}
ret = pmbus_set_active(bus_seq, addr);
if (ret) {
printf("pmbus: cannot select i2c%d:0x%02x (%d)\n",
bus_seq, addr, ret);
return CMD_RET_FAILURE;
}
act = pmbus_active();
if (act)
print_active(act);
return CMD_RET_SUCCESS;
}
static int do_list(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
struct udevice *dev;
struct uclass *uc;
int ret, n = 0;
if (!IS_ENABLED(CONFIG_DM_REGULATOR)) {
printf("pmbus: CONFIG_DM_REGULATOR not enabled in this build. Use 'pmbus dev <bus>:<addr>'.\n");
return CMD_RET_SUCCESS;
}
ret = uclass_get(UCLASS_REGULATOR, &uc);
if (ret) {
printf("pmbus: UCLASS_REGULATOR not available\n");
return CMD_RET_SUCCESS;
}
uclass_foreach_dev(dev, uc) {
struct dm_regulator_uclass_plat *up = dev_get_uclass_plat(dev);
struct udevice *parent = dev_get_parent(dev);
const char *rname = (up && up->name) ? up->name : "";
const char *drv = (dev->driver && dev->driver->name)
? dev->driver->name : "?";
int bus_seq = -1;
int addr = -1;
if (parent && device_get_uclass_id(parent) == UCLASS_I2C) {
bus_seq = dev_seq(parent);
addr = dev_read_addr(dev);
}
if (n == 0)
printf("UCLASS_REGULATOR devices (no PMBus filter):\n");
if (bus_seq >= 0 && addr >= 0) {
printf(" i2c%d:0x%02x rail=\"%s\" node=%s driver=%s\n",
bus_seq, addr, rname, dev->name, drv);
} else {
printf(" (non-I2C) rail=\"%s\" node=%s driver=%s\n",
rname, dev->name, drv);
}
n++;
}
if (!n)
printf("pmbus: no UCLASS_REGULATOR devices bound. Use 'pmbus dev <bus>:<addr>' to select a chip directly.\n");
return CMD_RET_SUCCESS;
}
static int do_info(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
static const char * const cls_names[PSC_NUM_CLASSES] = {
"VOLTAGE_IN", "VOLTAGE_OUT", "CURRENT_IN", "CURRENT_OUT",
"POWER", "TEMPERATURE",
};
static const char * const fmt_names[] = {
"LINEAR", "IEEE754", "DIRECT", "VID",
};
const struct pmbus_active_dev *act;
struct udevice *chip;
int rc, c, rrev;
u8 rev = 0;
rc = require_active(&chip, &act);
if (rc)
return rc;
rrev = pmbus_read_byte(chip, PMBUS_REVISION, &rev);
printf("pmbus device i2c%d:0x%02x\n", act->bus_seq, act->addr);
if (act->name[0])
printf(" regulator-name: \"%s\"\n", act->name);
printf(" MFR_ID : \"%s\"\n", act->mfr_id[0] ? act->mfr_id : "?");
printf(" MFR_MODEL : \"%s\"\n", act->mfr_model[0] ? act->mfr_model : "?");
/*
* MFR_REVISION may encodes the revision as a non printable byte
* (BCD nibbles, packed major / minor, etc.). Show both the
* printable form and the raw bytes the chip returned.
*/
{
u8 raw[PMBUS_MFR_STRING_MAX];
int len, i;
if (dm_i2c_read(chip, PMBUS_MFR_REVISION, raw, 1) ||
raw[0] < 1 || raw[0] > sizeof(raw) - 1 ||
dm_i2c_read(chip, PMBUS_MFR_REVISION, raw, raw[0] + 1)) {
printf(" MFR_REVISION : \"%s\"\n",
act->mfr_revision[0] ? act->mfr_revision : "?");
} else {
len = raw[0];
printf(" MFR_REVISION : \"%s\" raw=0x",
act->mfr_revision[0] ? act->mfr_revision : "?");
for (i = 1; i <= len; i++)
printf("%02x", raw[i]);
printf("\n");
}
}
if (rrev)
printf(" PMBUS_REVISION: <read failed (%d)>\n", rrev);
else
printf(" PMBUS_REVISION: 0x%02x (%s)\n", rev,
rev == PMBUS_REV_13 ? "PMBus 1.3" :
rev == PMBUS_REV_12 ? "PMBus 1.2" :
rev == PMBUS_REV_11 ? "PMBus 1.1" :
rev == PMBUS_REV_10 ? "PMBus 1.0" : "unknown");
printf(" vendor : %s\n", act->vendor[0] ? act->vendor : "(none)");
if (!act->info) {
printf(" driver_info : not registered (decoders fall back to LINEAR16 / LINEAR11)\n");
return CMD_RET_SUCCESS;
}
printf(" driver_info : pages=%d\n", act->info->pages);
for (c = 0; c < PSC_NUM_CLASSES; c++) {
printf(" [%-12s] format=%s",
cls_names[c], fmt_names[act->info->format[c]]);
if (act->info->format[c] == pmbus_fmt_direct)
printf(", m=%d, b=%d, R=%d",
act->info->m[c], act->info->b[c], act->info->R[c]);
printf("\n");
}
return CMD_RET_SUCCESS;
}
static int do_telemetry(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
const struct pmbus_active_dev *act;
struct udevice *chip;
int rc;
rc = require_active(&chip, &act);
if (rc)
return rc;
printf("pmbus telemetry @ i2c%d:0x%02x\n", act->bus_seq, act->addr);
pmbus_print_telemetry(chip);
return CMD_RET_SUCCESS;
}
static int do_status(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
const struct pmbus_active_dev *act;
struct udevice *chip;
u16 word = 0;
u8 b;
int rc;
rc = require_active(&chip, &act);
if (rc)
return rc;
if (pmbus_read_word(chip, PMBUS_STATUS_WORD, &word)) {
printf("pmbus: STATUS_WORD read failed\n");
return CMD_RET_FAILURE;
}
const struct pmbus_status_override *ovr =
act->info ? act->info->status_overrides : NULL;
printf("pmbus status @ i2c%d:0x%02x\n", act->bus_seq, act->addr);
printf(" STATUS_WORD (79h) = 0x%04x [", word);
pmbus_print_status_bits(PMBUS_STATUS_WORD, word,
pmbus_status_word_bits, ovr);
printf("]\n");
if (pmbus_read_byte(chip, PMBUS_STATUS_VOUT, &b) == 0) {
printf(" STATUS_VOUT (7Ah) = 0x%02x [", b);
pmbus_print_status_bits(PMBUS_STATUS_VOUT, b,
pmbus_status_vout_bits, ovr);
printf("]\n");
}
if (pmbus_read_byte(chip, PMBUS_STATUS_IOUT, &b) == 0) {
printf(" STATUS_IOUT (7Bh) = 0x%02x [", b);
pmbus_print_status_bits(PMBUS_STATUS_IOUT, b,
pmbus_status_iout_bits, ovr);
printf("]\n");
}
if (pmbus_read_byte(chip, PMBUS_STATUS_INPUT, &b) == 0) {
printf(" STATUS_INPUT (7Ch) = 0x%02x [", b);
pmbus_print_status_bits(PMBUS_STATUS_INPUT, b,
pmbus_status_input_bits, ovr);
printf("]\n");
}
if (pmbus_read_byte(chip, PMBUS_STATUS_TEMPERATURE, &b) == 0) {
printf(" STATUS_TEMP (7Dh) = 0x%02x [", b);
pmbus_print_status_bits(PMBUS_STATUS_TEMPERATURE, b,
pmbus_status_temp_bits, ovr);
printf("]\n");
}
if (pmbus_read_byte(chip, PMBUS_STATUS_CML, &b) == 0) {
printf(" STATUS_CML (7Eh) = 0x%02x [", b);
pmbus_print_status_bits(PMBUS_STATUS_CML, b,
pmbus_status_cml_bits, ovr);
printf("]\n");
}
return CMD_RET_SUCCESS;
}
static int do_dump(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
const struct pmbus_active_dev *act;
struct udevice *chip;
unsigned int i;
int rc;
rc = require_active(&chip, &act);
if (rc)
return rc;
printf("pmbus dump @ i2c%d:0x%02x (registers known to <pmbus.h>)\n",
act->bus_seq, act->addr);
for (i = 0; i < ARRAY_SIZE(pmbus_reg_syms); i++) {
u8 reg = pmbus_reg_syms[i].reg;
u8 b = 0;
u16 w = 0;
switch (reg) {
case PMBUS_PAGE:
case PMBUS_OPERATION:
case PMBUS_ON_OFF_CONFIG:
case PMBUS_WRITE_PROTECT:
case PMBUS_CAPABILITY:
case PMBUS_VOUT_MODE:
case PMBUS_STATUS_BYTE:
case PMBUS_STATUS_VOUT:
case PMBUS_STATUS_IOUT:
case PMBUS_STATUS_INPUT:
case PMBUS_STATUS_TEMPERATURE:
case PMBUS_STATUS_CML:
case PMBUS_REVISION:
if (pmbus_read_byte(chip, reg, &b) == 0)
printf(" %02xh %-15s b=0x%02x\n",
reg, pmbus_reg_syms[i].name, b);
break;
case PMBUS_MFR_ID:
case PMBUS_MFR_MODEL:
case PMBUS_MFR_REVISION: {
char s[PMBUS_MFR_STRING_MAX];
if (pmbus_read_string(chip, reg, s, sizeof(s),
act->mfr_reverse) >= 0)
printf(" %02xh %-15s s=\"%s\"\n",
reg, pmbus_reg_syms[i].name, s);
break;
}
default:
if (pmbus_read_word(chip, reg, &w) == 0)
printf(" %02xh %-15s w=0x%04x\n",
reg, pmbus_reg_syms[i].name, w);
break;
}
}
return CMD_RET_SUCCESS;
}
static int do_read(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
const struct pmbus_active_dev *act;
struct udevice *chip;
const char *fmt = "b";
u8 reg, b;
u16 w;
char s[PMBUS_MFR_STRING_MAX];
int rc, ret;
if (argc < 2)
return CMD_RET_USAGE;
rc = require_active(&chip, &act);
if (rc)
return rc;
if (parse_reg(argv[1], &reg) < 0) {
printf("pmbus: invalid register '%s'\n", argv[1]);
return CMD_RET_USAGE;
}
if (argc >= 3)
fmt = argv[2];
if (!strcmp(fmt, "b")) {
ret = pmbus_read_byte(chip, reg, &b);
if (ret) {
printf("pmbus: read byte 0x%02x failed (%d)\n", reg, ret);
return CMD_RET_FAILURE;
}
printf(" %02xh %-15s b=0x%02x\n", reg, pmbus_reg_name(reg), b);
} else if (!strcmp(fmt, "w")) {
ret = pmbus_read_word(chip, reg, &w);
if (ret) {
printf("pmbus: read word 0x%02x failed (%d)\n", reg, ret);
return CMD_RET_FAILURE;
}
printf(" %02xh %-15s w=0x%04x\n", reg, pmbus_reg_name(reg), w);
} else if (!strcmp(fmt, "s")) {
ret = pmbus_read_string(chip, reg, s, sizeof(s), false);
if (ret < 0) {
printf("pmbus: read string 0x%02x failed (%d)\n", reg, ret);
return CMD_RET_FAILURE;
}
printf(" %02xh %-15s s=\"%s\"\n", reg, pmbus_reg_name(reg), s);
} else {
printf("pmbus: unknown format '%s' (expected b, w, or s)\n", fmt);
return CMD_RET_USAGE;
}
return CMD_RET_SUCCESS;
}
static int do_write(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
const struct pmbus_active_dev *act;
struct udevice *chip;
const char *fmt = "b";
unsigned long val;
u8 reg, b;
u8 buf[2];
int rc, ret;
if (argc < 3)
return CMD_RET_USAGE;
rc = require_active(&chip, &act);
if (rc)
return rc;
if (parse_reg(argv[1], &reg) < 0) {
printf("pmbus: invalid register '%s'\n", argv[1]);
return CMD_RET_USAGE;
}
if (strict_strtoul(argv[2], 16, &val)) {
printf("pmbus: invalid value '%s'\n", argv[2]);
return CMD_RET_USAGE;
}
if (argc >= 4)
fmt = argv[3];
if (!strcmp(fmt, "b")) {
if (val > 0xff) {
printf("pmbus: byte value out of range\n");
return CMD_RET_USAGE;
}
b = (u8)val;
ret = dm_i2c_write(chip, reg, &b, 1);
} else if (!strcmp(fmt, "w")) {
if (val > 0xffff) {
printf("pmbus: word value out of range\n");
return CMD_RET_USAGE;
}
buf[0] = (u8)(val & 0xff);
buf[1] = (u8)((val >> 8) & 0xff);
ret = dm_i2c_write(chip, reg, buf, 2);
} else {
printf("pmbus: unknown format '%s' (expected b or w)\n", fmt);
return CMD_RET_USAGE;
}
if (ret) {
printf("pmbus: write 0x%02x failed (%d)\n", reg, ret);
return CMD_RET_FAILURE;
}
printf("pmbus: wrote 0x%lx to %02xh (%s)\n", val, reg, pmbus_reg_name(reg));
return CMD_RET_SUCCESS;
}
static int do_clear(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
const struct pmbus_active_dev *act;
struct udevice *chip;
int rc, ret;
if (argc >= 2 && strcmp(argv[1], "faults") != 0) {
printf("pmbus: unknown clear subcommand '%s' (expected 'faults')\n",
argv[1]);
return CMD_RET_USAGE;
}
rc = require_active(&chip, &act);
if (rc)
return rc;
ret = pmbus_clear_faults(chip);
if (ret) {
printf("pmbus: CLEAR_FAULTS (03h) failed (%d)\n", ret);
return CMD_RET_FAILURE;
}
printf("pmbus: CLEAR_FAULTS (03h) issued (RAM sticky STATUS_* cleared)\n");
return CMD_RET_SUCCESS;
}
static int do_vout(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
const struct pmbus_active_dev *act;
struct udevice *chip;
u8 vout_mode = 0;
u16 raw;
s64 uv;
int rc, ret;
rc = require_active(&chip, &act);
if (rc)
return rc;
if (pmbus_read_byte(chip, PMBUS_VOUT_MODE, &vout_mode)) {
printf("pmbus: VOUT_MODE read failed\n");
return CMD_RET_FAILURE;
}
if (argc < 2) {
if (pmbus_read_word(chip, PMBUS_READ_VOUT, &raw)) {
printf("pmbus: READ_VOUT failed\n");
return CMD_RET_FAILURE;
}
if (act->info)
uv = pmbus_reg2data(act->info, PSC_VOLTAGE_OUT, raw, vout_mode);
else
uv = pmbus_reg2data_linear16(raw, vout_mode);
printf("pmbus VOUT @ i2c%d:0x%02x raw=0x%04x ",
act->bus_seq, act->addr, raw);
print_micro(uv, "V");
printf("\n");
return CMD_RET_SUCCESS;
}
{
unsigned long target_uv;
const char *fmt_name;
u8 buf[2];
if (strict_strtoul(argv[1], 10, &target_uv)) {
printf("pmbus: invalid microvolt value '%s'\n", argv[1]);
return CMD_RET_USAGE;
}
switch (vout_mode & PB_VOUT_MODE_MODE_MASK) {
case PB_VOUT_MODE_LINEAR:
raw = pmbus_data2reg_linear16((s64)target_uv, vout_mode);
fmt_name = "LINEAR16";
break;
case PB_VOUT_MODE_DIRECT:
if (!act->info ||
act->info->format[PSC_VOLTAGE_OUT] != pmbus_fmt_direct) {
printf("pmbus: VOUT_MODE selects DIRECT but the active driver_info has no DIRECT coefficients for VOLTAGE_OUT\n");
return CMD_RET_FAILURE;
}
raw = pmbus_data2reg_direct((s64)target_uv,
act->info->m[PSC_VOLTAGE_OUT],
act->info->b[PSC_VOLTAGE_OUT],
act->info->R[PSC_VOLTAGE_OUT]);
fmt_name = "DIRECT";
break;
default:
printf("pmbus: VOUT_MODE 0x%02x selects an encoder not yet implemented (VID / IEEE754)\n",
vout_mode);
return CMD_RET_FAILURE;
}
buf[0] = raw & 0xff;
buf[1] = (raw >> 8) & 0xff;
ret = dm_i2c_write(chip, PMBUS_VOUT_COMMAND, buf, 2);
if (ret) {
printf("pmbus: VOUT_COMMAND write failed (%d)\n", ret);
return CMD_RET_FAILURE;
}
printf("pmbus: VOUT_COMMAND <- 0x%04x (%s, target %lu uV)\n",
raw, fmt_name, target_uv);
}
return CMD_RET_SUCCESS;
}
static int pmbus_scan_one_bus(struct udevice *bus, int bus_seq)
{
int hits = 0;
int addr;
for (addr = 0x08; addr <= 0x77; addr++) {
struct udevice *chip;
u8 b;
if (i2c_get_chip(bus, addr, 1, &chip))
continue;
/* MFR_ID block read: 1st byte is the length of the string. */
if (dm_i2c_read(chip, PMBUS_MFR_ID, &b, 1))
continue;
if (b >= 1 && b <= PMBUS_MFR_STRING_MAX - 1) {
char s[PMBUS_MFR_STRING_MAX] = "";
pmbus_read_string(chip, PMBUS_MFR_ID, s, sizeof(s), false);
if (!s[0])
pmbus_read_string(chip, PMBUS_MFR_ID, s, sizeof(s), true);
printf(" i2c%d:0x%02x MFR_ID=\"%s\"\n",
bus_seq, addr, s[0] ? s : "(unprintable)");
hits++;
}
}
return hits;
}
static int do_scan(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
int total = 0;
if (argc >= 2) {
struct udevice *bus;
unsigned long val;
int bus_seq;
if (strict_strtoul(argv[1], 10, &val)) {
printf("pmbus: invalid bus seq '%s'\n", argv[1]);
return CMD_RET_USAGE;
}
bus_seq = (int)val;
if (uclass_get_device_by_seq(UCLASS_I2C, bus_seq, &bus)) {
printf("pmbus: i2c%d not available\n", bus_seq);
return CMD_RET_FAILURE;
}
printf("pmbus scan i2c%d:\n", bus_seq);
total = pmbus_scan_one_bus(bus, bus_seq);
} else {
struct uclass *uc;
struct udevice *bus;
if (uclass_get(UCLASS_I2C, &uc))
return CMD_RET_FAILURE;
uclass_foreach_dev(bus, uc) {
int seq = dev_seq(bus);
if (seq < 0)
continue;
printf("pmbus scan i2c%d:\n", seq);
total += pmbus_scan_one_bus(bus, seq);
}
}
if (!total)
printf("pmbus: no PMBus responders found\n");
return CMD_RET_SUCCESS;
}
static int do_help(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
unsigned int i, n = pmbus_vendor_count();
if (n == 0) {
printf("pmbus: no vendor extensions registered.\n");
printf(" Vendor handlers are registered by per chip drivers at\n");
printf(" probe time; trigger a probe via 'pmbus dev <name>' or a\n");
printf(" board hook (boot snapshot) and re run 'pmbus help'.\n");
return CMD_RET_SUCCESS;
}
printf("Registered pmbus vendor extensions (%u):\n\n", n);
for (i = 0; i < n; i++) {
const struct pmbus_vendor_op *op = pmbus_vendor_at(i);
if (!op)
continue;
printf("[vendor: %s]\n", op->vendor);
if (op->help)
printf("%s", op->help);
printf("\n");
}
return CMD_RET_SUCCESS;
}
static struct cmd_tbl pmbus_subcmd[] = {
U_BOOT_CMD_MKENT(dev, 2, 1, do_dev, "", ""),
U_BOOT_CMD_MKENT(list, 1, 1, do_list, "", ""),
U_BOOT_CMD_MKENT(info, 1, 1, do_info, "", ""),
U_BOOT_CMD_MKENT(telemetry, 1, 1, do_telemetry, "", ""),
U_BOOT_CMD_MKENT(status, 1, 1, do_status, "", ""),
U_BOOT_CMD_MKENT(dump, 1, 1, do_dump, "", ""),
U_BOOT_CMD_MKENT(read, 3, 1, do_read, "", ""),
U_BOOT_CMD_MKENT(write, 4, 1, do_write, "", ""),
U_BOOT_CMD_MKENT(clear, 2, 1, do_clear, "", ""),
U_BOOT_CMD_MKENT(vout, 2, 1, do_vout, "", ""),
U_BOOT_CMD_MKENT(scan, 2, 1, do_scan, "", ""),
U_BOOT_CMD_MKENT(help, 1, 1, do_help, "", ""),
};
static int do_pmbus(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
const struct pmbus_vendor_op *vop;
struct cmd_tbl *cmd;
if (argc < 2)
return CMD_RET_USAGE;
argc--;
argv++;
cmd = find_cmd_tbl(argv[0], pmbus_subcmd, ARRAY_SIZE(pmbus_subcmd));
if (cmd) {
if (argc > cmd->maxargs)
return CMD_RET_USAGE;
return cmd->cmd(cmdtp, flag, argc, argv);
}
/* Vendor namespace dispatch */
vop = pmbus_lookup_vendor(argv[0]);
if (vop)
return vop->handler(cmdtp, flag, argc, argv);
printf("pmbus: unknown subcommand '%s'\n", argv[0]);
return CMD_RET_USAGE;
}
U_BOOT_CMD(pmbus, CONFIG_SYS_MAXARGS, 1, do_pmbus,
"PMBus 1.x device interrogation and control",
"list - list UCLASS_REGULATOR devices (DM bound)\n"
"pmbus dev [<bus>:<addr>|<name>] - show / select active PMBus device\n"
" (<bus> decimal, <addr>/<reg>/<val> hex)\n"
"pmbus info - identification banner + driver_info\n"
"pmbus telemetry - decoded VIN, VOUT, IIN, IOUT, TEMP\n"
"pmbus status - decode every STATUS_* register\n"
"pmbus dump - hex dump of every standard register\n"
"pmbus read <reg> [b|w|s] - raw read (b=byte, w=word, s=string)\n"
"pmbus write <reg> <val> [b|w] - raw write\n"
"pmbus clear [faults] - issue CLEAR_FAULTS (03h)\n"
"pmbus vout [<uV>] - read / set VOUT_COMMAND (microvolts)\n"
"pmbus scan [<bus>] - PMBus aware probe of one or all I2C buses\n"
"pmbus help - list registered vendor extensions\n"
"\n"
"Vendor extensions (pmbus <vendor> ...) are registered by per chip\n"
"drivers at probe time. Run 'pmbus help' after a chip is probed to\n"
"see the available subcommands.\n"
);
Reference in New Issue View Git Blame Copy Permalink