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