1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Tests for bdinfo command
4 *
5 * Copyright 2023 Marek Vasut <marek.vasut+renesas@mailbox.org>
6 */
7
8#include <common.h>
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>
19#include <serial.h>
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
26DECLARE_GLOBAL_DATA_PTR;
27
28/* Declare a new bdinfo test */
29#define BDINFO_TEST(_name, _flags)	UNIT_TEST(_name, _flags, bdinfo_test)
30
31static int test_num_l(struct unit_test_state *uts, const char *name,
32		      ulong value)
33{
34	ut_assert_nextline("%-12s= 0x%0*lx", name, 2 * (int)sizeof(value),
35			   value);
36
37	return 0;
38}
39
40static int test_num_ll(struct unit_test_state *uts, const char *name,
41		       unsigned long long value)
42{
43	ut_assert_nextline("%-12s= 0x%.*llx", name, 2 * (int)sizeof(ulong),
44			   value);
45
46	return 0;
47}
48
49static int test_eth(struct unit_test_state *uts)
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"));
69
70	return 0;
71}
72
73static int test_video_info(struct unit_test_state *uts)
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
85			ut_assertok(test_num_ll(uts, "FB base",
86						(ulong)upriv->fb));
87			if (upriv->copy_fb) {
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));
92			}
93			ut_assert_nextline("%-12s= %dx%dx%d", "FB size",
94					   upriv->xsize, upriv->ysize,
95					   1 << upriv->bpix);
96		}
97	}
98
99	return 0;
100}
101
102static int lmb_test_dump_region(struct unit_test_state *uts,
103				struct lmb_region *rgn, char *name)
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
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		}
129		ut_assert_nextline(" %s[%d]\t[0x%llx-0x%llx], 0x%08llx bytes flags: %x",
130				   name, i, base, end, size, flags);
131	}
132
133	return 0;
134}
135
136static int lmb_test_dump_all(struct unit_test_state *uts, struct lmb *lmb)
137{
138	ut_assert_nextline("lmb_dump_all:");
139	ut_assertok(lmb_test_dump_region(uts, &lmb->memory, "memory"));
140	ut_assertok(lmb_test_dump_region(uts, &lmb->reserved, "reserved"));
141
142	return 0;
143}
144
145static int bdinfo_check_mem(struct unit_test_state *uts)
146{
147	struct bd_info *bd = gd->bd;
148	int i;
149
150	for (i = 0; i < CONFIG_NR_DRAM_BANKS; ++i) {
151		if (bd->bi_dram[i].size) {
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));
157		}
158	}
159
160	return 0;
161}
162
163static 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
169	/* CONFIG_SYS_HAS_SRAM testing not supported */
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));
173	ut_assert_nextline("baudrate    = %lu bps",
174			   env_get_ulong("baudrate", 10, 1234));
175	ut_assertok(test_num_l(uts, "relocaddr", gd->relocaddr));
176	ut_assertok(test_num_l(uts, "reloc off", gd->reloc_off));
177	ut_assert_nextline("%-12s= %u-bit", "Build", (uint)sizeof(void *) * 8);
178
179	if (IS_ENABLED(CONFIG_CMD_NET))
180		ut_assertok(test_eth(uts));
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));
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));
192
193	if (IS_ENABLED(CONFIG_VIDEO))
194		ut_assertok(test_video_info(uts));
195
196	/* The gd->multi_dtb_fit may not be available, hence, #if below. */
197#if CONFIG_IS_ENABLED(MULTI_DTB_FIT)
198	ut_assertok(test_num_l(uts, "multi_dtb_fit", (ulong)gd->multi_dtb_fit));
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);
205		ut_assertok(lmb_test_dump_all(uts, &lmb));
206		if (IS_ENABLED(CONFIG_OF_REAL))
207			ut_assert_nextline("devicetree  = %s", fdtdec_get_srcname());
208	}
209
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
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
230	if (IS_ENABLED(CONFIG_X86))
231		ut_check_skip_to_linen(uts, " high end   =");
232
233	return 0;
234}
235
236static 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));
244	ut_assertok(ut_check_console_end(uts));
245
246	return 0;
247}
248
249BDINFO_TEST(bdinfo_test_full, UT_TESTF_CONSOLE_REC);
250
251static 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());
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	}
266	ut_assertok(ut_check_console_end(uts));
267
268	return 0;
269}
270
271BDINFO_TEST(bdinfo_test_help, UT_TESTF_CONSOLE_REC);
272
273static 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"));
278	if (!CONFIG_IS_ENABLED(GETOPT))
279		ut_assertok(bdinfo_test_all(uts));
280	else
281		ut_assertok(bdinfo_check_mem(uts));
282	ut_assertok(ut_check_console_end(uts));
283
284	return 0;
285}
286
287BDINFO_TEST(bdinfo_test_memory, UT_TESTF_CONSOLE_REC);
288
289static 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"));
294	if (!CONFIG_IS_ENABLED(GETOPT))
295		ut_assertok(bdinfo_test_all(uts));
296	else if (IS_ENABLED(CONFIG_CMD_NET))
297		ut_assertok(test_eth(uts));
298	ut_assertok(ut_check_console_end(uts));
299
300	return 0;
301}
302
303BDINFO_TEST(bdinfo_test_eth, UT_TESTF_CONSOLE_REC);
304
305int 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}
312