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

/*
 * Copyright (c) 2014 Google, Inc
 * Written by Simon Glass <sjg@chromium.org>
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#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.
 */
DECLARE_GLOBAL_DATA_PTR;

/* 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);
}

/* 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(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, 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, 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 modest  \bman\n\t\tand Has much to\b\bto be modest about.";
	const char *s;

	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
	for (s = test_string; *s; s++)
		vidconsole_put_char(con, *s);
	ut_asserteq(466, compress_frame_buffer(dev));

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

/**
 * 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)
{
	return check_vidconsole_output(uts, 0, 788, 453);
}
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);
Commit	Line	Data
3c97c4fb SG	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	/* Test text output works on the video console */
90	static int dm_test_video_text(struct unit_test_state *uts)
91	{
92	struct udevice dev, con;
93	int i;
94
95	#define WHITE 0xffff
96	#define SCROLL_LINES 100
97
98	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
99	ut_asserteq(46, compress_frame_buffer(dev));
100
101	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
102	vidconsole_putc_xy(con, 0, 0, 'a');
103	ut_asserteq(79, compress_frame_buffer(dev));
104
105	vidconsole_putc_xy(con, 0, 0, ' ');
106	ut_asserteq(46, compress_frame_buffer(dev));
107
108	for (i = 0; i < 20; i++)
109	vidconsole_putc_xy(con, i * 8, 0, ' ' + i);
110	ut_asserteq(273, compress_frame_buffer(dev));
111
112	vidconsole_set_row(con, 0, WHITE);
113	ut_asserteq(46, compress_frame_buffer(dev));
114
115	for (i = 0; i < 20; i++)
116	vidconsole_putc_xy(con, i * 8, 0, ' ' + i);
117	ut_asserteq(273, compress_frame_buffer(dev));
118
119	return 0;
120	}
121	DM_TEST(dm_test_video_text, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
122
123	/* Test handling of special characters in the console */
124	static int dm_test_video_chars(struct unit_test_state *uts)
125	{
126	struct udevice dev, con;
127	const char *test_string = "Well\b\b\b\bxhe is\r \n\ta very modest \bman\n\t\tand Has much to\b\bto be modest about.";
128	const char *s;
129
130	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
131	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
132	for (s = test_string; *s; s++)
133	vidconsole_put_char(con, *s);
134	ut_asserteq(466, compress_frame_buffer(dev));
135
136	return 0;
137	}
138	DM_TEST(dm_test_video_chars, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
139
140	/**
141	* check_vidconsole_output() - Run a text console test
142	*
143	* @uts: Test state
144	* @rot: Console rotation (0, 90, 180, 270)
145	* @wrap_size: Expected size of compressed frame buffer for the wrap test
146	* @scroll_size: Same for the scroll test
147	* @return 0 on success
148	*/
149	static int check_vidconsole_output(struct unit_test_state *uts, int rot,
150	int wrap_size, int scroll_size)
151	{
152	struct udevice dev, con;
153	struct sandbox_sdl_plat *plat;
154	int i;
155
156	ut_assertok(uclass_find_device(UCLASS_VIDEO, 0, &dev));
157	ut_assert(!device_active(dev));
158	plat = dev_get_platdata(dev);
159	plat->rot = rot;
160
161	ut_assertok(uclass_get_device(UCLASS_VIDEO, 0, &dev));
162	ut_assertok(uclass_get_device(UCLASS_VIDEO_CONSOLE, 0, &con));
163	ut_asserteq(46, compress_frame_buffer(dev));
164
165	/* Check display wrap */
166	for (i = 0; i < 120; i++)
167	vidconsole_put_char(con, 'A' + i % 50);
168	ut_asserteq(wrap_size, compress_frame_buffer(dev));
169
170	/* Check display scrolling */
171	for (i = 0; i < SCROLL_LINES; i++) {
172	vidconsole_put_char(con, 'A' + i % 50);
173	vidconsole_put_char(con, '\n');
174	}
175	ut_asserteq(scroll_size, compress_frame_buffer(dev));
176
177	/* If we scroll enough, the screen becomes blank again */
178	for (i = 0; i < SCROLL_LINES; i++)
179	vidconsole_put_char(con, '\n');
180	ut_asserteq(46, compress_frame_buffer(dev));
181
182	return 0;
183	}
184
185	/* Test text output through the console uclass */
186	static int dm_test_video_context(struct unit_test_state *uts)
187	{
188	return check_vidconsole_output(uts, 0, 788, 453);
189	}
190	DM_TEST(dm_test_video_context, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
85e08db8 SG	191
	192	/* Test rotated text output through the console uclass */
	193	static int dm_test_video_rotation1(struct unit_test_state *uts)
	194	{
	195	ut_assertok(check_vidconsole_output(uts, 1, 1112, 680));
	196
	197	return 0;
	198	}
	199	DM_TEST(dm_test_video_rotation1, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
	200
	201	/* Test rotated text output through the console uclass */
	202	static int dm_test_video_rotation2(struct unit_test_state *uts)
	203	{
	204	ut_assertok(check_vidconsole_output(uts, 2, 785, 446));
	205
	206	return 0;
	207	}
	208	DM_TEST(dm_test_video_rotation2, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
	209
	210	/* Test rotated text output through the console uclass */
	211	static int dm_test_video_rotation3(struct unit_test_state *uts)
	212	{
	213	ut_assertok(check_vidconsole_output(uts, 3, 1134, 681));
	214
	215	return 0;
	216	}
	217	DM_TEST(dm_test_video_rotation3, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);