leandrof/u-boot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update uclass iterators to work better when devices fail to probe

Browse Source 
Support VBE OS requests / fixups
 Minor error-handling tweaks to bootm command
 -----BEGIN PGP SIGNATURE-----
 
 iQFFBAABCgAvFiEEslwAIq+Gp8wWVbYnfxc6PpAIreYFAmNOjr4RHHNqZ0BjaHJv
 bWl1bS5vcmcACgkQfxc6PpAIreakFQf/bLTFMI8noOMa9d6Yo1RTSOa9wNiomgzC
 JGY7g8i7b6cARwQ+QuSncnO/EOpwjzBLWkohUK3UAktJu2LURBPJFR4qeP01F7iz
 4Mn3ikYlr3vRxAPeckN7l1aqSWrY/tEXbUdXLxSn+COzjxCQG5aBU1jd/tVBqIAk
 XgZ0NGVHOQe8XOPNxDP9+EYHw4kmqMSdWZmpkb1w+Jh5AIYMMDgn1ktiNmnWXllx
 LM89JxR8FMUJzFP9XBRtYemje55tAUPlENthRip9Zj9touEBbBKjV5eY8YsjpMMU
 Vt5rK33vKWE4mdNBjRmOoe9xkUv/pRclpaGUFBNswf2LGw7/lsHd2A==
 =3P/S
 -----END PGP SIGNATURE-----

Merge tag 'dm-pull-18oct22' of https://source.denx.de/u-boot/custodians/u-boot-dm

Update uclass iterators to work better when devices fail to probe
Support VBE OS requests / fixups
Minor error-handling tweaks to bootm command
This commit is contained in:
Tom Rini 2022-10-18 07:36:52 -04:00
commit 700b4fe782
77 changed files with 906 additions and 407 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arch/arm/mach-k3/j721s2_init.c
View File

@ -164,7 +164,7 @@ void board_init_f(ulong dummy)
if (ret)
panic("DRAM 0 init failed: %d\n", ret);
ret = uclass_next_device(&dev);
ret = uclass_next_device_err(&dev);
if (ret)
panic("DRAM 1 init failed: %d\n", ret);
}

4
arch/arm/mach-omap2/am33xx/board.c
View File

@ -265,8 +265,8 @@ int arch_misc_init(void)
struct udevice *dev;
int ret;
ret = uclass_first_device(UCLASS_MISC, &dev);
if (ret || !dev)
ret = uclass_first_device_err(UCLASS_MISC, &dev);
if (ret)
return ret;
#if defined(CONFIG_DM_ETH) && defined(CONFIG_USB_ETHER)

17
arch/sandbox/lib/bootm.c
View File

