[u-boot.git] / test / cmd / bdinfo.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Tests for bdinfo command
 *
 * Copyright 2023 Marek Vasut <[email protected]>
 */

#include <common.h>
#include <console.h>
#include <mapmem.h>
#include <asm/global_data.h>
#include <dm/uclass.h>
#include <test/suites.h>
#include <test/ut.h>
#include <dm.h>
#include <env.h>
#include <lmb.h>
#include <net.h>
#include <serial.h>
#include <video.h>
#include <vsprintf.h>
#include <asm/cache.h>
#include <asm/global_data.h>
#include <display_options.h>

DECLARE_GLOBAL_DATA_PTR;

/* Declare a new bdinfo test */
#define BDINFO_TEST(_name, _flags)	UNIT_TEST(_name, _flags, bdinfo_test)

static int test_num_l(struct unit_test_state *uts, const char *name,
		      ulong value)
{
	ut_assert_nextline("%-12s= 0x%0*lx", name, 2 * (int)sizeof(value),
			   value);

	return 0;
}

static int test_num_ll(struct unit_test_state *uts, const char *name,
		       unsigned long long value)
{
	ut_assert_nextline("%-12s= 0x%.*llx", name, 2 * (int)sizeof(ulong),
			   value);

	return 0;
}

static int test_eth(struct unit_test_state *uts)
{
	const int idx = eth_get_dev_index();
	uchar enetaddr[6];
	char name[10];
	int ret;

	if (idx)
		sprintf(name, "eth%iaddr", idx);
	else
		strcpy(name, "ethaddr");

	ret = eth_env_get_enetaddr_by_index("eth", idx, enetaddr);

	ut_assert_nextline("current eth = %s", eth_get_name());
	if (!ret)
		ut_assert_nextline("%-12s= (not set)", name);
	else
		ut_assert_nextline("%-12s= %pM", name, enetaddr);
	ut_assert_nextline("IP addr     = %s", env_get("ipaddr"));

	return 0;
}

static int test_video_info(struct unit_test_state *uts)
{
	const struct udevice *dev;
	struct uclass *uc;

	uclass_id_foreach_dev(UCLASS_VIDEO, dev, uc) {
		ut_assert_nextline("%-12s= %s %sactive", "Video", dev->name,
				   device_active(dev) ? "" : "in");
		if (device_active(dev)) {
			struct video_priv *upriv = dev_get_uclass_priv(dev);
			struct video_uc_plat *plat = dev_get_uclass_plat(dev);

			ut_assertok(test_num_ll(uts, "FB base",
						(ulong)upriv->fb));
			if (upriv->copy_fb) {
				ut_assertok(test_num_ll(uts, "FB copy",
							(ulong)upriv->copy_fb));
				ut_assertok(test_num_l(uts, " copy size",
						       plat->copy_size));
			}
			ut_assert_nextline("%-12s= %dx%dx%d", "FB size",
					   upriv->xsize, upriv->ysize,
					   1 << upriv->bpix);
		}
	}

	return 0;
}

static int lmb_test_dump_region(struct unit_test_state *uts,
				struct lmb_region *rgn, char *name)
{
	unsigned long long base, size, end;
	enum lmb_flags flags;
	int i;

	ut_assert_nextline(" %s.cnt = 0x%lx / max = 0x%lx", name, rgn->cnt, rgn->max);

	for (i = 0; i < rgn->cnt; i++) {
		base = rgn->region[i].base;
		size = rgn->region[i].size;
		end = base + size - 1;
		flags = rgn->region[i].flags;

		/*
		 * this entry includes the stack (get_sp()) on many platforms
		 * so will different each time lmb_init_and_reserve() is called.
		 * We could instead have the bdinfo command put its lmb region
		 * in a known location, so we can check it directly, rather than
		 * calling lmb_init_and_reserve() to create a new (and hopefully
		 * identical one). But for now this seems good enough.
		 */
		if (!IS_ENABLED(CONFIG_SANDBOX) && i == 3) {
			ut_assert_nextlinen(" %s[%d]\t[", name, i);
			continue;
		}
		ut_assert_nextline(" %s[%d]\t[0x%llx-0x%llx], 0x%08llx bytes flags: %x",
				   name, i, base, end, size, flags);
	}

	return 0;
}

static int lmb_test_dump_all(struct unit_test_state *uts, struct lmb *lmb)
{
	ut_assert_nextline("lmb_dump_all:");
	ut_assertok(lmb_test_dump_region(uts, &lmb->memory, "memory"));
	ut_assertok(lmb_test_dump_region(uts, &lmb->reserved, "reserved"));

	return 0;
}

