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