Message ID | 20190407220206.7655-3-erosca@de.adit-jv.com |
---|---|
State | Changes Requested |
Delegated to: | Heinrich Schuchardt |
Headers | show |
Series | Add 'bcb' command to read/modify/write Android BCB | expand |
On 4/8/19 12:02 AM, Eugeniu Rosca wrote: > 'Bootloader Control Block' (BCB) is a well established term/acronym in > the Android namespace which refers to a location in a dedicated raw > (i.e. FS-unaware) flash (e.g. eMMC) partition, usually called "misc", > which is used as media for exchanging messages between Android userspace > (particularly recovery [1]) and an Android-capable bootloader. > > On higher level, this allows implementing a subset of Android Bootloader > Requirements [2], amongst which is the Android-specific bootloader > flow [3]. Regardless how the latter is implemented in U-Boot ([3] being > the most notorious example), reading/writing/dumping the BCB fields in > the development process from inside the U-Boot is a convenient feature. > Hence, make it available to the users. > > Some usage examples of the new command recorded on R-Car H3ULCB-KF > ('>>>' is an overlay on top of the original console output): > > => bcb > bcb - Load/set/clear/test/dump/store Android BCB fields > > Usage: > bcb load <dev> <part> - load BCB from mmc <dev>:<part> > bcb set <field> <val> - set BCB <field> to <val> > bcb clear [<field>] - clear BCB <field> or all fields > bcb test <field> <op> <val> - test BCB <field> against <val> > bcb dump <field> - dump BCB <field> > bcb store - store BCB back to mmc > > Legend: > <dev> - MMC device index containing the BCB partition > <part> - MMC partition index or name containing the BCB > <field> - one of {command,status,recovery,stage,reserved} > <op> - the binary operator used in 'bcb test': > '=' returns true if <val> matches the string stored in <field> > '~' returns true if <val> matches a subset of <field>'s string > <val> - string/text provided as input to bcb {set,test} > NOTE: any ':' character in <val> will be replaced by line feed > during 'bcb set' and used as separator by upper layers > > => bcb dump command > Error: BCB not loaded! > >>> Users must specify mmc device and partition before any other call > > => bcb load 1 misc > => bcb load 1 1 > >>> The two calls are equivalent (assuming "misc" has index 1) > > => bcb dump command > 00000000: 62 6f 6f 74 6f 6e 63 65 2d 73 68 65 6c 6c 00 72 bootonce-shell.r > 00000010: 79 00 72 00 00 00 00 00 00 00 00 00 00 00 00 00 y.r............. > >>> The output is in binary/string format for convenience > >>> The output size matches the size of inspected BCB field > >>> (32 bytes in case of 'command') > > => bcb test command = bootonce-shell && echo true > true > => bcb test command = bootonce-shell- && echo true > => bcb test command = bootonce-shel && echo true > >>> The '=' operator returns 'true' on perfect match > > => bcb test command ~ bootonce-shel && echo true > true > => bcb test command ~ bootonce-shell && echo true > true > >>> The '~' operator returns 'true' on substring match > > => bcb set command recovery > => bcb dump command > 00000000: 72 65 63 6f 76 65 72 79 00 73 68 65 6c 6c 00 72 recovery.shell.r > 00000010: 79 00 72 00 00 00 00 00 00 00 00 00 00 00 00 00 y.r............. > >>> The new value is NULL-terminated and stored in the BCB field > > => bcb set recovery "msg1:msg2:msg3" > => bcb dump recovery > 00000040: 6d 73 67 31 0a 6d 73 67 32 0a 6d 73 67 33 00 00 msg1.msg2.msg3.. > 00000050: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................ > 00000060: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................ > >>> --- snip --- > >>> Every ':' is replaced by line-feed '\n' (0xA). The latter is used > >>> as separator between individual commands by Android userspace > > => bcb store > >>> Flush/store the BCB structure to MMC > > [1] https://android.googlesource.com/platform/bootable/recovery > [2] https://source.android.com/devices/bootloader > [3] https://patchwork.ozlabs.org/patch/746835/ > ("[U-Boot,5/6] Initial support for the Android Bootloader flow") > > Signed-off-by: Eugeniu Rosca <erosca@de.adit-jv.com> > --- > cmd/Kconfig | 17 +++ > cmd/Makefile | 1 + > cmd/bcb.c | 347 +++++++++++++++++++++++++++++++++++++++++++++++++++ > 3 files changed, 365 insertions(+) > create mode 100644 cmd/bcb.c > > diff --git a/cmd/Kconfig b/cmd/Kconfig > index 0b07b3b9d777..2c32d9b85b51 100644 > --- a/cmd/Kconfig > +++ b/cmd/Kconfig > @@ -621,6 +621,23 @@ config CMD_ADC > Shows ADC device info and permit printing one-shot analog converted > data from a named Analog to Digital Converter. > > +config CMD_BCB > + bool "bcb" > + depends on MMC > + depends on PARTITIONS > + help > + Read/modify/write the fields of Bootloader Control Block, usually > + stored on the flash "misc" partition with its structure defined in: > + https://android.googlesource.com/platform/bootable/recovery/+/master/ > + bootloader_message/include/bootloader_message/bootloader_message.h > + > + Some real-life use-cases include (but are not limited to): > + - Determine the "boot reason" (and act accordingly): > + https://source.android.com/devices/bootloader/boot-reason > + - Get/pass a list of commands from/to recovery: > + https://android.googlesource.com/platform/bootable/recovery > + - Inspect/dump the contents of the BCB fields > + > config CMD_BIND > bool "bind/unbind - Bind or unbind a device to/from a driver" > depends on DM > diff --git a/cmd/Makefile b/cmd/Makefile > index acb85f49fba8..b89d5187060b 100644 > --- a/cmd/Makefile > +++ b/cmd/Makefile > @@ -16,6 +16,7 @@ obj-$(CONFIG_CMD_ADC) += adc.o > obj-$(CONFIG_CMD_ARMFLASH) += armflash.o > obj-y += blk_common.o > obj-$(CONFIG_CMD_SOURCE) += source.o > +obj-$(CONFIG_CMD_BCB) += bcb.o > obj-$(CONFIG_CMD_BDI) += bdinfo.o > obj-$(CONFIG_CMD_BEDBUG) += bedbug.o > obj-$(CONFIG_CMD_BIND) += bind.o > diff --git a/cmd/bcb.c b/cmd/bcb.c > new file mode 100644 > index 000000000000..3084f5033d27 > --- /dev/null > +++ b/cmd/bcb.c > @@ -0,0 +1,347 @@ > +// SPDX-License-Identifier: GPL-2.0+ > +/* > + * Copyright (C) 2019 Eugeniu Rosca <rosca.eugeniu@gmail.com> > + * > + * Command to read/modify/write Android BCB fields > + */ > + > +#include <android_bl_msg.h> > +#include <command.h> > +#include <common.h> > +#include <malloc.h> > + > +enum bcb_cmd { > + BCB_CMD_LOAD, > + BCB_CMD_FIELD_SET, > + BCB_CMD_FIELD_CLEAR, > + BCB_CMD_FIELD_TEST, > + BCB_CMD_FIELD_DUMP, > + BCB_CMD_STORE, > +}; > + > +static int bcb_dev = -1; > +static int bcb_part = -1; > +static andr_bl_msg bcb = { { 0 } }; > + > +static int bcb_cmd_get(char *cmd) > +{ > + if (!strncmp(cmd, "load", sizeof("load"))) > + return BCB_CMD_LOAD; > + if (!strncmp(cmd, "set", sizeof("set"))) > + return BCB_CMD_FIELD_SET; > + if (!strncmp(cmd, "clear", sizeof("clear"))) > + return BCB_CMD_FIELD_CLEAR; > + if (!strncmp(cmd, "test", sizeof("test"))) > + return BCB_CMD_FIELD_TEST; > + if (!strncmp(cmd, "store", sizeof("store"))) > + return BCB_CMD_STORE; > + if (!strncmp(cmd, "dump", sizeof("dump"))) > + return BCB_CMD_FIELD_DUMP; > + else > + return -1; > +} > + > +static int > +bcb_load(int argc, char *const argv[], andr_bl_msg *bcb, > + int *bcb_dev, int *bcb_part) > +{ > + struct blk_desc *desc; > + disk_partition_t info; > + u64 cnt; > + char *endp; > + int part; > + > + if (argc != 3) > + return CMD_RET_USAGE; > + > + if (!bcb || !bcb_dev || !bcb_part) > + return CMD_RET_FAILURE; > + > + if (blk_get_device_by_str("mmc", argv[1], &desc) < 0) > + goto err_1; > + > + part = simple_strtoul(argv[2], &endp, 0); > + if (*endp == '\0') { > + if (part_get_info(desc, part, &info)) > + goto err_1; > + } else { > + part = part_get_info_by_name(desc, argv[2], &info); > + if (part < 0) > + goto err_1; > + } > + > + cnt = DIV_ROUND_UP(sizeof(andr_bl_msg), info.blksz); > + if (cnt > info.size) > + goto err_2; > + > + if (blk_dread(desc, info.start, cnt, bcb) != cnt) > + goto err_1; > + > + *bcb_dev = desc->devnum; > + *bcb_part = part; > + debug("%s: Loaded from mmc %d:%d\n", __func__, *bcb_dev, *bcb_part); > + > + return CMD_RET_SUCCESS; > +err_1: > + printf("Failed to read from mmc %s:%s\n", argv[1], argv[2]); > + goto err; > +err_2: > + printf("Error: mmc %s:%s too small!", argv[1], argv[2]); > + goto err; > +err: > + *bcb_dev = *bcb_part = -1; > + return CMD_RET_FAILURE; > +} > + > +static int > +bcb_is_misused(int argc, char *const argv[], andr_bl_msg *bcb, > + int bcb_dev, int bcb_part) > +{ > + if (bcb_dev < 0 || bcb_part < 0) { > + printf("Error: BCB not loaded!\n"); > + return -1; > + } > + if (!bcb) { > + debug("%s: Error: NULL BCB\n", __func__); > + return -1; > + } > + > + switch (bcb_cmd_get(argv[0])) { > + case BCB_CMD_LOAD: > + /* Dedicated arg handling */ > + break; > + case BCB_CMD_FIELD_SET: > + if (argc != 3) > + goto err; > + break; > + case BCB_CMD_FIELD_TEST: > + if (argc != 4) > + goto err; > + break; > + case BCB_CMD_FIELD_CLEAR: > + if (argc != 1 && argc != 2) > + goto err; > + break; > + case BCB_CMD_STORE: > + if (argc != 1) > + goto err; > + break; > + case BCB_CMD_FIELD_DUMP: > + if (argc != 2) > + goto err; > + break; > + default: > + debug("%s: Error: Unexpected BCB command\n", __func__); > + return -1; > + } > + > + return 0; > +err: > + printf("Error: Bad usage of 'bcb %s'\n", argv[0]); > + return -1; > +} > + > +static int > +bcb_field_get(char *name, andr_bl_msg *bcb, char **field, int *size) > +{ > + if (!strncmp(name, "command", sizeof("command"))) { > + *field = bcb->command; > + *size = sizeof(bcb->command); > + } else if (!strncmp(name, "status", sizeof("status"))) { > + *field = bcb->status; > + *size = sizeof(bcb->status); > + } else if (!strncmp(name, "recovery", sizeof("recovery"))) { > + *field = bcb->recovery; > + *size = sizeof(bcb->recovery); > + } else if (!strncmp(name, "stage", sizeof("stage"))) { > + *field = bcb->stage; > + *size = sizeof(bcb->stage); > + } else if (!strncmp(name, "reserved", sizeof("reserved"))) { > + *field = bcb->reserved; > + *size = sizeof(bcb->reserved); > + } else { > + printf("Error: Unknown field '%s'\n", name); > + return -1; > + } > + return 0; > +} > + > +static int > +bcb_field_set(int argc, char *const argv[], andr_bl_msg *bcb, > + int bcb_dev, int bcb_part) > +{ > + int size, len; > + char *field, *str, *found, *keep; > + > + if (bcb_is_misused(argc, argv, bcb, bcb_dev, bcb_part)) > + return CMD_RET_FAILURE; > + > + if (bcb_field_get(argv[1], bcb, &field, &size)) > + return CMD_RET_FAILURE; > + > + len = strlen(argv[2]); > + if (len >= size) { > + printf("Error: sizeof('%s') = %d >= %d = sizeof(bcb.%s)\n", > + argv[2], len, size, argv[1]); > + return CMD_RET_FAILURE; > + } > + str = strdup(argv[2]); > + keep = str; > + > + field[0] = '\0'; > + while ((found = strsep(&str, ":"))) { > + if (field[0] != '\0') > + strcat(field, "\n"); > + strcat(field, found); > + } > + > + free(keep); > + return CMD_RET_SUCCESS; > +} > + > +static int > +bcb_field_clear(int argc, char *const argv[], andr_bl_msg *bcb, > + int bcb_dev, int bcb_part) > +{ > + int size; > + char *field; > + > + if (bcb_is_misused(argc, argv, bcb, bcb_dev, bcb_part)) > + return CMD_RET_FAILURE; > + > + if (argc == 1) { > + memset(bcb, 0, sizeof(*bcb)); > + return CMD_RET_SUCCESS; > + } > + > + if (bcb_field_get(argv[1], bcb, &field, &size)) > + return CMD_RET_FAILURE; > + > + memset(field, 0, size); > + return CMD_RET_SUCCESS; > +} > + > +static int > +bcb_field_dump(int argc, char *const argv[], andr_bl_msg *bcb, > + int bcb_dev, int bcb_part) > +{ > + int size; > + char *field; > + > + if (bcb_is_misused(argc, argv, bcb, bcb_dev, bcb_part)) > + return CMD_RET_FAILURE; > + > + if (bcb_field_get(argv[1], bcb, &field, &size)) > + return CMD_RET_FAILURE; > + > + print_buffer((ulong)field - (ulong)bcb, (void *)field, 1, size, 16); > + return CMD_RET_SUCCESS; > +} > + > +static int > +bcb_field_test(int argc, char *const argv[], andr_bl_msg *bcb, > + int bcb_dev, int bcb_part) > +{ > + int size; > + char *field; > + > + if (bcb_is_misused(argc, argv, bcb, bcb_dev, bcb_part)) > + return CMD_RET_FAILURE; > + > + if (bcb_field_get(argv[1], bcb, &field, &size)) > + return CMD_RET_FAILURE; > + > + if (!strncmp(argv[2], "=", sizeof("="))) { > + if (!strncmp(argv[3], field, size)) > + return CMD_RET_SUCCESS; > + else > + return CMD_RET_FAILURE; > + } else if (!strncmp(argv[2], "~", sizeof("~"))) { > + if (!strstr(field, argv[3])) > + return CMD_RET_FAILURE; > + else > + return CMD_RET_SUCCESS; > + } else { > + printf("Error: Unknown operator '%s'\n", argv[2]); > + } > + return CMD_RET_FAILURE; > +} > + > +static int > +bcb_store(int argc, char *const argv[], andr_bl_msg *bcb, > + int bcb_dev, int bcb_part) > +{ > + struct blk_desc *desc; > + disk_partition_t info; > + u64 cnt; > + > + if (bcb_is_misused(argc, argv, bcb, bcb_dev, bcb_part)) > + return CMD_RET_FAILURE; > + > + desc = blk_get_devnum_by_type(IF_TYPE_MMC, bcb_dev); > + if (!desc) > + goto err; > + > + if (part_get_info(desc, bcb_part, &info)) > + goto err; > + > + cnt = DIV_ROUND_UP(sizeof(andr_bl_msg), info.blksz); > + > + if (blk_dwrite(desc, info.start, cnt, bcb) != cnt) > + goto err; > + > + return CMD_RET_SUCCESS; > +err: > + printf("Failed to write to mmc %d:%d\n", bcb_dev, bcb_part); > + return CMD_RET_FAILURE; > +} > + > +static int do_bcb(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) > +{ > + if (argc < 2) > + return CMD_RET_USAGE; > + > + argc--; > + argv++; > + > + switch (bcb_cmd_get(argv[0])) { > + case BCB_CMD_LOAD: > + return bcb_load(argc, argv, &bcb, &bcb_dev, &bcb_part); > + case BCB_CMD_FIELD_SET: > + return bcb_field_set(argc, argv, &bcb, bcb_dev, bcb_part); > + case BCB_CMD_FIELD_CLEAR: > + return bcb_field_clear(argc, argv, &bcb, bcb_dev, bcb_part); > + case BCB_CMD_FIELD_TEST: > + return bcb_field_test(argc, argv, &bcb, bcb_dev, bcb_part); > + case BCB_CMD_FIELD_DUMP: > + return bcb_field_dump(argc, argv, &bcb, bcb_dev, bcb_part); > + case BCB_CMD_STORE: > + return bcb_store(argc, argv, &bcb, bcb_dev, bcb_part); > + default: > + return CMD_RET_USAGE; > + } Please, implement the sub-commands as described in doc/README.commands using the U_BOOT_CMD_MKENT macro. Best regards Heinrich > + > + return CMD_RET_SUCCESS;> +} > + > +U_BOOT_CMD( > + bcb, CONFIG_SYS_MAXARGS, 1, do_bcb, > + "Load/set/clear/test/dump/store Android BCB fields", > + "load <dev> <part> - load BCB from mmc <dev>:<part>\n" > + "bcb set <field> <val> - set BCB <field> to <val>\n" > + "bcb clear [<field>] - clear BCB <field> or all fields\n" > + "bcb test <field> <op> <val> - test BCB <field> against <val>\n" > + "bcb dump <field> - dump BCB <field>\n" > + "bcb store - store BCB back to mmc\n" > + "\n" > + "Legend:\n" > + "<dev> - MMC device index containing the BCB partition\n" > + "<part> - MMC partition index or name containing the BCB\n" > + "<field> - one of {command,status,recovery,stage,reserved}\n" > + "<op> - the binary operator used in 'bcb test':\n" > + " '=' returns true if <val> matches the string stored in <field>\n" > + " '~' returns true if <val> matches a subset of <field>'s string\n" > + "<val> - string/text provided as input to bcb {set,test}\n" > + " NOTE: any ':' character in <val> will be replaced by line feed\n" > + " during 'bcb set' and used as separator by upper layers\n" > +); >
Hi Heinrich, On Mon, Apr 08, 2019 at 12:11:59AM +0200, Heinrich Schuchardt wrote: [..] > > + switch (bcb_cmd_get(argv[0])) { > > + case BCB_CMD_LOAD: > > + return bcb_load(argc, argv, &bcb, &bcb_dev, &bcb_part); > > + case BCB_CMD_FIELD_SET: > > + return bcb_field_set(argc, argv, &bcb, bcb_dev, bcb_part); > > + case BCB_CMD_FIELD_CLEAR: > > + return bcb_field_clear(argc, argv, &bcb, bcb_dev, bcb_part); > > + case BCB_CMD_FIELD_TEST: > > + return bcb_field_test(argc, argv, &bcb, bcb_dev, bcb_part); > > + case BCB_CMD_FIELD_DUMP: > > + return bcb_field_dump(argc, argv, &bcb, bcb_dev, bcb_part); > > + case BCB_CMD_STORE: > > + return bcb_store(argc, argv, &bcb, bcb_dev, bcb_part); > > + default: > > + return CMD_RET_USAGE; > > + } > > Please, implement the sub-commands as described in doc/README.commands > using the U_BOOT_CMD_MKENT macro. Thanks for the lightning-fast reply. Will fix in v2, once hopefully more review comments are collected. > Best regards > > Heinrich Best regards, Eugeniu.
diff --git a/cmd/Kconfig b/cmd/Kconfig index 0b07b3b9d777..2c32d9b85b51 100644 --- a/cmd/Kconfig +++ b/cmd/Kconfig @@ -621,6 +621,23 @@ config CMD_ADC Shows ADC device info and permit printing one-shot analog converted data from a named Analog to Digital Converter. +config CMD_BCB + bool "bcb" + depends on MMC + depends on PARTITIONS + help + Read/modify/write the fields of Bootloader Control Block, usually + stored on the flash "misc" partition with its structure defined in: + https://android.googlesource.com/platform/bootable/recovery/+/master/ + bootloader_message/include/bootloader_message/bootloader_message.h + + Some real-life use-cases include (but are not limited to): + - Determine the "boot reason" (and act accordingly): + https://source.android.com/devices/bootloader/boot-reason + - Get/pass a list of commands from/to recovery: + https://android.googlesource.com/platform/bootable/recovery + - Inspect/dump the contents of the BCB fields + config CMD_BIND bool "bind/unbind - Bind or unbind a device to/from a driver" depends on DM diff --git a/cmd/Makefile b/cmd/Makefile index acb85f49fba8..b89d5187060b 100644 --- a/cmd/Makefile +++ b/cmd/Makefile @@ -16,6 +16,7 @@ obj-$(CONFIG_CMD_ADC) += adc.o obj-$(CONFIG_CMD_ARMFLASH) += armflash.o obj-y += blk_common.o obj-$(CONFIG_CMD_SOURCE) += source.o +obj-$(CONFIG_CMD_BCB) += bcb.o obj-$(CONFIG_CMD_BDI) += bdinfo.o obj-$(CONFIG_CMD_BEDBUG) += bedbug.o obj-$(CONFIG_CMD_BIND) += bind.o diff --git a/cmd/bcb.c b/cmd/bcb.c new file mode 100644 index 000000000000..3084f5033d27 --- /dev/null +++ b/cmd/bcb.c @@ -0,0 +1,347 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Copyright (C) 2019 Eugeniu Rosca <rosca.eugeniu@gmail.com> + * + * Command to read/modify/write Android BCB fields + */ + +#include <android_bl_msg.h> +#include <command.h> +#include <common.h> +#include <malloc.h> + +enum bcb_cmd { + BCB_CMD_LOAD, + BCB_CMD_FIELD_SET, + BCB_CMD_FIELD_CLEAR, + BCB_CMD_FIELD_TEST, + BCB_CMD_FIELD_DUMP, + BCB_CMD_STORE, +}; + +static int bcb_dev = -1; +static int bcb_part = -1; +static andr_bl_msg bcb = { { 0 } }; + +static int bcb_cmd_get(char *cmd) +{ + if (!strncmp(cmd, "load", sizeof("load"))) + return BCB_CMD_LOAD; + if (!strncmp(cmd, "set", sizeof("set"))) + return BCB_CMD_FIELD_SET; + if (!strncmp(cmd, "clear", sizeof("clear"))) + return BCB_CMD_FIELD_CLEAR; + if (!strncmp(cmd, "test", sizeof("test"))) + return BCB_CMD_FIELD_TEST; + if (!strncmp(cmd, "store", sizeof("store"))) + return BCB_CMD_STORE; + if (!strncmp(cmd, "dump", sizeof("dump"))) + return BCB_CMD_FIELD_DUMP; + else + return -1; +} + +static int +bcb_load(int argc, char *const argv[], andr_bl_msg *bcb, + int *bcb_dev, int *bcb_part) +{ + struct blk_desc *desc; + disk_partition_t info; + u64 cnt; + char *endp; + int part; + + if (argc != 3) + return CMD_RET_USAGE; + + if (!bcb || !bcb_dev || !bcb_part) + return CMD_RET_FAILURE; + + if (blk_get_device_by_str("mmc", argv[1], &desc) < 0) + goto err_1; + + part = simple_strtoul(argv[2], &endp, 0); + if (*endp == '\0') { + if (part_get_info(desc, part, &info)) + goto err_1; + } else { + part = part_get_info_by_name(desc, argv[2], &info); + if (part < 0) + goto err_1; + } + + cnt = DIV_ROUND_UP(sizeof(andr_bl_msg), info.blksz); + if (cnt > info.size) + goto err_2; + + if (blk_dread(desc, info.start, cnt, bcb) != cnt) + goto err_1; + + *bcb_dev = desc->devnum; + *bcb_part = part; + debug("%s: Loaded from mmc %d:%d\n", __func__, *bcb_dev, *bcb_part); + + return CMD_RET_SUCCESS; +err_1: + printf("Failed to read from mmc %s:%s\n", argv[1], argv[2]); + goto err; +err_2: + printf("Error: mmc %s:%s too small!", argv[1], argv[2]); + goto err; +err: + *bcb_dev = *bcb_part = -1; + return CMD_RET_FAILURE; +} + +static int +bcb_is_misused(int argc, char *const argv[], andr_bl_msg *bcb, + int bcb_dev, int bcb_part) +{ + if (bcb_dev < 0 || bcb_part < 0) { + printf("Error: BCB not loaded!\n"); + return -1; + } + if (!bcb) { + debug("%s: Error: NULL BCB\n", __func__); + return -1; + } + + switch (bcb_cmd_get(argv[0])) { + case BCB_CMD_LOAD: + /* Dedicated arg handling */ + break; + case BCB_CMD_FIELD_SET: + if (argc != 3) + goto err; + break; + case BCB_CMD_FIELD_TEST: + if (argc != 4) + goto err; + break; + case BCB_CMD_FIELD_CLEAR: + if (argc != 1 && argc != 2) + goto err; + break; + case BCB_CMD_STORE: + if (argc != 1) + goto err; + break; + case BCB_CMD_FIELD_DUMP: + if (argc != 2) + goto err; + break; + default: + debug("%s: Error: Unexpected BCB command\n", __func__); + return -1; + } + + return 0; +err: + printf("Error: Bad usage of 'bcb %s'\n", argv[0]); + return -1; +} + +static int +bcb_field_get(char *name, andr_bl_msg *bcb, char **field, int *size) +{ + if (!strncmp(name, "command", sizeof("command"))) { + *field = bcb->command; + *size = sizeof(bcb->command); + } else if (!strncmp(name, "status", sizeof("status"))) { + *field = bcb->status; + *size = sizeof(bcb->status); + } else if (!strncmp(name, "recovery", sizeof("recovery"))) { + *field = bcb->recovery; + *size = sizeof(bcb->recovery); + } else if (!strncmp(name, "stage", sizeof("stage"))) { + *field = bcb->stage; + *size = sizeof(bcb->stage); + } else if (!strncmp(name, "reserved", sizeof("reserved"))) { + *field = bcb->reserved; + *size = sizeof(bcb->reserved); + } else { + printf("Error: Unknown field '%s'\n", name); + return -1; + } + return 0; +} + +static int +bcb_field_set(int argc, char *const argv[], andr_bl_msg *bcb, + int bcb_dev, int bcb_part) +{ + int size, len; + char *field, *str, *found, *keep; + + if (bcb_is_misused(argc, argv, bcb, bcb_dev, bcb_part)) + return CMD_RET_FAILURE; + + if (bcb_field_get(argv[1], bcb, &field, &size)) + return CMD_RET_FAILURE; + + len = strlen(argv[2]); + if (len >= size) { + printf("Error: sizeof('%s') = %d >= %d = sizeof(bcb.%s)\n", + argv[2], len, size, argv[1]); + return CMD_RET_FAILURE; + } + str = strdup(argv[2]); + keep = str; + + field[0] = '\0'; + while ((found = strsep(&str, ":"))) { + if (field[0] != '\0') + strcat(field, "\n"); + strcat(field, found); + } + + free(keep); + return CMD_RET_SUCCESS; +} + +static int +bcb_field_clear(int argc, char *const argv[], andr_bl_msg *bcb, + int bcb_dev, int bcb_part) +{ + int size; + char *field; + + if (bcb_is_misused(argc, argv, bcb, bcb_dev, bcb_part)) + return CMD_RET_FAILURE; + + if (argc == 1) { + memset(bcb, 0, sizeof(*bcb)); + return CMD_RET_SUCCESS; + } + + if (bcb_field_get(argv[1], bcb, &field, &size)) + return CMD_RET_FAILURE; + + memset(field, 0, size); + return CMD_RET_SUCCESS; +} + +static int +bcb_field_dump(int argc, char *const argv[], andr_bl_msg *bcb, + int bcb_dev, int bcb_part) +{ + int size; + char *field; + + if (bcb_is_misused(argc, argv, bcb, bcb_dev, bcb_part)) + return CMD_RET_FAILURE; + + if (bcb_field_get(argv[1], bcb, &field, &size)) + return CMD_RET_FAILURE; + + print_buffer((ulong)field - (ulong)bcb, (void *)field, 1, size, 16); + return CMD_RET_SUCCESS; +} + +static int +bcb_field_test(int argc, char *const argv[], andr_bl_msg *bcb, + int bcb_dev, int bcb_part) +{ + int size; + char *field; + + if (bcb_is_misused(argc, argv, bcb, bcb_dev, bcb_part)) + return CMD_RET_FAILURE; + + if (bcb_field_get(argv[1], bcb, &field, &size)) + return CMD_RET_FAILURE; + + if (!strncmp(argv[2], "=", sizeof("="))) { + if (!strncmp(argv[3], field, size)) + return CMD_RET_SUCCESS; + else + return CMD_RET_FAILURE; + } else if (!strncmp(argv[2], "~", sizeof("~"))) { + if (!strstr(field, argv[3])) + return CMD_RET_FAILURE; + else + return CMD_RET_SUCCESS; + } else { + printf("Error: Unknown operator '%s'\n", argv[2]); + } + return CMD_RET_FAILURE; +} + +static int +bcb_store(int argc, char *const argv[], andr_bl_msg *bcb, + int bcb_dev, int bcb_part) +{ + struct blk_desc *desc; + disk_partition_t info; + u64 cnt; + + if (bcb_is_misused(argc, argv, bcb, bcb_dev, bcb_part)) + return CMD_RET_FAILURE; + + desc = blk_get_devnum_by_type(IF_TYPE_MMC, bcb_dev); + if (!desc) + goto err; + + if (part_get_info(desc, bcb_part, &info)) + goto err; + + cnt = DIV_ROUND_UP(sizeof(andr_bl_msg), info.blksz); + + if (blk_dwrite(desc, info.start, cnt, bcb) != cnt) + goto err; + + return CMD_RET_SUCCESS; +err: + printf("Failed to write to mmc %d:%d\n", bcb_dev, bcb_part); + return CMD_RET_FAILURE; +} + +static int do_bcb(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) +{ + if (argc < 2) + return CMD_RET_USAGE; + + argc--; + argv++; + + switch (bcb_cmd_get(argv[0])) { + case BCB_CMD_LOAD: + return bcb_load(argc, argv, &bcb, &bcb_dev, &bcb_part); + case BCB_CMD_FIELD_SET: + return bcb_field_set(argc, argv, &bcb, bcb_dev, bcb_part); + case BCB_CMD_FIELD_CLEAR: + return bcb_field_clear(argc, argv, &bcb, bcb_dev, bcb_part); + case BCB_CMD_FIELD_TEST: + return bcb_field_test(argc, argv, &bcb, bcb_dev, bcb_part); + case BCB_CMD_FIELD_DUMP: + return bcb_field_dump(argc, argv, &bcb, bcb_dev, bcb_part); + case BCB_CMD_STORE: + return bcb_store(argc, argv, &bcb, bcb_dev, bcb_part); + default: + return CMD_RET_USAGE; + } + + return CMD_RET_SUCCESS; +} + +U_BOOT_CMD( + bcb, CONFIG_SYS_MAXARGS, 1, do_bcb, + "Load/set/clear/test/dump/store Android BCB fields", + "load <dev> <part> - load BCB from mmc <dev>:<part>\n" + "bcb set <field> <val> - set BCB <field> to <val>\n" + "bcb clear [<field>] - clear BCB <field> or all fields\n" + "bcb test <field> <op> <val> - test BCB <field> against <val>\n" + "bcb dump <field> - dump BCB <field>\n" + "bcb store - store BCB back to mmc\n" + "\n" + "Legend:\n" + "<dev> - MMC device index containing the BCB partition\n" + "<part> - MMC partition index or name containing the BCB\n" + "<field> - one of {command,status,recovery,stage,reserved}\n" + "<op> - the binary operator used in 'bcb test':\n" + " '=' returns true if <val> matches the string stored in <field>\n" + " '~' returns true if <val> matches a subset of <field>'s string\n" + "<val> - string/text provided as input to bcb {set,test}\n" + " NOTE: any ':' character in <val> will be replaced by line feed\n" + " during 'bcb set' and used as separator by upper layers\n" +);