static int bdinfo_check_mem(struct unit_test_state *uts)
{
	struct bd_info *bd = gd->bd;
	int i;

	for (i = 0; i < CONFIG_NR_DRAM_BANKS; ++i) {
		if (bd->bi_dram[i].size) {
			ut_assertok(test_num_l(uts, "DRAM bank", i));
			ut_assertok(test_num_ll(uts, "-> start",
						bd->bi_dram[i].start));
			ut_assertok(test_num_ll(uts, "-> size",
						bd->bi_dram[i].size));
		}
	}

	return 0;
}

static int bdinfo_test_all(struct unit_test_state *uts)
{
	ut_assertok(test_num_l(uts, "boot_params", 0));

	ut_assertok(bdinfo_check_mem(uts));

	/* CONFIG_SYS_HAS_SRAM testing not supported */
	ut_assertok(test_num_l(uts, "flashstart", 0));
	ut_assertok(test_num_l(uts, "flashsize", 0));
	ut_assertok(test_num_l(uts, "flashoffset", 0));
	ut_assert_nextline("baudrate    = %lu bps",
			   env_get_ulong("baudrate", 10, 1234));
	ut_assertok(test_num_l(uts, "relocaddr", gd->relocaddr));
	ut_assertok(test_num_l(uts, "reloc off", gd->reloc_off));
	ut_assert_nextline("%-12s= %u-bit", "Build", (uint)sizeof(void *) * 8);

	if (IS_ENABLED(CONFIG_CMD_NET))
		ut_assertok(test_eth(uts));

	/*
	 * Make sure environment variable "fdtcontroladdr" address
	 * matches mapped control DT address.
	 */
	ut_assert(map_to_sysmem(gd->fdt_blob) == env_get_hex("fdtcontroladdr", 0x1234));
	ut_assertok(test_num_l(uts, "fdt_blob",
			       (ulong)map_to_sysmem(gd->fdt_blob)));
	ut_assertok(test_num_l(uts, "new_fdt",
			       (ulong)map_to_sysmem(gd->new_fdt)));
	ut_assertok(test_num_l(uts, "fdt_size", (ulong)gd->fdt_size));

	if (IS_ENABLED(CONFIG_VIDEO))
		ut_assertok(test_video_info(uts));

	/* The gd->multi_dtb_fit may not be available, hence, #if below. */
#if CONFIG_IS_ENABLED(MULTI_DTB_FIT)
	ut_assertok(test_num_l(uts, "multi_dtb_fit", (ulong)gd->multi_dtb_fit));
#endif

	if (IS_ENABLED(CONFIG_LMB) && gd->fdt_blob) {
		struct lmb lmb;

		lmb_init_and_reserve(&lmb, gd->bd, (void *)gd->fdt_blob);
		ut_assertok(lmb_test_dump_all(uts, &lmb));
		if (IS_ENABLED(CONFIG_OF_REAL))
			ut_assert_nextline("devicetree  = %s", fdtdec_get_srcname());
	}

	if (IS_ENABLED(CONFIG_DM_SERIAL)) {
		struct serial_device_info info;

		ut_assertnonnull(gd->cur_serial_dev);
		ut_assertok(serial_getinfo(gd->cur_serial_dev, &info));

		ut_assertok(test_num_l(uts, "serial addr", info.addr));
		ut_assertok(test_num_l(uts, " width", info.reg_width));
		ut_assertok(test_num_l(uts, " shift", info.reg_shift));
		ut_assertok(test_num_l(uts, " offset", info.reg_offset));
		ut_assertok(test_num_l(uts, " clock", info.clock));
	}

	if (IS_ENABLED(CONFIG_CMD_BDINFO_EXTRA)) {
		ut_assert_nextlinen("stack ptr");
		ut_assertok(test_num_ll(uts, "ram_top ptr",
					(unsigned long long)gd->ram_top));
		ut_assertok(test_num_l(uts, "malloc base", gd_malloc_start()));
	}

	if (IS_ENABLED(CONFIG_X86))
		ut_check_skip_to_linen(uts, " high end   =");

	return 0;
}

static int bdinfo_test_full(struct unit_test_state *uts)
{
	/* Test BDINFO full print */
	ut_assertok(console_record_reset_enable());
	ut_assertok(run_commandf("bdinfo"));
	ut_assertok(bdinfo_test_all(uts));
	ut_assertok(run_commandf("bdinfo -a"));
	ut_assertok(bdinfo_test_all(uts));
	ut_assertok(ut_check_console_end(uts));

	return 0;
}

