[J-u-boot.git] / test / dm / video.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 2014 Google, Inc
 * Written by Simon Glass <[email protected]>
 */

#include <common.h>
#include <bzlib.h>
#include <dm.h>
#include <mapmem.h>
#include <os.h>
#include <video.h>
#include <video_console.h>
#include <dm/test.h>
#include <dm/uclass-internal.h>
#include <test/ut.h>

/*
 * These tests use the standard sandbox frame buffer, the resolution of which
 * is defined in the device tree. This only supports 16bpp so the tests only
 * test that code path. It would be possible to adjust this fairly easily,
 * by adjusting the bpix value in struct sandbox_sdl_plat. However the code
 * in sandbox_sdl_sync() would also need to change to handle the different
 * surface depth.
 */
/* Basic test of the video uclass */
static int dm_test_video_base(struct unit_test_state *uts)
{
	struct video_priv *priv;
	struct udevice *dev;

	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
	ut_asserteq(1366, video_get_xsize(dev));
	ut_asserteq(768, video_get_ysize(dev));
	priv = dev_get_uclass_priv(dev);
	ut_asserteq(priv->fb_size, 1366 * 768 * 2);

	return 0;
}
DM_TEST(dm_test_video_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

/**
 * compress_frame_buffer() - Compress the frame buffer and return its size
 *
 * We want to write tests which perform operations on the video console and
 * check that the frame buffer ends up with the correct contents. But it is
 * painful to store 'known good' images for comparison with the frame
 * buffer. As an alternative, we can compress the frame buffer and check the
 * size of the compressed data. This provides a pretty good level of
 * certainty and the resulting tests need only check a single value.
 *
 * @dev:	Video device
 * @return compressed size of the frame buffer, or -ve on error
 */
static int compress_frame_buffer(struct udevice *dev)
{
	struct video_priv *priv = dev_get_uclass_priv(dev);
	uint destlen;
	void *dest;
	int ret;

	destlen = priv->fb_size;
	dest = malloc(priv->fb_size);
	if (!dest)
		return -ENOMEM;
	ret = BZ2_bzBuffToBuffCompress(dest, &destlen,
				       priv->fb, priv->fb_size,
				       3, 0, 0);
	free(dest);
	if (ret)
		return ret;

	return destlen;
}

/*
 * Call this function at any point to halt and show the current display. Be
 * sure to run the test with the -l flag.
 */
static void __maybe_unused see_output(void)
{
	video_sync_all();
	while (1);
}

/* Select the video console driver to use for a video device */
static int select_vidconsole(struct unit_test_state *uts, const char *drv_name)
{
	struct sandbox_sdl_plat *plat;
	struct udevice *dev;

	ut_assertok(uclass_find_device(UCLASS_VIDEO, 0, &dev));
	ut_assert(!device_active(dev));
	plat = dev_get_platdata(dev);
	plat->vidconsole_drv_name = "vidconsole0";

	return 0;
}

static void vidconsole_put_string(struct udevice *dev, const char *str)
{
	const char *s;

	for (s = str; *s; s++)
		vidconsole_put_char(dev, *s);
}

/* Test text output works on the video console */
static int dm_test_video_text(struct unit_test_state *uts)
{
	struct udevice *dev, *con;
	int i;

#define WHITE		0xffff
#define SCROLL_LINES	100

	ut_assertok(select_vidconsole(uts, "vidconsole0"));
	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
	ut_asserteq(46, compress_frame_buffer(dev));

	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
	vidconsole_putc_xy(con, 0, 0, 'a');
	ut_asserteq(79, compress_frame_buffer(dev));

	vidconsole_putc_xy(con, 0, 0, ' ');
	ut_asserteq(46, compress_frame_buffer(dev));

	for (i = 0; i < 20; i++)
		vidconsole_putc_xy(con, VID_TO_POS(i * 8), 0, ' ' + i);
	ut_asserteq(273, compress_frame_buffer(dev));

	vidconsole_set_row(con, 0, WHITE);
	ut_asserteq(46, compress_frame_buffer(dev));

	for (i = 0; i < 20; i++)
		vidconsole_putc_xy(con, VID_TO_POS(i * 8), 0, ' ' + i);
	ut_asserteq(273, compress_frame_buffer(dev));

	return 0;
}
DM_TEST(dm_test_video_text, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

/* Test handling of special characters in the console */
static int dm_test_video_chars(struct unit_test_state *uts)
{
	struct udevice *dev, *con;
	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.";

	ut_assertok(select_vidconsole(uts, "vidconsole0"));
	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
	vidconsole_put_string(con, test_string);
	ut_asserteq(466, compress_frame_buffer(dev));

	return 0;
}
DM_TEST(dm_test_video_chars, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

#ifdef CONFIG_VIDEO_ANSI
#define ANSI_ESC "\x1b"
/* Test handling of ANSI escape sequences */
static int dm_test_video_ansi(struct unit_test_state *uts)
{
	struct udevice *dev, *con;

	ut_assertok(select_vidconsole(uts, "vidconsole0"));
	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));

	/* reference clear: */
	video_clear(con->parent);
	video_sync(con->parent);
	ut_asserteq(46, compress_frame_buffer(dev));

	/* test clear escape sequence: [2J */
	vidconsole_put_string(con, "A\tB\tC"ANSI_ESC"[2J");
	ut_asserteq(46, compress_frame_buffer(dev));

	/* test set-cursor: [%d;%df */
	vidconsole_put_string(con, "abc"ANSI_ESC"[2;2fab"ANSI_ESC"[4;4fcd");
	ut_asserteq(142, compress_frame_buffer(dev));

	/* test colors (30-37 fg color, 40-47 bg color) */
	vidconsole_put_string(con, ANSI_ESC"[30;41mfoo"); /* black on red */
	vidconsole_put_string(con, ANSI_ESC"[33;44mbar"); /* yellow on blue */
	ut_asserteq(265, compress_frame_buffer(dev));

	return 0;
}
DM_TEST(dm_test_video_ansi, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
#endif

/**
 * check_vidconsole_output() - Run a text console test
 *
 * @uts:	Test state
 * @rot:	Console rotation (0, 90, 180, 270)
 * @wrap_size:	Expected size of compressed frame buffer for the wrap test
 * @scroll_size: Same for the scroll test
 * @return 0 on success
 */
static int check_vidconsole_output(struct unit_test_state *uts, int rot,
				   int wrap_size, int scroll_size)
{
	struct udevice *dev, *con;
	struct sandbox_sdl_plat *plat;
	int i;

	ut_assertok(uclass_find_device(UCLASS_VIDEO, 0, &dev));
	ut_assert(!device_active(dev));
	plat = dev_get_platdata(dev);
	plat->rot = rot;

	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
	ut_asserteq(46, compress_frame_buffer(dev));

	/* Check display wrap */
	for (i = 0; i < 120; i++)
		vidconsole_put_char(con, 'A' + i % 50);
	ut_asserteq(wrap_size, compress_frame_buffer(dev));

	/* Check display scrolling */
	for (i = 0; i < SCROLL_LINES; i++) {
		vidconsole_put_char(con, 'A' + i % 50);
		vidconsole_put_char(con, '\n');
	}
	ut_asserteq(scroll_size, compress_frame_buffer(dev));

	/* If we scroll enough, the screen becomes blank again */
	for (i = 0; i < SCROLL_LINES; i++)
		vidconsole_put_char(con, '\n');
	ut_asserteq(46, compress_frame_buffer(dev));

	return 0;
}

/* Test text output through the console uclass */
static int dm_test_video_context(struct unit_test_state *uts)
{
	ut_assertok(select_vidconsole(uts, "vidconsole0"));
	ut_assertok(check_vidconsole_output(uts, 0, 788, 453));

	return 0;
}
DM_TEST(dm_test_video_context, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

/* Test rotated text output through the console uclass */
static int dm_test_video_rotation1(struct unit_test_state *uts)
{
	ut_assertok(check_vidconsole_output(uts, 1, 1112, 680));

	return 0;
}
DM_TEST(dm_test_video_rotation1, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

/* Test rotated text output through the console uclass */
static int dm_test_video_rotation2(struct unit_test_state *uts)
{
	ut_assertok(check_vidconsole_output(uts, 2, 785, 446));

	return 0;
}
DM_TEST(dm_test_video_rotation2, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

/* Test rotated text output through the console uclass */
static int dm_test_video_rotation3(struct unit_test_state *uts)
{
	ut_assertok(check_vidconsole_output(uts, 3, 1134, 681));

	return 0;
}
DM_TEST(dm_test_video_rotation3, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

/* Read a file into memory and return a pointer to it */
static int read_file(struct unit_test_state *uts, const char *fname,
		     ulong *addrp)
{
	int buf_size = 100000;
	ulong addr = 0;
	int size, fd;
	char *buf;

	buf = map_sysmem(addr, 0);
	ut_assert(buf != NULL);
	fd = os_open(fname, OS_O_RDONLY);
	ut_assert(fd >= 0);
	size = os_read(fd, buf, buf_size);
	os_close(fd);
	ut_assert(size >= 0);
	ut_assert(size < buf_size);
	*addrp = addr;

	return 0;
}

/* Test drawing a bitmap file */
static int dm_test_video_bmp(struct unit_test_state *uts)
{
	struct udevice *dev;
	ulong addr;

	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
	ut_assertok(read_file(uts, "tools/logos/denx.bmp", &addr));

	ut_assertok(video_bmp_display(dev, addr, 0, 0, false));
	ut_asserteq(1368, compress_frame_buffer(dev));

	return 0;
}
DM_TEST(dm_test_video_bmp, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

/* Test drawing a compressed bitmap file */
static int dm_test_video_bmp_comp(struct unit_test_state *uts)
{
	struct udevice *dev;
	ulong addr;

	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
	ut_assertok(read_file(uts, "tools/logos/denx-comp.bmp", &addr));

	ut_assertok(video_bmp_display(dev, addr, 0, 0, false));
	ut_asserteq(1368, compress_frame_buffer(dev));

	return 0;
}
DM_TEST(dm_test_video_bmp_comp, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

/* Test TrueType console */
static int dm_test_video_truetype(struct unit_test_state *uts)
{
	struct udevice *dev, *con;
	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";

	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
	vidconsole_put_string(con, test_string);
	ut_asserteq(12619, compress_frame_buffer(dev));

	return 0;
}
DM_TEST(dm_test_video_truetype, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

/* Test scrolling TrueType console */
static int dm_test_video_truetype_scroll(struct unit_test_state *uts)
{
	struct sandbox_sdl_plat *plat;
	struct udevice *dev, *con;
	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";

	ut_assertok(uclass_find_device(UCLASS_VIDEO, 0, &dev));
	ut_assert(!device_active(dev));
	plat = dev_get_platdata(dev);
	plat->font_size = 100;

	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
	vidconsole_put_string(con, test_string);
	ut_asserteq(33849, compress_frame_buffer(dev));

	return 0;
}
DM_TEST(dm_test_video_truetype_scroll, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

/* Test TrueType backspace, within and across lines */
static int dm_test_video_truetype_bs(struct unit_test_state *uts)
{
	struct sandbox_sdl_plat *plat;
	struct udevice *dev, *con;
	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.";

	ut_assertok(uclass_find_device(UCLASS_VIDEO, 0, &dev));
	ut_assert(!device_active(dev));
	plat = dev_get_platdata(dev);
	plat->font_size = 100;

	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
	vidconsole_put_string(con, test_string);
	ut_asserteq(34871, compress_frame_buffer(dev));

	return 0;
}
DM_TEST(dm_test_video_truetype_bs, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
3c97c4fb SG	2	/*
	3	* Copyright (c) 2014 Google, Inc
	4	* Written by Simon Glass <[email protected]>
3c97c4fb SG	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	*/
3c97c4fb SG	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
8df8dad5 SG	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
a7495ac8 RC	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
3c97c4fb SG	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
8df8dad5	117	ut_assertok(select_vidconsole(uts, "vidconsole0"));
3c97c4fb SG	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++)
f2661786	129	vidconsole_putc_xy(con, VID_TO_POS(i * 8), 0, ' ' + i);
3c97c4fb SG	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++)
f2661786	136	vidconsole_putc_xy(con, VID_TO_POS(i * 8), 0, ' ' + i);
3c97c4fb SG	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;
5508f10a	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.";
3c97c4fb	148
8df8dad5	149	ut_assertok(select_vidconsole(uts, "vidconsole0"));
3c97c4fb SG	150	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
3c97c4fb SG	151	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
a7495ac8	152	vidconsole_put_string(con, test_string);
3c97c4fb SG	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
40186ee2 RC	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);
	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 */
9ffa4d12	186	ut_asserteq(265, compress_frame_buffer(dev));
40186ee2 RC	187
	188	return 0;
	189	}
	190	DM_TEST(dm_test_video_ansi, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
	191	#endif
	192
3c97c4fb SG	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	{
8df8dad5 SG	241	ut_assertok(select_vidconsole(uts, "vidconsole0"));
	242	ut_assertok(check_vidconsole_output(uts, 0, 788, 453));
	243
	244	return 0;
3c97c4fb SG	245	}
3c97c4fb SG	246	DM_TEST(dm_test_video_context, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
85e08db8 SG	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);
747440d0 SG	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);
a108082d	289	os_close(fd);
747440d0 SG	290	ut_assert(size >= 0);
747440d0 SG	291	ut_assert(size < buf_size);
747440d0 SG	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);
5674ead7 SG	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";
5674ead7 SG	334
	335	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
	336	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
a7495ac8	337	vidconsole_put_string(con, test_string);
5674ead7 SG	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";
5674ead7 SG	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));
a7495ac8	358	vidconsole_put_string(con, test_string);
5674ead7 SG	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.";
5674ead7 SG	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));
a7495ac8	379	vidconsole_put_string(con, test_string);
5674ead7 SG	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);