blob: 9d22df8c4dc2763194144e06db6738f6f515144f [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glass2e7d35d2014-02-26 15:59:21 -07002/*
3 * Copyright (c) 2013 Google, Inc
Simon Glass2e7d35d2014-02-26 15:59:21 -07004 */
5
6#include <common.h>
Joe Hershberger40441e02015-05-20 14:27:29 -05007#include <command.h>
Simon Glass24b852a2015-11-08 23:47:45 -07008#include <console.h>
Simon Glass2e7d35d2014-02-26 15:59:21 -07009#include <dm.h>
10#include <errno.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060011#include <log.h>
Simon Glass756ac0b2014-10-04 11:29:50 -060012#include <malloc.h>
Simon Glass3884c982015-11-08 23:47:44 -070013#include <asm/state.h>
Simon Glass2e7d35d2014-02-26 15:59:21 -070014#include <dm/test.h>
15#include <dm/root.h>
16#include <dm/uclass-internal.h>
Simon Glass0e1fad42020-07-19 10:15:37 -060017#include <test/test.h>
18#include <test/test.h>
Joe Hershbergere721b882015-05-20 14:27:27 -050019#include <test/ut.h>
Simon Glass2e7d35d2014-02-26 15:59:21 -070020
21DECLARE_GLOBAL_DATA_PTR;
22
Joe Hershbergere721b882015-05-20 14:27:27 -050023struct unit_test_state global_dm_test_state;
24static struct dm_test_state _global_priv_dm_test_state;
Simon Glass2e7d35d2014-02-26 15:59:21 -070025
26/* Get ready for testing */
Simon Glassc166c472017-05-18 20:09:16 -060027static int dm_test_init(struct unit_test_state *uts, bool of_live)
Simon Glass2e7d35d2014-02-26 15:59:21 -070028{
Joe Hershbergere721b882015-05-20 14:27:27 -050029 struct dm_test_state *dms = uts->priv;
30
Simon Glass2e7d35d2014-02-26 15:59:21 -070031 memset(dms, '\0', sizeof(*dms));
32 gd->dm_root = NULL;
Simon Glass5b448ce2020-10-25 20:38:27 -060033 if (!CONFIG_IS_ENABLED(OF_PLATDATA))
34 memset(dm_testdrv_op_count, '\0', sizeof(dm_testdrv_op_count));
Simon Glass34b744b2017-05-18 20:09:13 -060035 state_reset_for_test(state_get_current());
Simon Glass2e7d35d2014-02-26 15:59:21 -070036
Simon Glassc166c472017-05-18 20:09:16 -060037 /* Determine whether to make the live tree available */
Simon Glassa652d9c2020-10-03 09:25:22 -060038 gd_set_of_root(of_live ? uts->of_root : NULL);
Simon Glassc166c472017-05-18 20:09:16 -060039 ut_assertok(dm_init(of_live));
Simon Glass2e7d35d2014-02-26 15:59:21 -070040 dms->root = dm_root();
41
42 return 0;
43}
44
45/* Ensure all the test devices are probed */
Joe Hershbergere721b882015-05-20 14:27:27 -050046static int do_autoprobe(struct unit_test_state *uts)
Simon Glass2e7d35d2014-02-26 15:59:21 -070047{
Heiko Schocher54c5d082014-05-22 12:43:05 +020048 struct udevice *dev;
Simon Glass2e7d35d2014-02-26 15:59:21 -070049 int ret;
50
51 /* Scanning the uclass is enough to probe all the devices */
52 for (ret = uclass_first_device(UCLASS_TEST, &dev);
53 dev;
54 ret = uclass_next_device(&dev))
55 ;
56
57 return ret;
58}
59
Joe Hershbergere721b882015-05-20 14:27:27 -050060static int dm_test_destroy(struct unit_test_state *uts)
Simon Glass2e7d35d2014-02-26 15:59:21 -070061{
62 int id;
63
64 for (id = 0; id < UCLASS_COUNT; id++) {
65 struct uclass *uc;
66
67 /*
68 * If the uclass doesn't exist we don't want to create it. So
Simon Glass22327002019-09-25 08:55:57 -060069 * check that here before we call uclass_find_device().
Simon Glass2e7d35d2014-02-26 15:59:21 -070070 */
71 uc = uclass_find(id);
72 if (!uc)
73 continue;
74 ut_assertok(uclass_destroy(uc));
75 }
76
77 return 0;
78}
79
Simon Glassc166c472017-05-18 20:09:16 -060080static int dm_do_test(struct unit_test_state *uts, struct unit_test *test,
81 bool of_live)
Simon Glassf86db102017-05-18 20:09:14 -060082{
83 struct sandbox_state *state = state_get_current();
Simon Glass801587b2017-05-18 20:09:15 -060084 const char *fname = strrchr(test->file, '/') + 1;
Simon Glassf86db102017-05-18 20:09:14 -060085
Simon Glassc166c472017-05-18 20:09:16 -060086 printf("Test: %s: %s%s\n", test->name, fname,
87 !of_live ? " (flat tree)" : "");
88 ut_assertok(dm_test_init(uts, of_live));
Simon Glassf86db102017-05-18 20:09:14 -060089
90 uts->start = mallinfo();
Simon Glasse180c2b2020-07-28 19:41:12 -060091 if (test->flags & UT_TESTF_SCAN_PDATA)
Simon Glassf86db102017-05-18 20:09:14 -060092 ut_assertok(dm_scan_platdata(false));
Simon Glasse180c2b2020-07-28 19:41:12 -060093 if (test->flags & UT_TESTF_PROBE_TEST)
Simon Glassf86db102017-05-18 20:09:14 -060094 ut_assertok(do_autoprobe(uts));
Simon Glass5b448ce2020-10-25 20:38:27 -060095 if (!CONFIG_IS_ENABLED(OF_PLATDATA) &&
96 (test->flags & UT_TESTF_SCAN_FDT))
Patrice Chotardee87a092017-09-04 14:55:57 +020097 ut_assertok(dm_extended_scan_fdt(gd->fdt_blob, false));
Simon Glassf86db102017-05-18 20:09:14 -060098
99 /*
Michal Simek96ffe872018-08-20 08:03:22 +0200100 * Silence the console and rely on console recording to get
Simon Glassf86db102017-05-18 20:09:14 -0600101 * our output.
102 */
Simon Glasscfccff82020-01-27 08:49:55 -0700103 console_record_reset_enable();
Simon Glassf86db102017-05-18 20:09:14 -0600104 if (!state->show_test_output)
105 gd->flags |= GD_FLG_SILENT;
106 test->func(uts);
Simon Glasscfccff82020-01-27 08:49:55 -0700107 gd->flags &= ~(GD_FLG_SILENT | GD_FLG_RECORD);
Simon Glassf86db102017-05-18 20:09:14 -0600108 state_set_skip_delays(false);
109
110 ut_assertok(dm_test_destroy(uts));
111
112 return 0;
113}
114
Simon Glass6fb2f572017-05-18 20:09:17 -0600115/**
116 * dm_test_run_on_flattree() - Check if we should run a test with flat DT
117 *
118 * This skips long/slow tests where there is not much value in running a flat
119 * DT test in addition to a live DT test.
120 *
121 * @return true to run the given test on the flat device tree
122 */
123static bool dm_test_run_on_flattree(struct unit_test *test)
124{
125 const char *fname = strrchr(test->file, '/') + 1;
126
127 return !strstr(fname, "video") || strstr(test->name, "video_base");
128}
129
Simon Glassb25ff5c2020-10-25 20:38:28 -0600130int dm_test_main(const char *test_name)
Simon Glass2e7d35d2014-02-26 15:59:21 -0700131{
Joe Hershbergere721b882015-05-20 14:27:27 -0500132 struct unit_test *tests = ll_entry_start(struct unit_test, dm_test);
133 const int n_ents = ll_entry_count(struct unit_test, dm_test);
134 struct unit_test_state *uts = &global_dm_test_state;
Joe Hershbergere721b882015-05-20 14:27:27 -0500135 struct unit_test *test;
Simon Glassad950472019-09-25 08:55:52 -0600136 int found;
Simon Glass2e7d35d2014-02-26 15:59:21 -0700137
Simon Glassc166c472017-05-18 20:09:16 -0600138 uts->priv = &_global_priv_dm_test_state;
Stephen Warren26e1bec2016-01-27 23:57:46 -0700139 uts->fail_count = 0;
140
Simon Glass5b448ce2020-10-25 20:38:27 -0600141 if (!CONFIG_IS_ENABLED(OF_PLATDATA)) {
142 /*
143 * If we have no device tree, or it only has a root node, then
144 * these * tests clearly aren't going to work...
145 */
146 if (!gd->fdt_blob || fdt_next_node(gd->fdt_blob, 0, NULL) < 0) {
147 puts("Please run with test device tree:\n"
148 " ./u-boot -d arch/sandbox/dts/test.dtb\n");
149 ut_assert(gd->fdt_blob);
150 }
Simon Glass2e7d35d2014-02-26 15:59:21 -0700151 }
152
Simon Glass57f54d52015-03-25 12:23:04 -0600153 if (!test_name)
154 printf("Running %d driver model tests\n", n_ents);
Simon Glass2e7d35d2014-02-26 15:59:21 -0700155
Simon Glassad950472019-09-25 08:55:52 -0600156 found = 0;
Simon Glassa652d9c2020-10-03 09:25:22 -0600157 uts->of_root = gd_of_root();
Simon Glass2e7d35d2014-02-26 15:59:21 -0700158 for (test = tests; test < tests + n_ents; test++) {
Simon Glassc02790c2015-07-06 12:54:23 -0600159 const char *name = test->name;
Simon Glass6fb2f572017-05-18 20:09:17 -0600160 int runs;
Simon Glassc02790c2015-07-06 12:54:23 -0600161
162 /* All tests have this prefix */
163 if (!strncmp(name, "dm_test_", 8))
164 name += 8;
165 if (test_name && strcmp(test_name, name))
Simon Glass57f54d52015-03-25 12:23:04 -0600166 continue;
Simon Glass6fb2f572017-05-18 20:09:17 -0600167
168 /* Run with the live tree if possible */
169 runs = 0;
Simon Glassa652d9c2020-10-03 09:25:22 -0600170 if (CONFIG_IS_ENABLED(OF_LIVE)) {
Simon Glasse180c2b2020-07-28 19:41:12 -0600171 if (!(test->flags & UT_TESTF_FLAT_TREE)) {
Simon Glass6fb2f572017-05-18 20:09:17 -0600172 ut_assertok(dm_do_test(uts, test, true));
173 runs++;
174 }
175 }
176
177 /*
178 * Run with the flat tree if we couldn't run it with live tree,
179 * or it is a core test.
180 */
Simon Glasse180c2b2020-07-28 19:41:12 -0600181 if (!(test->flags & UT_TESTF_LIVE_TREE) &&
Simon Glass6fb2f572017-05-18 20:09:17 -0600182 (!runs || dm_test_run_on_flattree(test))) {
183 ut_assertok(dm_do_test(uts, test, false));
184 runs++;
185 }
Simon Glassad950472019-09-25 08:55:52 -0600186 found++;
Simon Glass2e7d35d2014-02-26 15:59:21 -0700187 }
188
Simon Glassad950472019-09-25 08:55:52 -0600189 if (test_name && !found)
Simon Glassc02790c2015-07-06 12:54:23 -0600190 printf("Test '%s' not found\n", test_name);
191 else
192 printf("Failures: %d\n", uts->fail_count);
Simon Glass2e7d35d2014-02-26 15:59:21 -0700193
Simon Glassfe9a9672019-09-25 08:55:51 -0600194 /* Put everything back to normal so that sandbox works as expected */
Simon Glassa652d9c2020-10-03 09:25:22 -0600195 gd_set_of_root(uts->of_root);
Joe Hershbergerb6227d32015-05-20 14:27:35 -0500196 gd->dm_root = NULL;
Simon Glassa652d9c2020-10-03 09:25:22 -0600197 ut_assertok(dm_init(CONFIG_IS_ENABLED(OF_LIVE)));
Joe Hershbergerb6227d32015-05-20 14:27:35 -0500198 dm_scan_platdata(false);
Simon Glass5b448ce2020-10-25 20:38:27 -0600199 if (!CONFIG_IS_ENABLED(OF_PLATDATA))
200 dm_scan_fdt(gd->fdt_blob, false);
Joe Hershbergerb6227d32015-05-20 14:27:35 -0500201
Joe Hershberger7cccc662015-05-20 14:27:32 -0500202 return uts->fail_count ? CMD_RET_FAILURE : 0;
Simon Glass2e7d35d2014-02-26 15:59:21 -0700203}
Joe Hershberger40441e02015-05-20 14:27:29 -0500204
Simon Glass09140112020-05-10 11:40:03 -0600205int do_ut_dm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
Joe Hershberger40441e02015-05-20 14:27:29 -0500206{
207 const char *test_name = NULL;
208
209 if (argc > 1)
210 test_name = argv[1];
211
212 return dm_test_main(test_name);
213}