BDINFO_TEST(bdinfo_test_full, UT_TESTF_CONSOLE_REC);

static int bdinfo_test_help(struct unit_test_state *uts)
{
	/* Test BDINFO unknown option help text print */
	ut_assertok(console_record_reset_enable());
	if (!CONFIG_IS_ENABLED(GETOPT)) {
		ut_asserteq(0, run_commandf("bdinfo -h"));
		ut_assertok(bdinfo_test_all(uts));
	} else {
		ut_asserteq(1, run_commandf("bdinfo -h"));
		ut_assert_nextlinen("bdinfo: invalid option -- h");
		ut_assert_nextlinen("bdinfo - print Board Info structure");
		ut_assert_nextline_empty();
		ut_assert_nextlinen("Usage:");
		ut_assert_nextlinen("bdinfo");
	}
	ut_assertok(ut_check_console_end(uts));

	return 0;
}

BDINFO_TEST(bdinfo_test_help, UT_TESTF_CONSOLE_REC);

static int bdinfo_test_memory(struct unit_test_state *uts)
{
	/* Test BDINFO memory layout only print */
	ut_assertok(console_record_reset_enable());
	ut_assertok(run_commandf("bdinfo -m"));
	if (!CONFIG_IS_ENABLED(GETOPT))
		ut_assertok(bdinfo_test_all(uts));
	else
		ut_assertok(bdinfo_check_mem(uts));
	ut_assertok(ut_check_console_end(uts));

	return 0;
}

BDINFO_TEST(bdinfo_test_memory, UT_TESTF_CONSOLE_REC);

static int bdinfo_test_eth(struct unit_test_state *uts)
{
	/* Test BDINFO ethernet settings only print */
	ut_assertok(console_record_reset_enable());
	ut_assertok(run_commandf("bdinfo -e"));
	if (!CONFIG_IS_ENABLED(GETOPT))
		ut_assertok(bdinfo_test_all(uts));
	else if (IS_ENABLED(CONFIG_CMD_NET))
		ut_assertok(test_eth(uts));
	ut_assertok(ut_check_console_end(uts));

	return 0;
}

BDINFO_TEST(bdinfo_test_eth, UT_TESTF_CONSOLE_REC);

int do_ut_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
	struct unit_test *tests = UNIT_TEST_SUITE_START(bdinfo_test);
	const int n_ents = UNIT_TEST_SUITE_COUNT(bdinfo_test);

	return cmd_ut_category("bdinfo", "bdinfo_test_", tests, n_ents, argc, argv);
}
Commit	Line	Data
bf52766d MV	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Tests for bdinfo command
	4	*
	5	* Copyright 2023 Marek Vasut <[email protected]>
	6	*/
	7
d678a59d	8	#include <common.h>
bf52766d MV	9	#include <console.h>
	10	#include <mapmem.h>
	11	#include <asm/global_data.h>
	12	#include <dm/uclass.h>
	13	#include <test/suites.h>
	14	#include <test/ut.h>
	15	#include <dm.h>
	16	#include <env.h>
	17	#include <lmb.h>
	18	#include <net.h>
347a845a	19	#include <serial.h>
bf52766d MV	20	#include <video.h>
	21	#include <vsprintf.h>
	22	#include <asm/cache.h>
	23	#include <asm/global_data.h>
	24	#include <display_options.h>
	25
	26	DECLARE_GLOBAL_DATA_PTR;
	27
	28	/* Declare a new bdinfo test */
	29	#define BDINFO_TEST(_name, _flags) UNIT_TEST(_name, _flags, bdinfo_test)
	30