@ -50,8 +50,25 @@ int bootz_setup(ulong image, ulong *start, ulong *end)
return ret;
}
/* Subcommand: PREP */
static int boot_prep_linux(struct bootm_headers *images)
{
int ret;
if (CONFIG_IS_ENABLED(LMB)) {
ret = image_setup_linux(images);
if (ret)
return ret;
}
return 0;
}
int do_bootm_linux(int flag, int argc, char *argv[], struct bootm_headers *images)
{
if (flag & BOOTM_STATE_OS_PREP)
return boot_prep_linux(images);
if (flag & (BOOTM_STATE_OS_GO | BOOTM_STATE_OS_FAKE_GO)) {
bootstage_mark(BOOTSTAGE_ID_RUN_OS);
printf("## Transferring control to Linux (at address %08lx)...\n",

4
arch/x86/cpu/broadwell/cpu.c
View File

@ -31,11 +31,9 @@ static int broadwell_init_cpu(void *ctx, struct event *event)
int ret;
/* Start up the LPC so we have serial */
ret = uclass_first_device(UCLASS_LPC, &dev);
ret = uclass_first_device_err(UCLASS_LPC, &dev);
if (ret)
return ret;
if (!dev)
return -ENODEV;
ret = cpu_set_flex_ratio_to_tdp_nominal();
if (ret)
return ret;

4
arch/x86/cpu/intel_common/cpu.c
View File

@ -61,11 +61,9 @@ int cpu_common_init(void)
/* Early chipset init required before RAM init can work */
uclass_first_device(UCLASS_NORTHBRIDGE, &dev);
ret = uclass_first_device(UCLASS_LPC, &lpc);
ret = uclass_first_device_err(UCLASS_LPC, &lpc);
if (ret)
return ret;
if (!lpc)
return -ENODEV;
/* Cause the SATA device to do its early init */
uclass_first_device(UCLASS_AHCI, &dev);

4
arch/x86/lib/pinctrl_ich6.c
View File

@ -160,11 +160,9 @@ static int ich6_pinctrl_probe(struct udevice *dev)
u32 iobase = -1;
debug("%s: start\n", __func__);
ret = uclass_first_device(UCLASS_PCH, &pch);
ret = uclass_first_device_err(UCLASS_PCH, &pch);
if (ret)
return ret;
if (!pch)
return -ENODEV;
/*
* Get the memory/io base address to configure every pins.

2
board/atmel/common/mac_eeprom.c
View File

@ -56,7 +56,7 @@ int at91_set_eth1addr(int offset)
return ret;
/* attempt to obtain a second eeprom device */
ret = uclass_next_device(&dev);
ret = uclass_next_device_err(&dev);
if (ret)
return ret;

12
board/gdsys/mpc8308/gazerbeam.c
View File

@ -49,8 +49,10 @@ int board_early_init_r(void)
int mc = 0;
int con = 0;
if (sysinfo_get(&sysinfo))
if (sysinfo_get(&sysinfo)) {
puts("Could not find sysinfo information device.\n");
sysinfo = NULL;
}
/* Initialize serdes */
uclass_get_device_by_phandle(UCLASS_MISC, sysinfo, "serdes", &serdes);
@ -92,8 +94,10 @@ int checksysinfo(void)
int mc = 0;
int con = 0;
if (sysinfo_get(&sysinfo))
if (sysinfo_get(&sysinfo)) {
puts("Could not find sysinfo information device.\n");
sysinfo = NULL;
}
sysinfo_get_int(sysinfo, BOARD_MULTICHANNEL, &mc);
sysinfo_get_int(sysinfo, BOARD_VARIANT, &con);
@ -130,8 +134,10 @@ int last_stage_init(void)
struct udevice *tpm;
int ret;
if (sysinfo_get(&sysinfo))
if (sysinfo_get(&sysinfo)) {
puts("Could not find sysinfo information device.\n");
sysinfo = NULL;
}
if (sysinfo) {
int res = sysinfo_get_int(sysinfo, BOARD_HWVERSION,

4
board/intel/cougarcanyon2/cougarcanyon2.c
View File

@ -21,11 +21,9 @@ int board_early_init_f(void)
struct udevice *pch;
int ret;
ret = uclass_first_device(UCLASS_PCH, &pch);
ret = uclass_first_device_err(UCLASS_PCH, &pch);
if (ret)
return ret;
if (!pch)
return -ENODEV;
/* Initialize LPC interface to turn on superio chipset decode range */
dm_pci_write_config16(pch, LPC_IO_DEC, COMA_DEC_RANGE | COMB_DEC_RANGE);

2
boot/Makefile
View File

@ -47,5 +47,5 @@ ifdef CONFIG_SPL_BUILD
obj-$(CONFIG_SPL_LOAD_FIT) += common_fit.o
endif
obj-$(CONFIG_$(SPL_TPL_)BOOTMETH_VBE) += vbe.o
obj-$(CONFIG_$(SPL_TPL_)BOOTMETH_VBE) += vbe.o vbe_fixup.o
obj-$(CONFIG_$(SPL_TPL_)BOOTMETH_VBE_SIMPLE) += vbe_simple.o

4
boot/bootdev-uclass.c
View File

@ -195,7 +195,7 @@ void bootdev_list(bool probe)
printf("Seq Probed Status Uclass Name\n");
printf("--- ------ ------ -------- ------------------\n");
if (probe)
ret = uclass_first_device_err(UCLASS_BOOTDEV, &dev);
ret = uclass_first_device_check(UCLASS_BOOTDEV, &dev);
else
ret = uclass_find_first_device(UCLASS_BOOTDEV, &dev);
for (i = 0; dev; i++) {
@ -204,7 +204,7 @@ void bootdev_list(bool probe)
ret ? simple_itoa(ret) : "OK",
dev_get_uclass_name(dev_get_parent(dev)), dev->name);
if (probe)
ret = uclass_next_device_err(&dev);
ret = uclass_next_device_check(&dev);
else
ret = uclass_find_next_device(&dev);
}

2
boot/bootm.c
View File

@ -790,7 +790,7 @@ int do_bootm_states(struct cmd_tbl *cmdtp, int flag, int argc,
/* Check for unsupported subcommand. */
if (ret) {
puts("subcommand not supported\n");
printf("subcommand failed (err=%d)\n", ret);
return ret;
}

37
boot/image-fdt.c
View File

@ -186,24 +186,25 @@ int boot_relocate_fdt(struct lmb *lmb, char **of_flat_tree, ulong *of_size)
/* If fdt_high is set use it to select the relocation address */
fdt_high = env_get("fdt_high");
if (fdt_high) {
void *desired_addr = (void *)hextoul(fdt_high, NULL);
ulong desired_addr = hextoul(fdt_high, NULL);
ulong addr;
if (((ulong) desired_addr) == ~0UL) {
if (desired_addr == ~0UL) {
/* All ones means use fdt in place */
of_start = fdt_blob;
lmb_reserve(lmb, (ulong)of_start, of_len);
lmb_reserve(lmb, map_to_sysmem(of_start), of_len);
disable_relocation = 1;
} else if (desired_addr) {
of_start =
(void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000,
(ulong)desired_addr);
addr = lmb_alloc_base(lmb, of_len, 0x1000,
desired_addr);
of_start = map_sysmem(addr, of_len);
if (of_start == NULL) {
puts("Failed using fdt_high value for Device Tree");
goto error;
}
} else {
of_start =
(void *)(ulong) lmb_alloc(lmb, of_len, 0x1000);
addr = lmb_alloc(lmb, of_len, 0x1000);
of_start = map_sysmem(addr, of_len);
}
} else {
mapsize = env_get_bootm_mapsize();
@ -224,9 +225,8 @@ int boot_relocate_fdt(struct lmb *lmb, char **of_flat_tree, ulong *of_size)
* At least part of this DRAM bank is usable, try
* using it for LMB allocation.
*/
of_start =
(void *)(ulong) lmb_alloc_base(lmb, of_len, 0x1000,
start + usable);
of_start = map_sysmem((ulong)lmb_alloc_base(lmb,
of_len, 0x1000, start + usable), of_len);
/* Allocation succeeded, use this block. */
if (of_start != NULL)
break;
@ -665,15 +665,18 @@ int image_setup_libfdt(struct bootm_headers *images, void *blob,
goto err;
}
}
if (CONFIG_IS_ENABLED(EVENT)) {
if (!of_live_active() && CONFIG_IS_ENABLED(EVENT)) {
struct event_ft_fixup fixup;
fixup.tree = oftree_default();
fixup.tree = oftree_from_fdt(blob);
fixup.images = images;
ret = event_notify(EVT_FT_FIXUP, &fixup, sizeof(fixup));
if (ret) {
printf("ERROR: fdt fixup event failed: %d\n", ret);
goto err;
if (oftree_valid(fixup.tree)) {
ret = event_notify(EVT_FT_FIXUP, &fixup, sizeof(fixup));
if (ret) {
printf("ERROR: fdt fixup event failed: %d\n",
ret);
goto err;
}
}
}

233
boot/vbe_fixup.c Normal file
View File

@ -0,0 +1,233 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Verified Boot for Embedded (VBE) device tree fixup functions
*
* Copyright 2022 Google LLC
* Written by Simon Glass <sjg@chromium.org>
*/
#define LOG_CATEGORY LOGC_BOOT
#include <common.h>
#include <dm.h>
#include <event.h>
#include <image.h>
#include <malloc.h>
#include <rng.h>
#include <dm/ofnode.h>
#define VBE_PREFIX "vbe,"
#define VBE_PREFIX_LEN (sizeof(VBE_PREFIX) - 1)
#define VBE_ERR_STR_LEN 128
#define VBE_MAX_RAND_SIZE 256
struct vbe_result {
int errnum;
char err_str[VBE_ERR_STR_LEN];
};
typedef int (*vbe_req_func)(ofnode node, struct vbe_result *result);
static int handle_random_req(ofnode node, int default_size,
struct vbe_result *result)
{
char buf[VBE_MAX_RAND_SIZE];
struct udevice *dev;
u32 size;
int ret;
if (!IS_ENABLED(CONFIG_DM_RNG))
return -ENOTSUPP;
if (ofnode_read_u32(node, "vbe,size", &size)) {
if (!default_size) {
snprintf(result->err_str, VBE_ERR_STR_LEN,
"Missing vbe,size property");
return log_msg_ret("byt", -EINVAL);
}
size = default_size;
}
if (size > VBE_MAX_RAND_SIZE) {
snprintf(result->err_str, VBE_ERR_STR_LEN,
"vbe,size %#x exceeds max size %#x", size,
VBE_MAX_RAND_SIZE);
return log_msg_ret("siz", -E2BIG);
}
ret = uclass_first_device_err(UCLASS_RNG, &dev);
if (ret) {
snprintf(result->err_str, VBE_ERR_STR_LEN,
"Cannot find random-number device (err=%d)", ret);
return log_msg_ret("wr", ret);
}
ret = dm_rng_read(dev, buf, size);
if (ret) {
snprintf(result->err_str, VBE_ERR_STR_LEN,
"Failed to read random-number device (err=%d)", ret);
return log_msg_ret("rd", ret);
}
ret = ofnode_write_prop(node, "data", buf, size, true);
if (ret)
return log_msg_ret("wr", -EINVAL);
return 0;
}
static int vbe_req_random_seed(ofnode node, struct vbe_result *result)
{
return handle_random_req(node, 0, result);
}
static int vbe_req_aslr_move(ofnode node, struct vbe_result *result)
{
return -ENOTSUPP;
}
static int vbe_req_aslr_rand(ofnode node, struct vbe_result *result)
{
return handle_random_req(node, 4, result);
}
static int vbe_req_efi_runtime_rand(ofnode node, struct vbe_result *result)
{
return handle_random_req(node, 4, result);
}
static struct vbe_req {
const char *compat;
vbe_req_func func;
} vbe_reqs[] = {
/* address space layout randomization - move the OS in memory */
{ "aslr-move", vbe_req_aslr_move },
/* provide random data for address space layout randomization */
{ "aslr-rand", vbe_req_aslr_rand },
/* provide random data for EFI-runtime-services address */
{ "efi-runtime-rand", vbe_req_efi_runtime_rand },
/* generate random data bytes to see the OS's rand generator */
{ "random-rand", vbe_req_random_seed },
};
static int vbe_process_request(ofnode node, struct vbe_result *result)
{
const char *compat, *req_name;
int i;
compat = ofnode_read_string(node, "compatible");
if (!compat)
return 0;
if (strlen(compat) <= VBE_PREFIX_LEN ||
strncmp(compat, VBE_PREFIX, VBE_PREFIX_LEN))
return -EINVAL;
req_name = compat + VBE_PREFIX_LEN; /* drop "vbe," prefix */
for (i = 0; i < ARRAY_SIZE(vbe_reqs); i++) {
if (!strcmp(vbe_reqs[i].compat, req_name)) {
int ret;
ret = vbe_reqs[i].func(node, result);
if (ret)
return log_msg_ret("req", ret);
return 0;
}
}
snprintf(result->err_str, VBE_ERR_STR_LEN, "Unknown request: %s",
req_name);
return -ENOTSUPP;
}
/**
* bootmeth_vbe_ft_fixup() - Process VBE OS requests and do device tree fixups
*
* If there are no images provided, this does nothing and returns 0.
*
* @ctx: Context for event
* @event: Event to process
* @return 0 if OK, -ve on error
*/
static int bootmeth_vbe_ft_fixup(void *ctx, struct event *event)
{
const struct event_ft_fixup *fixup = &event->data.ft_fixup;
const struct bootm_headers *images = fixup->images;
ofnode parent, dest_parent, root, node;
oftree fit;
if (!images || !images->fit_hdr_os)
return 0;
/* Get the image node with requests in it */
log_debug("fit=%p, noffset=%d\n", images->fit_hdr_os,
images->fit_noffset_os);
fit = oftree_from_fdt(images->fit_hdr_os);
root = oftree_root(fit);
if (of_live_active()) {
log_warning("Cannot fix up live tree\n");
return 0;
}
if (!ofnode_valid(root))
return log_msg_ret("rt", -EINVAL);
parent = noffset_to_ofnode(root, images->fit_noffset_os);
if (!ofnode_valid(parent))
return log_msg_ret("img", -EINVAL);
dest_parent = oftree_path(fixup->tree, "/chosen");
if (!ofnode_valid(dest_parent))
return log_msg_ret("dst", -EINVAL);
ofnode_for_each_subnode(node, parent) {
const char *name = ofnode_get_name(node);
struct vbe_result result;
ofnode dest;
int ret;
log_debug("copy subnode: %s\n", name);
ret = ofnode_add_subnode(dest_parent, name, &dest);
if (ret && ret != -EEXIST)
return log_msg_ret("add", ret);
ret = ofnode_copy_props(node, dest);
if (ret)
return log_msg_ret("cp", ret);
*result.err_str = '\0';
ret = vbe_process_request(dest, &result);
if (ret) {
result.errnum = ret;
log_err("Failed to process VBE request %s (err=%d)\n",
ofnode_get_name(dest), ret);
if (*result.err_str) {
char *msg = strdup(result.err_str);
if (!msg)
return log_msg_ret("msg", -ENOMEM);
ret = ofnode_write_string(dest, "vbe,error",
msg);
if (ret) {
free(msg);
return log_msg_ret("str", -ENOMEM);
}
}
if (result.errnum) {
ret = ofnode_write_u32(dest, "vbe,errnum",
result.errnum);
if (ret)
return log_msg_ret("num", -ENOMEM);
if (result.errnum != -ENOTSUPP)
return log_msg_ret("pro",
result.errnum);
if (result.errnum == -ENOTSUPP &&
ofnode_read_bool(dest, "vbe,required")) {
log_err("Cannot handle required request: %s\n",
ofnode_get_name(dest));
return log_msg_ret("req",
result.errnum);
}
}
}
}
return 0;
}
EVENT_SPY(EVT_FT_FIXUP, bootmeth_vbe_ft_fixup);

16
boot/vbe_simple.c
View File

@ -6,6 +6,8 @@
* Written by Simon Glass <sjg@chromium.org>
*/
#define LOG_CATEGORY LOGC_BOOT
#include <common.h>
#include <log.h>
#include <memalign.h>
@ -199,17 +201,17 @@ int vbe_simple_fixup_node(ofnode node, struct simple_state *state)
version = strdup(state->fw_version);
if (!version)
return log_msg_ret("ver", -ENOMEM);
return log_msg_ret("dup", -ENOMEM);
ret = ofnode_write_string(node, "cur-version", version);
if (ret)
return log_msg_ret("ver", ret);
ret = ofnode_write_u32(node, "cur-vernum", state->fw_vernum);
if (ret)
return log_msg_ret("ver", ret);
return log_msg_ret("num", ret);
ret = ofnode_write_string(node, "bootloader-version", version_string);
if (ret)
return log_msg_ret("fix", ret);
return log_msg_ret("bl", ret);
return 0;
}
@ -233,7 +235,7 @@ static int bootmeth_vbe_simple_ft_fixup(void *ctx, struct event *event)
*/
for (vbe_find_first_device(&dev); dev; vbe_find_next_device(&dev)) {
struct simple_state state;
ofnode node;
ofnode node, subnode;
int ret;
if (strcmp("vbe_simple", dev->driver->name))
@ -243,8 +245,8 @@ static int bootmeth_vbe_simple_ft_fixup(void *ctx, struct event *event)
node = oftree_path(tree, "/chosen/fwupd");
if (!ofnode_valid(node))
continue;
node = ofnode_find_subnode(node, dev->name);
if (!ofnode_valid(node))
subnode = ofnode_find_subnode(node, dev->name);
if (!ofnode_valid(subnode))
continue;
log_debug("Fixing up: %s\n", dev->name);
@ -255,7 +257,7 @@ static int bootmeth_vbe_simple_ft_fixup(void *ctx, struct event *event)
if (ret)
return log_msg_ret("read", ret);
ret = vbe_simple_fixup_node(node, &state);
ret = vbe_simple_fixup_node(subnode, &state);
if (ret)
return log_msg_ret("fix", ret);
}

24
cmd/adc.c
View File

@ -12,23 +12,19 @@ static int do_adc_list(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
struct udevice *dev;
int ret;
int ret, err;
ret = uclass_first_device_err(UCLASS_ADC, &dev);
if (ret) {
printf("No available ADC device\n");
return CMD_RET_FAILURE;
ret = err = uclass_first_device_check(UCLASS_ADC, &dev);
while (dev) {
printf("- %s status: %i\n", dev->name, ret);
ret = uclass_next_device_check(&dev);
if (ret)
err = ret;
}
do {
printf("- %s\n", dev->name);
ret = uclass_next_device(&dev);
if (ret)
return CMD_RET_FAILURE;
} while (dev);
return CMD_RET_SUCCESS;
return err ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
}
static int do_adc_info(struct cmd_tbl *cmdtp, int flag, int argc,

25
cmd/bootm.c
View File

@ -111,7 +111,7 @@ static int do_bootm_subcommand(struct cmd_tbl *cmdtp, int flag, int argc,
bootm_get_addr(argc, argv) + image_load_offset);
#endif
return ret;
return ret ? CMD_RET_FAILURE : 0;
}
/*******************************************************************/
@ -120,6 +120,9 @@ static int do_bootm_subcommand(struct cmd_tbl *cmdtp, int flag, int argc,
int do_bootm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int states;
int ret;
#ifdef CONFIG_NEEDS_MANUAL_RELOC
static int relocated = 0;
@ -152,17 +155,17 @@ int do_bootm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
return do_bootm_subcommand(cmdtp, flag, argc, argv);
}
return do_bootm_states(cmdtp, flag, argc, argv, BOOTM_STATE_START |
BOOTM_STATE_FINDOS | BOOTM_STATE_PRE_LOAD | BOOTM_STATE_FINDOTHER |
BOOTM_STATE_LOADOS |
#ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
BOOTM_STATE_RAMDISK |
#endif
#if defined(CONFIG_PPC) || defined(CONFIG_MIPS)
BOOTM_STATE_OS_CMDLINE |
#endif
states = BOOTM_STATE_START | BOOTM_STATE_FINDOS | BOOTM_STATE_PRE_LOAD |
BOOTM_STATE_FINDOTHER | BOOTM_STATE_LOADOS |
BOOTM_STATE_OS_PREP | BOOTM_STATE_OS_FAKE_GO |
BOOTM_STATE_OS_GO, &images, 1);
BOOTM_STATE_OS_GO;
if (IS_ENABLED(CONFIG_SYS_BOOT_RAMDISK_HIGH))
states |= BOOTM_STATE_RAMDISK;
if (IS_ENABLED(CONFIG_PPC) || IS_ENABLED(CONFIG_MIPS))
states |= BOOTM_STATE_OS_CMDLINE;
ret = do_bootm_states(cmdtp, flag, argc, argv, states, &images, 1);
return ret ? CMD_RET_FAILURE : 0;
}
int bootm_maybe_autostart(struct cmd_tbl *cmdtp, const char *cmd)

15
cmd/demo.c
View File

@ -64,20 +64,23 @@ static int do_demo_light(struct cmd_tbl *cmdtp, int flag, int argc,
int do_demo_list(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct udevice *dev;
int i, ret;
int i, ret, err = 0;
puts("Demo uclass entries:\n");
for (i = 0, ret = uclass_first_device(UCLASS_DEMO, &dev);
for (i = 0, ret = uclass_first_device_check(UCLASS_DEMO, &dev);
dev;
ret = uclass_next_device(&dev)) {
printf("entry %d - instance %08x, ops %08x, plat %08x\n",
ret = uclass_next_device_check(&dev)) {
printf("entry %d - instance %08x, ops %08x, plat %08x, status %i\n",
i++, (uint)map_to_sysmem(dev),
(uint)map_to_sysmem(dev->driver->ops),
(uint)map_to_sysmem(dev_get_plat(dev)));
(uint)map_to_sysmem(dev_get_plat(dev)),
ret);
if (ret)
err = ret;
}
return cmd_process_error(cmdtp, ret);
return cmd_process_error(cmdtp, err);
}
static struct cmd_tbl demo_commands[] = {

1
cmd/fdt.c
View File

@ -40,6 +40,7 @@ void set_working_fdt_addr(ulong addr)
{
void *buf;
printf("Working FDT set to %lx\n", addr);
buf = map_sysmem(addr, 0);
working_fdt = buf;
env_set_hex("fdtaddr", addr);

15
cmd/gpio.c
View File

@ -77,17 +77,24 @@ static int do_gpio_status(bool all, const char *gpio_name)
struct udevice *dev;
int banklen;
int flags;
int ret;
int ret, err = 0;
flags = 0;
if (gpio_name && !*gpio_name)
gpio_name = NULL;
for (ret = uclass_first_device(UCLASS_GPIO, &dev);
for (ret = uclass_first_device_check(UCLASS_GPIO, &dev);
dev;
ret = uclass_next_device(&dev)) {
ret = uclass_next_device_check(&dev)) {
const char *bank_name;
int num_bits;
if (ret) {
printf("GPIO device %s probe error %i\n",
dev->name, ret);
err = ret;
continue;
}
flags |= FLAG_SHOW_BANK;
if (all)
flags |= FLAG_SHOW_ALL;
@ -120,7 +127,7 @@ static int do_gpio_status(bool all, const char *gpio_name)
flags |= FLAG_SHOW_NEWLINE;
}
return ret;
return err;
}
#endif

15
cmd/pmic.c
View File

@ -51,25 +51,26 @@ static int do_list(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
struct udevice *dev;
int ret;
int ret, err = 0;
printf("| %-*.*s| %-*.*s| %s @ %s\n",
LIMIT_DEV, LIMIT_DEV, "Name",
LIMIT_PARENT, LIMIT_PARENT, "Parent name",
"Parent uclass", "seq");
for (ret = uclass_first_device(UCLASS_PMIC, &dev); dev;
ret = uclass_next_device(&dev)) {
for (ret = uclass_first_device_check(UCLASS_PMIC, &dev); dev;
ret = uclass_next_device_check(&dev)) {
if (ret)
continue;
err = ret;
printf("| %-*.*s| %-*.*s| %s @ %d\n",
printf("| %-*.*s| %-*.*s| %s @ %d | status: %i\n",
LIMIT_DEV, LIMIT_DEV, dev->name,
LIMIT_PARENT, LIMIT_PARENT, dev->parent->name,
dev_get_uclass_name(dev->parent), dev_seq(dev->parent));
dev_get_uclass_name(dev->parent), dev_seq(dev->parent),
ret);
}
if (ret)
if (err)
return CMD_RET_FAILURE;
return CMD_RET_SUCCESS;

13
cmd/regulator.c
View File

@ -205,7 +205,7 @@ static void do_status_detail(struct udevice *dev,
constraint(" * mode id:", mode, mode_name);
}
static void do_status_line(struct udevice *dev)
static void do_status_line(struct udevice *dev, int status)
{
struct dm_regulator_uclass_plat *pdata;
int current, value, mode;
@ -231,6 +231,7 @@ static void do_status_line(struct udevice *dev)
printf("%-10s", mode_name);
else
printf("%-10s", "-");
printf(" %i", status);
printf("\n");
}
@ -250,11 +251,11 @@ static int do_status(struct cmd_tbl *cmdtp, int flag, int argc,
}
/* Show all of them in a list, probing them as needed */
printf("%-20s %-10s %10s %10s %-10s\n", "Name", "Enabled", "uV", "mA",
"Mode");
for (ret = uclass_first_device(UCLASS_REGULATOR, &dev); dev;
ret = uclass_next_device(&dev))
do_status_line(dev);
printf("%-20s %-10s %10s %10s %-10s %s\n", "Name", "Enabled", "uV", "mA",
"Mode", "Status");
for (ret = uclass_first_device_check(UCLASS_REGULATOR, &dev); dev;
ret = uclass_next_device_check(&dev))
do_status_line(dev, ret);
return CMD_RET_SUCCESS;
}

32
common/stdio.c
View File

@ -314,7 +314,6 @@ int stdio_init_tables(void)
int stdio_add_devices(void)
{
struct udevice *dev;
struct uclass *uc;
int ret;
if (IS_ENABLED(CONFIG_DM_KEYBOARD)) {
@ -324,24 +323,18 @@ int stdio_add_devices(void)
* have a list of input devices to start up in the stdin
* environment variable. That work probably makes more sense
* when stdio itself is converted to driver model.
*
* TODO(sjg@chromium.org): Convert changing
* uclass_first_device() etc. to return the device even on
* error. Then we could use that here.
*/
ret = uclass_get(UCLASS_KEYBOARD, &uc);
if (ret)
return ret;
/*
* Don't report errors to the caller - assume that they are
* non-fatal
*/
uclass_foreach_dev(dev, uc) {
ret = device_probe(dev);
for (ret = uclass_first_device_check(UCLASS_KEYBOARD, &dev);
dev;
ret = uclass_next_device_check(&dev)) {
if (ret)
printf("Failed to probe keyboard '%s'\n",
dev->name);
printf("%s: Failed to probe keyboard '%s' (ret=%d)\n",
__func__, dev->name, ret);
}
}
#if CONFIG_IS_ENABLED(SYS_I2C_LEGACY)
@ -361,13 +354,14 @@ int stdio_add_devices(void)
int ret;
if (!IS_ENABLED(CONFIG_SYS_CONSOLE_IS_IN_ENV)) {
for (ret = uclass_first_device(UCLASS_VIDEO, &vdev);
vdev;
ret = uclass_next_device(&vdev))
;
if (ret)
printf("%s: Video device failed (ret=%d)\n",
__func__, ret);
for (ret = uclass_first_device_check(UCLASS_VIDEO,
&vdev);
vdev;
ret = uclass_next_device_check(&vdev)) {
if (ret)
printf("%s: Failed to probe video device '%s' (ret=%d)\n",
__func__, vdev->name, ret);
}
}
if (IS_ENABLED(CONFIG_SPLASH_SCREEN) &&
IS_ENABLED(CONFIG_CMD_BMP))

2
configs/sandbox_flattree_defconfig
View File

@ -11,7 +11,6 @@ CONFIG_DISTRO_DEFAULTS=y
CONFIG_FIT=y
CONFIG_FIT_SIGNATURE=y
CONFIG_FIT_VERBOSE=y
# CONFIG_BOOTMETH_VBE is not set
CONFIG_BOOTSTAGE=y
CONFIG_BOOTSTAGE_REPORT=y
CONFIG_BOOTSTAGE_FDT=y
@ -84,6 +83,7 @@ CONFIG_REGMAP=y
CONFIG_SYSCON=y
CONFIG_DEVRES=y
CONFIG_DEBUG_DEVRES=y
CONFIG_OFNODE_MULTI_TREE=y
CONFIG_ADC=y
CONFIG_ADC_SANDBOX=y
CONFIG_AXI=y

15
disk/part_efi.c
View File

@ -264,20 +264,19 @@ int part_get_info_efi(struct blk_desc *dev_desc, int part,
/* "part" argument must be at least 1 */
if (part < 1) {
printf("%s: Invalid Argument(s)\n", __func__);
return -1;
log_debug("Invalid Argument(s)\n");
return -EINVAL;
}
/* This function validates AND fills in the GPT header and PTE */
if (find_valid_gpt(dev_desc, gpt_head, &gpt_pte) != 1)
return -1;
return -EINVAL;
if (part > le32_to_cpu(gpt_head->num_partition_entries) ||
!is_pte_valid(&gpt_pte[part - 1])) {
debug("%s: *** ERROR: Invalid partition number %d ***\n",
__func__, part);
log_debug("*** ERROR: Invalid partition number %d ***\n", part);
free(gpt_pte);
return -1;
return -EPERM;
}
/* The 'lbaint_t' casting may limit the maximum disk size to 2 TB */
@ -300,8 +299,8 @@ int part_get_info_efi(struct blk_desc *dev_desc, int part,
info->type_guid, UUID_STR_FORMAT_GUID);
#endif
debug("%s: start 0x" LBAF ", size 0x" LBAF ", name %s\n", __func__,
info->start, info->size, info->name);
log_debug("start 0x" LBAF ", size 0x" LBAF ", name %s\n", info->start,
info->size, info->name);
/* Remember to free pte */
free(gpt_pte);

2
doc/develop/driver-model/livetree.rst
View File

@ -255,7 +255,7 @@ So long as OF_LIVE is disabled, it is possible to do fixups using the ofnode
interface. The OF_LIVE support required addition of the flattening step at the
end.
See dm_test_ofnode_root() for some examples. The ofnode_path_root() function
See dm_test_ofnode_root() for some examples. The oftree_from_fdt() function
causes a flat device tree to be 'registered' such that it can be used by the
ofnode interface.

3
doc/develop/vbe.rst
View File

@ -19,8 +19,9 @@ listing methods and getting the status for a method.
For a detailed overview of VBE, see vbe-intro_. A fuller description of
bootflows is at vbe-bootflows_ and the firmware-update mechanism is described at
vbe-fwupdate_.
vbe-fwupdate_. VBE OS requests are described at vbe-osrequests_.
.. _vbe-intro: https://docs.google.com/document/d/e/2PACX-1vQjXLPWMIyVktaTMf8edHZYDrEvMYD_iNzIj1FgPmKF37fpglAC47Tt5cvPBC5fvTdoK-GA5Zv1wifo/pub
.. _vbe-bootflows: https://docs.google.com/document/d/e/2PACX-1vR0OzhuyRJQ8kdeOibS3xB1rVFy3J4M_QKTM5-3vPIBNcdvR0W8EXu9ymG-yWfqthzWoM4JUNhqwydN/pub
.. _vbe-fwupdate: https://docs.google.com/document/d/e/2PACX-1vTnlIL17vVbl6TVoTHWYMED0bme7oHHNk-g5VGxblbPiKIdGDALE1HKId8Go5f0g1eziLsv4h9bocbk/pub
.. _vbe-osrequests: https://docs.google.com/document/d/e/2PACX-1vTHhxX7WSZe68i9rAkW-DHdx6koU-jxYHhamLhZn9GQ9QT2_epSBosMV1_r7yPHOXZccx71rF_t0PXL/pub

1
doc/usage/cmd/fdt.rst
View File

@ -60,6 +60,7 @@ The second word shows the size of the FDT. Now set the working FDT to that
address and expand it to 0xf000 in size::
=> fdt addr 10000 f000
Working FDT set to 10000
=> md 10000 4
00010000: edfe0dd0 00f00000 78000000 7c270000 ...........x..'|

16
drivers/block/blk-uclass.c
View File

@ -593,11 +593,9 @@ int blk_find_next(enum blk_flag_t flags, struct udevice **devp)
int blk_first_device_err(enum blk_flag_t flags, struct udevice **devp)
{
int ret;
for (ret = uclass_first_device_err(UCLASS_BLK, devp);
!ret;
ret = uclass_next_device_err(devp)) {
for (uclass_first_device(UCLASS_BLK, devp);
*devp;
uclass_next_device(devp)) {
if (!blk_flags_check(*devp, flags))
return 0;
}
@ -607,11 +605,9 @@ int blk_first_device_err(enum blk_flag_t flags, struct udevice **devp)
int blk_next_device_err(enum blk_flag_t flags, struct udevice **devp)
{
int ret;
for (ret = uclass_next_device_err(devp);
!ret;
ret = uclass_next_device_err(devp)) {
for (uclass_next_device(devp);
*devp;
uclass_next_device(devp)) {
if (!blk_flags_check(*devp, flags))
return 0;
}

23
drivers/core/regmap.c
View File

@ -4,6 +4,8 @@
* Written by Simon Glass <sjg@chromium.org>
*/
#define LOG_CATEGORY LOGC_DM
#include <common.h>
#include <dm.h>
#include <errno.h>
@ -36,6 +38,22 @@ struct regmap_field {
DECLARE_GLOBAL_DATA_PTR;
/**
* do_range_check() - Control whether range checks are done
*
* Returns: true to do range checks, false to skip
*
* This is used to reduce code size on SPL where range checks are known not to
* be needed
*
* Add this to the top of the file to enable them: #define LOG_DEBUG
*/
static inline bool do_range_check(void)
{
return _LOG_DEBUG || !IS_ENABLED(CONFIG_SPL);
}
/**
* regmap_alloc() - Allocate a regmap with a given number of ranges.
*
@ -391,7 +409,7 @@ int regmap_raw_read_range(struct regmap *map, uint range_num, uint offset,
struct regmap_range *range;
void *ptr;
if (range_num >= map->range_count) {
if (do_range_check() && range_num >= map->range_count) {
debug("%s: range index %d larger than range count\n",
__func__, range_num);
return -ERANGE;
@ -399,7 +417,8 @@ int regmap_raw_read_range(struct regmap *map, uint range_num, uint offset,
range = &map->ranges[range_num];
offset <<= map->reg_offset_shift;
if (offset + val_len > range->size || offset + val_len < offset) {
if (do_range_check() &&
(offset + val_len > range->size || offset + val_len < offset)) {
debug("%s: offset/size combination invalid\n", __func__);
return -ERANGE;
}

40
drivers/core/uclass.c
View File

@ -586,19 +586,6 @@ int uclass_first_device(enum uclass_id id, struct udevice **devp)
return uclass_get_device_tail(dev, ret, devp);
}
int uclass_first_device_err(enum uclass_id id, struct udevice **devp)
{
int ret;
ret = uclass_first_device(id, devp);
if (ret)
return ret;
else if (!*devp)
return -ENODEV;
return 0;
}
int uclass_next_device(struct udevice **devp)
{
struct udevice *dev = *devp;
@ -611,11 +598,24 @@ int uclass_next_device(struct udevice **devp)
return uclass_get_device_tail(dev, ret, devp);
}
int uclass_first_device_err(enum uclass_id id, struct udevice **devp)
{
int ret;
ret = uclass_first_device_check(id, devp);
if (ret)
return ret;
else if (!*devp)
return -ENODEV;
return 0;
}
int uclass_next_device_err(struct udevice **devp)
{
int ret;
ret = uclass_next_device(devp);
ret = uclass_next_device_check(devp);
if (ret)
return ret;
else if (!*devp)
@ -799,20 +799,18 @@ int uclass_pre_remove_device(struct udevice *dev)
int uclass_probe_all(enum uclass_id id)
{
struct udevice *dev;
int ret;
int ret, err;
ret = uclass_first_device(id, &dev);
if (ret || !dev)
return ret;
err = uclass_first_device_check(id, &dev);
/* Scanning uclass to probe all devices */
while (dev) {
ret = uclass_next_device(&dev);
ret = uclass_next_device_check(&dev);
if (ret)
return ret;
err = ret;
}
return 0;
return err;
}
int uclass_id_count(enum uclass_id id)

20
drivers/cpu/cpu-uclass.c
View File

@ -20,25 +20,13 @@ DECLARE_GLOBAL_DATA_PTR;
int cpu_probe_all(void)
{
struct udevice *cpu;
int ret;
int ret = uclass_probe_all(UCLASS_CPU);
ret = uclass_first_device(UCLASS_CPU, &cpu);
if (ret) {
debug("%s: No CPU found (err = %d)\n", __func__, ret);
return ret;
debug("%s: Error while probing CPUs (err = %d %s)\n",
__func__, ret, errno_str(ret));
}
while (cpu) {
ret = uclass_next_device(&cpu);
if (ret) {
debug("%s: Error while probing CPU (err = %d)\n",
__func__, ret);
return ret;
}
}
return 0;
return ret;
}
int cpu_is_current(struct udevice *cpu)

2
drivers/mmc/omap_hsmmc.c
View File

@ -644,7 +644,7 @@ static int omap_hsmmc_execute_tuning(struct udevice *dev, uint opcode)
((mmc->selected_mode == UHS_SDR50) && (val & CAPA2_TSDR50))))
return 0;
ret = uclass_first_device(UCLASS_THERMAL, &thermal_dev);
ret = uclass_first_device_err(UCLASS_THERMAL, &thermal_dev);
if (ret) {
printf("Couldn't get thermal device for tuning\n");
return ret;

4
drivers/pci/pci-uclass.c
View File

@ -1217,7 +1217,7 @@ static int skip_to_next_device(struct udevice *bus, struct udevice **devp)
* Scan through all the PCI controllers. On x86 there will only be one
* but that is not necessarily true on other hardware.
*/
do {
while (bus) {
device_find_first_child(bus, &dev);
if (dev) {
*devp = dev;
@ -1226,7 +1226,7 @@ static int skip_to_next_device(struct udevice *bus, struct udevice **devp)
ret = uclass_next_device(&bus);
if (ret)
return ret;
} while (bus);
}
return 0;
}

2
drivers/serial/serial-uclass.c
View File

@ -143,7 +143,7 @@ static void serial_find_console_or_panic(void)
#else
if (!uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) ||
!uclass_get_device(UCLASS_SERIAL, INDEX, &dev) ||
(!uclass_first_device(UCLASS_SERIAL, &dev) && dev)) {
!uclass_first_device_err(UCLASS_SERIAL, &dev)) {
gd->cur_serial_dev = dev;
return;
}

2
drivers/serial/serial_bcm283x_mu.c
View File

@ -147,7 +147,7 @@ static bool bcm283x_is_serial_muxed(void)
int serial_gpio = 15;
struct udevice *dev;
if (uclass_first_device(UCLASS_PINCTRL, &dev) || !dev)
if (uclass_first_device_err(UCLASS_PINCTRL, &dev))
return false;
if (pinctrl_get_gpio_mux(dev, 0, serial_gpio) != BCM2835_GPIO_ALT5)

2
drivers/serial/serial_bcm283x_pl011.c
View File

@ -24,7 +24,7 @@ static bool bcm283x_is_serial_muxed(void)
int serial_gpio = 15;
struct udevice *dev;
if (uclass_first_device(UCLASS_PINCTRL, &dev) || !dev)
if (uclass_first_device_err(UCLASS_PINCTRL, &dev))
return false;
if (pinctrl_get_gpio_mux(dev, 0, serial_gpio) != BCM2835_GPIO_ALT0)

2
drivers/sysreset/sysreset_ast.c
View File

@ -18,7 +18,7 @@ static int ast_sysreset_request(struct udevice *dev, enum sysreset_t type)
{
struct udevice *wdt;
u32 reset_mode;
int ret = uclass_first_device(UCLASS_WDT, &wdt);
int ret = uclass_first_device_err(UCLASS_WDT, &wdt);
if (ret)
return ret;

11
drivers/usb/gadget/ether.c
View File

@ -2636,18 +2636,17 @@ static const struct eth_ops usb_eth_ops = {
int usb_ether_init(void)
{
struct udevice *dev;
struct udevice *usb_dev;
int ret;
ret = uclass_first_device(UCLASS_USB_GADGET_GENERIC, &usb_dev);
if (!usb_dev || ret) {
uclass_first_device(UCLASS_USB_GADGET_GENERIC, &usb_dev);
if (!usb_dev) {
pr_err("No USB device found\n");
return ret;
return -ENODEV;
}
ret = device_bind_driver(usb_dev, "usb_ether", "usb_ether", &dev);
if (!dev || ret) {
ret = device_bind_driver(usb_dev, "usb_ether", "usb_ether", NULL);
if (ret) {
pr_err("usb - not able to bind usb_ether device\n");
return ret;
}

14
drivers/video/exynos/exynos_fb.c
View File

@ -640,25 +640,17 @@ static int exynos_fb_probe(struct udevice *dev)
#endif
exynos_fimd_lcd_init(dev);
ret = uclass_first_device(UCLASS_PANEL, &panel);
ret = uclass_first_device_err(UCLASS_PANEL, &panel);
if (ret) {
printf("LCD panel failed to probe\n");
printf("%s: LCD panel failed to probe %d\n", __func__, ret);
return ret;
}
if (!panel) {
printf("LCD panel not found\n");
return -ENODEV;
}
ret = uclass_first_device(UCLASS_DISPLAY, &dp);
ret = uclass_first_device_err(UCLASS_DISPLAY, &dp);
if (ret) {
debug("%s: Display device error %d\n", __func__, ret);
return ret;
}
if (!dev) {
debug("%s: Display device missing\n", __func__);
return -ENODEV;
}
ret = display_enable(dp, 18, NULL);
if (ret) {
debug("%s: Display enable error %d\n", __func__, ret);

9
drivers/video/imx/mxc_ipuv3_fb.c
View File

@ -609,12 +609,11 @@ static int ipuv3_video_probe(struct udevice *dev)
return ret;
#if defined(CONFIG_DISPLAY)
ret = uclass_first_device(UCLASS_DISPLAY, &disp_dev);
if (disp_dev) {
ret = uclass_first_device_err(UCLASS_DISPLAY, &disp_dev);
if (!ret)
ret = display_enable(disp_dev, 16, NULL);
if (ret < 0)
return ret;
}
if (ret < 0)
return ret;
#endif
if (CONFIG_IS_ENABLED(PANEL)) {
struct udevice *panel_dev;

2
drivers/video/mali_dp.c
View File

@ -244,7 +244,7 @@ static int malidp_update_timings_from_edid(struct udevice *dev,
struct udevice *disp_dev;
int err;
err = uclass_first_device(UCLASS_DISPLAY, &disp_dev);
err = uclass_first_device_err(UCLASS_DISPLAY, &disp_dev);
if (err)
return err;

2
drivers/video/stm32/stm32_dsi.c
View File

@ -346,7 +346,7 @@ static int stm32_dsi_attach(struct udevice *dev)
struct display_timing timings;
int ret;
ret = uclass_first_device(UCLASS_PANEL, &priv->panel);
ret = uclass_first_device_err(UCLASS_PANEL, &priv->panel);
if (ret) {
dev_err(dev, "panel device error %d\n", ret);
return ret;

4
drivers/video/tegra124/dp.c
View File

@ -1494,8 +1494,8 @@ int tegra_dp_enable(struct udevice *dev, int panel_bpp,
return -ENOLINK;
}
ret = uclass_first_device(UCLASS_VIDEO_BRIDGE, &sor);
if (ret || !sor) {
ret = uclass_first_device_err(UCLASS_VIDEO_BRIDGE, &sor);
if (ret) {
debug("dp: failed to find SOR device: ret=%d\n", ret);
return ret;
}

15
drivers/virtio/virtio-uclass.c
View File

@ -183,21 +183,8 @@ void virtio_driver_features_init(struct virtio_dev_priv *priv,
int virtio_init(void)
{
struct udevice *bus;
int ret;
/* Enumerate all known virtio devices */
ret = uclass_first_device(UCLASS_VIRTIO, &bus);
if (ret)
return ret;
while (bus) {
ret = uclass_next_device(&bus);
if (ret)
break;
}
return ret;
return uclass_probe_all(UCLASS_VIRTIO);
}
static int virtio_uclass_pre_probe(struct udevice *udev)

20
drivers/w1/w1-uclass.c
View File

@ -16,6 +16,7 @@
#include <common.h>
#include <dm.h>
#include <errno.h>
#include <log.h>
#include <w1.h>
#include <w1-eeprom.h>
@ -182,24 +183,25 @@ static int w1_enumerate(struct udevice *bus)
int w1_get_bus(int busnum, struct udevice **busp)
{
int ret, i = 0;
struct udevice *dev;
for (ret = uclass_first_device(UCLASS_W1, &dev);
dev && !ret;
ret = uclass_next_device(&dev), i++) {
for (ret = uclass_first_device_check(UCLASS_W1, &dev);
dev;
ret = uclass_next_device_check(&dev), i++) {
if (i == busnum) {
if (ret) {
debug("Cannot probe w1 bus %d: %d (%s)\n",
busnum, ret, errno_str(ret));
return ret;
}
*busp = dev;
return 0;
}
}
if (!ret) {
debug("Cannot find w1 bus %d\n", busnum);
ret = -ENODEV;
}
debug("Cannot find w1 bus %d\n", busnum);
return ret;
return -ENODEV;
}
u8 w1_get_device_family(struct udevice *dev)

5
drivers/xen/pvblock.c
View File

@ -852,10 +852,7 @@ static int pvblock_probe(struct udevice *udev)
ret = uclass_get(UCLASS_BLK, &uc);
if (ret)
return ret;
uclass_foreach_dev_probe(UCLASS_BLK, udev) {
if (_ret)
return _ret;
};
uclass_foreach_dev_probe(UCLASS_BLK, udev);
return 0;
}

7
fs/btrfs/disk-io.c
View File

@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-2.0+
#include <common.h>
#include <fs_internal.h>
#include <log.h>
#include <uuid.h>
#include <memalign.h>
#include "kernel-shared/btrfs_tree.h"
@ -910,9 +911,9 @@ static int btrfs_scan_fs_devices(struct blk_desc *desc,
if (round_up(BTRFS_SUPER_INFO_SIZE + BTRFS_SUPER_INFO_OFFSET,
desc->blksz) > (part->size << desc->log2blksz)) {
error("superblock end %u is larger than device size " LBAFU,
BTRFS_SUPER_INFO_SIZE + BTRFS_SUPER_INFO_OFFSET,
part->size << desc->log2blksz);
log_debug("superblock end %u is larger than device size " LBAFU,
BTRFS_SUPER_INFO_SIZE + BTRFS_SUPER_INFO_OFFSET,
part->size << desc->log2blksz);
return -EINVAL;
}

2
fs/ext4/ext4_common.c
View File

@ -2415,7 +2415,7 @@ int ext4fs_mount(unsigned part_length)
return 1;
fail:
printf("Failed to mount ext2 filesystem...\n");
log_debug("Failed to mount ext2 filesystem...\n");
fail_noerr:
free(data);
ext4fs_root = NULL;

3
fs/fs_internal.c
View File

@ -29,8 +29,7 @@ int fs_devread(struct blk_desc *blk, struct disk_partition *partition,
/* Check partition boundaries */
if ((sector + ((byte_offset + byte_len - 1) >> log2blksz))
>= partition->size) {
log_err("%s read outside partition " LBAFU "\n", __func__,
sector);
log_debug("read outside partition " LBAFU "\n", sector);
return 0;
}

3
include/dm/ofnode.h
View File

@ -59,6 +59,9 @@ __attribute_const__ int ofnode_to_offset(ofnode node);
/**
* oftree_from_fdt() - Returns an oftree from a flat device tree pointer
*
* If @fdt is not already registered in the list of current device trees, it is
* added to the list.
*
* @fdt: Device tree to use
*
* Returns: reference to the given node

26
include/dm/uclass.h
View File

@ -332,17 +332,6 @@ int uclass_get_device_by_driver(enum uclass_id id, const struct driver *drv,
*/
int uclass_first_device(enum uclass_id id, struct udevice **devp);
/**
* uclass_first_device_err() - Get the first device in a uclass
*
* The device returned is probed if necessary, and ready for use
*
* @id: Uclass ID to look up
* @devp: Returns pointer to the first device in that uclass, or NULL if none
* Return: 0 if found, -ENODEV if not found, other -ve on error
*/
int uclass_first_device_err(enum uclass_id id, struct udevice **devp);
/**
* uclass_next_device() - Get the next device in a uclass
*
@ -358,6 +347,17 @@ int uclass_first_device_err(enum uclass_id id, struct udevice **devp);
*/
int uclass_next_device(struct udevice **devp);
/**
* uclass_first_device_err() - Get the first device in a uclass
*
* The device returned is probed if necessary, and ready for use
*
* @id: Uclass ID to look up
* @devp: Returns pointer to the first device in that uclass, or NULL if none
* Return: 0 if found, -ENODEV if not found, other -ve on error
*/
int uclass_first_device_err(enum uclass_id id, struct udevice **devp);
/**
* uclass_next_device_err() - Get the next device in a uclass
*
@ -491,7 +491,7 @@ int uclass_id_count(enum uclass_id id);
* are no more devices.
*/
#define uclass_foreach_dev_probe(id, dev) \
for (int _ret = uclass_first_device_err(id, &dev); !_ret && dev; \
_ret = uclass_next_device_err(&dev))
for (uclass_first_device(id, &dev); dev; \
uclass_next_device(&dev))
#endif

2
lib/acpi/acpi_table.c
View File

@ -40,7 +40,7 @@ int acpi_create_dmar(struct acpi_dmar *dmar, enum dmar_flags flags)
struct udevice *cpu;
int ret;
ret = uclass_first_device(UCLASS_CPU, &cpu);
ret = uclass_first_device_err(UCLASS_CPU, &cpu);
if (ret)
return log_msg_ret("cpu", ret);
ret = cpu_get_info(cpu, &info);

2
lib/efi_loader/efi_gop.c
View File

@ -482,7 +482,7 @@ efi_status_t efi_gop_register(void)
struct video_priv *priv;
/* We only support a single video output device for now */
if (uclass_first_device(UCLASS_VIDEO, &vdev) || !vdev) {
if (uclass_first_device_err(UCLASS_VIDEO, &vdev)) {
debug("WARNING: No video device\n");
return EFI_SUCCESS;
}

6
net/eth-uclass.c
View File

@ -91,8 +91,10 @@ struct udevice *eth_get_dev(void)
eth_errno = uclass_get_device_by_seq(UCLASS_ETH, 0,
&uc_priv->current);
if (eth_errno)
eth_errno = uclass_first_device(UCLASS_ETH,
&uc_priv->current);
eth_errno = uclass_first_device_err(UCLASS_ETH,
&uc_priv->current);
if (eth_errno)
uc_priv->current = NULL;
}
return uc_priv->current;
}

1
test/boot/Makefile
View File

@ -7,3 +7,4 @@ obj-$(CONFIG_BOOTSTD) += bootdev.o bootstd_common.o bootflow.o bootmeth.o
ifdef CONFIG_OF_LIVE
obj-$(CONFIG_BOOTMETH_VBE_SIMPLE) += vbe_simple.o
endif
obj-$(CONFIG_BOOTMETH_VBE) += vbe_fixup.o

2
test/boot/bootflow.c
View File

@ -329,6 +329,8 @@ static int bootflow_system(struct unit_test_state *uts)
{
struct udevice *dev;
if (!IS_ENABLED(CONFIG_CMD_BOOTEFI_BOOTMGR))
return 0;
ut_assertok(uclass_get_device_by_name(UCLASS_BOOTMETH, "efi_mgr",
&dev));
sandbox_set_fake_efi_mgr_dev(dev, true);

2
test/boot/bootmeth.c
View File

@ -156,7 +156,7 @@ static int bootmeth_state(struct unit_test_state *uts)
struct udevice *dev;
char buf[50];
ut_assertok(uclass_first_device(UCLASS_BOOTMETH, &dev));
ut_assertok(uclass_first_device_err(UCLASS_BOOTMETH, &dev));
ut_assertnonnull(dev);
ut_assertok(bootmeth_get_state_desc(dev, buf, sizeof(buf)));

49
test/boot/bootstd_common.c
View File

@ -9,10 +9,52 @@
#include <common.h>
#include <bootstd.h>
#include <dm.h>
#include <memalign.h>
#include <mmc.h>
#include <linux/log2.h>
#include <test/suites.h>
#include <test/ut.h>
#include <u-boot/crc.h>
#include "bootstd_common.h"
/* tracks whether bootstd_setup_for_tests() has been run yet */
bool vbe_setup_done;
/* set up MMC for VBE tests */
int bootstd_setup_for_tests(void)
{
ALLOC_CACHE_ALIGN_BUFFER(u8, buf, MMC_MAX_BLOCK_LEN);
struct udevice *mmc;
struct blk_desc *desc;
int ret;
if (vbe_setup_done)
return 0;
/* Set up the version string */
ret = uclass_get_device(UCLASS_MMC, 1, &mmc);
if (ret)
return log_msg_ret("mmc", -EIO);
desc = blk_get_by_device(mmc);
memset(buf, '\0', MMC_MAX_BLOCK_LEN);
strcpy(buf, TEST_VERSION);
if (blk_dwrite(desc, VERSION_START_BLK, 1, buf) != 1)
return log_msg_ret("wr1", -EIO);
/* Set up the nvdata */
memset(buf, '\0', MMC_MAX_BLOCK_LEN);
buf[1] = ilog2(0x40) << 4 | 1;
*(u32 *)(buf + 4) = TEST_VERNUM;
buf[0] = crc8(0, buf + 1, 0x3f);
if (blk_dwrite(desc, NVDATA_START_BLK, 1, buf) != 1)
return log_msg_ret("wr2", -EIO);
vbe_setup_done = true;
return 0;
}
int bootstd_test_drop_bootdev_order(struct unit_test_state *uts)
{
struct bootstd_priv *priv;
@ -29,6 +71,13 @@ int do_ut_bootstd(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct unit_test *tests = UNIT_TEST_SUITE_START(bootstd_test);
const int n_ents = UNIT_TEST_SUITE_COUNT(bootstd_test);
int ret;
ret = bootstd_setup_for_tests();
if (ret) {
printf("Failed to set up for bootstd tests (err=%d)\n", ret);
return CMD_RET_FAILURE;
}
return cmd_ut_category("bootstd", "bootstd_test_",
tests, n_ents, argc, argv);

16
test/boot/bootstd_common.h
View File

@ -9,10 +9,17 @@
#ifndef __bootstd_common_h
#define __bootstd_common_h
#include <version_string.h>
/* Declare a new bootdev test */
#define BOOTSTD_TEST(_name, _flags) \
UNIT_TEST(_name, _flags, bootstd_test)
#define NVDATA_START_BLK ((0x400 + 0x400) / MMC_MAX_BLOCK_LEN)
#define VERSION_START_BLK ((0x400 + 0x800) / MMC_MAX_BLOCK_LEN)
#define TEST_VERSION "U-Boot v2022.04-local2"
#define TEST_VERNUM 0x00010002
struct unit_test_state;
/**
@ -24,4 +31,13 @@ struct unit_test_state;
*/
int bootstd_test_drop_bootdev_order(struct unit_test_state *uts);
/**
* bootstd_setup_for_tests() - Set up MMC data for VBE tests
*
* Some data is needed for VBE tests to work. This function sets that up.
*
* @return 0 if OK, -ve on error
*/
int bootstd_setup_for_tests(void);
#endif

59
test/boot/vbe_fixup.c Normal file
View File

@ -0,0 +1,59 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Test for VBE device tree fix-ups
*
* Copyright 2022 Google LLC
* Written by Simon Glass <sjg@chromium.org>
*/
#include <common.h>
#include <dm/ofnode.h>
#include <linux/libfdt.h>
#include <test/test.h>
#include <test/ut.h>
#include "bootstd_common.h"
/* Basic test of reading nvdata and updating a fwupd node in the device tree */
static int vbe_test_fixup(struct unit_test_state *uts)
{
ofnode chosen, node;
const char *data;
oftree tree;
int size;
/*
* This test works when called from test_vbe.py and it must use the
* flat tree, since device tree fix-ups do not yet support live tree.
*/
if (!working_fdt)
return 0;
tree = oftree_from_fdt(working_fdt);
ut_assert(oftree_valid(tree));
chosen = oftree_path(tree, "/chosen");
ut_assert(ofnode_valid(chosen));
/* check the things set up for the FIT in test_vbe.py */
node = ofnode_find_subnode(chosen, "random");
/* ignore if this test is run on its own */
if (!ofnode_valid(node))
return 0;
data = ofnode_read_prop(node, "data", &size);
ut_asserteq(0x40, size);
node = ofnode_find_subnode(chosen, "aslr2");
ut_assert(ofnode_valid(node));
data = ofnode_read_prop(node, "data", &size);
ut_asserteq(4, size);
node = ofnode_find_subnode(chosen, "efi-runtime");
ut_assert(ofnode_valid(node));
data = ofnode_read_prop(node, "data", &size);
ut_asserteq(4, size);
return 0;
}
BOOTSTD_TEST(vbe_test_fixup,
UT_TESTF_DM | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);

34
test/boot/vbe_simple.c
View File

@ -10,54 +10,27 @@
#include <bootmeth.h>
#include <dm.h>
#include <image.h>
#include <memalign.h>
#include <mmc.h>
#include <of_live.h>
#include <vbe.h>
#include <version_string.h>
#include <linux/log2.h>
#include <test/suites.h>
#include <test/ut.h>
#include <u-boot/crc.h>
#include "bootstd_common.h"
#define NVDATA_START_BLK ((0x400 + 0x400) / MMC_MAX_BLOCK_LEN)
#define VERSION_START_BLK ((0x400 + 0x800) / MMC_MAX_BLOCK_LEN)
#define TEST_VERSION "U-Boot v2022.04-local2"
#define TEST_VERNUM 0x00010002
/* Basic test of reading nvdata and updating a fwupd node in the device tree */
static int vbe_simple_test_base(struct unit_test_state *uts)
{
ALLOC_CACHE_ALIGN_BUFFER(u8, buf, MMC_MAX_BLOCK_LEN);
const char *version, *bl_version;
struct event_ft_fixup fixup;
struct udevice *dev, *mmc;
struct udevice *dev;
struct device_node *np;
struct blk_desc *desc;
char fdt_buf[0x400];
char info[100];
int node_ofs;
ofnode node;
u32 vernum;
/* Set up the version string */
ut_assertok(uclass_get_device(UCLASS_MMC, 1, &mmc));
desc = blk_get_by_device(mmc);
ut_assertnonnull(desc);
memset(buf, '\0', MMC_MAX_BLOCK_LEN);
strcpy(buf, TEST_VERSION);
if (blk_dwrite(desc, VERSION_START_BLK, 1, buf) != 1)
return log_msg_ret("write", -EIO);
/* Set up the nvdata */
memset(buf, '\0', MMC_MAX_BLOCK_LEN);
buf[1] = ilog2(0x40) << 4 | 1;
*(u32 *)(buf + 4) = TEST_VERNUM;
buf[0] = crc8(0, buf + 1, 0x3f);
if (blk_dwrite(desc, NVDATA_START_BLK, 1, buf) != 1)
return log_msg_ret("write", -EIO);
/* Set up the VBE info */
ut_assertok(bootstd_setup_for_tests());
/* Read the version back */
ut_assertok(vbe_find_by_any("firmware0", &dev));
@ -90,6 +63,7 @@ static int vbe_simple_test_base(struct unit_test_state *uts)
*
* Two fix this we need image_setup_libfdt() is updated to use ofnode
*/
fixup.images = NULL;
ut_assertok(event_notify(EVT_FT_FIXUP, &fixup, sizeof(fixup)));
node = oftree_path(fixup.tree, "/chosen/fwupd/firmware0");

11
test/cmd/fdt.c
View File

@ -55,6 +55,7 @@ static int fdt_test_addr(struct unit_test_state *uts)
/* The working fdt is not set, so this should fail */
set_working_fdt_addr(0);
ut_assert_nextline("Working FDT set to 0");
ut_asserteq(CMD_RET_FAILURE, run_command("fdt addr", 0));
ut_assert_nextline("libfdt fdt_check_header(): FDT_ERR_BADMAGIC");
ut_assertok(ut_check_console_end(uts));
@ -63,18 +64,22 @@ static int fdt_test_addr(struct unit_test_state *uts)
ut_assertok(make_test_fdt(uts, fdt, sizeof(fdt)));
addr = map_to_sysmem(fdt);
set_working_fdt_addr(addr);
ut_assert_nextline("Working FDT set to %lx", addr);
ut_assertok(run_command("fdt addr", 0));
ut_assert_nextline("Working fdt: %08lx", (ulong)map_to_sysmem(fdt));
ut_assertok(ut_check_console_end(uts));
/* Set the working FDT */
set_working_fdt_addr(0);
ut_assert_nextline("Working FDT set to 0");
ut_assertok(run_commandf("fdt addr %08x", addr));
ut_assert_nextline("Working FDT set to %lx", addr);
ut_asserteq(addr, map_to_sysmem(working_fdt));
ut_assertok(ut_check_console_end(uts));
set_working_fdt_addr(0);
ut_assert_nextline("Working FDT set to 0");
/* Set the working FDT */
/* Set the control FDT */
fdt_blob = gd->fdt_blob;
gd->fdt_blob = NULL;
ret = run_commandf("fdt addr -c %08x", addr);
@ -93,6 +98,7 @@ static int fdt_test_addr(struct unit_test_state *uts)
/* Test detecting an invalid FDT */
fdt[0] = 123;
set_working_fdt_addr(addr);
ut_assert_nextline("Working FDT set to %lx", addr);
ut_asserteq(1, run_commandf("fdt addr"));
ut_assert_nextline("libfdt fdt_check_header(): FDT_ERR_BADMAGIC");
ut_assertok(ut_check_console_end(uts));
@ -115,16 +121,19 @@ static int fdt_test_resize(struct unit_test_state *uts)
/* Test setting and resizing the working FDT to a larger size */
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("fdt addr %08x %x", addr, newsize));
ut_assert_nextline("Working FDT set to %lx", addr);
ut_assertok(ut_check_console_end(uts));
/* Try shrinking it */
ut_assertok(run_commandf("fdt addr %08x %x", addr, sizeof(fdt) / 4));
ut_assert_nextline("Working FDT set to %lx", addr);
ut_assert_nextline("New length %d < existing length %d, ignoring",
(int)sizeof(fdt) / 4, newsize);
ut_assertok(ut_check_console_end(uts));
/* ...quietly */
ut_assertok(run_commandf("fdt addr -q %08x %x", addr, sizeof(fdt) / 4));
ut_assert_nextline("Working FDT set to %lx", addr);
ut_assertok(ut_check_console_end(uts));
/* We cannot easily provoke errors in fdt_open_into(), so ignore that */

14
test/dm/acpi.c
View File

@ -169,28 +169,28 @@ static int dm_test_acpi_get_name(struct unit_test_state *uts)
ut_asserteq_str("GHIJ", name);
/* Test getting the name from acpi_device_get_name() */
ut_assertok(uclass_first_device(UCLASS_I2C, &i2c));
ut_assertok(uclass_first_device_err(UCLASS_I2C, &i2c));
ut_assertok(acpi_get_name(i2c, name));
ut_asserteq_str("I2C0", name);
ut_assertok(uclass_first_device(UCLASS_SPI, &spi));
ut_assertok(uclass_first_device_err(UCLASS_SPI, &spi));
ut_assertok(acpi_get_name(spi, name));
ut_asserteq_str("SPI0", name);
/* ACPI doesn't know about the timer */
ut_assertok(uclass_first_device(UCLASS_TIMER, &timer));
ut_assertok(uclass_first_device_err(UCLASS_TIMER, &timer));
ut_asserteq(-ENOENT, acpi_get_name(timer, name));
/* May as well test the rest of the cases */
ut_assertok(uclass_first_device(UCLASS_SOUND, &sound));
ut_assertok(uclass_first_device_err(UCLASS_SOUND, &sound));
ut_assertok(acpi_get_name(sound, name));
ut_asserteq_str("HDAS", name);
ut_assertok(uclass_first_device(UCLASS_PCI, &pci));
ut_assertok(uclass_first_device_err(UCLASS_PCI, &pci));
ut_assertok(acpi_get_name(pci, name));
ut_asserteq_str("PCI0", name);
ut_assertok(uclass_first_device(UCLASS_ROOT, &root));
ut_assertok(uclass_first_device_err(UCLASS_ROOT, &root));
ut_assertok(acpi_get_name(root, name));
ut_asserteq_str("\\_SB", name);
@ -219,7 +219,7 @@ static int dm_test_acpi_create_dmar(struct unit_test_state *uts)
struct acpi_dmar dmar;
struct udevice *cpu;
ut_assertok(uclass_first_device(UCLASS_CPU, &cpu));
ut_assertok(uclass_first_device_err(UCLASS_CPU, &cpu));
ut_assertnonnull(cpu);
ut_assertok(acpi_create_dmar(&dmar, DMAR_INTR_REMAP));
ut_asserteq(DMAR_INTR_REMAP, dmar.flags);

17
test/dm/core.c
View File

@ -512,23 +512,15 @@ static int dm_test_leak(struct unit_test_state *uts)
int i;
for (i = 0; i < 2; i++) {
struct udevice *dev;
int ret;
int id;
dm_leak_check_start(uts);
ut_assertok(dm_scan_plat(false));
ut_assertok(dm_scan_fdt(false));
/* Scanning the uclass is enough to probe all the devices */
for (id = UCLASS_ROOT; id < UCLASS_COUNT; id++) {
for (ret = uclass_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_next_device(&dev))
;
ut_assertok(ret);
}
ret = uclass_probe_all(UCLASS_TEST);
ut_assertok(ret);
ut_assertok(dm_leak_check_end(uts));
}
@ -653,10 +645,7 @@ static int dm_test_children(struct unit_test_state *uts)
ut_asserteq(2 + NODE_COUNT, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
/* Probe everything */
for (ret = uclass_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_next_device(&dev))
;
ret = uclass_probe_all(UCLASS_TEST);
ut_assertok(ret);
ut_asserteq(total, dm_testdrv_op_count[DM_TEST_OP_PROBE]);

4
test/dm/devres.c
View File

@ -165,8 +165,8 @@ static int dm_test_devres_phase(struct unit_test_state *uts)
ut_asserteq(TEST_DEVRES_SIZE + TEST_DEVRES_SIZE3, stats.total_size);
/* Probing the device should add one allocation */
ut_assertok(uclass_first_device(UCLASS_TEST_DEVRES, &dev));
ut_assert(dev != NULL);
ut_assertok(uclass_first_device_err(UCLASS_TEST_DEVRES, &dev));
ut_assertnonnull(dev);
devres_get_stats(dev, &stats);
ut_asserteq(3, stats.allocs);
ut_asserteq(TEST_DEVRES_SIZE + TEST_DEVRES_SIZE2 + TEST_DEVRES_SIZE3,

8
test/dm/i2c.c
View File

@ -124,7 +124,7 @@ static int dm_test_i2c_bytewise(struct unit_test_state *uts)
ut_asserteq_mem(buf, "\0\0\0\0\0", sizeof(buf));
/* Tell the EEPROM to only read/write one register at a time */
ut_assertok(uclass_first_device(UCLASS_I2C_EMUL, &eeprom));
ut_assertok(uclass_first_device_err(UCLASS_I2C_EMUL, &eeprom));
ut_assertnonnull(eeprom);
sandbox_i2c_eeprom_set_test_mode(eeprom, SIE_TEST_MODE_SINGLE_BYTE);
@ -177,7 +177,7 @@ static int dm_test_i2c_offset(struct unit_test_state *uts)
/* Do a transfer so we can find the emulator */
ut_assertok(dm_i2c_read(dev, 0, buf, 5));
ut_assertok(uclass_first_device(UCLASS_I2C_EMUL, &eeprom));
ut_assertok(uclass_first_device_err(UCLASS_I2C_EMUL, &eeprom));
/* Offset length 0 */
sandbox_i2c_eeprom_set_offset_len(eeprom, 0);
@ -250,7 +250,7 @@ static int dm_test_i2c_addr_offset(struct unit_test_state *uts)
/* Do a transfer so we can find the emulator */
ut_assertok(dm_i2c_read(dev, 0, buf, 5));
ut_assertok(uclass_first_device(UCLASS_I2C_EMUL, &eeprom));
ut_assertok(uclass_first_device_err(UCLASS_I2C_EMUL, &eeprom));
/* Offset length 0 */
sandbox_i2c_eeprom_set_offset_len(eeprom, 0);
@ -315,7 +315,7 @@ static int dm_test_i2c_reg_clrset(struct unit_test_state *uts)
/* Do a transfer so we can find the emulator */
ut_assertok(dm_i2c_read(dev, 0, buf, 5));
ut_assertok(uclass_first_device(UCLASS_I2C_EMUL, &eeprom));
ut_assertok(uclass_first_device_err(UCLASS_I2C_EMUL, &eeprom));
/* Dummy data for the test */
ut_assertok(dm_i2c_write(dev, 0, "\xff\x00\xff\x00\x10", 5));

19
test/dm/test-fdt.c
View File

@ -392,10 +392,10 @@ DM_TEST(dm_test_fdt_offset,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
/**
* Test various error conditions with uclass_first_device() and
* uclass_next_device()
* Test various error conditions with uclass_first_device(),
* uclass_next_device(), and uclass_probe_all()
*/
static int dm_test_first_next_device(struct unit_test_state *uts)
static int dm_test_first_next_device_probeall(struct unit_test_state *uts)
{
struct dm_testprobe_pdata *pdata;
struct udevice *dev, *parent = NULL;
@ -428,9 +428,20 @@ static int dm_test_first_next_device(struct unit_test_state *uts)
device_remove(parent, DM_REMOVE_NORMAL);
ut_asserteq(-ENOENT, uclass_first_device(UCLASS_TEST_PROBE, &dev));
/* Now that broken devices are set up test probe_all */
device_remove(parent, DM_REMOVE_NORMAL);
/* There are broken devices so an error should be returned */
ut_assert(uclass_probe_all(UCLASS_TEST_PROBE) < 0);
/* but non-error device should be probed nonetheless */
ut_assertok(uclass_get_device(UCLASS_TEST_PROBE, 2, &dev));
ut_assert(dev_get_flags(dev) & DM_FLAG_ACTIVATED);
ut_assertok(uclass_get_device(UCLASS_TEST_PROBE, 3, &dev));
ut_assert(dev_get_flags(dev) & DM_FLAG_ACTIVATED);
return 0;
}
DM_TEST(dm_test_first_next_device, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_first_next_device_probeall,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
/* Test iteration through devices in a uclass */
static int dm_test_uclass_foreach(struct unit_test_state *uts)

8
test/dm/virtio_device.c
View File

@ -22,7 +22,7 @@ static int dm_test_virtio_base(struct unit_test_state *uts)
u8 status;
/* check probe success */
ut_assertok(uclass_first_device(UCLASS_VIRTIO, &bus));
ut_assertok(uclass_first_device_err(UCLASS_VIRTIO, &bus));
ut_assertnonnull(bus);
/* check the child virtio-rng device is bound */
@ -60,7 +60,7 @@ static int dm_test_virtio_all_ops(struct unit_test_state *uts)
struct virtqueue *vqs[2];
/* check probe success */
ut_assertok(uclass_first_device(UCLASS_VIRTIO, &bus));
ut_assertok(uclass_first_device_err(UCLASS_VIRTIO, &bus));
ut_assertnonnull(bus);
/* check the child virtio-rng device is bound */
@ -102,7 +102,7 @@ static int dm_test_virtio_remove(struct unit_test_state *uts)
struct udevice *bus, *dev;
/* check probe success */
ut_assertok(uclass_first_device(UCLASS_VIRTIO, &bus));
ut_assertok(uclass_first_device_err(UCLASS_VIRTIO, &bus));
ut_assertnonnull(bus);
/* check the child virtio-rng device is bound */
@ -134,7 +134,7 @@ static int dm_test_virtio_ring(struct unit_test_state *uts)
u8 buffer[2][32];
/* check probe success */
ut_assertok(uclass_first_device(UCLASS_VIRTIO, &bus));
ut_assertok(uclass_first_device_err(UCLASS_VIRTIO, &bus));
ut_assertnonnull(bus);
/* check the child virtio-blk device is bound */

2
test/dm/virtio_rng.c
View File

@ -28,7 +28,7 @@ static int dm_test_virtio_rng_check_len(struct unit_test_state *uts)
u8 buffer[16];
/* check probe success */
ut_assertok(uclass_first_device(UCLASS_VIRTIO, &bus));
ut_assertok(uclass_first_device_err(UCLASS_VIRTIO, &bus));
ut_assertnonnull(bus);
/* check the child virtio-rng device is bound */

2
test/fuzz/cmd_fuzz.c
View File

@ -29,7 +29,7 @@ static struct udevice *find_fuzzing_engine(void)
{
struct udevice *dev;
if (uclass_first_device(UCLASS_FUZZING_ENGINE, &dev))
if (uclass_first_device_err(UCLASS_FUZZING_ENGINE, &dev))
return NULL;
return dev;

2
test/fuzz/virtio.c
View File

@ -30,7 +30,7 @@ static int fuzz_vring(const uint8_t *data, size_t size)
return 0;
/* check probe success */
if (uclass_first_device(UCLASS_VIRTIO, &bus) || !bus)
if (uclass_first_device_err(UCLASS_VIRTIO, &bus))
panic("Could not find virtio bus\n");
/* check the child virtio-rng device is bound */

93
test/py/tests/fit_util.py Normal file
View File

@ -0,0 +1,93 @@
# SPDX-License-Identifier: GPL-2.0+
# Copyright 2022 Google LLC
"""Common utility functions for FIT tests"""
import os
import u_boot_utils as util
def make_fname(cons, basename):
"""Make a temporary filename
Args:
cons (ConsoleBase): u_boot_console to use
basename (str): Base name of file to create (within temporary directory)
Return:
Temporary filename
"""
return os.path.join(cons.config.build_dir, basename)
def make_its(cons, base_its, params, basename='test.its'):
"""Make a sample .its file with parameters embedded
Args:
cons (ConsoleBase): u_boot_console to use
base_its (str): Template text for the .its file, typically containing
%() references
params (dict of str): Parameters to embed in the %() strings
basename (str): base name to write to (will be placed in the temp dir)
Returns:
str: Filename of .its file created
"""
its = make_fname(cons, basename)
with open(its, 'w', encoding='utf-8') as outf:
print(base_its % params, file=outf)
return its
def make_fit(cons, mkimage, base_its, params, basename='test.fit', base_fdt=None):
"""Make a sample .fit file ready for loading
This creates a .its script with the selected parameters and uses mkimage to
turn this into a .fit image.
Args:
cons (ConsoleBase): u_boot_console to use
mkimage (str): Filename of 'mkimage' utility
base_its (str): Template text for the .its file, typically containing
%() references
params (dict of str): Parameters to embed in the %() strings
basename (str): base name to write to (will be placed in the temp dir)
Return:
Filename of .fit file created
"""
fit = make_fname(cons, basename)
its = make_its(cons, base_its, params)
util.run_and_log(cons, [mkimage, '-f', its, fit])
if base_fdt:
with open(make_fname(cons, 'u-boot.dts'), 'w') as fd:
fd.write(base_fdt)
return fit
def make_kernel(cons, basename, text):
"""Make a sample kernel with test data
Args:
cons (ConsoleBase): u_boot_console to use
basename (str): base name to write to (will be placed in the temp dir)
text (str): Contents of the kernel file (will be repeated 100 times)
Returns:
str: Full path and filename of the kernel it created
"""
fname = make_fname(cons, basename)
data = ''
for i in range(100):
data += f'this {text} {i} is unlikely to boot\n'
with open(fname, 'w', encoding='utf-8') as outf:
print(data, file=outf)
return fname
def make_dtb(cons, base_fdt, basename):
"""Make a sample .dts file and compile it to a .dtb
Returns:
cons (ConsoleBase): u_boot_console to use
Filename of .dtb file created
"""
src = make_fname(cons, f'{basename}.dts')
dtb = make_fname(cons, f'{basename}.dtb')
with open(src, 'w', encoding='utf-8') as outf:
outf.write(base_fdt)
util.run_and_log(cons, ['dtc', src, '-O', 'dtb', '-o', dtb])
return dtb

1
test/py/tests/test_event_dump.py
View File

@ -16,6 +16,7 @@ def test_event_dump(u_boot_console):
out = util.run_and_log(cons, ['scripts/event_dump.py', sandbox])
expect = '''.*Event type Id Source location
-------------------- ------------------------------ ------------------------------
EVT_FT_FIXUP bootmeth_vbe_ft_fixup .*boot/vbe_fixup.c:.*
EVT_FT_FIXUP bootmeth_vbe_simple_ft_fixup .*boot/vbe_simple.c:.*
EVT_MISC_INIT_F sandbox_misc_init_f .*arch/sandbox/cpu/start.c:'''
assert re.match(expect, out, re.MULTILINE) is not None

79
test/py/tests/test_fit.py
View File

@ -7,6 +7,7 @@ import os
import pytest
import struct
import u_boot_utils as util
import fit_util
# Define a base ITS which we can adjust using % and a dictionary
base_its = '''
@ -126,7 +127,6 @@ def test_fit(u_boot_console):
Return:
Temporary filename
"""
return os.path.join(cons.config.build_dir, leaf)
def filesize(fname):
@ -150,67 +150,6 @@ def test_fit(u_boot_console):
with open(fname, 'rb') as fd:
return fd.read()
def make_dtb():
"""Make a sample .dts file and compile it to a .dtb
Returns:
Filename of .dtb file created
"""
src = make_fname('u-boot.dts')
dtb = make_fname('u-boot.dtb')
with open(src, 'w') as fd:
fd.write(base_fdt)
util.run_and_log(cons, ['dtc', src, '-O', 'dtb', '-o', dtb])
return dtb
def make_its(params):
"""Make a sample .its file with parameters embedded
Args:
params: Dictionary containing parameters to embed in the %() strings
Returns:
Filename of .its file created
"""
its = make_fname('test.its')
with open(its, 'w') as fd:
print(base_its % params, file=fd)
return its
def make_fit(mkimage, params):
"""Make a sample .fit file ready for loading
This creates a .its script with the selected parameters and uses mkimage to
turn this into a .fit image.
Args:
mkimage: Filename of 'mkimage' utility
params: Dictionary containing parameters to embed in the %() strings
Return:
Filename of .fit file created
"""
fit = make_fname('test.fit')
its = make_its(params)
util.run_and_log(cons, [mkimage, '-f', its, fit])
with open(make_fname('u-boot.dts'), 'w') as fd:
fd.write(base_fdt)
return fit
def make_kernel(filename, text):
"""Make a sample kernel with test data
Args:
filename: the name of the file you want to create
Returns:
Full path and filename of the kernel it created
"""
fname = make_fname(filename)
data = ''
for i in range(100):
data += 'this %s %d is unlikely to boot\n' % (text, i)
with open(fname, 'w') as fd:
print(data, file=fd)
return fname
def make_ramdisk(filename, text):
"""Make a sample ramdisk with test data
@ -321,10 +260,10 @@ def test_fit(u_boot_console):
- run code coverage to make sure we are testing all the code
"""
# Set up invariant files
control_dtb = make_dtb()
kernel = make_kernel('test-kernel.bin', 'kernel')
control_dtb = fit_util.make_dtb(cons, base_fdt, 'u-boot')
kernel = fit_util.make_kernel(cons, 'test-kernel.bin', 'kernel')
ramdisk = make_ramdisk('test-ramdisk.bin', 'ramdisk')
loadables1 = make_kernel('test-loadables1.bin', 'lenrek')
loadables1 = fit_util.make_kernel(cons, 'test-loadables1.bin', 'lenrek')
loadables2 = make_ramdisk('test-loadables2.bin', 'ksidmar')
kernel_out = make_fname('kernel-out.bin')
fdt = make_fname('u-boot.dtb')
@ -372,7 +311,7 @@ def test_fit(u_boot_console):
}
# Make a basic FIT and a script to load it
fit = make_fit(mkimage, params)
fit = fit_util.make_fit(cons, mkimage, base_its, params)
params['fit'] = fit
cmd = base_script % params
@ -403,7 +342,7 @@ def test_fit(u_boot_console):
# Now a kernel and an FDT
with cons.log.section('Kernel + FDT load'):
params['fdt_load'] = 'load = <%#x>;' % params['fdt_addr']
fit = make_fit(mkimage, params)
fit = fit_util.make_fit(cons, mkimage, base_its, params)
cons.restart_uboot()
output = cons.run_command_list(cmd.splitlines())
check_equal(kernel, kernel_out, 'Kernel not loaded')
@ -415,7 +354,7 @@ def test_fit(u_boot_console):
with cons.log.section('Kernel + FDT + Ramdisk load'):
params['ramdisk_config'] = 'ramdisk = "ramdisk-1";'
params['ramdisk_load'] = 'load = <%#x>;' % params['ramdisk_addr']
fit = make_fit(mkimage, params)
fit = fit_util.make_fit(cons, mkimage, base_its, params)
cons.restart_uboot()
output = cons.run_command_list(cmd.splitlines())
check_equal(ramdisk, ramdisk_out, 'Ramdisk not loaded')
@ -427,7 +366,7 @@ def test_fit(u_boot_console):
params['loadables1_addr'])
params['loadables2_load'] = ('load = <%#x>;' %
params['loadables2_addr'])
fit = make_fit(mkimage, params)
fit = fit_util.make_fit(cons, mkimage, base_its, params)
cons.restart_uboot()
output = cons.run_command_list(cmd.splitlines())
check_equal(loadables1, loadables1_out,
@ -441,7 +380,7 @@ def test_fit(u_boot_console):
params['kernel'] = make_compressed(kernel)
params['fdt'] = make_compressed(fdt)
params['ramdisk'] = make_compressed(ramdisk)
fit = make_fit(mkimage, params)
fit = fit_util.make_fit(cons, mkimage, base_its, params)
cons.restart_uboot()
output = cons.run_command_list(cmd.splitlines())
check_equal(kernel, kernel_out, 'Kernel not loaded')

123
test/py/tests/test_vbe.py Normal file
View File

@ -0,0 +1,123 @@
# SPDX-License-Identifier: GPL-2.0+
# Copyright 2022 Google LLC
#
# Test addition of VBE
import pytest
import fit_util
# Define a base ITS which we can adjust using % and a dictionary
base_its = '''
/dts-v1/;
/ {
description = "Example kernel";
images {
kernel-1 {
data = /incbin/("%(kernel)s");
type = "kernel";
arch = "sandbox";
os = "linux";
load = <0x40000>;
entry = <0x8>;
compression = "%(compression)s";
random {
compatible = "vbe,random-rand";
vbe,size = <0x40>;
vbe,required;
};
aslr1 {
compatible = "vbe,aslr-move";
vbe,align = <0x100000>;
};
aslr2 {
compatible = "vbe,aslr-rand";
};
efi-runtime {
compatible = "vbe,efi-runtime-rand";
};
wibble {
compatible = "vbe,wibble";
};
};
fdt-1 {
description = "snow";
data = /incbin/("%(fdt)s");
type = "flat_dt";
arch = "sandbox";
load = <%(fdt_addr)#x>;
compression = "%(compression)s";
};
};
configurations {
default = "conf-1";
conf-1 {
kernel = "kernel-1";
fdt = "fdt-1";
};
};
};
'''
# Define a base FDT - currently we don't use anything in this
base_fdt = '''
/dts-v1/;
/ {
chosen {
};
};
'''
# This is the U-Boot script that is run for each test. First load the FIT,
# then run the 'bootm' command, then run the unit test which checks that the
# working tree has the required things filled in according to the OS requests
# above (random, aslr2, etc.)
base_script = '''
host load hostfs 0 %(fit_addr)x %(fit)s
fdt addr %(fit_addr)x
bootm start %(fit_addr)x
bootm loados
bootm prep
fdt addr
fdt print
ut bootstd vbe_test_fixup
'''
@pytest.mark.boardspec('sandbox_flattree')
@pytest.mark.requiredtool('dtc')
def test_vbe(u_boot_console):
cons = u_boot_console
kernel = fit_util.make_kernel(cons, 'vbe-kernel.bin', 'kernel')
fdt = fit_util.make_dtb(cons, base_fdt, 'vbe-fdt')
fdt_out = fit_util.make_fname(cons, 'fdt-out.dtb')
params = {
'fit_addr' : 0x1000,
'kernel' : kernel,
'fdt' : fdt,
'fdt_out' : fdt_out,
'fdt_addr' : 0x80000,
'fdt_size' : 0x1000,
'compression' : 'none',
}
mkimage = cons.config.build_dir + '/tools/mkimage'
fit = fit_util.make_fit(cons, mkimage, base_its, params, 'test-vbe.fit',
base_fdt)
params['fit'] = fit
cmd = base_script % params
with cons.log.section('Kernel load'):
output = cons.run_command_list(cmd.splitlines())
# This is a little wonky since there are two tests running in CI. The final
# one is the 'ut bootstd' command above
failures = [line for line in output if 'Failures' in line]
assert len(failures) >= 1 and 'Failures: 0' in failures[-1]

11
test/test-main.c
View File

@ -165,16 +165,7 @@ static int dm_test_post_run(struct unit_test_state *uts)
/* Ensure all the test devices are probed */
static int do_autoprobe(struct unit_test_state *uts)
{
struct udevice *dev;
int ret;
/* Scanning the uclass is enough to probe all the devices */
for (ret = uclass_first_device(UCLASS_TEST, &dev);
dev;
ret = uclass_next_device(&dev))
;
return ret;
return uclass_probe_all(UCLASS_TEST);
}
/*