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 */ 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 */ 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 */ 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 */ 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 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 */ 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 */ 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 */ 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(142, 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(265, 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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(12619, 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 */ 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(33849, 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 */ 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(34871, 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
