xref: /openbmc/u-boot/test/dm/video.c (revision 626f048b)
1 /*
2  * Copyright (c) 2014 Google, Inc
3  * Written by Simon Glass <sjg@chromium.org>
4  *
5  * SPDX-License-Identifier:	GPL-2.0+
6  */
7 
8 #include <common.h>
9 #include <bzlib.h>
10 #include <dm.h>
11 #include <mapmem.h>
12 #include <os.h>
13 #include <video.h>
14 #include <video_console.h>
15 #include <dm/test.h>
16 #include <dm/uclass-internal.h>
17 #include <test/ut.h>
18 
19 /*
20  * These tests use the standard sandbox frame buffer, the resolution of which
21  * is defined in the device tree. This only supports 16bpp so the tests only
22  * test that code path. It would be possible to adjust this fairly easily,
23  * by adjusting the bpix value in struct sandbox_sdl_plat. However the code
24  * in sandbox_sdl_sync() would also need to change to handle the different
25  * surface depth.
26  */
27 DECLARE_GLOBAL_DATA_PTR;
28 
29 /* Basic test of the video uclass */
30 static int dm_test_video_base(struct unit_test_state *uts)
31 {
32 	struct video_priv *priv;
33 	struct udevice *dev;
34 
35 	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
36 	ut_asserteq(1366, video_get_xsize(dev));
37 	ut_asserteq(768, video_get_ysize(dev));
38 	priv = dev_get_uclass_priv(dev);
39 	ut_asserteq(priv->fb_size, 1366 * 768 * 2);
40 
41 	return 0;
42 }
43 DM_TEST(dm_test_video_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
44 
45 /**
46  * compress_frame_buffer() - Compress the frame buffer and return its size
47  *
48  * We want to write tests which perform operations on the video console and
49  * check that the frame buffer ends up with the correct contents. But it is
50  * painful to store 'known good' images for comparison with the frame
51  * buffer. As an alternative, we can compress the frame buffer and check the
52  * size of the compressed data. This provides a pretty good level of
53  * certainty and the resulting tests need only check a single value.
54  *
55  * @dev:	Video device
56  * @return compressed size of the frame buffer, or -ve on error
57  */
58 static int compress_frame_buffer(struct udevice *dev)
59 {
60 	struct video_priv *priv = dev_get_uclass_priv(dev);
61 	uint destlen;
62 	void *dest;
63 	int ret;
64 
65 	destlen = priv->fb_size;
66 	dest = malloc(priv->fb_size);
67 	if (!dest)
68 		return -ENOMEM;
69 	ret = BZ2_bzBuffToBuffCompress(dest, &destlen,
70 				       priv->fb, priv->fb_size,
71 				       3, 0, 0);
72 	free(dest);
73 	if (ret)
74 		return ret;
75 
76 	return destlen;
77 }
78 
79 /*
80  * Call this function at any point to halt and show the current display. Be
81  * sure to run the test with the -l flag.
82  */
83 static void __maybe_unused see_output(void)
84 {
85 	video_sync_all();
86 	while (1);
87 }
88 
89 /* Select the video console driver to use for a video device */
90 static int select_vidconsole(struct unit_test_state *uts, const char *drv_name)
91 {
92 	struct sandbox_sdl_plat *plat;
93 	struct udevice *dev;
94 
95 	ut_assertok(uclass_find_device(UCLASS_VIDEO, 0, &dev));
96 	ut_assert(!device_active(dev));
97 	plat = dev_get_platdata(dev);
98 	plat->vidconsole_drv_name = "vidconsole0";
99 
100 	return 0;
101 }
102 
103 /* Test text output works on the video console */
104 static int dm_test_video_text(struct unit_test_state *uts)
105 {
106 	struct udevice *dev, *con;
107 	int i;
108 
109 #define WHITE		0xffff
110 #define SCROLL_LINES	100
111 
112 	ut_assertok(select_vidconsole(uts, "vidconsole0"));
113 	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
114 	ut_asserteq(46, compress_frame_buffer(dev));
115 
116 	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
117 	vidconsole_putc_xy(con, 0, 0, 'a');
118 	ut_asserteq(79, compress_frame_buffer(dev));
119 
120 	vidconsole_putc_xy(con, 0, 0, ' ');
121 	ut_asserteq(46, compress_frame_buffer(dev));
122 
123 	for (i = 0; i < 20; i++)
124 		vidconsole_putc_xy(con, VID_TO_POS(i * 8), 0, ' ' + i);
125 	ut_asserteq(273, compress_frame_buffer(dev));
126 
127 	vidconsole_set_row(con, 0, WHITE);
128 	ut_asserteq(46, compress_frame_buffer(dev));
129 
130 	for (i = 0; i < 20; i++)
131 		vidconsole_putc_xy(con, VID_TO_POS(i * 8), 0, ' ' + i);
132 	ut_asserteq(273, compress_frame_buffer(dev));
133 
134 	return 0;
135 }
136 DM_TEST(dm_test_video_text, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
137 
138 /* Test handling of special characters in the console */
139 static int dm_test_video_chars(struct unit_test_state *uts)
140 {
141 	struct udevice *dev, *con;
142 	const char *test_string = "Well\b\b\b\bxhe is\r \n\ta very \amodest  \bman\n\t\tand Has much to\b\bto be modest about.";
143 	const char *s;
144 
145 	ut_assertok(select_vidconsole(uts, "vidconsole0"));
146 	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
147 	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
148 	for (s = test_string; *s; s++)
149 		vidconsole_put_char(con, *s);
150 	ut_asserteq(466, compress_frame_buffer(dev));
151 
152 	return 0;
153 }
154 DM_TEST(dm_test_video_chars, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
155 
156 /**
157  * check_vidconsole_output() - Run a text console test
158  *
159  * @uts:	Test state
160  * @rot:	Console rotation (0, 90, 180, 270)
161  * @wrap_size:	Expected size of compressed frame buffer for the wrap test
162  * @scroll_size: Same for the scroll test
163  * @return 0 on success
164  */
165 static int check_vidconsole_output(struct unit_test_state *uts, int rot,
166 				   int wrap_size, int scroll_size)
167 {
168 	struct udevice *dev, *con;
169 	struct sandbox_sdl_plat *plat;
170 	int i;
171 
172 	ut_assertok(uclass_find_device(UCLASS_VIDEO, 0, &dev));
173 	ut_assert(!device_active(dev));
174 	plat = dev_get_platdata(dev);
175 	plat->rot = rot;
176 
177 	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
178 	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
179 	ut_asserteq(46, compress_frame_buffer(dev));
180 
181 	/* Check display wrap */
182 	for (i = 0; i < 120; i++)
183 		vidconsole_put_char(con, 'A' + i % 50);
184 	ut_asserteq(wrap_size, compress_frame_buffer(dev));
185 
186 	/* Check display scrolling */
187 	for (i = 0; i < SCROLL_LINES; i++) {
188 		vidconsole_put_char(con, 'A' + i % 50);
189 		vidconsole_put_char(con, '\n');
190 	}
191 	ut_asserteq(scroll_size, compress_frame_buffer(dev));
192 
193 	/* If we scroll enough, the screen becomes blank again */
194 	for (i = 0; i < SCROLL_LINES; i++)
195 		vidconsole_put_char(con, '\n');
196 	ut_asserteq(46, compress_frame_buffer(dev));
197 
198 	return 0;
199 }
200 
201 /* Test text output through the console uclass */
202 static int dm_test_video_context(struct unit_test_state *uts)
203 {
204 	ut_assertok(select_vidconsole(uts, "vidconsole0"));
205 	ut_assertok(check_vidconsole_output(uts, 0, 788, 453));
206 
207 	return 0;
208 }
209 DM_TEST(dm_test_video_context, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
210 
211 /* Test rotated text output through the console uclass */
212 static int dm_test_video_rotation1(struct unit_test_state *uts)
213 {
214 	ut_assertok(check_vidconsole_output(uts, 1, 1112, 680));
215 
216 	return 0;
217 }
218 DM_TEST(dm_test_video_rotation1, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
219 
220 /* Test rotated text output through the console uclass */
221 static int dm_test_video_rotation2(struct unit_test_state *uts)
222 {
223 	ut_assertok(check_vidconsole_output(uts, 2, 785, 446));
224 
225 	return 0;
226 }
227 DM_TEST(dm_test_video_rotation2, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
228 
229 /* Test rotated text output through the console uclass */
230 static int dm_test_video_rotation3(struct unit_test_state *uts)
231 {
232 	ut_assertok(check_vidconsole_output(uts, 3, 1134, 681));
233 
234 	return 0;
235 }
236 DM_TEST(dm_test_video_rotation3, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
237 
238 /* Read a file into memory and return a pointer to it */
239 static int read_file(struct unit_test_state *uts, const char *fname,
240 		     ulong *addrp)
241 {
242 	int buf_size = 100000;
243 	ulong addr = 0;
244 	int size, fd;
245 	char *buf;
246 
247 	buf = map_sysmem(addr, 0);
248 	ut_assert(buf != NULL);
249 	fd = os_open(fname, OS_O_RDONLY);
250 	ut_assert(fd >= 0);
251 	size = os_read(fd, buf, buf_size);
252 	os_close(fd);
253 	ut_assert(size >= 0);
254 	ut_assert(size < buf_size);
255 	*addrp = addr;
256 
257 	return 0;
258 }
259 
260 /* Test drawing a bitmap file */
261 static int dm_test_video_bmp(struct unit_test_state *uts)
262 {
263 	struct udevice *dev;
264 	ulong addr;
265 
266 	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
267 	ut_assertok(read_file(uts, "tools/logos/denx.bmp", &addr));
268 
269 	ut_assertok(video_bmp_display(dev, addr, 0, 0, false));
270 	ut_asserteq(1368, compress_frame_buffer(dev));
271 
272 	return 0;
273 }
274 DM_TEST(dm_test_video_bmp, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
275 
276 /* Test drawing a compressed bitmap file */
277 static int dm_test_video_bmp_comp(struct unit_test_state *uts)
278 {
279 	struct udevice *dev;
280 	ulong addr;
281 
282 	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
283 	ut_assertok(read_file(uts, "tools/logos/denx-comp.bmp", &addr));
284 
285 	ut_assertok(video_bmp_display(dev, addr, 0, 0, false));
286 	ut_asserteq(1368, compress_frame_buffer(dev));
287 
288 	return 0;
289 }
290 DM_TEST(dm_test_video_bmp_comp, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
291 
292 /* Test TrueType console */
293 static int dm_test_video_truetype(struct unit_test_state *uts)
294 {
295 	struct udevice *dev, *con;
296 	const char *test_string = "Criticism may not be agreeable, but it is necessary. It fulfils the same function as pain in the human body. It calls attention to an unhealthy state of things. Some see private enterprise as a predatory target to be shot, others as a cow to be milked, but few are those who see it as a sturdy horse pulling the wagon. The \aprice OF\b\bof greatness\n\tis responsibility.\n\nBye";
297 	const char *s;
298 
299 	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
300 	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
301 	for (s = test_string; *s; s++)
302 		vidconsole_put_char(con, *s);
303 	ut_asserteq(12619, compress_frame_buffer(dev));
304 
305 	return 0;
306 }
307 DM_TEST(dm_test_video_truetype, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
308 
309 /* Test scrolling TrueType console */
310 static int dm_test_video_truetype_scroll(struct unit_test_state *uts)
311 {
312 	struct sandbox_sdl_plat *plat;
313 	struct udevice *dev, *con;
314 	const char *test_string = "Criticism may not be agreeable, but it is necessary. It fulfils the same function as pain in the human body. It calls attention to an unhealthy state of things. Some see private enterprise as a predatory target to be shot, others as a cow to be milked, but few are those who see it as a sturdy horse pulling the wagon. The \aprice OF\b\bof greatness\n\tis responsibility.\n\nBye";
315 	const char *s;
316 
317 	ut_assertok(uclass_find_device(UCLASS_VIDEO, 0, &dev));
318 	ut_assert(!device_active(dev));
319 	plat = dev_get_platdata(dev);
320 	plat->font_size = 100;
321 
322 	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
323 	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
324 	for (s = test_string; *s; s++)
325 		vidconsole_put_char(con, *s);
326 	ut_asserteq(33849, compress_frame_buffer(dev));
327 
328 	return 0;
329 }
330 DM_TEST(dm_test_video_truetype_scroll, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
331 
332 /* Test TrueType backspace, within and across lines */
333 static int dm_test_video_truetype_bs(struct unit_test_state *uts)
334 {
335 	struct sandbox_sdl_plat *plat;
336 	struct udevice *dev, *con;
337 	const char *test_string = "...Criticism may or may\b\b\b\b\b\bnot be agreeable, but seldom it is necessary\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\bit is necessary. It fulfils the same function as pain in the human body. It calls attention to an unhealthy state of things.";
338 	const char *s;
339 
340 	ut_assertok(uclass_find_device(UCLASS_VIDEO, 0, &dev));
341 	ut_assert(!device_active(dev));
342 	plat = dev_get_platdata(dev);
343 	plat->font_size = 100;
344 
345 	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
346 	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
347 	for (s = test_string; *s; s++)
348 		vidconsole_put_char(con, *s);
349 	ut_asserteq(34871, compress_frame_buffer(dev));
350 
351 	return 0;
352 }
353 DM_TEST(dm_test_video_truetype_bs, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
354