2c522af7 SG	31	static int test_num_l(struct unit_test_state uts, const char name,
2c522af7 SG	32	ulong value)
bf52766d	33	{
2c522af7 SG	34	ut_assert_nextline("%-12s= 0x%0lx", name, 2 (int)sizeof(value),
	35	value);
	36
	37	return 0;
bf52766d MV	38	}
bf52766d MV	39
2c522af7 SG	40	static int test_num_ll(struct unit_test_state uts, const char name,
2c522af7 SG	41	unsigned long long value)
bf52766d	42	{
2c522af7 SG	43	ut_assert_nextline("%-12s= 0x%.llx", name, 2 (int)sizeof(ulong),
	44	value);
	45
	46	return 0;
bf52766d MV	47	}
bf52766d MV	48
2c522af7	49	static int test_eth(struct unit_test_state *uts)
bf52766d MV	50	{
	51	const int idx = eth_get_dev_index();
	52	uchar enetaddr[6];
	53	char name[10];
	54	int ret;
	55
	56	if (idx)
	57	sprintf(name, "eth%iaddr", idx);
	58	else
	59	strcpy(name, "ethaddr");
	60
	61	ret = eth_env_get_enetaddr_by_index("eth", idx, enetaddr);
	62
	63	ut_assert_nextline("current eth = %s", eth_get_name());
	64	if (!ret)
	65	ut_assert_nextline("%-12s= (not set)", name);
	66	else
	67	ut_assert_nextline("%-12s= %pM", name, enetaddr);
	68	ut_assert_nextline("IP addr = %s", env_get("ipaddr"));
2c522af7 SG	69
2c522af7 SG	70	return 0;
bf52766d MV	71	}
bf52766d MV	72
2c522af7	73	static int test_video_info(struct unit_test_state *uts)
bf52766d MV	74	{
	75	const struct udevice *dev;
	76	struct uclass *uc;
	77
	78	uclass_id_foreach_dev(UCLASS_VIDEO, dev, uc) {
	79	ut_assert_nextline("%-12s= %s %sactive", "Video", dev->name,
	80	device_active(dev) ? "" : "in");
	81	if (device_active(dev)) {
	82	struct video_priv *upriv = dev_get_uclass_priv(dev);
	83	struct video_uc_plat *plat = dev_get_uclass_plat(dev);
	84
2c522af7 SG	85	ut_assertok(test_num_ll(uts, "FB base",
2c522af7 SG	86	(ulong)upriv->fb));
bf52766d	87	if (upriv->copy_fb) {
2c522af7 SG	88	ut_assertok(test_num_ll(uts, "FB copy",
	89	(ulong)upriv->copy_fb));
	90	ut_assertok(test_num_l(uts, " copy size",
	91	plat->copy_size));
bf52766d MV	92	}
	93	ut_assert_nextline("%-12s= %dx%dx%d", "FB size",
	94	upriv->xsize, upriv->ysize,
	95	1 << upriv->bpix);
	96	}
	97	}
2c522af7 SG	98
2c522af7 SG	99	return 0;
bf52766d MV	100	}
bf52766d MV	101
2c522af7 SG	102	static int lmb_test_dump_region(struct unit_test_state *uts,
2c522af7 SG	103	struct lmb_region rgn, char name)
bf52766d MV	104	{
	105	unsigned long long base, size, end;
	106	enum lmb_flags flags;
	107	int i;
	108
	109	ut_assert_nextline(" %s.cnt = 0x%lx / max = 0x%lx", name, rgn->cnt, rgn->max);
	110
	111	for (i = 0; i < rgn->cnt; i++) {
	112	base = rgn->region[i].base;
	113	size = rgn->region[i].size;
	114	end = base + size - 1;
	115	flags = rgn->region[i].flags;
	116
80a8a2eb SG	117	/*
	118	* this entry includes the stack (get_sp()) on many platforms
	119	* so will different each time lmb_init_and_reserve() is called.
	120	* We could instead have the bdinfo command put its lmb region
	121	* in a known location, so we can check it directly, rather than
	122	* calling lmb_init_and_reserve() to create a new (and hopefully
	123	* identical one). But for now this seems good enough.
	124	*/
	125	if (!IS_ENABLED(CONFIG_SANDBOX) && i == 3) {
	126	ut_assert_nextlinen(" %s[%d]\t[", name, i);
	127	continue;
	128	}
bf52766d MV	129	ut_assert_nextline(" %s[%d]\t[0x%llx-0x%llx], 0x%08llx bytes flags: %x",
	130	name, i, base, end, size, flags);
	131	}
2c522af7 SG	132
2c522af7 SG	133	return 0;
bf52766d MV	134	}
bf52766d MV	135
2c522af7	136	static int lmb_test_dump_all(struct unit_test_state uts, struct lmb lmb)
bf52766d MV	137	{
bf52766d MV	138	ut_assert_nextline("lmb_dump_all:");
3535f607 SG	139	ut_assertok(lmb_test_dump_region(uts, &lmb->memory, "memory"));
3535f607 SG	140	ut_assertok(lmb_test_dump_region(uts, &lmb->reserved, "reserved"));
2c522af7 SG	141
2c522af7 SG	142	return 0;
bf52766d MV	143	}
bf52766d MV	144
2696f3ab	145	static int bdinfo_check_mem(struct unit_test_state *uts)
bf52766d MV	146	{
	147	struct bd_info *bd = gd->bd;
	148	int i;
	149
bf52766d MV	150	for (i = 0; i < CONFIG_NR_DRAM_BANKS; ++i) {
bf52766d MV	151	if (bd->bi_dram[i].size) {
2c522af7 SG	152	ut_assertok(test_num_l(uts, "DRAM bank", i));
	153	ut_assertok(test_num_ll(uts, "-> start",
	154	bd->bi_dram[i].start));
	155	ut_assertok(test_num_ll(uts, "-> size",
	156	bd->bi_dram[i].size));
bf52766d MV	157	}
	158	}
	159
2696f3ab MV	160	return 0;
	161	}
	162
	163	static int bdinfo_test_all(struct unit_test_state *uts)
	164	{
	165	ut_assertok(test_num_l(uts, "boot_params", 0));
	166
	167	ut_assertok(bdinfo_check_mem(uts));
	168
bf52766d	169	/* CONFIG_SYS_HAS_SRAM testing not supported */
2c522af7 SG	170	ut_assertok(test_num_l(uts, "flashstart", 0));
	171	ut_assertok(test_num_l(uts, "flashsize", 0));
	172	ut_assertok(test_num_l(uts, "flashoffset", 0));
bf52766d MV	173	ut_assert_nextline("baudrate = %lu bps",
bf52766d MV	174	env_get_ulong("baudrate", 10, 1234));
2c522af7 SG	175	ut_assertok(test_num_l(uts, "relocaddr", gd->relocaddr));
2c522af7 SG	176	ut_assertok(test_num_l(uts, "reloc off", gd->reloc_off));
bf52766d MV	177	ut_assert_nextline("%-12s= %u-bit", "Build", (uint)sizeof(void ) 8);
	178
	179	if (IS_ENABLED(CONFIG_CMD_NET))
2c522af7	180	ut_assertok(test_eth(uts));
bf52766d MV	181
	182	/*
	183	* Make sure environment variable "fdtcontroladdr" address
	184	* matches mapped control DT address.
	185	*/
	186	ut_assert(map_to_sysmem(gd->fdt_blob) == env_get_hex("fdtcontroladdr", 0x1234));
2c522af7 SG	187	ut_assertok(test_num_l(uts, "fdt_blob",
	188	(ulong)map_to_sysmem(gd->fdt_blob)));
	189	ut_assertok(test_num_l(uts, "new_fdt",
	190	(ulong)map_to_sysmem(gd->new_fdt)));
	191	ut_assertok(test_num_l(uts, "fdt_size", (ulong)gd->fdt_size));
bf52766d MV	192
bf52766d MV	193	if (IS_ENABLED(CONFIG_VIDEO))
3535f607	194	ut_assertok(test_video_info(uts));
bf52766d MV	195
	196	/* The gd->multi_dtb_fit may not be available, hence, #if below. */
	197	#if CONFIG_IS_ENABLED(MULTI_DTB_FIT)
2c522af7	198	ut_assertok(test_num_l(uts, "multi_dtb_fit", (ulong)gd->multi_dtb_fit));
bf52766d MV	199	#endif
	200
	201	if (IS_ENABLED(CONFIG_LMB) && gd->fdt_blob) {
	202	struct lmb lmb;
	203
	204	lmb_init_and_reserve(&lmb, gd->bd, (void *)gd->fdt_blob);
3535f607	205	ut_assertok(lmb_test_dump_all(uts, &lmb));
bf52766d MV	206	if (IS_ENABLED(CONFIG_OF_REAL))
	207	ut_assert_nextline("devicetree = %s", fdtdec_get_srcname());
	208	}
	209
347a845a SG	210	if (IS_ENABLED(CONFIG_DM_SERIAL)) {
	211	struct serial_device_info info;
	212
	213	ut_assertnonnull(gd->cur_serial_dev);
	214	ut_assertok(serial_getinfo(gd->cur_serial_dev, &info));
	215
	216	ut_assertok(test_num_l(uts, "serial addr", info.addr));
	217	ut_assertok(test_num_l(uts, " width", info.reg_width));
	218	ut_assertok(test_num_l(uts, " shift", info.reg_shift));
	219	ut_assertok(test_num_l(uts, " offset", info.reg_offset));
	220	ut_assertok(test_num_l(uts, " clock", info.clock));
	221	}
	222
b279f517 SG	223	if (IS_ENABLED(CONFIG_CMD_BDINFO_EXTRA)) {
	224	ut_assert_nextlinen("stack ptr");
	225	ut_assertok(test_num_ll(uts, "ram_top ptr",
	226	(unsigned long long)gd->ram_top));
	227	ut_assertok(test_num_l(uts, "malloc base", gd_malloc_start()));
	228	}
	229
3535f607 SG	230	if (IS_ENABLED(CONFIG_X86))
	231	ut_check_skip_to_linen(uts, " high end =");
	232
4823b05f MV	233	return 0;
	234	}
	235
	236	static int bdinfo_test_full(struct unit_test_state *uts)
	237	{
	238	/* Test BDINFO full print */
	239	ut_assertok(console_record_reset_enable());
	240	ut_assertok(run_commandf("bdinfo"));
	241	ut_assertok(bdinfo_test_all(uts));
	242	ut_assertok(run_commandf("bdinfo -a"));
	243	ut_assertok(bdinfo_test_all(uts));
bf52766d MV	244	ut_assertok(ut_check_console_end(uts));
	245
	246	return 0;
	247	}
	248
5bd32a96	249	BDINFO_TEST(bdinfo_test_full, UT_TESTF_CONSOLE_REC);
bf52766d	250
8827a387 MV	251	static int bdinfo_test_help(struct unit_test_state *uts)
	252	{
	253	/* Test BDINFO unknown option help text print */
	254	ut_assertok(console_record_reset_enable());
be4a5f7c MV	255	if (!CONFIG_IS_ENABLED(GETOPT)) {
	256	ut_asserteq(0, run_commandf("bdinfo -h"));
	257	ut_assertok(bdinfo_test_all(uts));
	258	} else {
	259	ut_asserteq(1, run_commandf("bdinfo -h"));
	260	ut_assert_nextlinen("bdinfo: invalid option -- h");
	261	ut_assert_nextlinen("bdinfo - print Board Info structure");
	262	ut_assert_nextline_empty();
	263	ut_assert_nextlinen("Usage:");
	264	ut_assert_nextlinen("bdinfo");
	265	}
8827a387 MV	266	ut_assertok(ut_check_console_end(uts));
	267
	268	return 0;
	269	}
	270
	271	BDINFO_TEST(bdinfo_test_help, UT_TESTF_CONSOLE_REC);
	272
2696f3ab MV	273	static int bdinfo_test_memory(struct unit_test_state *uts)
	274	{
	275	/* Test BDINFO memory layout only print */
	276	ut_assertok(console_record_reset_enable());
	277	ut_assertok(run_commandf("bdinfo -m"));
be4a5f7c MV	278	if (!CONFIG_IS_ENABLED(GETOPT))
	279	ut_assertok(bdinfo_test_all(uts));
	280	else
	281	ut_assertok(bdinfo_check_mem(uts));
2696f3ab MV	282	ut_assertok(ut_check_console_end(uts));
	283
	284	return 0;
	285	}
	286
	287	BDINFO_TEST(bdinfo_test_memory, UT_TESTF_CONSOLE_REC);
	288
3ff2d796 MV	289	static int bdinfo_test_eth(struct unit_test_state *uts)
	290	{
	291	/* Test BDINFO ethernet settings only print */
	292	ut_assertok(console_record_reset_enable());
	293	ut_assertok(run_commandf("bdinfo -e"));
be4a5f7c MV	294	if (!CONFIG_IS_ENABLED(GETOPT))
	295	ut_assertok(bdinfo_test_all(uts));
	296	else if (IS_ENABLED(CONFIG_CMD_NET))
3ff2d796 MV	297	ut_assertok(test_eth(uts));
	298	ut_assertok(ut_check_console_end(uts));
	299
	300	return 0;
	301	}
	302
	303	BDINFO_TEST(bdinfo_test_eth, UT_TESTF_CONSOLE_REC);
	304
bf52766d MV	305	int do_ut_bdinfo(struct cmd_tbl cmdtp, int flag, int argc, char const argv[])
	306	{
	307	struct unit_test *tests = UNIT_TEST_SUITE_START(bdinfo_test);
	308	const int n_ents = UNIT_TEST_SUITE_COUNT(bdinfo_test);
	309
	310	return cmd_ut_category("bdinfo", "bdinfo_test_", tests, n_ents, argc, argv);
	311	}